{"version":3,"sources":["../../node_modules/.pnpm/reduce-css-calc@2.1.8/node_modules/reduce-css-calc/dist/parser.js","../../node_modules/.pnpm/reduce-css-calc@2.1.8/node_modules/reduce-css-calc/dist/lib/convert.js","../../node_modules/.pnpm/reduce-css-calc@2.1.8/node_modules/reduce-css-calc/dist/lib/stringifier.js","../../node_modules/.pnpm/resize-observer-polyfill@1.5.1/node_modules/resize-observer-polyfill/dist/ResizeObserver.es.js","../../node_modules/.pnpm/reduce-css-calc@2.1.8/node_modules/reduce-css-calc/dist/index.js","../../node_modules/.pnpm/reduce-css-calc@2.1.8/node_modules/reduce-css-calc/dist/lib/reducer.js","../../node_modules/.pnpm/resolve-pathname@3.0.0/node_modules/resolve-pathname/esm/resolve-pathname.js","../../node_modules/.pnpm/scheduler@0.20.2/node_modules/scheduler/index.js","../../node_modules/.pnpm/scheduler@0.20.2/node_modules/scheduler/cjs/scheduler.production.min.js"],"names":["parser","JisonParserError","msg","hash","Object","defineProperty","enumerable","writable","value","stacktrace","exception","Error","ex2","message","stack","hasOwnProperty","captureStackTrace","constructor","setPrototypeOf","prototype","create","name","bp","s","rv","p","pop","r","rule","i","l","length","push","bda","d","idx","g","goto","j","bt","len","y","symbol","t","type","a","state","m","mode","n","q","z","shift","c","u","e","apply","trace","no_op_trace","yy","options","hasPartialLrUpgradeOnConflict","errorRecoveryTokenDiscardCount","symbols_","terminals_","TERROR","EOF","originalQuoteName","originalParseError","cleanupAfterParse","constructParseErrorInfo","yyMergeLocationInfo","__reentrant_call_depth","__error_infos","__error_recovery_infos","quoteName","parser_quoteName","id_str","getSymbolName","parser_getSymbolName","key","describeSymbol","parser_describeSymbol","terminal_descriptions_","id","collect_expected_token_set","parser_collect_expected_token_set","do_not_describe","tokenset","check","state_descriptions_","table","productions_","performAction","parser__PerformAction","yystate","yysp","yyvstack","yyparser","yylexer","lexer","$","operator","left","right","prefix","parseFloat","fallback","unit","exec","prev","defaultActions","parseError","str","ExceptionClass","recoverable","destroy","parse","input","self","Array","sstack","vstack","sp","ERROR_RECOVERY_TOKEN_DISCARD_COUNT","NO_ACTION","__lexer__","sharedState_yy","undefined","pre_parse","post_parse","pre_lex","post_lex","ASSERT","assert","JisonAssert","cond","yyGetSharedState","shallow_copy_noclobber","dst","src","k","call","parseErrorAlt","quoteNameAlt","parser_cleanupAfterParse","resultValue","invoke_post_methods","do_not_nuke_errorinfos","cleanupAfterLex","el","parser_constructParseErrorInfo","ex","expected","pei","errStr","text","match","yytext","token","token_id","line","yylineno","action","new_state","newState","symbol_stack","state_stack","value_stack","stack_pointer","destructParseErrorInfo","rec","getNonTerminalFromCode","tokenName","stdLex","lex","fastLex","yyval","_$","yyrulelen","this_production","retval","setInput","canIUse","lexerInfo","errSymbolDescr","showPosition","join","ntsymbol","JisonLexerError","ERROR","__currentRuleSet__","__decompressed","done","_backtrack","_input","_more","_signaled_error_token","conditionStack","matched","matches","offset","yyleng","yylloc","constructLexErrorInfo","lexer_constructLexErrorInfo","show_input_position","indexOf","prettyPrintRange","pretty_src","test","pos_str","loc","destructLexErrorInfo","lexer_parseError","yyerror","yyError","lineno_msg","lexerErrorsAreRecoverable","args","slice","arguments","extra_error_attributes","lexer_cleanupAfterLex","clear","lexer_clear","col","last_column","first_line","first_column","last_line","range","lexer_setInput","rules","rule_re","conditions","spec","rule_ids","rule_regexes","rule_new_ids","__rule_regexes","__rule_count","editRemainingInput","lexer_editRemainingInput","callback","cpsArg","lexer_input","ch","slice_len","lines","ch2","unput","lexer_unput","split","substr","pre","pre_lines","more","lexer_more","reject","lexer_reject","backtrack_lexer","less","lexer_less","pastInput","lexer_pastInput","maxSize","maxLines","past","substring","replace","upcomingInput","lexer_upcomingInput","next","lexer_showPosition","maxPrefix","maxPostfix","deriveLocationInfo","lexer_deriveYYLLOC","actual","preceding","following","current","lexer_prettyPrintRange","context_loc","context_loc2","CONTEXT","CONTEXT_TAIL","MINIMUM_VISIBLE_NONEMPTY_LINE_COUNT","l0","Math","max","l1","lineno_display_width","log10","ws_prefix","nonempty_line_indexes","map","injectLineNumber","index","lno","lno_pfx","errpfx","lead","mark","trim","clip_start","clip_end","intermediate_line","splice","describeYYLLOC","lexer_describe_yylloc","display_range_too","l2","c1","c2","dl","dc","r1","r2","test_match","lexer_test_match","indexed_rule","backup","match_str","match_str_len","lexer_next","tempMatch","_currentRules","trackPosition","topState","regexes","flex","pendingInput","activeCondition","conditionStackDepth","lexer_lex","lexer_fastLex","lexer_canIUse","begin","lexer_begin","condition","pushState","lexer_pushState","popState","lexer_popState","lexer_topState","abs","lexer__currentRules","stateStackSize","lexer_stateStackSize","lexer__performAction","yyrulenumber","YY_START","yy_","YYSTATE","simpleCaseActionClusters","inclusive","Parser","exports","_cssUnitConverter","require","_cssUnitConverter2","_interopRequireDefault","obj","__esModule","default","convertNodes","precision","convertAbsoluteLength","module","calc","node","stringify","_reducer","order","round","prec","pow","op","includes","flip","MapShim","Map","getIndex","arr","result","some","entry","class_1","__entries__","get","configurable","set","delete","entries","has","forEach","ctx","_i","_a","isBrowser","window","document","global$1","global","Function","requestAnimationFrame$1","requestAnimationFrame","bind","setTimeout","Date","now","trailingTimeout","throttle","delay","leadingCall","trailingCall","lastCallTime","resolvePending","proxy","timeoutCallback","timeStamp","REFRESH_DELAY","transitionKeys","mutationObserverSupported","MutationObserver","ResizeObserverController","connected_","mutationEventsAdded_","mutationsObserver_","observers_","onTransitionEnd_","refresh","addObserver","observer","connect_","removeObserver","observers","disconnect_","changesDetected","updateObservers_","activeObservers","filter","gatherActive","hasActive","broadcastActive","addEventListener","observe","attributes","childList","characterData","subtree","removeEventListener","disconnect","_b","propertyName","isReflowProperty","getInstance","instance_","defineConfigurable","target","props","keys","getWindowOf","ownerGlobal","ownerDocument","defaultView","emptyRect","createRectInit","toFloat","getBordersSize","styles","positions","reduce","size","position","getPaddings","paddings","positions_1","getSVGContentRect","bbox","getBBox","width","height","getHTMLElementContentRect","clientWidth","clientHeight","getComputedStyle","horizPad","vertPad","top","bottom","boxSizing","isDocumentElement","vertScrollbar","horizScrollbar","isSVGGraphicsElement","SVGGraphicsElement","SVGElement","documentElement","getContentRect","createReadOnlyRect","x","Constr","DOMRectReadOnly","rect","ResizeObservation","broadcastWidth","broadcastHeight","contentRect_","isActive","broadcastRect","ResizeObserverEntry","rectInit","contentRect","ResizeObserverSPI","controller","callbackCtx","activeObservations_","observations_","TypeError","callback_","controller_","callbackCtx_","Element","observations","unobserve","clearActive","_this","observation","WeakMap","ResizeObserver","method","_postcssValueParser","_postcssValueParser2","_parser","_reducer2","_stringifier","_stringifier2","MATCH_CALC","walk","contents","nodes","ast","reducedAst","toString","_convert","_convert2","reduceMathExpression","isEqual","isValueType","convertMathExpression","flipValue","reduceAddSubExpression","_node","assign","reduceDivisionExpression","reduceMultiplicationExpression","isAbsolute","pathname","charAt","spliceOne","list","resolvePathname","to","from","toParts","fromParts","isToAbs","isFromAbs","mustEndAbs","concat","hasTrailingSlash","last","up","part","unshift","process","f","h","performance","unstable_now","MessageChannel","w","b","clearTimeout","unstable_shouldYield","unstable_forceFrameRate","console","cancelAnimationFrame","error","A","B","C","D","E","floor","F","G","port2","port1","onmessage","postMessage","H","I","J","K","v","sortIndex","L","M","N","O","P","Q","R","S","T","startTime","expirationTime","U","V","priorityLevel","W","unstable_IdlePriority","unstable_ImmediatePriority","unstable_LowPriority","unstable_NormalPriority","unstable_Profiling","unstable_UserBlockingPriority","unstable_cancelCallback","unstable_continueExecution","unstable_getCurrentPriorityLevel","unstable_getFirstCallbackNode","unstable_next","unstable_pauseExecution","unstable_requestPaint","unstable_runWithPriority","unstable_scheduleCallback","unstable_wrapCallback"],"mappings":";;;;;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAIY,IAAIA,MAAM,GAAI,YAAY;EAGtC;EACA;EACA;EACA;EACA,SAASC,gBAAT,CAA0BC,GAA1B,EAA+BC,IAA/B,EAAqC;IACjCC,MAAM,CAACC,cAAP,CAAsB,IAAtB,EAA4B,MAA5B,EAAoC;MAChCC,UAAU,EAAE,KADoB;MAEhCC,QAAQ,EAAE,KAFsB;MAGhCC,KAAK,EAAE;IAHyB,CAApC;IAMA,IAAIN,GAAG,IAAI,IAAX,EAAiBA,GAAG,GAAG,KAAN;IAEjBE,MAAM,CAACC,cAAP,CAAsB,IAAtB,EAA4B,SAA5B,EAAuC;MACnCC,UAAU,EAAE,KADuB;MAEnCC,QAAQ,EAAE,IAFyB;MAGnCC,KAAK,EAAEN;IAH4B,CAAvC;IAMA,KAAKC,IAAL,GAAYA,IAAZ;IAEA,IAAIM,UAAJ;;IACA,IAAIN,IAAI,IAAIA,IAAI,CAACO,SAAL,YAA0BC,KAAtC,EAA6C;MACzC,IAAIC,GAAG,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;EACA;;EAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;EAGA,IAAIyB,KAAK,GAAG,YAAW;IACrB;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;IACE,SAASyF,eAAT,CAAyB3L,GAAzB,EAA8BC,I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","file":"static/js/vendors~main~d62b924b.2e8468eb.chunk.js","sourcesContent":["\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: <startSymbol> $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 <startSymbol> 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 <<EOF>> tokens and perform user action code for a <<EOF>> 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","'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});\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\"];","/**\r\n * A collection of shims that provide minimal functionality of the ES6 collections.\r\n *\r\n * These implementations are not meant to be used outside of the ResizeObserver\r\n * modules as they cover only a limited range of use cases.\r\n */\r\n/* eslint-disable require-jsdoc, valid-jsdoc */\r\nvar MapShim = (function () {\r\n    if (typeof Map !== 'undefined') {\r\n        return Map;\r\n    }\r\n    /**\r\n     * Returns index in provided array that matches the specified key.\r\n     *\r\n     * @param {Array<Array>} arr\r\n     * @param {*} key\r\n     * @returns {number}\r\n     */\r\n    function getIndex(arr, key) {\r\n        var result = -1;\r\n        arr.some(function (entry, index) {\r\n            if (entry[0] === key) {\r\n                result = index;\r\n                return true;\r\n            }\r\n            return false;\r\n        });\r\n        return result;\r\n    }\r\n    return /** @class */ (function () {\r\n        function class_1() {\r\n            this.__entries__ = [];\r\n        }\r\n        Object.defineProperty(class_1.prototype, \"size\", {\r\n            /**\r\n             * @returns {boolean}\r\n             */\r\n            get: function () {\r\n                return this.__entries__.length;\r\n            },\r\n            enumerable: true,\r\n            configurable: true\r\n        });\r\n        /**\r\n         * @param {*} key\r\n         * @returns {*}\r\n         */\r\n        class_1.prototype.get = function (key) {\r\n            var index = getIndex(this.__entries__, key);\r\n            var entry = this.__entries__[index];\r\n            return entry && entry[1];\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @param {*} value\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.set = function (key, value) {\r\n            var index = getIndex(this.__entries__, key);\r\n            if (~index) {\r\n                this.__entries__[index][1] = value;\r\n            }\r\n            else {\r\n                this.__entries__.push([key, value]);\r\n            }\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.delete = function (key) {\r\n            var entries = this.__entries__;\r\n            var index = getIndex(entries, key);\r\n            if (~index) {\r\n                entries.splice(index, 1);\r\n            }\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.has = function (key) {\r\n            return !!~getIndex(this.__entries__, key);\r\n        };\r\n        /**\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.clear = function () {\r\n            this.__entries__.splice(0);\r\n        };\r\n        /**\r\n         * @param {Function} callback\r\n         * @param {*} [ctx=null]\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.forEach = function (callback, ctx) {\r\n            if (ctx === void 0) { ctx = null; }\r\n            for (var _i = 0, _a = this.__entries__; _i < _a.length; _i++) {\r\n                var entry = _a[_i];\r\n                callback.call(ctx, entry[1], entry[0]);\r\n            }\r\n        };\r\n        return class_1;\r\n    }());\r\n})();\n\n/**\r\n * Detects whether window and document objects are available in current environment.\r\n */\r\nvar isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && window.document === document;\n\n// Returns global object of a current environment.\r\nvar global$1 = (function () {\r\n    if (typeof global !== 'undefined' && global.Math === Math) {\r\n        return global;\r\n    }\r\n    if (typeof self !== 'undefined' && self.Math === Math) {\r\n        return self;\r\n    }\r\n    if (typeof window !== 'undefined' && window.Math === Math) {\r\n        return window;\r\n    }\r\n    // eslint-disable-next-line no-new-func\r\n    return Function('return this')();\r\n})();\n\n/**\r\n * A shim for the requestAnimationFrame which falls back to the setTimeout if\r\n * first one is not supported.\r\n *\r\n * @returns {number} Requests' identifier.\r\n */\r\nvar requestAnimationFrame$1 = (function () {\r\n    if (typeof requestAnimationFrame === 'function') {\r\n        // It's required to use a bounded function because IE sometimes throws\r\n        // an \"Invalid calling object\" error if rAF is invoked without the global\r\n        // object on the left hand side.\r\n        return requestAnimationFrame.bind(global$1);\r\n    }\r\n    return function (callback) { return setTimeout(function () { return callback(Date.now()); }, 1000 / 60); };\r\n})();\n\n// Defines minimum timeout before adding a trailing call.\r\nvar trailingTimeout = 2;\r\n/**\r\n * Creates a wrapper function which ensures that provided callback will be\r\n * invoked only once during the specified delay period.\r\n *\r\n * @param {Function} callback - Function to be invoked after the delay period.\r\n * @param {number} delay - Delay after which to invoke callback.\r\n * @returns {Function}\r\n */\r\nfunction throttle (callback, delay) {\r\n    var leadingCall = false, trailingCall = false, lastCallTime = 0;\r\n    /**\r\n     * Invokes the original callback function and schedules new invocation if\r\n     * the \"proxy\" was called during current request.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function resolvePending() {\r\n        if (leadingCall) {\r\n            leadingCall = false;\r\n            callback();\r\n        }\r\n        if (trailingCall) {\r\n            proxy();\r\n        }\r\n    }\r\n    /**\r\n     * Callback invoked after the specified delay. It will further postpone\r\n     * invocation of the original function delegating it to the\r\n     * requestAnimationFrame.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function timeoutCallback() {\r\n        requestAnimationFrame$1(resolvePending);\r\n    }\r\n    /**\r\n     * Schedules invocation of the original function.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function proxy() {\r\n        var timeStamp = Date.now();\r\n        if (leadingCall) {\r\n            // Reject immediately following calls.\r\n            if (timeStamp - lastCallTime < trailingTimeout) {\r\n                return;\r\n            }\r\n            // Schedule new call to be in invoked when the pending one is resolved.\r\n            // This is important for \"transitions\" which never actually start\r\n            // immediately so there is a chance that we might miss one if change\r\n            // happens amids the pending invocation.\r\n            trailingCall = true;\r\n        }\r\n        else {\r\n            leadingCall = true;\r\n            trailingCall = false;\r\n            setTimeout(timeoutCallback, delay);\r\n        }\r\n        lastCallTime = timeStamp;\r\n    }\r\n    return proxy;\r\n}\n\n// Minimum delay before invoking the update of observers.\r\nvar REFRESH_DELAY = 20;\r\n// A list of substrings of CSS properties used to find transition events that\r\n// might affect dimensions of observed elements.\r\nvar transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight'];\r\n// Check if MutationObserver is available.\r\nvar mutationObserverSupported = typeof MutationObserver !== 'undefined';\r\n/**\r\n * Singleton controller class which handles updates of ResizeObserver instances.\r\n */\r\nvar ResizeObserverController = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserverController.\r\n     *\r\n     * @private\r\n     */\r\n    function ResizeObserverController() {\r\n        /**\r\n         * Indicates whether DOM listeners have been added.\r\n         *\r\n         * @private {boolean}\r\n         */\r\n        this.connected_ = false;\r\n        /**\r\n         * Tells that controller has subscribed for Mutation Events.\r\n         *\r\n         * @private {boolean}\r\n         */\r\n        this.mutationEventsAdded_ = false;\r\n        /**\r\n         * Keeps reference to the instance of MutationObserver.\r\n         *\r\n         * @private {MutationObserver}\r\n         */\r\n        this.mutationsObserver_ = null;\r\n        /**\r\n         * A list of connected observers.\r\n         *\r\n         * @private {Array<ResizeObserverSPI>}\r\n         */\r\n        this.observers_ = [];\r\n        this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);\r\n        this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);\r\n    }\r\n    /**\r\n     * Adds observer to observers list.\r\n     *\r\n     * @param {ResizeObserverSPI} observer - Observer to be added.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.addObserver = function (observer) {\r\n        if (!~this.observers_.indexOf(observer)) {\r\n            this.observers_.push(observer);\r\n        }\r\n        // Add listeners if they haven't been added yet.\r\n        if (!this.connected_) {\r\n            this.connect_();\r\n        }\r\n    };\r\n    /**\r\n     * Removes observer from observers list.\r\n     *\r\n     * @param {ResizeObserverSPI} observer - Observer to be removed.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.removeObserver = function (observer) {\r\n        var observers = this.observers_;\r\n        var index = observers.indexOf(observer);\r\n        // Remove observer if it's present in registry.\r\n        if (~index) {\r\n            observers.splice(index, 1);\r\n        }\r\n        // Remove listeners if controller has no connected observers.\r\n        if (!observers.length && this.connected_) {\r\n            this.disconnect_();\r\n        }\r\n    };\r\n    /**\r\n     * Invokes the update of observers. It will continue running updates insofar\r\n     * it detects changes.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.refresh = function () {\r\n        var changesDetected = this.updateObservers_();\r\n        // Continue running updates if changes have been detected as there might\r\n        // be future ones caused by CSS transitions.\r\n        if (changesDetected) {\r\n            this.refresh();\r\n        }\r\n    };\r\n    /**\r\n     * Updates every observer from observers list and notifies them of queued\r\n     * entries.\r\n     *\r\n     * @private\r\n     * @returns {boolean} Returns \"true\" if any observer has detected changes in\r\n     *      dimensions of it's elements.\r\n     */\r\n    ResizeObserverController.prototype.updateObservers_ = function () {\r\n        // Collect observers that have active observations.\r\n        var activeObservers = this.observers_.filter(function (observer) {\r\n            return observer.gatherActive(), observer.hasActive();\r\n        });\r\n        // Deliver notifications in a separate cycle in order to avoid any\r\n        // collisions between observers, e.g. when multiple instances of\r\n        // ResizeObserver are tracking the same element and the callback of one\r\n        // of them changes content dimensions of the observed target. Sometimes\r\n        // this may result in notifications being blocked for the rest of observers.\r\n        activeObservers.forEach(function (observer) { return observer.broadcastActive(); });\r\n        return activeObservers.length > 0;\r\n    };\r\n    /**\r\n     * Initializes DOM listeners.\r\n     *\r\n     * @private\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.connect_ = function () {\r\n        // Do nothing if running in a non-browser environment or if listeners\r\n        // have been already added.\r\n        if (!isBrowser || this.connected_) {\r\n            return;\r\n        }\r\n        // Subscription to the \"Transitionend\" event is used as a workaround for\r\n        // delayed transitions. This way it's possible to capture at least the\r\n        // final state of an element.\r\n        document.addEventListener('transitionend', this.onTransitionEnd_);\r\n        window.addEventListener('resize', this.refresh);\r\n        if (mutationObserverSupported) {\r\n            this.mutationsObserver_ = new MutationObserver(this.refresh);\r\n            this.mutationsObserver_.observe(document, {\r\n                attributes: true,\r\n                childList: true,\r\n                characterData: true,\r\n                subtree: true\r\n            });\r\n        }\r\n        else {\r\n            document.addEventListener('DOMSubtreeModified', this.refresh);\r\n            this.mutationEventsAdded_ = true;\r\n        }\r\n        this.connected_ = true;\r\n    };\r\n    /**\r\n     * Removes DOM listeners.\r\n     *\r\n     * @private\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.disconnect_ = function () {\r\n        // Do nothing if running in a non-browser environment or if listeners\r\n        // have been already removed.\r\n        if (!isBrowser || !this.connected_) {\r\n            return;\r\n        }\r\n        document.removeEventListener('transitionend', this.onTransitionEnd_);\r\n        window.removeEventListener('resize', this.refresh);\r\n        if (this.mutationsObserver_) {\r\n            this.mutationsObserver_.disconnect();\r\n        }\r\n        if (this.mutationEventsAdded_) {\r\n            document.removeEventListener('DOMSubtreeModified', this.refresh);\r\n        }\r\n        this.mutationsObserver_ = null;\r\n        this.mutationEventsAdded_ = false;\r\n        this.connected_ = false;\r\n    };\r\n    /**\r\n     * \"Transitionend\" event handler.\r\n     *\r\n     * @private\r\n     * @param {TransitionEvent} event\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.onTransitionEnd_ = function (_a) {\r\n        var _b = _a.propertyName, propertyName = _b === void 0 ? '' : _b;\r\n        // Detect whether transition may affect dimensions of an element.\r\n        var isReflowProperty = transitionKeys.some(function (key) {\r\n            return !!~propertyName.indexOf(key);\r\n        });\r\n        if (isReflowProperty) {\r\n            this.refresh();\r\n        }\r\n    };\r\n    /**\r\n     * Returns instance of the ResizeObserverController.\r\n     *\r\n     * @returns {ResizeObserverController}\r\n     */\r\n    ResizeObserverController.getInstance = function () {\r\n        if (!this.instance_) {\r\n            this.instance_ = new ResizeObserverController();\r\n        }\r\n        return this.instance_;\r\n    };\r\n    /**\r\n     * Holds reference to the controller's instance.\r\n     *\r\n     * @private {ResizeObserverController}\r\n     */\r\n    ResizeObserverController.instance_ = null;\r\n    return ResizeObserverController;\r\n}());\n\n/**\r\n * Defines non-writable/enumerable properties of the provided target object.\r\n *\r\n * @param {Object} target - Object for which to define properties.\r\n * @param {Object} props - Properties to be defined.\r\n * @returns {Object} Target object.\r\n */\r\nvar defineConfigurable = (function (target, props) {\r\n    for (var _i = 0, _a = Object.keys(props); _i < _a.length; _i++) {\r\n        var key = _a[_i];\r\n        Object.defineProperty(target, key, {\r\n            value: props[key],\r\n            enumerable: false,\r\n            writable: false,\r\n            configurable: true\r\n        });\r\n    }\r\n    return target;\r\n});\n\n/**\r\n * Returns the global object associated with provided element.\r\n *\r\n * @param {Object} target\r\n * @returns {Object}\r\n */\r\nvar getWindowOf = (function (target) {\r\n    // Assume that the element is an instance of Node, which means that it\r\n    // has the \"ownerDocument\" property from which we can retrieve a\r\n    // corresponding global object.\r\n    var ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView;\r\n    // Return the local global object if it's not possible extract one from\r\n    // provided element.\r\n    return ownerGlobal || global$1;\r\n});\n\n// Placeholder of an empty content rectangle.\r\nvar emptyRect = createRectInit(0, 0, 0, 0);\r\n/**\r\n * Converts provided string to a number.\r\n *\r\n * @param {number|string} value\r\n * @returns {number}\r\n */\r\nfunction toFloat(value) {\r\n    return parseFloat(value) || 0;\r\n}\r\n/**\r\n * Extracts borders size from provided styles.\r\n *\r\n * @param {CSSStyleDeclaration} styles\r\n * @param {...string} positions - Borders positions (top, right, ...)\r\n * @returns {number}\r\n */\r\nfunction getBordersSize(styles) {\r\n    var positions = [];\r\n    for (var _i = 1; _i < arguments.length; _i++) {\r\n        positions[_i - 1] = arguments[_i];\r\n    }\r\n    return positions.reduce(function (size, position) {\r\n        var value = styles['border-' + position + '-width'];\r\n        return size + toFloat(value);\r\n    }, 0);\r\n}\r\n/**\r\n * Extracts paddings sizes from provided styles.\r\n *\r\n * @param {CSSStyleDeclaration} styles\r\n * @returns {Object} Paddings box.\r\n */\r\nfunction getPaddings(styles) {\r\n    var positions = ['top', 'right', 'bottom', 'left'];\r\n    var paddings = {};\r\n    for (var _i = 0, positions_1 = positions; _i < positions_1.length; _i++) {\r\n        var position = positions_1[_i];\r\n        var value = styles['padding-' + position];\r\n        paddings[position] = toFloat(value);\r\n    }\r\n    return paddings;\r\n}\r\n/**\r\n * Calculates content rectangle of provided SVG element.\r\n *\r\n * @param {SVGGraphicsElement} target - Element content rectangle of which needs\r\n *      to be calculated.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getSVGContentRect(target) {\r\n    var bbox = target.getBBox();\r\n    return createRectInit(0, 0, bbox.width, bbox.height);\r\n}\r\n/**\r\n * Calculates content rectangle of provided HTMLElement.\r\n *\r\n * @param {HTMLElement} target - Element for which to calculate the content rectangle.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getHTMLElementContentRect(target) {\r\n    // Client width & height properties can't be\r\n    // used exclusively as they provide rounded values.\r\n    var clientWidth = target.clientWidth, clientHeight = target.clientHeight;\r\n    // By this condition we can catch all non-replaced inline, hidden and\r\n    // detached elements. Though elements with width & height properties less\r\n    // than 0.5 will be discarded as well.\r\n    //\r\n    // Without it we would need to implement separate methods for each of\r\n    // those cases and it's not possible to perform a precise and performance\r\n    // effective test for hidden elements. E.g. even jQuery's ':visible' filter\r\n    // gives wrong results for elements with width & height less than 0.5.\r\n    if (!clientWidth && !clientHeight) {\r\n        return emptyRect;\r\n    }\r\n    var styles = getWindowOf(target).getComputedStyle(target);\r\n    var paddings = getPaddings(styles);\r\n    var horizPad = paddings.left + paddings.right;\r\n    var vertPad = paddings.top + paddings.bottom;\r\n    // Computed styles of width & height are being used because they are the\r\n    // only dimensions available to JS that contain non-rounded values. It could\r\n    // be possible to utilize the getBoundingClientRect if only it's data wasn't\r\n    // affected by CSS transformations let alone paddings, borders and scroll bars.\r\n    var width = toFloat(styles.width), height = toFloat(styles.height);\r\n    // Width & height include paddings and borders when the 'border-box' box\r\n    // model is applied (except for IE).\r\n    if (styles.boxSizing === 'border-box') {\r\n        // Following conditions are required to handle Internet Explorer which\r\n        // doesn't include paddings and borders to computed CSS dimensions.\r\n        //\r\n        // We can say that if CSS dimensions + paddings are equal to the \"client\"\r\n        // properties then it's either IE, and thus we don't need to subtract\r\n        // anything, or an element merely doesn't have paddings/borders styles.\r\n        if (Math.round(width + horizPad) !== clientWidth) {\r\n            width -= getBordersSize(styles, 'left', 'right') + horizPad;\r\n        }\r\n        if (Math.round(height + vertPad) !== clientHeight) {\r\n            height -= getBordersSize(styles, 'top', 'bottom') + vertPad;\r\n        }\r\n    }\r\n    // Following steps can't be applied to the document's root element as its\r\n    // client[Width/Height] properties represent viewport area of the window.\r\n    // Besides, it's as well not necessary as the <html> itself neither has\r\n    // rendered scroll bars nor it can be clipped.\r\n    if (!isDocumentElement(target)) {\r\n        // In some browsers (only in Firefox, actually) CSS width & height\r\n        // include scroll bars size which can be removed at this step as scroll\r\n        // bars are the only difference between rounded dimensions + paddings\r\n        // and \"client\" properties, though that is not always true in Chrome.\r\n        var vertScrollbar = Math.round(width + horizPad) - clientWidth;\r\n        var horizScrollbar = Math.round(height + vertPad) - clientHeight;\r\n        // Chrome has a rather weird rounding of \"client\" properties.\r\n        // E.g. for an element with content width of 314.2px it sometimes gives\r\n        // the client width of 315px and for the width of 314.7px it may give\r\n        // 314px. And it doesn't happen all the time. So just ignore this delta\r\n        // as a non-relevant.\r\n        if (Math.abs(vertScrollbar) !== 1) {\r\n            width -= vertScrollbar;\r\n        }\r\n        if (Math.abs(horizScrollbar) !== 1) {\r\n            height -= horizScrollbar;\r\n        }\r\n    }\r\n    return createRectInit(paddings.left, paddings.top, width, height);\r\n}\r\n/**\r\n * Checks whether provided element is an instance of the SVGGraphicsElement.\r\n *\r\n * @param {Element} target - Element to be checked.\r\n * @returns {boolean}\r\n */\r\nvar isSVGGraphicsElement = (function () {\r\n    // Some browsers, namely IE and Edge, don't have the SVGGraphicsElement\r\n    // interface.\r\n    if (typeof SVGGraphicsElement !== 'undefined') {\r\n        return function (target) { return target instanceof getWindowOf(target).SVGGraphicsElement; };\r\n    }\r\n    // If it's so, then check that element is at least an instance of the\r\n    // SVGElement and that it has the \"getBBox\" method.\r\n    // eslint-disable-next-line no-extra-parens\r\n    return function (target) { return (target instanceof getWindowOf(target).SVGElement &&\r\n        typeof target.getBBox === 'function'); };\r\n})();\r\n/**\r\n * Checks whether provided element is a document element (<html>).\r\n *\r\n * @param {Element} target - Element to be checked.\r\n * @returns {boolean}\r\n */\r\nfunction isDocumentElement(target) {\r\n    return target === getWindowOf(target).document.documentElement;\r\n}\r\n/**\r\n * Calculates an appropriate content rectangle for provided html or svg element.\r\n *\r\n * @param {Element} target - Element content rectangle of which needs to be calculated.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getContentRect(target) {\r\n    if (!isBrowser) {\r\n        return emptyRect;\r\n    }\r\n    if (isSVGGraphicsElement(target)) {\r\n        return getSVGContentRect(target);\r\n    }\r\n    return getHTMLElementContentRect(target);\r\n}\r\n/**\r\n * Creates rectangle with an interface of the DOMRectReadOnly.\r\n * Spec: https://drafts.fxtf.org/geometry/#domrectreadonly\r\n *\r\n * @param {DOMRectInit} rectInit - Object with rectangle's x/y coordinates and dimensions.\r\n * @returns {DOMRectReadOnly}\r\n */\r\nfunction createReadOnlyRect(_a) {\r\n    var x = _a.x, y = _a.y, width = _a.width, height = _a.height;\r\n    // If DOMRectReadOnly is available use it as a prototype for the rectangle.\r\n    var Constr = typeof DOMRectReadOnly !== 'undefined' ? DOMRectReadOnly : Object;\r\n    var rect = Object.create(Constr.prototype);\r\n    // Rectangle's properties are not writable and non-enumerable.\r\n    defineConfigurable(rect, {\r\n        x: x, y: y, width: width, height: height,\r\n        top: y,\r\n        right: x + width,\r\n        bottom: height + y,\r\n        left: x\r\n    });\r\n    return rect;\r\n}\r\n/**\r\n * Creates DOMRectInit object based on the provided dimensions and the x/y coordinates.\r\n * Spec: https://drafts.fxtf.org/geometry/#dictdef-domrectinit\r\n *\r\n * @param {number} x - X coordinate.\r\n * @param {number} y - Y coordinate.\r\n * @param {number} width - Rectangle's width.\r\n * @param {number} height - Rectangle's height.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction createRectInit(x, y, width, height) {\r\n    return { x: x, y: y, width: width, height: height };\r\n}\n\n/**\r\n * Class that is responsible for computations of the content rectangle of\r\n * provided DOM element and for keeping track of it's changes.\r\n */\r\nvar ResizeObservation = /** @class */ (function () {\r\n    /**\r\n     * Creates an instance of ResizeObservation.\r\n     *\r\n     * @param {Element} target - Element to be observed.\r\n     */\r\n    function ResizeObservation(target) {\r\n        /**\r\n         * Broadcasted width of content rectangle.\r\n         *\r\n         * @type {number}\r\n         */\r\n        this.broadcastWidth = 0;\r\n        /**\r\n         * Broadcasted height of content rectangle.\r\n         *\r\n         * @type {number}\r\n         */\r\n        this.broadcastHeight = 0;\r\n        /**\r\n         * Reference to the last observed content rectangle.\r\n         *\r\n         * @private {DOMRectInit}\r\n         */\r\n        this.contentRect_ = createRectInit(0, 0, 0, 0);\r\n        this.target = target;\r\n    }\r\n    /**\r\n     * Updates content rectangle and tells whether it's width or height properties\r\n     * have changed since the last broadcast.\r\n     *\r\n     * @returns {boolean}\r\n     */\r\n    ResizeObservation.prototype.isActive = function () {\r\n        var rect = getContentRect(this.target);\r\n        this.contentRect_ = rect;\r\n        return (rect.width !== this.broadcastWidth ||\r\n            rect.height !== this.broadcastHeight);\r\n    };\r\n    /**\r\n     * Updates 'broadcastWidth' and 'broadcastHeight' properties with a data\r\n     * from the corresponding properties of the last observed content rectangle.\r\n     *\r\n     * @returns {DOMRectInit} Last observed content rectangle.\r\n     */\r\n    ResizeObservation.prototype.broadcastRect = function () {\r\n        var rect = this.contentRect_;\r\n        this.broadcastWidth = rect.width;\r\n        this.broadcastHeight = rect.height;\r\n        return rect;\r\n    };\r\n    return ResizeObservation;\r\n}());\n\nvar ResizeObserverEntry = /** @class */ (function () {\r\n    /**\r\n     * Creates an instance of ResizeObserverEntry.\r\n     *\r\n     * @param {Element} target - Element that is being observed.\r\n     * @param {DOMRectInit} rectInit - Data of the element's content rectangle.\r\n     */\r\n    function ResizeObserverEntry(target, rectInit) {\r\n        var contentRect = createReadOnlyRect(rectInit);\r\n        // According to the specification following properties are not writable\r\n        // and are also not enumerable in the native implementation.\r\n        //\r\n        // Property accessors are not being used as they'd require to define a\r\n        // private WeakMap storage which may cause memory leaks in browsers that\r\n        // don't support this type of collections.\r\n        defineConfigurable(this, { target: target, contentRect: contentRect });\r\n    }\r\n    return ResizeObserverEntry;\r\n}());\n\nvar ResizeObserverSPI = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserver.\r\n     *\r\n     * @param {ResizeObserverCallback} callback - Callback function that is invoked\r\n     *      when one of the observed elements changes it's content dimensions.\r\n     * @param {ResizeObserverController} controller - Controller instance which\r\n     *      is responsible for the updates of observer.\r\n     * @param {ResizeObserver} callbackCtx - Reference to the public\r\n     *      ResizeObserver instance which will be passed to callback function.\r\n     */\r\n    function ResizeObserverSPI(callback, controller, callbackCtx) {\r\n        /**\r\n         * Collection of resize observations that have detected changes in dimensions\r\n         * of elements.\r\n         *\r\n         * @private {Array<ResizeObservation>}\r\n         */\r\n        this.activeObservations_ = [];\r\n        /**\r\n         * Registry of the ResizeObservation instances.\r\n         *\r\n         * @private {Map<Element, ResizeObservation>}\r\n         */\r\n        this.observations_ = new MapShim();\r\n        if (typeof callback !== 'function') {\r\n            throw new TypeError('The callback provided as parameter 1 is not a function.');\r\n        }\r\n        this.callback_ = callback;\r\n        this.controller_ = controller;\r\n        this.callbackCtx_ = callbackCtx;\r\n    }\r\n    /**\r\n     * Starts observing provided element.\r\n     *\r\n     * @param {Element} target - Element to be observed.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.observe = function (target) {\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        // Do nothing if current environment doesn't have the Element interface.\r\n        if (typeof Element === 'undefined' || !(Element instanceof Object)) {\r\n            return;\r\n        }\r\n        if (!(target instanceof getWindowOf(target).Element)) {\r\n            throw new TypeError('parameter 1 is not of type \"Element\".');\r\n        }\r\n        var observations = this.observations_;\r\n        // Do nothing if element is already being observed.\r\n        if (observations.has(target)) {\r\n            return;\r\n        }\r\n        observations.set(target, new ResizeObservation(target));\r\n        this.controller_.addObserver(this);\r\n        // Force the update of observations.\r\n        this.controller_.refresh();\r\n    };\r\n    /**\r\n     * Stops observing provided element.\r\n     *\r\n     * @param {Element} target - Element to stop observing.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.unobserve = function (target) {\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        // Do nothing if current environment doesn't have the Element interface.\r\n        if (typeof Element === 'undefined' || !(Element instanceof Object)) {\r\n            return;\r\n        }\r\n        if (!(target instanceof getWindowOf(target).Element)) {\r\n            throw new TypeError('parameter 1 is not of type \"Element\".');\r\n        }\r\n        var observations = this.observations_;\r\n        // Do nothing if element is not being observed.\r\n        if (!observations.has(target)) {\r\n            return;\r\n        }\r\n        observations.delete(target);\r\n        if (!observations.size) {\r\n            this.controller_.removeObserver(this);\r\n        }\r\n    };\r\n    /**\r\n     * Stops observing all elements.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.disconnect = function () {\r\n        this.clearActive();\r\n        this.observations_.clear();\r\n        this.controller_.removeObserver(this);\r\n    };\r\n    /**\r\n     * Collects observation instances the associated element of which has changed\r\n     * it's content rectangle.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.gatherActive = function () {\r\n        var _this = this;\r\n        this.clearActive();\r\n        this.observations_.forEach(function (observation) {\r\n            if (observation.isActive()) {\r\n                _this.activeObservations_.push(observation);\r\n            }\r\n        });\r\n    };\r\n    /**\r\n     * Invokes initial callback function with a list of ResizeObserverEntry\r\n     * instances collected from active resize observations.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.broadcastActive = function () {\r\n        // Do nothing if observer doesn't have active observations.\r\n        if (!this.hasActive()) {\r\n            return;\r\n        }\r\n        var ctx = this.callbackCtx_;\r\n        // Create ResizeObserverEntry instance for every active observation.\r\n        var entries = this.activeObservations_.map(function (observation) {\r\n            return new ResizeObserverEntry(observation.target, observation.broadcastRect());\r\n        });\r\n        this.callback_.call(ctx, entries, ctx);\r\n        this.clearActive();\r\n    };\r\n    /**\r\n     * Clears the collection of active observations.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.clearActive = function () {\r\n        this.activeObservations_.splice(0);\r\n    };\r\n    /**\r\n     * Tells whether observer has active observations.\r\n     *\r\n     * @returns {boolean}\r\n     */\r\n    ResizeObserverSPI.prototype.hasActive = function () {\r\n        return this.activeObservations_.length > 0;\r\n    };\r\n    return ResizeObserverSPI;\r\n}());\n\n// Registry of internal observers. If WeakMap is not available use current shim\r\n// for the Map collection as it has all required methods and because WeakMap\r\n// can't be fully polyfilled anyway.\r\nvar observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new MapShim();\r\n/**\r\n * ResizeObserver API. Encapsulates the ResizeObserver SPI implementation\r\n * exposing only those methods and properties that are defined in the spec.\r\n */\r\nvar ResizeObserver = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserver.\r\n     *\r\n     * @param {ResizeObserverCallback} callback - Callback that is invoked when\r\n     *      dimensions of the observed elements change.\r\n     */\r\n    function ResizeObserver(callback) {\r\n        if (!(this instanceof ResizeObserver)) {\r\n            throw new TypeError('Cannot call a class as a function.');\r\n        }\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        var controller = ResizeObserverController.getInstance();\r\n        var observer = new ResizeObserverSPI(callback, controller, this);\r\n        observers.set(this, observer);\r\n    }\r\n    return ResizeObserver;\r\n}());\r\n// Expose public methods of ResizeObserver.\r\n[\r\n    'observe',\r\n    'unobserve',\r\n    'disconnect'\r\n].forEach(function (method) {\r\n    ResizeObserver.prototype[method] = function () {\r\n        var _a;\r\n        return (_a = observers.get(this))[method].apply(_a, arguments);\r\n    };\r\n});\n\nvar index = (function () {\r\n    // Export existing implementation if available.\r\n    if (typeof global$1.ResizeObserver !== 'undefined') {\r\n        return global$1.ResizeObserver;\r\n    }\r\n    return ResizeObserver;\r\n})();\n\nexport default index;\n","'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});\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 <op> (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) <op> 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;","function isAbsolute(pathname) {\n  return pathname.charAt(0) === '/';\n}\n\n// About 1.5x faster than the two-arg version of Array#splice()\nfunction spliceOne(list, index) {\n  for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) {\n    list[i] = list[k];\n  }\n\n  list.pop();\n}\n\n// This implementation is based heavily on node's url.parse\nfunction resolvePathname(to, from) {\n  if (from === undefined) from = '';\n\n  var toParts = (to && to.split('/')) || [];\n  var fromParts = (from && from.split('/')) || [];\n\n  var isToAbs = to && isAbsolute(to);\n  var isFromAbs = from && isAbsolute(from);\n  var mustEndAbs = isToAbs || isFromAbs;\n\n  if (to && isAbsolute(to)) {\n    // to is absolute\n    fromParts = toParts;\n  } else if (toParts.length) {\n    // to is relative, drop the filename\n    fromParts.pop();\n    fromParts = fromParts.concat(toParts);\n  }\n\n  if (!fromParts.length) return '/';\n\n  var hasTrailingSlash;\n  if (fromParts.length) {\n    var last = fromParts[fromParts.length - 1];\n    hasTrailingSlash = last === '.' || last === '..' || last === '';\n  } else {\n    hasTrailingSlash = false;\n  }\n\n  var up = 0;\n  for (var i = fromParts.length; i >= 0; i--) {\n    var part = fromParts[i];\n\n    if (part === '.') {\n      spliceOne(fromParts, i);\n    } else if (part === '..') {\n      spliceOne(fromParts, i);\n      up++;\n    } else if (up) {\n      spliceOne(fromParts, i);\n      up--;\n    }\n  }\n\n  if (!mustEndAbs) for (; up--; up) fromParts.unshift('..');\n\n  if (\n    mustEndAbs &&\n    fromParts[0] !== '' &&\n    (!fromParts[0] || !isAbsolute(fromParts[0]))\n  )\n    fromParts.unshift('');\n\n  var result = fromParts.join('/');\n\n  if (hasTrailingSlash && result.substr(-1) !== '/') result += '/';\n\n  return result;\n}\n\nexport default resolvePathname;\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/scheduler.production.min.js');\n} else {\n  module.exports = require('./cjs/scheduler.development.js');\n}\n","/** @license React v0.20.2\n * scheduler.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var f,g,h,k;if(\"object\"===typeof performance&&\"function\"===typeof performance.now){var l=performance;exports.unstable_now=function(){return l.now()}}else{var p=Date,q=p.now();exports.unstable_now=function(){return p.now()-q}}\nif(\"undefined\"===typeof window||\"function\"!==typeof MessageChannel){var t=null,u=null,w=function(){if(null!==t)try{var a=exports.unstable_now();t(!0,a);t=null}catch(b){throw setTimeout(w,0),b;}};f=function(a){null!==t?setTimeout(f,0,a):(t=a,setTimeout(w,0))};g=function(a,b){u=setTimeout(a,b)};h=function(){clearTimeout(u)};exports.unstable_shouldYield=function(){return!1};k=exports.unstable_forceFrameRate=function(){}}else{var x=window.setTimeout,y=window.clearTimeout;if(\"undefined\"!==typeof console){var z=\nwindow.cancelAnimationFrame;\"function\"!==typeof window.requestAnimationFrame&&console.error(\"This browser doesn't support requestAnimationFrame. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills\");\"function\"!==typeof z&&console.error(\"This browser doesn't support cancelAnimationFrame. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills\")}var A=!1,B=null,C=-1,D=5,E=0;exports.unstable_shouldYield=function(){return exports.unstable_now()>=\nE};k=function(){};exports.unstable_forceFrameRate=function(a){0>a||125<a?console.error(\"forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported\"):D=0<a?Math.floor(1E3/a):5};var F=new MessageChannel,G=F.port2;F.port1.onmessage=function(){if(null!==B){var a=exports.unstable_now();E=a+D;try{B(!0,a)?G.postMessage(null):(A=!1,B=null)}catch(b){throw G.postMessage(null),b;}}else A=!1};f=function(a){B=a;A||(A=!0,G.postMessage(null))};g=function(a,b){C=\nx(function(){a(exports.unstable_now())},b)};h=function(){y(C);C=-1}}function H(a,b){var c=a.length;a.push(b);a:for(;;){var d=c-1>>>1,e=a[d];if(void 0!==e&&0<I(e,b))a[d]=b,a[c]=e,c=d;else break a}}function J(a){a=a[0];return void 0===a?null:a}\nfunction K(a){var b=a[0];if(void 0!==b){var c=a.pop();if(c!==b){a[0]=c;a:for(var d=0,e=a.length;d<e;){var m=2*(d+1)-1,n=a[m],v=m+1,r=a[v];if(void 0!==n&&0>I(n,c))void 0!==r&&0>I(r,n)?(a[d]=r,a[v]=c,d=v):(a[d]=n,a[m]=c,d=m);else if(void 0!==r&&0>I(r,c))a[d]=r,a[v]=c,d=v;else break a}}return b}return null}function I(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}var L=[],M=[],N=1,O=null,P=3,Q=!1,R=!1,S=!1;\nfunction T(a){for(var b=J(M);null!==b;){if(null===b.callback)K(M);else if(b.startTime<=a)K(M),b.sortIndex=b.expirationTime,H(L,b);else break;b=J(M)}}function U(a){S=!1;T(a);if(!R)if(null!==J(L))R=!0,f(V);else{var b=J(M);null!==b&&g(U,b.startTime-a)}}\nfunction V(a,b){R=!1;S&&(S=!1,h());Q=!0;var c=P;try{T(b);for(O=J(L);null!==O&&(!(O.expirationTime>b)||a&&!exports.unstable_shouldYield());){var d=O.callback;if(\"function\"===typeof d){O.callback=null;P=O.priorityLevel;var e=d(O.expirationTime<=b);b=exports.unstable_now();\"function\"===typeof e?O.callback=e:O===J(L)&&K(L);T(b)}else K(L);O=J(L)}if(null!==O)var m=!0;else{var n=J(M);null!==n&&g(U,n.startTime-b);m=!1}return m}finally{O=null,P=c,Q=!1}}var W=k;exports.unstable_IdlePriority=5;\nexports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;exports.unstable_NormalPriority=3;exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function(a){a.callback=null};exports.unstable_continueExecution=function(){R||Q||(R=!0,f(V))};exports.unstable_getCurrentPriorityLevel=function(){return P};exports.unstable_getFirstCallbackNode=function(){return J(L)};\nexports.unstable_next=function(a){switch(P){case 1:case 2:case 3:var b=3;break;default:b=P}var c=P;P=b;try{return a()}finally{P=c}};exports.unstable_pauseExecution=function(){};exports.unstable_requestPaint=W;exports.unstable_runWithPriority=function(a,b){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3}var c=P;P=a;try{return b()}finally{P=c}};\nexports.unstable_scheduleCallback=function(a,b,c){var d=exports.unstable_now();\"object\"===typeof c&&null!==c?(c=c.delay,c=\"number\"===typeof c&&0<c?d+c:d):c=d;switch(a){case 1:var e=-1;break;case 2:e=250;break;case 5:e=1073741823;break;case 4:e=1E4;break;default:e=5E3}e=c+e;a={id:N++,callback:b,priorityLevel:a,startTime:c,expirationTime:e,sortIndex:-1};c>d?(a.sortIndex=c,H(M,a),null===J(L)&&a===J(M)&&(S?h():S=!0,g(U,c-d))):(a.sortIndex=e,H(L,a),R||Q||(R=!0,f(V)));return a};\nexports.unstable_wrapCallback=function(a){var b=P;return function(){var c=P;P=b;try{return a.apply(this,arguments)}finally{P=c}}};\n"],"sourceRoot":""}