barbiche.js

(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Barbiche = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
/* parser generated by jison 0.4.18-180 */

/*
 * Returns a Parser object of the following structure:
 *
 *  Parser: {
 *    yy: {}     The so-called "shared state" or rather the *source* of it;
 *               the real "shared state" `yy` passed around to
 *               the rule actions, etc. is a derivative/copy of this one,
 *               not a direct reference!
 *  }
 *
 *  Parser.prototype: {
 *    yy: {},
 *    EOF: 1,
 *    TERROR: 2,
 *
 *    trace: function(errorMessage, ...),
 *
 *    JisonParserError: function(msg, hash),
 *
 *    quoteName: function(name),
 *               Helper function which can be overridden by user code later on: put suitable
 *               quotes around literal IDs in a description string.
 *
 *    originalQuoteName: function(name),
 *               The basic quoteName handler provided by JISON.
 *               `cleanupAfterParse()` will clean up and reset `quoteName()` to reference this function
 *               at the end of the `parse()`.
 *
 *    describeSymbol: function(symbol),
 *               Return a more-or-less human-readable description of the given symbol, when
 *               available, or the symbol itself, serving as its own 'description' for lack
 *               of something better to serve up.
 *
 *               Return NULL when the symbol is unknown to the parser.
 *
 *    symbols_: {associative list: name ==> number},
 *    terminals_: {associative list: number ==> name},
 *    nonterminals: {associative list: rule-name ==> {associative list: number ==> rule-alt}},
 *    terminal_descriptions_: (if there are any) {associative list: number ==> description},
 *    productions_: [...],
 *
 *    performAction: function parser__performAction(yytext, yyleng, yylineno, yyloc, yystate, yysp, yyvstack, yylstack, yystack, yysstack, ...),
 *               where `...` denotes the (optional) additional arguments the user passed to
 *               `parser.parse(str, ...)` and specified by way of `%parse-param ...` in the grammar file
 *
 *               The function parameters and `this` have the following value/meaning:
 *               - `this`    : reference to the `yyval` internal object, which has members (`$` and `_$`)
 *                             to store/reference the rule value `$$` and location info `@$`.
 *
 *                 One important thing to note about `this` a.k.a. `yyval`: every *reduce* action gets
 *                 to see the same object via the `this` reference, i.e. if you wish to carry custom
 *                 data from one reduce action through to the next within a single parse run, then you
 *                 may get nasty and use `yyval` a.k.a. `this` for storing you own semi-permanent data.
 *
 *               - `yytext`  : reference to the lexer value which belongs to the last lexer token used
 *                             to match this rule. This is *not* the look-ahead token, but the last token
 *                             that's actually part of this rule.
 *
 *                 Formulated another way, `yytext` is the value of the token immediately preceeding
 *                 the current look-ahead token.
 *                 Caveats apply for rules which don't require look-ahead, such as epsilon rules.
 *
 *               - `yyleng`  : ditto as `yytext`, only now for the lexer.yyleng value.
 *
 *               - `yylineno`: ditto as `yytext`, only now for the lexer.yylineno value.
 *
 *               - `yyloc`   : ditto as `yytext`, only now for the lexer.yylloc lexer token location info.
 *
 *               - `yystate` : the current parser state number, used internally for dispatching and
 *                             executing the action code chunk matching the rule currently being reduced.
 *
 *               - `yysp`    : the current state stack position (a.k.a. 'stack pointer')
 *
 *                 This one comes in handy when you are going to do advanced things to the parser
 *                 stacks, all of which are accessible from your action code (see the next entries below).
 *
 *                 Also note that you can access this and other stack index values using the new double-hash
 *                 syntax, i.e. `##$ === ##0 === yysp`, while `##1` is the stack index for all things
 *                 related to the first rule term, just like you have `$1`, `@1` and `#1`.
 *                 This is made available to write very advanced grammar action rules, e.g. when you want
 *                 to investigate the parse state stack in your action code, which would, for example,
 *                 be relevant when you wish to implement error diagnostics and reporting schemes similar
 *                 to the work described here:
 *
 *                 + Pottier, F., 2016. Reachability and error diagnosis in LR(1) automata.
 *                   In Journées Francophones des Languages Applicatifs.
 *
 *                 + Jeffery, C.L., 2003. Generating LR syntax error messages from examples.
 *                   ACM Transactions on Programming Languages and Systems (TOPLAS), 25(5), pp.631–640.
 *
 *               - `yyvstack`: reference to the parser value stack. Also accessed via the `$1` etc.
 *                             constructs.
 *
 *               - `yylstack`: reference to the parser token location stack. Also accessed via
 *                             the `@1` etc. constructs.
 *
 *               - `yystack` : reference to the parser token id stack. Also accessed via the
 *                             `#1` etc. constructs.
 *
 *                 Note: this is a bit of a **white lie** as we can statically decode any `#n` reference to
 *                 its numeric token id value, hence that code wouldn't need the `yystack` but *you* might
 *                 want access for your own purposes, such as error analysis as mentioned above!
 *
 *                 Note that this stack stores the current stack of *tokens*, that is the sequence of
 *                 already parsed=reduced *nonterminals* (tokens representing rules) and *terminals*
 *                 (lexer tokens *shifted* onto the stack until the rule they belong to is found and
 *                 *reduced*.
 *
 *               - `yysstack`: reference to the parser state stack. This one carries the internal parser
 *                             *states* such as the one in `yystate`, which are used to represent
 *                             the parser state machine in the *parse table*. *Very* *internal* stuff,
 *                             what can I say? If you access this one, you're clearly doing wicked things
 *
 *               - `...`     : the extra arguments you specified in the `%parse-param` statement in your
 *                             grammar definition file.
 *
 *    table: [...],
 *               State transition table
 *               ----------------------
 *
 *               index levels are:
 *               - `state`  --> hash table
 *               - `symbol` --> action (number or array)
 *
 *                 If the `action` is an array, these are the elements' meaning:
 *                 - index [0]: 1 = shift, 2 = reduce, 3 = accept
 *                 - index [1]: GOTO `state`
 *
 *                 If the `action` is a number, it is the GOTO `state`
 *
 *    defaultActions: {...},
 *
 *    parseError: function(str, hash, ExceptionClass),
 *    yyError: function(str, ...),
 *    yyRecovering: function(),
 *    yyErrOk: function(),
 *    yyClearIn: function(),
 *
 *    constructParseErrorInfo: function(error_message, exception_object, expected_token_set, is_recoverable),
 *               Helper function **which will be set up during the first invocation of the `parse()` method**.
 *               Produces a new errorInfo 'hash object' which can be passed into `parseError()`.
 *               See it's use in this parser kernel in many places; example usage:
 *
 *                   var infoObj = parser.constructParseErrorInfo('fail!', null,
 *                                     parser.collect_expected_token_set(state), true);
 *                   var retVal = parser.parseError(infoObj.errStr, infoObj, parser.JisonParserError);
 *
 *    originalParseError: function(str, hash, ExceptionClass),
 *               The basic `parseError` handler provided by JISON.
 *               `cleanupAfterParse()` will clean up and reset `parseError()` to reference this function
 *               at the end of the `parse()`.
 *
 *    options: { ... parser %options ... },
 *
 *    parse: function(input[, args...]),
 *               Parse the given `input` and return the parsed value (or `true` when none was provided by
 *               the root action, in which case the parser is acting as a *matcher*).
 *               You MAY use the additional `args...` parameters as per `%parse-param` spec of this grammar:
 *               these extra `args...` are passed verbatim to the grammar rules' action code.
 *
 *    cleanupAfterParse: function(resultValue, invoke_post_methods, do_not_nuke_errorinfos),
 *               Helper function **which will be set up during the first invocation of the `parse()` method**.
 *               This helper API is invoked at the end of the `parse()` call, unless an exception was thrown
 *               and `%options no-try-catch` has been defined for this grammar: in that case this helper MAY
 *               be invoked by calling user code to ensure the `post_parse` callbacks are invoked and
 *               the internal parser gets properly garbage collected under these particular circumstances.
 *
 *    lexer: {
 *        yy: {...},           A reference to the so-called "shared state" `yy` once
 *                             received via a call to the `.setInput(input, yy)` lexer API.
 *        EOF: 1,
 *        ERROR: 2,
 *        JisonLexerError: function(msg, hash),
 *        parseError: function(str, hash, ExceptionClass),
 *        setInput: function(input, [yy]),
 *        input: function(),
 *        unput: function(str),
 *        more: function(),
 *        reject: function(),
 *        less: function(n),
 *        pastInput: function(n),
 *        upcomingInput: function(n),
 *        showPosition: function(),
 *        test_match: function(regex_match_array, rule_index, ...),
 *        next: function(...),
 *        lex: function(...),
 *        begin: function(condition),
 *        pushState: function(condition),
 *        popState: function(),
 *        topState: function(),
 *        _currentRules: function(),
 *        stateStackSize: function(),
 *        cleanupAfterLex: function()
 *
 *        options: { ... lexer %options ... },
 *
 *        performAction: function(yy, yy_, $avoiding_name_collisions, YY_START, ...),
 *        rules: [...],
 *        conditions: {associative list: name ==> set},
 *    }
 *  }
 *
 *
 *  token location info (@$, _$, etc.): {
 *    first_line: n,
 *    last_line: n,
 *    first_column: n,
 *    last_column: n,
 *    range: [start_number, end_number]
 *               (where the numbers are indexes into the input string, zero-based)
 *  }
 *
 * ---
 *
 * The `parseError` function receives a 'hash' object with these members for lexer and
 * parser errors:
 *
 *  {
 *    text:        (matched text)
 *    token:       (the produced terminal token, if any)
 *    token_id:    (the produced terminal token numeric ID, if any)
 *    line:        (yylineno)
 *    loc:         (yylloc)
 *  }
 *
 * parser (grammar) errors will also provide these additional members:
 *
 *  {
 *    expected:    (array describing the set of expected tokens;
 *                  may be UNDEFINED when we cannot easily produce such a set)
 *    state:       (integer (or array when the table includes grammar collisions);
 *                  represents the current internal state of the parser kernel.
 *                  can, for example, be used to pass to the `collect_expected_token_set()`
 *                  API to obtain the expected token set)
 *    action:      (integer; represents the current internal action which will be executed)
 *    new_state:   (integer; represents the next/planned internal state, once the current
 *                  action has executed)
 *    recoverable: (boolean: TRUE when the parser MAY have an error recovery rule
 *                  available for this particular error)
 *    state_stack: (array: the current parser LALR/LR internal state stack; this can be used,
 *                  for instance, for advanced error analysis and reporting)
 *    value_stack: (array: the current parser LALR/LR internal `$$` value stack; this can be used,
 *                  for instance, for advanced error analysis and reporting)
 *    location_stack: (array: the current parser LALR/LR internal location stack; this can be used,
 *                  for instance, for advanced error analysis and reporting)
 *    yy:          (object: the current parser internal "shared state" `yy`
 *                  as is also available in the rule actions; this can be used,
 *                  for instance, for advanced error analysis and reporting)
 *    lexer:       (reference to the current lexer instance used by the parser)
 *    parser:      (reference to the current parser instance)
 *  }
 *
 * while `this` will reference the current parser instance.
 *
 * When `parseError` is invoked by the lexer, `this` will still reference the related *parser*
 * instance, while these additional `hash` fields will also be provided:
 *
 *  {
 *    lexer:       (reference to the current lexer instance which reported the error)
 *  }
 *
 * When `parseError` is invoked by the parser due to a **JavaScript exception** being fired
 * from either the parser or lexer, `this` will still reference the related *parser*
 * instance, while these additional `hash` fields will also be provided:
 *
 *  {
 *    exception:   (reference to the exception thrown)
 *  }
 *
 * Please do note that in the latter situation, the `expected` field will be omitted as
 * this type of failure is assumed not to be due to *parse errors* but rather due to user
 * action code in either parser or lexer failing unexpectedly.
 *
 * ---
 *
 * You can specify parser options by setting / modifying the `.yy` object of your Parser instance.
 * These options are available:
 *
 * ### options which are global for all parser instances
 *
 *  Parser.pre_parse: function(yy [, optional parse() args])
 *                 optional: you can specify a pre_parse() function in the chunk following
 *                 the grammar, i.e. after the last `%%`.
 *  Parser.post_parse: function(yy, retval [, optional parse() args]) { return retval; }
 *                 optional: you can specify a post_parse() function in the chunk following
 *                 the grammar, i.e. after the last `%%`. When it does not return any value,
 *                 the parser will return the original `retval`.
 *
 * ### options which can be set up per parser instance
 *
 *  yy: {
 *      pre_parse:  function(yy [, optional parse() args])
 *                 optional: is invoked before the parse cycle starts (and before the first
 *                 invocation of `lex()`) but immediately after the invocation of
 *                 `parser.pre_parse()`).
 *      post_parse: function(yy, retval [, optional parse() args]) { return retval; }
 *                 optional: is invoked when the parse terminates due to success ('accept')
 *                 or failure (even when exceptions are thrown).
 *                 `retval` contains the return value to be produced by `Parser.parse()`;
 *                 this function can override the return value by returning another.
 *                 When it does not return any value, the parser will return the original
 *                 `retval`.
 *                 This function is invoked immediately before `Parser.post_parse()`.
 *
 *      parseError: function(str, hash, ExceptionClass)
 *                 optional: overrides the default `parseError` function.
 *      quoteName: function(name),
 *                 optional: overrides the default `quoteName` function.
 *  }
 *
 *  parser.lexer.options: {
 *      pre_lex:  function()
 *                 optional: is invoked before the lexer is invoked to produce another token.
 *                 `this` refers to the Lexer object.
 *      post_lex: function(token) { return token; }
 *                 optional: is invoked when the lexer has produced a token `token`;
 *                 this function can override the returned token value by returning another.
 *                 When it does not return any (truthy) value, the lexer will return
 *                 the original `token`.
 *                 `this` refers to the Lexer object.
 *
 *      ranges: boolean
 *                 optional: `true` ==> token location info will include a .range[] member.
 *      flex: boolean
 *                 optional: `true` ==> flex-like lexing behaviour where the rules are tested
 *                 exhaustively to find the longest match.
 *      backtrack_lexer: boolean
 *                 optional: `true` ==> lexer regexes are tested in order and for invoked;
 *                 the lexer terminates the scan when a token is returned by the action code.
 *      xregexp: boolean
 *                 optional: `true` ==> lexer rule regexes are "extended regex format" requiring the
 *                 `XRegExp` library. When this %option has not been specified at compile time, all lexer
 *                 rule regexes have been written as standard JavaScript RegExp expressions.
 *  }
 */
var parser = (function () {

// See also:
// http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript/#35881508
// but we keep the prototype.constructor and prototype.name assignment lines too for compatibility
// with userland code which might access the derived class in a 'classic' way.
function JisonParserError(msg, hash) {
    Object.defineProperty(this, 'name', {
        enumerable: false,
        writable: false,
        value: 'JisonParserError'
    });

    if (msg == null) msg = '???';

    Object.defineProperty(this, 'message', {
        enumerable: false,
        writable: true,
        value: msg
    });

    this.hash = hash;

    var stacktrace;
    if (hash && hash.exception instanceof Error) {
        var ex2 = hash.exception;
        this.message = ex2.message || msg;
        stacktrace = ex2.stack;
    }
    if (!stacktrace) {
        if (Error.hasOwnProperty('captureStackTrace')) { // V8
            Error.captureStackTrace(this, this.constructor);
        } else {
            stacktrace = (new Error(msg)).stack;
        }
    }
    if (stacktrace) {
        Object.defineProperty(this, 'stack', {
            enumerable: false,
            writable: false,
            value: stacktrace
        });
    }
}

if (typeof Object.setPrototypeOf === 'function') {
    Object.setPrototypeOf(JisonParserError.prototype, Error.prototype);
} else {
    JisonParserError.prototype = Object.create(Error.prototype);
}
JisonParserError.prototype.constructor = JisonParserError;
JisonParserError.prototype.name = 'JisonParserError';




// helper: reconstruct the productions[] table
function bp(s) {
    var rv = [];
    var p = s.pop;
    var r = s.rule;
    for (var i = 0, l = p.length; i < l; i++) {
        rv.push([
            p[i],
            r[i]
        ]);
    }
    return rv;
}



// helper: reconstruct the defaultActions[] table
function bda(s) {
    var rv = {};
    var d = s.idx;
    var g = s.goto;
    for (var i = 0, l = d.length; i < l; i++) {
        var j = d[i];
        rv[j] = g[i];
    }
    return rv;
}



// helper: reconstruct the 'goto' table
function bt(s) {
    var rv = [];
    var d = s.len;
    var y = s.symbol;
    var t = s.type;
    var a = s.state;
    var m = s.mode;
    var g = s.goto;
    for (var i = 0, l = d.length; i < l; i++) {
        var n = d[i];
        var q = {};
        for (var j = 0; j < n; j++) {
            var z = y.shift();
            switch (t.shift()) {
            case 2:
                q[z] = [
                    m.shift(),
                    g.shift()
                ];
                break;

            case 0:
                q[z] = a.shift();
                break;

            default:
                // type === 1: accept
                q[z] = [
                    3
                ];
            }
        }
        rv.push(q);
    }
    return rv;
}



// helper: runlength encoding with increment step: code, length: step (default step = 0)
// `this` references an array
function s(c, l, a) {
    a = a || 0;
    for (var i = 0; i < l; i++) {
        this.push(c);
        c += a;
    }
}

// helper: duplicate sequence from *relative* offset and length.
// `this` references an array
function c(i, l) {
    i = this.length - i;
    for (l += i; i < l; i++) {
        this.push(this[i]);
    }
}

// helper: unpack an array using helpers and data, all passed in an array argument 'a'.
function u(a) {
    var rv = [];
    for (var i = 0, l = a.length; i < l; i++) {
        var e = a[i];
        // Is this entry a helper function?
        if (typeof e === 'function') {
            i++;
            e.apply(rv, a[i]);
        } else {
            rv.push(e);
        }
    }
    return rv;
}


var parser = {
    // Code Generator Information Report
    // ---------------------------------
    //
    // Options:
    //
    //   no default action: ............... true
    //   no try..catch: ................... false
    //   no default resolve on conflict:    false
    //   on-demand look-ahead: ............ false
    //   error recovery token skip maximum: 3
    //   debug grammar/output: ............ false
    //   has partial LR conflict upgrade:   true
    //   rudimentary token-stack support:   false
    //   parser table compression mode: ... 2
    //   export debug tables: ............. false
    //   export *all* tables: ............. false
    //   module type: ..................... commonjs
    //   parser engine type: .............. lalr
    //   output main() in the module: ..... true
    //   number of expected conflicts: .... 0
    //
    //
    // Parser Analysis flags:
    //
    //   all actions are default: ......... false
    //   uses yyleng: ..................... false
    //   uses yylineno: ................... false
    //   uses yytext: ..................... true
    //   uses yylloc: ..................... false
    //   uses ParseError API: ............. false
    //   uses YYERROR: .................... false
    //   uses YYRECOVERING: ............... false
    //   uses YYERROK: .................... false
    //   uses YYCLEARIN: .................. false
    //   tracks rule values: .............. true
    //   assigns rule values: ............. true
    //   uses location tracking: .......... false
    //   assigns location: ................ false
    //   uses yystack: .................... false
    //   uses yysstack: ................... false
    //   uses yysp: ....................... true
    //   has error recovery: .............. false
    //
    // --------- END OF REPORT -----------

trace: function no_op_trace() { },
JisonParserError: JisonParserError,
yy: {},
options: {
  type: "lalr",
  hasPartialLrUpgradeOnConflict: true,
  errorRecoveryTokenDiscardCount: 3
},
symbols_: {
  "!": 7,
  "!=": 19,
  "!==": 21,
  "$accept": 0,
  "$end": 1,
  "&&": 17,
  "(": 8,
  ")": 9,
  "+": 6,
  "++": 15,
  ",": 13,
  "--": 14,
  ".": 12,
  ":": 3,
  "<": 4,
  "<=": 22,
  "==": 18,
  "===": 20,
  ">": 5,
  ">=": 23,
  "Arguments": 35,
  "Array": 36,
  "EOF": 1,
  "FALSE": 28,
  "IDENTIFIER": 26,
  "List": 37,
  "Main": 31,
  "NULL": 30,
  "NUMBER": 24,
  "Order": 32,
  "PropertyName": 34,
  "STRING": 25,
  "SimpleExpression": 33,
  "TRUE": 27,
  "UNDEFINED": 29,
  "[": 10,
  "]": 11,
  "error": 2,
  "||": 16
},
terminals_: {
  1: "EOF",
  2: "error",
  3: ":",
  4: "<",
  5: ">",
  6: "+",
  7: "!",
  8: "(",
  9: ")",
  10: "[",
  11: "]",
  12: ".",
  13: ",",
  14: "--",
  15: "++",
  16: "||",
  17: "&&",
  18: "==",
  19: "!=",
  20: "===",
  21: "!==",
  22: "<=",
  23: ">=",
  24: "NUMBER",
  25: "STRING",
  26: "IDENTIFIER",
  27: "TRUE",
  28: "FALSE",
  29: "UNDEFINED",
  30: "NULL"
},
TERROR: 2,
EOF: 1,

// internals: defined here so the object *structure* doesn't get modified by parse() et al,
// thus helping JIT compilers like Chrome V8.
originalQuoteName: null,
originalParseError: null,
cleanupAfterParse: null,
constructParseErrorInfo: null,

__reentrant_call_depth: 0,      // INTERNAL USE ONLY
__error_infos: [],              // INTERNAL USE ONLY: the set of parseErrorInfo objects created since the last cleanup

// APIs which will be set up depending on user action code analysis:
//yyRecovering: 0,
//yyErrOk: 0,
//yyClearIn: 0,

// Helper APIs
// -----------

// Helper function which can be overridden by user code later on: put suitable quotes around
// literal IDs in a description string.
quoteName: function parser_quoteName(id_str) {
    return '"' + id_str + '"';
},

// Return a more-or-less human-readable description of the given symbol, when available,
// or the symbol itself, serving as its own 'description' for lack of something better to serve up.
//
// Return NULL when the symbol is unknown to the parser.
describeSymbol: function parser_describeSymbol(symbol) {
    if (symbol !== this.EOF && this.terminal_descriptions_ && this.terminal_descriptions_[symbol]) {
        return this.terminal_descriptions_[symbol];
    }
    else if (symbol === this.EOF) {
        return 'end of input';
    }
    else if (this.terminals_[symbol]) {
        return this.quoteName(this.terminals_[symbol]);
    }
    // Otherwise... this might refer to a RULE token i.e. a non-terminal: see if we can dig that one up.
    //
    // An example of this may be where a rule's action code contains a call like this:
    //
    //      parser.describeSymbol(#$)
    //
    // to obtain a human-readable description or name of the current grammar rule. This comes handy in
    // error handling action code blocks, for example.
    var s = this.symbols_;
    for (var key in s) {
        if (s[key] === symbol) {
            return key;
        }
    }
    return null;
},

// Produce a (more or less) human-readable list of expected tokens at the point of failure.
//
// The produced list may contain token or token set descriptions instead of the tokens
// themselves to help turning this output into something that easier to read by humans
// unless `do_not_describe` parameter is set, in which case a list of the raw, *numeric*,
// expected terminals and nonterminals is produced.
//
// The returned list (array) will not contain any duplicate entries.
collect_expected_token_set: function parser_collect_expected_token_set(state, do_not_describe) {
    var TERROR = this.TERROR;
    var tokenset = [];
    var check = {};
    // Has this (error?) state been outfitted with a custom expectations description text for human consumption?
    // If so, use that one instead of the less palatable token set.
    if (!do_not_describe && this.state_descriptions_ && this.state_descriptions_[state]) {
        return [
            this.state_descriptions_[state]
        ];
    }
    for (var p in this.table[state]) {
        p = +p;
        if (p !== TERROR) {
            var d = do_not_describe ? p : this.describeSymbol(p);
            if (d && !check[d]) {
                tokenset.push(d);
                check[d] = true;        // Mark this token description as already mentioned to prevent outputting duplicate entries.
            }
        }
    }
    return tokenset;
},
productions_: bp({
  pop: u([
  31,
  31,
  32,
  32,
  s,
  [33, 25],
  34,
  35,
  35,
  36,
  36,
  37,
  37
]),
  rule: u([
  2,
  3,
  1,
  1,
  s,
  [3, 12],
  2,
  3,
  2,
  4,
  c,
  [19, 3],
  s,
  [1, 7],
  c,
  [14, 3],
  3,
  1,
  3
])
}),
performAction: function parser__PerformAction(yytext, yystate /* action[1] */, yysp, yyvstack) {
/* this == yyval */
var yy = this.yy;

switch (yystate) {
case 1:
    /*! Production::    Main : SimpleExpression EOF */
    return yyvstack[yysp - 1];
    break;

case 2:
    /*! Production::    Main : SimpleExpression Order EOF */
    return ORDER.bind(null, yyvstack[yysp - 2], yyvstack[yysp - 1]);
    break;

case 3:
    /*! Production::    Order : "--" */
    this.$ = 'after';
    break;

case 4:
    /*! Production::    Order : "++" */
    this.$ = 'before';
    break;

case 5:
    /*! Production::    SimpleExpression : SimpleExpression ":" SimpleExpression */
    this.$ = BB_OBJ.bind(yy, yyvstack[yysp - 2], yyvstack[yysp]);
    break;

case 6:
    /*! Production::    SimpleExpression : SimpleExpression "||" SimpleExpression */
    this.$ = OR.bind(null, yyvstack[yysp - 2], yyvstack[yysp]);
    break;

case 7:
    /*! Production::    SimpleExpression : SimpleExpression "&&" SimpleExpression */
    this.$ = AND.bind(null, yyvstack[yysp - 2], yyvstack[yysp]);
    break;

case 8:
    /*! Production::    SimpleExpression : SimpleExpression "==" SimpleExpression */
    this.$ = EQUAL.bind(null, yyvstack[yysp - 2], yyvstack[yysp]);
    break;

case 9:
    /*! Production::    SimpleExpression : SimpleExpression "!=" SimpleExpression */
    this.$ = NOT_EQ.bind(null, yyvstack[yysp - 2], yyvstack[yysp]);
    break;

case 10:
    /*! Production::    SimpleExpression : SimpleExpression "===" SimpleExpression */
    this.$ = STRICT_EQUAL.bind(null, yyvstack[yysp - 2], yyvstack[yysp]);
    break;

case 11:
    /*! Production::    SimpleExpression : SimpleExpression "!==" SimpleExpression */
    this.$ = STRICT_NOT_EQ.bind(null, yyvstack[yysp - 2], yyvstack[yysp]);
    break;

case 12:
    /*! Production::    SimpleExpression : SimpleExpression "<=" SimpleExpression */
    this.$ = LEQ.bind(null, yyvstack[yysp - 2], yyvstack[yysp]);
    break;

case 13:
    /*! Production::    SimpleExpression : SimpleExpression ">=" SimpleExpression */
    this.$ = GEQ.bind(null, yyvstack[yysp - 2], yyvstack[yysp]);
    break;

case 14:
    /*! Production::    SimpleExpression : SimpleExpression "<" SimpleExpression */
    this.$ = LESS.bind(null, yyvstack[yysp - 2], yyvstack[yysp]);
    break;

case 15:
    /*! Production::    SimpleExpression : SimpleExpression ">" SimpleExpression */
    this.$ = GREATER.bind(null, yyvstack[yysp - 2], yyvstack[yysp]);
    break;

case 16:
    /*! Production::    SimpleExpression : SimpleExpression "+" SimpleExpression */
    this.$ = PLUS.bind(null, yyvstack[yysp - 2], yyvstack[yysp]);
    break;

case 17:
    /*! Production::    SimpleExpression : "!" SimpleExpression */
    this.$ = NOT.bind(null, yyvstack[yysp]);
    break;

case 18:
    /*! Production::    SimpleExpression : "(" SimpleExpression ")" */
case 32:
    /*! Production::    Arguments : "(" List ")" */
case 34:
    /*! Production::    Array : "[" List "]" */
    this.$ = yyvstack[yysp - 1];
    break;

case 19:
    /*! Production::    SimpleExpression : SimpleExpression Arguments */
    this.$ = CALL.bind(null, yyvstack[yysp - 1], yyvstack[yysp]);
    break;

case 20:
    /*! Production::    SimpleExpression : SimpleExpression "[" SimpleExpression "]" */
    this.$ = GET_PROPERTY.bind(null, yyvstack[yysp - 3], yyvstack[yysp - 1]);
    break;

case 21:
    /*! Production::    SimpleExpression : SimpleExpression "." PropertyName */
    this.$ = GET_PROPERTY.bind(null, yyvstack[yysp - 2], yyvstack[yysp]);
    break;

case 22:
    /*! Production::    SimpleExpression : Array */
    this.$ = yyvstack[yysp];
    break;

case 23:
    /*! Production::    SimpleExpression : NUMBER */
    var number = Number(yytext); this.$ = function() {return number;};
    break;

case 24:
    /*! Production::    SimpleExpression : STRING */
case 30:
    /*! Production::    PropertyName : IDENTIFIER */
    this.$ = function() {return yytext;};
    break;

case 25:
    /*! Production::    SimpleExpression : IDENTIFIER */
    this.$ = yy.context.resolve.bind(yy.context, yytext);
    break;

case 26:
    /*! Production::    SimpleExpression : TRUE */
    this.$ = TRUE;
    break;

case 27:
    /*! Production::    SimpleExpression : FALSE */
    this.$ = FALSE;
    break;

case 28:
    /*! Production::    SimpleExpression : UNDEFINED */
    this.$ = UNDEFINED;
    break;

case 29:
    /*! Production::    SimpleExpression : NULL */
    this.$ = NULL;
    break;

case 31:
    /*! Production::    Arguments : "(" ")" */
case 33:
    /*! Production::    Array : "[" "]" */
    this.$ = EMPTY_ARRAY;
    break;

case 35:
    /*! Production::    List : SimpleExpression */
    this.$ = SINGLETON.bind(null, yyvstack[yysp]);
    break;

case 36:
    /*! Production::    List : List "," SimpleExpression */
    this.$ = PUSH.bind(null, yyvstack[yysp - 2], yyvstack[yysp]);
    break;

}
},
table: bt({
  len: u([
  13,
  1,
  20,
  12,
  12,
  s,
  [0, 8],
  14,
  0,
  1,
  s,
  [12, 12],
  0,
  12,
  2,
  c,
  [20, 3],
  22,
  17,
  0,
  2,
  19,
  0,
  s,
  [22, 12],
  17,
  s,
  [0, 3],
  c,
  [26, 3],
  c,
  [55, 3],
  19
]),
  symbol: u([
  7,
  8,
  10,
  s,
  [24, 8, 1],
  33,
  36,
  1,
  1,
  s,
  [3, 4, 1],
  s,
  [8, 4, 2],
  s,
  [15, 9, 1],
  32,
  35,
  c,
  [34, 10],
  33,
  36,
  c,
  [12, 15],
  11,
  c,
  [13, 9],
  37,
  1,
  c,
  [39, 27],
  c,
  [12, 129],
  26,
  34,
  s,
  [7, 4, 1],
  c,
  [173, 11],
  c,
  [231, 5],
  s,
  [9, 15, 1],
  35,
  c,
  [21, 7],
  12,
  c,
  [17, 9],
  11,
  13,
  c,
  [40, 10],
  c,
  [21, 9],
  c,
  [60, 22],
  c,
  [22, 242],
  c,
  [554, 6],
  11,
  c,
  [302, 10],
  9,
  13,
  c,
  [371, 12],
  c,
  [314, 19]
]),
  type: u([
  s,
  [2, 10],
  s,
  [0, 3],
  1,
  s,
  [2, 18],
  0,
  0,
  c,
  [12, 34],
  c,
  [59, 4],
  c,
  [51, 47],
  c,
  [12, 111],
  c,
  [173, 26],
  c,
  [24, 11],
  c,
  [17, 33],
  c,
  [21, 25],
  c,
  [22, 260],
  c,
  [17, 13],
  c,
  [355, 20],
  0
]),
  state: u([
  1,
  2,
  5,
  15,
  28,
  34,
  5,
  35,
  5,
  38,
  5,
  37,
  40,
  5,
  41,
  5,
  42,
  5,
  43,
  5,
  44,
  5,
  45,
  5,
  46,
  5,
  47,
  5,
  48,
  5,
  49,
  5,
  50,
  5,
  51,
  5,
  52,
  5,
  53,
  38,
  5,
  56,
  s,
  [28, 16],
  62,
  5,
  28
]),
  mode: u([
  s,
  [1, 202],
  s,
  [2, 5],
  1,
  2,
  1,
  c,
  [4, 3],
  s,
  [2, 10],
  c,
  [44, 24],
  c,
  [40, 5],
  c,
  [57, 9],
  c,
  [19, 9],
  c,
  [49, 10],
  c,
  [21, 13],
  c,
  [22, 8],
  c,
  [21, 14],
  c,
  [22, 7],
  c,
  [21, 15],
  c,
  [25, 6],
  c,
  [21, 65],
  c,
  [6, 5],
  c,
  [204, 14],
  c,
  [21, 67],
  c,
  [288, 40],
  c,
  [298, 23]
]),
  goto: u([
  3,
  4,
  13,
  s,
  [6, 7, 1],
  14,
  16,
  25,
  26,
  27,
  33,
  s,
  [29, 4, 1],
  s,
  [17, 8, 1],
  c,
  [28, 10],
  c,
  [10, 13],
  36,
  c,
  [11, 7],
  39,
  c,
  [32, 23],
  c,
  [10, 107],
  54,
  3,
  4,
  55,
  c,
  [12, 8],
  s,
  [17, 5],
  33,
  17,
  29,
  17,
  30,
  s,
  [17, 11],
  c,
  [212, 5],
  57,
  29,
  30,
  c,
  [211, 8],
  58,
  59,
  c,
  [18, 5],
  35,
  29,
  35,
  30,
  35,
  c,
  [20, 8],
  5,
  5,
  c,
  [19, 4],
  5,
  29,
  5,
  30,
  s,
  [5, 3],
  c,
  [21, 8],
  6,
  6,
  c,
  [21, 4],
  6,
  29,
  6,
  30,
  s,
  [6, 4],
  c,
  [21, 7],
  7,
  7,
  c,
  [21, 4],
  7,
  29,
  7,
  30,
  s,
  [7, 5],
  c,
  [21, 6],
  8,
  8,
  c,
  [21, 4],
  8,
  29,
  8,
  30,
  s,
  [8, 9],
  23,
  24,
  9,
  9,
  c,
  [21, 4],
  9,
  29,
  9,
  30,
  s,
  [9, 9],
  23,
  24,
  10,
  10,
  c,
  [21, 4],
  10,
  29,
  10,
  30,
  s,
  [10, 9],
  23,
  24,
  11,
  11,
  c,
  [21, 4],
  11,
  29,
  11,
  30,
  s,
  [11, 9],
  23,
  24,
  s,
  [12, 4],
  27,
  33,
  12,
  29,
  12,
  30,
  s,
  [12, 11],
  s,
  [13, 4],
  27,
  33,
  13,
  29,
  13,
  30,
  s,
  [13, 11],
  s,
  [14, 4],
  27,
  33,
  14,
  29,
  14,
  30,
  s,
  [14, 11],
  s,
  [15, 4],
  27,
  33,
  15,
  29,
  15,
  30,
  s,
  [15, 11],
  s,
  [16, 5],
  33,
  16,
  29,
  16,
  30,
  s,
  [16, 12],
  c,
  [500, 5],
  60,
  c,
  [288, 9],
  61,
  59,
  c,
  [349, 10],
  c,
  [28, 5],
  36,
  29,
  36,
  30,
  36,
  c,
  [30, 8]
])
}),
defaultActions: bda({
  idx: u([
  s,
  [5, 8, 1],
  14,
  28,
  31,
  32,
  36,
  39,
  53,
  54,
  55,
  57,
  58,
  60,
  61
]),
  goto: u([
  s,
  [22, 8, 1],
  1,
  19,
  3,
  4,
  33,
  2,
  21,
  30,
  31,
  18,
  34,
  20,
  32
])
}),
parseError: function parseError(str, hash, ExceptionClass) {
    if (hash.recoverable) {
        this.trace(str);
        hash.destroy();             // destroy... well, *almost*!
    } else {
        throw new ExceptionClass(str, hash);
    }
},
parse: function parse(input) {
    var self = this,
        stack = new Array(128),         // token stack: stores token which leads to state at the same index (column storage)
        sstack = new Array(128),        // state stack: stores states (column storage)

        vstack = new Array(128),        // semantic value stack

        table = this.table,
        sp = 0;                         // 'stack pointer': index into the stacks

    var TERROR = this.TERROR,
        EOF = this.EOF,
        ERROR_RECOVERY_TOKEN_DISCARD_COUNT = (this.options.errorRecoveryTokenDiscardCount | 0) || 3;
    var NO_ACTION = [0, table.length /* ensures that anyone using this new state will fail dramatically! */];

    //this.reductionCount = this.shiftCount = 0;

    var lexer;
    if (this.__lexer__) {
        lexer = this.__lexer__;
    } else {
        lexer = this.__lexer__ = Object.create(this.lexer);
    }

    var sharedState_yy = {
        parseError: null,
        quoteName: null,
        lexer: null,
        parser: null,
        pre_parse: null,
        post_parse: null
    };
    // copy state
    for (var k in this.yy) {
      if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
        sharedState_yy[k] = this.yy[k];
      }
    }

    sharedState_yy.lexer = lexer;
    sharedState_yy.parser = this;






    lexer.setInput(input, sharedState_yy);



    vstack[sp] = null;
    sstack[sp] = 0;
    stack[sp] = 0;
    ++sp;

    var yytext = lexer.yytext;


    // Does the shared state override the default `parseError` that already comes with this instance?
    if (typeof sharedState_yy.parseError === 'function') {
        this.parseError = function parseErrorAlt(str, hash, ExceptionClass) {
            return sharedState_yy.parseError(str, hash, ExceptionClass);
        };
    } else {
        this.parseError = this.originalParseError;
    }

    // Does the shared state override the default `quoteName` that already comes with this instance?
    if (typeof sharedState_yy.quoteName === 'function') {
        this.quoteName = sharedState_yy.quoteName;
    } else {
        this.quoteName = this.originalQuoteName;
    }

    // set up the cleanup function; make it an API so that external code can re-use this one in case of
    // calamities or when the `%options no-try-catch` option has been specified for the grammar, in which
    // case this parse() API method doesn't come with a `finally { ... }` block any more!
    //
    // NOTE: as this API uses parse() as a closure, it MUST be set again on every parse() invocation,
    //       or else your `sharedState`, etc. references will be *wrong*!
    this.cleanupAfterParse = function parser_cleanupAfterParse(resultValue, invoke_post_methods, do_not_nuke_errorinfos) {
        var rv;

        if (invoke_post_methods) {
            if (sharedState_yy.post_parse) {
                rv = sharedState_yy.post_parse.call(this, sharedState_yy, resultValue);
                if (typeof rv !== 'undefined') resultValue = rv;
            }
            if (this.post_parse) {
                rv = this.post_parse.call(this, sharedState_yy, resultValue);
                if (typeof rv !== 'undefined') resultValue = rv;
            }
        }

        if (this.__reentrant_call_depth > 1) return resultValue;        // do not (yet) kill the sharedState when this is a reentrant run.

        // clean up the lingering lexer structures as well:
        if (lexer.cleanupAfterLex) {
            lexer.cleanupAfterLex(do_not_nuke_errorinfos);
        }

        // prevent lingering circular references from causing memory leaks:
        if (sharedState_yy) {
            sharedState_yy.parseError = undefined;
            sharedState_yy.quoteName = undefined;
            sharedState_yy.lexer = undefined;
            sharedState_yy.parser = undefined;
            if (lexer.yy === sharedState_yy) {
                lexer.yy = undefined;
            }
        }
        sharedState_yy = undefined;
        this.parseError = this.originalParseError;
        this.quoteName = this.originalQuoteName;

        // nuke the vstack[] array at least as that one will still reference obsoleted user values.
        // To be safe, we nuke the other internal stack columns as well...
        stack.length = 0;               // fastest way to nuke an array without overly bothering the GC
        sstack.length = 0;

        vstack.length = 0;
        sp = 0;

        // nuke the error hash info instances created during this run.
        // Userland code must COPY any data/references
        // in the error hash instance(s) it is more permanently interested in.
        if (!do_not_nuke_errorinfos) {
            for (var i = this.__error_infos.length - 1; i >= 0; i--) {
                var el = this.__error_infos[i];
                if (el && typeof el.destroy === 'function') {
                    el.destroy();
                }
            }
            this.__error_infos.length = 0;
        }

        return resultValue;
    };

    // NOTE: as this API uses parse() as a closure, it MUST be set again on every parse() invocation,
    //       or else your `lexer`, `sharedState`, etc. references will be *wrong*!
    this.constructParseErrorInfo = function parser_constructParseErrorInfo(msg, ex, expected, recoverable) {
        var pei = {
            errStr: msg,
            exception: ex,
            text: lexer.match,
            value: lexer.yytext,
            token: this.describeSymbol(symbol) || symbol,
            token_id: symbol,
            line: lexer.yylineno,

            expected: expected,
            recoverable: recoverable,
            state: state,
            action: action,
            new_state: newState,
            symbol_stack: stack,
            state_stack: sstack,
            value_stack: vstack,

            stack_pointer: sp,
            yy: sharedState_yy,
            lexer: lexer,
            parser: this,

            // and make sure the error info doesn't stay due to potential
            // ref cycle via userland code manipulations.
            // These would otherwise all be memory leak opportunities!
            //
            // Note that only array and object references are nuked as those
            // constitute the set of elements which can produce a cyclic ref.
            // The rest of the members is kept intact as they are harmless.
            destroy: function destructParseErrorInfo() {
                // remove cyclic references added to error info:
                // info.yy = null;
                // info.lexer = null;
                // info.value = null;
                // info.value_stack = null;
                // ...
                var rec = !!this.recoverable;
                for (var key in this) {
                    if (this.hasOwnProperty(key) && typeof key === 'object') {
                        this[key] = undefined;
                    }
                }
                this.recoverable = rec;
            }
        };
        // track this instance so we can `destroy()` it once we deem it superfluous and ready for garbage collection!
        this.__error_infos.push(pei);
        return pei;
    };


    function lex() {
        var token = lexer.lex();
        // if token isn't its numeric value, convert
        if (typeof token !== 'number') {
            token = self.symbols_[token] || token;
        }
        return token || EOF;
    }


    var symbol = 0;

    var state, action, r, t;
    var yyval = {
        $: true,
        _$: undefined,
        yy: sharedState_yy
    };
    var p, len, this_production;

    var newState;
    var retval = false;


    try {
        this.__reentrant_call_depth++;

        if (this.pre_parse) {
            this.pre_parse.call(this, sharedState_yy);
        }
        if (sharedState_yy.pre_parse) {
            sharedState_yy.pre_parse.call(this, sharedState_yy);
        }

        newState = sstack[sp - 1];
        for (;;) {
            // retrieve state number from top of stack
            state = newState;               // sstack[sp - 1];

            // use default actions if available
            if (this.defaultActions[state]) {
                action = 2;
                newState = this.defaultActions[state];
            } else {
                // The single `==` condition below covers both these `===` comparisons in a single
                // operation:
                //
                //     if (symbol === null || typeof symbol === 'undefined') ...
                if (!symbol) {
                    symbol = lex();
                }
                // read action for current state and first input
                t = (table[state] && table[state][symbol]) || NO_ACTION;
                newState = t[1];
                action = t[0];




                // handle parse error
                if (!action) {
                    var errStr;
                    var errSymbolDescr = (this.describeSymbol(symbol) || symbol);
                    var expected = this.collect_expected_token_set(state);

                    // Report error
                    if (typeof lexer.yylineno === 'number') {
                        errStr = 'Parse error on line ' + (lexer.yylineno + 1) + ': ';
                    } else {
                        errStr = 'Parse error: ';
                    }
                    if (lexer.showPosition) {
                        errStr += '\n' + lexer.showPosition(79 - 10, 10) + '\n';
                    }
                    if (expected.length) {
                        errStr += 'Expecting ' + expected.join(', ') + ', got unexpected ' + errSymbolDescr;
                    } else {
                        errStr += 'Unexpected ' + errSymbolDescr;
                    }
                    // we cannot recover from the error!
                    p = this.constructParseErrorInfo(errStr, null, expected, false);
                    retval = this.parseError(p.errStr, p, this.JisonParserError);
                    break;
                }


            }









            switch (action) {
            // catch misc. parse failures:
            default:
                // this shouldn't happen, unless resolve defaults are off
                if (action instanceof Array) {
                    p = this.constructParseErrorInfo(('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol), null, null, false);
                    retval = this.parseError(p.errStr, p, this.JisonParserError);
                    break;
                }
                // Another case of better safe than sorry: in case state transitions come out of another error recovery process
                // or a buggy LUT (LookUp Table):
                p = this.constructParseErrorInfo('Parsing halted. No viable error recovery approach available due to internal system failure.', null, null, false);
                retval = this.parseError(p.errStr, p, this.JisonParserError);
                break;

            // shift:
            case 1:
                //this.shiftCount++;
                stack[sp] = symbol;
                vstack[sp] = lexer.yytext;

                sstack[sp] = newState; // push state
                ++sp;
                symbol = 0;

                    // Pick up the lexer details for the current symbol as that one is not 'look-ahead' any more:

                    yytext = lexer.yytext;








                




                continue;

            // reduce:
            case 2:
                //this.reductionCount++;
                this_production = this.productions_[newState - 1];  // `this.productions_[]` is zero-based indexed while states start from 1 upwards...
                len = this_production[1];




                // Do this to prevent nasty action block codes to *read* `$0` or `$$`
                // and *not* get `undefined` as a result for their efforts!
                vstack[sp] = undefined;











                r = this.performAction.call(yyval, yytext, newState, sp - 1, vstack);

                if (typeof r !== 'undefined') {
                    retval = r;
                    break;
                }

                // pop off stack
                sp -= len;

                // don't overwrite the `symbol` variable: use a local var to speed things up:
                var ntsymbol = this_production[0];    // push nonterminal (reduce)
                stack[sp] = ntsymbol;
                vstack[sp] = yyval.$;

                // goto new state = table[STATE][NONTERMINAL]
                newState = table[sstack[sp - 1]][ntsymbol];
                sstack[sp] = newState;
                ++sp;

                continue;

            // accept:
            case 3:
                retval = true;
                // Return the `$accept` rule's `$$` result, if available.
                //
                // Also note that JISON always adds this top-most `$accept` rule (with implicit,
                // default, action):
                //
                //     $accept: <startSymbol> $end
                //                  %{ $$ = $1; @$ = @1; %}
                //
                // which, combined with the parse kernel's `$accept` state behaviour coded below,
                // will produce the `$$` value output of the <startSymbol> rule as the parse result,
                // IFF that result is *not* `undefined`. (See also the parser kernel code.)
                //
                // In code:
                //
                //                  %{
                //                      @$ = @1;            // if location tracking support is included
                //                      if (typeof $1 !== 'undefined')
                //                          return $1;
                //                      else
                //                          return true;           // the default parse result if the rule actions don't produce anything
                //                  %}
                if (typeof yyval.$ !== 'undefined') {
                    retval = yyval.$;
                }
                break;
            }

            // break out of loop: we accept or fail with error
            break;
        }
    } catch (ex) {
        // report exceptions through the parseError callback too:
        p = this.constructParseErrorInfo('Parsing aborted due to exception.', ex, null, false);
        retval = this.parseError(p.errStr, p, this.JisonParserError);
    } finally {
        retval = this.cleanupAfterParse(retval, true, true);
        this.__reentrant_call_depth--;
    }

    return retval;
}
};
parser.originalParseError = parser.parseError;
parser.originalQuoteName = parser.quoteName;

/* Helpers */
var table = {
	"n": "\n",
	"'": "'",
	"\"": "\"",
	"t": "\t",
	"r": "\r",
	"\\": "\\",
	"`": "`",
	"b": "\b"
};
var stringUnescapeRegExp = /\\(?:(\\|'|"|r|n|t|b|`)|u(.{4})|x(.{2}))/g;
function charCodeToChar(str) {
	return String.fromCharCode(parseInt(str, 16));
}
function stringUnescapeReplace() {
	if (arguments[1]) return table[arguments[1]];
	else return charCodeToChar(arguments[2] || arguments[3]);
}
function stringUnescape(str) {
	return str.replace(stringUnescapeRegExp, stringUnescapeReplace);
}

function OR(a, b) {
	return a() || b();
}

function AND(a, b) {
	return a() && b();
}

function EQUAL(a, b) {
	return a() == b();
}

function NOT_EQ(a, b) {
	return a() != b();
}

function STRICT_EQUAL(a, b) {
	return a() === b();
}

function STRICT_NOT_EQ(a, b) {
	return a() !== b();
}

function LEQ(a, b) {
	return a() <= b();
}

function LESS(a, b) {
	return a() < b();
}

function GEQ(a, b) {
	return a() >= b();
}

function GREATER(a, b) {
	return a() > b();
}

function NOT(a) {
	return !(a());
}

function EMPTY_ARRAY() {return [];}

function SINGLETON(a) {return [a()];}

function PUSH(a, b) {
	var ret = a();
	ret.push(b());
	return ret;
}

function GET_PROPERTY(a, b) {
	var val = a();
	if (val != null) {
		var ret = val[b()];
		if (typeof(ret) === 'function') {
			return ret.bind(val);
		} else return ret;
	}
}

function CALL(a, b) {
	var fun = a();
	if (typeof(fun) === 'function') {
		return fun.apply(null, b());
	}
}

function BB_OBJ(a, b) {
	return new this.BBObj(a(), b());
}

function PLUS(a, b) {
	return a() + b();
}

function ORDER(a, b) {
	var ret = a();
	ret._order = b;
	return ret;
}

function TRUE() {return true;}
function FALSE() {return false;}
function NULL() {return null;}
function UNDEFINED() {}
/* lexer generated by jison-lex 0.3.4-166 */
/*
 * Returns a Lexer object of the following structure:
 *
 *  Lexer: {
 *    yy: {}     The so-called "shared state" or rather the *source* of it;
 *               the real "shared state" `yy` passed around to
 *               the rule actions, etc. is a derivative/copy of this one,
 *               not a direct reference!
 *  }
 *
 *  Lexer.prototype: {
 *    yy: {},
 *    EOF: 1,
 *    ERROR: 2,
 *
 *    JisonLexerError: function(msg, hash),
 *
 *    performAction: function lexer__performAction(yy, yy_, $avoiding_name_collisions, YY_START, ...),
 *               where `...` denotes the (optional) additional arguments the user passed to
 *               `lexer.lex(...)` and specified by way of `%parse-param ...` in the **parser** grammar file
 *
 *               The function parameters and `this` have the following value/meaning:
 *               - `this`    : reference to the `lexer` instance.
 *
 *               - `yy`      : a reference to the `yy` "shared state" object which was passed to the lexer
 *                             by way of the `lexer.setInput(str, yy)` API before.
 *
 *               - `yy_`     : lexer instance reference used internally.
 *
 *               - `$avoiding_name_collisions`   : index of the matched lexer rule (regex), used internally.
 *
 *               - `YY_START`: the current lexer "start condition" state.
 *
 *               - `...`     : the extra arguments you specified in the `%parse-param` statement in your
 *                             **parser** grammar definition file and which are passed to the lexer via
 *                             its `lexer.lex(...)` API.
 *
 *    parseError: function(str, hash, ExceptionClass),
 *
 *    constructLexErrorInfo: function(error_message, is_recoverable),
 *               Helper function.
 *               Produces a new errorInfo 'hash object' which can be passed into `parseError()`.
 *               See it's use in this lexer kernel in many places; example usage:
 *
 *                   var infoObj = lexer.constructParseErrorInfo('fail!', true);
 *                   var retVal = lexer.parseError(infoObj.errStr, infoObj, lexer.JisonLexerError);
 *
 *    options: { ... lexer %options ... },
 *
 *    lex: function([args...]),
 *               Produce one token of lexed input, which was passed in earlier via the `lexer.setInput()` API.
 *               You MAY use the additional `args...` parameters as per `%parse-param` spec of the **parser** grammar:
 *               these extra `args...` are passed verbatim to the lexer rules' action code.
 *
 *    cleanupAfterLex: function(do_not_nuke_errorinfos),
 *               Helper function.
 *               This helper API is invoked when the parse process has completed. This helper may
 *               be invoked by user code to ensure the internal lexer gets properly garbage collected.
 *
 *        setInput: function(input, [yy]),
 *        input: function(),
 *        unput: function(str),
 *        more: function(),
 *        reject: function(),
 *        less: function(n),
 *        pastInput: function(n),
 *        upcomingInput: function(n),
 *        showPosition: function(),
 *        test_match: function(regex_match_array, rule_index),
 *        next: function(...),
 *        lex: function(...),
 *        begin: function(condition),
 *        pushState: function(condition),
 *        popState: function(),
 *        topState: function(),
 *        _currentRules: function(),
 *        stateStackSize: function(),
 *
 *        options: { ... lexer %options ... },
 *
 *        performAction: function(yy, yy_, $avoiding_name_collisions, YY_START, ...),
 *        rules: [...],
 *        conditions: {associative list: name ==> set},
 *  }
 *
 *
 *  token location info (`yylloc`): {
 *    first_line: n,
 *    last_line: n,
 *    first_column: n,
 *    last_column: n,
 *    range: [start_number, end_number]
 *               (where the numbers are indexes into the input string, zero-based)
 *  }
 *
 * ---
 *
 * The `parseError` function receives a 'hash' object with these members for lexer errors:
 *
 *  {
 *    text:        (matched text)
 *    token:       (the produced terminal token, if any)
 *    token_id:    (the produced terminal token numeric ID, if any)
 *    line:        (yylineno)
 *    loc:         (yylloc)
 *    recoverable: (boolean: TRUE when the parser MAY have an error recovery rule
 *                  available for this particular error)
 *    yy:          (object: the current parser internal "shared state" `yy`
 *                  as is also available in the rule actions; this can be used,
 *                  for instance, for advanced error analysis and reporting)
 *    lexer:       (reference to the current lexer instance used by the parser)
 *  }
 *
 * while `this` will reference the current lexer instance.
 *
 * When `parseError` is invoked by the lexer, the default implementation will
 * attempt to invoke `yy.parser.parseError()`; when this callback is not provided
 * it will try to invoke `yy.parseError()` instead. When that callback is also not
 * provided, a `JisonLexerError` exception will be thrown containing the error
 * message and `hash`, as constructed by the `constructLexErrorInfo()` API.
 *
 * Note that the lexer's `JisonLexerError` error class is passed via the
 * `ExceptionClass` argument, which is invoked to construct the exception
 * instance to be thrown, so technically `parseError` will throw the object
 * produced by the `new ExceptionClass(str, hash)` JavaScript expression.
 *
 * ---
 *
 * You can specify lexer options by setting / modifying the `.options` object of your Lexer instance.
 * These options are available:
 *
 * (Options are permanent.)
 *  
 *  yy: {
 *      parseError: function(str, hash, ExceptionClass)
 *                 optional: overrides the default `parseError` function.
 *  }
 *
 *  lexer.options: {
 *      pre_lex:  function()
 *                 optional: is invoked before the lexer is invoked to produce another token.
 *                 `this` refers to the Lexer object.
 *      post_lex: function(token) { return token; }
 *                 optional: is invoked when the lexer has produced a token `token`;
 *                 this function can override the returned token value by returning another.
 *                 When it does not return any (truthy) value, the lexer will return
 *                 the original `token`.
 *                 `this` refers to the Lexer object.
 *
 * WARNING: the next set of options are not meant to be changed. They echo the abilities of
 * the lexer as per when it was compiled!
 *
 *      ranges: boolean
 *                 optional: `true` ==> token location info will include a .range[] member.
 *      flex: boolean
 *                 optional: `true` ==> flex-like lexing behaviour where the rules are tested
 *                 exhaustively to find the longest match.
 *      backtrack_lexer: boolean
 *                 optional: `true` ==> lexer regexes are tested in order and for invoked;
 *                 the lexer terminates the scan when a token is returned by the action code.
 *      xregexp: boolean
 *                 optional: `true` ==> lexer rule regexes are "extended regex format" requiring the
 *                 `XRegExp` library. When this %option has not been specified at compile time, all lexer
 *                 rule regexes have been written as standard JavaScript RegExp expressions.
 *  }
 */


var lexer = (function () {
// See also:
// http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript/#35881508
// but we keep the prototype.constructor and prototype.name assignment lines too for compatibility
// with userland code which might access the derived class in a 'classic' way.
function JisonLexerError(msg, hash) {
    Object.defineProperty(this, 'name', {
        enumerable: false,
        writable: false,
        value: 'JisonLexerError'
    });

    if (msg == null) msg = '???';

    Object.defineProperty(this, 'message', {
        enumerable: false,
        writable: true,
        value: msg
    });

    this.hash = hash;

    var stacktrace;
    if (hash && hash.exception instanceof Error) {
        var ex2 = hash.exception;
        this.message = ex2.message || msg;
        stacktrace = ex2.stack;
    }
    if (!stacktrace) {
        if (Error.hasOwnProperty('captureStackTrace')) { // V8
            Error.captureStackTrace(this, this.constructor);
        } else {
            stacktrace = (new Error(msg)).stack;
        }
    }
    if (stacktrace) {
        Object.defineProperty(this, 'stack', {
            enumerable: false,
            writable: false,
            value: stacktrace
        });
    }
}

if (typeof Object.setPrototypeOf === 'function') {
    Object.setPrototypeOf(JisonLexerError.prototype, Error.prototype);
} else {
    JisonLexerError.prototype = Object.create(Error.prototype);
}
JisonLexerError.prototype.constructor = JisonLexerError;
JisonLexerError.prototype.name = 'JisonLexerError';




var lexer = {
    // Code Generator Information Report
    // ---------------------------------
    //
    // Options:
    //   backtracking:        false
    //   location.ranges:     undefined
    //
    // Forwarded Parser Analysis flags:
    //   uses yyleng:         false
    //   uses yylineno:       false
    //   uses yytext:         true
    //   uses yylloc:         false
    //   uses lexer values:   true / true
    //   location tracking:   false
    //   location assignment: false
    //
    // --------- END OF REPORT -----------


    EOF: 1,
    ERROR: 2,

    // JisonLexerError: JisonLexerError,        // <-- injected by the code generator

    // options: {},                             // <-- injected by the code generator

    // yy: ...,                                 // <-- injected by setInput()

    __currentRuleSet__: null,                   // <-- internal rule set cache for the current lexer state

    __error_infos: [],                          // INTERNAL USE ONLY: the set of lexErrorInfo objects created since the last cleanup

    __decompressed: false,                      // INTERNAL USE ONLY: mark whether the lexer instance has been 'unfolded' completely and is now ready for use

    done: false,                                // INTERNAL USE ONLY
    _backtrack: false,                          // INTERNAL USE ONLY
    _input: '',                                 // INTERNAL USE ONLY
    _more: false,                               // INTERNAL USE ONLY
    _signaled_error_token: false,               // INTERNAL USE ONLY

    conditionStack: [],                         // INTERNAL USE ONLY; managed via `pushState()`, `popState()`, `topState()` and `stateStackSize()`

    match: '',                                  // READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: tracks input which has been matched so far for the lexer token under construction. `match` is identical to `yytext` except that this one still contains the matched input string after `lexer.performAction()` has been invoked, where userland code MAY have changed/replaced the `yytext` value entirely!
    matched: '',                                // READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: tracks entire input which has been matched so far
    matches: false,                             // READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: tracks RE match result for last (successful) match attempt
    yytext: '',                                 // ADVANCED USE ONLY: tracks input which has been matched so far for the lexer token under construction; this value is transferred to the parser as the 'token value' when the parser consumes the lexer token produced through a call to the `lex()` API.
    offset: 0,                                  // READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: tracks the 'cursor position' in the input string, i.e. the number of characters matched so far
    yyleng: 0,                                  // READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: length of matched input for the token under construction (`yytext`)
    yylineno: 0,                                // READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: 'line number' at which the token under construction is located
    yylloc: null,                               // READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: tracks location info (lines + columns) for the token under construction

    // INTERNAL USE: construct a suitable error info hash object instance for `parseError`.
    /**
    @public 
    @this {RegExpLexer} 
    */
    constructLexErrorInfo: function lexer_constructLexErrorInfo(msg, recoverable) {
        /** @constructor */
        var pei = {
            errStr: msg,
            recoverable: !!recoverable,
            text: this.match,           // This one MAY be empty; userland code should use the `upcomingInput` API to obtain more text which follows the 'lexer cursor position'...
            token: null,
            line: this.yylineno,
            loc: this.yylloc,
            yy: this.yy,
            lexer: this,

            // and make sure the error info doesn't stay due to potential
            // ref cycle via userland code manipulations.
            // These would otherwise all be memory leak opportunities!
            //
            // Note that only array and object references are nuked as those
            // constitute the set of elements which can produce a cyclic ref.
            // The rest of the members is kept intact as they are harmless.
            /** 
            @public 
            @this {LexErrorInfo} 
            */
            destroy: function destructLexErrorInfo() {
                // remove cyclic references added to error info:
                // info.yy = null;
                // info.lexer = null;
                // ...
                var rec = !!this.recoverable;
                for (var key in this) {
                    if (this.hasOwnProperty(key) && typeof key === 'object') {
                        this[key] = undefined;
                    }
                }
                this.recoverable = rec;
            }
        };
        // track this instance so we can `destroy()` it once we deem it superfluous and ready for garbage collection!
        this.__error_infos.push(pei);
        return pei;
    },

    /** 
    @public 
    @this {RegExpLexer} 
    */
    parseError: function lexer_parseError(str, hash, ExceptionClass) {
        if (this.yy.parser && typeof this.yy.parser.parseError === 'function') {
            return this.yy.parser.parseError(str, hash, ExceptionClass) || this.ERROR;
        } else if (typeof this.yy.parseError === 'function') {
            return this.yy.parseError(str, hash, ExceptionClass) || this.ERROR;
        } else {
            throw new ExceptionClass(str, hash);
        }
    },

    // final cleanup function for when we have completed lexing the input;
    // make it an API so that external code can use this one once userland
    // code has decided it's time to destroy any lingering lexer error
    // hash object instances and the like: this function helps to clean
    // up these constructs, which *may* carry cyclic references which would
    // otherwise prevent the instances from being properly and timely
    // garbage-collected, i.e. this function helps prevent memory leaks!
    /** 
    @public 
    @this {RegExpLexer} 
    */
    cleanupAfterLex: function lexer_cleanupAfterLex(do_not_nuke_errorinfos) {
        var rv;

        // prevent lingering circular references from causing memory leaks:
        this.setInput('', {});

        // nuke the error hash info instances created during this run.
        // Userland code must COPY any data/references
        // in the error hash instance(s) it is more permanently interested in.
        if (!do_not_nuke_errorinfos) {
            for (var i = this.__error_infos.length - 1; i >= 0; i--) {
                var el = this.__error_infos[i];
                if (el && typeof el.destroy === 'function') {
                    el.destroy();
                }
            }
            this.__error_infos.length = 0;
        }

        return this;
    },

    // clear the lexer token context; intended for internal use only
    /** 
    @public 
    @this {RegExpLexer} 
    */
    clear: function lexer_clear() {
        this.yytext = '';
        this.yyleng = 0;
        this.match = '';
        this.matches = false;
        this._more = false;
        this._backtrack = false;
    },

    // resets the lexer, sets new input
    /** 
    @public 
    @this {RegExpLexer} 
    */
    setInput: function lexer_setInput(input, yy) {
        this.yy = yy || this.yy || {};

        // also check if we've fully initialized the lexer instance,
        // including expansion work to be done to go from a loaded
        // lexer to a usable lexer:
        if (!this.__decompressed) {
          // step 1: decompress the regex list:
          var rules = this.rules;
          for (var i = 0, len = rules.length; i < len; i++) {
            var rule_re = rules[i];

            // compression: is the RE an xref to another RE slot in the rules[] table?
            if (typeof rule_re === 'number') {
              rules[i] = rules[rule_re];
            }
          }

          // step 2: unfold the conditions[] set to make these ready for use:
          var conditions = this.conditions;
          for (var k in conditions) {
            var spec = conditions[k];

            var rule_ids = spec.rules;

            var len = rule_ids.length;
            var rule_regexes = new Array(len + 1);            // slot 0 is unused; we use a 1-based index approach here to keep the hottest code in `lexer_next()` fast and simple!
            var rule_new_ids = new Array(len + 1);

            for (var i = 0; i < len; i++) {
              var idx = rule_ids[i];
              var rule_re = rules[idx];
              rule_regexes[i + 1] = rule_re;
              rule_new_ids[i + 1] = idx;
            }

            spec.rules = rule_new_ids;
            spec.__rule_regexes = rule_regexes;
            spec.__rule_count = len;
          }

          this.__decompressed = true;
        }

        this._input = input || '';
        this.clear();
        this._signaled_error_token = false;
        this.done = false;
        this.yylineno = 0;
        this.matched = '';
        this.conditionStack = ['INITIAL'];
        this.__currentRuleSet__ = null;
        this.yylloc = {
            first_line: 1,
            first_column: 0,
            last_line: 1,
            last_column: 0
        };
        if (this.options.ranges) {
            this.yylloc.range = [0, 0];
        }
        this.offset = 0;
        return this;
    },

    // consumes and returns one char from the input
    /** 
    @public 
    @this {RegExpLexer} 
    */
    input: function lexer_input() {
        if (!this._input) {
            //this.done = true;    -- don't set `done` as we want the lex()/next() API to be able to produce one custom EOF token match after this anyhow. (lexer can match special <<EOF>> tokens and perform user action code for a <<EOF>> match, but only does so *once*)
            return null;
        }
        var ch = this._input[0];
        this.yytext += ch;
        this.yyleng++;
        this.offset++;
        this.match += ch;
        this.matched += ch;
        // Count the linenumber up when we hit the LF (or a stand-alone CR).
        // On CRLF, the linenumber is incremented when you fetch the CR or the CRLF combo
        // and we advance immediately past the LF as well, returning both together as if
        // it was all a single 'character' only.
        var slice_len = 1;
        var lines = false;
        if (ch === '\n') {
            lines = true;
        } else if (ch === '\r') {
            lines = true;
            var ch2 = this._input[1];
            if (ch2 === '\n') {
                slice_len++;
                ch += ch2;
                this.yytext += ch2;
                this.yyleng++;
                this.offset++;
                this.match += ch2;
                this.matched += ch2;
                if (this.options.ranges) {
                    this.yylloc.range[1]++;
                }
            }
        }
        if (lines) {
            this.yylineno++;
            this.yylloc.last_line++;
        } else {
            this.yylloc.last_column++;
        }
        if (this.options.ranges) {
            this.yylloc.range[1]++;
        }

        this._input = this._input.slice(slice_len);
        return ch;
    },

    // unshifts one char (or a string) into the input
    /** 
    @public 
    @this {RegExpLexer} 
    */
    unput: function lexer_unput(ch) {
        var len = ch.length;
        var lines = ch.split(/(?:\r\n?|\n)/g);

        this._input = ch + this._input;
        this.yytext = this.yytext.substr(0, this.yytext.length - len);
        //this.yyleng -= len;
        this.offset -= len;
        var oldLines = this.match.split(/(?:\r\n?|\n)/g);
        this.match = this.match.substr(0, this.match.length - len);
        this.matched = this.matched.substr(0, this.matched.length - len);

        if (lines.length - 1) {
            this.yylineno -= lines.length - 1;
        }

        this.yylloc.last_line = this.yylineno + 1;
        this.yylloc.last_column = (lines ?
                (lines.length === oldLines.length ? this.yylloc.first_column : 0)
                + oldLines[oldLines.length - lines.length].length - lines[0].length :
                this.yylloc.first_column - len);

        if (this.options.ranges) {
            this.yylloc.range[1] = this.yylloc.range[0] + this.yyleng - len;
        }
        this.yyleng = this.yytext.length;
        this.done = false;
        return this;
    },

    // When called from action, caches matched text and appends it on next action
    /** 
    @public 
    @this {RegExpLexer} 
    */
    more: function lexer_more() {
        this._more = true;
        return this;
    },

    // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
    /** 
    @public 
    @this {RegExpLexer} 
    */
    reject: function lexer_reject() {
        if (this.options.backtrack_lexer) {
            this._backtrack = true;
        } else {
            // when the `parseError()` call returns, we MUST ensure that the error is registered.
            // We accomplish this by signaling an 'error' token to be produced for the current
            // `.lex()` run.
            var p = this.constructLexErrorInfo('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), false);
            this._signaled_error_token = (this.parseError(p.errStr, p, this.JisonLexerError) || this.ERROR);
        }
        return this;
    },

    // retain first n characters of the match
    /** 
    @public 
    @this {RegExpLexer} 
    */
    less: function lexer_less(n) {
        return this.unput(this.match.slice(n));
    },

    // return (part of the) already matched input, i.e. for error messages.
    // Limit the returned string length to `maxSize` (default: 20).
    // Limit the returned string to the `maxLines` number of lines of input (default: 1).
    // Negative limit values equal *unlimited*.
    /** 
    @public 
    @this {RegExpLexer} 
    */
    pastInput: function lexer_pastInput(maxSize, maxLines) {
        var past = this.matched.substring(0, this.matched.length - this.match.length);
        if (maxSize < 0)
            maxSize = past.length;
        else if (!maxSize)
            maxSize = 20;
        if (maxLines < 0)
            maxLines = past.length;         // can't ever have more input lines than this!
        else if (!maxLines)
            maxLines = 1;
        // `substr` anticipation: treat \r\n as a single character and take a little
        // more than necessary so that we can still properly check against maxSize
        // after we've transformed and limited the newLines in here:
        past = past.substr(-maxSize * 2 - 2);
        // now that we have a significantly reduced string to process, transform the newlines
        // and chop them, then limit them:
        var a = past.replace(/\r\n|\r/g, '\n').split('\n');
        a = a.slice(-maxLines);
        past = a.join('\n');
        // When, after limiting to maxLines, we still have too much to return,
        // do add an ellipsis prefix...
        if (past.length > maxSize) {
            past = '...' + past.substr(-maxSize);
        }
        return past;
    },

    // return (part of the) upcoming input, i.e. for error messages.
    // Limit the returned string length to `maxSize` (default: 20).
    // Limit the returned string to the `maxLines` number of lines of input (default: 1).
    // Negative limit values equal *unlimited*.
    /** 
    @public 
    @this {RegExpLexer} 
    */
    upcomingInput: function lexer_upcomingInput(maxSize, maxLines) {
        var next = this.match;
        if (maxSize < 0)
            maxSize = next.length + this._input.length;
        else if (!maxSize)
            maxSize = 20;
        if (maxLines < 0)
            maxLines = maxSize;         // can't ever have more input lines than this!
        else if (!maxLines)
            maxLines = 1;
        // `substring` anticipation: treat \r\n as a single character and take a little
        // more than necessary so that we can still properly check against maxSize
        // after we've transformed and limited the newLines in here:
        if (next.length < maxSize * 2 + 2) {
            next += this._input.substring(0, maxSize * 2 + 2);  // substring is faster on Chrome/V8
        }
        // now that we have a significantly reduced string to process, transform the newlines
        // and chop them, then limit them:
        var a = next.replace(/\r\n|\r/g, '\n').split('\n');
        a = a.slice(0, maxLines);
        next = a.join('\n');
        // When, after limiting to maxLines, we still have too much to return,
        // do add an ellipsis postfix...
        if (next.length > maxSize) {
            next = next.substring(0, maxSize) + '...';
        }
        return next;
    },

    // return a string which displays the character position where the lexing error occurred, i.e. for error messages
    /** 
    @public 
    @this {RegExpLexer} 
    */
    showPosition: function lexer_showPosition(maxPrefix, maxPostfix) {
        var pre = this.pastInput(maxPrefix).replace(/\s/g, ' ');
        var c = new Array(pre.length + 1).join('-');
        return pre + this.upcomingInput(maxPostfix).replace(/\s/g, ' ') + '\n' + c + '^';
    },

    // helper function, used to produce a human readable description as a string, given
    // the input `yylloc` location object.
    // Set `display_range_too` to TRUE to include the string character index position(s)
    // in the description if the `yylloc.range` is available.
    /** 
    @public 
    @this {RegExpLexer} 
    */
    describeYYLLOC: function lexer_describe_yylloc(yylloc, display_range_too) {
        var l1 = yylloc.first_line;
        var l2 = yylloc.last_line;
        var o1 = yylloc.first_column;
        var o2 = yylloc.last_column - 1;
        var dl = l2 - l1;
        var d_o = (dl === 0 ? o2 - o1 : 1000);
        var rv;
        if (dl === 0) {
            rv = 'line ' + l1 + ', ';
            if (d_o === 0) {
                rv += 'column ' + o1;
            } else {
                rv += 'columns ' + o1 + ' .. ' + o2;
            }
        } else {
            rv = 'lines ' + l1 + '(column ' + o1 + ') .. ' + l2 + '(column ' + o2 + ')';
        }
        if (yylloc.range && display_range_too) {
            var r1 = yylloc.range[0];
            var r2 = yylloc.range[1] - 1;
            if (r2 === r1) {
                rv += ' {String Offset: ' + r1 + '}';
            } else {
                rv += ' {String Offset range: ' + r1 + ' .. ' + r2 + '}';
            }
        }
        return rv;
        // return JSON.stringify(yylloc);
    },

    // test the lexed token: return FALSE when not a match, otherwise return token.
    //
    // `match` is supposed to be an array coming out of a regex match, i.e. `match[0]`
    // contains the actually matched text string.
    //
    // Also move the input cursor forward and update the match collectors:
    // - yytext
    // - yyleng
    // - match
    // - matches
    // - yylloc
    // - offset
    /** 
    @public 
    @this {RegExpLexer} 
    */
    test_match: function lexer_test_match(match, indexed_rule) {
        var token,
            lines,
            backup,
            match_str,
            match_str_len;

        if (this.options.backtrack_lexer) {
            // save context
            backup = {
                yylineno: this.yylineno,
                yylloc: {
                    first_line: this.yylloc.first_line,
                    last_line: this.last_line,
                    first_column: this.yylloc.first_column,
                    last_column: this.yylloc.last_column
                },
                yytext: this.yytext,
                match: this.match,
                matches: this.matches,
                matched: this.matched,
                yyleng: this.yyleng,
                offset: this.offset,
                _more: this._more,
                _input: this._input,
                yy: this.yy,
                conditionStack: this.conditionStack.slice(0),
                done: this.done
            };
            if (this.options.ranges) {
                backup.yylloc.range = this.yylloc.range.slice(0);
            }
        }

        match_str = match[0];
        match_str_len = match_str.length;
        // if (match_str.indexOf('\n') !== -1 || match_str.indexOf('\r') !== -1) {
            lines = match_str.match(/(?:\r\n?|\n).*/g);
            if (lines) {
                this.yylineno += lines.length;
            }
        // }
        this.yylloc = {
            first_line: this.yylloc.last_line,
            last_line: this.yylineno + 1,
            first_column: this.yylloc.last_column,
            last_column: lines ?
                         lines[lines.length - 1].length - lines[lines.length - 1].match(/^\r?\n?/)[0].length :
                         this.yylloc.last_column + match_str_len
        };
        this.yytext += match_str;
        this.match += match_str;
        this.matches = match;
        this.yyleng = this.yytext.length;
        if (this.options.ranges) {
            this.yylloc.range = [this.offset, this.offset + this.yyleng];
        }
        // previous lex rules MAY have invoked the `more()` API rather than producing a token:
        // those rules will already have moved this `offset` forward matching their match lengths,
        // hence we must only add our own match length now:
        this.offset += match_str_len;
        this._more = false;
        this._backtrack = false;
        this._input = this._input.slice(match_str_len);
        this.matched += match_str;

        // calling this method:
        //
        //   function lexer__performAction(yy, yy_, $avoiding_name_collisions, YY_START) {...}
        token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1] /* = YY_START */);
        // otherwise, when the action codes are all simple return token statements:
        //token = this.simpleCaseActionClusters[indexed_rule];

        if (this.done && this._input) {
            this.done = false;
        }
        if (token) {
            return token;
        } else if (this._backtrack) {
            // recover context
            for (var k in backup) {
                this[k] = backup[k];
            }
            this.__currentRuleSet__ = null;
            return false; // rule action called reject() implying the next rule should be tested instead.
        } else if (this._signaled_error_token) {
            // produce one 'error' token as `.parseError()` in `reject()` did not guarantee a failure signal by throwing an exception!
            token = this._signaled_error_token;
            this._signaled_error_token = false;
            return token;
        }
        return false;
    },

    // return next match in input
    /** 
    @public 
    @this {RegExpLexer} 
    */
    next: function lexer_next() {
        if (this.done) {
            this.clear();
            return this.EOF;
        }
        if (!this._input) {
            this.done = true;
        }

        var token,
            match,
            tempMatch,
            index;
        if (!this._more) {
            this.clear();
        }
        var spec = this.__currentRuleSet__;
        if (!spec) {
            // Update the ruleset cache as we apparently encountered a state change or just started lexing.
            // The cache is set up for fast lookup -- we assume a lexer will switch states much less often than it will
            // invoke the `lex()` token-producing API and related APIs, hence caching the set for direct access helps
            // speed up those activities a tiny bit.
            spec = this.__currentRuleSet__ = this._currentRules();
            // Check whether a *sane* condition has been pushed before: this makes the lexer robust against
            // user-programmer bugs such as https://github.com/zaach/jison-lex/issues/19
            if (!spec || !spec.rules) {
                var p = this.constructLexErrorInfo('Internal lexer engine error on line ' + (this.yylineno + 1) + '. The lex grammar programmer pushed a non-existing condition name "' + this.topState() + '"; this is a fatal error and should be reported to the application programmer team!\n', false);
                // produce one 'error' token until this situation has been resolved, most probably by parse termination!
                return (this.parseError(p.errStr, p, this.JisonLexerError) || this.ERROR);
            }
        }

        var rule_ids = spec.rules;
        //var dispatch = spec.__dispatch_lut;
        var regexes = spec.__rule_regexes;
        var len = spec.__rule_count;

        //var c0 = this._input[0];

        // Note: the arrays are 1-based, while `len` itself is a valid index,
        // hence the non-standard less-or-equal check in the next loop condition!
        //
        // `dispatch` is a lookup table which lists the *first* rule which matches the 1-char *prefix* of the rule-to-match.
        // By using that array as a jumpstart, we can cut down on the otherwise O(n*m) behaviour of this lexer, down to
        // O(n) ideally, where:
        //
        // - N is the number of input particles -- which is not precisely characters
        //   as we progress on a per-regex-match basis rather than on a per-character basis
        //
        // - M is the number of rules (regexes) to test in the active condition state.
        //
        for (var i = 1 /* (dispatch[c0] || 1) */ ; i <= len; i++) {
            tempMatch = this._input.match(regexes[i]);
            if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
                match = tempMatch;
                index = i;
                if (this.options.backtrack_lexer) {
                    token = this.test_match(tempMatch, rule_ids[i]);
                    if (token !== false) {
                        return token;
                    } else if (this._backtrack) {
                        match = undefined;
                        continue; // rule action called reject() implying a rule MISmatch.
                    } else {
                        // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                        return false;
                    }
                } else if (!this.options.flex) {
                    break;
                }
            }
        }
        if (match) {
            token = this.test_match(match, rule_ids[index]);
            if (token !== false) {
                return token;
            }
            // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
            return false;
        }
        if (this._input === '') {
            this.done = true;
            return this.EOF;
        } else {
            var p = this.constructLexErrorInfo('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), this.options.lexer_errors_are_recoverable);
            token = (this.parseError(p.errStr, p, this.JisonLexerError) || this.ERROR);
            if (token === this.ERROR) {
                // we can try to recover from a lexer error that `parseError()` did not 'recover' for us
                // by moving forward at least one character at a time:
                if (!this.match.length) {
                    this.input();
                }
            }
            return token;
        }
    },

    // return next match that has a token
    /** 
    @public 
    @this {RegExpLexer} 
    */
    lex: function lexer_lex() {
        var r;
        // allow the PRE/POST handlers set/modify the return token for maximum flexibility of the generated lexer:
        if (typeof this.options.pre_lex === 'function') {
            r = this.options.pre_lex.call(this);
        }
        while (!r) {
            r = this.next();
        }
        if (typeof this.options.post_lex === 'function') {
            // (also account for a userdef function which does not return any value: keep the token as is)
            r = this.options.post_lex.call(this, r) || r;
        }
        return r;
    },

    // backwards compatible alias for `pushState()`;
    // the latter is symmetrical with `popState()` and we advise to use
    // those APIs in any modern lexer code, rather than `begin()`.
    /** 
    @public 
    @this {RegExpLexer} 
    */
    begin: function lexer_begin(condition) {
        return this.pushState(condition);
    },

    // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
    /** 
    @public 
    @this {RegExpLexer} 
    */
    pushState: function lexer_pushState(condition) {
        this.conditionStack.push(condition);
        this.__currentRuleSet__ = null;
        return this;
    },

    // pop the previously active lexer condition state off the condition stack
    /** 
    @public 
    @this {RegExpLexer} 
    */
    popState: function lexer_popState() {
        var n = this.conditionStack.length - 1;
        if (n > 0) {
            this.__currentRuleSet__ = null;
            return this.conditionStack.pop();
        } else {
            return this.conditionStack[0];
        }
    },

    // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
    /** 
    @public 
    @this {RegExpLexer} 
    */
    topState: function lexer_topState(n) {
        n = this.conditionStack.length - 1 - Math.abs(n || 0);
        if (n >= 0) {
            return this.conditionStack[n];
        } else {
            return 'INITIAL';
        }
    },

    // (internal) determine the lexer rule set which is active for the currently active lexer condition state
    /** 
    @public 
    @this {RegExpLexer} 
    */
    _currentRules: function lexer__currentRules() {
        if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
            return this.conditions[this.conditionStack[this.conditionStack.length - 1]];
        } else {
            return this.conditions['INITIAL'];
        }
    },

    // return the number of states currently on the stack
    /** 
    @public 
    @this {RegExpLexer} 
    */
    stateStackSize: function lexer_stateStackSize() {
        return this.conditionStack.length;
    },
    options: {},
    JisonLexerError: JisonLexerError,
    performAction: function lexer__performAction(yy, yy_, $avoiding_name_collisions, YY_START) {

var YYSTATE = YY_START;
switch($avoiding_name_collisions) {
case 0 : 
/*! Conditions:: INITIAL */ 
/*! Rule::       \s+ */ 
 /* skip whitespace */ 
break;
case 27 : 
/*! Conditions:: INITIAL */ 
/*! Rule::       {StringLiteral} */ 
 yy_.yytext = stringUnescape(yy_.yytext.substr(1, yy_.yyleng - 2)); return 25 
break;
case 28 : 
/*! Conditions:: INITIAL */ 
/*! Rule::       {BackTickIdentifier} */ 
 yy_.yytext = stringUnescape(yy_.yytext.substr(1, yy_.yyleng - 2)); return 26 
break;
case 29 : 
/*! Conditions:: INITIAL */ 
/*! Rule::       {Identifier} */ 
 yy_.yytext = stringUnescape(yy_.yytext); return 26 
break;
default:
  return this.simpleCaseActionClusters[$avoiding_name_collisions];
}
},
    simpleCaseActionClusters: {

  /*! Conditions:: INITIAL */ 
  /*! Rule::       (-)?[0-9]+(\.[0-9]+)?\b */ 
   1 : 24,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       \|\| */ 
   2 : 16,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       && */ 
   3 : 17,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       === */ 
   4 : 20,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       !== */ 
   5 : 21,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       == */ 
   6 : 18,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       != */ 
   7 : 19,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       <= */ 
   8 : 22,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       >= */ 
   9 : 23,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       < */ 
   10 : 4,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       > */ 
   11 : 5,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       \+\+ */ 
   12 : 15,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       -- */ 
   13 : 14,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       \+ */ 
   14 : 6,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       ! */ 
   15 : 7,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       \( */ 
   16 : 8,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       \) */ 
   17 : 9,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       true */ 
   18 : 27,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       false */ 
   19 : 28,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       undefined */ 
   20 : 29,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       null */ 
   21 : 30,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       , */ 
   22 : 13,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       \. */ 
   23 : 12,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       \[ */ 
   24 : 10,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       \] */ 
   25 : 11,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       : */ 
   26 : 3,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       $ */ 
   30 : 1,
  /*! Conditions:: INITIAL */ 
  /*! Rule::       . */ 
   31 : 'INVALID'
},
    rules: [
/^(?:\s+)/,
/^(?:(-)?\d+(\.\d+)?\b)/,
/^(?:\|\|)/,
/^(?:&&)/,
/^(?:===)/,
/^(?:!==)/,
/^(?:==)/,
/^(?:!=)/,
/^(?:<=)/,
/^(?:>=)/,
/^(?:<)/,
/^(?:>)/,
/^(?:\+\+)/,
/^(?:--)/,
/^(?:\+)/,
/^(?:!)/,
/^(?:\()/,
/^(?:\))/,
/^(?:true)/,
/^(?:false)/,
/^(?:undefined)/,
/^(?:null)/,
/^(?:,)/,
/^(?:\.)/,
/^(?:\[)/,
/^(?:\])/,
/^(?::)/,
/^(?:(("(?:([^\n\r"\\]+)|(\\(?:(?:(?:["'\\bfnrtv])|(?:[^\d"'\\bfnrt-vx]))|(?:[x](?:[\dA-Fa-f]){2})|(?:[u](?:[\dA-Fa-f]){4}))))*")|('(?:([^\n\r'\\]+)|(\\(?:(?:(?:["'\\bfnrtv])|(?:[^\d"'\\bfnrt-vx]))|(?:[x](?:[\dA-Fa-f]){2})|(?:[u](?:[\dA-Fa-f]){4}))))*')))/,
/^(?:((`(?:([^\n\r\\`]+)|(\\(?:(?:(?:["'\\bfnrtv])|(?:[^\d"'\\bfnrt-vx]))|(?:[x](?:[\dA-Fa-f]){2})|(?:[u](?:[\dA-Fa-f]){4}))))*`)))/,
/^(?:((?:[$A-Z_a-z]|(\\(?:(?:(?:["'\\bfnrtv])|(?:[^\d"'\\bfnrt-vx]))|(?:[x](?:[\dA-Fa-f]){2})|(?:[u](?:[\dA-Fa-f]){4}))))(?:(?:[$A-Z_a-z]|(\\(?:(?:(?:["'\\bfnrtv])|(?:[^\d"'\\bfnrt-vx]))|(?:[x](?:[\dA-Fa-f]){2})|(?:[u](?:[\dA-Fa-f]){4}))))|\d)*))/,
/^(?:$)/,
/^(?:.)/
],
    conditions: {
  "INITIAL": {
    rules: [
      0,
      1,
      2,
      3,
      4,
      5,
      6,
      7,
      8,
      9,
      10,
      11,
      12,
      13,
      14,
      15,
      16,
      17,
      18,
      19,
      20,
      21,
      22,
      23,
      24,
      25,
      26,
      27,
      28,
      29,
      30,
      31
    ],
    inclusive: true
  }
}
};




return lexer;
})();
parser.lexer = lexer;

function Parser() {
  this.yy = {};
}
Parser.prototype = parser;
parser.Parser = Parser;

return new Parser();
})();




if (typeof require !== 'undefined' && typeof exports !== 'undefined') {
  exports.parser = parser;
  exports.Parser = parser.Parser;
  exports.parse = function () {
    return parser.parse.apply(parser, arguments);
  };

}

},{}],2:[function(require,module,exports){
// Barbiche
// version: 3.0.11
// author: Manuel Baclet <mbaclet@gmail.com>
// license: MIT

'use strict';

/* Constants */

var attrs = ['if', 'alias', 'text', 'html', 'repeat', 'import', 'attr', 'class'];
var BB_IF = 0, BB_ALIAS = 1, BB_TEXT = 2, BB_HTML = 3,
    BB_REPEAT = 4, BB_IMPORT = 5, BB_ATTR = 6, BB_CLASS = 7;

var globalAttr = 'global';
var elseAttr = 'else';
var inertAttr = 'inert';

var TEMPLATE = 'TEMPLATE';

var ELEMENT_NODE = Node.ELEMENT_NODE, TEXT_NODE = Node.TEXT_NODE,
    COMMENT_NODE = Node.COMMENT_NODE, DOCUMENT_FRAGMENT_NODE = Node.DOCUMENT_FRAGMENT_NODE;

var ArrayFrom = Array.prototype.slice;

function createTemplate(ownerDoc) {
	return ownerDoc.createElement(TEMPLATE);
}

/* Shared context */

var context = {
	stack: null,
	resolve: function(identifier) {
		for (var i = this.stack.length - 1; i >= 0; --i) {
			if (identifier in this.stack[i]) return this.stack[i][identifier];
		}
	},
	get: function() {
		return this.stack;
	},
	set: function(arr) {
		this.stack = arr;
	},
	push: function(obj) {
		this.stack.push(obj);
	},
	pop: function() {
		this.stack.pop();
	}
};

/* BBObj class */

function BBObj(a, b) {
	this.value = a;
	this.name = b;
}

BBObj.prototype.toString = function() {
	if (this.value && this.name != null) return this.name.toString();
	else return '';
};

/* Shared Parser */

var Parser = require('../parser.js');
Parser.parser.yy.context = context;
Parser.parser.yy.BBObj = BBObj;

/* Curly braces parsing error */

function ParseError(res) {
	this.message = 'Unexpected characters "' + res[0] + '":\n' +
		res.input.replace(/\t|\n/g, '.') + '\n' + (new Array(res.index + 1).join('-')) + '^';
	this.name = 'ParseError';
}

/* Barbiche instance builder */

function Barbiche(opt) {
	opt = opt || {};
	var doc = opt.document || document;
	var prefix = opt.prefix || 'bb-';
	var destructive = (opt.destructive !== undefined) ? !!opt.destructive : true;

	var prefixedAttrs = attrs.map(function(str) {
		return prefix + str;
	});
	var prefixedAttrsObj = Object.create(null);
	prefixedAttrs.forEach(function(attr, index) {
		prefixedAttrsObj[attr] = attrs[index];
	});

	var prefixedGlobalAttr = prefix + globalAttr;
	var prefixedGlobalAttrSelector = '[' + prefixedGlobalAttr + ']';
	var prefixedElseAttr = prefix + elseAttr;
	var prefixedInertAttr = prefix + inertAttr;

	var store = Object.create(null);

	/* Compilation helpers */

	var compile_works = Object.create(null);
	compile_works[ELEMENT_NODE] = function(node, template) {
		if (node.hasAttribute(prefixedAttrs[BB_REPEAT]) &&
			(node.nodeName !== TEMPLATE || node.hasAttribute(prefixedInertAttr))) {

			if (node.hasAttribute(prefixedAttrs[BB_TEXT]) || node.hasAttribute(prefixedAttrs[BB_HTML]))
				node.removeAttribute(prefixedAttrs[BB_REPEAT]);
			else {
				var wrapper = createTemplate(node.ownerDocument);
				wrapper.setAttribute(prefixedAttrs[BB_REPEAT], node.getAttribute(prefixedAttrs[BB_REPEAT]));
				node.removeAttribute(prefixedAttrs[BB_REPEAT]);
				[prefixedAttrs[BB_IF], prefixedAttrs[BB_ALIAS], prefixedElseAttr].forEach(function(attr) {
					if (node.hasAttribute(attr)) {
						wrapper.setAttribute(attr, node.getAttribute(attr));
						node.removeAttribute(attr);
					}
				});
				node.parentNode.insertBefore(wrapper, node);
				wrapper.content.appendChild(node);
				node = wrapper;
			}
		}
		var bbAttrs;
		function setAttr(name, value) {
			if (!bbAttrs) bbAttrs = Object.create(null);
			bbAttrs[prefixedAttrsObj[name]] = template._addClosure(Parser.parse(value));
			node.removeAttribute(name);
		}
		if (node.attributes.length > attrs.length) {
			prefixedAttrs.forEach(function(attr) {
				if (node.hasAttribute(attr)) setAttr(attr, node.getAttribute(attr));
			});
		} else {
			for (var i = node.attributes.length - 1; i >= 0; --i) {
				var attr = node.attributes[i].name;
				if (attr in prefixedAttrsObj) setAttr(attr, node.attributes[i].value);
			}
		}
		if (!bbAttrs && node.nodeName === TEMPLATE &&
			(node.hasAttribute(prefixedElseAttr) || node.hasAttribute(prefixedInertAttr))) {
			bbAttrs = Object.create(null);
		}

		if (bbAttrs) node.setAttribute(prefixedGlobalAttr, JSON.stringify(bbAttrs));
		if (node.nodeName === TEMPLATE) {
			compile(node.content, template);
			if (!bbAttrs) node.parentNode.replaceChild(node.content, node);
		} else {
			ArrayFrom.call(node.childNodes).forEach(function(child) {
				compile(child, template);
			});
		}
	};

	compile_works[TEXT_NODE] = (function() {
		var delimiters = opt.delimiters || ['{', '}'];

		function regExpEscape(str) {
			return str.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
		}

		var textHTMLTable = {
			'\\': '\\\\'
		};
		textHTMLTable[delimiters[0]] = delimiters[0];
		textHTMLTable[delimiters[1]] = delimiters[1];

		var UnescapeDelimitersRegExp = new RegExp('\\\\(' +
			['\\\\', regExpEscape(delimiters[0]), regExpEscape(delimiters[1])].join('|') +
		')', 'g');
		function unescapePlainText(str) {
			return str.replace(UnescapeDelimitersRegExp, function() {return arguments[1];});
		}
		function unescapeTextHTML(str) {
			return str.replace(UnescapeDelimitersRegExp, function() {return textHTMLTable[arguments[1]];});
		}

		var regExpTemplate = [
			'aaa((?:a|f|c|d|e|b(?:a|f|c|d|e|b(?:a|f|c|d|e)))*)bbb',
			'aa((?:a|f|c|d|e|b(?:a|f|c|d|e))*)bb',
			'((?:b|f|c|d|e|a(?:b|f|c|d|e))(?:b|f|c|d|e|a(?:b|f|c|d|e))*(?:a(?!a)|b|f|c|d|e||a(?:b|f|c|d|e))' +
			'|(?:a(?!a)))',
			'(.+)'
		];
		var table = {
			a: regExpEscape(delimiters[0]),
			b: regExpEscape(delimiters[1]),
			c: regExpEscape('\\' + delimiters[0]),
			d: regExpEscape('\\' + delimiters[1]),
			e: '[^' + regExpEscape(delimiters[0]) + regExpEscape(delimiters[1]) + ']',
			f: regExpEscape('\\\\')
		};

		var textNodeRegExp = new RegExp(regExpTemplate.map(function(str) {
			return '(?:' +
				str.replace(/a|b|c|d|e|f/g, function() {return table[arguments[0]];}) + ')';
		}).join('|'), 'g');

		var match, newNode;
		return function(node, template) {
			while((match = textNodeRegExp.exec(node.nodeValue))) {
				if (match[3]) {
					newNode = node.ownerDocument.createTextNode(unescapePlainText(match[3]));
					node.parentNode.insertBefore(newNode, node);
				} else if (match[2]) {
					newNode = createTemplate(node.ownerDocument);
					newNode.setAttribute(prefixedAttrs[BB_TEXT], unescapeTextHTML(match[2]));
					node.parentNode.insertBefore(newNode, node);
					compile(newNode, template);
				} else if (match[1]) {
					newNode = createTemplate(node.ownerDocument);
					newNode.setAttribute(prefixedAttrs[BB_HTML], unescapeTextHTML(match[1]));
					node.parentNode.insertBefore(newNode, node);
					compile(newNode, template);
				} else {
					textNodeRegExp.lastIndex = 0;
					throw new ParseError(match);
				}
			}
			node.parentNode.removeChild(node);
		};
	})();

	compile_works[COMMENT_NODE] = function(node, template) {};

	compile_works[DOCUMENT_FRAGMENT_NODE] = function(node, template) {
		ArrayFrom.call(node.childNodes).forEach(function(child) {compile(child, template);});
	};

	function compile(node, template) {
		(compile_works[node.nodeType])(node, template);
	}

	/* Merge helpers */

	var works = Object.create(null);
	works[ELEMENT_NODE] = (function() {
		var child, bbAttrs, value;
		var draft = createTemplate(doc);
		return function(node, template) {
			var nodeContext;
			bbAttrs = JSON.parse(node.getAttribute(prefixedGlobalAttr));
			node.removeAttribute(prefixedGlobalAttr);
			if (bbAttrs.if) {
				value = (template.closures[bbAttrs.if])();
				if (node.nextElementSibling && node.nextElementSibling.hasAttribute(prefixedElseAttr)) {
					if (value) node.parentNode.removeChild(node.nextElementSibling);
					else {
						node.nextElementSibling.removeAttribute(prefixedElseAttr);
						return node.parentNode.removeChild(node);
					}
				} else if (!value) return node.parentNode.removeChild(node);
			}
			if (bbAttrs.alias) {
				value = (template.closures[bbAttrs.alias])();
				if (!Array.isArray(value)) value = [value];
				nodeContext = Object.create(null);
				context.push(nodeContext);
				value.forEach(function(item) {
					nodeContext[item.name] = item.value;
				});
			}
			if (bbAttrs.text) {
				value = (template.closures[bbAttrs.text])();
				if (value != null) {
					node.parentNode.replaceChild(node.ownerDocument.createTextNode(value), node);
				} else node.parentNode.removeChild(node);
			} else if (bbAttrs.html) {
				value = (template.closures[bbAttrs.html])();
				if (value instanceof Node) node.parentNode.replaceChild(value, node);
				else if (value != null) {
					draft.innerHTML = value;
					node.parentNode.replaceChild(draft.content, node);
				} else node.parentNode.removeChild(node);
			} else if (node.nodeName === TEMPLATE && !node.hasAttribute(prefixedInertAttr)) {
				if (bbAttrs.repeat) {
					if (!nodeContext) {
						nodeContext = Object.create(null);
						context.push(nodeContext);
					}
					value = (template.closures[bbAttrs.repeat])();
					var after = (value._order === 'after');
					if (!Array.isArray(value)) value = [value];

					var reduceInit = (function(str) {
						var closure = template.closures[str];
						if (closure) return function() {
							var clone = Template(closure())._clone();
							node.parentNode.insertBefore(
								works[DOCUMENT_FRAGMENT_NODE](clone.node.content, clone),
								after ? node.nextSibling : node
							);
						}; else return function() {
							node.parentNode.insertBefore(
								works[DOCUMENT_FRAGMENT_NODE](
									node.cloneNode(true).content,
									template
								),
								after ? node.nextSibling : node
							);
						};
					})(bbAttrs.import);

					//iterate on cartesian product of arrays:
					(value.reduceRight(function(accu, task) {
						var alias = task.name;
						var value = task.value;
						if (value == null) value = [];
						return function() {
							value.forEach(function(item, index) {
								nodeContext[alias] = item;
								nodeContext['_' + alias + '_'] = index;
								accu();
							});
						};
					}, reduceInit))();
				} else if (bbAttrs.import) {
					value = (template.closures[bbAttrs.import])();
					var clone = Template(value)._clone();
					node.parentNode.insertBefore(
						works[DOCUMENT_FRAGMENT_NODE](clone.node.content, clone),
						node
					);
				} else {
					node.parentNode.insertBefore(
						works[DOCUMENT_FRAGMENT_NODE](node.content, template),
						node
					);
				}
				node.parentNode.removeChild(node);
			} else {
				if (bbAttrs.attr) {
					value = (template.closures[bbAttrs.attr])();
					if (!Array.isArray(value)) value = [value];
					value.forEach(function(item) {
						if (item.value != null && item.name != null) {
							var name = item.name.toString();
							if (name) node.setAttribute(name, item.value);
						}
					});
				}
				if (bbAttrs.class) {
					value = (template.closures[bbAttrs.class])();
					if (!Array.isArray(value)) value = [value];
					value.forEach(function(item) {
						if (item != null) {
							var value = item.toString();
							if (value) node.classList.add(value);
						}
					});
				}
				if (node.nodeName === TEMPLATE) {
					node.removeAttribute(prefixedInertAttr);
					works[DOCUMENT_FRAGMENT_NODE](node.content, template);
				} else {
					while((child = node.querySelector(prefixedGlobalAttrSelector))) {
						works[ELEMENT_NODE](child, template);
					}
				}
			}
			if (nodeContext) context.pop();
		};
	})();

	works[DOCUMENT_FRAGMENT_NODE] = (function() {
		var child;
		return function(node, template) {
			while((child = node.querySelector(prefixedGlobalAttrSelector))) {
				works[ELEMENT_NODE](child, template);
			}
			return node;
		};
	})();

	/* Template class */

	function Template(node) {
		if (node instanceof BBObj) {
			var name = node.name;
			if (name != null) name = name.toString();
			if (name && name in store) return store[name];
			else {
				var t = createTemplate(doc);
				t.innerHTML = node.value;
				if (name) t.id = name;
				node = t;
			}
		} else if (typeof(node) === 'string') {
			if (node in store) return store[node];
			else node = doc.querySelector('#' + node);
		}
		if (!(this instanceof Template)) {
			return new Template(node);
		}
		if (node instanceof HTMLTemplateElement) {
			if (node.id) store[node.id] = this;
			if (destructive) {
				this.node = node;
				if (node.parentNode) node.parentNode.removeChild(node);
			} else this.node = node.cloneNode(true);
			this.ready = false;
		} else {
			this.node = createTemplate(doc);
			this.ready = true;
		}
		this.closures = Object.create(null);
	}

	/* Statics */

	Template.bbObj = function(a, b) {return new BBObj(a, b);};

	Template.clean = function(name) {
		if (name === undefined) {
			for (var key in store) {
				delete store[key];
			}
		} else if (typeof(name) === 'string') delete store[name];
	};

	/* Public methods */

	Template.prototype.merge = function() {
		var clone = this._clone();
		var args = [];
		for (var i = 0; i < arguments.length; ++i) {
			if (arguments[i] != null) args.push(arguments[i]);
		}
		var savedContext = context.get();
		context.set(args);
		works[DOCUMENT_FRAGMENT_NODE](clone.node.content, clone);
		context.set(savedContext);
		return clone.node.content;
	};

	/* Private methods */

	Template.prototype._addClosure = (function() {
		var counter = 0;
		return function(fun) {
			var str = 'fun' + (++counter);
			this.closures[str] = fun;
			return str;
		};
	})();

	Template.prototype._compile = function() {
		compile(this.node.content, this);
		this.ready = true;
		return this;
	};

	Template.prototype._clone = function() {
		if (!this.ready) this._compile();
		return Object.create(Template.prototype, {
			node: {value: this.node.cloneNode(true)},
			closures: {value: this.closures},
			ready: {value: true}
		});
	};

	return Template;
}

module.exports = Barbiche;

},{"../parser.js":1}]},{},[2])(2)
});