@staffbase/create-staffbase-plugin 1.0.2 → 1.0.6

package/scaffoldTpl/node_modules/.staging/pug-parser-d0822fb9/index.js

@@ -1,1262 +0,0 @@
-'use strict';
-
-var assert = require('assert');
-var TokenStream = require('token-stream');
-var error = require('pug-error');
-var inlineTags = require('./lib/inline-tags');
-
-module.exports = parse;
-module.exports.Parser = Parser;
-function parse(tokens, options) {
-  var parser = new Parser(tokens, options);
-  var ast = parser.parse();
-  return JSON.parse(JSON.stringify(ast));
-}
-
-/**
- * Initialize `Parser` with the given input `str` and `filename`.
- *
- * @param {String} str
- * @param {String} filename
- * @param {Object} options
- * @api public
- */
-
-function Parser(tokens, options) {
-  options = options || {};
-  if (!Array.isArray(tokens)) {
-    throw new Error(
-      'Expected tokens to be an Array but got "' + typeof tokens + '"'
-    );
-  }
-  if (typeof options !== 'object') {
-    throw new Error(
-      'Expected "options" to be an object but got "' + typeof options + '"'
-    );
-  }
-  this.tokens = new TokenStream(tokens);
-  this.filename = options.filename;
-  this.src = options.src;
-  this.inMixin = 0;
-  this.plugins = options.plugins || [];
-}
-
-/**
- * Parser prototype.
- */
-
-Parser.prototype = {
-  /**
-   * Save original constructor
-   */
-
-  constructor: Parser,
-
-  error: function(code, message, token) {
-    var err = error(code, message, {
-      line: token.loc.start.line,
-      column: token.loc.start.column,
-      filename: this.filename,
-      src: this.src,
-    });
-    throw err;
-  },
-
-  /**
-   * Return the next token object.
-   *
-   * @return {Object}
-   * @api private
-   */
-
-  advance: function() {
-    return this.tokens.advance();
-  },
-
-  /**
-   * Single token lookahead.
-   *
-   * @return {Object}
-   * @api private
-   */
-
-  peek: function() {
-    return this.tokens.peek();
-  },
-
-  /**
-   * `n` token lookahead.
-   *
-   * @param {Number} n
-   * @return {Object}
-   * @api private
-   */
-
-  lookahead: function(n) {
-    return this.tokens.lookahead(n);
-  },
-
-  /**
-   * Parse input returning a string of js for evaluation.
-   *
-   * @return {String}
-   * @api public
-   */
-
-  parse: function() {
-    var block = this.emptyBlock(0);
-
-    while ('eos' != this.peek().type) {
-      if ('newline' == this.peek().type) {
-        this.advance();
-      } else if ('text-html' == this.peek().type) {
-        block.nodes = block.nodes.concat(this.parseTextHtml());
-      } else {
-        var expr = this.parseExpr();
-        if (expr) {
-          if (expr.type === 'Block') {
-            block.nodes = block.nodes.concat(expr.nodes);
-          } else {
-            block.nodes.push(expr);
-          }
-        }
-      }
-    }
-
-    return block;
-  },
-
-  /**
-   * Expect the given type, or throw an exception.
-   *
-   * @param {String} type
-   * @api private
-   */
-
-  expect: function(type) {
-    if (this.peek().type === type) {
-      return this.advance();
-    } else {
-      this.error(
-        'INVALID_TOKEN',
-        'expected "' + type + '", but got "' + this.peek().type + '"',
-        this.peek()
-      );
-    }
-  },
-
-  /**
-   * Accept the given `type`.
-   *
-   * @param {String} type
-   * @api private
-   */
-
-  accept: function(type) {
-    if (this.peek().type === type) {
-      return this.advance();
-    }
-  },
-
-  initBlock: function(line, nodes) {
-    /* istanbul ignore if */
-    if ((line | 0) !== line) throw new Error('`line` is not an integer');
-    /* istanbul ignore if */
-    if (!Array.isArray(nodes)) throw new Error('`nodes` is not an array');
-    return {
-      type: 'Block',
-      nodes: nodes,
-      line: line,
-      filename: this.filename,
-    };
-  },
-
-  emptyBlock: function(line) {
-    return this.initBlock(line, []);
-  },
-
-  runPlugin: function(context, tok) {
-    var rest = [this];
-    for (var i = 2; i < arguments.length; i++) {
-      rest.push(arguments[i]);
-    }
-    var pluginContext;
-    for (var i = 0; i < this.plugins.length; i++) {
-      var plugin = this.plugins[i];
-      if (plugin[context] && plugin[context][tok.type]) {
-        if (pluginContext)
-          throw new Error(
-            'Multiple plugin handlers found for context ' +
-              JSON.stringify(context) +
-              ', token type ' +
-              JSON.stringify(tok.type)
-          );
-        pluginContext = plugin[context];
-      }
-    }
-    if (pluginContext)
-      return pluginContext[tok.type].apply(pluginContext, rest);
-  },
-
-  /**
-   *   tag
-   * | doctype
-   * | mixin
-   * | include
-   * | filter
-   * | comment
-   * | text
-   * | text-html
-   * | dot
-   * | each
-   * | code
-   * | yield
-   * | id
-   * | class
-   * | interpolation
-   */
-
-  parseExpr: function() {
-    switch (this.peek().type) {
-      case 'tag':
-        return this.parseTag();
-      case 'mixin':
-        return this.parseMixin();
-      case 'block':
-        return this.parseBlock();
-      case 'mixin-block':
-        return this.parseMixinBlock();
-      case 'case':
-        return this.parseCase();
-      case 'extends':
-        return this.parseExtends();
-      case 'include':
-        return this.parseInclude();
-      case 'doctype':
-        return this.parseDoctype();
-      case 'filter':
-        return this.parseFilter();
-      case 'comment':
-        return this.parseComment();
-      case 'text':
-      case 'interpolated-code':
-      case 'start-pug-interpolation':
-        return this.parseText({block: true});
-      case 'text-html':
-        return this.initBlock(this.peek().loc.start.line, this.parseTextHtml());
-      case 'dot':
-        return this.parseDot();
-      case 'each':
-        return this.parseEach();
-      case 'eachOf':
-        return this.parseEachOf();
-      case 'code':
-        return this.parseCode();
-      case 'blockcode':
-        return this.parseBlockCode();
-      case 'if':
-        return this.parseConditional();
-      case 'while':
-        return this.parseWhile();
-      case 'call':
-        return this.parseCall();
-      case 'interpolation':
-        return this.parseInterpolation();
-      case 'yield':
-        return this.parseYield();
-      case 'id':
-      case 'class':
-        if (!this.peek().loc.start) debugger;
-        this.tokens.defer({
-          type: 'tag',
-          val: 'div',
-          loc: this.peek().loc,
-          filename: this.filename,
-        });
-        return this.parseExpr();
-      default:
-        var pluginResult = this.runPlugin('expressionTokens', this.peek());
-        if (pluginResult) return pluginResult;
-        this.error(
-          'INVALID_TOKEN',
-          'unexpected token "' + this.peek().type + '"',
-          this.peek()
-        );
-    }
-  },
-
-  parseDot: function() {
-    this.advance();
-    return this.parseTextBlock();
-  },
-
-  /**
-   * Text
-   */
-
-  parseText: function(options) {
-    var tags = [];
-    var lineno = this.peek().loc.start.line;
-    var nextTok = this.peek();
-    loop: while (true) {
-      switch (nextTok.type) {
-        case 'text':
-          var tok = this.advance();
-          tags.push({
-            type: 'Text',
-            val: tok.val,
-            line: tok.loc.start.line,
-            column: tok.loc.start.column,
-            filename: this.filename,
-          });
-          break;
-        case 'interpolated-code':
-          var tok = this.advance();
-          tags.push({
-            type: 'Code',
-            val: tok.val,
-            buffer: tok.buffer,
-            mustEscape: tok.mustEscape !== false,
-            isInline: true,
-            line: tok.loc.start.line,
-            column: tok.loc.start.column,
-            filename: this.filename,
-          });
-          break;
-        case 'newline':
-          if (!options || !options.block) break loop;
-          var tok = this.advance();
-          var nextType = this.peek().type;
-          if (nextType === 'text' || nextType === 'interpolated-code') {
-            tags.push({
-              type: 'Text',
-              val: '\n',
-              line: tok.loc.start.line,
-              column: tok.loc.start.column,
-              filename: this.filename,
-            });
-          }
-          break;
-        case 'start-pug-interpolation':
-          this.advance();
-          tags.push(this.parseExpr());
-          this.expect('end-pug-interpolation');
-          break;
-        default:
-          var pluginResult = this.runPlugin('textTokens', nextTok, tags);
-          if (pluginResult) break;
-          break loop;
-      }
-      nextTok = this.peek();
-    }
-    if (tags.length === 1) return tags[0];
-    else return this.initBlock(lineno, tags);
-  },
-
-  parseTextHtml: function() {
-    var nodes = [];
-    var currentNode = null;
-    loop: while (true) {
-      switch (this.peek().type) {
-        case 'text-html':
-          var text = this.advance();
-          if (!currentNode) {
-            currentNode = {
-              type: 'Text',
-              val: text.val,
-              filename: this.filename,
-              line: text.loc.start.line,
-              column: text.loc.start.column,
-              isHtml: true,
-            };
-            nodes.push(currentNode);
-          } else {
-            currentNode.val += '\n' + text.val;
-          }
-          break;
-        case 'indent':
-          var block = this.block();
-          block.nodes.forEach(function(node) {
-            if (node.isHtml) {
-              if (!currentNode) {
-                currentNode = node;
-                nodes.push(currentNode);
-              } else {
-                currentNode.val += '\n' + node.val;
-              }
-            } else {
-              currentNode = null;
-              nodes.push(node);
-            }
-          });
-          break;
-        case 'code':
-          currentNode = null;
-          nodes.push(this.parseCode(true));
-          break;
-        case 'newline':
-          this.advance();
-          break;
-        default:
-          break loop;
-      }
-    }
-    return nodes;
-  },
-
-  /**
-   *   ':' expr
-   * | block
-   */
-
-  parseBlockExpansion: function() {
-    var tok = this.accept(':');
-    if (tok) {
-      var expr = this.parseExpr();
-      return expr.type === 'Block'
-        ? expr
-        : this.initBlock(tok.loc.start.line, [expr]);
-    } else {
-      return this.block();
-    }
-  },
-
-  /**
-   * case
-   */
-
-  parseCase: function() {
-    var tok = this.expect('case');
-    var node = {
-      type: 'Case',
-      expr: tok.val,
-      line: tok.loc.start.line,
-      column: tok.loc.start.column,
-      filename: this.filename,
-    };
-
-    var block = this.emptyBlock(tok.loc.start.line + 1);
-    this.expect('indent');
-    while ('outdent' != this.peek().type) {
-      switch (this.peek().type) {
-        case 'comment':
-        case 'newline':
-          this.advance();
-          break;
-        case 'when':
-          block.nodes.push(this.parseWhen());
-          break;
-        case 'default':
-          block.nodes.push(this.parseDefault());
-          break;
-        default:
-          var pluginResult = this.runPlugin('caseTokens', this.peek(), block);
-          if (pluginResult) break;
-          this.error(
-            'INVALID_TOKEN',
-            'Unexpected token "' +
-              this.peek().type +
-              '", expected "when", "default" or "newline"',
-            this.peek()
-          );
-      }
-    }
-    this.expect('outdent');
-
-    node.block = block;
-
-    return node;
-  },
-
-  /**
-   * when
-   */
-
-  parseWhen: function() {
-    var tok = this.expect('when');
-    if (this.peek().type !== 'newline') {
-      return {
-        type: 'When',
-        expr: tok.val,
-        block: this.parseBlockExpansion(),
-        debug: false,
-        line: tok.loc.start.line,
-        column: tok.loc.start.column,
-        filename: this.filename,
-      };
-    } else {
-      return {
-        type: 'When',
-        expr: tok.val,
-        debug: false,
-        line: tok.loc.start.line,
-        column: tok.loc.start.column,
-        filename: this.filename,
-      };
-    }
-  },
-
-  /**
-   * default
-   */
-
-  parseDefault: function() {
-    var tok = this.expect('default');
-    return {
-      type: 'When',
-      expr: 'default',
-      block: this.parseBlockExpansion(),
-      debug: false,
-      line: tok.loc.start.line,
-      column: tok.loc.start.column,
-      filename: this.filename,
-    };
-  },
-
-  /**
-   * code
-   */
-
-  parseCode: function(noBlock) {
-    var tok = this.expect('code');
-    assert(
-      typeof tok.mustEscape === 'boolean',
-      'Please update to the newest version of pug-lexer.'
-    );
-    var node = {
-      type: 'Code',
-      val: tok.val,
-      buffer: tok.buffer,
-      mustEscape: tok.mustEscape !== false,
-      isInline: !!noBlock,
-      line: tok.loc.start.line,
-      column: tok.loc.start.column,
-      filename: this.filename,
-    };
-    // todo: why is this here?  It seems like a hacky workaround
-    if (node.val.match(/^ *else/)) node.debug = false;
-
-    if (noBlock) return node;
-
-    var block;
-
-    // handle block
-    block = 'indent' == this.peek().type;
-    if (block) {
-      if (tok.buffer) {
-        this.error(
-          'BLOCK_IN_BUFFERED_CODE',
-          'Buffered code cannot have a block attached to it',
-          this.peek()
-        );
-      }
-      node.block = this.block();
-    }
-
-    return node;
-  },
-  parseConditional: function() {
-    var tok = this.expect('if');
-    var node = {
-      type: 'Conditional',
-      test: tok.val,
-      consequent: this.emptyBlock(tok.loc.start.line),
-      alternate: null,
-      line: tok.loc.start.line,
-      column: tok.loc.start.column,
-      filename: this.filename,
-    };
-
-    // handle block
-    if ('indent' == this.peek().type) {
-      node.consequent = this.block();
-    }
-
-    var currentNode = node;
-    while (true) {
-      if (this.peek().type === 'newline') {
-        this.expect('newline');
-      } else if (this.peek().type === 'else-if') {
-        tok = this.expect('else-if');
-        currentNode = currentNode.alternate = {
-          type: 'Conditional',
-          test: tok.val,
-          consequent: this.emptyBlock(tok.loc.start.line),
-          alternate: null,
-          line: tok.loc.start.line,
-          column: tok.loc.start.column,
-          filename: this.filename,
-        };
-        if ('indent' == this.peek().type) {
-          currentNode.consequent = this.block();
-        }
-      } else if (this.peek().type === 'else') {
-        this.expect('else');
-        if (this.peek().type === 'indent') {
-          currentNode.alternate = this.block();
-        }
-        break;
-      } else {
-        break;
-      }
-    }
-
-    return node;
-  },
-  parseWhile: function() {
-    var tok = this.expect('while');
-    var node = {
-      type: 'While',
-      test: tok.val,
-      line: tok.loc.start.line,
-      column: tok.loc.start.column,
-      filename: this.filename,
-    };
-
-    // handle block
-    if ('indent' == this.peek().type) {
-      node.block = this.block();
-    } else {
-      node.block = this.emptyBlock(tok.loc.start.line);
-    }
-
-    return node;
-  },
-
-  /**
-   * block code
-   */
-
-  parseBlockCode: function() {
-    var tok = this.expect('blockcode');
-    var line = tok.loc.start.line;
-    var column = tok.loc.start.column;
-    var body = this.peek();
-    var text = '';
-    if (body.type === 'start-pipeless-text') {
-      this.advance();
-      while (this.peek().type !== 'end-pipeless-text') {
-        tok = this.advance();
-        switch (tok.type) {
-          case 'text':
-            text += tok.val;
-            break;
-          case 'newline':
-            text += '\n';
-            break;
-          default:
-            var pluginResult = this.runPlugin('blockCodeTokens', tok, tok);
-            if (pluginResult) {
-              text += pluginResult;
-              break;
-            }
-            this.error(
-              'INVALID_TOKEN',
-              'Unexpected token type: ' + tok.type,
-              tok
-            );
-        }
-      }
-      this.advance();
-    }
-    return {
-      type: 'Code',
-      val: text,
-      buffer: false,
-      mustEscape: false,
-      isInline: false,
-      line: line,
-      column: column,
-      filename: this.filename,
-    };
-  },
-  /**
-   * comment
-   */
-
-  parseComment: function() {
-    var tok = this.expect('comment');
-    var block;
-    if ((block = this.parseTextBlock())) {
-      return {
-        type: 'BlockComment',
-        val: tok.val,
-        block: block,
-        buffer: tok.buffer,
-        line: tok.loc.start.line,
-        column: tok.loc.start.column,
-        filename: this.filename,
-      };
-    } else {
-      return {
-        type: 'Comment',
-        val: tok.val,
-        buffer: tok.buffer,
-        line: tok.loc.start.line,
-        column: tok.loc.start.column,
-        filename: this.filename,
-      };
-    }
-  },
-
-  /**
-   * doctype
-   */
-
-  parseDoctype: function() {
-    var tok = this.expect('doctype');
-    return {
-      type: 'Doctype',
-      val: tok.val,
-      line: tok.loc.start.line,
-      column: tok.loc.start.column,
-      filename: this.filename,
-    };
-  },
-
-  parseIncludeFilter: function() {
-    var tok = this.expect('filter');
-    var attrs = [];
-
-    if (this.peek().type === 'start-attributes') {
-      attrs = this.attrs();
-    }
-
-    return {
-      type: 'IncludeFilter',
-      name: tok.val,
-      attrs: attrs,
-      line: tok.loc.start.line,
-      column: tok.loc.start.column,
-      filename: this.filename,
-    };
-  },
-
-  /**
-   * filter attrs? text-block
-   */
-
-  parseFilter: function() {
-    var tok = this.expect('filter');
-    var block,
-      attrs = [];
-
-    if (this.peek().type === 'start-attributes') {
-      attrs = this.attrs();
-    }
-
-    if (this.peek().type === 'text') {
-      var textToken = this.advance();
-      block = this.initBlock(textToken.loc.start.line, [
-        {
-          type: 'Text',
-          val: textToken.val,
-          line: textToken.loc.start.line,
-          column: textToken.loc.start.column,
-          filename: this.filename,
-        },
-      ]);
-    } else if (this.peek().type === 'filter') {
-      block = this.initBlock(tok.loc.start.line, [this.parseFilter()]);
-    } else {
-      block = this.parseTextBlock() || this.emptyBlock(tok.loc.start.line);
-    }
-
-    return {
-      type: 'Filter',
-      name: tok.val,
-      block: block,
-      attrs: attrs,
-      line: tok.loc.start.line,
-      column: tok.loc.start.column,
-      filename: this.filename,
-    };
-  },
-
-  /**
-   * each block
-   */
-
-  parseEach: function() {
-    var tok = this.expect('each');
-    var node = {
-      type: 'Each',
-      obj: tok.code,
-      val: tok.val,
-      key: tok.key,
-      block: this.block(),
-      line: tok.loc.start.line,
-      column: tok.loc.start.column,
-      filename: this.filename,
-    };
-    if (this.peek().type == 'else') {
-      this.advance();
-      node.alternate = this.block();
-    }
-    return node;
-  },
-
-  parseEachOf: function() {
-    var tok = this.expect('eachOf');
-    var node = {
-      type: 'EachOf',
-      obj: tok.code,
-      val: tok.val,
-      block: this.block(),
-      line: tok.loc.start.line,
-      column: tok.loc.start.column,
-      filename: this.filename,
-    };
-    return node;
-  },
-  /**
-   * 'extends' name
-   */
-
-  parseExtends: function() {
-    var tok = this.expect('extends');
-    var path = this.expect('path');
-    return {
-      type: 'Extends',
-      file: {
-        type: 'FileReference',
-        path: path.val.trim(),
-        line: path.loc.start.line,
-        column: path.loc.start.column,
-        filename: this.filename,
-      },
-      line: tok.loc.start.line,
-      column: tok.loc.start.column,
-      filename: this.filename,
-    };
-  },
-
-  /**
-   * 'block' name block
-   */
-
-  parseBlock: function() {
-    var tok = this.expect('block');
-
-    var node =
-      'indent' == this.peek().type
-        ? this.block()
-        : this.emptyBlock(tok.loc.start.line);
-    node.type = 'NamedBlock';
-    node.name = tok.val.trim();
-    node.mode = tok.mode;
-    node.line = tok.loc.start.line;
-    node.column = tok.loc.start.column;
-
-    return node;
-  },
-
-  parseMixinBlock: function() {
-    var tok = this.expect('mixin-block');
-    if (!this.inMixin) {
-      this.error(
-        'BLOCK_OUTISDE_MIXIN',
-        'Anonymous blocks are not allowed unless they are part of a mixin.',
-        tok
-      );
-    }
-    return {
-      type: 'MixinBlock',
-      line: tok.loc.start.line,
-      column: tok.loc.start.column,
-      filename: this.filename,
-    };
-  },
-
-  parseYield: function() {
-    var tok = this.expect('yield');
-    return {
-      type: 'YieldBlock',
-      line: tok.loc.start.line,
-      column: tok.loc.start.column,
-      filename: this.filename,
-    };
-  },
-
-  /**
-   * include block?
-   */
-
-  parseInclude: function() {
-    var tok = this.expect('include');
-    var node = {
-      type: 'Include',
-      file: {
-        type: 'FileReference',
-        filename: this.filename,
-      },
-      line: tok.loc.start.line,
-      column: tok.loc.start.column,
-      filename: this.filename,
-    };
-    var filters = [];
-    while (this.peek().type === 'filter') {
-      filters.push(this.parseIncludeFilter());
-    }
-    var path = this.expect('path');
-
-    node.file.path = path.val.trim();
-    node.file.line = path.loc.start.line;
-    node.file.column = path.loc.start.column;
-
-    if (
-      (/\.jade$/.test(node.file.path) || /\.pug$/.test(node.file.path)) &&
-      !filters.length
-    ) {
-      node.block =
-        'indent' == this.peek().type
-          ? this.block()
-          : this.emptyBlock(tok.loc.start.line);
-      if (/\.jade$/.test(node.file.path)) {
-        console.warn(
-          this.filename +
-            ', line ' +
-            tok.loc.start.line +
-            ':\nThe .jade extension is deprecated, use .pug for "' +
-            node.file.path +
-            '".'
-        );
-      }
-    } else {
-      node.type = 'RawInclude';
-      node.filters = filters;
-      if (this.peek().type === 'indent') {
-        this.error(
-          'RAW_INCLUDE_BLOCK',
-          'Raw inclusion cannot contain a block',
-          this.peek()
-        );
-      }
-    }
-    return node;
-  },
-
-  /**
-   * call ident block
-   */
-
-  parseCall: function() {
-    var tok = this.expect('call');
-    var name = tok.val;
-    var args = tok.args;
-    var mixin = {
-      type: 'Mixin',
-      name: name,
-      args: args,
-      block: this.emptyBlock(tok.loc.start.line),
-      call: true,
-      attrs: [],
-      attributeBlocks: [],
-      line: tok.loc.start.line,
-      column: tok.loc.start.column,
-      filename: this.filename,
-    };
-
-    this.tag(mixin);
-    if (mixin.code) {
-      mixin.block.nodes.push(mixin.code);
-      delete mixin.code;
-    }
-    if (mixin.block.nodes.length === 0) mixin.block = null;
-    return mixin;
-  },
-
-  /**
-   * mixin block
-   */
-
-  parseMixin: function() {
-    var tok = this.expect('mixin');
-    var name = tok.val;
-    var args = tok.args;
-
-    if ('indent' == this.peek().type) {
-      this.inMixin++;
-      var mixin = {
-        type: 'Mixin',
-        name: name,
-        args: args,
-        block: this.block(),
-        call: false,
-        line: tok.loc.start.line,
-        column: tok.loc.start.column,
-        filename: this.filename,
-      };
-      this.inMixin--;
-      return mixin;
-    } else {
-      this.error(
-        'MIXIN_WITHOUT_BODY',
-        'Mixin ' + name + ' declared without body',
-        tok
-      );
-    }
-  },
-
-  /**
-   * indent (text | newline)* outdent
-   */
-
-  parseTextBlock: function() {
-    var tok = this.accept('start-pipeless-text');
-    if (!tok) return;
-    var block = this.emptyBlock(tok.loc.start.line);
-    while (this.peek().type !== 'end-pipeless-text') {
-      var tok = this.advance();
-      switch (tok.type) {
-        case 'text':
-          block.nodes.push({
-            type: 'Text',
-            val: tok.val,
-            line: tok.loc.start.line,
-            column: tok.loc.start.column,
-            filename: this.filename,
-          });
-          break;
-        case 'newline':
-          block.nodes.push({
-            type: 'Text',
-            val: '\n',
-            line: tok.loc.start.line,
-            column: tok.loc.start.column,
-            filename: this.filename,
-          });
-          break;
-        case 'start-pug-interpolation':
-          block.nodes.push(this.parseExpr());
-          this.expect('end-pug-interpolation');
-          break;
-        case 'interpolated-code':
-          block.nodes.push({
-            type: 'Code',
-            val: tok.val,
-            buffer: tok.buffer,
-            mustEscape: tok.mustEscape !== false,
-            isInline: true,
-            line: tok.loc.start.line,
-            column: tok.loc.start.column,
-            filename: this.filename,
-          });
-          break;
-        default:
-          var pluginResult = this.runPlugin('textBlockTokens', tok, block, tok);
-          if (pluginResult) break;
-          this.error(
-            'INVALID_TOKEN',
-            'Unexpected token type: ' + tok.type,
-            tok
-          );
-      }
-    }
-    this.advance();
-    return block;
-  },
-
-  /**
-   * indent expr* outdent
-   */
-
-  block: function() {
-    var tok = this.expect('indent');
-    var block = this.emptyBlock(tok.loc.start.line);
-    while ('outdent' != this.peek().type) {
-      if ('newline' == this.peek().type) {
-        this.advance();
-      } else if ('text-html' == this.peek().type) {
-        block.nodes = block.nodes.concat(this.parseTextHtml());
-      } else {
-        var expr = this.parseExpr();
-        if (expr.type === 'Block') {
-          block.nodes = block.nodes.concat(expr.nodes);
-        } else {
-          block.nodes.push(expr);
-        }
-      }
-    }
-    this.expect('outdent');
-    return block;
-  },
-
-  /**
-   * interpolation (attrs | class | id)* (text | code | ':')? newline* block?
-   */
-
-  parseInterpolation: function() {
-    var tok = this.advance();
-    var tag = {
-      type: 'InterpolatedTag',
-      expr: tok.val,
-      selfClosing: false,
-      block: this.emptyBlock(tok.loc.start.line),
-      attrs: [],
-      attributeBlocks: [],
-      isInline: false,
-      line: tok.loc.start.line,
-      column: tok.loc.start.column,
-      filename: this.filename,
-    };
-
-    return this.tag(tag, {selfClosingAllowed: true});
-  },
-
-  /**
-   * tag (attrs | class | id)* (text | code | ':')? newline* block?
-   */
-
-  parseTag: function() {
-    var tok = this.advance();
-    var tag = {
-      type: 'Tag',
-      name: tok.val,
-      selfClosing: false,
-      block: this.emptyBlock(tok.loc.start.line),
-      attrs: [],
-      attributeBlocks: [],
-      isInline: inlineTags.indexOf(tok.val) !== -1,
-      line: tok.loc.start.line,
-      column: tok.loc.start.column,
-      filename: this.filename,
-    };
-
-    return this.tag(tag, {selfClosingAllowed: true});
-  },
-
-  /**
-   * Parse tag.
-   */
-
-  tag: function(tag, options) {
-    var seenAttrs = false;
-    var attributeNames = [];
-    var selfClosingAllowed = options && options.selfClosingAllowed;
-    // (attrs | class | id)*
-    out: while (true) {
-      switch (this.peek().type) {
-        case 'id':
-        case 'class':
-          var tok = this.advance();
-          if (tok.type === 'id') {
-            if (attributeNames.indexOf('id') !== -1) {
-              this.error(
-                'DUPLICATE_ID',
-                'Duplicate attribute "id" is not allowed.',
-                tok
-              );
-            }
-            attributeNames.push('id');
-          }
-          tag.attrs.push({
-            name: tok.type,
-            val: "'" + tok.val + "'",
-            line: tok.loc.start.line,
-            column: tok.loc.start.column,
-            filename: this.filename,
-            mustEscape: false,
-          });
-          continue;
-        case 'start-attributes':
-          if (seenAttrs) {
-            console.warn(
-              this.filename +
-                ', line ' +
-                this.peek().loc.start.line +
-                ':\nYou should not have pug tags with multiple attributes.'
-            );
-          }
-          seenAttrs = true;
-          tag.attrs = tag.attrs.concat(this.attrs(attributeNames));
-          continue;
-        case '&attributes':
-          var tok = this.advance();
-          tag.attributeBlocks.push({
-            type: 'AttributeBlock',
-            val: tok.val,
-            line: tok.loc.start.line,
-            column: tok.loc.start.column,
-            filename: this.filename,
-          });
-          break;
-        default:
-          var pluginResult = this.runPlugin(
-            'tagAttributeTokens',
-            this.peek(),
-            tag,
-            attributeNames
-          );
-          if (pluginResult) break;
-          break out;
-      }
-    }
-
-    // check immediate '.'
-    if ('dot' == this.peek().type) {
-      tag.textOnly = true;
-      this.advance();
-    }
-
-    // (text | code | ':')?
-    switch (this.peek().type) {
-      case 'text':
-      case 'interpolated-code':
-        var text = this.parseText();
-        if (text.type === 'Block') {
-          tag.block.nodes.push.apply(tag.block.nodes, text.nodes);
-        } else {
-          tag.block.nodes.push(text);
-        }
-        break;
-      case 'code':
-        tag.block.nodes.push(this.parseCode(true));
-        break;
-      case ':':
-        this.advance();
-        var expr = this.parseExpr();
-        tag.block =
-          expr.type === 'Block' ? expr : this.initBlock(tag.line, [expr]);
-        break;
-      case 'newline':
-      case 'indent':
-      case 'outdent':
-      case 'eos':
-      case 'start-pipeless-text':
-      case 'end-pug-interpolation':
-        break;
-      case 'slash':
-        if (selfClosingAllowed) {
-          this.advance();
-          tag.selfClosing = true;
-          break;
-        }
-      default:
-        var pluginResult = this.runPlugin(
-          'tagTokens',
-          this.peek(),
-          tag,
-          options
-        );
-        if (pluginResult) break;
-        this.error(
-          'INVALID_TOKEN',
-          'Unexpected token `' +
-            this.peek().type +
-            '` expected `text`, `interpolated-code`, `code`, `:`' +
-            (selfClosingAllowed ? ', `slash`' : '') +
-            ', `newline` or `eos`',
-          this.peek()
-        );
-    }
-
-    // newline*
-    while ('newline' == this.peek().type) this.advance();
-
-    // block?
-    if (tag.textOnly) {
-      tag.block = this.parseTextBlock() || this.emptyBlock(tag.line);
-    } else if ('indent' == this.peek().type) {
-      var block = this.block();
-      for (var i = 0, len = block.nodes.length; i < len; ++