{"version":3,"file":"static/module-reduce-css-calc.efe52dbb.js","mappings":"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A,EACA,EACA,EACAlB,EACA,CAAC,EAAG,CAAC,EACL,EACA,EACA,EACAkB,EACA,CAAC,GAAI,CAAC,EACNA,EACA,CAAC,GAAI,CAAC,EACN,EACA,EACA,CACF,CAAC,EACC,OAAQC,EAAE,CACV,EACA,EACA,EACA,GACA,GACAnB,EACA,CAAC,GAAI,GAAI,CAAC,EACV,EACA,EACAA,EACA,CAAC,EAAG,EAAG,CAAC,EACRkB,EACA,CAAC,GAAI,EAAE,EACPA,EACA,CAAC,GAAI,CAAC,EACN,EACA,EACA,GACA,GACAA,EACA,CAAC,GAAI,EAAE,EACPA,EACA,CAAC,GAAI,CAAC,EACNA,EACA,CAAC,GAAI,EAAE,EACPA,EACA,CAAC,GAAI,EAAE,EACPA,EACA,CAAC,IAAK,CAAC,EACP,EACAA,EACA,CAAC,GAAI,EAAE,EACP,EACAA,EACA,CAAC,IAAK,EAAE,EACR,GACAA,EACA,CAAC,IAAK,CAAC,EACP,EACAA,EACA,CAAC,EAAG,CAAC,EACLA,EACA,CAAC,EAAG,CAAC,EACL,EACA,EACA,GACAA,EACA,CAAC,IAAK,EAAE,EACRA,EACA,CAAC,GAAI,EAAE,CACT,CAAC,EACC,KAAMC,EAAE,CACRnB,EACA,CAAC,EAAG,EAAE,EACNA,EACA,CAAC,EAAG,CAAC,EACL,EACAA,EACA,CAAC,EAAG,EAAE,EACNA,EACA,CAAC,EAAG,CAAC,EACLkB,EACA,CAAC,GAAI,EAAE,EACPA,EACA,CAAC,GAAI,EAAE,EACPA,EACA,CAAC,GAAI,EAAE,EACPA,EACA,CAAC,GAAI,EAAE,EACPA,EACA,CAAC,GAAI,EAAE,EACPA,EACA,CAAC,IAAK,EAAE,CACV,CAAC,EACC,MAAOC,EAAE,CACT,EACA,EACA,EACA,EACA,EACA,GACAD,EACA,CAAC,EAAG,CAAC,EACL,GACA,GACAA,EACA,CAAC,EAAG,CAAC,EACL,GACAA,EACA,CAAC,EAAG,CAAC,EACL,GACAA,EACA,CAAC,EAAG,CAAC,EACL,GACAA,EACA,CAAC,EAAG,CAAC,EACL,GACAA,EACA,CAAC,GAAI,CAAC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","sources":["webpack://@spotify-confidence/app/../../node_modules/reduce-css-calc/dist/index.js","webpack://@spotify-confidence/app/../../node_modules/reduce-css-calc/dist/lib/convert.js","webpack://@spotify-confidence/app/../../node_modules/reduce-css-calc/dist/lib/reducer.js","webpack://@spotify-confidence/app/../../node_modules/reduce-css-calc/dist/lib/stringifier.js","webpack://@spotify-confidence/app/../../node_modules/reduce-css-calc/dist/parser.js","webpack://@spotify-confidence/app/../../node_modules/reduce-css-calc/node_modules/postcss-value-parser/lib/index.js","webpack://@spotify-confidence/app/../../node_modules/reduce-css-calc/node_modules/postcss-value-parser/lib/parse.js","webpack://@spotify-confidence/app/../../node_modules/reduce-css-calc/node_modules/postcss-value-parser/lib/stringify.js","webpack://@spotify-confidence/app/../../node_modules/reduce-css-calc/node_modules/postcss-value-parser/lib/unit.js","webpack://@spotify-confidence/app/../../node_modules/reduce-css-calc/node_modules/postcss-value-parser/lib/walk.js"],"sourcesContent":["'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _postcssValueParser = require('postcss-value-parser');\n\nvar _postcssValueParser2 = _interopRequireDefault(_postcssValueParser);\n\nvar _parser = require('./parser');\n\nvar _reducer = require('./lib/reducer');\n\nvar _reducer2 = _interopRequireDefault(_reducer);\n\nvar _stringifier = require('./lib/stringifier');\n\nvar _stringifier2 = _interopRequireDefault(_stringifier);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n// eslint-disable-line\nvar MATCH_CALC = /((?:\\-[a-z]+\\-)?calc)/;\n\nexports.default = function (value) {\n var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5;\n\n return (0, _postcssValueParser2.default)(value).walk(function (node) {\n // skip anything which isn't a calc() function\n if (node.type !== 'function' || !MATCH_CALC.test(node.value)) return;\n\n // stringify calc expression and produce an AST\n var contents = _postcssValueParser2.default.stringify(node.nodes);\n\n // skip constant() and env()\n if (contents.indexOf('constant') >= 0 || contents.indexOf('env') >= 0) return;\n\n var ast = _parser.parser.parse(contents);\n\n // reduce AST to its simplest form, that is, either to a single value\n // or a simplified calc expression\n var reducedAst = (0, _reducer2.default)(ast, precision);\n\n // stringify AST and write it back\n node.type = 'word';\n node.value = (0, _stringifier2.default)(node.value, reducedAst, precision);\n }, true).toString();\n};\n\nmodule.exports = exports['default'];","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _cssUnitConverter = require('css-unit-converter');\n\nvar _cssUnitConverter2 = _interopRequireDefault(_cssUnitConverter);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction convertNodes(left, right, precision) {\n switch (left.type) {\n case 'LengthValue':\n case 'AngleValue':\n case 'TimeValue':\n case 'FrequencyValue':\n case 'ResolutionValue':\n return convertAbsoluteLength(left, right, precision);\n default:\n return { left: left, right: right };\n }\n}\n\nfunction convertAbsoluteLength(left, right, precision) {\n if (right.type === left.type) {\n right = {\n type: left.type,\n value: (0, _cssUnitConverter2.default)(right.value, right.unit, left.unit, precision),\n unit: left.unit\n };\n }\n return { left: left, right: right };\n}\n\nexports.default = convertNodes;\nmodule.exports = exports['default'];","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.flip = flip;\n\nvar _convert = require(\"./convert\");\n\nvar _convert2 = _interopRequireDefault(_convert);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction reduce(node, precision) {\n if (node.type === \"MathExpression\") return reduceMathExpression(node, precision);\n if (node.type === \"Calc\") return reduce(node.value, precision);\n\n return node;\n}\n\nfunction isEqual(left, right) {\n return left.type === right.type && left.value === right.value;\n}\n\nfunction isValueType(type) {\n switch (type) {\n case 'LengthValue':\n case 'AngleValue':\n case 'TimeValue':\n case 'FrequencyValue':\n case 'ResolutionValue':\n case 'EmValue':\n case 'ExValue':\n case 'ChValue':\n case 'RemValue':\n case 'VhValue':\n case 'VwValue':\n case 'VminValue':\n case 'VmaxValue':\n case 'PercentageValue':\n case 'Value':\n return true;\n }\n return false;\n}\n\nfunction convertMathExpression(node, precision) {\n var nodes = (0, _convert2.default)(node.left, node.right, precision);\n var left = reduce(nodes.left, precision);\n var right = reduce(nodes.right, precision);\n\n if (left.type === \"MathExpression\" && right.type === \"MathExpression\") {\n\n if (left.operator === '/' && right.operator === '*' || left.operator === '-' && right.operator === '+' || left.operator === '*' && right.operator === '/' || left.operator === '+' && right.operator === '-') {\n\n if (isEqual(left.right, right.right)) nodes = (0, _convert2.default)(left.left, right.left, precision);else if (isEqual(left.right, right.left)) nodes = (0, _convert2.default)(left.left, right.right, precision);\n\n left = reduce(nodes.left, precision);\n right = reduce(nodes.right, precision);\n }\n }\n\n node.left = left;\n node.right = right;\n return node;\n}\n\nfunction flip(operator) {\n return operator === '+' ? '-' : '+';\n}\n\nfunction flipValue(node) {\n if (isValueType(node.type)) node.value = -node.value;else if (node.type == 'MathExpression') {\n node.left = flipValue(node.left);\n node.right = flipValue(node.right);\n }\n return node;\n}\n\nfunction reduceAddSubExpression(node, precision) {\n var _node = node,\n left = _node.left,\n right = _node.right,\n op = _node.operator;\n\n\n if (left.type === 'CssVariable' || right.type === 'CssVariable') return node;\n\n // something + 0 => something\n // something - 0 => something\n if (right.value === 0) return left;\n\n // 0 + something => something\n if (left.value === 0 && op === \"+\") return right;\n\n // 0 - something => -something\n if (left.value === 0 && op === \"-\") return flipValue(right);\n\n // value + value\n // value - value\n if (left.type === right.type && isValueType(left.type)) {\n node = Object.assign({}, left);\n if (op === \"+\") node.value = left.value + right.value;else node.value = left.value - right.value;\n }\n\n // value (expr)\n if (isValueType(left.type) && (right.operator === '+' || right.operator === '-') && right.type === 'MathExpression') {\n // value + (value + something) => (value + value) + something\n // value + (value - something) => (value + value) - something\n // value - (value + something) => (value - value) - something\n // value - (value - something) => (value - value) + something\n if (left.type === right.left.type) {\n node = Object.assign({}, node);\n node.left = reduce({\n type: 'MathExpression',\n operator: op,\n left: left,\n right: right.left\n }, precision);\n node.right = right.right;\n node.operator = op === '-' ? flip(right.operator) : right.operator;\n return reduce(node, precision);\n }\n // value + (something + value) => (value + value) + something\n // value + (something - value) => (value - value) + something\n // value - (something + value) => (value - value) - something\n // value - (something - value) => (value + value) - something\n else if (left.type === right.right.type) {\n node = Object.assign({}, node);\n node.left = reduce({\n type: 'MathExpression',\n operator: op === '-' ? flip(right.operator) : right.operator,\n left: left,\n right: right.right\n }, precision);\n node.right = right.left;\n return reduce(node, precision);\n }\n }\n\n // (expr) value\n if (left.type === 'MathExpression' && (left.operator === '+' || left.operator === '-') && isValueType(right.type)) {\n // (value + something) + value => (value + value) + something\n // (value - something) + value => (value + value) - something\n // (value + something) - value => (value - value) + something\n // (value - something) - value => (value - value) - something\n if (right.type === left.left.type) {\n node = Object.assign({}, left);\n node.left = reduce({\n type: 'MathExpression',\n operator: op,\n left: left.left,\n right: right\n }, precision);\n return reduce(node, precision);\n }\n // (something + value) + value => something + (value + value)\n // (something - value1) + value2 => something - (value2 - value1)\n // (something + value) - value => something + (value - value)\n // (something - value) - value => something - (value + value)\n else if (right.type === left.right.type) {\n node = Object.assign({}, left);\n if (left.operator === '-') {\n node.right = reduce({\n type: 'MathExpression',\n operator: op === '-' ? '+' : '-',\n left: right,\n right: left.right\n }, precision);\n node.operator = op === '-' ? '-' : '+';\n } else {\n node.right = reduce({\n type: 'MathExpression',\n operator: op,\n left: left.right,\n right: right\n }, precision);\n }\n if (node.right.value < 0) {\n node.right.value *= -1;\n node.operator = node.operator === '-' ? '+' : '-';\n }\n return reduce(node, precision);\n }\n }\n return node;\n}\n\nfunction reduceDivisionExpression(node, precision) {\n if (!isValueType(node.right.type)) return node;\n\n if (node.right.type !== 'Value') throw new Error(\"Cannot divide by \\\"\" + node.right.unit + \"\\\", number expected\");\n\n if (node.right.value === 0) throw new Error('Cannot divide by zero');\n\n // (expr) / value\n if (node.left.type === 'MathExpression') {\n if (isValueType(node.left.left.type) && isValueType(node.left.right.type)) {\n node.left.left.value /= node.right.value;\n node.left.right.value /= node.right.value;\n return reduce(node.left, precision);\n }\n return node;\n }\n // something / value\n else if (isValueType(node.left.type)) {\n node.left.value /= node.right.value;\n return node.left;\n }\n return node;\n}\n\nfunction reduceMultiplicationExpression(node) {\n // (expr) * value\n if (node.left.type === 'MathExpression' && node.right.type === 'Value') {\n if (isValueType(node.left.left.type) && isValueType(node.left.right.type)) {\n node.left.left.value *= node.right.value;\n node.left.right.value *= node.right.value;\n return node.left;\n }\n }\n // something * value\n else if (isValueType(node.left.type) && node.right.type === 'Value') {\n node.left.value *= node.right.value;\n return node.left;\n }\n // value * (expr)\n else if (node.left.type === 'Value' && node.right.type === 'MathExpression') {\n if (isValueType(node.right.left.type) && isValueType(node.right.right.type)) {\n node.right.left.value *= node.left.value;\n node.right.right.value *= node.left.value;\n return node.right;\n }\n }\n // value * something\n else if (node.left.type === 'Value' && isValueType(node.right.type)) {\n node.right.value *= node.left.value;\n return node.right;\n }\n return node;\n}\n\nfunction reduceMathExpression(node, precision) {\n node = convertMathExpression(node, precision);\n\n switch (node.operator) {\n case \"+\":\n case \"-\":\n return reduceAddSubExpression(node, precision);\n case \"/\":\n return reduceDivisionExpression(node, precision);\n case \"*\":\n return reduceMultiplicationExpression(node);\n }\n return node;\n}\n\nexports.default = reduce;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nexports.default = function (calc, node, precision) {\n var str = stringify(node, precision);\n\n if (node.type === \"MathExpression\") {\n // if calc expression couldn't be resolved to a single value, re-wrap it as\n // a calc()\n str = calc + \"(\" + str + \")\";\n }\n return str;\n};\n\nvar _reducer = require(\"./reducer\");\n\nvar order = {\n \"*\": 0,\n \"/\": 0,\n \"+\": 1,\n \"-\": 1\n};\n\nfunction round(value, prec) {\n if (prec !== false) {\n var precision = Math.pow(10, prec);\n return Math.round(value * precision) / precision;\n }\n return value;\n}\n\nfunction stringify(node, prec) {\n switch (node.type) {\n case \"MathExpression\":\n {\n var left = node.left,\n right = node.right,\n op = node.operator;\n\n var str = \"\";\n\n if (left.type === 'MathExpression' && order[op] < order[left.operator]) str += \"(\" + stringify(left, prec) + \")\";else str += stringify(left, prec);\n\n str += \" \" + node.operator + \" \";\n\n if (right.type === 'MathExpression' && order[op] < order[right.operator]) {\n str += \"(\" + stringify(right, prec) + \")\";\n } else if (right.type === 'MathExpression' && op === \"-\" && [\"+\", \"-\"].includes(right.operator)) {\n // fix #52 : a-(b+c) = a-b-c\n right.operator = (0, _reducer.flip)(right.operator);\n str += stringify(right, prec);\n } else {\n str += stringify(right, prec);\n }\n\n return str;\n }\n case \"Value\":\n return round(node.value, prec);\n case 'CssVariable':\n if (node.fallback) {\n return \"var(\" + node.value + \", \" + stringify(node.fallback, prec, true) + \")\";\n }\n return \"var(\" + node.value + \")\";\n case 'Calc':\n if (node.prefix) {\n return \"-\" + node.prefix + \"-calc(\" + stringify(node.value, prec) + \")\";\n }\n return \"calc(\" + stringify(node.value, prec) + \")\";\n default:\n return round(node.value, prec) + node.unit;\n }\n}\n\nmodule.exports = exports[\"default\"];","\n/* parser generated by jison 0.6.1-215 */\n\n/*\n * Returns a Parser object of the following structure:\n *\n * Parser: {\n * yy: {} The so-called \"shared state\" or rather the *source* of it;\n * the real \"shared state\" `yy` passed around to\n * the rule actions, etc. is a derivative/copy of this one,\n * not a direct reference!\n * }\n *\n * Parser.prototype: {\n * yy: {},\n * EOF: 1,\n * TERROR: 2,\n *\n * trace: function(errorMessage, ...),\n *\n * JisonParserError: function(msg, hash),\n *\n * quoteName: function(name),\n * Helper function which can be overridden by user code later on: put suitable\n * quotes around literal IDs in a description string.\n *\n * originalQuoteName: function(name),\n * The basic quoteName handler provided by JISON.\n * `cleanupAfterParse()` will clean up and reset `quoteName()` to reference this function\n * at the end of the `parse()`.\n *\n * describeSymbol: function(symbol),\n * Return a more-or-less human-readable description of the given symbol, when\n * available, or the symbol itself, serving as its own 'description' for lack\n * of something better to serve up.\n *\n * Return NULL when the symbol is unknown to the parser.\n *\n * symbols_: {associative list: name ==> number},\n * terminals_: {associative list: number ==> name},\n * nonterminals: {associative list: rule-name ==> {associative list: number ==> rule-alt}},\n * terminal_descriptions_: (if there are any) {associative list: number ==> description},\n * productions_: [...],\n *\n * performAction: function parser__performAction(yytext, yyleng, yylineno, yyloc, yystate, yysp, yyvstack, yylstack, yystack, yysstack),\n *\n * The function parameters and `this` have the following value/meaning:\n * - `this` : reference to the `yyval` internal object, which has members (`$` and `_$`)\n * to store/reference the rule value `$$` and location info `@$`.\n *\n * One important thing to note about `this` a.k.a. `yyval`: every *reduce* action gets\n * to see the same object via the `this` reference, i.e. if you wish to carry custom\n * data from one reduce action through to the next within a single parse run, then you\n * may get nasty and use `yyval` a.k.a. `this` for storing you own semi-permanent data.\n *\n * `this.yy` is a direct reference to the `yy` shared state object.\n *\n * `%parse-param`-specified additional `parse()` arguments have been added to this `yy`\n * object at `parse()` start and are therefore available to the action code via the\n * same named `yy.xxxx` attributes (where `xxxx` represents a identifier name from\n * the %parse-param` list.\n *\n * - `yytext` : reference to the lexer value which belongs to the last lexer token used\n * to match this rule. This is *not* the look-ahead token, but the last token\n * that's actually part of this rule.\n *\n * Formulated another way, `yytext` is the value of the token immediately preceeding\n * the current look-ahead token.\n * Caveats apply for rules which don't require look-ahead, such as epsilon rules.\n *\n * - `yyleng` : ditto as `yytext`, only now for the lexer.yyleng value.\n *\n * - `yylineno`: ditto as `yytext`, only now for the lexer.yylineno value.\n *\n * - `yyloc` : ditto as `yytext`, only now for the lexer.yylloc lexer token location info.\n *\n * WARNING: since jison 0.4.18-186 this entry may be NULL/UNDEFINED instead\n * of an empty object when no suitable location info can be provided.\n *\n * - `yystate` : the current parser state number, used internally for dispatching and\n * executing the action code chunk matching the rule currently being reduced.\n *\n * - `yysp` : the current state stack position (a.k.a. 'stack pointer')\n *\n * This one comes in handy when you are going to do advanced things to the parser\n * stacks, all of which are accessible from your action code (see the next entries below).\n *\n * Also note that you can access this and other stack index values using the new double-hash\n * syntax, i.e. `##$ === ##0 === yysp`, while `##1` is the stack index for all things\n * related to the first rule term, just like you have `$1`, `@1` and `#1`.\n * This is made available to write very advanced grammar action rules, e.g. when you want\n * to investigate the parse state stack in your action code, which would, for example,\n * be relevant when you wish to implement error diagnostics and reporting schemes similar\n * to the work described here:\n *\n * + Pottier, F., 2016. Reachability and error diagnosis in LR(1) automata.\n * In Journées Francophones des Languages Applicatifs.\n *\n * + Jeffery, C.L., 2003. Generating LR syntax error messages from examples.\n * ACM Transactions on Programming Languages and Systems (TOPLAS), 25(5), pp.631–640.\n *\n * - `yyrulelength`: the current rule's term count, i.e. the number of entries occupied on the stack.\n *\n * This one comes in handy when you are going to do advanced things to the parser\n * stacks, all of which are accessible from your action code (see the next entries below).\n *\n * - `yyvstack`: reference to the parser value stack. Also accessed via the `$1` etc.\n * constructs.\n *\n * - `yylstack`: reference to the parser token location stack. Also accessed via\n * the `@1` etc. constructs.\n *\n * WARNING: since jison 0.4.18-186 this array MAY contain slots which are\n * UNDEFINED rather than an empty (location) object, when the lexer/parser\n * action code did not provide a suitable location info object when such a\n * slot was filled!\n *\n * - `yystack` : reference to the parser token id stack. Also accessed via the\n * `#1` etc. constructs.\n *\n * Note: this is a bit of a **white lie** as we can statically decode any `#n` reference to\n * its numeric token id value, hence that code wouldn't need the `yystack` but *you* might\n * want access this array for your own purposes, such as error analysis as mentioned above!\n *\n * Note that this stack stores the current stack of *tokens*, that is the sequence of\n * already parsed=reduced *nonterminals* (tokens representing rules) and *terminals*\n * (lexer tokens *shifted* onto the stack until the rule they belong to is found and\n * *reduced*.\n *\n * - `yysstack`: reference to the parser state stack. This one carries the internal parser\n * *states* such as the one in `yystate`, which are used to represent\n * the parser state machine in the *parse table*. *Very* *internal* stuff,\n * what can I say? If you access this one, you're clearly doing wicked things\n *\n * - `...` : the extra arguments you specified in the `%parse-param` statement in your\n * grammar definition file.\n *\n * table: [...],\n * State transition table\n * ----------------------\n *\n * index levels are:\n * - `state` --> hash table\n * - `symbol` --> action (number or array)\n *\n * If the `action` is an array, these are the elements' meaning:\n * - index [0]: 1 = shift, 2 = reduce, 3 = accept\n * - index [1]: GOTO `state`\n *\n * If the `action` is a number, it is the GOTO `state`\n *\n * defaultActions: {...},\n *\n * parseError: function(str, hash, ExceptionClass),\n * yyError: function(str, ...),\n * yyRecovering: function(),\n * yyErrOk: function(),\n * yyClearIn: function(),\n *\n * constructParseErrorInfo: function(error_message, exception_object, expected_token_set, is_recoverable),\n * Helper function **which will be set up during the first invocation of the `parse()` method**.\n * Produces a new errorInfo 'hash object' which can be passed into `parseError()`.\n * See it's use in this parser kernel in many places; example usage:\n *\n * var infoObj = parser.constructParseErrorInfo('fail!', null,\n * parser.collect_expected_token_set(state), true);\n * var retVal = parser.parseError(infoObj.errStr, infoObj, parser.JisonParserError);\n *\n * originalParseError: function(str, hash, ExceptionClass),\n * The basic `parseError` handler provided by JISON.\n * `cleanupAfterParse()` will clean up and reset `parseError()` to reference this function\n * at the end of the `parse()`.\n *\n * options: { ... parser %options ... },\n *\n * parse: function(input[, args...]),\n * Parse the given `input` and return the parsed value (or `true` when none was provided by\n * the root action, in which case the parser is acting as a *matcher*).\n * You MAY use the additional `args...` parameters as per `%parse-param` spec of this grammar:\n * these extra `args...` are added verbatim to the `yy` object reference as member variables.\n *\n * WARNING:\n * Parser's additional `args...` parameters (via `%parse-param`) MAY conflict with\n * any attributes already added to `yy` by the jison run-time;\n * when such a collision is detected an exception is thrown to prevent the generated run-time\n * from silently accepting this confusing and potentially hazardous situation!\n *\n * The lexer MAY add its own set of additional parameters (via the `%parse-param` line in\n * the lexer section of the grammar spec): these will be inserted in the `yy` shared state\n * object and any collision with those will be reported by the lexer via a thrown exception.\n *\n * cleanupAfterParse: function(resultValue, invoke_post_methods, do_not_nuke_errorinfos),\n * Helper function **which will be set up during the first invocation of the `parse()` method**.\n * This helper API is invoked at the end of the `parse()` call, unless an exception was thrown\n * and `%options no-try-catch` has been defined for this grammar: in that case this helper MAY\n * be invoked by calling user code to ensure the `post_parse` callbacks are invoked and\n * the internal parser gets properly garbage collected under these particular circumstances.\n *\n * yyMergeLocationInfo: function(first_index, last_index, first_yylloc, last_yylloc, dont_look_back),\n * Helper function **which will be set up during the first invocation of the `parse()` method**.\n * This helper API can be invoked to calculate a spanning `yylloc` location info object.\n *\n * Note: %epsilon rules MAY specify no `first_index` and `first_yylloc`, in which case\n * this function will attempt to obtain a suitable location marker by inspecting the location stack\n * backwards.\n *\n * For more info see the documentation comment further below, immediately above this function's\n * implementation.\n *\n * lexer: {\n * yy: {...}, A reference to the so-called \"shared state\" `yy` once\n * received via a call to the `.setInput(input, yy)` lexer API.\n * EOF: 1,\n * ERROR: 2,\n * JisonLexerError: function(msg, hash),\n * parseError: function(str, hash, ExceptionClass),\n * setInput: function(input, [yy]),\n * input: function(),\n * unput: function(str),\n * more: function(),\n * reject: function(),\n * less: function(n),\n * pastInput: function(n),\n * upcomingInput: function(n),\n * showPosition: function(),\n * test_match: function(regex_match_array, rule_index, ...),\n * next: function(...),\n * lex: function(...),\n * begin: function(condition),\n * pushState: function(condition),\n * popState: function(),\n * topState: function(),\n * _currentRules: function(),\n * stateStackSize: function(),\n * cleanupAfterLex: function()\n *\n * options: { ... lexer %options ... },\n *\n * performAction: function(yy, yy_, $avoiding_name_collisions, YY_START, ...),\n * rules: [...],\n * conditions: {associative list: name ==> set},\n * }\n * }\n *\n *\n * token location info (@$, _$, etc.): {\n * first_line: n,\n * last_line: n,\n * first_column: n,\n * last_column: n,\n * range: [start_number, end_number]\n * (where the numbers are indexes into the input string, zero-based)\n * }\n *\n * ---\n *\n * The `parseError` function receives a 'hash' object with these members for lexer and\n * parser errors:\n *\n * {\n * text: (matched text)\n * token: (the produced terminal token, if any)\n * token_id: (the produced terminal token numeric ID, if any)\n * line: (yylineno)\n * loc: (yylloc)\n * }\n *\n * parser (grammar) errors will also provide these additional members:\n *\n * {\n * expected: (array describing the set of expected tokens;\n * may be UNDEFINED when we cannot easily produce such a set)\n * state: (integer (or array when the table includes grammar collisions);\n * represents the current internal state of the parser kernel.\n * can, for example, be used to pass to the `collect_expected_token_set()`\n * API to obtain the expected token set)\n * action: (integer; represents the current internal action which will be executed)\n * new_state: (integer; represents the next/planned internal state, once the current\n * action has executed)\n * recoverable: (boolean: TRUE when the parser MAY have an error recovery rule\n * available for this particular error)\n * state_stack: (array: the current parser LALR/LR internal state stack; this can be used,\n * for instance, for advanced error analysis and reporting)\n * value_stack: (array: the current parser LALR/LR internal `$$` value stack; this can be used,\n * for instance, for advanced error analysis and reporting)\n * location_stack: (array: the current parser LALR/LR internal location stack; this can be used,\n * for instance, for advanced error analysis and reporting)\n * yy: (object: the current parser internal \"shared state\" `yy`\n * as is also available in the rule actions; this can be used,\n * for instance, for advanced error analysis and reporting)\n * lexer: (reference to the current lexer instance used by the parser)\n * parser: (reference to the current parser instance)\n * }\n *\n * while `this` will reference the current parser instance.\n *\n * When `parseError` is invoked by the lexer, `this` will still reference the related *parser*\n * instance, while these additional `hash` fields will also be provided:\n *\n * {\n * lexer: (reference to the current lexer instance which reported the error)\n * }\n *\n * When `parseError` is invoked by the parser due to a **JavaScript exception** being fired\n * from either the parser or lexer, `this` will still reference the related *parser*\n * instance, while these additional `hash` fields will also be provided:\n *\n * {\n * exception: (reference to the exception thrown)\n * }\n *\n * Please do note that in the latter situation, the `expected` field will be omitted as\n * this type of failure is assumed not to be due to *parse errors* but rather due to user\n * action code in either parser or lexer failing unexpectedly.\n *\n * ---\n *\n * You can specify parser options by setting / modifying the `.yy` object of your Parser instance.\n * These options are available:\n *\n * ### options which are global for all parser instances\n *\n * Parser.pre_parse: function(yy)\n * optional: you can specify a pre_parse() function in the chunk following\n * the grammar, i.e. after the last `%%`.\n * Parser.post_parse: function(yy, retval, parseInfo) { return retval; }\n * optional: you can specify a post_parse() function in the chunk following\n * the grammar, i.e. after the last `%%`. When it does not return any value,\n * the parser will return the original `retval`.\n *\n * ### options which can be set up per parser instance\n *\n * yy: {\n * pre_parse: function(yy)\n * optional: is invoked before the parse cycle starts (and before the first\n * invocation of `lex()`) but immediately after the invocation of\n * `parser.pre_parse()`).\n * post_parse: function(yy, retval, parseInfo) { return retval; }\n * optional: is invoked when the parse terminates due to success ('accept')\n * or failure (even when exceptions are thrown).\n * `retval` contains the return value to be produced by `Parser.parse()`;\n * this function can override the return value by returning another.\n * When it does not return any value, the parser will return the original\n * `retval`.\n * This function is invoked immediately before `parser.post_parse()`.\n *\n * parseError: function(str, hash, ExceptionClass)\n * optional: overrides the default `parseError` function.\n * quoteName: function(name),\n * optional: overrides the default `quoteName` function.\n * }\n *\n * parser.lexer.options: {\n * pre_lex: function()\n * optional: is invoked before the lexer is invoked to produce another token.\n * `this` refers to the Lexer object.\n * post_lex: function(token) { return token; }\n * optional: is invoked when the lexer has produced a token `token`;\n * this function can override the returned token value by returning another.\n * When it does not return any (truthy) value, the lexer will return\n * the original `token`.\n * `this` refers to the Lexer object.\n *\n * ranges: boolean\n * optional: `true` ==> token location info will include a .range[] member.\n * flex: boolean\n * optional: `true` ==> flex-like lexing behaviour where the rules are tested\n * exhaustively to find the longest match.\n * backtrack_lexer: boolean\n * optional: `true` ==> lexer regexes are tested in order and for invoked;\n * the lexer terminates the scan when a token is returned by the action code.\n * xregexp: boolean\n * optional: `true` ==> lexer rule regexes are \"extended regex format\" requiring the\n * `XRegExp` library. When this `%option` has not been specified at compile time, all lexer\n * rule regexes have been written as standard JavaScript RegExp expressions.\n * }\n */\n\n \n \n var parser = (function () {\n\n\n// See also:\n// http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript/#35881508\n// but we keep the prototype.constructor and prototype.name assignment lines too for compatibility\n// with userland code which might access the derived class in a 'classic' way.\nfunction JisonParserError(msg, hash) {\n Object.defineProperty(this, 'name', {\n enumerable: false,\n writable: false,\n value: 'JisonParserError'\n });\n\n if (msg == null) msg = '???';\n\n Object.defineProperty(this, 'message', {\n enumerable: false,\n writable: true,\n value: msg\n });\n\n this.hash = hash;\n\n var stacktrace;\n if (hash && hash.exception instanceof Error) {\n var ex2 = hash.exception;\n this.message = ex2.message || msg;\n stacktrace = ex2.stack;\n }\n if (!stacktrace) {\n if (Error.hasOwnProperty('captureStackTrace')) { // V8/Chrome engine\n Error.captureStackTrace(this, this.constructor);\n } else {\n stacktrace = (new Error(msg)).stack;\n }\n }\n if (stacktrace) {\n Object.defineProperty(this, 'stack', {\n enumerable: false,\n writable: false,\n value: stacktrace\n });\n }\n}\n\nif (typeof Object.setPrototypeOf === 'function') {\n Object.setPrototypeOf(JisonParserError.prototype, Error.prototype);\n} else {\n JisonParserError.prototype = Object.create(Error.prototype);\n}\nJisonParserError.prototype.constructor = JisonParserError;\nJisonParserError.prototype.name = 'JisonParserError';\n\n\n\n\n // helper: reconstruct the productions[] table\n function bp(s) {\n var rv = [];\n var p = s.pop;\n var r = s.rule;\n for (var i = 0, l = p.length; i < l; i++) {\n rv.push([\n p[i],\n r[i]\n ]);\n }\n return rv;\n }\n \n\n\n // helper: reconstruct the defaultActions[] table\n function bda(s) {\n var rv = {};\n var d = s.idx;\n var g = s.goto;\n for (var i = 0, l = d.length; i < l; i++) {\n var j = d[i];\n rv[j] = g[i];\n }\n return rv;\n }\n \n\n\n // helper: reconstruct the 'goto' table\n function bt(s) {\n var rv = [];\n var d = s.len;\n var y = s.symbol;\n var t = s.type;\n var a = s.state;\n var m = s.mode;\n var g = s.goto;\n for (var i = 0, l = d.length; i < l; i++) {\n var n = d[i];\n var q = {};\n for (var j = 0; j < n; j++) {\n var z = y.shift();\n switch (t.shift()) {\n case 2:\n q[z] = [\n m.shift(),\n g.shift()\n ];\n break;\n\n case 0:\n q[z] = a.shift();\n break;\n\n default:\n // type === 1: accept\n q[z] = [\n 3\n ];\n }\n }\n rv.push(q);\n }\n return rv;\n }\n \n\n\n // helper: runlength encoding with increment step: code, length: step (default step = 0)\n // `this` references an array\n function s(c, l, a) {\n a = a || 0;\n for (var i = 0; i < l; i++) {\n this.push(c);\n c += a;\n }\n }\n\n // helper: duplicate sequence from *relative* offset and length.\n // `this` references an array\n function c(i, l) {\n i = this.length - i;\n for (l += i; i < l; i++) {\n this.push(this[i]);\n }\n }\n\n // helper: unpack an array using helpers and data, all passed in an array argument 'a'.\n function u(a) {\n var rv = [];\n for (var i = 0, l = a.length; i < l; i++) {\n var e = a[i];\n // Is this entry a helper function?\n if (typeof e === 'function') {\n i++;\n e.apply(rv, a[i]);\n } else {\n rv.push(e);\n }\n }\n return rv;\n }\n \n\nvar parser = {\n // Code Generator Information Report\n // ---------------------------------\n //\n // Options:\n //\n // default action mode: ............. [\"classic\",\"merge\"]\n // test-compile action mode: ........ \"parser:*,lexer:*\"\n // try..catch: ...................... true\n // default resolve on conflict: ..... true\n // on-demand look-ahead: ............ false\n // error recovery token skip maximum: 3\n // yyerror in parse actions is: ..... NOT recoverable,\n // yyerror in lexer actions and other non-fatal lexer are:\n // .................................. NOT recoverable,\n // debug grammar/output: ............ false\n // has partial LR conflict upgrade: true\n // rudimentary token-stack support: false\n // parser table compression mode: ... 2\n // export debug tables: ............. false\n // export *all* tables: ............. false\n // module type: ..................... commonjs\n // parser engine type: .............. lalr\n // output main() in the module: ..... true\n // has user-specified main(): ....... false\n // has user-specified require()/import modules for main():\n // .................................. false\n // number of expected conflicts: .... 0\n //\n //\n // Parser Analysis flags:\n //\n // no significant actions (parser is a language matcher only):\n // .................................. false\n // uses yyleng: ..................... false\n // uses yylineno: ................... false\n // uses yytext: ..................... false\n // uses yylloc: ..................... false\n // uses ParseError API: ............. false\n // uses YYERROR: .................... false\n // uses YYRECOVERING: ............... false\n // uses YYERROK: .................... false\n // uses YYCLEARIN: .................. false\n // tracks rule values: .............. true\n // assigns rule values: ............. true\n // uses location tracking: .......... false\n // assigns location: ................ false\n // uses yystack: .................... false\n // uses yysstack: ................... false\n // uses yysp: ....................... true\n // uses yyrulelength: ............... false\n // uses yyMergeLocationInfo API: .... false\n // has error recovery: .............. false\n // has error reporting: ............. false\n //\n // --------- END OF REPORT -----------\n\ntrace: function no_op_trace() { },\nJisonParserError: JisonParserError,\nyy: {},\noptions: {\n type: \"lalr\",\n hasPartialLrUpgradeOnConflict: true,\n errorRecoveryTokenDiscardCount: 3\n},\nsymbols_: {\n \"$accept\": 0,\n \"$end\": 1,\n \"ADD\": 3,\n \"ANGLE\": 16,\n \"CHS\": 22,\n \"COMMA\": 14,\n \"CSS_CPROP\": 13,\n \"CSS_VAR\": 12,\n \"DIV\": 6,\n \"EMS\": 20,\n \"EOF\": 1,\n \"EXS\": 21,\n \"FREQ\": 18,\n \"LENGTH\": 15,\n \"LPAREN\": 7,\n \"MUL\": 5,\n \"NESTED_CALC\": 9,\n \"NUMBER\": 11,\n \"PERCENTAGE\": 28,\n \"PREFIX\": 10,\n \"REMS\": 23,\n \"RES\": 19,\n \"RPAREN\": 8,\n \"SUB\": 4,\n \"TIME\": 17,\n \"VHS\": 24,\n \"VMAXS\": 27,\n \"VMINS\": 26,\n \"VWS\": 25,\n \"css_value\": 33,\n \"css_variable\": 32,\n \"error\": 2,\n \"expression\": 29,\n \"math_expression\": 30,\n \"value\": 31\n},\nterminals_: {\n 1: \"EOF\",\n 2: \"error\",\n 3: \"ADD\",\n 4: \"SUB\",\n 5: \"MUL\",\n 6: \"DIV\",\n 7: \"LPAREN\",\n 8: \"RPAREN\",\n 9: \"NESTED_CALC\",\n 10: \"PREFIX\",\n 11: \"NUMBER\",\n 12: \"CSS_VAR\",\n 13: \"CSS_CPROP\",\n 14: \"COMMA\",\n 15: \"LENGTH\",\n 16: \"ANGLE\",\n 17: \"TIME\",\n 18: \"FREQ\",\n 19: \"RES\",\n 20: \"EMS\",\n 21: \"EXS\",\n 22: \"CHS\",\n 23: \"REMS\",\n 24: \"VHS\",\n 25: \"VWS\",\n 26: \"VMINS\",\n 27: \"VMAXS\",\n 28: \"PERCENTAGE\"\n},\nTERROR: 2,\n EOF: 1,\n\n // internals: defined here so the object *structure* doesn't get modified by parse() et al,\n // thus helping JIT compilers like Chrome V8.\n originalQuoteName: null,\n originalParseError: null,\n cleanupAfterParse: null,\n constructParseErrorInfo: null,\n yyMergeLocationInfo: null,\n\n __reentrant_call_depth: 0, // INTERNAL USE ONLY\n __error_infos: [], // INTERNAL USE ONLY: the set of parseErrorInfo objects created since the last cleanup\n __error_recovery_infos: [], // INTERNAL USE ONLY: the set of parseErrorInfo objects created since the last cleanup\n\n // APIs which will be set up depending on user action code analysis:\n //yyRecovering: 0,\n //yyErrOk: 0,\n //yyClearIn: 0,\n\n // Helper APIs\n // -----------\n\n // Helper function which can be overridden by user code later on: put suitable quotes around\n // literal IDs in a description string.\n quoteName: function parser_quoteName(id_str) {\n return '\"' + id_str + '\"';\n },\n\n // Return the name of the given symbol (terminal or non-terminal) as a string, when available.\n //\n // Return NULL when the symbol is unknown to the parser.\n getSymbolName: function parser_getSymbolName(symbol) {\n if (this.terminals_[symbol]) {\n return this.terminals_[symbol];\n }\n\n // Otherwise... this might refer to a RULE token i.e. a non-terminal: see if we can dig that one up.\n //\n // An example of this may be where a rule's action code contains a call like this:\n //\n // parser.getSymbolName(#$)\n //\n // to obtain a human-readable name of the current grammar rule.\n var s = this.symbols_;\n for (var key in s) {\n if (s[key] === symbol) {\n return key;\n }\n }\n return null;\n },\n\n // Return a more-or-less human-readable description of the given symbol, when available,\n // or the symbol itself, serving as its own 'description' for lack of something better to serve up.\n //\n // Return NULL when the symbol is unknown to the parser.\n describeSymbol: function parser_describeSymbol(symbol) {\n if (symbol !== this.EOF && this.terminal_descriptions_ && this.terminal_descriptions_[symbol]) {\n return this.terminal_descriptions_[symbol];\n }\n else if (symbol === this.EOF) {\n return 'end of input';\n }\n var id = this.getSymbolName(symbol);\n if (id) {\n return this.quoteName(id);\n }\n return null;\n },\n\n // Produce a (more or less) human-readable list of expected tokens at the point of failure.\n //\n // The produced list may contain token or token set descriptions instead of the tokens\n // themselves to help turning this output into something that easier to read by humans\n // unless `do_not_describe` parameter is set, in which case a list of the raw, *numeric*,\n // expected terminals and nonterminals is produced.\n //\n // The returned list (array) will not contain any duplicate entries.\n collect_expected_token_set: function parser_collect_expected_token_set(state, do_not_describe) {\n var TERROR = this.TERROR;\n var tokenset = [];\n var check = {};\n // Has this (error?) state been outfitted with a custom expectations description text for human consumption?\n // If so, use that one instead of the less palatable token set.\n if (!do_not_describe && this.state_descriptions_ && this.state_descriptions_[state]) {\n return [\n this.state_descriptions_[state]\n ];\n }\n for (var p in this.table[state]) {\n p = +p;\n if (p !== TERROR) {\n var d = do_not_describe ? p : this.describeSymbol(p);\n if (d && !check[d]) {\n tokenset.push(d);\n check[d] = true; // Mark this token description as already mentioned to prevent outputting duplicate entries.\n }\n }\n }\n return tokenset;\n },\nproductions_: bp({\n pop: u([\n 29,\n s,\n [30, 10],\n 31,\n 31,\n 32,\n 32,\n s,\n [33, 15]\n]),\n rule: u([\n 2,\n s,\n [3, 5],\n 4,\n 7,\n s,\n [1, 4],\n 2,\n 4,\n 6,\n s,\n [1, 14],\n 2\n])\n}),\nperformAction: function parser__PerformAction(yystate /* action[1] */, yysp, yyvstack) {\n\n /* this == yyval */\n\n // the JS engine itself can go and remove these statements when `yy` turns out to be unused in any action code!\n var yy = this.yy;\n var yyparser = yy.parser;\n var yylexer = yy.lexer;\n\n \n\n switch (yystate) {\ncase 0:\n /*! Production:: $accept : expression $end */\n\n // default action (generated by JISON mode classic/merge :: 1,VT,VA,-,-,-,-,-,-):\n this.$ = yyvstack[yysp - 1];\n // END of default action (generated by JISON mode classic/merge :: 1,VT,VA,-,-,-,-,-,-)\n break;\n\ncase 1:\n /*! Production:: expression : math_expression EOF */\n\n // default action (generated by JISON mode classic/merge :: 2,VT,VA,-,-,-,-,-,-):\n this.$ = yyvstack[yysp - 1];\n // END of default action (generated by JISON mode classic/merge :: 2,VT,VA,-,-,-,-,-,-)\n \n \n return yyvstack[yysp - 1];\n break;\n\ncase 2:\n /*! Production:: math_expression : math_expression ADD math_expression */\ncase 3:\n /*! Production:: math_expression : math_expression SUB math_expression */\ncase 4:\n /*! Production:: math_expression : math_expression MUL math_expression */\ncase 5:\n /*! Production:: math_expression : math_expression DIV math_expression */\n\n this.$ = { type: 'MathExpression', operator: yyvstack[yysp - 1], left: yyvstack[yysp - 2], right: yyvstack[yysp] };\n break;\n\ncase 6:\n /*! Production:: math_expression : LPAREN math_expression RPAREN */\n\n this.$ = yyvstack[yysp - 1];\n break;\n\ncase 7:\n /*! Production:: math_expression : NESTED_CALC LPAREN math_expression RPAREN */\n\n this.$ = { type: 'Calc', value: yyvstack[yysp - 1] };\n break;\n\ncase 8:\n /*! Production:: math_expression : SUB PREFIX SUB NESTED_CALC LPAREN math_expression RPAREN */\n\n this.$ = { type: 'Calc', value: yyvstack[yysp - 1], prefix: yyvstack[yysp - 5] };\n break;\n\ncase 9:\n /*! Production:: math_expression : css_variable */\ncase 10:\n /*! Production:: math_expression : css_value */\ncase 11:\n /*! Production:: math_expression : value */\n\n this.$ = yyvstack[yysp];\n break;\n\ncase 12:\n /*! Production:: value : NUMBER */\n\n this.$ = { type: 'Value', value: parseFloat(yyvstack[yysp]) };\n break;\n\ncase 13:\n /*! Production:: value : SUB NUMBER */\n\n this.$ = { type: 'Value', value: parseFloat(yyvstack[yysp]) * -1 };\n break;\n\ncase 14:\n /*! Production:: css_variable : CSS_VAR LPAREN CSS_CPROP RPAREN */\n\n this.$ = { type: 'CssVariable', value: yyvstack[yysp - 1] };\n break;\n\ncase 15:\n /*! Production:: css_variable : CSS_VAR LPAREN CSS_CPROP COMMA math_expression RPAREN */\n\n this.$ = { type: 'CssVariable', value: yyvstack[yysp - 3], fallback: yyvstack[yysp - 1] };\n break;\n\ncase 16:\n /*! Production:: css_value : LENGTH */\n\n this.$ = { type: 'LengthValue', value: parseFloat(yyvstack[yysp]), unit: /[a-z]+/.exec(yyvstack[yysp])[0] };\n break;\n\ncase 17:\n /*! Production:: css_value : ANGLE */\n\n this.$ = { type: 'AngleValue', value: parseFloat(yyvstack[yysp]), unit: /[a-z]+/.exec(yyvstack[yysp])[0] };\n break;\n\ncase 18:\n /*! Production:: css_value : TIME */\n\n this.$ = { type: 'TimeValue', value: parseFloat(yyvstack[yysp]), unit: /[a-z]+/.exec(yyvstack[yysp])[0] };\n break;\n\ncase 19:\n /*! Production:: css_value : FREQ */\n\n this.$ = { type: 'FrequencyValue', value: parseFloat(yyvstack[yysp]), unit: /[a-z]+/.exec(yyvstack[yysp])[0] };\n break;\n\ncase 20:\n /*! Production:: css_value : RES */\n\n this.$ = { type: 'ResolutionValue', value: parseFloat(yyvstack[yysp]), unit: /[a-z]+/.exec(yyvstack[yysp])[0] };\n break;\n\ncase 21:\n /*! Production:: css_value : EMS */\n\n this.$ = { type: 'EmValue', value: parseFloat(yyvstack[yysp]), unit: 'em' };\n break;\n\ncase 22:\n /*! Production:: css_value : EXS */\n\n this.$ = { type: 'ExValue', value: parseFloat(yyvstack[yysp]), unit: 'ex' };\n break;\n\ncase 23:\n /*! Production:: css_value : CHS */\n\n this.$ = { type: 'ChValue', value: parseFloat(yyvstack[yysp]), unit: 'ch' };\n break;\n\ncase 24:\n /*! Production:: css_value : REMS */\n\n this.$ = { type: 'RemValue', value: parseFloat(yyvstack[yysp]), unit: 'rem' };\n break;\n\ncase 25:\n /*! Production:: css_value : VHS */\n\n this.$ = { type: 'VhValue', value: parseFloat(yyvstack[yysp]), unit: 'vh' };\n break;\n\ncase 26:\n /*! Production:: css_value : VWS */\n\n this.$ = { type: 'VwValue', value: parseFloat(yyvstack[yysp]), unit: 'vw' };\n break;\n\ncase 27:\n /*! Production:: css_value : VMINS */\n\n this.$ = { type: 'VminValue', value: parseFloat(yyvstack[yysp]), unit: 'vmin' };\n break;\n\ncase 28:\n /*! Production:: css_value : VMAXS */\n\n this.$ = { type: 'VmaxValue', value: parseFloat(yyvstack[yysp]), unit: 'vmax' };\n break;\n\ncase 29:\n /*! Production:: css_value : PERCENTAGE */\n\n this.$ = { type: 'PercentageValue', value: parseFloat(yyvstack[yysp]), unit: '%' };\n break;\n\ncase 30:\n /*! Production:: css_value : SUB css_value */\n\n var prev = yyvstack[yysp]; prev.value *= -1; this.$ = prev;\n break;\n\n}\n},\ntable: bt({\n len: u([\n 24,\n 1,\n 5,\n 23,\n 1,\n 18,\n s,\n [0, 3],\n 1,\n s,\n [0, 16],\n s,\n [23, 4],\n c,\n [28, 3],\n 0,\n 0,\n 16,\n 1,\n 6,\n 6,\n s,\n [0, 3],\n 5,\n 1,\n 2,\n c,\n [37, 3],\n c,\n [20, 3],\n 5,\n 0,\n 0\n]),\n symbol: u([\n 4,\n 7,\n 9,\n 11,\n 12,\n s,\n [15, 19, 1],\n 1,\n 1,\n s,\n [3, 4, 1],\n c,\n [30, 19],\n c,\n [29, 4],\n 7,\n 4,\n 10,\n 11,\n c,\n [22, 14],\n c,\n [19, 3],\n c,\n [43, 22],\n c,\n [23, 69],\n c,\n [139, 4],\n 8,\n c,\n [51, 24],\n 4,\n c,\n [138, 15],\n 13,\n c,\n [186, 5],\n 8,\n c,\n [6, 6],\n c,\n [5, 5],\n 9,\n 8,\n 14,\n c,\n [159, 47],\n c,\n [60, 10]\n]),\n type: u([\n s,\n [2, 19],\n s,\n [0, 5],\n 1,\n s,\n [2, 24],\n s,\n [0, 4],\n c,\n [22, 19],\n c,\n [43, 42],\n c,\n [23, 70],\n c,\n [28, 25],\n c,\n [45, 25],\n c,\n [113, 54]\n]),\n state: u([\n 1,\n 2,\n 8,\n 6,\n 7,\n 30,\n c,\n [4, 3],\n 33,\n 37,\n c,\n [5, 3],\n 38,\n c,\n [4, 3],\n 39,\n c,\n [4, 3],\n 40,\n c,\n [4, 3],\n 42,\n c,\n [21, 4],\n 50,\n c,\n [5, 3],\n 51,\n c,\n [4, 3]\n]),\n mode: u([\n s,\n [1, 179],\n s,\n [2, 3],\n c,\n [5, 5],\n c,\n [6, 4],\n s,\n [1, 57]\n]),\n goto: u([\n 5,\n 3,\n 4,\n 24,\n s,\n [9, 15, 1],\n s,\n [25, 5, 1],\n c,\n [24, 19],\n 31,\n 35,\n 32,\n 34,\n c,\n [18, 14],\n 36,\n c,\n [38, 19],\n c,\n [19, 57],\n c,\n [118, 4],\n 41,\n c,\n [24, 19],\n 43,\n 35,\n c,\n [16, 14],\n 44,\n s,\n [2, 3],\n 28,\n 29,\n 2,\n s,\n [3, 3],\n 28,\n 29,\n 3,\n c,\n [53, 4],\n s,\n [45, 5, 1],\n c,\n [100, 42],\n 52,\n c,\n [5, 4],\n 53\n])\n}),\ndefaultActions: bda({\n idx: u([\n 6,\n 7,\n 8,\n s,\n [10, 16, 1],\n 33,\n 34,\n 39,\n 40,\n 41,\n 45,\n 47,\n 52,\n 53\n]),\n goto: u([\n 9,\n 10,\n 11,\n s,\n [16, 14, 1],\n 12,\n 1,\n 30,\n 13,\n s,\n [4, 4, 1],\n 14,\n 15,\n 8\n])\n}),\nparseError: function parseError(str, hash, ExceptionClass) {\n if (hash.recoverable) {\n if (typeof this.trace === 'function') {\n this.trace(str);\n }\n hash.destroy(); // destroy... well, *almost*!\n } else {\n if (typeof this.trace === 'function') {\n this.trace(str);\n }\n if (!ExceptionClass) {\n ExceptionClass = this.JisonParserError;\n }\n throw new ExceptionClass(str, hash);\n }\n},\nparse: function parse(input) {\n var self = this;\n var stack = new Array(128); // token stack: stores token which leads to state at the same index (column storage)\n var sstack = new Array(128); // state stack: stores states (column storage)\n\n var vstack = new Array(128); // semantic value stack\n\n var table = this.table;\n var sp = 0; // 'stack pointer': index into the stacks\n\n\n \n\n\n var symbol = 0;\n\n\n\n var TERROR = this.TERROR;\n var EOF = this.EOF;\n var ERROR_RECOVERY_TOKEN_DISCARD_COUNT = (this.options.errorRecoveryTokenDiscardCount | 0) || 3;\n var NO_ACTION = [0, 54 /* === table.length :: ensures that anyone using this new state will fail dramatically! */];\n\n var lexer;\n if (this.__lexer__) {\n lexer = this.__lexer__;\n } else {\n lexer = this.__lexer__ = Object.create(this.lexer);\n }\n\n var sharedState_yy = {\n parseError: undefined,\n quoteName: undefined,\n lexer: undefined,\n parser: undefined,\n pre_parse: undefined,\n post_parse: undefined,\n pre_lex: undefined,\n post_lex: undefined // WARNING: must be written this way for the code expanders to work correctly in both ES5 and ES6 modes!\n };\n\n var ASSERT;\n if (typeof assert !== 'function') {\n ASSERT = function JisonAssert(cond, msg) {\n if (!cond) {\n throw new Error('assertion failed: ' + (msg || '***'));\n }\n };\n } else {\n ASSERT = assert;\n }\n\n this.yyGetSharedState = function yyGetSharedState() {\n return sharedState_yy;\n };\n\n\n\n\n\n\n\n\n function shallow_copy_noclobber(dst, src) {\n for (var k in src) {\n if (typeof dst[k] === 'undefined' && Object.prototype.hasOwnProperty.call(src, k)) {\n dst[k] = src[k];\n }\n }\n }\n\n // copy state\n shallow_copy_noclobber(sharedState_yy, this.yy);\n\n sharedState_yy.lexer = lexer;\n sharedState_yy.parser = this;\n\n\n\n\n\n\n // Does the shared state override the default `parseError` that already comes with this instance?\n if (typeof sharedState_yy.parseError === 'function') {\n this.parseError = function parseErrorAlt(str, hash, ExceptionClass) {\n if (!ExceptionClass) {\n ExceptionClass = this.JisonParserError;\n }\n return sharedState_yy.parseError.call(this, str, hash, ExceptionClass);\n };\n } else {\n this.parseError = this.originalParseError;\n }\n\n // Does the shared state override the default `quoteName` that already comes with this instance?\n if (typeof sharedState_yy.quoteName === 'function') {\n this.quoteName = function quoteNameAlt(id_str) {\n return sharedState_yy.quoteName.call(this, id_str);\n };\n } else {\n this.quoteName = this.originalQuoteName;\n }\n\n // set up the cleanup function; make it an API so that external code can re-use this one in case of\n // calamities or when the `%options no-try-catch` option has been specified for the grammar, in which\n // case this parse() API method doesn't come with a `finally { ... }` block any more!\n //\n // NOTE: as this API uses parse() as a closure, it MUST be set again on every parse() invocation,\n // or else your `sharedState`, etc. references will be *wrong*!\n this.cleanupAfterParse = function parser_cleanupAfterParse(resultValue, invoke_post_methods, do_not_nuke_errorinfos) {\n var rv;\n\n if (invoke_post_methods) {\n var hash;\n\n if (sharedState_yy.post_parse || this.post_parse) {\n // create an error hash info instance: we re-use this API in a **non-error situation**\n // as this one delivers all parser internals ready for access by userland code.\n hash = this.constructParseErrorInfo(null /* no error! */, null /* no exception! */, null, false);\n }\n\n if (sharedState_yy.post_parse) {\n rv = sharedState_yy.post_parse.call(this, sharedState_yy, resultValue, hash);\n if (typeof rv !== 'undefined') resultValue = rv;\n }\n if (this.post_parse) {\n rv = this.post_parse.call(this, sharedState_yy, resultValue, hash);\n if (typeof rv !== 'undefined') resultValue = rv;\n }\n\n // cleanup:\n if (hash && hash.destroy) {\n hash.destroy();\n }\n }\n\n if (this.__reentrant_call_depth > 1) return resultValue; // do not (yet) kill the sharedState when this is a reentrant run.\n\n // clean up the lingering lexer structures as well:\n if (lexer.cleanupAfterLex) {\n lexer.cleanupAfterLex(do_not_nuke_errorinfos);\n }\n\n // prevent lingering circular references from causing memory leaks:\n if (sharedState_yy) {\n sharedState_yy.lexer = undefined;\n sharedState_yy.parser = undefined;\n if (lexer.yy === sharedState_yy) {\n lexer.yy = undefined;\n }\n }\n sharedState_yy = undefined;\n this.parseError = this.originalParseError;\n this.quoteName = this.originalQuoteName;\n\n // nuke the vstack[] array at least as that one will still reference obsoleted user values.\n // To be safe, we nuke the other internal stack columns as well...\n stack.length = 0; // fastest way to nuke an array without overly bothering the GC\n sstack.length = 0;\n\n vstack.length = 0;\n sp = 0;\n\n // nuke the error hash info instances created during this run.\n // Userland code must COPY any data/references\n // in the error hash instance(s) it is more permanently interested in.\n if (!do_not_nuke_errorinfos) {\n for (var i = this.__error_infos.length - 1; i >= 0; i--) {\n var el = this.__error_infos[i];\n if (el && typeof el.destroy === 'function') {\n el.destroy();\n }\n }\n this.__error_infos.length = 0;\n\n\n }\n\n return resultValue;\n };\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n // NOTE: as this API uses parse() as a closure, it MUST be set again on every parse() invocation,\n // or else your `lexer`, `sharedState`, etc. references will be *wrong*!\n this.constructParseErrorInfo = function parser_constructParseErrorInfo(msg, ex, expected, recoverable) {\n var pei = {\n errStr: msg,\n exception: ex,\n text: lexer.match,\n value: lexer.yytext,\n token: this.describeSymbol(symbol) || symbol,\n token_id: symbol,\n line: lexer.yylineno,\n\n expected: expected,\n recoverable: recoverable,\n state: state,\n action: action,\n new_state: newState,\n symbol_stack: stack,\n state_stack: sstack,\n value_stack: vstack,\n\n stack_pointer: sp,\n yy: sharedState_yy,\n lexer: lexer,\n parser: this,\n\n // and make sure the error info doesn't stay due to potential\n // ref cycle via userland code manipulations.\n // These would otherwise all be memory leak opportunities!\n //\n // Note that only array and object references are nuked as those\n // constitute the set of elements which can produce a cyclic ref.\n // The rest of the members is kept intact as they are harmless.\n destroy: function destructParseErrorInfo() {\n // remove cyclic references added to error info:\n // info.yy = null;\n // info.lexer = null;\n // info.value = null;\n // info.value_stack = null;\n // ...\n var rec = !!this.recoverable;\n for (var key in this) {\n if (this.hasOwnProperty(key) && typeof key === 'object') {\n this[key] = undefined;\n }\n }\n this.recoverable = rec;\n }\n };\n // track this instance so we can `destroy()` it once we deem it superfluous and ready for garbage collection!\n this.__error_infos.push(pei);\n return pei;\n };\n\n\n\n\n\n\n\n\n\n\n\n\n\n function getNonTerminalFromCode(symbol) {\n var tokenName = self.getSymbolName(symbol);\n if (!tokenName) {\n tokenName = symbol;\n }\n return tokenName;\n }\n\n\n function stdLex() {\n var token = lexer.lex();\n // if token isn't its numeric value, convert\n if (typeof token !== 'number') {\n token = self.symbols_[token] || token;\n }\n\n return token || EOF;\n }\n\n function fastLex() {\n var token = lexer.fastLex();\n // if token isn't its numeric value, convert\n if (typeof token !== 'number') {\n token = self.symbols_[token] || token;\n }\n\n return token || EOF;\n }\n\n var lex = stdLex;\n\n\n var state, action, r, t;\n var yyval = {\n $: true,\n _$: undefined,\n yy: sharedState_yy\n };\n var p;\n var yyrulelen;\n var this_production;\n var newState;\n var retval = false;\n\n\n try {\n this.__reentrant_call_depth++;\n\n lexer.setInput(input, sharedState_yy);\n\n // NOTE: we *assume* no lexer pre/post handlers are set up *after* \n // this initial `setInput()` call: hence we can now check and decide\n // whether we'll go with the standard, slower, lex() API or the\n // `fast_lex()` one:\n if (typeof lexer.canIUse === 'function') {\n var lexerInfo = lexer.canIUse();\n if (lexerInfo.fastLex && typeof fastLex === 'function') {\n lex = fastLex;\n }\n } \n\n\n\n vstack[sp] = null;\n sstack[sp] = 0;\n stack[sp] = 0;\n ++sp;\n\n\n\n\n\n if (this.pre_parse) {\n this.pre_parse.call(this, sharedState_yy);\n }\n if (sharedState_yy.pre_parse) {\n sharedState_yy.pre_parse.call(this, sharedState_yy);\n }\n\n newState = sstack[sp - 1];\n for (;;) {\n // retrieve state number from top of stack\n state = newState; // sstack[sp - 1];\n\n // use default actions if available\n if (this.defaultActions[state]) {\n action = 2;\n newState = this.defaultActions[state];\n } else {\n // The single `==` condition below covers both these `===` comparisons in a single\n // operation:\n //\n // if (symbol === null || typeof symbol === 'undefined') ...\n if (!symbol) {\n symbol = lex();\n }\n // read action for current state and first input\n t = (table[state] && table[state][symbol]) || NO_ACTION;\n newState = t[1];\n action = t[0];\n\n\n\n\n\n\n\n\n\n\n\n // handle parse error\n if (!action) {\n var errStr;\n var errSymbolDescr = (this.describeSymbol(symbol) || symbol);\n var expected = this.collect_expected_token_set(state);\n\n // Report error\n if (typeof lexer.yylineno === 'number') {\n errStr = 'Parse error on line ' + (lexer.yylineno + 1) + ': ';\n } else {\n errStr = 'Parse error: ';\n }\n if (typeof lexer.showPosition === 'function') {\n errStr += '\\n' + lexer.showPosition(79 - 10, 10) + '\\n';\n }\n if (expected.length) {\n errStr += 'Expecting ' + expected.join(', ') + ', got unexpected ' + errSymbolDescr;\n } else {\n errStr += 'Unexpected ' + errSymbolDescr;\n }\n // we cannot recover from the error!\n p = this.constructParseErrorInfo(errStr, null, expected, false);\n r = this.parseError(p.errStr, p, this.JisonParserError);\n if (typeof r !== 'undefined') {\n retval = r;\n }\n break;\n }\n\n\n }\n\n\n\n\n\n\n\n\n\n\n switch (action) {\n // catch misc. parse failures:\n default:\n // this shouldn't happen, unless resolve defaults are off\n if (action instanceof Array) {\n p = this.constructParseErrorInfo('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol, null, null, false);\n r = this.parseError(p.errStr, p, this.JisonParserError);\n if (typeof r !== 'undefined') {\n retval = r;\n }\n break;\n }\n // Another case of better safe than sorry: in case state transitions come out of another error recovery process\n // or a buggy LUT (LookUp Table):\n p = this.constructParseErrorInfo('Parsing halted. No viable error recovery approach available due to internal system failure.', null, null, false);\n r = this.parseError(p.errStr, p, this.JisonParserError);\n if (typeof r !== 'undefined') {\n retval = r;\n }\n break;\n\n // shift:\n case 1:\n stack[sp] = symbol;\n vstack[sp] = lexer.yytext;\n\n sstack[sp] = newState; // push state\n\n ++sp;\n symbol = 0;\n\n\n\n\n // Pick up the lexer details for the current symbol as that one is not 'look-ahead' any more:\n\n\n\n\n continue;\n\n // reduce:\n case 2:\n\n\n\n this_production = this.productions_[newState - 1]; // `this.productions_[]` is zero-based indexed while states start from 1 upwards...\n yyrulelen = this_production[1];\n\n\n\n\n\n\n\n\n\n\n r = this.performAction.call(yyval, newState, sp - 1, vstack);\n\n if (typeof r !== 'undefined') {\n retval = r;\n break;\n }\n\n // pop off stack\n sp -= yyrulelen;\n\n // don't overwrite the `symbol` variable: use a local var to speed things up:\n var ntsymbol = this_production[0]; // push nonterminal (reduce)\n stack[sp] = ntsymbol;\n vstack[sp] = yyval.$;\n\n // goto new state = table[STATE][NONTERMINAL]\n newState = table[sstack[sp - 1]][ntsymbol];\n sstack[sp] = newState;\n ++sp;\n\n\n\n\n\n\n\n\n\n continue;\n\n // accept:\n case 3:\n if (sp !== -2) {\n retval = true;\n // Return the `$accept` rule's `$$` result, if available.\n //\n // Also note that JISON always adds this top-most `$accept` rule (with implicit,\n // default, action):\n //\n // $accept: $end\n // %{ $$ = $1; @$ = @1; %}\n //\n // which, combined with the parse kernel's `$accept` state behaviour coded below,\n // will produce the `$$` value output of the rule as the parse result,\n // IFF that result is *not* `undefined`. (See also the parser kernel code.)\n //\n // In code:\n //\n // %{\n // @$ = @1; // if location tracking support is included\n // if (typeof $1 !== 'undefined')\n // return $1;\n // else\n // return true; // the default parse result if the rule actions don't produce anything\n // %}\n sp--;\n if (typeof vstack[sp] !== 'undefined') {\n retval = vstack[sp];\n }\n }\n break;\n }\n\n // break out of loop: we accept or fail with error\n break;\n }\n } catch (ex) {\n // report exceptions through the parseError callback too, but keep the exception intact\n // if it is a known parser or lexer error which has been thrown by parseError() already:\n if (ex instanceof this.JisonParserError) {\n throw ex;\n }\n else if (lexer && typeof lexer.JisonLexerError === 'function' && ex instanceof lexer.JisonLexerError) {\n throw ex;\n }\n\n p = this.constructParseErrorInfo('Parsing aborted due to exception.', ex, null, false);\n retval = false;\n r = this.parseError(p.errStr, p, this.JisonParserError);\n if (typeof r !== 'undefined') {\n retval = r;\n }\n } finally {\n retval = this.cleanupAfterParse(retval, true, true);\n this.__reentrant_call_depth--;\n } // /finally\n\n return retval;\n}\n};\nparser.originalParseError = parser.parseError;\nparser.originalQuoteName = parser.quoteName;\n/* lexer generated by jison-lex 0.6.1-215 */\n\n/*\n * Returns a Lexer object of the following structure:\n *\n * Lexer: {\n * yy: {} The so-called \"shared state\" or rather the *source* of it;\n * the real \"shared state\" `yy` passed around to\n * the rule actions, etc. is a direct reference!\n *\n * This \"shared context\" object was passed to the lexer by way of \n * the `lexer.setInput(str, yy)` API before you may use it.\n *\n * This \"shared context\" object is passed to the lexer action code in `performAction()`\n * so userland code in the lexer actions may communicate with the outside world \n * and/or other lexer rules' actions in more or less complex ways.\n *\n * }\n *\n * Lexer.prototype: {\n * EOF: 1,\n * ERROR: 2,\n *\n * yy: The overall \"shared context\" object reference.\n *\n * JisonLexerError: function(msg, hash),\n *\n * performAction: function lexer__performAction(yy, yyrulenumber, YY_START),\n *\n * The function parameters and `this` have the following value/meaning:\n * - `this` : reference to the `lexer` instance. \n * `yy_` is an alias for `this` lexer instance reference used internally.\n *\n * - `yy` : a reference to the `yy` \"shared state\" object which was passed to the lexer\n * by way of the `lexer.setInput(str, yy)` API before.\n *\n * Note:\n * The extra arguments you specified in the `%parse-param` statement in your\n * **parser** grammar definition file are passed to the lexer via this object\n * reference as member variables.\n *\n * - `yyrulenumber` : index of the matched lexer rule (regex), used internally.\n *\n * - `YY_START`: the current lexer \"start condition\" state.\n *\n * parseError: function(str, hash, ExceptionClass),\n *\n * constructLexErrorInfo: function(error_message, is_recoverable),\n * Helper function.\n * Produces a new errorInfo 'hash object' which can be passed into `parseError()`.\n * See it's use in this lexer kernel in many places; example usage:\n *\n * var infoObj = lexer.constructParseErrorInfo('fail!', true);\n * var retVal = lexer.parseError(infoObj.errStr, infoObj, lexer.JisonLexerError);\n *\n * options: { ... lexer %options ... },\n *\n * lex: function(),\n * Produce one token of lexed input, which was passed in earlier via the `lexer.setInput()` API.\n * You MAY use the additional `args...` parameters as per `%parse-param` spec of the **lexer** grammar:\n * these extra `args...` are added verbatim to the `yy` object reference as member variables.\n *\n * WARNING:\n * Lexer's additional `args...` parameters (via lexer's `%parse-param`) MAY conflict with\n * any attributes already added to `yy` by the **parser** or the jison run-time; \n * when such a collision is detected an exception is thrown to prevent the generated run-time \n * from silently accepting this confusing and potentially hazardous situation! \n *\n * cleanupAfterLex: function(do_not_nuke_errorinfos),\n * Helper function.\n *\n * This helper API is invoked when the **parse process** has completed: it is the responsibility\n * of the **parser** (or the calling userland code) to invoke this method once cleanup is desired. \n *\n * This helper may be invoked by user code to ensure the internal lexer gets properly garbage collected.\n *\n * setInput: function(input, [yy]),\n *\n *\n * input: function(),\n *\n *\n * unput: function(str),\n *\n *\n * more: function(),\n *\n *\n * reject: function(),\n *\n *\n * less: function(n),\n *\n *\n * pastInput: function(n),\n *\n *\n * upcomingInput: function(n),\n *\n *\n * showPosition: function(),\n *\n *\n * test_match: function(regex_match_array, rule_index),\n *\n *\n * next: function(),\n *\n *\n * begin: function(condition),\n *\n *\n * pushState: function(condition),\n *\n *\n * popState: function(),\n *\n *\n * topState: function(),\n *\n *\n * _currentRules: function(),\n *\n *\n * stateStackSize: function(),\n *\n *\n * performAction: function(yy, yy_, yyrulenumber, YY_START),\n *\n *\n * rules: [...],\n *\n *\n * conditions: {associative list: name ==> set},\n * }\n *\n *\n * token location info (`yylloc`): {\n * first_line: n,\n * last_line: n,\n * first_column: n,\n * last_column: n,\n * range: [start_number, end_number]\n * (where the numbers are indexes into the input string, zero-based)\n * }\n *\n * ---\n *\n * The `parseError` function receives a 'hash' object with these members for lexer errors:\n *\n * {\n * text: (matched text)\n * token: (the produced terminal token, if any)\n * token_id: (the produced terminal token numeric ID, if any)\n * line: (yylineno)\n * loc: (yylloc)\n * recoverable: (boolean: TRUE when the parser MAY have an error recovery rule\n * available for this particular error)\n * yy: (object: the current parser internal \"shared state\" `yy`\n * as is also available in the rule actions; this can be used,\n * for instance, for advanced error analysis and reporting)\n * lexer: (reference to the current lexer instance used by the parser)\n * }\n *\n * while `this` will reference the current lexer instance.\n *\n * When `parseError` is invoked by the lexer, the default implementation will\n * attempt to invoke `yy.parser.parseError()`; when this callback is not provided\n * it will try to invoke `yy.parseError()` instead. When that callback is also not\n * provided, a `JisonLexerError` exception will be thrown containing the error\n * message and `hash`, as constructed by the `constructLexErrorInfo()` API.\n *\n * Note that the lexer's `JisonLexerError` error class is passed via the\n * `ExceptionClass` argument, which is invoked to construct the exception\n * instance to be thrown, so technically `parseError` will throw the object\n * produced by the `new ExceptionClass(str, hash)` JavaScript expression.\n *\n * ---\n *\n * You can specify lexer options by setting / modifying the `.options` object of your Lexer instance.\n * These options are available:\n *\n * (Options are permanent.)\n * \n * yy: {\n * parseError: function(str, hash, ExceptionClass)\n * optional: overrides the default `parseError` function.\n * }\n *\n * lexer.options: {\n * pre_lex: function()\n * optional: is invoked before the lexer is invoked to produce another token.\n * `this` refers to the Lexer object.\n * post_lex: function(token) { return token; }\n * optional: is invoked when the lexer has produced a token `token`;\n * this function can override the returned token value by returning another.\n * When it does not return any (truthy) value, the lexer will return\n * the original `token`.\n * `this` refers to the Lexer object.\n *\n * WARNING: the next set of options are not meant to be changed. They echo the abilities of\n * the lexer as per when it was compiled!\n *\n * ranges: boolean\n * optional: `true` ==> token location info will include a .range[] member.\n * flex: boolean\n * optional: `true` ==> flex-like lexing behaviour where the rules are tested\n * exhaustively to find the longest match.\n * backtrack_lexer: boolean\n * optional: `true` ==> lexer regexes are tested in order and for invoked;\n * the lexer terminates the scan when a token is returned by the action code.\n * xregexp: boolean\n * optional: `true` ==> lexer rule regexes are \"extended regex format\" requiring the\n * `XRegExp` library. When this %option has not been specified at compile time, all lexer\n * rule regexes have been written as standard JavaScript RegExp expressions.\n * }\n */\n\n\nvar lexer = function() {\n /**\n * See also:\n * http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript/#35881508\n * but we keep the prototype.constructor and prototype.name assignment lines too for compatibility\n * with userland code which might access the derived class in a 'classic' way.\n *\n * @public\n * @constructor\n * @nocollapse\n */\n function JisonLexerError(msg, hash) {\n Object.defineProperty(this, 'name', {\n enumerable: false,\n writable: false,\n value: 'JisonLexerError'\n });\n\n if (msg == null)\n msg = '???';\n\n Object.defineProperty(this, 'message', {\n enumerable: false,\n writable: true,\n value: msg\n });\n\n this.hash = hash;\n var stacktrace;\n\n if (hash && hash.exception instanceof Error) {\n var ex2 = hash.exception;\n this.message = ex2.message || msg;\n stacktrace = ex2.stack;\n }\n\n if (!stacktrace) {\n if (Error.hasOwnProperty('captureStackTrace')) {\n // V8\n Error.captureStackTrace(this, this.constructor);\n } else {\n stacktrace = new Error(msg).stack;\n }\n }\n\n if (stacktrace) {\n Object.defineProperty(this, 'stack', {\n enumerable: false,\n writable: false,\n value: stacktrace\n });\n }\n }\n\n if (typeof Object.setPrototypeOf === 'function') {\n Object.setPrototypeOf(JisonLexerError.prototype, Error.prototype);\n } else {\n JisonLexerError.prototype = Object.create(Error.prototype);\n }\n\n JisonLexerError.prototype.constructor = JisonLexerError;\n JisonLexerError.prototype.name = 'JisonLexerError';\n\n var lexer = {\n \n// Code Generator Information Report\n// ---------------------------------\n//\n// Options:\n//\n// backtracking: .................... false\n// location.ranges: ................. false\n// location line+column tracking: ... true\n//\n//\n// Forwarded Parser Analysis flags:\n//\n// uses yyleng: ..................... false\n// uses yylineno: ................... false\n// uses yytext: ..................... false\n// uses yylloc: ..................... false\n// uses lexer values: ............... true / true\n// location tracking: ............... false\n// location assignment: ............. false\n//\n//\n// Lexer Analysis flags:\n//\n// uses yyleng: ..................... ???\n// uses yylineno: ................... ???\n// uses yytext: ..................... ???\n// uses yylloc: ..................... ???\n// uses ParseError API: ............. ???\n// uses yyerror: .................... ???\n// uses location tracking & editing: ???\n// uses more() API: ................. ???\n// uses unput() API: ................ ???\n// uses reject() API: ............... ???\n// uses less() API: ................. ???\n// uses display APIs pastInput(), upcomingInput(), showPosition():\n// ............................. ???\n// uses describeYYLLOC() API: ....... ???\n//\n// --------- END OF REPORT -----------\n\nEOF: 1,\n ERROR: 2,\n\n // JisonLexerError: JisonLexerError, /// <-- injected by the code generator\n\n // options: {}, /// <-- injected by the code generator\n\n // yy: ..., /// <-- injected by setInput()\n\n __currentRuleSet__: null, /// INTERNAL USE ONLY: internal rule set cache for the current lexer state \n\n __error_infos: [], /// INTERNAL USE ONLY: the set of lexErrorInfo objects created since the last cleanup \n __decompressed: false, /// INTERNAL USE ONLY: mark whether the lexer instance has been 'unfolded' completely and is now ready for use \n done: false, /// INTERNAL USE ONLY \n _backtrack: false, /// INTERNAL USE ONLY \n _input: '', /// INTERNAL USE ONLY \n _more: false, /// INTERNAL USE ONLY \n _signaled_error_token: false, /// INTERNAL USE ONLY \n conditionStack: [], /// INTERNAL USE ONLY; managed via `pushState()`, `popState()`, `topState()` and `stateStackSize()` \n 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! \n matched: '', /// READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: tracks entire input which has been matched so far \n matches: false, /// READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: tracks RE match result for last (successful) match attempt \n 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. \n 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 \n yyleng: 0, /// READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: length of matched input for the token under construction (`yytext`) \n yylineno: 0, /// READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: 'line number' at which the token under construction is located \n yylloc: null, /// READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: tracks location info (lines + columns) for the token under construction \n\n /**\n * INTERNAL USE: construct a suitable error info hash object instance for `parseError`.\n * \n * @public\n * @this {RegExpLexer}\n */\n constructLexErrorInfo: function lexer_constructLexErrorInfo(msg, recoverable, show_input_position) {\n msg = '' + msg;\n\n // heuristic to determine if the error message already contains a (partial) source code dump\n // as produced by either `showPosition()` or `prettyPrintRange()`:\n if (show_input_position == undefined) {\n show_input_position = !(msg.indexOf('\\n') > 0 && msg.indexOf('^') > 0);\n }\n\n if (this.yylloc && show_input_position) {\n if (typeof this.prettyPrintRange === 'function') {\n var pretty_src = this.prettyPrintRange(this.yylloc);\n\n if (!/\\n\\s*$/.test(msg)) {\n msg += '\\n';\n }\n\n msg += '\\n Erroneous area:\\n' + this.prettyPrintRange(this.yylloc);\n } else if (typeof this.showPosition === 'function') {\n var pos_str = this.showPosition();\n\n if (pos_str) {\n if (msg.length && msg[msg.length - 1] !== '\\n' && pos_str[0] !== '\\n') {\n msg += '\\n' + pos_str;\n } else {\n msg += pos_str;\n }\n }\n }\n }\n\n /** @constructor */\n var pei = {\n errStr: msg,\n recoverable: !!recoverable,\n 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'... \n token: null,\n line: this.yylineno,\n loc: this.yylloc,\n yy: this.yy,\n lexer: this,\n\n /**\n * and make sure the error info doesn't stay due to potential\n * ref cycle via userland code manipulations.\n * These would otherwise all be memory leak opportunities!\n * \n * Note that only array and object references are nuked as those\n * constitute the set of elements which can produce a cyclic ref.\n * The rest of the members is kept intact as they are harmless.\n * \n * @public\n * @this {LexErrorInfo}\n */\n destroy: function destructLexErrorInfo() {\n // remove cyclic references added to error info:\n // info.yy = null;\n // info.lexer = null;\n // ...\n var rec = !!this.recoverable;\n\n for (var key in this) {\n if (this.hasOwnProperty(key) && typeof key === 'object') {\n this[key] = undefined;\n }\n }\n\n this.recoverable = rec;\n }\n };\n\n // track this instance so we can `destroy()` it once we deem it superfluous and ready for garbage collection!\n this.__error_infos.push(pei);\n\n return pei;\n },\n\n /**\n * handler which is invoked when a lexer error occurs.\n * \n * @public\n * @this {RegExpLexer}\n */\n parseError: function lexer_parseError(str, hash, ExceptionClass) {\n if (!ExceptionClass) {\n ExceptionClass = this.JisonLexerError;\n }\n\n if (this.yy) {\n if (this.yy.parser && typeof this.yy.parser.parseError === 'function') {\n return this.yy.parser.parseError.call(this, str, hash, ExceptionClass) || this.ERROR;\n } else if (typeof this.yy.parseError === 'function') {\n return this.yy.parseError.call(this, str, hash, ExceptionClass) || this.ERROR;\n }\n }\n\n throw new ExceptionClass(str, hash);\n },\n\n /**\n * method which implements `yyerror(str, ...args)` functionality for use inside lexer actions.\n * \n * @public\n * @this {RegExpLexer}\n */\n yyerror: function yyError(str /*, ...args */) {\n var lineno_msg = '';\n\n if (this.yylloc) {\n lineno_msg = ' on line ' + (this.yylineno + 1);\n }\n\n var p = this.constructLexErrorInfo(\n 'Lexical error' + lineno_msg + ': ' + str,\n this.options.lexerErrorsAreRecoverable\n );\n\n // Add any extra args to the hash under the name `extra_error_attributes`:\n var args = Array.prototype.slice.call(arguments, 1);\n\n if (args.length) {\n p.extra_error_attributes = args;\n }\n\n return this.parseError(p.errStr, p, this.JisonLexerError) || this.ERROR;\n },\n\n /**\n * final cleanup function for when we have completed lexing the input;\n * make it an API so that external code can use this one once userland\n * code has decided it's time to destroy any lingering lexer error\n * hash object instances and the like: this function helps to clean\n * up these constructs, which *may* carry cyclic references which would\n * otherwise prevent the instances from being properly and timely\n * garbage-collected, i.e. this function helps prevent memory leaks!\n * \n * @public\n * @this {RegExpLexer}\n */\n cleanupAfterLex: function lexer_cleanupAfterLex(do_not_nuke_errorinfos) {\n // prevent lingering circular references from causing memory leaks:\n this.setInput('', {});\n\n // nuke the error hash info instances created during this run.\n // Userland code must COPY any data/references\n // in the error hash instance(s) it is more permanently interested in.\n if (!do_not_nuke_errorinfos) {\n for (var i = this.__error_infos.length - 1; i >= 0; i--) {\n var el = this.__error_infos[i];\n\n if (el && typeof el.destroy === 'function') {\n el.destroy();\n }\n }\n\n this.__error_infos.length = 0;\n }\n\n return this;\n },\n\n /**\n * clear the lexer token context; intended for internal use only\n * \n * @public\n * @this {RegExpLexer}\n */\n clear: function lexer_clear() {\n this.yytext = '';\n this.yyleng = 0;\n this.match = '';\n\n // - DO NOT reset `this.matched`\n this.matches = false;\n\n this._more = false;\n this._backtrack = false;\n var col = (this.yylloc ? this.yylloc.last_column : 0);\n\n this.yylloc = {\n first_line: this.yylineno + 1,\n first_column: col,\n last_line: this.yylineno + 1,\n last_column: col,\n range: [this.offset, this.offset]\n };\n },\n\n /**\n * resets the lexer, sets new input\n * \n * @public\n * @this {RegExpLexer}\n */\n setInput: function lexer_setInput(input, yy) {\n this.yy = yy || this.yy || {};\n\n // also check if we've fully initialized the lexer instance,\n // including expansion work to be done to go from a loaded\n // lexer to a usable lexer:\n if (!this.__decompressed) {\n // step 1: decompress the regex list:\n var rules = this.rules;\n\n for (var i = 0, len = rules.length; i < len; i++) {\n var rule_re = rules[i];\n\n // compression: is the RE an xref to another RE slot in the rules[] table?\n if (typeof rule_re === 'number') {\n rules[i] = rules[rule_re];\n }\n }\n\n // step 2: unfold the conditions[] set to make these ready for use:\n var conditions = this.conditions;\n\n for (var k in conditions) {\n var spec = conditions[k];\n var rule_ids = spec.rules;\n var len = rule_ids.length;\n 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! \n var rule_new_ids = new Array(len + 1);\n\n for (var i = 0; i < len; i++) {\n var idx = rule_ids[i];\n var rule_re = rules[idx];\n rule_regexes[i + 1] = rule_re;\n rule_new_ids[i + 1] = idx;\n }\n\n spec.rules = rule_new_ids;\n spec.__rule_regexes = rule_regexes;\n spec.__rule_count = len;\n }\n\n this.__decompressed = true;\n }\n\n this._input = input || '';\n this.clear();\n this._signaled_error_token = false;\n this.done = false;\n this.yylineno = 0;\n this.matched = '';\n this.conditionStack = ['INITIAL'];\n this.__currentRuleSet__ = null;\n\n this.yylloc = {\n first_line: 1,\n first_column: 0,\n last_line: 1,\n last_column: 0,\n range: [0, 0]\n };\n\n this.offset = 0;\n return this;\n },\n\n /**\n * edit the remaining input via user-specified callback.\n * This can be used to forward-adjust the input-to-parse, \n * e.g. inserting macro expansions and alike in the\n * input which has yet to be lexed.\n * The behaviour of this API contrasts the `unput()` et al\n * APIs as those act on the *consumed* input, while this\n * one allows one to manipulate the future, without impacting\n * the current `yyloc` cursor location or any history. \n * \n * Use this API to help implement C-preprocessor-like\n * `#include` statements, etc.\n * \n * The provided callback must be synchronous and is\n * expected to return the edited input (string).\n *\n * The `cpsArg` argument value is passed to the callback\n * as-is.\n *\n * `callback` interface: \n * `function callback(input, cpsArg)`\n * \n * - `input` will carry the remaining-input-to-lex string\n * from the lexer.\n * - `cpsArg` is `cpsArg` passed into this API.\n * \n * The `this` reference for the callback will be set to\n * reference this lexer instance so that userland code\n * in the callback can easily and quickly access any lexer\n * API. \n *\n * When the callback returns a non-string-type falsey value,\n * we assume the callback did not edit the input and we\n * will using the input as-is.\n *\n * When the callback returns a non-string-type value, it\n * is converted to a string for lexing via the `\"\" + retval`\n * operation. (See also why: http://2ality.com/2012/03/converting-to-string.html \n * -- that way any returned object's `toValue()` and `toString()`\n * methods will be invoked in a proper/desirable order.)\n * \n * @public\n * @this {RegExpLexer}\n */\n editRemainingInput: function lexer_editRemainingInput(callback, cpsArg) {\n var rv = callback.call(this, this._input, cpsArg);\n\n if (typeof rv !== 'string') {\n if (rv) {\n this._input = '' + rv;\n } \n // else: keep `this._input` as is. \n } else {\n this._input = rv;\n }\n\n return this;\n },\n\n /**\n * consumes and returns one char from the input\n * \n * @public\n * @this {RegExpLexer}\n */\n input: function lexer_input() {\n if (!this._input) {\n //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 <> tokens and perform user action code for a <> match, but only does so *once*)\n return null;\n }\n\n var ch = this._input[0];\n this.yytext += ch;\n this.yyleng++;\n this.offset++;\n this.match += ch;\n this.matched += ch;\n\n // Count the linenumber up when we hit the LF (or a stand-alone CR).\n // On CRLF, the linenumber is incremented when you fetch the CR or the CRLF combo\n // and we advance immediately past the LF as well, returning both together as if\n // it was all a single 'character' only.\n var slice_len = 1;\n\n var lines = false;\n\n if (ch === '\\n') {\n lines = true;\n } else if (ch === '\\r') {\n lines = true;\n var ch2 = this._input[1];\n\n if (ch2 === '\\n') {\n slice_len++;\n ch += ch2;\n this.yytext += ch2;\n this.yyleng++;\n this.offset++;\n this.match += ch2;\n this.matched += ch2;\n this.yylloc.range[1]++;\n }\n }\n\n if (lines) {\n this.yylineno++;\n this.yylloc.last_line++;\n this.yylloc.last_column = 0;\n } else {\n this.yylloc.last_column++;\n }\n\n this.yylloc.range[1]++;\n this._input = this._input.slice(slice_len);\n return ch;\n },\n\n /**\n * unshifts one char (or an entire string) into the input\n * \n * @public\n * @this {RegExpLexer}\n */\n unput: function lexer_unput(ch) {\n var len = ch.length;\n var lines = ch.split(/(?:\\r\\n?|\\n)/g);\n this._input = ch + this._input;\n this.yytext = this.yytext.substr(0, this.yytext.length - len);\n this.yyleng = this.yytext.length;\n this.offset -= len;\n this.match = this.match.substr(0, this.match.length - len);\n this.matched = this.matched.substr(0, this.matched.length - len);\n\n if (lines.length > 1) {\n this.yylineno -= lines.length - 1;\n this.yylloc.last_line = this.yylineno + 1;\n\n // Get last entirely matched line into the `pre_lines[]` array's\n // last index slot; we don't mind when other previously \n // matched lines end up in the array too. \n var pre = this.match;\n\n var pre_lines = pre.split(/(?:\\r\\n?|\\n)/g);\n\n if (pre_lines.length === 1) {\n pre = this.matched;\n pre_lines = pre.split(/(?:\\r\\n?|\\n)/g);\n }\n\n this.yylloc.last_column = pre_lines[pre_lines.length - 1].length;\n } else {\n this.yylloc.last_column -= len;\n }\n\n this.yylloc.range[1] = this.yylloc.range[0] + this.yyleng;\n this.done = false;\n return this;\n },\n\n /**\n * cache matched text and append it on next action\n * \n * @public\n * @this {RegExpLexer}\n */\n more: function lexer_more() {\n this._more = true;\n return this;\n },\n\n /**\n * signal the lexer that this rule fails to match the input, so the\n * next matching rule (regex) should be tested instead.\n * \n * @public\n * @this {RegExpLexer}\n */\n reject: function lexer_reject() {\n if (this.options.backtrack_lexer) {\n this._backtrack = true;\n } else {\n // when the `parseError()` call returns, we MUST ensure that the error is registered.\n // We accomplish this by signaling an 'error' token to be produced for the current\n // `.lex()` run.\n var lineno_msg = '';\n\n if (this.yylloc) {\n lineno_msg = ' on line ' + (this.yylineno + 1);\n }\n\n var p = this.constructLexErrorInfo(\n 'Lexical error' + lineno_msg + ': You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).',\n false\n );\n\n this._signaled_error_token = this.parseError(p.errStr, p, this.JisonLexerError) || this.ERROR;\n }\n\n return this;\n },\n\n /**\n * retain first n characters of the match\n * \n * @public\n * @this {RegExpLexer}\n */\n less: function lexer_less(n) {\n return this.unput(this.match.slice(n));\n },\n\n /**\n * return (part of the) already matched input, i.e. for error\n * messages.\n * \n * Limit the returned string length to `maxSize` (default: 20).\n * \n * Limit the returned string to the `maxLines` number of lines of\n * input (default: 1).\n * \n * Negative limit values equal *unlimited*.\n * \n * @public\n * @this {RegExpLexer}\n */\n pastInput: function lexer_pastInput(maxSize, maxLines) {\n var past = this.matched.substring(0, this.matched.length - this.match.length);\n\n if (maxSize < 0)\n maxSize = past.length;\n else if (!maxSize)\n maxSize = 20;\n\n if (maxLines < 0)\n maxLines = past.length; // can't ever have more input lines than this! \n else if (!maxLines)\n maxLines = 1;\n\n // `substr` anticipation: treat \\r\\n as a single character and take a little\n // more than necessary so that we can still properly check against maxSize\n // after we've transformed and limited the newLines in here:\n past = past.substr(-maxSize * 2 - 2);\n\n // now that we have a significantly reduced string to process, transform the newlines\n // and chop them, then limit them:\n var a = past.replace(/\\r\\n|\\r/g, '\\n').split('\\n');\n\n a = a.slice(-maxLines);\n past = a.join('\\n');\n\n // When, after limiting to maxLines, we still have too much to return,\n // do add an ellipsis prefix...\n if (past.length > maxSize) {\n past = '...' + past.substr(-maxSize);\n }\n\n return past;\n },\n\n /**\n * return (part of the) upcoming input, i.e. for error messages.\n * \n * Limit the returned string length to `maxSize` (default: 20).\n * \n * Limit the returned string to the `maxLines` number of lines of input (default: 1).\n * \n * Negative limit values equal *unlimited*.\n *\n * > ### NOTE ###\n * >\n * > *\"upcoming input\"* is defined as the whole of the both\n * > the *currently lexed* input, together with any remaining input\n * > following that. *\"currently lexed\"* input is the input \n * > already recognized by the lexer but not yet returned with\n * > the lexer token. This happens when you are invoking this API\n * > from inside any lexer rule action code block. \n * >\n * \n * @public\n * @this {RegExpLexer}\n */\n upcomingInput: function lexer_upcomingInput(maxSize, maxLines) {\n var next = this.match;\n\n if (maxSize < 0)\n maxSize = next.length + this._input.length;\n else if (!maxSize)\n maxSize = 20;\n\n if (maxLines < 0)\n maxLines = maxSize; // can't ever have more input lines than this! \n else if (!maxLines)\n maxLines = 1;\n\n // `substring` anticipation: treat \\r\\n as a single character and take a little\n // more than necessary so that we can still properly check against maxSize\n // after we've transformed and limited the newLines in here:\n if (next.length < maxSize * 2 + 2) {\n next += this._input.substring(0, maxSize * 2 + 2); // substring is faster on Chrome/V8 \n }\n\n // now that we have a significantly reduced string to process, transform the newlines\n // and chop them, then limit them:\n var a = next.replace(/\\r\\n|\\r/g, '\\n').split('\\n');\n\n a = a.slice(0, maxLines);\n next = a.join('\\n');\n\n // When, after limiting to maxLines, we still have too much to return,\n // do add an ellipsis postfix...\n if (next.length > maxSize) {\n next = next.substring(0, maxSize) + '...';\n }\n\n return next;\n },\n\n /**\n * return a string which displays the character position where the\n * lexing error occurred, i.e. for error messages\n * \n * @public\n * @this {RegExpLexer}\n */\n showPosition: function lexer_showPosition(maxPrefix, maxPostfix) {\n var pre = this.pastInput(maxPrefix).replace(/\\s/g, ' ');\n var c = new Array(pre.length + 1).join('-');\n return pre + this.upcomingInput(maxPostfix).replace(/\\s/g, ' ') + '\\n' + c + '^';\n },\n\n /**\n * return an YYLLOC info object derived off the given context (actual, preceding, following, current).\n * Use this method when the given `actual` location is not guaranteed to exist (i.e. when\n * it MAY be NULL) and you MUST have a valid location info object anyway:\n * then we take the given context of the `preceding` and `following` locations, IFF those are available,\n * and reconstruct the `actual` location info from those.\n * If this fails, the heuristic is to take the `current` location, IFF available.\n * If this fails as well, we assume the sought location is at/around the current lexer position\n * and then produce that one as a response. DO NOTE that these heuristic/derived location info\n * values MAY be inaccurate!\n *\n * NOTE: `deriveLocationInfo()` ALWAYS produces a location info object *copy* of `actual`, not just\n * a *reference* hence all input location objects can be assumed to be 'constant' (function has no side-effects).\n * \n * @public\n * @this {RegExpLexer}\n */\n deriveLocationInfo: function lexer_deriveYYLLOC(actual, preceding, following, current) {\n var loc = {\n first_line: 1,\n first_column: 0,\n last_line: 1,\n last_column: 0,\n range: [0, 0]\n };\n\n if (actual) {\n loc.first_line = actual.first_line | 0;\n loc.last_line = actual.last_line | 0;\n loc.first_column = actual.first_column | 0;\n loc.last_column = actual.last_column | 0;\n\n if (actual.range) {\n loc.range[0] = actual.range[0] | 0;\n loc.range[1] = actual.range[1] | 0;\n }\n }\n\n if (loc.first_line <= 0 || loc.last_line < loc.first_line) {\n // plan B: heuristic using preceding and following:\n if (loc.first_line <= 0 && preceding) {\n loc.first_line = preceding.last_line | 0;\n loc.first_column = preceding.last_column | 0;\n\n if (preceding.range) {\n loc.range[0] = actual.range[1] | 0;\n }\n }\n\n if ((loc.last_line <= 0 || loc.last_line < loc.first_line) && following) {\n loc.last_line = following.first_line | 0;\n loc.last_column = following.first_column | 0;\n\n if (following.range) {\n loc.range[1] = actual.range[0] | 0;\n }\n }\n\n // plan C?: see if the 'current' location is useful/sane too:\n if (loc.first_line <= 0 && current && (loc.last_line <= 0 || current.last_line <= loc.last_line)) {\n loc.first_line = current.first_line | 0;\n loc.first_column = current.first_column | 0;\n\n if (current.range) {\n loc.range[0] = current.range[0] | 0;\n }\n }\n\n if (loc.last_line <= 0 && current && (loc.first_line <= 0 || current.first_line >= loc.first_line)) {\n loc.last_line = current.last_line | 0;\n loc.last_column = current.last_column | 0;\n\n if (current.range) {\n loc.range[1] = current.range[1] | 0;\n }\n }\n }\n\n // sanitize: fix last_line BEFORE we fix first_line as we use the 'raw' value of the latter\n // or plan D heuristics to produce a 'sensible' last_line value:\n if (loc.last_line <= 0) {\n if (loc.first_line <= 0) {\n loc.first_line = this.yylloc.first_line;\n loc.last_line = this.yylloc.last_line;\n loc.first_column = this.yylloc.first_column;\n loc.last_column = this.yylloc.last_column;\n loc.range[0] = this.yylloc.range[0];\n loc.range[1] = this.yylloc.range[1];\n } else {\n loc.last_line = this.yylloc.last_line;\n loc.last_column = this.yylloc.last_column;\n loc.range[1] = this.yylloc.range[1];\n }\n }\n\n if (loc.first_line <= 0) {\n loc.first_line = loc.last_line;\n loc.first_column = 0; // loc.last_column; \n loc.range[1] = loc.range[0];\n }\n\n if (loc.first_column < 0) {\n loc.first_column = 0;\n }\n\n if (loc.last_column < 0) {\n loc.last_column = (loc.first_column > 0 ? loc.first_column : 80);\n }\n\n return loc;\n },\n\n /**\n * return a string which displays the lines & columns of input which are referenced \n * by the given location info range, plus a few lines of context.\n * \n * This function pretty-prints the indicated section of the input, with line numbers \n * and everything!\n * \n * This function is very useful to provide highly readable error reports, while\n * the location range may be specified in various flexible ways:\n * \n * - `loc` is the location info object which references the area which should be\n * displayed and 'marked up': these lines & columns of text are marked up by `^`\n * characters below each character in the entire input range.\n * \n * - `context_loc` is the *optional* location info object which instructs this\n * pretty-printer how much *leading* context should be displayed alongside\n * the area referenced by `loc`. This can help provide context for the displayed\n * error, etc.\n * \n * When this location info is not provided, a default context of 3 lines is\n * used.\n * \n * - `context_loc2` is another *optional* location info object, which serves\n * a similar purpose to `context_loc`: it specifies the amount of *trailing*\n * context lines to display in the pretty-print output.\n * \n * When this location info is not provided, a default context of 1 line only is\n * used.\n * \n * Special Notes:\n * \n * - when the `loc`-indicated range is very large (about 5 lines or more), then\n * only the first and last few lines of this block are printed while a\n * `...continued...` message will be printed between them.\n * \n * This serves the purpose of not printing a huge amount of text when the `loc`\n * range happens to be huge: this way a manageable & readable output results\n * for arbitrary large ranges.\n * \n * - this function can display lines of input which whave not yet been lexed.\n * `prettyPrintRange()` can access the entire input!\n * \n * @public\n * @this {RegExpLexer}\n */\n prettyPrintRange: function lexer_prettyPrintRange(loc, context_loc, context_loc2) {\n loc = this.deriveLocationInfo(loc, context_loc, context_loc2);\n const CONTEXT = 3;\n const CONTEXT_TAIL = 1;\n const MINIMUM_VISIBLE_NONEMPTY_LINE_COUNT = 2;\n var input = this.matched + this._input;\n var lines = input.split('\\n');\n var l0 = Math.max(1, (context_loc ? context_loc.first_line : loc.first_line - CONTEXT));\n var l1 = Math.max(1, (context_loc2 ? context_loc2.last_line : loc.last_line + CONTEXT_TAIL));\n var lineno_display_width = 1 + Math.log10(l1 | 1) | 0;\n var ws_prefix = new Array(lineno_display_width).join(' ');\n var nonempty_line_indexes = [];\n\n var rv = lines.slice(l0 - 1, l1 + 1).map(function injectLineNumber(line, index) {\n var lno = index + l0;\n var lno_pfx = (ws_prefix + lno).substr(-lineno_display_width);\n var rv = lno_pfx + ': ' + line;\n var errpfx = new Array(lineno_display_width + 1).join('^');\n var offset = 2 + 1;\n var len = 0;\n\n if (lno === loc.first_line) {\n offset += loc.first_column;\n\n len = Math.max(\n 2,\n ((lno === loc.last_line ? loc.last_column : line.length)) - loc.first_column + 1\n );\n } else if (lno === loc.last_line) {\n len = Math.max(2, loc.last_column + 1);\n } else if (lno > loc.first_line && lno < loc.last_line) {\n len = Math.max(2, line.length + 1);\n }\n\n if (len) {\n var lead = new Array(offset).join('.');\n var mark = new Array(len).join('^');\n rv += '\\n' + errpfx + lead + mark;\n\n if (line.trim().length > 0) {\n nonempty_line_indexes.push(index);\n }\n }\n\n rv = rv.replace(/\\t/g, ' ');\n return rv;\n });\n\n // now make sure we don't print an overly large amount of error area: limit it \n // to the top and bottom line count:\n if (nonempty_line_indexes.length > 2 * MINIMUM_VISIBLE_NONEMPTY_LINE_COUNT) {\n var clip_start = nonempty_line_indexes[MINIMUM_VISIBLE_NONEMPTY_LINE_COUNT - 1] + 1;\n var clip_end = nonempty_line_indexes[nonempty_line_indexes.length - MINIMUM_VISIBLE_NONEMPTY_LINE_COUNT] - 1;\n var intermediate_line = new Array(lineno_display_width + 1).join(' ') + ' (...continued...)';\n intermediate_line += '\\n' + new Array(lineno_display_width + 1).join('-') + ' (---------------)';\n rv.splice(clip_start, clip_end - clip_start + 1, intermediate_line);\n }\n\n return rv.join('\\n');\n },\n\n /**\n * helper function, used to produce a human readable description as a string, given\n * the input `yylloc` location object.\n * \n * Set `display_range_too` to TRUE to include the string character index position(s)\n * in the description if the `yylloc.range` is available.\n * \n * @public\n * @this {RegExpLexer}\n */\n describeYYLLOC: function lexer_describe_yylloc(yylloc, display_range_too) {\n var l1 = yylloc.first_line;\n var l2 = yylloc.last_line;\n var c1 = yylloc.first_column;\n var c2 = yylloc.last_column;\n var dl = l2 - l1;\n var dc = c2 - c1;\n var rv;\n\n if (dl === 0) {\n rv = 'line ' + l1 + ', ';\n\n if (dc <= 1) {\n rv += 'column ' + c1;\n } else {\n rv += 'columns ' + c1 + ' .. ' + c2;\n }\n } else {\n rv = 'lines ' + l1 + '(column ' + c1 + ') .. ' + l2 + '(column ' + c2 + ')';\n }\n\n if (yylloc.range && display_range_too) {\n var r1 = yylloc.range[0];\n var r2 = yylloc.range[1] - 1;\n\n if (r2 <= r1) {\n rv += ' {String Offset: ' + r1 + '}';\n } else {\n rv += ' {String Offset range: ' + r1 + ' .. ' + r2 + '}';\n }\n }\n\n return rv;\n },\n\n /**\n * test the lexed token: return FALSE when not a match, otherwise return token.\n * \n * `match` is supposed to be an array coming out of a regex match, i.e. `match[0]`\n * contains the actually matched text string.\n * \n * Also move the input cursor forward and update the match collectors:\n * \n * - `yytext`\n * - `yyleng`\n * - `match`\n * - `matches`\n * - `yylloc`\n * - `offset`\n * \n * @public\n * @this {RegExpLexer}\n */\n test_match: function lexer_test_match(match, indexed_rule) {\n var token, lines, backup, match_str, match_str_len;\n\n if (this.options.backtrack_lexer) {\n // save context\n backup = {\n yylineno: this.yylineno,\n\n yylloc: {\n first_line: this.yylloc.first_line,\n last_line: this.yylloc.last_line,\n first_column: this.yylloc.first_column,\n last_column: this.yylloc.last_column,\n range: this.yylloc.range.slice(0)\n },\n\n yytext: this.yytext,\n match: this.match,\n matches: this.matches,\n matched: this.matched,\n yyleng: this.yyleng,\n offset: this.offset,\n _more: this._more,\n _input: this._input,\n\n //_signaled_error_token: this._signaled_error_token,\n yy: this.yy,\n\n conditionStack: this.conditionStack.slice(0),\n done: this.done\n };\n }\n\n match_str = match[0];\n match_str_len = match_str.length;\n\n // if (match_str.indexOf('\\n') !== -1 || match_str.indexOf('\\r') !== -1) {\n lines = match_str.split(/(?:\\r\\n?|\\n)/g);\n\n if (lines.length > 1) {\n this.yylineno += lines.length - 1;\n this.yylloc.last_line = this.yylineno + 1;\n this.yylloc.last_column = lines[lines.length - 1].length;\n } else {\n this.yylloc.last_column += match_str_len;\n }\n\n // }\n this.yytext += match_str;\n\n this.match += match_str;\n this.matched += match_str;\n this.matches = match;\n this.yyleng = this.yytext.length;\n this.yylloc.range[1] += match_str_len;\n\n // previous lex rules MAY have invoked the `more()` API rather than producing a token:\n // those rules will already have moved this `offset` forward matching their match lengths,\n // hence we must only add our own match length now:\n this.offset += match_str_len;\n\n this._more = false;\n this._backtrack = false;\n this._input = this._input.slice(match_str_len);\n\n // calling this method:\n //\n // function lexer__performAction(yy, yyrulenumber, YY_START) {...}\n token = this.performAction.call(\n this,\n this.yy,\n indexed_rule,\n this.conditionStack[this.conditionStack.length - 1] /* = YY_START */\n );\n\n // otherwise, when the action codes are all simple return token statements:\n //token = this.simpleCaseActionClusters[indexed_rule];\n\n if (this.done && this._input) {\n this.done = false;\n }\n\n if (token) {\n return token;\n } else if (this._backtrack) {\n // recover context\n for (var k in backup) {\n this[k] = backup[k];\n }\n\n this.__currentRuleSet__ = null;\n return false; // rule action called reject() implying the next rule should be tested instead. \n } else if (this._signaled_error_token) {\n // produce one 'error' token as `.parseError()` in `reject()`\n // did not guarantee a failure signal by throwing an exception!\n token = this._signaled_error_token;\n\n this._signaled_error_token = false;\n return token;\n }\n\n return false;\n },\n\n /**\n * return next match in input\n * \n * @public\n * @this {RegExpLexer}\n */\n next: function lexer_next() {\n if (this.done) {\n this.clear();\n return this.EOF;\n }\n\n if (!this._input) {\n this.done = true;\n }\n\n var token, match, tempMatch, index;\n\n if (!this._more) {\n this.clear();\n }\n\n var spec = this.__currentRuleSet__;\n\n if (!spec) {\n // Update the ruleset cache as we apparently encountered a state change or just started lexing.\n // The cache is set up for fast lookup -- we assume a lexer will switch states much less often than it will\n // invoke the `lex()` token-producing API and related APIs, hence caching the set for direct access helps\n // speed up those activities a tiny bit.\n spec = this.__currentRuleSet__ = this._currentRules();\n\n // Check whether a *sane* condition has been pushed before: this makes the lexer robust against\n // user-programmer bugs such as https://github.com/zaach/jison-lex/issues/19\n if (!spec || !spec.rules) {\n var lineno_msg = '';\n\n if (this.options.trackPosition) {\n lineno_msg = ' on line ' + (this.yylineno + 1);\n }\n\n var p = this.constructLexErrorInfo(\n 'Internal lexer engine error' + lineno_msg + ': 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\n );\n\n // produce one 'error' token until this situation has been resolved, most probably by parse termination!\n return this.parseError(p.errStr, p, this.JisonLexerError) || this.ERROR;\n }\n }\n\n var rule_ids = spec.rules;\n var regexes = spec.__rule_regexes;\n var len = spec.__rule_count;\n\n // Note: the arrays are 1-based, while `len` itself is a valid index,\n // hence the non-standard less-or-equal check in the next loop condition!\n for (var i = 1; i <= len; i++) {\n tempMatch = this._input.match(regexes[i]);\n\n if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {\n match = tempMatch;\n index = i;\n\n if (this.options.backtrack_lexer) {\n token = this.test_match(tempMatch, rule_ids[i]);\n\n if (token !== false) {\n return token;\n } else if (this._backtrack) {\n match = undefined;\n continue; // rule action called reject() implying a rule MISmatch. \n } else {\n // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)\n return false;\n }\n } else if (!this.options.flex) {\n break;\n }\n }\n }\n\n if (match) {\n token = this.test_match(match, rule_ids[index]);\n\n if (token !== false) {\n return token;\n }\n\n // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)\n return false;\n }\n\n if (!this._input) {\n this.done = true;\n this.clear();\n return this.EOF;\n } else {\n var lineno_msg = '';\n\n if (this.options.trackPosition) {\n lineno_msg = ' on line ' + (this.yylineno + 1);\n }\n\n var p = this.constructLexErrorInfo(\n 'Lexical error' + lineno_msg + ': Unrecognized text.',\n this.options.lexerErrorsAreRecoverable\n );\n\n var pendingInput = this._input;\n var activeCondition = this.topState();\n var conditionStackDepth = this.conditionStack.length;\n token = this.parseError(p.errStr, p, this.JisonLexerError) || this.ERROR;\n\n if (token === this.ERROR) {\n // we can try to recover from a lexer error that `parseError()` did not 'recover' for us\n // by moving forward at least one character at a time IFF the (user-specified?) `parseError()`\n // has not consumed/modified any pending input or changed state in the error handler:\n if (!this.matches && // and make sure the input has been modified/consumed ...\n pendingInput === this._input && // ...or the lexer state has been modified significantly enough\n // to merit a non-consuming error handling action right now.\n activeCondition === this.topState() && conditionStackDepth === this.conditionStack.length) {\n this.input();\n }\n }\n\n return token;\n }\n },\n\n /**\n * return next match that has a token\n * \n * @public\n * @this {RegExpLexer}\n */\n lex: function lexer_lex() {\n var r;\n\n // allow the PRE/POST handlers set/modify the return token for maximum flexibility of the generated lexer:\n if (typeof this.pre_lex === 'function') {\n r = this.pre_lex.call(this, 0);\n }\n\n if (typeof this.options.pre_lex === 'function') {\n // (also account for a userdef function which does not return any value: keep the token as is)\n r = this.options.pre_lex.call(this, r) || r;\n }\n\n if (this.yy && typeof this.yy.pre_lex === 'function') {\n // (also account for a userdef function which does not return any value: keep the token as is)\n r = this.yy.pre_lex.call(this, r) || r;\n }\n\n while (!r) {\n r = this.next();\n }\n\n if (this.yy && typeof this.yy.post_lex === 'function') {\n // (also account for a userdef function which does not return any value: keep the token as is)\n r = this.yy.post_lex.call(this, r) || r;\n }\n\n if (typeof this.options.post_lex === 'function') {\n // (also account for a userdef function which does not return any value: keep the token as is)\n r = this.options.post_lex.call(this, r) || r;\n }\n\n if (typeof this.post_lex === 'function') {\n // (also account for a userdef function which does not return any value: keep the token as is)\n r = this.post_lex.call(this, r) || r;\n }\n\n return r;\n },\n\n /**\n * return next match that has a token. Identical to the `lex()` API but does not invoke any of the \n * `pre_lex()` nor any of the `post_lex()` callbacks.\n * \n * @public\n * @this {RegExpLexer}\n */\n fastLex: function lexer_fastLex() {\n var r;\n\n while (!r) {\n r = this.next();\n }\n\n return r;\n },\n\n /**\n * return info about the lexer state that can help a parser or other lexer API user to use the\n * most efficient means available. This API is provided to aid run-time performance for larger\n * systems which employ this lexer.\n * \n * @public\n * @this {RegExpLexer}\n */\n canIUse: function lexer_canIUse() {\n var rv = {\n fastLex: !(typeof this.pre_lex === 'function' || typeof this.options.pre_lex === 'function' || this.yy && typeof this.yy.pre_lex === 'function' || this.yy && typeof this.yy.post_lex === 'function' || typeof this.options.post_lex === 'function' || typeof this.post_lex === 'function') && typeof this.fastLex === 'function'\n };\n\n return rv;\n },\n\n /**\n * backwards compatible alias for `pushState()`;\n * the latter is symmetrical with `popState()` and we advise to use\n * those APIs in any modern lexer code, rather than `begin()`.\n * \n * @public\n * @this {RegExpLexer}\n */\n begin: function lexer_begin(condition) {\n return this.pushState(condition);\n },\n\n /**\n * activates a new lexer condition state (pushes the new lexer\n * condition state onto the condition stack)\n * \n * @public\n * @this {RegExpLexer}\n */\n pushState: function lexer_pushState(condition) {\n this.conditionStack.push(condition);\n this.__currentRuleSet__ = null;\n return this;\n },\n\n /**\n * pop the previously active lexer condition state off the condition\n * stack\n * \n * @public\n * @this {RegExpLexer}\n */\n popState: function lexer_popState() {\n var n = this.conditionStack.length - 1;\n\n if (n > 0) {\n this.__currentRuleSet__ = null;\n return this.conditionStack.pop();\n } else {\n return this.conditionStack[0];\n }\n },\n\n /**\n * return the currently active lexer condition state; when an index\n * argument is provided it produces the N-th previous condition state,\n * if available\n * \n * @public\n * @this {RegExpLexer}\n */\n topState: function lexer_topState(n) {\n n = this.conditionStack.length - 1 - Math.abs(n || 0);\n\n if (n >= 0) {\n return this.conditionStack[n];\n } else {\n return 'INITIAL';\n }\n },\n\n /**\n * (internal) determine the lexer rule set which is active for the\n * currently active lexer condition state\n * \n * @public\n * @this {RegExpLexer}\n */\n _currentRules: function lexer__currentRules() {\n if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {\n return this.conditions[this.conditionStack[this.conditionStack.length - 1]];\n } else {\n return this.conditions['INITIAL'];\n }\n },\n\n /**\n * return the number of states currently on the stack\n * \n * @public\n * @this {RegExpLexer}\n */\n stateStackSize: function lexer_stateStackSize() {\n return this.conditionStack.length;\n },\n\n options: {\n trackPosition: true\n },\n\n JisonLexerError: JisonLexerError,\n\n performAction: function lexer__performAction(yy, yyrulenumber, YY_START) {\n var yy_ = this;\n var YYSTATE = YY_START;\n\n switch (yyrulenumber) {\n case 1:\n /*! Conditions:: INITIAL */\n /*! Rule:: \\s+ */\n /* skip whitespace */\n break;\n\n default:\n return this.simpleCaseActionClusters[yyrulenumber];\n }\n },\n\n simpleCaseActionClusters: {\n /*! Conditions:: INITIAL */\n /*! Rule:: (--[0-9a-z-A-Z-]*) */\n 0: 13,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: \\* */\n 2: 5,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: \\/ */\n 3: 6,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: \\+ */\n 4: 3,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: - */\n 5: 4,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)px\\b */\n 6: 15,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)cm\\b */\n 7: 15,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)mm\\b */\n 8: 15,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)in\\b */\n 9: 15,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)pt\\b */\n 10: 15,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)pc\\b */\n 11: 15,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)deg\\b */\n 12: 16,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)grad\\b */\n 13: 16,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)rad\\b */\n 14: 16,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)turn\\b */\n 15: 16,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)s\\b */\n 16: 17,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)ms\\b */\n 17: 17,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)Hz\\b */\n 18: 18,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)kHz\\b */\n 19: 18,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)dpi\\b */\n 20: 19,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)dpcm\\b */\n 21: 19,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)dppx\\b */\n 22: 19,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)em\\b */\n 23: 20,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)ex\\b */\n 24: 21,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)ch\\b */\n 25: 22,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)rem\\b */\n 26: 23,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)vw\\b */\n 27: 25,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)vh\\b */\n 28: 24,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)vmin\\b */\n 29: 26,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)vmax\\b */\n 30: 27,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)% */\n 31: 28,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([0-9]+(\\.[0-9]*)?|\\.[0-9]+)\\b */\n 32: 11,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: (calc) */\n 33: 9,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: (var) */\n 34: 12,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: ([a-z]+) */\n 35: 10,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: \\( */\n 36: 7,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: \\) */\n 37: 8,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: , */\n 38: 14,\n\n /*! Conditions:: INITIAL */\n /*! Rule:: $ */\n 39: 1\n },\n\n rules: [\n /* 0: */ /^(?:(--[\\d\\-A-Za-z]*))/,\n /* 1: */ /^(?:\\s+)/,\n /* 2: */ /^(?:\\*)/,\n /* 3: */ /^(?:\\/)/,\n /* 4: */ /^(?:\\+)/,\n /* 5: */ /^(?:-)/,\n /* 6: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)px\\b)/,\n /* 7: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)cm\\b)/,\n /* 8: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)mm\\b)/,\n /* 9: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)in\\b)/,\n /* 10: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)pt\\b)/,\n /* 11: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)pc\\b)/,\n /* 12: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)deg\\b)/,\n /* 13: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)grad\\b)/,\n /* 14: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)rad\\b)/,\n /* 15: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)turn\\b)/,\n /* 16: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)s\\b)/,\n /* 17: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)ms\\b)/,\n /* 18: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)Hz\\b)/,\n /* 19: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)kHz\\b)/,\n /* 20: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)dpi\\b)/,\n /* 21: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)dpcm\\b)/,\n /* 22: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)dppx\\b)/,\n /* 23: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)em\\b)/,\n /* 24: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)ex\\b)/,\n /* 25: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)ch\\b)/,\n /* 26: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)rem\\b)/,\n /* 27: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)vw\\b)/,\n /* 28: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)vh\\b)/,\n /* 29: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)vmin\\b)/,\n /* 30: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)vmax\\b)/,\n /* 31: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)%)/,\n /* 32: */ /^(?:(\\d+(\\.\\d*)?|\\.\\d+)\\b)/,\n /* 33: */ /^(?:(calc))/,\n /* 34: */ /^(?:(var))/,\n /* 35: */ /^(?:([a-z]+))/,\n /* 36: */ /^(?:\\()/,\n /* 37: */ /^(?:\\))/,\n /* 38: */ /^(?:,)/,\n /* 39: */ /^(?:$)/\n ],\n\n conditions: {\n 'INITIAL': {\n rules: [\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28,\n 29,\n 30,\n 31,\n 32,\n 33,\n 34,\n 35,\n 36,\n 37,\n 38,\n 39\n ],\n\n inclusive: true\n }\n }\n };\n\n return lexer;\n}();\nparser.lexer = lexer;\n\n\n\nfunction Parser() {\n this.yy = {};\n}\nParser.prototype = parser;\nparser.Parser = Parser;\n\nreturn new Parser();\n})();\n\n \n\n\nif (typeof require !== 'undefined' && typeof exports !== 'undefined') {\n exports.parser = parser;\n exports.Parser = parser.Parser;\n exports.parse = function () {\n return parser.parse.apply(parser, arguments);\n };\n \n}\n","var parse = require(\"./parse\");\nvar walk = require(\"./walk\");\nvar stringify = require(\"./stringify\");\n\nfunction ValueParser(value) {\n if (this instanceof ValueParser) {\n this.nodes = parse(value);\n return this;\n }\n return new ValueParser(value);\n}\n\nValueParser.prototype.toString = function() {\n return Array.isArray(this.nodes) ? stringify(this.nodes) : \"\";\n};\n\nValueParser.prototype.walk = function(cb, bubble) {\n walk(this.nodes, cb, bubble);\n return this;\n};\n\nValueParser.unit = require(\"./unit\");\n\nValueParser.walk = walk;\n\nValueParser.stringify = stringify;\n\nmodule.exports = ValueParser;\n","var openParentheses = \"(\".charCodeAt(0);\nvar closeParentheses = \")\".charCodeAt(0);\nvar singleQuote = \"'\".charCodeAt(0);\nvar doubleQuote = '\"'.charCodeAt(0);\nvar backslash = \"\\\\\".charCodeAt(0);\nvar slash = \"/\".charCodeAt(0);\nvar comma = \",\".charCodeAt(0);\nvar colon = \":\".charCodeAt(0);\nvar star = \"*\".charCodeAt(0);\n\nmodule.exports = function(input) {\n var tokens = [];\n var value = input;\n\n var next, quote, prev, token, escape, escapePos, whitespacePos;\n var pos = 0;\n var code = value.charCodeAt(pos);\n var max = value.length;\n var stack = [{ nodes: tokens }];\n var balanced = 0;\n var parent;\n\n var name = \"\";\n var before = \"\";\n var after = \"\";\n\n while (pos < max) {\n // Whitespaces\n if (code <= 32) {\n next = pos;\n do {\n next += 1;\n code = value.charCodeAt(next);\n } while (code <= 32);\n token = value.slice(pos, next);\n\n prev = tokens[tokens.length - 1];\n if (code === closeParentheses && balanced) {\n after = token;\n } else if (prev && prev.type === \"div\") {\n prev.after = token;\n } else if (\n code === comma ||\n code === colon ||\n (code === slash && value.charCodeAt(next + 1) !== star)\n ) {\n before = token;\n } else {\n tokens.push({\n type: \"space\",\n sourceIndex: pos,\n value: token\n });\n }\n\n pos = next;\n\n // Quotes\n } else if (code === singleQuote || code === doubleQuote) {\n next = pos;\n quote = code === singleQuote ? \"'\" : '\"';\n token = {\n type: \"string\",\n sourceIndex: pos,\n quote: quote\n };\n do {\n escape = false;\n next = value.indexOf(quote, next + 1);\n if (~next) {\n escapePos = next;\n while (value.charCodeAt(escapePos - 1) === backslash) {\n escapePos -= 1;\n escape = !escape;\n }\n } else {\n value += quote;\n next = value.length - 1;\n token.unclosed = true;\n }\n } while (escape);\n token.value = value.slice(pos + 1, next);\n\n tokens.push(token);\n pos = next + 1;\n code = value.charCodeAt(pos);\n\n // Comments\n } else if (code === slash && value.charCodeAt(pos + 1) === star) {\n token = {\n type: \"comment\",\n sourceIndex: pos\n };\n\n next = value.indexOf(\"*/\", pos);\n if (next === -1) {\n token.unclosed = true;\n next = value.length;\n }\n\n token.value = value.slice(pos + 2, next);\n tokens.push(token);\n\n pos = next + 2;\n code = value.charCodeAt(pos);\n\n // Dividers\n } else if (code === slash || code === comma || code === colon) {\n token = value[pos];\n\n tokens.push({\n type: \"div\",\n sourceIndex: pos - before.length,\n value: token,\n before: before,\n after: \"\"\n });\n before = \"\";\n\n pos += 1;\n code = value.charCodeAt(pos);\n\n // Open parentheses\n } else if (openParentheses === code) {\n // Whitespaces after open parentheses\n next = pos;\n do {\n next += 1;\n code = value.charCodeAt(next);\n } while (code <= 32);\n token = {\n type: \"function\",\n sourceIndex: pos - name.length,\n value: name,\n before: value.slice(pos + 1, next)\n };\n pos = next;\n\n if (name === \"url\" && code !== singleQuote && code !== doubleQuote) {\n next -= 1;\n do {\n escape = false;\n next = value.indexOf(\")\", next + 1);\n if (~next) {\n escapePos = next;\n while (value.charCodeAt(escapePos - 1) === backslash) {\n escapePos -= 1;\n escape = !escape;\n }\n } else {\n value += \")\";\n next = value.length - 1;\n token.unclosed = true;\n }\n } while (escape);\n // Whitespaces before closed\n whitespacePos = next;\n do {\n whitespacePos -= 1;\n code = value.charCodeAt(whitespacePos);\n } while (code <= 32);\n if (pos !== whitespacePos + 1) {\n token.nodes = [\n {\n type: \"word\",\n sourceIndex: pos,\n value: value.slice(pos, whitespacePos + 1)\n }\n ];\n } else {\n token.nodes = [];\n }\n if (token.unclosed && whitespacePos + 1 !== next) {\n token.after = \"\";\n token.nodes.push({\n type: \"space\",\n sourceIndex: whitespacePos + 1,\n value: value.slice(whitespacePos + 1, next)\n });\n } else {\n token.after = value.slice(whitespacePos + 1, next);\n }\n pos = next + 1;\n code = value.charCodeAt(pos);\n tokens.push(token);\n } else {\n balanced += 1;\n token.after = \"\";\n tokens.push(token);\n stack.push(token);\n tokens = token.nodes = [];\n parent = token;\n }\n name = \"\";\n\n // Close parentheses\n } else if (closeParentheses === code && balanced) {\n pos += 1;\n code = value.charCodeAt(pos);\n\n parent.after = after;\n after = \"\";\n balanced -= 1;\n stack.pop();\n parent = stack[balanced];\n tokens = parent.nodes;\n\n // Words\n } else {\n next = pos;\n do {\n if (code === backslash) {\n next += 1;\n }\n next += 1;\n code = value.charCodeAt(next);\n } while (\n next < max &&\n !(\n code <= 32 ||\n code === singleQuote ||\n code === doubleQuote ||\n code === comma ||\n code === colon ||\n code === slash ||\n code === openParentheses ||\n (code === closeParentheses && balanced)\n )\n );\n token = value.slice(pos, next);\n\n if (openParentheses === code) {\n name = token;\n } else {\n tokens.push({\n type: \"word\",\n sourceIndex: pos,\n value: token\n });\n }\n\n pos = next;\n }\n }\n\n for (pos = stack.length - 1; pos; pos -= 1) {\n stack[pos].unclosed = true;\n }\n\n return stack[0].nodes;\n};\n","function stringifyNode(node, custom) {\n var type = node.type;\n var value = node.value;\n var buf;\n var customResult;\n\n if (custom && (customResult = custom(node)) !== undefined) {\n return customResult;\n } else if (type === \"word\" || type === \"space\") {\n return value;\n } else if (type === \"string\") {\n buf = node.quote || \"\";\n return buf + value + (node.unclosed ? \"\" : buf);\n } else if (type === \"comment\") {\n return \"/*\" + value + (node.unclosed ? \"\" : \"*/\");\n } else if (type === \"div\") {\n return (node.before || \"\") + value + (node.after || \"\");\n } else if (Array.isArray(node.nodes)) {\n buf = stringify(node.nodes);\n if (type !== \"function\") {\n return buf;\n }\n return (\n value +\n \"(\" +\n (node.before || \"\") +\n buf +\n (node.after || \"\") +\n (node.unclosed ? \"\" : \")\")\n );\n }\n return value;\n}\n\nfunction stringify(nodes, custom) {\n var result, i;\n\n if (Array.isArray(nodes)) {\n result = \"\";\n for (i = nodes.length - 1; ~i; i -= 1) {\n result = stringifyNode(nodes[i], custom) + result;\n }\n return result;\n }\n return stringifyNode(nodes, custom);\n}\n\nmodule.exports = stringify;\n","var minus = \"-\".charCodeAt(0);\nvar plus = \"+\".charCodeAt(0);\nvar dot = \".\".charCodeAt(0);\nvar exp = \"e\".charCodeAt(0);\nvar EXP = \"E\".charCodeAt(0);\n\nmodule.exports = function(value) {\n var pos = 0;\n var length = value.length;\n var dotted = false;\n var sciPos = -1;\n var containsNumber = false;\n var code;\n\n while (pos < length) {\n code = value.charCodeAt(pos);\n\n if (code >= 48 && code <= 57) {\n containsNumber = true;\n } else if (code === exp || code === EXP) {\n if (sciPos > -1) {\n break;\n }\n sciPos = pos;\n } else if (code === dot) {\n if (dotted) {\n break;\n }\n dotted = true;\n } else if (code === plus || code === minus) {\n if (pos !== 0) {\n break;\n }\n } else {\n break;\n }\n\n pos += 1;\n }\n\n if (sciPos + 1 === pos) pos--;\n\n return containsNumber\n ? {\n number: value.slice(0, pos),\n unit: value.slice(pos)\n }\n : false;\n};\n","module.exports = function walk(nodes, cb, bubble) {\n var i, max, node, result;\n\n for (i = 0, max = nodes.length; i < max; i += 1) {\n node = nodes[i];\n if (!bubble) {\n result = cb(node, i, nodes);\n }\n\n if (\n result !== false &&\n node.type === \"function\" &&\n Array.isArray(node.nodes)\n ) {\n walk(node.nodes, cb, bubble);\n }\n\n if (bubble) {\n cb(node, i, nodes);\n }\n }\n};\n"],"names":["exports","_postcssValueParser","_postcssValueParser2","_interopRequireDefault","_parser","_reducer","_reducer2","_stringifier","_stringifier2","obj","MATCH_CALC","value","precision","node","contents","ast","reducedAst","module","_cssUnitConverter","_cssUnitConverter2","convertNodes","left","right","convertAbsoluteLength","flip","_convert","_convert2","reduce","reduceMathExpression","isEqual","isValueType","type","convertMathExpression","nodes","operator","flipValue","reduceAddSubExpression","_node","op","reduceDivisionExpression","reduceMultiplicationExpression","calc","str","stringify","order","round","prec","parser","JisonParserError","msg","hash","stacktrace","ex2","bp","s","rv","p","r","i","l","bda","d","g","j","bt","y","t","a","m","n","q","z","c","u","e","id_str","symbol","key","id","state","do_not_describe","TERROR","tokenset","check","yystate","yysp","yyvstack","yy","yyparser","yylexer","prev","ExceptionClass","input","self","stack","sstack","vstack","table","sp","EOF","ERROR_RECOVERY_TOKEN_DISCARD_COUNT","NO_ACTION","lexer","sharedState_yy","ASSERT","cond","shallow_copy_noclobber","dst","src","k","resultValue","invoke_post_methods","do_not_nuke_errorinfos","el","ex","expected","recoverable","pei","action","newState","rec","getNonTerminalFromCode","tokenName","stdLex","token","fastLex","lex","yyval","yyrulelen","this_production","retval","lexerInfo","errStr","errSymbolDescr","ntsymbol","JisonLexerError","show_input_position","pretty_src","pos_str","lineno_msg","args","col","rules","len","rule_re","conditions","spec","rule_ids","rule_regexes","rule_new_ids","idx","callback","cpsArg","ch","slice_len","lines","ch2","pre","pre_lines","maxSize","maxLines","past","next","maxPrefix","maxPostfix","actual","preceding","following","current","loc","context_loc","context_loc2","CONTEXT","CONTEXT_TAIL","MINIMUM_VISIBLE_NONEMPTY_LINE_COUNT","l0","l1","lineno_display_width","ws_prefix","nonempty_line_indexes","line","index","lno","lno_pfx","errpfx","offset","lead","mark","clip_start","clip_end","intermediate_line","yylloc","display_range_too","l2","c1","c2","dl","dc","r1","r2","match","indexed_rule","backup","match_str","match_str_len","tempMatch","regexes","pendingInput","activeCondition","conditionStackDepth","condition","yyrulenumber","YY_START","yy_","YYSTATE","Parser","parse","walk","ValueParser","cb","bubble","openParentheses","closeParentheses","singleQuote","doubleQuote","backslash","slash","comma","colon","star","tokens","quote","escape","escapePos","whitespacePos","pos","code","max","balanced","parent","name","before","after","stringifyNode","custom","buf","customResult","result","minus","plus","dot","exp","EXP","length","dotted","sciPos","containsNumber"],"sourceRoot":""}