*/
+ return true
+ }
+
+ if (state.switchU && state.eat(0x2D /* - */)) {
+ state.lastIntValue = 0x2D; /* - */
+ return true
+ }
+
+ if (!state.switchU && state.eat(0x63 /* c */)) {
+ if (this.regexp_eatClassControlLetter(state)) {
+ return true
+ }
+ state.pos = start;
+ }
+
+ return (
+ this.regexp_eatCharacterClassEscape(state) ||
+ this.regexp_eatCharacterEscape(state)
+ )
+ };
+
+ // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassControlLetter
+ pp$8.regexp_eatClassControlLetter = function(state) {
+ var ch = state.current();
+ if (isDecimalDigit(ch) || ch === 0x5F /* _ */) {
+ state.lastIntValue = ch % 0x20;
+ state.advance();
+ return true
+ }
+ return false
+ };
+
+ // https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence
+ pp$8.regexp_eatHexEscapeSequence = function(state) {
+ var start = state.pos;
+ if (state.eat(0x78 /* x */)) {
+ if (this.regexp_eatFixedHexDigits(state, 2)) {
+ return true
+ }
+ if (state.switchU) {
+ state.raise("Invalid escape");
+ }
+ state.pos = start;
+ }
+ return false
+ };
+
+ // https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalDigits
+ pp$8.regexp_eatDecimalDigits = function(state) {
+ var start = state.pos;
+ var ch = 0;
+ state.lastIntValue = 0;
+ while (isDecimalDigit(ch = state.current())) {
+ state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 /* 0 */);
+ state.advance();
+ }
+ return state.pos !== start
+ };
+ function isDecimalDigit(ch) {
+ return ch >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */
+ }
+
+ // https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigits
+ pp$8.regexp_eatHexDigits = function(state) {
+ var start = state.pos;
+ var ch = 0;
+ state.lastIntValue = 0;
+ while (isHexDigit(ch = state.current())) {
+ state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch);
+ state.advance();
+ }
+ return state.pos !== start
+ };
+ function isHexDigit(ch) {
+ return (
+ (ch >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */) ||
+ (ch >= 0x41 /* A */ && ch <= 0x46 /* F */) ||
+ (ch >= 0x61 /* a */ && ch <= 0x66 /* f */)
+ )
+ }
+ function hexToInt(ch) {
+ if (ch >= 0x41 /* A */ && ch <= 0x46 /* F */) {
+ return 10 + (ch - 0x41 /* A */)
+ }
+ if (ch >= 0x61 /* a */ && ch <= 0x66 /* f */) {
+ return 10 + (ch - 0x61 /* a */)
+ }
+ return ch - 0x30 /* 0 */
+ }
+
+ // https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-LegacyOctalEscapeSequence
+ // Allows only 0-377(octal) i.e. 0-255(decimal).
+ pp$8.regexp_eatLegacyOctalEscapeSequence = function(state) {
+ if (this.regexp_eatOctalDigit(state)) {
+ var n1 = state.lastIntValue;
+ if (this.regexp_eatOctalDigit(state)) {
+ var n2 = state.lastIntValue;
+ if (n1 <= 3 && this.regexp_eatOctalDigit(state)) {
+ state.lastIntValue = n1 * 64 + n2 * 8 + state.lastIntValue;
+ } else {
+ state.lastIntValue = n1 * 8 + n2;
+ }
+ } else {
+ state.lastIntValue = n1;
+ }
+ return true
+ }
+ return false
+ };
+
+ // https://www.ecma-international.org/ecma-262/8.0/#prod-OctalDigit
+ pp$8.regexp_eatOctalDigit = function(state) {
+ var ch = state.current();
+ if (isOctalDigit(ch)) {
+ state.lastIntValue = ch - 0x30; /* 0 */
+ state.advance();
+ return true
+ }
+ state.lastIntValue = 0;
+ return false
+ };
+ function isOctalDigit(ch) {
+ return ch >= 0x30 /* 0 */ && ch <= 0x37 /* 7 */
+ }
+
+ // https://www.ecma-international.org/ecma-262/8.0/#prod-Hex4Digits
+ // https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigit
+ // And HexDigit HexDigit in https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence
+ pp$8.regexp_eatFixedHexDigits = function(state, length) {
+ var start = state.pos;
+ state.lastIntValue = 0;
+ for (var i = 0; i < length; ++i) {
+ var ch = state.current();
+ if (!isHexDigit(ch)) {
+ state.pos = start;
+ return false
+ }
+ state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch);
+ state.advance();
+ }
+ return true
+ };
+
+ // Object type used to represent tokens. Note that normally, tokens
+ // simply exist as properties on the parser object. This is only
+ // used for the onToken callback and the external tokenizer.
+
+ var Token = function Token(p) {
+ this.type = p.type;
+ this.value = p.value;
+ this.start = p.start;
+ this.end = p.end;
+ if (p.options.locations)
+ { this.loc = new SourceLocation(p, p.startLoc, p.endLoc); }
+ if (p.options.ranges)
+ { this.range = [p.start, p.end]; }
+ };
+
+ // ## Tokenizer
+
+ var pp$9 = Parser.prototype;
+
+ // Move to the next token
+
+ pp$9.next = function(ignoreEscapeSequenceInKeyword) {
+ if (!ignoreEscapeSequenceInKeyword && this.type.keyword && this.containsEsc)
+ { this.raiseRecoverable(this.start, "Escape sequence in keyword " + this.type.keyword); }
+ if (this.options.onToken)
+ { this.options.onToken(new Token(this)); }
+
+ this.lastTokEnd = this.end;
+ this.lastTokStart = this.start;
+ this.lastTokEndLoc = this.endLoc;
+ this.lastTokStartLoc = this.startLoc;
+ this.nextToken();
+ };
+
+ pp$9.getToken = function() {
+ this.next();
+ return new Token(this)
+ };
+
+ // If we're in an ES6 environment, make parsers iterable
+ if (typeof Symbol !== "undefined")
+ { pp$9[Symbol.iterator] = function() {
+ var this$1 = this;
+
+ return {
+ next: function () {
+ var token = this$1.getToken();
+ return {
+ done: token.type === types.eof,
+ value: token
+ }
+ }
+ }
+ }; }
+
+ // Toggle strict mode. Re-reads the next number or string to please
+ // pedantic tests (`"use strict"; 010;` should fail).
+
+ pp$9.curContext = function() {
+ return this.context[this.context.length - 1]
+ };
+
+ // Read a single token, updating the parser object's token-related
+ // properties.
+
+ pp$9.nextToken = function() {
+ var curContext = this.curContext();
+ if (!curContext || !curContext.preserveSpace) { this.skipSpace(); }
+
+ this.start = this.pos;
+ if (this.options.locations) { this.startLoc = this.curPosition(); }
+ if (this.pos >= this.input.length) { return this.finishToken(types.eof) }
+
+ if (curContext.override) { return curContext.override(this) }
+ else { this.readToken(this.fullCharCodeAtPos()); }
+ };
+
+ pp$9.readToken = function(code) {
+ // Identifier or keyword. '\uXXXX' sequences are allowed in
+ // identifiers, so '\' also dispatches to that.
+ if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\' */)
+ { return this.readWord() }
+
+ return this.getTokenFromCode(code)
+ };
+
+ pp$9.fullCharCodeAtPos = function() {
+ var code = this.input.charCodeAt(this.pos);
+ if (code <= 0xd7ff || code >= 0xe000) { return code }
+ var next = this.input.charCodeAt(this.pos + 1);
+ return (code << 10) + next - 0x35fdc00
+ };
+
+ pp$9.skipBlockComment = function() {
+ var startLoc = this.options.onComment && this.curPosition();
+ var start = this.pos, end = this.input.indexOf("*/", this.pos += 2);
+ if (end === -1) { this.raise(this.pos - 2, "Unterminated comment"); }
+ this.pos = end + 2;
+ if (this.options.locations) {
+ lineBreakG.lastIndex = start;
+ var match;
+ while ((match = lineBreakG.exec(this.input)) && match.index < this.pos) {
+ ++this.curLine;
+ this.lineStart = match.index + match[0].length;
+ }
+ }
+ if (this.options.onComment)
+ { this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos,
+ startLoc, this.curPosition()); }
+ };
+
+ pp$9.skipLineComment = function(startSkip) {
+ var start = this.pos;
+ var startLoc = this.options.onComment && this.curPosition();
+ var ch = this.input.charCodeAt(this.pos += startSkip);
+ while (this.pos < this.input.length && !isNewLine(ch)) {
+ ch = this.input.charCodeAt(++this.pos);
+ }
+ if (this.options.onComment)
+ { this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos,
+ startLoc, this.curPosition()); }
+ };
+
+ // Called at the start of the parse and after every token. Skips
+ // whitespace and comments, and.
+
+ pp$9.skipSpace = function() {
+ loop: while (this.pos < this.input.length) {
+ var ch = this.input.charCodeAt(this.pos);
+ switch (ch) {
+ case 32: case 160: // ' '
+ ++this.pos;
+ break
+ case 13:
+ if (this.input.charCodeAt(this.pos + 1) === 10) {
+ ++this.pos;
+ }
+ case 10: case 8232: case 8233:
+ ++this.pos;
+ if (this.options.locations) {
+ ++this.curLine;
+ this.lineStart = this.pos;
+ }
+ break
+ case 47: // '/'
+ switch (this.input.charCodeAt(this.pos + 1)) {
+ case 42: // '*'
+ this.skipBlockComment();
+ break
+ case 47:
+ this.skipLineComment(2);
+ break
+ default:
+ break loop
+ }
+ break
+ default:
+ if (ch > 8 && ch < 14 || ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+ ++this.pos;
+ } else {
+ break loop
+ }
+ }
+ }
+ };
+
+ // Called at the end of every token. Sets `end`, `val`, and
+ // maintains `context` and `exprAllowed`, and skips the space after
+ // the token, so that the next one's `start` will point at the
+ // right position.
+
+ pp$9.finishToken = function(type, val) {
+ this.end = this.pos;
+ if (this.options.locations) { this.endLoc = this.curPosition(); }
+ var prevType = this.type;
+ this.type = type;
+ this.value = val;
+
+ this.updateContext(prevType);
+ };
+
+ // ### Token reading
+
+ // This is the function that is called to fetch the next token. It
+ // is somewhat obscure, because it works in character codes rather
+ // than characters, and because operator parsing has been inlined
+ // into it.
+ //
+ // All in the name of speed.
+ //
+ pp$9.readToken_dot = function() {
+ var next = this.input.charCodeAt(this.pos + 1);
+ if (next >= 48 && next <= 57) { return this.readNumber(true) }
+ var next2 = this.input.charCodeAt(this.pos + 2);
+ if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'
+ this.pos += 3;
+ return this.finishToken(types.ellipsis)
+ } else {
+ ++this.pos;
+ return this.finishToken(types.dot)
+ }
+ };
+
+ pp$9.readToken_slash = function() { // '/'
+ var next = this.input.charCodeAt(this.pos + 1);
+ if (this.exprAllowed) { ++this.pos; return this.readRegexp() }
+ if (next === 61) { return this.finishOp(types.assign, 2) }
+ return this.finishOp(types.slash, 1)
+ };
+
+ pp$9.readToken_mult_modulo_exp = function(code) { // '%*'
+ var next = this.input.charCodeAt(this.pos + 1);
+ var size = 1;
+ var tokentype = code === 42 ? types.star : types.modulo;
+
+ // exponentiation operator ** and **=
+ if (this.options.ecmaVersion >= 7 && code === 42 && next === 42) {
+ ++size;
+ tokentype = types.starstar;
+ next = this.input.charCodeAt(this.pos + 2);
+ }
+
+ if (next === 61) { return this.finishOp(types.assign, size + 1) }
+ return this.finishOp(tokentype, size)
+ };
+
+ pp$9.readToken_pipe_amp = function(code) { // '|&'
+ var next = this.input.charCodeAt(this.pos + 1);
+ if (next === code) {
+ if (this.options.ecmaVersion >= 12) {
+ var next2 = this.input.charCodeAt(this.pos + 2);
+ if (next2 === 61) { return this.finishOp(types.assign, 3) }
+ }
+ return this.finishOp(code === 124 ? types.logicalOR : types.logicalAND, 2)
+ }
+ if (next === 61) { return this.finishOp(types.assign, 2) }
+ return this.finishOp(code === 124 ? types.bitwiseOR : types.bitwiseAND, 1)
+ };
+
+ pp$9.readToken_caret = function() { // '^'
+ var next = this.input.charCodeAt(this.pos + 1);
+ if (next === 61) { return this.finishOp(types.assign, 2) }
+ return this.finishOp(types.bitwiseXOR, 1)
+ };
+
+ pp$9.readToken_plus_min = function(code) { // '+-'
+ var next = this.input.charCodeAt(this.pos + 1);
+ if (next === code) {
+ if (next === 45 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 62 &&
+ (this.lastTokEnd === 0 || lineBreak.test(this.input.slice(this.lastTokEnd, this.pos)))) {
+ // A `-->` line comment
+ this.skipLineComment(3);
+ this.skipSpace();
+ return this.nextToken()
+ }
+ return this.finishOp(types.incDec, 2)
+ }
+ if (next === 61) { return this.finishOp(types.assign, 2) }
+ return this.finishOp(types.plusMin, 1)
+ };
+
+ pp$9.readToken_lt_gt = function(code) { // '<>'
+ var next = this.input.charCodeAt(this.pos + 1);
+ var size = 1;
+ if (next === code) {
+ size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;
+ if (this.input.charCodeAt(this.pos + size) === 61) { return this.finishOp(types.assign, size + 1) }
+ return this.finishOp(types.bitShift, size)
+ }
+ if (next === 33 && code === 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 45 &&
+ this.input.charCodeAt(this.pos + 3) === 45) {
+ // `` line comment\n this.skipLineComment(3)\n this.skipSpace()\n return this.nextToken()\n }\n return this.finishOp(tt.incDec, 2)\n }\n if (next === 61) return this.finishOp(tt.assign, 2)\n return this.finishOp(tt.plusMin, 1)\n}\n\npp.readToken_lt_gt = function(code) { // '<>'\n let next = this.input.charCodeAt(this.pos + 1)\n let size = 1\n if (next === code) {\n size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2\n if (this.input.charCodeAt(this.pos + size) === 61) return this.finishOp(tt.assign, size + 1)\n return this.finishOp(tt.bitShift, size)\n }\n if (next === 33 && code === 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 45 &&\n this.input.charCodeAt(this.pos + 3) === 45) {\n // `` line comment
+ this.skipLineComment(3);
+ this.skipSpace();
+ return this.nextToken()
+ }
+ return this.finishOp(types.incDec, 2)
+ }
+ if (next === 61) { return this.finishOp(types.assign, 2) }
+ return this.finishOp(types.plusMin, 1)
+};
+
+pp$9.readToken_lt_gt = function(code) { // '<>'
+ var next = this.input.charCodeAt(this.pos + 1);
+ var size = 1;
+ if (next === code) {
+ size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;
+ if (this.input.charCodeAt(this.pos + size) === 61) { return this.finishOp(types.assign, size + 1) }
+ return this.finishOp(types.bitShift, size)
+ }
+ if (next === 33 && code === 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 45 &&
+ this.input.charCodeAt(this.pos + 3) === 45) {
+ // `` line comment\n this.skipLineComment(3)\n this.skipSpace()\n return this.nextToken()\n }\n return this.finishOp(tt.incDec, 2)\n }\n if (next === 61) return this.finishOp(tt.assign, 2)\n return this.finishOp(tt.plusMin, 1)\n}\n\npp.readToken_lt_gt = function(code) { // '<>'\n let next = this.input.charCodeAt(this.pos + 1)\n let size = 1\n if (next === code) {\n size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2\n if (this.input.charCodeAt(this.pos + size) === 61) return this.finishOp(tt.assign, size + 1)\n return this.finishOp(tt.bitShift, size)\n }\n if (next === 33 && code === 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 45 &&\n this.input.charCodeAt(this.pos + 3) === 45) {\n // `
-foo
-bar
-```
-
-Jade 同样支持不输出的注释，加一个短横线就行了：
-
-```jade
-//- will not output within markup
-p foo
-p bar
-```
-
-渲染为：
-
-```html
-foo
-bar
-```
-
-
-### 块注释
-
-块注释也是支持的：
-
-```jade
-body
- //
- #content
- h1 Example
-```
-
-渲染为：
-
-```html
-
-
-
-```
-
-Jade 同样很好的支持了条件注释：
-
-```jade
-body
- //if IE
- a(href='http://www.mozilla.com/en-US/firefox/') Get Firefox
-```
-
-渲染为：
-
-```html
-
-
-
-```
-
-
-### 内联
-
-Jade 支持以自然的方式定义标签嵌套:
-
-```jade
-ul
- li.first
- a(href='#') foo
- li
- a(href='#') bar
- li.last
- a(href='#') baz
-```
-
-
-### 块展开
-
-块展开可以帮助你在一行内创建嵌套的标签，下面的例子和上面的是一样的：
-
-```jade
-ul
- li.first: a(href='#') foo
- li: a(href='#') bar
- li.last: a(href='#') baz
-```
-
-
-### Case
-
-`case` 表达式按下面这样的形式写:
-
-```jade
-html
- body
- friends = 10
- case friends
- when 0
- p you have no friends
- when 1
- p you have a friend
- default
- p you have #{friends} friends
-```
-
-块展开在这里也可以使用:
-
-```jade
-friends = 5
-
-html
- body
- case friends
- when 0: p you have no friends
- when 1: p you have a friend
- default: p you have #{friends} friends
-```
-
-
-### 属性
-
-Jade 现在支持使用 `(` 和 `)` 作为属性分隔符
-
-```jade
-a(href='/login', title='View login page') Login
-```
-
-当一个值是 `undefined` 或者 `null` 属性 _不_ 会被加上,
-所以呢，它不会编译出 'something="null"'.
-
-```jade
-div(something=null)
-```
-
-Boolean 属性也是支持的:
-
-```jade
-input(type="checkbox", checked)
-```
-
-使用代码的 Boolean 属性只有当属性为 `true` 时才会输出：
-
-```jade
-input(type="checkbox", checked=someValue)
-```
-
-多行同样也是可用的：
-
-```jade
-input(type='checkbox',
- name='agreement',
- checked)
-```
-
-多行的时候可以不加逗号：
-
-```jade
-input(type='checkbox'
- name='agreement'
- checked)
-```
-
-加点空格，格式好看一点？同样支持
-
-```jade
-input(
- type='checkbox'
- name='agreement'
- checked)
-```
-
-冒号也是支持的:
-
-```jade
-rss(xmlns:atom="atom")
-```
-
-假如我有一个 `user` 对象 `{ id: 12, name: 'tobi' }`
-我们希望创建一个指向 `/user/12` 的链接 `href`, 我们可以使用普通的 JavaScript 字符串连接，如下:
-
-```jade
-a(href='/user/' + user.id)= user.name
-```
-
-或者我们使用 Jade 的修改方式, 这个我想很多使用 Ruby 或者 CoffeeScript 的人会看起来像普通的 JS..:
-
-```jade
-a(href='/user/#{user.id}')= user.name
-```
-
-`class` 属性是一个特殊的属性，你可以直接传递一个数组，比如 `bodyClasses = ['user', 'authenticated']` :
-
-```jade
-body(class=bodyClasses)
-```
-
-
-### HTML
-
-内联的 HTML 是可以的，我们可以使用管道定义一段文本 :
-
-```jade
-html
- body
- | Title
- | foo bar baz
-```
-
-或者我们可以使用 `.` 来告诉 Jade 我们需要一段文本：
-
-```jade
-html
- body.
- Title
- foo bar baz
-```
-
-上面的两个例子都会渲染成相同的结果：
-
-```jade
-Title
-foo bar baz
-
-```
-
- 这条规则适应于在 Jade 里的任何文本：
-
-```
-html
- body
- h1 User #{name}
-```
-
-
-### Doctypes
-
-添加文档类型只需要简单的使用 `!!!`, 或者 `doctype` 跟上下面的可选项:
-
-```jade
-!!!
-```
-
-会渲染出 _transitional_ 文档类型, 或者:
-
-```jade
-!!! 5
-```
-
-或
-
-```jade
-!!! html
-```
-
-或
-
-```jade
-doctype html
-```
-
-Doctype 是大小写不敏感的, 所以下面两个是一样的:
-
-```jade
-doctype Basic
-doctype basic
-```
-
-当然也是可以直接传递一段文档类型的文本：
-
-```jade
-doctype html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN"
-```
-
-渲染后:
-
-```html
-
-```
-
-会输出 _HTML5_ 文档类型. 下面的默认的文档类型，可以很简单的扩展：
-
-```javascript
-var doctypes = exports.doctypes = {
- '5': '',
- 'xml': '',
- 'default': '',
- 'transitional': '',
- 'strict': '',
- 'frameset': '',
- '1.1': '',
- 'basic': '',
- 'mobile': ''
-};
-```
-
-通过下面的代码可以很简单的改变默认的文档类型：
-
-```javascript
- jade.doctypes.default = 'whatever you want';
-```
-
-
-## 过滤器
-
-过滤器前缀 `:`, 比如 `:markdown` 会把下面块里的文本交给专门的函数进行处理。查看顶部 _特性_ 里有哪些可用的过滤器。
-
-```jade
-body
- :markdown
- Woah! jade _and_ markdown, very **cool**
- we can even link to [stuff](http://google.com)
-```
-
-渲染为:
-
-```html
-Woah! jade and markdown, very cool we can even link to stuff
-```
-
-
-## 代码
-
-Jade 目前支持三种类型的可执行代码。第一种是前缀 `-`， 这是不会被输出的：
-
-```jade
-- var foo = 'bar';
-```
-
-这可以用在条件语句或者循环中：
-
-```jade
-- for (var key in obj)
- p= obj[key]
-```
-
-由于 Jade 的缓存技术，下面的代码也是可以的：
-
-```jade
-- if (foo)
- ul
- li yay
- li foo
- li worked
-- else
- p oh no! didnt work
-```
-
-哈哈，甚至是很长的循环也是可以的：
-
- - if (items.length)
- ul
- - items.forEach(function(item){
- li= item
- - })
-
-所以你想要的！
-
-下一步我们要 _转义_ 输出的代码，比如我们返回一个值，只要前缀一个 `=`：
-
-```jade
-- var foo = 'bar'
-= foo
-h1= foo
-```
-
-它会渲染为 `barbar
`. 为了安全起见，使用 `=` 输出的代码默认是转义的,如果想直接输出不转义的值可以使用 `!=`：
-
-```jade
-p!= aVarContainingMoreHTML
-```
-
-Jade 同样是设计师友好的，它可以使 JavaScript 更直接更富表现力。比如下面的赋值语句是相等的，同时表达式还是通常的 JavaScript：
-
-```jade
-- var foo = 'foo ' + 'bar'
-foo = 'foo ' + 'bar'
-```
-
-Jade 会把 `if`, `else if`, `else`, `until`, `while`, `unless` 同别的优先对待, 但是你得记住它们还是普通的 JavaScript：
-
-```jade
-if foo == 'bar'
- ul
- li yay
- li foo
- li worked
-else
- p oh no! didnt work
-```
-
-
-## 循环
-
-尽管已经支持 JavaScript 原生代码，Jade 还是支持了一些特殊的标签，它们可以让模板更加易于理解，其中之一就是 `each`, 这种形式：
-
-```jade
-each VAL[, KEY] in OBJ
-```
-
-一个遍历数组的例子 ：
-
-```jade
-- var items = ["one", "two", "three"]
-each item in items
- li= item
-```
-
-渲染为:
-
-```html
-one
-two
-three
-```
-
-遍历一个数组同时带上索引：
-
-```jade
-items = ["one", "two", "three"]
-each item, i in items
- li #{item}: #{i}
-```
-
-渲染为:
-
-```html
-one: 0
-two: 1
-three: 2
-```
-
-遍历一个数组的键值：
-
-```jade
-obj = { foo: 'bar' }
-each val, key in obj
- li #{key}: #{val}
-```
-
-将会渲染为：`foo: bar`
-
-Jade 在内部会把这些语句转换成原生的 JavaScript 语句，就像使用 `users.forEach(function(user){`, 词法作用域和嵌套会像在普通的 JavaScript 中一样：
-
-```jade
-each user in users
- each role in user.roles
- li= role
-```
-
-如果你喜欢，也可以使用 `for` ：
-
-```jade
-for user in users
- for role in user.roles
- li= role
-```
-
-
-## 条件语句
-
-Jade 条件语句和使用了(`-`) 前缀的 JavaScript 语句是一致的,然后它允许你不使用圆括号，这样会看上去对设计师更友好一点，
-同时要在心里记住这个表达式渲染出的是 _常规_ JavaScript：
-
-```jade
-for user in users
- if user.role == 'admin'
- p #{user.name} is an admin
- else
- p= user.name
-```
-
-和下面的使用了常规 JavaScript 的代码是相等的：
-
-```jade
-for user in users
- - if (user.role == 'admin')
- p #{user.name} is an admin
- - else
- p= user.name
-```
-
-Jade 同时支持 `unless`, 这和 `if (!(expr))` 是等价的：
-
-```jade
-for user in users
- unless user.isAnonymous
- p
- | Click to view
- a(href='/users/' + user.id)= user.name
-```
-
-
-## 模板继承
-
-Jade 支持通过 `block` 和 `extends` 关键字来实现模板继承。 一个块就是一个 Jade 的 block ，它将在子模板中实现，同时是支持递归的。
-
-Jade 块如果没有内容，Jade 会添加默认内容，下面的代码默认会输出 `block scripts`, `block content`, 和 `block foot`.
-
-```jade
-html
- head
- h1 My Site - #{title}
- block scripts
- script(src='/jquery.js')
- body
- block content
- block foot
- #footer
- p some footer content
-```
-
-现在我们来继承这个布局，简单创建一个新文件，像下面那样直接使用 `extends`，给定路径（可以选择带 `.jade` 扩展名或者不带）. 你可以定义一个或者更多的块来覆盖父级块内容, 注意到这里的 `foot` 块 _没有_ 定义，所以它还会输出父级的 "some footer content"。
-
-```jade
-extends extend-layout
-
-block scripts
- script(src='/jquery.js')
- script(src='/pets.js')
-
-block content
- h1= title
- each pet in pets
- include pet
-```
-
-同样可以在一个子块里添加块，就像下面实现的块 `content` 里又定义了两个可以被实现的块 `sidebar` 和 `primary`，或者子模板直接实现 `content`。
-
-```jade
-extends regular-layout
-
-block content
- .sidebar
- block sidebar
- p nothing
- .primary
- block primary
- p nothing
-```
-
-
-
-## 前置、追加代码块
-
-Jade允许你 _替换_ （默认）、 _前置_ 和 _追加_ blocks. 比如，假设你希望在 _所有_ 页面的头部都加上默认的脚本，你可以这么做：
-
-
-```jade
-html
- head
- block head
- script(src='/vendor/jquery.js')
- script(src='/vendor/caustic.js')
- body
- block content
-```
-
-现在假设你有一个Javascript游戏的页面，你希望在默认的脚本之外添加一些游戏相关的脚本，你可以直接`append`上代码块：
-
-
-```jade
-extends layout
-
-block append head
- script(src='/vendor/three.js')
- script(src='/game.js')
-```
-
-使用 `block append` 或 `block prepend` 时 `block` 是可选的:
-
-```jade
-extends layout
-
-append head
- script(src='/vendor/three.js')
- script(src='/game.js')
-```
-
-
-## 包含
-
-Includes 允许你静态包含一段 Jade, 或者别的存放在单个文件中的东西比如 CSS, HTML 非常常见的例子是包含头部和页脚。 假设我们有一个下面目录结构的文件夹：
-
-```
-./layout.jade
-./includes/
- ./head.jade
- ./tail.jade
-```
-
-下面是 `layout.jade` 的内容:
-
-```jade
-html
- include includes/head
- body
- h1 My Site
- p Welcome to my super amazing site.
- include includes/foot
-```
-
-这两个包含 `includes/head` 和 `includes/foot` 都会读取相对于给 `layout.jade` 参数`filename` 的路径的文件, 这是一个绝对路径，不用担心Express帮你搞定这些了。Include 会解析这些文件，并且插入到已经生成的语法树中，然后渲染为你期待的内容：
-
-```html
-
-
- My Site
-
-
-
- My Site
- Welcome to my super lame site.
-
-
-
-```
-
-前面已经提到，`include` 可以包含比如 HTML 或者 CSS 这样的内容。给定一个扩展名后，Jade 不会把这个文件当作一个 Jade 源代码，并且会把它当作一个普通文本包含进来：
-
-```
-html
- head
- //- css and js have simple filters that wrap them in
-