{"version":3,"file":"xpath.cjs","mappings":"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AAC,EAAG,GACJ,EACA,EACA,GACAY,EACA,CAAC,GAAI,GACL,GACA,IAEA8X,OAAQ3I,EAAE,CACV,EACA,EACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA/P,EACA,CAAC,GAAI,GAAI,GACT,GACA,GACA,GACAA,EACA,CAAC,GAAI,EAAG,GACR,EACA,EACAA,EACA,CAAC,EAAG,GAAI,GACR,EACA,EACAY,EACA,CAAC,GAAI,IACL,GACA,GACA,GACA,GACA,GACA,GACAA,EACA,CAAC,GAAI,IACLA,EACA,CAAC,GAAI,IACLA,EACA,CAAC,GAAI,IACLA,EACA,CAAC,GAAI,IACL,GACA,EACA,EACAA,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,IAAK,IACN,GACAA,EACA,CAAC,GAAI,IACL,GACA,GACA,GACAA,EACA,CAAC,GAAI,GACLA,EACA,CAAC,GAAI,GACL,GACAA,EACA,CAAC,GAAI,IACLA,EACA,CAAC,IAAK,IACN,GACAA,EACA,CAAC,GAAI,GACL,GACAZ,EACA,CAAC,EAAG,GACJY,EACA,CAAC,IAAK,IACNA,EACA,CAAC,GAAI,KACLA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,GAAI,IACLA,EACA,CAAC,GAAI,IACLA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,IAAK,IACN,GACA,GACA,GACA,EACA,EACAA,EACA,CAAC,IAAK,IACNZ,EACA,CAAC,GAAI,EAAG,GACRY,EACA,CAAC,IAAK,IACN,GACAA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,IAAK,IACNZ,EACA,CAAC,EAAG,GACJ,GACAY,EACA,CAAC,IAAK,IACNA,EACA,CAAC,GAAI,KACLA,EACA,CAAC,IAAK,IACN,GACAA,EACA,CAAC,GAAI,IACLA,EACA,CAAC,GAAI,IACL,GACA,GACA,EACA,GACAA,EACA,CAAC,GAAI,IACL,EACAA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,GAAI,MAELkR,KAAM/B,EAAE,CACR/P,EACA,CAAC,EAAG,IACJA,EACA,CAAC,EAAG,IACJ,EACAA,EACA,CAAC,EAAG,IACJ,EACAY,EACA,CAAC,GAAI,IACLZ,EACA,CAAC,EAAG,IACJY,EACA,CAAC,GAAI,IACLZ,EACA,CAAC,EAAG,IACJY,EACA,CAAC,GAAI,IACLA,EACA,CAAC,GAAI,IACLA,EACA,CAAC,GAAI,GACLA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,GAAI,KACLA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,GAAI,IACLA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,IAAK,IACNZ,EACA,CAAC,EAAG,KACJY,EACA,CAAC,IAAK,IACNA,EACA,CAAC,IAAK,MAENkY,MAAO/I,EAAE,CACT/P,EACA,CAAC,EAAG,EAAG,GACP,EACA,EACA,EACA,EACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACAY,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,EAAG,GACJ,GACAA,EACA,CAAC,EAAG,GACJ,GACA,GACA,GACAA,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,EAAG,GACJ,GACAA,EACA,CAAC,EAAG,GACJ,GACAA,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,EAAG,GACJ,GACAA,EACA,CAAC,EAAG,GACJ,GACAA,EACA,CAAC,GAAI,GACL,GACAA,EACA,CAAC,GAAI,IACL,GACA,GACAA,EACA,CAAC,EAAG,GACJ,IACAA,EACA,CAAC,EAAG,GACJ,IACA,IACAA,EACA,CAAC,GAAI,MAEL6Z,KAAM1K,EAAE,CACR/P,EACA,CAAC,EAAG,IACJA,EACA,CAAC,EAAG,IACJY,EACA,CAAC,GAAI,IACLA,EACA,CAAC,GAAI,GACLZ,EACA,CAAC,EAAG,IACJ,EACAY,EACA,CAAC,GAAI,IACLA,EACA,CAAC,GAAI,GACLA,EACA,CAAC,GAAI,IACLA,EACA,CAAC,GAAI,IACLA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,GAAI,GACLZ,EACA,CAAC,EAAG,KACJY,EACA,CAAC,IAAK,IACNA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,GAAI,GACLA,EACA,CAAC,GAAI,IACLA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,GAAI,IACLA,EACA,CAAC,GAAI,IACLA,EACA,CAAC,GAAI,IACLA,EACA,CAAC,GAAI,GACLA,EACA,CAAC,GAAI,IACLA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,GAAI,IACLA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,GAAI,IACLA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,GAAI,MAEL+Z,KAAM5K,EAAE,CACR,EACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA/P,EACA,CAAC,GAAI,EAAG,GACR,GACA,GACAA,EACA,CAAC,GAAI,GAAI,GACTA,EACA,CAAC,EAAG,IACJ,GACA,GACA,GACA,EACAA,EACA,CAAC,EAAG,IACJ,GACA,GACA,GACA,EACAY,EACA,CAAC,GAAI,IACLA,EACA,CAAC,GAAI,IACL,GACA,GACA,GACAZ,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,GAAI,IACL,GACA,GACA,GACAA,EACA,CAAC,GAAI,IACL,GACA,GACA,GACAY,EACA,CAAC,GAAI,GACL,GACAA,EACA,CAAC,GAAI,GACLZ,EACA,CAAC,GAAI,IACL,GACA,GACA,GACAY,EACA,CAAC,GAAI,GACLZ,EACA,CAAC,GAAI,EAAG,GACRY,EACA,CAAC,IAAK,IACNA,EACA,CAAC,GAAI,KACLA,EACA,CAAC,IAAK,IACNA,EACA,CAAC,GAAI,IACLA,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,IAAK,IACNZ,EACA,CAAC,GAAI,IACLY,EACA,CAAC,GAAI,GACLZ,EACA,CAAC,GAAI,IACL,GACA,GACA,EACA,GACAY,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,GAAI,IACLZ,EACA,CAAC,GAAI,IACL,GACA,GACA,GACAA,EACA,CAAC,GAAI,IACL,GACAA,EACA,CAAC,GAAI,IACL,GACA,GACA,GACAA,EACA,CAAC,IAAK,EAAG,GACT,GACA,GACAY,EACA,CAAC,IAAK,IACN,GACA,GACAZ,EACA,CAAC,GAAI,GACLY,EACA,CAAC,GAAI,IACL,GACA,GACAZ,EACA,CAAC,GAAI,GACLY,EACA,CAAC,GAAI,IACL,GACA,GACAZ,EACA,CAAC,GAAI,GACLY,EACA,CAAC,GAAI,IACL,GACA,GACAZ,EACA,CAAC,GAAI,IACLY,EACA,CAAC,GAAI,GACL,GACA,GACAZ,EACA,CAAC,GAAI,IACLY,EACA,CAAC,GAAI,GACL,GACA,GACAZ,EACA,CAAC,GAAI,IACLY,EACA,CAAC,GAAI,GACL,GACA,GACAZ,EACA,CAAC,GAAI,IACLY,EACA,CAAC,GAAI,GACL,GACA,GACAZ,EACA,CAAC,GAAI,IACLY,EACA,CAAC,GAAI,GACL,GACA,GACAZ,EACA,CAAC,GAAI,IACLY,EACA,CAAC,GAAI,GACL,GACA,GACAZ,EACA,CAAC,GAAI,IACL,GACA,GACA,GACAA,EACA,CAAC,GAAI,IACL,GACA,GACA,GACAA,EACA,CAAC,GAAI,IACL,GACA,GACA,GACAA,EACA,CAAC,GAAI,IACL,GACA,GACA,GACAA,EACA,CAAC,GAAI,IAC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","sources":["webpack://ts-xpath/webpack/bootstrap","webpack://ts-xpath/webpack/runtime/define property getters","webpack://ts-xpath/webpack/runtime/hasOwnProperty shorthand","webpack://ts-xpath/webpack/runtime/make namespace object","webpack://ts-xpath/./node_modules/bignumber.js/bignumber.mjs","webpack://ts-xpath/./src/xpath-models.ts","webpack://ts-xpath/./src/jison/xpath.js","webpack://ts-xpath/./src/xpath.ts"],"sourcesContent":["// The require scope\nvar __webpack_require__ = {};\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","/*\r\n *      bignumber.js v9.1.1\r\n *      A JavaScript library for arbitrary-precision arithmetic.\r\n *      https://github.com/MikeMcl/bignumber.js\r\n *      Copyright (c) 2022 Michael Mclaughlin <M8ch88l@gmail.com>\r\n *      MIT Licensed.\r\n *\r\n *      BigNumber.prototype methods     |  BigNumber methods\r\n *                                      |\r\n *      absoluteValue            abs    |  clone\r\n *      comparedTo                      |  config               set\r\n *      decimalPlaces            dp     |      DECIMAL_PLACES\r\n *      dividedBy                div    |      ROUNDING_MODE\r\n *      dividedToIntegerBy       idiv   |      EXPONENTIAL_AT\r\n *      exponentiatedBy          pow    |      RANGE\r\n *      integerValue                    |      CRYPTO\r\n *      isEqualTo                eq     |      MODULO_MODE\r\n *      isFinite                        |      POW_PRECISION\r\n *      isGreaterThan            gt     |      FORMAT\r\n *      isGreaterThanOrEqualTo   gte    |      ALPHABET\r\n *      isInteger                       |  isBigNumber\r\n *      isLessThan               lt     |  maximum              max\r\n *      isLessThanOrEqualTo      lte    |  minimum              min\r\n *      isNaN                           |  random\r\n *      isNegative                      |  sum\r\n *      isPositive                      |\r\n *      isZero                          |\r\n *      minus                           |\r\n *      modulo                   mod    |\r\n *      multipliedBy             times  |\r\n *      negated                         |\r\n *      plus                            |\r\n *      precision                sd     |\r\n *      shiftedBy                       |\r\n *      squareRoot               sqrt   |\r\n *      toExponential                   |\r\n *      toFixed                         |\r\n *      toFormat                        |\r\n *      toFraction                      |\r\n *      toJSON                          |\r\n *      toNumber                        |\r\n *      toPrecision                     |\r\n *      toString                        |\r\n *      valueOf                         |\r\n *\r\n */\r\n\r\n\r\nvar\r\n  isNumeric = /^-?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?$/i,\r\n  mathceil = Math.ceil,\r\n  mathfloor = Math.floor,\r\n\r\n  bignumberError = '[BigNumber Error] ',\r\n  tooManyDigits = bignumberError + 'Number primitive has more than 15 significant digits: ',\r\n\r\n  BASE = 1e14,\r\n  LOG_BASE = 14,\r\n  MAX_SAFE_INTEGER = 0x1fffffffffffff,         // 2^53 - 1\r\n  // MAX_INT32 = 0x7fffffff,                   // 2^31 - 1\r\n  POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13],\r\n  SQRT_BASE = 1e7,\r\n\r\n  // EDITABLE\r\n  // The limit on the value of DECIMAL_PLACES, TO_EXP_NEG, TO_EXP_POS, MIN_EXP, MAX_EXP, and\r\n  // the arguments to toExponential, toFixed, toFormat, and toPrecision.\r\n  MAX = 1E9;                                   // 0 to MAX_INT32\r\n\r\n\r\n/*\r\n * Create and return a BigNumber constructor.\r\n */\r\nfunction clone(configObject) {\r\n  var div, convertBase, parseNumeric,\r\n    P = BigNumber.prototype = { constructor: BigNumber, toString: null, valueOf: null },\r\n    ONE = new BigNumber(1),\r\n\r\n\r\n    //----------------------------- EDITABLE CONFIG DEFAULTS -------------------------------\r\n\r\n\r\n    // The default values below must be integers within the inclusive ranges stated.\r\n    // The values can also be changed at run-time using BigNumber.set.\r\n\r\n    // The maximum number of decimal places for operations involving division.\r\n    DECIMAL_PLACES = 20,                     // 0 to MAX\r\n\r\n    // The rounding mode used when rounding to the above decimal places, and when using\r\n    // toExponential, toFixed, toFormat and toPrecision, and round (default value).\r\n    // UP         0 Away from zero.\r\n    // DOWN       1 Towards zero.\r\n    // CEIL       2 Towards +Infinity.\r\n    // FLOOR      3 Towards -Infinity.\r\n    // HALF_UP    4 Towards nearest neighbour. If equidistant, up.\r\n    // HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.\r\n    // HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.\r\n    // HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.\r\n    // HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.\r\n    ROUNDING_MODE = 4,                       // 0 to 8\r\n\r\n    // EXPONENTIAL_AT : [TO_EXP_NEG , TO_EXP_POS]\r\n\r\n    // The exponent value at and beneath which toString returns exponential notation.\r\n    // Number type: -7\r\n    TO_EXP_NEG = -7,                         // 0 to -MAX\r\n\r\n    // The exponent value at and above which toString returns exponential notation.\r\n    // Number type: 21\r\n    TO_EXP_POS = 21,                         // 0 to MAX\r\n\r\n    // RANGE : [MIN_EXP, MAX_EXP]\r\n\r\n    // The minimum exponent value, beneath which underflow to zero occurs.\r\n    // Number type: -324  (5e-324)\r\n    MIN_EXP = -1e7,                          // -1 to -MAX\r\n\r\n    // The maximum exponent value, above which overflow to Infinity occurs.\r\n    // Number type:  308  (1.7976931348623157e+308)\r\n    // For MAX_EXP > 1e7, e.g. new BigNumber('1e100000000').plus(1) may be slow.\r\n    MAX_EXP = 1e7,                           // 1 to MAX\r\n\r\n    // Whether to use cryptographically-secure random number generation, if available.\r\n    CRYPTO = false,                          // true or false\r\n\r\n    // The modulo mode used when calculating the modulus: a mod n.\r\n    // The quotient (q = a / n) is calculated according to the corresponding rounding mode.\r\n    // The remainder (r) is calculated as: r = a - n * q.\r\n    //\r\n    // UP        0 The remainder is positive if the dividend is negative, else is negative.\r\n    // DOWN      1 The remainder has the same sign as the dividend.\r\n    //             This modulo mode is commonly known as 'truncated division' and is\r\n    //             equivalent to (a % n) in JavaScript.\r\n    // FLOOR     3 The remainder has the same sign as the divisor (Python %).\r\n    // HALF_EVEN 6 This modulo mode implements the IEEE 754 remainder function.\r\n    // EUCLID    9 Euclidian division. q = sign(n) * floor(a / abs(n)).\r\n    //             The remainder is always positive.\r\n    //\r\n    // The truncated division, floored division, Euclidian division and IEEE 754 remainder\r\n    // modes are commonly used for the modulus operation.\r\n    // Although the other rounding modes can also be used, they may not give useful results.\r\n    MODULO_MODE = 1,                         // 0 to 9\r\n\r\n    // The maximum number of significant digits of the result of the exponentiatedBy operation.\r\n    // If POW_PRECISION is 0, there will be unlimited significant digits.\r\n    POW_PRECISION = 0,                       // 0 to MAX\r\n\r\n    // The format specification used by the BigNumber.prototype.toFormat method.\r\n    FORMAT = {\r\n      prefix: '',\r\n      groupSize: 3,\r\n      secondaryGroupSize: 0,\r\n      groupSeparator: ',',\r\n      decimalSeparator: '.',\r\n      fractionGroupSize: 0,\r\n      fractionGroupSeparator: '\\xA0',        // non-breaking space\r\n      suffix: ''\r\n    },\r\n\r\n    // The alphabet used for base conversion. It must be at least 2 characters long, with no '+',\r\n    // '-', '.', whitespace, or repeated character.\r\n    // '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'\r\n    ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz',\r\n    alphabetHasNormalDecimalDigits = true;\r\n\r\n\r\n  //------------------------------------------------------------------------------------------\r\n\r\n\r\n  // CONSTRUCTOR\r\n\r\n\r\n  /*\r\n   * The BigNumber constructor and exported function.\r\n   * Create and return a new instance of a BigNumber object.\r\n   *\r\n   * v {number|string|BigNumber} A numeric value.\r\n   * [b] {number} The base of v. Integer, 2 to ALPHABET.length inclusive.\r\n   */\r\n  function BigNumber(v, b) {\r\n    var alphabet, c, caseChanged, e, i, isNum, len, str,\r\n      x = this;\r\n\r\n    // Enable constructor call without `new`.\r\n    if (!(x instanceof BigNumber)) return new BigNumber(v, b);\r\n\r\n    if (b == null) {\r\n\r\n      if (v && v._isBigNumber === true) {\r\n        x.s = v.s;\r\n\r\n        if (!v.c || v.e > MAX_EXP) {\r\n          x.c = x.e = null;\r\n        } else if (v.e < MIN_EXP) {\r\n          x.c = [x.e = 0];\r\n        } else {\r\n          x.e = v.e;\r\n          x.c = v.c.slice();\r\n        }\r\n\r\n        return;\r\n      }\r\n\r\n      if ((isNum = typeof v == 'number') && v * 0 == 0) {\r\n\r\n        // Use `1 / n` to handle minus zero also.\r\n        x.s = 1 / v < 0 ? (v = -v, -1) : 1;\r\n\r\n        // Fast path for integers, where n < 2147483648 (2**31).\r\n        if (v === ~~v) {\r\n          for (e = 0, i = v; i >= 10; i /= 10, e++);\r\n\r\n          if (e > MAX_EXP) {\r\n            x.c = x.e = null;\r\n          } else {\r\n            x.e = e;\r\n            x.c = [v];\r\n          }\r\n\r\n          return;\r\n        }\r\n\r\n        str = String(v);\r\n      } else {\r\n\r\n        if (!isNumeric.test(str = String(v))) return parseNumeric(x, str, isNum);\r\n\r\n        x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;\r\n      }\r\n\r\n      // Decimal point?\r\n      if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n\r\n      // Exponential form?\r\n      if ((i = str.search(/e/i)) > 0) {\r\n\r\n        // Determine exponent.\r\n        if (e < 0) e = i;\r\n        e += +str.slice(i + 1);\r\n        str = str.substring(0, i);\r\n      } else if (e < 0) {\r\n\r\n        // Integer.\r\n        e = str.length;\r\n      }\r\n\r\n    } else {\r\n\r\n      // '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n      intCheck(b, 2, ALPHABET.length, 'Base');\r\n\r\n      // Allow exponential notation to be used with base 10 argument, while\r\n      // also rounding to DECIMAL_PLACES as with other bases.\r\n      if (b == 10 && alphabetHasNormalDecimalDigits) {\r\n        x = new BigNumber(v);\r\n        return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);\r\n      }\r\n\r\n      str = String(v);\r\n\r\n      if (isNum = typeof v == 'number') {\r\n\r\n        // Avoid potential interpretation of Infinity and NaN as base 44+ values.\r\n        if (v * 0 != 0) return parseNumeric(x, str, isNum, b);\r\n\r\n        x.s = 1 / v < 0 ? (str = str.slice(1), -1) : 1;\r\n\r\n        // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n        if (BigNumber.DEBUG && str.replace(/^0\\.0*|\\./, '').length > 15) {\r\n          throw Error\r\n           (tooManyDigits + v);\r\n        }\r\n      } else {\r\n        x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;\r\n      }\r\n\r\n      alphabet = ALPHABET.slice(0, b);\r\n      e = i = 0;\r\n\r\n      // Check that str is a valid base b number.\r\n      // Don't use RegExp, so alphabet can contain special characters.\r\n      for (len = str.length; i < len; i++) {\r\n        if (alphabet.indexOf(c = str.charAt(i)) < 0) {\r\n          if (c == '.') {\r\n\r\n            // If '.' is not the first character and it has not be found before.\r\n            if (i > e) {\r\n              e = len;\r\n              continue;\r\n            }\r\n          } else if (!caseChanged) {\r\n\r\n            // Allow e.g. hexadecimal 'FF' as well as 'ff'.\r\n            if (str == str.toUpperCase() && (str = str.toLowerCase()) ||\r\n                str == str.toLowerCase() && (str = str.toUpperCase())) {\r\n              caseChanged = true;\r\n              i = -1;\r\n              e = 0;\r\n              continue;\r\n            }\r\n          }\r\n\r\n          return parseNumeric(x, String(v), isNum, b);\r\n        }\r\n      }\r\n\r\n      // Prevent later check for length on converted number.\r\n      isNum = false;\r\n      str = convertBase(str, b, 10, x.s);\r\n\r\n      // Decimal point?\r\n      if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n      else e = str.length;\r\n    }\r\n\r\n    // Determine leading zeros.\r\n    for (i = 0; str.charCodeAt(i) === 48; i++);\r\n\r\n    // Determine trailing zeros.\r\n    for (len = str.length; str.charCodeAt(--len) === 48;);\r\n\r\n    if (str = str.slice(i, ++len)) {\r\n      len -= i;\r\n\r\n      // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n      if (isNum && BigNumber.DEBUG &&\r\n        len > 15 && (v > MAX_SAFE_INTEGER || v !== mathfloor(v))) {\r\n          throw Error\r\n           (tooManyDigits + (x.s * v));\r\n      }\r\n\r\n       // Overflow?\r\n      if ((e = e - i - 1) > MAX_EXP) {\r\n\r\n        // Infinity.\r\n        x.c = x.e = null;\r\n\r\n      // Underflow?\r\n      } else if (e < MIN_EXP) {\r\n\r\n        // Zero.\r\n        x.c = [x.e = 0];\r\n      } else {\r\n        x.e = e;\r\n        x.c = [];\r\n\r\n        // Transform base\r\n\r\n        // e is the base 10 exponent.\r\n        // i is where to slice str to get the first element of the coefficient array.\r\n        i = (e + 1) % LOG_BASE;\r\n        if (e < 0) i += LOG_BASE;  // i < 1\r\n\r\n        if (i < len) {\r\n          if (i) x.c.push(+str.slice(0, i));\r\n\r\n          for (len -= LOG_BASE; i < len;) {\r\n            x.c.push(+str.slice(i, i += LOG_BASE));\r\n          }\r\n\r\n          i = LOG_BASE - (str = str.slice(i)).length;\r\n        } else {\r\n          i -= len;\r\n        }\r\n\r\n        for (; i--; str += '0');\r\n        x.c.push(+str);\r\n      }\r\n    } else {\r\n\r\n      // Zero.\r\n      x.c = [x.e = 0];\r\n    }\r\n  }\r\n\r\n\r\n  // CONSTRUCTOR PROPERTIES\r\n\r\n\r\n  BigNumber.clone = clone;\r\n\r\n  BigNumber.ROUND_UP = 0;\r\n  BigNumber.ROUND_DOWN = 1;\r\n  BigNumber.ROUND_CEIL = 2;\r\n  BigNumber.ROUND_FLOOR = 3;\r\n  BigNumber.ROUND_HALF_UP = 4;\r\n  BigNumber.ROUND_HALF_DOWN = 5;\r\n  BigNumber.ROUND_HALF_EVEN = 6;\r\n  BigNumber.ROUND_HALF_CEIL = 7;\r\n  BigNumber.ROUND_HALF_FLOOR = 8;\r\n  BigNumber.EUCLID = 9;\r\n\r\n\r\n  /*\r\n   * Configure infrequently-changing library-wide settings.\r\n   *\r\n   * Accept an object with the following optional properties (if the value of a property is\r\n   * a number, it must be an integer within the inclusive range stated):\r\n   *\r\n   *   DECIMAL_PLACES   {number}           0 to MAX\r\n   *   ROUNDING_MODE    {number}           0 to 8\r\n   *   EXPONENTIAL_AT   {number|number[]}  -MAX to MAX  or  [-MAX to 0, 0 to MAX]\r\n   *   RANGE            {number|number[]}  -MAX to MAX (not zero)  or  [-MAX to -1, 1 to MAX]\r\n   *   CRYPTO           {boolean}          true or false\r\n   *   MODULO_MODE      {number}           0 to 9\r\n   *   POW_PRECISION       {number}           0 to MAX\r\n   *   ALPHABET         {string}           A string of two or more unique characters which does\r\n   *                                       not contain '.'.\r\n   *   FORMAT           {object}           An object with some of the following properties:\r\n   *     prefix                 {string}\r\n   *     groupSize              {number}\r\n   *     secondaryGroupSize     {number}\r\n   *     groupSeparator         {string}\r\n   *     decimalSeparator       {string}\r\n   *     fractionGroupSize      {number}\r\n   *     fractionGroupSeparator {string}\r\n   *     suffix                 {string}\r\n   *\r\n   * (The values assigned to the above FORMAT object properties are not checked for validity.)\r\n   *\r\n   * E.g.\r\n   * BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 })\r\n   *\r\n   * Ignore properties/parameters set to null or undefined, except for ALPHABET.\r\n   *\r\n   * Return an object with the properties current values.\r\n   */\r\n  BigNumber.config = BigNumber.set = function (obj) {\r\n    var p, v;\r\n\r\n    if (obj != null) {\r\n\r\n      if (typeof obj == 'object') {\r\n\r\n        // DECIMAL_PLACES {number} Integer, 0 to MAX inclusive.\r\n        // '[BigNumber Error] DECIMAL_PLACES {not a primitive number|not an integer|out of range}: {v}'\r\n        if (obj.hasOwnProperty(p = 'DECIMAL_PLACES')) {\r\n          v = obj[p];\r\n          intCheck(v, 0, MAX, p);\r\n          DECIMAL_PLACES = v;\r\n        }\r\n\r\n        // ROUNDING_MODE {number} Integer, 0 to 8 inclusive.\r\n        // '[BigNumber Error] ROUNDING_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n        if (obj.hasOwnProperty(p = 'ROUNDING_MODE')) {\r\n          v = obj[p];\r\n          intCheck(v, 0, 8, p);\r\n          ROUNDING_MODE = v;\r\n        }\r\n\r\n        // EXPONENTIAL_AT {number|number[]}\r\n        // Integer, -MAX to MAX inclusive or\r\n        // [integer -MAX to 0 inclusive, 0 to MAX inclusive].\r\n        // '[BigNumber Error] EXPONENTIAL_AT {not a primitive number|not an integer|out of range}: {v}'\r\n        if (obj.hasOwnProperty(p = 'EXPONENTIAL_AT')) {\r\n          v = obj[p];\r\n          if (v && v.pop) {\r\n            intCheck(v[0], -MAX, 0, p);\r\n            intCheck(v[1], 0, MAX, p);\r\n            TO_EXP_NEG = v[0];\r\n            TO_EXP_POS = v[1];\r\n          } else {\r\n            intCheck(v, -MAX, MAX, p);\r\n            TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);\r\n          }\r\n        }\r\n\r\n        // RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or\r\n        // [integer -MAX to -1 inclusive, integer 1 to MAX inclusive].\r\n        // '[BigNumber Error] RANGE {not a primitive number|not an integer|out of range|cannot be zero}: {v}'\r\n        if (obj.hasOwnProperty(p = 'RANGE')) {\r\n          v = obj[p];\r\n          if (v && v.pop) {\r\n            intCheck(v[0], -MAX, -1, p);\r\n            intCheck(v[1], 1, MAX, p);\r\n            MIN_EXP = v[0];\r\n            MAX_EXP = v[1];\r\n          } else {\r\n            intCheck(v, -MAX, MAX, p);\r\n            if (v) {\r\n              MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);\r\n            } else {\r\n              throw Error\r\n               (bignumberError + p + ' cannot be zero: ' + v);\r\n            }\r\n          }\r\n        }\r\n\r\n        // CRYPTO {boolean} true or false.\r\n        // '[BigNumber Error] CRYPTO not true or false: {v}'\r\n        // '[BigNumber Error] crypto unavailable'\r\n        if (obj.hasOwnProperty(p = 'CRYPTO')) {\r\n          v = obj[p];\r\n          if (v === !!v) {\r\n            if (v) {\r\n              if (typeof crypto != 'undefined' && crypto &&\r\n               (crypto.getRandomValues || crypto.randomBytes)) {\r\n                CRYPTO = v;\r\n              } else {\r\n                CRYPTO = !v;\r\n                throw Error\r\n                 (bignumberError + 'crypto unavailable');\r\n              }\r\n            } else {\r\n              CRYPTO = v;\r\n            }\r\n          } else {\r\n            throw Error\r\n             (bignumberError + p + ' not true or false: ' + v);\r\n          }\r\n        }\r\n\r\n        // MODULO_MODE {number} Integer, 0 to 9 inclusive.\r\n        // '[BigNumber Error] MODULO_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n        if (obj.hasOwnProperty(p = 'MODULO_MODE')) {\r\n          v = obj[p];\r\n          intCheck(v, 0, 9, p);\r\n          MODULO_MODE = v;\r\n        }\r\n\r\n        // POW_PRECISION {number} Integer, 0 to MAX inclusive.\r\n        // '[BigNumber Error] POW_PRECISION {not a primitive number|not an integer|out of range}: {v}'\r\n        if (obj.hasOwnProperty(p = 'POW_PRECISION')) {\r\n          v = obj[p];\r\n          intCheck(v, 0, MAX, p);\r\n          POW_PRECISION = v;\r\n        }\r\n\r\n        // FORMAT {object}\r\n        // '[BigNumber Error] FORMAT not an object: {v}'\r\n        if (obj.hasOwnProperty(p = 'FORMAT')) {\r\n          v = obj[p];\r\n          if (typeof v == 'object') FORMAT = v;\r\n          else throw Error\r\n           (bignumberError + p + ' not an object: ' + v);\r\n        }\r\n\r\n        // ALPHABET {string}\r\n        // '[BigNumber Error] ALPHABET invalid: {v}'\r\n        if (obj.hasOwnProperty(p = 'ALPHABET')) {\r\n          v = obj[p];\r\n\r\n          // Disallow if less than two characters,\r\n          // or if it contains '+', '-', '.', whitespace, or a repeated character.\r\n          if (typeof v == 'string' && !/^.?$|[+\\-.\\s]|(.).*\\1/.test(v)) {\r\n            alphabetHasNormalDecimalDigits = v.slice(0, 10) == '0123456789';\r\n            ALPHABET = v;\r\n          } else {\r\n            throw Error\r\n             (bignumberError + p + ' invalid: ' + v);\r\n          }\r\n        }\r\n\r\n      } else {\r\n\r\n        // '[BigNumber Error] Object expected: {v}'\r\n        throw Error\r\n         (bignumberError + 'Object expected: ' + obj);\r\n      }\r\n    }\r\n\r\n    return {\r\n      DECIMAL_PLACES: DECIMAL_PLACES,\r\n      ROUNDING_MODE: ROUNDING_MODE,\r\n      EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],\r\n      RANGE: [MIN_EXP, MAX_EXP],\r\n      CRYPTO: CRYPTO,\r\n      MODULO_MODE: MODULO_MODE,\r\n      POW_PRECISION: POW_PRECISION,\r\n      FORMAT: FORMAT,\r\n      ALPHABET: ALPHABET\r\n    };\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if v is a BigNumber instance, otherwise return false.\r\n   *\r\n   * If BigNumber.DEBUG is true, throw if a BigNumber instance is not well-formed.\r\n   *\r\n   * v {any}\r\n   *\r\n   * '[BigNumber Error] Invalid BigNumber: {v}'\r\n   */\r\n  BigNumber.isBigNumber = function (v) {\r\n    if (!v || v._isBigNumber !== true) return false;\r\n    if (!BigNumber.DEBUG) return true;\r\n\r\n    var i, n,\r\n      c = v.c,\r\n      e = v.e,\r\n      s = v.s;\r\n\r\n    out: if ({}.toString.call(c) == '[object Array]') {\r\n\r\n      if ((s === 1 || s === -1) && e >= -MAX && e <= MAX && e === mathfloor(e)) {\r\n\r\n        // If the first element is zero, the BigNumber value must be zero.\r\n        if (c[0] === 0) {\r\n          if (e === 0 && c.length === 1) return true;\r\n          break out;\r\n        }\r\n\r\n        // Calculate number of digits that c[0] should have, based on the exponent.\r\n        i = (e + 1) % LOG_BASE;\r\n        if (i < 1) i += LOG_BASE;\r\n\r\n        // Calculate number of digits of c[0].\r\n        //if (Math.ceil(Math.log(c[0] + 1) / Math.LN10) == i) {\r\n        if (String(c[0]).length == i) {\r\n\r\n          for (i = 0; i < c.length; i++) {\r\n            n = c[i];\r\n            if (n < 0 || n >= BASE || n !== mathfloor(n)) break out;\r\n          }\r\n\r\n          // Last element cannot be zero, unless it is the only element.\r\n          if (n !== 0) return true;\r\n        }\r\n      }\r\n\r\n    // Infinity/NaN\r\n    } else if (c === null && e === null && (s === null || s === 1 || s === -1)) {\r\n      return true;\r\n    }\r\n\r\n    throw Error\r\n      (bignumberError + 'Invalid BigNumber: ' + v);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the maximum of the arguments.\r\n   *\r\n   * arguments {number|string|BigNumber}\r\n   */\r\n  BigNumber.maximum = BigNumber.max = function () {\r\n    return maxOrMin(arguments, P.lt);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the minimum of the arguments.\r\n   *\r\n   * arguments {number|string|BigNumber}\r\n   */\r\n  BigNumber.minimum = BigNumber.min = function () {\r\n    return maxOrMin(arguments, P.gt);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber with a random value equal to or greater than 0 and less than 1,\r\n   * and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing\r\n   * zeros are produced).\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp}'\r\n   * '[BigNumber Error] crypto unavailable'\r\n   */\r\n  BigNumber.random = (function () {\r\n    var pow2_53 = 0x20000000000000;\r\n\r\n    // Return a 53 bit integer n, where 0 <= n < 9007199254740992.\r\n    // Check if Math.random() produces more than 32 bits of randomness.\r\n    // If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits.\r\n    // 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1.\r\n    var random53bitInt = (Math.random() * pow2_53) & 0x1fffff\r\n     ? function () { return mathfloor(Math.random() * pow2_53); }\r\n     : function () { return ((Math.random() * 0x40000000 | 0) * 0x800000) +\r\n       (Math.random() * 0x800000 | 0); };\r\n\r\n    return function (dp) {\r\n      var a, b, e, k, v,\r\n        i = 0,\r\n        c = [],\r\n        rand = new BigNumber(ONE);\r\n\r\n      if (dp == null) dp = DECIMAL_PLACES;\r\n      else intCheck(dp, 0, MAX);\r\n\r\n      k = mathceil(dp / LOG_BASE);\r\n\r\n      if (CRYPTO) {\r\n\r\n        // Browsers supporting crypto.getRandomValues.\r\n        if (crypto.getRandomValues) {\r\n\r\n          a = crypto.getRandomValues(new Uint32Array(k *= 2));\r\n\r\n          for (; i < k;) {\r\n\r\n            // 53 bits:\r\n            // ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2)\r\n            // 11111 11111111 11111111 11111111 11100000 00000000 00000000\r\n            // ((Math.pow(2, 32) - 1) >>> 11).toString(2)\r\n            //                                     11111 11111111 11111111\r\n            // 0x20000 is 2^21.\r\n            v = a[i] * 0x20000 + (a[i + 1] >>> 11);\r\n\r\n            // Rejection sampling:\r\n            // 0 <= v < 9007199254740992\r\n            // Probability that v >= 9e15, is\r\n            // 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251\r\n            if (v >= 9e15) {\r\n              b = crypto.getRandomValues(new Uint32Array(2));\r\n              a[i] = b[0];\r\n              a[i + 1] = b[1];\r\n            } else {\r\n\r\n              // 0 <= v <= 8999999999999999\r\n              // 0 <= (v % 1e14) <= 99999999999999\r\n              c.push(v % 1e14);\r\n              i += 2;\r\n            }\r\n          }\r\n          i = k / 2;\r\n\r\n        // Node.js supporting crypto.randomBytes.\r\n        } else if (crypto.randomBytes) {\r\n\r\n          // buffer\r\n          a = crypto.randomBytes(k *= 7);\r\n\r\n          for (; i < k;) {\r\n\r\n            // 0x1000000000000 is 2^48, 0x10000000000 is 2^40\r\n            // 0x100000000 is 2^32, 0x1000000 is 2^24\r\n            // 11111 11111111 11111111 11111111 11111111 11111111 11111111\r\n            // 0 <= v < 9007199254740992\r\n            v = ((a[i] & 31) * 0x1000000000000) + (a[i + 1] * 0x10000000000) +\r\n               (a[i + 2] * 0x100000000) + (a[i + 3] * 0x1000000) +\r\n               (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];\r\n\r\n            if (v >= 9e15) {\r\n              crypto.randomBytes(7).copy(a, i);\r\n            } else {\r\n\r\n              // 0 <= (v % 1e14) <= 99999999999999\r\n              c.push(v % 1e14);\r\n              i += 7;\r\n            }\r\n          }\r\n          i = k / 7;\r\n        } else {\r\n          CRYPTO = false;\r\n          throw Error\r\n           (bignumberError + 'crypto unavailable');\r\n        }\r\n      }\r\n\r\n      // Use Math.random.\r\n      if (!CRYPTO) {\r\n\r\n        for (; i < k;) {\r\n          v = random53bitInt();\r\n          if (v < 9e15) c[i++] = v % 1e14;\r\n        }\r\n      }\r\n\r\n      k = c[--i];\r\n      dp %= LOG_BASE;\r\n\r\n      // Convert trailing digits to zeros according to dp.\r\n      if (k && dp) {\r\n        v = POWS_TEN[LOG_BASE - dp];\r\n        c[i] = mathfloor(k / v) * v;\r\n      }\r\n\r\n      // Remove trailing elements which are zero.\r\n      for (; c[i] === 0; c.pop(), i--);\r\n\r\n      // Zero?\r\n      if (i < 0) {\r\n        c = [e = 0];\r\n      } else {\r\n\r\n        // Remove leading elements which are zero and adjust exponent accordingly.\r\n        for (e = -1 ; c[0] === 0; c.splice(0, 1), e -= LOG_BASE);\r\n\r\n        // Count the digits of the first element of c to determine leading zeros, and...\r\n        for (i = 1, v = c[0]; v >= 10; v /= 10, i++);\r\n\r\n        // adjust the exponent accordingly.\r\n        if (i < LOG_BASE) e -= LOG_BASE - i;\r\n      }\r\n\r\n      rand.e = e;\r\n      rand.c = c;\r\n      return rand;\r\n    };\r\n  })();\r\n\r\n\r\n   /*\r\n   * Return a BigNumber whose value is the sum of the arguments.\r\n   *\r\n   * arguments {number|string|BigNumber}\r\n   */\r\n  BigNumber.sum = function () {\r\n    var i = 1,\r\n      args = arguments,\r\n      sum = new BigNumber(args[0]);\r\n    for (; i < args.length;) sum = sum.plus(args[i++]);\r\n    return sum;\r\n  };\r\n\r\n\r\n  // PRIVATE FUNCTIONS\r\n\r\n\r\n  // Called by BigNumber and BigNumber.prototype.toString.\r\n  convertBase = (function () {\r\n    var decimal = '0123456789';\r\n\r\n    /*\r\n     * Convert string of baseIn to an array of numbers of baseOut.\r\n     * Eg. toBaseOut('255', 10, 16) returns [15, 15].\r\n     * Eg. toBaseOut('ff', 16, 10) returns [2, 5, 5].\r\n     */\r\n    function toBaseOut(str, baseIn, baseOut, alphabet) {\r\n      var j,\r\n        arr = [0],\r\n        arrL,\r\n        i = 0,\r\n        len = str.length;\r\n\r\n      for (; i < len;) {\r\n        for (arrL = arr.length; arrL--; arr[arrL] *= baseIn);\r\n\r\n        arr[0] += alphabet.indexOf(str.charAt(i++));\r\n\r\n        for (j = 0; j < arr.length; j++) {\r\n\r\n          if (arr[j] > baseOut - 1) {\r\n            if (arr[j + 1] == null) arr[j + 1] = 0;\r\n            arr[j + 1] += arr[j] / baseOut | 0;\r\n            arr[j] %= baseOut;\r\n          }\r\n        }\r\n      }\r\n\r\n      return arr.reverse();\r\n    }\r\n\r\n    // Convert a numeric string of baseIn to a numeric string of baseOut.\r\n    // If the caller is toString, we are converting from base 10 to baseOut.\r\n    // If the caller is BigNumber, we are converting from baseIn to base 10.\r\n    return function (str, baseIn, baseOut, sign, callerIsToString) {\r\n      var alphabet, d, e, k, r, x, xc, y,\r\n        i = str.indexOf('.'),\r\n        dp = DECIMAL_PLACES,\r\n        rm = ROUNDING_MODE;\r\n\r\n      // Non-integer.\r\n      if (i >= 0) {\r\n        k = POW_PRECISION;\r\n\r\n        // Unlimited precision.\r\n        POW_PRECISION = 0;\r\n        str = str.replace('.', '');\r\n        y = new BigNumber(baseIn);\r\n        x = y.pow(str.length - i);\r\n        POW_PRECISION = k;\r\n\r\n        // Convert str as if an integer, then restore the fraction part by dividing the\r\n        // result by its base raised to a power.\r\n\r\n        y.c = toBaseOut(toFixedPoint(coeffToString(x.c), x.e, '0'),\r\n         10, baseOut, decimal);\r\n        y.e = y.c.length;\r\n      }\r\n\r\n      // Convert the number as integer.\r\n\r\n      xc = toBaseOut(str, baseIn, baseOut, callerIsToString\r\n       ? (alphabet = ALPHABET, decimal)\r\n       : (alphabet = decimal, ALPHABET));\r\n\r\n      // xc now represents str as an integer and converted to baseOut. e is the exponent.\r\n      e = k = xc.length;\r\n\r\n      // Remove trailing zeros.\r\n      for (; xc[--k] == 0; xc.pop());\r\n\r\n      // Zero?\r\n      if (!xc[0]) return alphabet.charAt(0);\r\n\r\n      // Does str represent an integer? If so, no need for the division.\r\n      if (i < 0) {\r\n        --e;\r\n      } else {\r\n        x.c = xc;\r\n        x.e = e;\r\n\r\n        // The sign is needed for correct rounding.\r\n        x.s = sign;\r\n        x = div(x, y, dp, rm, baseOut);\r\n        xc = x.c;\r\n        r = x.r;\r\n        e = x.e;\r\n      }\r\n\r\n      // xc now represents str converted to baseOut.\r\n\r\n      // THe index of the rounding digit.\r\n      d = e + dp + 1;\r\n\r\n      // The rounding digit: the digit to the right of the digit that may be rounded up.\r\n      i = xc[d];\r\n\r\n      // Look at the rounding digits and mode to determine whether to round up.\r\n\r\n      k = baseOut / 2;\r\n      r = r || d < 0 || xc[d + 1] != null;\r\n\r\n      r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n            : i > k || i == k &&(rm == 4 || r || rm == 6 && xc[d - 1] & 1 ||\r\n             rm == (x.s < 0 ? 8 : 7));\r\n\r\n      // If the index of the rounding digit is not greater than zero, or xc represents\r\n      // zero, then the result of the base conversion is zero or, if rounding up, a value\r\n      // such as 0.00001.\r\n      if (d < 1 || !xc[0]) {\r\n\r\n        // 1^-dp or 0\r\n        str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0)) : alphabet.charAt(0);\r\n      } else {\r\n\r\n        // Truncate xc to the required number of decimal places.\r\n        xc.length = d;\r\n\r\n        // Round up?\r\n        if (r) {\r\n\r\n          // Rounding up may mean the previous digit has to be rounded up and so on.\r\n          for (--baseOut; ++xc[--d] > baseOut;) {\r\n            xc[d] = 0;\r\n\r\n            if (!d) {\r\n              ++e;\r\n              xc = [1].concat(xc);\r\n            }\r\n          }\r\n        }\r\n\r\n        // Determine trailing zeros.\r\n        for (k = xc.length; !xc[--k];);\r\n\r\n        // E.g. [4, 11, 15] becomes 4bf.\r\n        for (i = 0, str = ''; i <= k; str += alphabet.charAt(xc[i++]));\r\n\r\n        // Add leading zeros, decimal point and trailing zeros as required.\r\n        str = toFixedPoint(str, e, alphabet.charAt(0));\r\n      }\r\n\r\n      // The caller will add the sign.\r\n      return str;\r\n    };\r\n  })();\r\n\r\n\r\n  // Perform division in the specified base. Called by div and convertBase.\r\n  div = (function () {\r\n\r\n    // Assume non-zero x and k.\r\n    function multiply(x, k, base) {\r\n      var m, temp, xlo, xhi,\r\n        carry = 0,\r\n        i = x.length,\r\n        klo = k % SQRT_BASE,\r\n        khi = k / SQRT_BASE | 0;\r\n\r\n      for (x = x.slice(); i--;) {\r\n        xlo = x[i] % SQRT_BASE;\r\n        xhi = x[i] / SQRT_BASE | 0;\r\n        m = khi * xlo + xhi * klo;\r\n        temp = klo * xlo + ((m % SQRT_BASE) * SQRT_BASE) + carry;\r\n        carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;\r\n        x[i] = temp % base;\r\n      }\r\n\r\n      if (carry) x = [carry].concat(x);\r\n\r\n      return x;\r\n    }\r\n\r\n    function compare(a, b, aL, bL) {\r\n      var i, cmp;\r\n\r\n      if (aL != bL) {\r\n        cmp = aL > bL ? 1 : -1;\r\n      } else {\r\n\r\n        for (i = cmp = 0; i < aL; i++) {\r\n\r\n          if (a[i] != b[i]) {\r\n            cmp = a[i] > b[i] ? 1 : -1;\r\n            break;\r\n          }\r\n        }\r\n      }\r\n\r\n      return cmp;\r\n    }\r\n\r\n    function subtract(a, b, aL, base) {\r\n      var i = 0;\r\n\r\n      // Subtract b from a.\r\n      for (; aL--;) {\r\n        a[aL] -= i;\r\n        i = a[aL] < b[aL] ? 1 : 0;\r\n        a[aL] = i * base + a[aL] - b[aL];\r\n      }\r\n\r\n      // Remove leading zeros.\r\n      for (; !a[0] && a.length > 1; a.splice(0, 1));\r\n    }\r\n\r\n    // x: dividend, y: divisor.\r\n    return function (x, y, dp, rm, base) {\r\n      var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0,\r\n        yL, yz,\r\n        s = x.s == y.s ? 1 : -1,\r\n        xc = x.c,\r\n        yc = y.c;\r\n\r\n      // Either NaN, Infinity or 0?\r\n      if (!xc || !xc[0] || !yc || !yc[0]) {\r\n\r\n        return new BigNumber(\r\n\r\n         // Return NaN if either NaN, or both Infinity or 0.\r\n         !x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN :\r\n\r\n          // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.\r\n          xc && xc[0] == 0 || !yc ? s * 0 : s / 0\r\n       );\r\n      }\r\n\r\n      q = new BigNumber(s);\r\n      qc = q.c = [];\r\n      e = x.e - y.e;\r\n      s = dp + e + 1;\r\n\r\n      if (!base) {\r\n        base = BASE;\r\n        e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);\r\n        s = s / LOG_BASE | 0;\r\n      }\r\n\r\n      // Result exponent may be one less then the current value of e.\r\n      // The coefficients of the BigNumbers from convertBase may have trailing zeros.\r\n      for (i = 0; yc[i] == (xc[i] || 0); i++);\r\n\r\n      if (yc[i] > (xc[i] || 0)) e--;\r\n\r\n      if (s < 0) {\r\n        qc.push(1);\r\n        more = true;\r\n      } else {\r\n        xL = xc.length;\r\n        yL = yc.length;\r\n        i = 0;\r\n        s += 2;\r\n\r\n        // Normalise xc and yc so highest order digit of yc is >= base / 2.\r\n\r\n        n = mathfloor(base / (yc[0] + 1));\r\n\r\n        // Not necessary, but to handle odd bases where yc[0] == (base / 2) - 1.\r\n        // if (n > 1 || n++ == 1 && yc[0] < base / 2) {\r\n        if (n > 1) {\r\n          yc = multiply(yc, n, base);\r\n          xc = multiply(xc, n, base);\r\n          yL = yc.length;\r\n          xL = xc.length;\r\n        }\r\n\r\n        xi = yL;\r\n        rem = xc.slice(0, yL);\r\n        remL = rem.length;\r\n\r\n        // Add zeros to make remainder as long as divisor.\r\n        for (; remL < yL; rem[remL++] = 0);\r\n        yz = yc.slice();\r\n        yz = [0].concat(yz);\r\n        yc0 = yc[0];\r\n        if (yc[1] >= base / 2) yc0++;\r\n        // Not necessary, but to prevent trial digit n > base, when using base 3.\r\n        // else if (base == 3 && yc0 == 1) yc0 = 1 + 1e-15;\r\n\r\n        do {\r\n          n = 0;\r\n\r\n          // Compare divisor and remainder.\r\n          cmp = compare(yc, rem, yL, remL);\r\n\r\n          // If divisor < remainder.\r\n          if (cmp < 0) {\r\n\r\n            // Calculate trial digit, n.\r\n\r\n            rem0 = rem[0];\r\n            if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);\r\n\r\n            // n is how many times the divisor goes into the current remainder.\r\n            n = mathfloor(rem0 / yc0);\r\n\r\n            //  Algorithm:\r\n            //  product = divisor multiplied by trial digit (n).\r\n            //  Compare product and remainder.\r\n            //  If product is greater than remainder:\r\n            //    Subtract divisor from product, decrement trial digit.\r\n            //  Subtract product from remainder.\r\n            //  If product was less than remainder at the last compare:\r\n            //    Compare new remainder and divisor.\r\n            //    If remainder is greater than divisor:\r\n            //      Subtract divisor from remainder, increment trial digit.\r\n\r\n            if (n > 1) {\r\n\r\n              // n may be > base only when base is 3.\r\n              if (n >= base) n = base - 1;\r\n\r\n              // product = divisor * trial digit.\r\n              prod = multiply(yc, n, base);\r\n              prodL = prod.length;\r\n              remL = rem.length;\r\n\r\n              // Compare product and remainder.\r\n              // If product > remainder then trial digit n too high.\r\n              // n is 1 too high about 5% of the time, and is not known to have\r\n              // ever been more than 1 too high.\r\n              while (compare(prod, rem, prodL, remL) == 1) {\r\n                n--;\r\n\r\n                // Subtract divisor from product.\r\n                subtract(prod, yL < prodL ? yz : yc, prodL, base);\r\n                prodL = prod.length;\r\n                cmp = 1;\r\n              }\r\n            } else {\r\n\r\n              // n is 0 or 1, cmp is -1.\r\n              // If n is 0, there is no need to compare yc and rem again below,\r\n              // so change cmp to 1 to avoid it.\r\n              // If n is 1, leave cmp as -1, so yc and rem are compared again.\r\n              if (n == 0) {\r\n\r\n                // divisor < remainder, so n must be at least 1.\r\n                cmp = n = 1;\r\n              }\r\n\r\n              // product = divisor\r\n              prod = yc.slice();\r\n              prodL = prod.length;\r\n            }\r\n\r\n            if (prodL < remL) prod = [0].concat(prod);\r\n\r\n            // Subtract product from remainder.\r\n            subtract(rem, prod, remL, base);\r\n            remL = rem.length;\r\n\r\n             // If product was < remainder.\r\n            if (cmp == -1) {\r\n\r\n              // Compare divisor and new remainder.\r\n              // If divisor < new remainder, subtract divisor from remainder.\r\n              // Trial digit n too low.\r\n              // n is 1 too low about 5% of the time, and very rarely 2 too low.\r\n              while (compare(yc, rem, yL, remL) < 1) {\r\n                n++;\r\n\r\n                // Subtract divisor from remainder.\r\n                subtract(rem, yL < remL ? yz : yc, remL, base);\r\n                remL = rem.length;\r\n              }\r\n            }\r\n          } else if (cmp === 0) {\r\n            n++;\r\n            rem = [0];\r\n          } // else cmp === 1 and n will be 0\r\n\r\n          // Add the next digit, n, to the result array.\r\n          qc[i++] = n;\r\n\r\n          // Update the remainder.\r\n          if (rem[0]) {\r\n            rem[remL++] = xc[xi] || 0;\r\n          } else {\r\n            rem = [xc[xi]];\r\n            remL = 1;\r\n          }\r\n        } while ((xi++ < xL || rem[0] != null) && s--);\r\n\r\n        more = rem[0] != null;\r\n\r\n        // Leading zero?\r\n        if (!qc[0]) qc.splice(0, 1);\r\n      }\r\n\r\n      if (base == BASE) {\r\n\r\n        // To calculate q.e, first get the number of digits of qc[0].\r\n        for (i = 1, s = qc[0]; s >= 10; s /= 10, i++);\r\n\r\n        round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);\r\n\r\n      // Caller is convertBase.\r\n      } else {\r\n        q.e = e;\r\n        q.r = +more;\r\n      }\r\n\r\n      return q;\r\n    };\r\n  })();\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of BigNumber n in fixed-point or exponential\r\n   * notation rounded to the specified decimal places or significant digits.\r\n   *\r\n   * n: a BigNumber.\r\n   * i: the index of the last digit required (i.e. the digit that may be rounded up).\r\n   * rm: the rounding mode.\r\n   * id: 1 (toExponential) or 2 (toPrecision).\r\n   */\r\n  function format(n, i, rm, id) {\r\n    var c0, e, ne, len, str;\r\n\r\n    if (rm == null) rm = ROUNDING_MODE;\r\n    else intCheck(rm, 0, 8);\r\n\r\n    if (!n.c) return n.toString();\r\n\r\n    c0 = n.c[0];\r\n    ne = n.e;\r\n\r\n    if (i == null) {\r\n      str = coeffToString(n.c);\r\n      str = id == 1 || id == 2 && (ne <= TO_EXP_NEG || ne >= TO_EXP_POS)\r\n       ? toExponential(str, ne)\r\n       : toFixedPoint(str, ne, '0');\r\n    } else {\r\n      n = round(new BigNumber(n), i, rm);\r\n\r\n      // n.e may have changed if the value was rounded up.\r\n      e = n.e;\r\n\r\n      str = coeffToString(n.c);\r\n      len = str.length;\r\n\r\n      // toPrecision returns exponential notation if the number of significant digits\r\n      // specified is less than the number of digits necessary to represent the integer\r\n      // part of the value in fixed-point notation.\r\n\r\n      // Exponential notation.\r\n      if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {\r\n\r\n        // Append zeros?\r\n        for (; len < i; str += '0', len++);\r\n        str = toExponential(str, e);\r\n\r\n      // Fixed-point notation.\r\n      } else {\r\n        i -= ne;\r\n        str = toFixedPoint(str, e, '0');\r\n\r\n        // Append zeros?\r\n        if (e + 1 > len) {\r\n          if (--i > 0) for (str += '.'; i--; str += '0');\r\n        } else {\r\n          i += e - len;\r\n          if (i > 0) {\r\n            if (e + 1 == len) str += '.';\r\n            for (; i--; str += '0');\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    return n.s < 0 && c0 ? '-' + str : str;\r\n  }\r\n\r\n\r\n  // Handle BigNumber.max and BigNumber.min.\r\n  function maxOrMin(args, method) {\r\n    var n,\r\n      i = 1,\r\n      m = new BigNumber(args[0]);\r\n\r\n    for (; i < args.length; i++) {\r\n      n = new BigNumber(args[i]);\r\n\r\n      // If any number is NaN, return NaN.\r\n      if (!n.s) {\r\n        m = n;\r\n        break;\r\n      } else if (method.call(m, n)) {\r\n        m = n;\r\n      }\r\n    }\r\n\r\n    return m;\r\n  }\r\n\r\n\r\n  /*\r\n   * Strip trailing zeros, calculate base 10 exponent and check against MIN_EXP and MAX_EXP.\r\n   * Called by minus, plus and times.\r\n   */\r\n  function normalise(n, c, e) {\r\n    var i = 1,\r\n      j = c.length;\r\n\r\n     // Remove trailing zeros.\r\n    for (; !c[--j]; c.pop());\r\n\r\n    // Calculate the base 10 exponent. First get the number of digits of c[0].\r\n    for (j = c[0]; j >= 10; j /= 10, i++);\r\n\r\n    // Overflow?\r\n    if ((e = i + e * LOG_BASE - 1) > MAX_EXP) {\r\n\r\n      // Infinity.\r\n      n.c = n.e = null;\r\n\r\n    // Underflow?\r\n    } else if (e < MIN_EXP) {\r\n\r\n      // Zero.\r\n      n.c = [n.e = 0];\r\n    } else {\r\n      n.e = e;\r\n      n.c = c;\r\n    }\r\n\r\n    return n;\r\n  }\r\n\r\n\r\n  // Handle values that fail the validity test in BigNumber.\r\n  parseNumeric = (function () {\r\n    var basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i,\r\n      dotAfter = /^([^.]+)\\.$/,\r\n      dotBefore = /^\\.([^.]+)$/,\r\n      isInfinityOrNaN = /^-?(Infinity|NaN)$/,\r\n      whitespaceOrPlus = /^\\s*\\+(?=[\\w.])|^\\s+|\\s+$/g;\r\n\r\n    return function (x, str, isNum, b) {\r\n      var base,\r\n        s = isNum ? str : str.replace(whitespaceOrPlus, '');\r\n\r\n      // No exception on ±Infinity or NaN.\r\n      if (isInfinityOrNaN.test(s)) {\r\n        x.s = isNaN(s) ? null : s < 0 ? -1 : 1;\r\n      } else {\r\n        if (!isNum) {\r\n\r\n          // basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i\r\n          s = s.replace(basePrefix, function (m, p1, p2) {\r\n            base = (p2 = p2.toLowerCase()) == 'x' ? 16 : p2 == 'b' ? 2 : 8;\r\n            return !b || b == base ? p1 : m;\r\n          });\r\n\r\n          if (b) {\r\n            base = b;\r\n\r\n            // E.g. '1.' to '1', '.1' to '0.1'\r\n            s = s.replace(dotAfter, '$1').replace(dotBefore, '0.$1');\r\n          }\r\n\r\n          if (str != s) return new BigNumber(s, base);\r\n        }\r\n\r\n        // '[BigNumber Error] Not a number: {n}'\r\n        // '[BigNumber Error] Not a base {b} number: {n}'\r\n        if (BigNumber.DEBUG) {\r\n          throw Error\r\n            (bignumberError + 'Not a' + (b ? ' base ' + b : '') + ' number: ' + str);\r\n        }\r\n\r\n        // NaN\r\n        x.s = null;\r\n      }\r\n\r\n      x.c = x.e = null;\r\n    }\r\n  })();\r\n\r\n\r\n  /*\r\n   * Round x to sd significant digits using rounding mode rm. Check for over/under-flow.\r\n   * If r is truthy, it is known that there are more digits after the rounding digit.\r\n   */\r\n  function round(x, sd, rm, r) {\r\n    var d, i, j, k, n, ni, rd,\r\n      xc = x.c,\r\n      pows10 = POWS_TEN;\r\n\r\n    // if x is not Infinity or NaN...\r\n    if (xc) {\r\n\r\n      // rd is the rounding digit, i.e. the digit after the digit that may be rounded up.\r\n      // n is a base 1e14 number, the value of the element of array x.c containing rd.\r\n      // ni is the index of n within x.c.\r\n      // d is the number of digits of n.\r\n      // i is the index of rd within n including leading zeros.\r\n      // j is the actual index of rd within n (if < 0, rd is a leading zero).\r\n      out: {\r\n\r\n        // Get the number of digits of the first element of xc.\r\n        for (d = 1, k = xc[0]; k >= 10; k /= 10, d++);\r\n        i = sd - d;\r\n\r\n        // If the rounding digit is in the first element of xc...\r\n        if (i < 0) {\r\n          i += LOG_BASE;\r\n          j = sd;\r\n          n = xc[ni = 0];\r\n\r\n          // Get the rounding digit at index j of n.\r\n          rd = n / pows10[d - j - 1] % 10 | 0;\r\n        } else {\r\n          ni = mathceil((i + 1) / LOG_BASE);\r\n\r\n          if (ni >= xc.length) {\r\n\r\n            if (r) {\r\n\r\n              // Needed by sqrt.\r\n              for (; xc.length <= ni; xc.push(0));\r\n              n = rd = 0;\r\n              d = 1;\r\n              i %= LOG_BASE;\r\n              j = i - LOG_BASE + 1;\r\n            } else {\r\n              break out;\r\n            }\r\n          } else {\r\n            n = k = xc[ni];\r\n\r\n            // Get the number of digits of n.\r\n            for (d = 1; k >= 10; k /= 10, d++);\r\n\r\n            // Get the index of rd within n.\r\n            i %= LOG_BASE;\r\n\r\n            // Get the index of rd within n, adjusted for leading zeros.\r\n            // The number of leading zeros of n is given by LOG_BASE - d.\r\n            j = i - LOG_BASE + d;\r\n\r\n            // Get the rounding digit at index j of n.\r\n            rd = j < 0 ? 0 : n / pows10[d - j - 1] % 10 | 0;\r\n          }\r\n        }\r\n\r\n        r = r || sd < 0 ||\r\n\r\n        // Are there any non-zero digits after the rounding digit?\r\n        // The expression  n % pows10[d - j - 1]  returns all digits of n to the right\r\n        // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.\r\n         xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);\r\n\r\n        r = rm < 4\r\n         ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n         : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 &&\r\n\r\n          // Check whether the digit to the left of the rounding digit is odd.\r\n          ((i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10) & 1 ||\r\n           rm == (x.s < 0 ? 8 : 7));\r\n\r\n        if (sd < 1 || !xc[0]) {\r\n          xc.length = 0;\r\n\r\n          if (r) {\r\n\r\n            // Convert sd to decimal places.\r\n            sd -= x.e + 1;\r\n\r\n            // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n            xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];\r\n            x.e = -sd || 0;\r\n          } else {\r\n\r\n            // Zero.\r\n            xc[0] = x.e = 0;\r\n          }\r\n\r\n          return x;\r\n        }\r\n\r\n        // Remove excess digits.\r\n        if (i == 0) {\r\n          xc.length = ni;\r\n          k = 1;\r\n          ni--;\r\n        } else {\r\n          xc.length = ni + 1;\r\n          k = pows10[LOG_BASE - i];\r\n\r\n          // E.g. 56700 becomes 56000 if 7 is the rounding digit.\r\n          // j > 0 means i > number of leading zeros of n.\r\n          xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;\r\n        }\r\n\r\n        // Round up?\r\n        if (r) {\r\n\r\n          for (; ;) {\r\n\r\n            // If the digit to be rounded up is in the first element of xc...\r\n            if (ni == 0) {\r\n\r\n              // i will be the length of xc[0] before k is added.\r\n              for (i = 1, j = xc[0]; j >= 10; j /= 10, i++);\r\n              j = xc[0] += k;\r\n              for (k = 1; j >= 10; j /= 10, k++);\r\n\r\n              // if i != k the length has increased.\r\n              if (i != k) {\r\n                x.e++;\r\n                if (xc[0] == BASE) xc[0] = 1;\r\n              }\r\n\r\n              break;\r\n            } else {\r\n              xc[ni] += k;\r\n              if (xc[ni] != BASE) break;\r\n              xc[ni--] = 0;\r\n              k = 1;\r\n            }\r\n          }\r\n        }\r\n\r\n        // Remove trailing zeros.\r\n        for (i = xc.length; xc[--i] === 0; xc.pop());\r\n      }\r\n\r\n      // Overflow? Infinity.\r\n      if (x.e > MAX_EXP) {\r\n        x.c = x.e = null;\r\n\r\n      // Underflow? Zero.\r\n      } else if (x.e < MIN_EXP) {\r\n        x.c = [x.e = 0];\r\n      }\r\n    }\r\n\r\n    return x;\r\n  }\r\n\r\n\r\n  function valueOf(n) {\r\n    var str,\r\n      e = n.e;\r\n\r\n    if (e === null) return n.toString();\r\n\r\n    str = coeffToString(n.c);\r\n\r\n    str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n      ? toExponential(str, e)\r\n      : toFixedPoint(str, e, '0');\r\n\r\n    return n.s < 0 ? '-' + str : str;\r\n  }\r\n\r\n\r\n  // PROTOTYPE/INSTANCE METHODS\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the absolute value of this BigNumber.\r\n   */\r\n  P.absoluteValue = P.abs = function () {\r\n    var x = new BigNumber(this);\r\n    if (x.s < 0) x.s = 1;\r\n    return x;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return\r\n   *   1 if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n   *   -1 if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n   *   0 if they have the same value,\r\n   *   or null if the value of either is NaN.\r\n   */\r\n  P.comparedTo = function (y, b) {\r\n    return compare(this, new BigNumber(y, b));\r\n  };\r\n\r\n\r\n  /*\r\n   * If dp is undefined or null or true or false, return the number of decimal places of the\r\n   * value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n   *\r\n   * Otherwise, if dp is a number, return a new BigNumber whose value is the value of this\r\n   * BigNumber rounded to a maximum of dp decimal places using rounding mode rm, or\r\n   * ROUNDING_MODE if rm is omitted.\r\n   *\r\n   * [dp] {number} Decimal places: integer, 0 to MAX inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n   */\r\n  P.decimalPlaces = P.dp = function (dp, rm) {\r\n    var c, n, v,\r\n      x = this;\r\n\r\n    if (dp != null) {\r\n      intCheck(dp, 0, MAX);\r\n      if (rm == null) rm = ROUNDING_MODE;\r\n      else intCheck(rm, 0, 8);\r\n\r\n      return round(new BigNumber(x), dp + x.e + 1, rm);\r\n    }\r\n\r\n    if (!(c = x.c)) return null;\r\n    n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;\r\n\r\n    // Subtract the number of trailing zeros of the last number.\r\n    if (v = c[v]) for (; v % 10 == 0; v /= 10, n--);\r\n    if (n < 0) n = 0;\r\n\r\n    return n;\r\n  };\r\n\r\n\r\n  /*\r\n   *  n / 0 = I\r\n   *  n / N = N\r\n   *  n / I = 0\r\n   *  0 / n = 0\r\n   *  0 / 0 = N\r\n   *  0 / N = N\r\n   *  0 / I = 0\r\n   *  N / n = N\r\n   *  N / 0 = N\r\n   *  N / N = N\r\n   *  N / I = N\r\n   *  I / n = I\r\n   *  I / 0 = I\r\n   *  I / N = N\r\n   *  I / I = N\r\n   *\r\n   * Return a new BigNumber whose value is the value of this BigNumber divided by the value of\r\n   * BigNumber(y, b), rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n   */\r\n  P.dividedBy = P.div = function (y, b) {\r\n    return div(this, new BigNumber(y, b), DECIMAL_PLACES, ROUNDING_MODE);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the integer part of dividing the value of this\r\n   * BigNumber by the value of BigNumber(y, b).\r\n   */\r\n  P.dividedToIntegerBy = P.idiv = function (y, b) {\r\n    return div(this, new BigNumber(y, b), 0, 1);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a BigNumber whose value is the value of this BigNumber exponentiated by n.\r\n   *\r\n   * If m is present, return the result modulo m.\r\n   * If n is negative round according to DECIMAL_PLACES and ROUNDING_MODE.\r\n   * If POW_PRECISION is non-zero and m is not present, round to POW_PRECISION using ROUNDING_MODE.\r\n   *\r\n   * The modular power operation works efficiently when x, n, and m are integers, otherwise it\r\n   * is equivalent to calculating x.exponentiatedBy(n).modulo(m) with a POW_PRECISION of 0.\r\n   *\r\n   * n {number|string|BigNumber} The exponent. An integer.\r\n   * [m] {number|string|BigNumber} The modulus.\r\n   *\r\n   * '[BigNumber Error] Exponent not an integer: {n}'\r\n   */\r\n  P.exponentiatedBy = P.pow = function (n, m) {\r\n    var half, isModExp, i, k, more, nIsBig, nIsNeg, nIsOdd, y,\r\n      x = this;\r\n\r\n    n = new BigNumber(n);\r\n\r\n    // Allow NaN and ±Infinity, but not other non-integers.\r\n    if (n.c && !n.isInteger()) {\r\n      throw Error\r\n        (bignumberError + 'Exponent not an integer: ' + valueOf(n));\r\n    }\r\n\r\n    if (m != null) m = new BigNumber(m);\r\n\r\n    // Exponent of MAX_SAFE_INTEGER is 15.\r\n    nIsBig = n.e > 14;\r\n\r\n    // If x is NaN, ±Infinity, ±0 or ±1, or n is ±Infinity, NaN or ±0.\r\n    if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {\r\n\r\n      // The sign of the result of pow when x is negative depends on the evenness of n.\r\n      // If +n overflows to ±Infinity, the evenness of n would be not be known.\r\n      y = new BigNumber(Math.pow(+valueOf(x), nIsBig ? n.s * (2 - isOdd(n)) : +valueOf(n)));\r\n      return m ? y.mod(m) : y;\r\n    }\r\n\r\n    nIsNeg = n.s < 0;\r\n\r\n    if (m) {\r\n\r\n      // x % m returns NaN if abs(m) is zero, or m is NaN.\r\n      if (m.c ? !m.c[0] : !m.s) return new BigNumber(NaN);\r\n\r\n      isModExp = !nIsNeg && x.isInteger() && m.isInteger();\r\n\r\n      if (isModExp) x = x.mod(m);\r\n\r\n    // Overflow to ±Infinity: >=2**1e10 or >=1.0000024**1e15.\r\n    // Underflow to ±0: <=0.79**1e10 or <=0.9999975**1e15.\r\n    } else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0\r\n      // [1, 240000000]\r\n      ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7\r\n      // [80000000000000]  [99999750000000]\r\n      : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7))) {\r\n\r\n      // If x is negative and n is odd, k = -0, else k = 0.\r\n      k = x.s < 0 && isOdd(n) ? -0 : 0;\r\n\r\n      // If x >= 1, k = ±Infinity.\r\n      if (x.e > -1) k = 1 / k;\r\n\r\n      // If n is negative return ±0, else return ±Infinity.\r\n      return new BigNumber(nIsNeg ? 1 / k : k);\r\n\r\n    } else if (POW_PRECISION) {\r\n\r\n      // Truncating each coefficient array to a length of k after each multiplication\r\n      // equates to truncating significant digits to POW_PRECISION + [28, 41],\r\n      // i.e. there will be a minimum of 28 guard digits retained.\r\n      k = mathceil(POW_PRECISION / LOG_BASE + 2);\r\n    }\r\n\r\n    if (nIsBig) {\r\n      half = new BigNumber(0.5);\r\n      if (nIsNeg) n.s = 1;\r\n      nIsOdd = isOdd(n);\r\n    } else {\r\n      i = Math.abs(+valueOf(n));\r\n      nIsOdd = i % 2;\r\n    }\r\n\r\n    y = new BigNumber(ONE);\r\n\r\n    // Performs 54 loop iterations for n of 9007199254740991.\r\n    for (; ;) {\r\n\r\n      if (nIsOdd) {\r\n        y = y.times(x);\r\n        if (!y.c) break;\r\n\r\n        if (k) {\r\n          if (y.c.length > k) y.c.length = k;\r\n        } else if (isModExp) {\r\n          y = y.mod(m);    //y = y.minus(div(y, m, 0, MODULO_MODE).times(m));\r\n        }\r\n      }\r\n\r\n      if (i) {\r\n        i = mathfloor(i / 2);\r\n        if (i === 0) break;\r\n        nIsOdd = i % 2;\r\n      } else {\r\n        n = n.times(half);\r\n        round(n, n.e + 1, 1);\r\n\r\n        if (n.e > 14) {\r\n          nIsOdd = isOdd(n);\r\n        } else {\r\n          i = +valueOf(n);\r\n          if (i === 0) break;\r\n          nIsOdd = i % 2;\r\n        }\r\n      }\r\n\r\n      x = x.times(x);\r\n\r\n      if (k) {\r\n        if (x.c && x.c.length > k) x.c.length = k;\r\n      } else if (isModExp) {\r\n        x = x.mod(m);    //x = x.minus(div(x, m, 0, MODULO_MODE).times(m));\r\n      }\r\n    }\r\n\r\n    if (isModExp) return y;\r\n    if (nIsNeg) y = ONE.div(y);\r\n\r\n    return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the value of this BigNumber rounded to an integer\r\n   * using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n   *\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {rm}'\r\n   */\r\n  P.integerValue = function (rm) {\r\n    var n = new BigNumber(this);\r\n    if (rm == null) rm = ROUNDING_MODE;\r\n    else intCheck(rm, 0, 8);\r\n    return round(n, n.e + 1, rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is equal to the value of BigNumber(y, b),\r\n   * otherwise return false.\r\n   */\r\n  P.isEqualTo = P.eq = function (y, b) {\r\n    return compare(this, new BigNumber(y, b)) === 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is a finite number, otherwise return false.\r\n   */\r\n  P.isFinite = function () {\r\n    return !!this.c;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n   * otherwise return false.\r\n   */\r\n  P.isGreaterThan = P.gt = function (y, b) {\r\n    return compare(this, new BigNumber(y, b)) > 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is greater than or equal to the value of\r\n   * BigNumber(y, b), otherwise return false.\r\n   */\r\n  P.isGreaterThanOrEqualTo = P.gte = function (y, b) {\r\n    return (b = compare(this, new BigNumber(y, b))) === 1 || b === 0;\r\n\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is an integer, otherwise return false.\r\n   */\r\n  P.isInteger = function () {\r\n    return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n   * otherwise return false.\r\n   */\r\n  P.isLessThan = P.lt = function (y, b) {\r\n    return compare(this, new BigNumber(y, b)) < 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is less than or equal to the value of\r\n   * BigNumber(y, b), otherwise return false.\r\n   */\r\n  P.isLessThanOrEqualTo = P.lte = function (y, b) {\r\n    return (b = compare(this, new BigNumber(y, b))) === -1 || b === 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is NaN, otherwise return false.\r\n   */\r\n  P.isNaN = function () {\r\n    return !this.s;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is negative, otherwise return false.\r\n   */\r\n  P.isNegative = function () {\r\n    return this.s < 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is positive, otherwise return false.\r\n   */\r\n  P.isPositive = function () {\r\n    return this.s > 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is 0 or -0, otherwise return false.\r\n   */\r\n  P.isZero = function () {\r\n    return !!this.c && this.c[0] == 0;\r\n  };\r\n\r\n\r\n  /*\r\n   *  n - 0 = n\r\n   *  n - N = N\r\n   *  n - I = -I\r\n   *  0 - n = -n\r\n   *  0 - 0 = 0\r\n   *  0 - N = N\r\n   *  0 - I = -I\r\n   *  N - n = N\r\n   *  N - 0 = N\r\n   *  N - N = N\r\n   *  N - I = N\r\n   *  I - n = I\r\n   *  I - 0 = I\r\n   *  I - N = N\r\n   *  I - I = N\r\n   *\r\n   * Return a new BigNumber whose value is the value of this BigNumber minus the value of\r\n   * BigNumber(y, b).\r\n   */\r\n  P.minus = function (y, b) {\r\n    var i, j, t, xLTy,\r\n      x = this,\r\n      a = x.s;\r\n\r\n    y = new BigNumber(y, b);\r\n    b = y.s;\r\n\r\n    // Either NaN?\r\n    if (!a || !b) return new BigNumber(NaN);\r\n\r\n    // Signs differ?\r\n    if (a != b) {\r\n      y.s = -b;\r\n      return x.plus(y);\r\n    }\r\n\r\n    var xe = x.e / LOG_BASE,\r\n      ye = y.e / LOG_BASE,\r\n      xc = x.c,\r\n      yc = y.c;\r\n\r\n    if (!xe || !ye) {\r\n\r\n      // Either Infinity?\r\n      if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber(yc ? x : NaN);\r\n\r\n      // Either zero?\r\n      if (!xc[0] || !yc[0]) {\r\n\r\n        // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n        return yc[0] ? (y.s = -b, y) : new BigNumber(xc[0] ? x :\r\n\r\n         // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity\r\n         ROUNDING_MODE == 3 ? -0 : 0);\r\n      }\r\n    }\r\n\r\n    xe = bitFloor(xe);\r\n    ye = bitFloor(ye);\r\n    xc = xc.slice();\r\n\r\n    // Determine which is the bigger number.\r\n    if (a = xe - ye) {\r\n\r\n      if (xLTy = a < 0) {\r\n        a = -a;\r\n        t = xc;\r\n      } else {\r\n        ye = xe;\r\n        t = yc;\r\n      }\r\n\r\n      t.reverse();\r\n\r\n      // Prepend zeros to equalise exponents.\r\n      for (b = a; b--; t.push(0));\r\n      t.reverse();\r\n    } else {\r\n\r\n      // Exponents equal. Check digit by digit.\r\n      j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;\r\n\r\n      for (a = b = 0; b < j; b++) {\r\n\r\n        if (xc[b] != yc[b]) {\r\n          xLTy = xc[b] < yc[b];\r\n          break;\r\n        }\r\n      }\r\n    }\r\n\r\n    // x < y? Point xc to the array of the bigger number.\r\n    if (xLTy) t = xc, xc = yc, yc = t, y.s = -y.s;\r\n\r\n    b = (j = yc.length) - (i = xc.length);\r\n\r\n    // Append zeros to xc if shorter.\r\n    // No need to add zeros to yc if shorter as subtract only needs to start at yc.length.\r\n    if (b > 0) for (; b--; xc[i++] = 0);\r\n    b = BASE - 1;\r\n\r\n    // Subtract yc from xc.\r\n    for (; j > a;) {\r\n\r\n      if (xc[--j] < yc[j]) {\r\n        for (i = j; i && !xc[--i]; xc[i] = b);\r\n        --xc[i];\r\n        xc[j] += BASE;\r\n      }\r\n\r\n      xc[j] -= yc[j];\r\n    }\r\n\r\n    // Remove leading zeros and adjust exponent accordingly.\r\n    for (; xc[0] == 0; xc.splice(0, 1), --ye);\r\n\r\n    // Zero?\r\n    if (!xc[0]) {\r\n\r\n      // Following IEEE 754 (2008) 6.3,\r\n      // n - n = +0  but  n - n = -0  when rounding towards -Infinity.\r\n      y.s = ROUNDING_MODE == 3 ? -1 : 1;\r\n      y.c = [y.e = 0];\r\n      return y;\r\n    }\r\n\r\n    // No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity\r\n    // for finite x and y.\r\n    return normalise(y, xc, ye);\r\n  };\r\n\r\n\r\n  /*\r\n   *   n % 0 =  N\r\n   *   n % N =  N\r\n   *   n % I =  n\r\n   *   0 % n =  0\r\n   *  -0 % n = -0\r\n   *   0 % 0 =  N\r\n   *   0 % N =  N\r\n   *   0 % I =  0\r\n   *   N % n =  N\r\n   *   N % 0 =  N\r\n   *   N % N =  N\r\n   *   N % I =  N\r\n   *   I % n =  N\r\n   *   I % 0 =  N\r\n   *   I % N =  N\r\n   *   I % I =  N\r\n   *\r\n   * Return a new BigNumber whose value is the value of this BigNumber modulo the value of\r\n   * BigNumber(y, b). The result depends on the value of MODULO_MODE.\r\n   */\r\n  P.modulo = P.mod = function (y, b) {\r\n    var q, s,\r\n      x = this;\r\n\r\n    y = new BigNumber(y, b);\r\n\r\n    // Return NaN if x is Infinity or NaN, or y is NaN or zero.\r\n    if (!x.c || !y.s || y.c && !y.c[0]) {\r\n      return new BigNumber(NaN);\r\n\r\n    // Return x if y is Infinity or x is zero.\r\n    } else if (!y.c || x.c && !x.c[0]) {\r\n      return new BigNumber(x);\r\n    }\r\n\r\n    if (MODULO_MODE == 9) {\r\n\r\n      // Euclidian division: q = sign(y) * floor(x / abs(y))\r\n      // r = x - qy    where  0 <= r < abs(y)\r\n      s = y.s;\r\n      y.s = 1;\r\n      q = div(x, y, 0, 3);\r\n      y.s = s;\r\n      q.s *= s;\r\n    } else {\r\n      q = div(x, y, 0, MODULO_MODE);\r\n    }\r\n\r\n    y = x.minus(q.times(y));\r\n\r\n    // To match JavaScript %, ensure sign of zero is sign of dividend.\r\n    if (!y.c[0] && MODULO_MODE == 1) y.s = x.s;\r\n\r\n    return y;\r\n  };\r\n\r\n\r\n  /*\r\n   *  n * 0 = 0\r\n   *  n * N = N\r\n   *  n * I = I\r\n   *  0 * n = 0\r\n   *  0 * 0 = 0\r\n   *  0 * N = N\r\n   *  0 * I = N\r\n   *  N * n = N\r\n   *  N * 0 = N\r\n   *  N * N = N\r\n   *  N * I = N\r\n   *  I * n = I\r\n   *  I * 0 = N\r\n   *  I * N = N\r\n   *  I * I = I\r\n   *\r\n   * Return a new BigNumber whose value is the value of this BigNumber multiplied by the value\r\n   * of BigNumber(y, b).\r\n   */\r\n  P.multipliedBy = P.times = function (y, b) {\r\n    var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc,\r\n      base, sqrtBase,\r\n      x = this,\r\n      xc = x.c,\r\n      yc = (y = new BigNumber(y, b)).c;\r\n\r\n    // Either NaN, ±Infinity or ±0?\r\n    if (!xc || !yc || !xc[0] || !yc[0]) {\r\n\r\n      // Return NaN if either is NaN, or one is 0 and the other is Infinity.\r\n      if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {\r\n        y.c = y.e = y.s = null;\r\n      } else {\r\n        y.s *= x.s;\r\n\r\n        // Return ±Infinity if either is ±Infinity.\r\n        if (!xc || !yc) {\r\n          y.c = y.e = null;\r\n\r\n        // Return ±0 if either is ±0.\r\n        } else {\r\n          y.c = [0];\r\n          y.e = 0;\r\n        }\r\n      }\r\n\r\n      return y;\r\n    }\r\n\r\n    e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);\r\n    y.s *= x.s;\r\n    xcL = xc.length;\r\n    ycL = yc.length;\r\n\r\n    // Ensure xc points to longer array and xcL to its length.\r\n    if (xcL < ycL) zc = xc, xc = yc, yc = zc, i = xcL, xcL = ycL, ycL = i;\r\n\r\n    // Initialise the result array with zeros.\r\n    for (i = xcL + ycL, zc = []; i--; zc.push(0));\r\n\r\n    base = BASE;\r\n    sqrtBase = SQRT_BASE;\r\n\r\n    for (i = ycL; --i >= 0;) {\r\n      c = 0;\r\n      ylo = yc[i] % sqrtBase;\r\n      yhi = yc[i] / sqrtBase | 0;\r\n\r\n      for (k = xcL, j = i + k; j > i;) {\r\n        xlo = xc[--k] % sqrtBase;\r\n        xhi = xc[k] / sqrtBase | 0;\r\n        m = yhi * xlo + xhi * ylo;\r\n        xlo = ylo * xlo + ((m % sqrtBase) * sqrtBase) + zc[j] + c;\r\n        c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;\r\n        zc[j--] = xlo % base;\r\n      }\r\n\r\n      zc[j] = c;\r\n    }\r\n\r\n    if (c) {\r\n      ++e;\r\n    } else {\r\n      zc.splice(0, 1);\r\n    }\r\n\r\n    return normalise(y, zc, e);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the value of this BigNumber negated,\r\n   * i.e. multiplied by -1.\r\n   */\r\n  P.negated = function () {\r\n    var x = new BigNumber(this);\r\n    x.s = -x.s || null;\r\n    return x;\r\n  };\r\n\r\n\r\n  /*\r\n   *  n + 0 = n\r\n   *  n + N = N\r\n   *  n + I = I\r\n   *  0 + n = n\r\n   *  0 + 0 = 0\r\n   *  0 + N = N\r\n   *  0 + I = I\r\n   *  N + n = N\r\n   *  N + 0 = N\r\n   *  N + N = N\r\n   *  N + I = N\r\n   *  I + n = I\r\n   *  I + 0 = I\r\n   *  I + N = N\r\n   *  I + I = I\r\n   *\r\n   * Return a new BigNumber whose value is the value of this BigNumber plus the value of\r\n   * BigNumber(y, b).\r\n   */\r\n  P.plus = function (y, b) {\r\n    var t,\r\n      x = this,\r\n      a = x.s;\r\n\r\n    y = new BigNumber(y, b);\r\n    b = y.s;\r\n\r\n    // Either NaN?\r\n    if (!a || !b) return new BigNumber(NaN);\r\n\r\n    // Signs differ?\r\n     if (a != b) {\r\n      y.s = -b;\r\n      return x.minus(y);\r\n    }\r\n\r\n    var xe = x.e / LOG_BASE,\r\n      ye = y.e / LOG_BASE,\r\n      xc = x.c,\r\n      yc = y.c;\r\n\r\n    if (!xe || !ye) {\r\n\r\n      // Return ±Infinity if either ±Infinity.\r\n      if (!xc || !yc) return new BigNumber(a / 0);\r\n\r\n      // Either zero?\r\n      // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n      if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber(xc[0] ? x : a * 0);\r\n    }\r\n\r\n    xe = bitFloor(xe);\r\n    ye = bitFloor(ye);\r\n    xc = xc.slice();\r\n\r\n    // Prepend zeros to equalise exponents. Faster to use reverse then do unshifts.\r\n    if (a = xe - ye) {\r\n      if (a > 0) {\r\n        ye = xe;\r\n        t = yc;\r\n      } else {\r\n        a = -a;\r\n        t = xc;\r\n      }\r\n\r\n      t.reverse();\r\n      for (; a--; t.push(0));\r\n      t.reverse();\r\n    }\r\n\r\n    a = xc.length;\r\n    b = yc.length;\r\n\r\n    // Point xc to the longer array, and b to the shorter length.\r\n    if (a - b < 0) t = yc, yc = xc, xc = t, b = a;\r\n\r\n    // Only start adding at yc.length - 1 as the further digits of xc can be ignored.\r\n    for (a = 0; b;) {\r\n      a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;\r\n      xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;\r\n    }\r\n\r\n    if (a) {\r\n      xc = [a].concat(xc);\r\n      ++ye;\r\n    }\r\n\r\n    // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n    // ye = MAX_EXP + 1 possible\r\n    return normalise(y, xc, ye);\r\n  };\r\n\r\n\r\n  /*\r\n   * If sd is undefined or null or true or false, return the number of significant digits of\r\n   * the value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n   * If sd is true include integer-part trailing zeros in the count.\r\n   *\r\n   * Otherwise, if sd is a number, return a new BigNumber whose value is the value of this\r\n   * BigNumber rounded to a maximum of sd significant digits using rounding mode rm, or\r\n   * ROUNDING_MODE if rm is omitted.\r\n   *\r\n   * sd {number|boolean} number: significant digits: integer, 1 to MAX inclusive.\r\n   *                     boolean: whether to count integer-part trailing zeros: true or false.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n   */\r\n  P.precision = P.sd = function (sd, rm) {\r\n    var c, n, v,\r\n      x = this;\r\n\r\n    if (sd != null && sd !== !!sd) {\r\n      intCheck(sd, 1, MAX);\r\n      if (rm == null) rm = ROUNDING_MODE;\r\n      else intCheck(rm, 0, 8);\r\n\r\n      return round(new BigNumber(x), sd, rm);\r\n    }\r\n\r\n    if (!(c = x.c)) return null;\r\n    v = c.length - 1;\r\n    n = v * LOG_BASE + 1;\r\n\r\n    if (v = c[v]) {\r\n\r\n      // Subtract the number of trailing zeros of the last element.\r\n      for (; v % 10 == 0; v /= 10, n--);\r\n\r\n      // Add the number of digits of the first element.\r\n      for (v = c[0]; v >= 10; v /= 10, n++);\r\n    }\r\n\r\n    if (sd && x.e + 1 > n) n = x.e + 1;\r\n\r\n    return n;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the value of this BigNumber shifted by k places\r\n   * (powers of 10). Shift to the right if n > 0, and to the left if n < 0.\r\n   *\r\n   * k {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {k}'\r\n   */\r\n  P.shiftedBy = function (k) {\r\n    intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);\r\n    return this.times('1e' + k);\r\n  };\r\n\r\n\r\n  /*\r\n   *  sqrt(-n) =  N\r\n   *  sqrt(N) =  N\r\n   *  sqrt(-I) =  N\r\n   *  sqrt(I) =  I\r\n   *  sqrt(0) =  0\r\n   *  sqrt(-0) = -0\r\n   *\r\n   * Return a new BigNumber whose value is the square root of the value of this BigNumber,\r\n   * rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n   */\r\n  P.squareRoot = P.sqrt = function () {\r\n    var m, n, r, rep, t,\r\n      x = this,\r\n      c = x.c,\r\n      s = x.s,\r\n      e = x.e,\r\n      dp = DECIMAL_PLACES + 4,\r\n      half = new BigNumber('0.5');\r\n\r\n    // Negative/NaN/Infinity/zero?\r\n    if (s !== 1 || !c || !c[0]) {\r\n      return new BigNumber(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);\r\n    }\r\n\r\n    // Initial estimate.\r\n    s = Math.sqrt(+valueOf(x));\r\n\r\n    // Math.sqrt underflow/overflow?\r\n    // Pass x to Math.sqrt as integer, then adjust the exponent of the result.\r\n    if (s == 0 || s == 1 / 0) {\r\n      n = coeffToString(c);\r\n      if ((n.length + e) % 2 == 0) n += '0';\r\n      s = Math.sqrt(+n);\r\n      e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);\r\n\r\n      if (s == 1 / 0) {\r\n        n = '5e' + e;\r\n      } else {\r\n        n = s.toExponential();\r\n        n = n.slice(0, n.indexOf('e') + 1) + e;\r\n      }\r\n\r\n      r = new BigNumber(n);\r\n    } else {\r\n      r = new BigNumber(s + '');\r\n    }\r\n\r\n    // Check for zero.\r\n    // r could be zero if MIN_EXP is changed after the this value was created.\r\n    // This would cause a division by zero (x/t) and hence Infinity below, which would cause\r\n    // coeffToString to throw.\r\n    if (r.c[0]) {\r\n      e = r.e;\r\n      s = e + dp;\r\n      if (s < 3) s = 0;\r\n\r\n      // Newton-Raphson iteration.\r\n      for (; ;) {\r\n        t = r;\r\n        r = half.times(t.plus(div(x, t, dp, 1)));\r\n\r\n        if (coeffToString(t.c).slice(0, s) === (n = coeffToString(r.c)).slice(0, s)) {\r\n\r\n          // The exponent of r may here be one less than the final result exponent,\r\n          // e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust s so the rounding digits\r\n          // are indexed correctly.\r\n          if (r.e < e) --s;\r\n          n = n.slice(s - 3, s + 1);\r\n\r\n          // The 4th rounding digit may be in error by -1 so if the 4 rounding digits\r\n          // are 9999 or 4999 (i.e. approaching a rounding boundary) continue the\r\n          // iteration.\r\n          if (n == '9999' || !rep && n == '4999') {\r\n\r\n            // On the first iteration only, check to see if rounding up gives the\r\n            // exact result as the nines may infinitely repeat.\r\n            if (!rep) {\r\n              round(t, t.e + DECIMAL_PLACES + 2, 0);\r\n\r\n              if (t.times(t).eq(x)) {\r\n                r = t;\r\n                break;\r\n              }\r\n            }\r\n\r\n            dp += 4;\r\n            s += 4;\r\n            rep = 1;\r\n          } else {\r\n\r\n            // If rounding digits are null, 0{0,4} or 50{0,3}, check for exact\r\n            // result. If not, then there are further digits and m will be truthy.\r\n            if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\r\n\r\n              // Truncate to the first rounding digit.\r\n              round(r, r.e + DECIMAL_PLACES + 2, 1);\r\n              m = !r.times(r).eq(x);\r\n            }\r\n\r\n            break;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this BigNumber in exponential notation and\r\n   * rounded using ROUNDING_MODE to dp fixed decimal places.\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n   */\r\n  P.toExponential = function (dp, rm) {\r\n    if (dp != null) {\r\n      intCheck(dp, 0, MAX);\r\n      dp++;\r\n    }\r\n    return format(this, dp, rm, 1);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this BigNumber in fixed-point notation rounding\r\n   * to dp fixed decimal places using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n   *\r\n   * Note: as with JavaScript's number type, (-0).toFixed(0) is '0',\r\n   * but e.g. (-0.00001).toFixed(0) is '-0'.\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n   */\r\n  P.toFixed = function (dp, rm) {\r\n    if (dp != null) {\r\n      intCheck(dp, 0, MAX);\r\n      dp = dp + this.e + 1;\r\n    }\r\n    return format(this, dp, rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this BigNumber in fixed-point notation rounded\r\n   * using rm or ROUNDING_MODE to dp decimal places, and formatted according to the properties\r\n   * of the format or FORMAT object (see BigNumber.set).\r\n   *\r\n   * The formatting object may contain some or all of the properties shown below.\r\n   *\r\n   * FORMAT = {\r\n   *   prefix: '',\r\n   *   groupSize: 3,\r\n   *   secondaryGroupSize: 0,\r\n   *   groupSeparator: ',',\r\n   *   decimalSeparator: '.',\r\n   *   fractionGroupSize: 0,\r\n   *   fractionGroupSeparator: '\\xA0',      // non-breaking space\r\n   *   suffix: ''\r\n   * };\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   * [format] {object} Formatting options. See FORMAT pbject above.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n   * '[BigNumber Error] Argument not an object: {format}'\r\n   */\r\n  P.toFormat = function (dp, rm, format) {\r\n    var str,\r\n      x = this;\r\n\r\n    if (format == null) {\r\n      if (dp != null && rm && typeof rm == 'object') {\r\n        format = rm;\r\n        rm = null;\r\n      } else if (dp && typeof dp == 'object') {\r\n        format = dp;\r\n        dp = rm = null;\r\n      } else {\r\n        format = FORMAT;\r\n      }\r\n    } else if (typeof format != 'object') {\r\n      throw Error\r\n        (bignumberError + 'Argument not an object: ' + format);\r\n    }\r\n\r\n    str = x.toFixed(dp, rm);\r\n\r\n    if (x.c) {\r\n      var i,\r\n        arr = str.split('.'),\r\n        g1 = +format.groupSize,\r\n        g2 = +format.secondaryGroupSize,\r\n        groupSeparator = format.groupSeparator || '',\r\n        intPart = arr[0],\r\n        fractionPart = arr[1],\r\n        isNeg = x.s < 0,\r\n        intDigits = isNeg ? intPart.slice(1) : intPart,\r\n        len = intDigits.length;\r\n\r\n      if (g2) i = g1, g1 = g2, g2 = i, len -= i;\r\n\r\n      if (g1 > 0 && len > 0) {\r\n        i = len % g1 || g1;\r\n        intPart = intDigits.substr(0, i);\r\n        for (; i < len; i += g1) intPart += groupSeparator + intDigits.substr(i, g1);\r\n        if (g2 > 0) intPart += groupSeparator + intDigits.slice(i);\r\n        if (isNeg) intPart = '-' + intPart;\r\n      }\r\n\r\n      str = fractionPart\r\n       ? intPart + (format.decimalSeparator || '') + ((g2 = +format.fractionGroupSize)\r\n        ? fractionPart.replace(new RegExp('\\\\d{' + g2 + '}\\\\B', 'g'),\r\n         '$&' + (format.fractionGroupSeparator || ''))\r\n        : fractionPart)\r\n       : intPart;\r\n    }\r\n\r\n    return (format.prefix || '') + str + (format.suffix || '');\r\n  };\r\n\r\n\r\n  /*\r\n   * Return an array of two BigNumbers representing the value of this BigNumber as a simple\r\n   * fraction with an integer numerator and an integer denominator.\r\n   * The denominator will be a positive non-zero value less than or equal to the specified\r\n   * maximum denominator. If a maximum denominator is not specified, the denominator will be\r\n   * the lowest value necessary to represent the number exactly.\r\n   *\r\n   * [md] {number|string|BigNumber} Integer >= 1, or Infinity. The maximum denominator.\r\n   *\r\n   * '[BigNumber Error] Argument {not an integer|out of range} : {md}'\r\n   */\r\n  P.toFraction = function (md) {\r\n    var d, d0, d1, d2, e, exp, n, n0, n1, q, r, s,\r\n      x = this,\r\n      xc = x.c;\r\n\r\n    if (md != null) {\r\n      n = new BigNumber(md);\r\n\r\n      // Throw if md is less than one or is not an integer, unless it is Infinity.\r\n      if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {\r\n        throw Error\r\n          (bignumberError + 'Argument ' +\r\n            (n.isInteger() ? 'out of range: ' : 'not an integer: ') + valueOf(n));\r\n      }\r\n    }\r\n\r\n    if (!xc) return new BigNumber(x);\r\n\r\n    d = new BigNumber(ONE);\r\n    n1 = d0 = new BigNumber(ONE);\r\n    d1 = n0 = new BigNumber(ONE);\r\n    s = coeffToString(xc);\r\n\r\n    // Determine initial denominator.\r\n    // d is a power of 10 and the minimum max denominator that specifies the value exactly.\r\n    e = d.e = s.length - x.e - 1;\r\n    d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];\r\n    md = !md || n.comparedTo(d) > 0 ? (e > 0 ? d : n1) : n;\r\n\r\n    exp = MAX_EXP;\r\n    MAX_EXP = 1 / 0;\r\n    n = new BigNumber(s);\r\n\r\n    // n0 = d1 = 0\r\n    n0.c[0] = 0;\r\n\r\n    for (; ;)  {\r\n      q = div(n, d, 0, 1);\r\n      d2 = d0.plus(q.times(d1));\r\n      if (d2.comparedTo(md) == 1) break;\r\n      d0 = d1;\r\n      d1 = d2;\r\n      n1 = n0.plus(q.times(d2 = n1));\r\n      n0 = d2;\r\n      d = n.minus(q.times(d2 = d));\r\n      n = d2;\r\n    }\r\n\r\n    d2 = div(md.minus(d0), d1, 0, 1);\r\n    n0 = n0.plus(d2.times(n1));\r\n    d0 = d0.plus(d2.times(d1));\r\n    n0.s = n1.s = x.s;\r\n    e = e * 2;\r\n\r\n    // Determine which fraction is closer to x, n0/d0 or n1/d1\r\n    r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(\r\n        div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1 ? [n1, d1] : [n0, d0];\r\n\r\n    MAX_EXP = exp;\r\n\r\n    return r;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return the value of this BigNumber converted to a number primitive.\r\n   */\r\n  P.toNumber = function () {\r\n    return +valueOf(this);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this BigNumber rounded to sd significant digits\r\n   * using rounding mode rm or ROUNDING_MODE. If sd is less than the number of digits\r\n   * necessary to represent the integer part of the value in fixed-point notation, then use\r\n   * exponential notation.\r\n   *\r\n   * [sd] {number} Significant digits. Integer, 1 to MAX inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n   */\r\n  P.toPrecision = function (sd, rm) {\r\n    if (sd != null) intCheck(sd, 1, MAX);\r\n    return format(this, sd, rm, 2);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this BigNumber in base b, or base 10 if b is\r\n   * omitted. If a base is specified, including base 10, round according to DECIMAL_PLACES and\r\n   * ROUNDING_MODE. If a base is not specified, and this BigNumber has a positive exponent\r\n   * that is equal to or greater than TO_EXP_POS, or a negative exponent equal to or less than\r\n   * TO_EXP_NEG, return exponential notation.\r\n   *\r\n   * [b] {number} Integer, 2 to ALPHABET.length inclusive.\r\n   *\r\n   * '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n   */\r\n  P.toString = function (b) {\r\n    var str,\r\n      n = this,\r\n      s = n.s,\r\n      e = n.e;\r\n\r\n    // Infinity or NaN?\r\n    if (e === null) {\r\n      if (s) {\r\n        str = 'Infinity';\r\n        if (s < 0) str = '-' + str;\r\n      } else {\r\n        str = 'NaN';\r\n      }\r\n    } else {\r\n      if (b == null) {\r\n        str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n         ? toExponential(coeffToString(n.c), e)\r\n         : toFixedPoint(coeffToString(n.c), e, '0');\r\n      } else if (b === 10 && alphabetHasNormalDecimalDigits) {\r\n        n = round(new BigNumber(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);\r\n        str = toFixedPoint(coeffToString(n.c), n.e, '0');\r\n      } else {\r\n        intCheck(b, 2, ALPHABET.length, 'Base');\r\n        str = convertBase(toFixedPoint(coeffToString(n.c), e, '0'), 10, b, s, true);\r\n      }\r\n\r\n      if (s < 0 && n.c[0]) str = '-' + str;\r\n    }\r\n\r\n    return str;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return as toString, but do not accept a base argument, and include the minus sign for\r\n   * negative zero.\r\n   */\r\n  P.valueOf = P.toJSON = function () {\r\n    return valueOf(this);\r\n  };\r\n\r\n\r\n  P._isBigNumber = true;\r\n\r\n  P[Symbol.toStringTag] = 'BigNumber';\r\n\r\n  // Node.js v10.12.0+\r\n  P[Symbol.for('nodejs.util.inspect.custom')] = P.valueOf;\r\n\r\n  if (configObject != null) BigNumber.set(configObject);\r\n\r\n  return BigNumber;\r\n}\r\n\r\n\r\n// PRIVATE HELPER FUNCTIONS\r\n\r\n// These functions don't need access to variables,\r\n// e.g. DECIMAL_PLACES, in the scope of the `clone` function above.\r\n\r\n\r\nfunction bitFloor(n) {\r\n  var i = n | 0;\r\n  return n > 0 || n === i ? i : i - 1;\r\n}\r\n\r\n\r\n// Return a coefficient array as a string of base 10 digits.\r\nfunction coeffToString(a) {\r\n  var s, z,\r\n    i = 1,\r\n    j = a.length,\r\n    r = a[0] + '';\r\n\r\n  for (; i < j;) {\r\n    s = a[i++] + '';\r\n    z = LOG_BASE - s.length;\r\n    for (; z--; s = '0' + s);\r\n    r += s;\r\n  }\r\n\r\n  // Determine trailing zeros.\r\n  for (j = r.length; r.charCodeAt(--j) === 48;);\r\n\r\n  return r.slice(0, j + 1 || 1);\r\n}\r\n\r\n\r\n// Compare the value of BigNumbers x and y.\r\nfunction compare(x, y) {\r\n  var a, b,\r\n    xc = x.c,\r\n    yc = y.c,\r\n    i = x.s,\r\n    j = y.s,\r\n    k = x.e,\r\n    l = y.e;\r\n\r\n  // Either NaN?\r\n  if (!i || !j) return null;\r\n\r\n  a = xc && !xc[0];\r\n  b = yc && !yc[0];\r\n\r\n  // Either zero?\r\n  if (a || b) return a ? b ? 0 : -j : i;\r\n\r\n  // Signs differ?\r\n  if (i != j) return i;\r\n\r\n  a = i < 0;\r\n  b = k == l;\r\n\r\n  // Either Infinity?\r\n  if (!xc || !yc) return b ? 0 : !xc ^ a ? 1 : -1;\r\n\r\n  // Compare exponents.\r\n  if (!b) return k > l ^ a ? 1 : -1;\r\n\r\n  j = (k = xc.length) < (l = yc.length) ? k : l;\r\n\r\n  // Compare digit by digit.\r\n  for (i = 0; i < j; i++) if (xc[i] != yc[i]) return xc[i] > yc[i] ^ a ? 1 : -1;\r\n\r\n  // Compare lengths.\r\n  return k == l ? 0 : k > l ^ a ? 1 : -1;\r\n}\r\n\r\n\r\n/*\r\n * Check that n is a primitive number, an integer, and in range, otherwise throw.\r\n */\r\nfunction intCheck(n, min, max, name) {\r\n  if (n < min || n > max || n !== mathfloor(n)) {\r\n    throw Error\r\n     (bignumberError + (name || 'Argument') + (typeof n == 'number'\r\n       ? n < min || n > max ? ' out of range: ' : ' not an integer: '\r\n       : ' not a primitive number: ') + String(n));\r\n  }\r\n}\r\n\r\n\r\n// Assumes finite n.\r\nfunction isOdd(n) {\r\n  var k = n.c.length - 1;\r\n  return bitFloor(n.e / LOG_BASE) == k && n.c[k] % 2 != 0;\r\n}\r\n\r\n\r\nfunction toExponential(str, e) {\r\n  return (str.length > 1 ? str.charAt(0) + '.' + str.slice(1) : str) +\r\n   (e < 0 ? 'e' : 'e+') + e;\r\n}\r\n\r\n\r\nfunction toFixedPoint(str, e, z) {\r\n  var len, zs;\r\n\r\n  // Negative exponent?\r\n  if (e < 0) {\r\n\r\n    // Prepend zeros.\r\n    for (zs = z + '.'; ++e; zs += z);\r\n    str = zs + str;\r\n\r\n  // Positive exponent\r\n  } else {\r\n    len = str.length;\r\n\r\n    // Append zeros.\r\n    if (++e > len) {\r\n      for (zs = z, e -= len; --e; zs += z);\r\n      str += zs;\r\n    } else if (e < len) {\r\n      str = str.slice(0, e) + '.' + str.slice(e);\r\n    }\r\n  }\r\n\r\n  return str;\r\n}\r\n\r\n\r\n// EXPORT\r\n\r\n\r\nexport var BigNumber = clone();\r\n\r\nexport default BigNumber;\r\n","// based on https://github.com/dimagi/js-xpath/blob/master/src/models.js\nimport { BigNumber } from 'bignumber.js';\nimport { XPathParser } from './xpath';\nexport var XPathModels;\n(function (XPathModels) {\n    XPathModels.DefaultHashtagConfig = {\n        isValidNamespace: function (namespace) {\n            return false;\n        },\n        hashtagToXPath: function (hashtagExpr) {\n            throw new Error(\"This should be overridden\");\n        },\n        toHashtag: function (xpath) {\n            return xpath.toXPath();\n        }\n    };\n    XPathModels.isDebugging = false;\n    function debugLog(...args) {\n        if (XPathModels.isDebugging) {\n            console.debug(args.join(', '));\n        }\n    }\n    XPathModels.debugLog = debugLog;\n    function testAxisName(name) {\n        for (const key of Object.keys(XPathAxisEnum)) {\n            if (name === XPathAxisEnum[key]) {\n                return name;\n            }\n        }\n        throw `${name} is not a valid axis name!`;\n    }\n    XPathModels.testAxisName = testAxisName;\n    class ParseError {\n        constructor(message, hash) {\n            this.message = message;\n            this.hash = hash;\n        }\n    }\n    XPathModels.ParseError = ParseError;\n    function parseError(str, hash) {\n        throw new ParseError(str, hash);\n    }\n    XPathModels.parseError = parseError;\n    let XPathInitialContextEnum;\n    (function (XPathInitialContextEnum) {\n        XPathInitialContextEnum[\"HASHTAG\"] = \"hashtag\";\n        XPathInitialContextEnum[\"ROOT\"] = \"abs\";\n        XPathInitialContextEnum[\"RELATIVE\"] = \"rel\";\n        XPathInitialContextEnum[\"EXPR\"] = \"expr\";\n    })(XPathInitialContextEnum = XPathModels.XPathInitialContextEnum || (XPathModels.XPathInitialContextEnum = {}));\n    ;\n    let XPathAxisEnum;\n    (function (XPathAxisEnum) {\n        XPathAxisEnum[\"CHILD\"] = \"child\";\n        XPathAxisEnum[\"DESCENDANT\"] = \"descendant\";\n        XPathAxisEnum[\"PARENT\"] = \"parent\";\n        XPathAxisEnum[\"ANCESTOR\"] = \"ancestor\";\n        XPathAxisEnum[\"FOLLOWING_SIBLING\"] = \"following-sibling\";\n        XPathAxisEnum[\"PRECEDING_SIBLING\"] = \"preceding-sibling\";\n        XPathAxisEnum[\"FOLLOWING\"] = \"following\";\n        XPathAxisEnum[\"PRECEDING\"] = \"preceding\";\n        XPathAxisEnum[\"ATTRIBUTE\"] = \"attribute\";\n        XPathAxisEnum[\"NAMESPACE\"] = \"namespace\";\n        XPathAxisEnum[\"SELF\"] = \"self\";\n        XPathAxisEnum[\"DESCENDANT_OR_SELF\"] = \"descendant-or-self\";\n        XPathAxisEnum[\"ANCESTOR_OR_SELF\"] = \"ancestor-or-self\";\n    })(XPathAxisEnum = XPathModels.XPathAxisEnum || (XPathModels.XPathAxisEnum = {}));\n    ;\n    let XPathTestEnum;\n    (function (XPathTestEnum) {\n        XPathTestEnum[\"NAME\"] = \"name\";\n        XPathTestEnum[\"NAME_WILDCARD\"] = \"*\";\n        XPathTestEnum[\"NAMESPACE_WILDCARD\"] = \":*\";\n        XPathTestEnum[\"TYPE_NODE\"] = \"node()\";\n        XPathTestEnum[\"TYPE_TEXT\"] = \"text()\";\n        XPathTestEnum[\"TYPE_COMMENT\"] = \"comment()\";\n        XPathTestEnum[\"TYPE_FUNCTION\"] = \"function()\";\n        XPathTestEnum[\"TYPE_PROCESSING_INSTRUCTION\"] = \"processing-instruction\";\n    })(XPathTestEnum = XPathModels.XPathTestEnum || (XPathModels.XPathTestEnum = {}));\n    class XPathExpressionBase {\n        toXPath() {\n            return this.toTokens(true).map(t => t.text).join('');\n        }\n        parentheses(args, expandHashtags) {\n            let tokens = [\n                {\n                    expression: this,\n                    text: '(',\n                    type: 'paren.left'\n                }\n            ];\n            for (let i = 0; i < args.length; i++) {\n                if (i > 0) {\n                    tokens.push({ expression: this, text: ',', type: 'function.separator' });\n                    tokens.push({ expression: this, text: ' ', type: 'whitespace' });\n                }\n                tokens.push(...args[i].toTokens(expandHashtags));\n            }\n            tokens.push({\n                expression: this,\n                text: ')',\n                type: 'paren.right'\n            });\n            return tokens;\n        }\n        brackets(args, expandHashtags) {\n            let tokens = [];\n            for (let arg of args) {\n                tokens.push({ expression: arg, text: '[', type: 'bracket.left' });\n                tokens.push(...arg.toTokens(expandHashtags));\n                tokens.push({ expression: arg, text: ']', type: 'bracket.right' });\n            }\n            return tokens;\n        }\n    }\n    XPathModels.XPathExpressionBase = XPathExpressionBase;\n    class XPathVariableReference extends XPathExpressionBase {\n        constructor(value) {\n            super();\n            this.value = value;\n        }\n        toString() {\n            return \"{var:\" + String(this.value) + \"}\";\n        }\n        toHashtag() {\n            return this.toXPath();\n        }\n        toTokens(expandHashtags = true) {\n            return [{\n                    expression: this,\n                    type: 'variable.sigil',\n                    text: '$'\n                }, {\n                    expression: this,\n                    type: 'variable.value',\n                    text: this.value\n                }];\n        }\n    }\n    XPathModels.XPathVariableReference = XPathVariableReference;\n    class XPathOperationBase extends XPathExpressionBase {\n        constructor() {\n            super(...arguments);\n            this.type = 'operation';\n        }\n        toHashtag() {\n            return XPathModels.CurrentHashtagConfig.toHashtag(this);\n        }\n    }\n    XPathModels.XPathOperationBase = XPathOperationBase;\n    class XPathOperator extends XPathOperationBase {\n        constructor(properties) {\n            super();\n            this.properties = properties;\n            this.parens = false;\n            this.operationType = properties.type;\n        }\n        combine(formatter, operationTypeLiteral, space, leftParen, rightParen) {\n            let ret = [\n                ...formatter(this.properties.left),\n                space,\n                operationTypeLiteral(this.operationType),\n                space,\n                ...formatter(this.properties.right)\n            ];\n            if (this.parens === true) {\n                return [leftParen, ...ret, rightParen];\n            }\n            return ret;\n        }\n        getChildren() {\n            return [this.properties.left, this.properties.right];\n        }\n        toHashtag() {\n            return this.combine(expr => [expr.toHashtag()], this.expressionTypeEnumToXPathLiteral, ' ', '(', ')').join('');\n        }\n        toString() {\n            return \"{binop-expr:\" + this.properties.type + \",\" + String(this.properties.left) + \",\" + String(this.properties.right) + \"}\";\n        }\n        toTokens(expandHashtags = true) {\n            return this.combine(expr => expr.toTokens(expandHashtags), (operationType) => {\n                return {\n                    expression: this,\n                    text: this.expressionTypeEnumToXPathLiteral(operationType),\n                    type: 'operator'\n                };\n            }, {\n                expression: this,\n                text: ' ',\n                type: 'whitespace'\n            }, {\n                expression: this,\n                text: '(',\n                type: 'paren.left'\n            }, {\n                expression: this,\n                text: ')',\n                type: 'paren.right'\n            });\n        }\n    }\n    XPathModels.XPathOperator = XPathOperator;\n    class XPathBoolExpr extends XPathOperator {\n        expressionTypeEnumToXPathLiteral(type) {\n            return type;\n        }\n    }\n    XPathModels.XPathBoolExpr = XPathBoolExpr;\n    class XPathEqExpr extends XPathOperator {\n        expressionTypeEnumToXPathLiteral(type) {\n            return type == '==' ? '=' : '!=';\n        }\n    }\n    XPathModels.XPathEqExpr = XPathEqExpr;\n    class XPathCmpExpr extends XPathOperator {\n        expressionTypeEnumToXPathLiteral(type) {\n            return type;\n        }\n    }\n    XPathModels.XPathCmpExpr = XPathCmpExpr;\n    class XPathArithExpr extends XPathOperator {\n        expressionTypeEnumToXPathLiteral(type) {\n            switch (type) {\n                case '%':\n                    return 'mod';\n                case '/':\n                    return 'div';\n                default:\n                    return type;\n            }\n        }\n    }\n    XPathModels.XPathArithExpr = XPathArithExpr;\n    class XPathUnionExpr extends XPathOperator {\n        expressionTypeEnumToXPathLiteral(type) {\n            return '|';\n        }\n    }\n    XPathModels.XPathUnionExpr = XPathUnionExpr;\n    class XPathNumNegExpr extends XPathOperationBase {\n        constructor(properties) {\n            super();\n            this.properties = properties;\n            this.operationType = properties.type;\n        }\n        getChildren() {\n            return [this.properties.value];\n        }\n        toString() {\n            return \"{unop-expr:\" + this.properties.type + \",\" + String(this.properties.value) + \"}\";\n        }\n        toHashtag() {\n            return `-${this.properties.value.toHashtag()}`;\n        }\n        toTokens(expandHashtags = true) {\n            return [\n                {\n                    expression: this,\n                    text: '-',\n                    type: 'negation'\n                },\n                ...this.properties.value.toTokens(expandHashtags)\n            ];\n        }\n    }\n    XPathModels.XPathNumNegExpr = XPathNumNegExpr;\n    /**\n     * Functional call expression.\n     */\n    class XPathFuncExpr extends XPathExpressionBase {\n        constructor(properties) {\n            super();\n            this.properties = properties;\n            this.type = 'function';\n            this.args = properties.args || [];\n        }\n        combine(mapper) {\n            return this.properties.id + \"(\" + this.args.map(mapper).join(\", \") + \")\";\n        }\n        getChildren() {\n            return this.args;\n        }\n        toString() {\n            return `{func-expr:${this.properties.id},{${this.properties.args.join(',')}}}`;\n        }\n        toHashtag() {\n            return XPathModels.CurrentHashtagConfig.toHashtag(this) || this.combine(part => part.toHashtag());\n        }\n        toTokens(expandHashtags = true) {\n            return [{\n                    expression: this,\n                    text: this.properties.id,\n                    type: 'function.name'\n                },\n                ...this.parentheses(this.args, expandHashtags)];\n        }\n    }\n    XPathModels.XPathFuncExpr = XPathFuncExpr;\n    class XPathPathExpr extends XPathExpressionBase {\n        constructor(properties) {\n            super();\n            this.properties = properties;\n            this.type = 'path';\n            this.steps = properties.steps || [];\n        }\n        combine(partMap) {\n            var parts = this.steps.map(partMap), ret = [], curPart, prevPart = '', sep;\n            var root = (this.properties.initialContext === XPathInitialContextEnum.ROOT) ? \"/\" : \"\";\n            if (this.properties.filter) {\n                parts.splice(0, 0, this.properties.filter.toXPath());\n            }\n            if (parts.length === 0) {\n                return root;\n            }\n            for (var i = 0; i < parts.length; i++) {\n                curPart = parts[i];\n                if (curPart !== \"//\" && prevPart !== \"//\") {\n                    // unless the current part starts with a slash, put slashes between\n                    // parts. the only exception to this rule is at the beginning,\n                    // when we only use a slash if it's an absolute path\n                    sep = (i === 0) ? root : \"/\";\n                    ret.push(sep);\n                }\n                ret.push(curPart);\n                prevPart = curPart;\n            }\n            return ret.join(\"\");\n        }\n        getChildren() {\n            return this.steps;\n        }\n        toString() {\n            return `{path-expr:${this.properties.initialContext === XPathInitialContextEnum.EXPR\n                ? String(this.properties.filter)\n                : this.properties.initialContext},{${this.steps.join(',')}}}`;\n        }\n        toHashtag() {\n            return XPathModels.CurrentHashtagConfig.toHashtag(this) || this.combine(part => part.toHashtag());\n        }\n        toTokens(expandHashtags = true) {\n            let parts = this.steps.map(step => step.toTokens(expandHashtags)), ret = [], curPart, prevPart = '', sep;\n            let root = (this.properties.initialContext === XPathInitialContextEnum.ROOT) ? [{\n                    expression: this,\n                    text: \"/\",\n                    type: 'path'\n                }] : [];\n            if (this.properties.filter) {\n                parts.splice(0, 0, this.properties.filter.toTokens(expandHashtags));\n            }\n            if (parts.length === 0) {\n                return root;\n            }\n            for (let i = 0; i < parts.length; i++) {\n                curPart = parts[i].map(p => p.text).join('');\n                if (curPart !== \"//\" && prevPart !== \"//\") {\n                    // unless the current part starts with a slash, put slashes between\n                    // parts. the only exception to this rule is at the beginning,\n                    // when we only use a slash if it's an absolute path\n                    sep = (i === 0) ? root : [{\n                            expression: this,\n                            text: \"/\",\n                            type: 'path'\n                        }];\n                    ret.push(...sep);\n                }\n                ret.push(...parts[i]);\n                prevPart = curPart;\n            }\n            return ret;\n        }\n        pathWithoutPredicates() {\n            return this.combine(step => step.mainXPath(true));\n        }\n    }\n    XPathModels.XPathPathExpr = XPathPathExpr;\n    class XPathStep extends XPathExpressionBase {\n        constructor(properties) {\n            super();\n            this.properties = properties;\n            this.type = 'path-step';\n            if (!properties.axis) {\n                throw 'No axis specified';\n            }\n            this.predicates = properties.predicates || [];\n        }\n        testTokens(expandHashtags) {\n            switch (this.properties.test) {\n                case XPathTestEnum.NAME:\n                    return [{\n                            expression: this,\n                            text: this.properties.name,\n                            type: 'node.name'\n                        }];\n                case XPathTestEnum.TYPE_PROCESSING_INSTRUCTION:\n                    return [{\n                            expression: this,\n                            text: \"processing-instruction\",\n                            type: 'function.name'\n                        }, {\n                            expression: this,\n                            text: '(',\n                            type: 'paren.left'\n                        }, ...this.properties.literal ? this.properties.literal.toTokens(expandHashtags) : [], {\n                            expression: this,\n                            text: \")\",\n                            type: 'paren.right'\n                        }];\n                case XPathTestEnum.NAMESPACE_WILDCARD:\n                    return [{\n                            expression: this,\n                            text: this.properties.namespace,\n                            type: 'namespace'\n                        }, {\n                            expression: this,\n                            text: \":*\",\n                            type: 'path'\n                        }];\n                case XPathTestEnum.TYPE_FUNCTION:\n                    // path token (slash) is already added when combining\n                    // the paths in XPathPathExpr\n                    return [];\n                default:\n                    return this.properties.test ? [{\n                            expression: this,\n                            text: this.properties.test,\n                            type: 'path'\n                        }] : [];\n            }\n        }\n        predicateXPath(mapper) {\n            if (this.predicates.length > 0) {\n                return \"[\" + this.predicates.map(mapper).join(\"][\") + \"]\";\n            }\n            return \"\";\n        }\n        combine(expandHashtags, mapper) {\n            return this.mainXPath(expandHashtags) + this.predicateXPath(mapper);\n        }\n        getChildren() {\n            return this.predicates;\n        }\n        mainXPath(expandHashtags) {\n            return this.mainTokens(expandHashtags).map(t => t.text).join('');\n        }\n        mainTokens(expandHashtags) {\n            let axisPrefix = [{\n                    expression: this,\n                    text: this.properties.axis,\n                    type: 'path'\n                }, {\n                    expression: this,\n                    text: \"::\",\n                    type: 'operator'\n                }];\n            // Use the abbreviated syntax to shorten the axis\n            // or in some cases the whole thing\n            switch (this.properties.axis) {\n                case XPathAxisEnum.DESCENDANT_OR_SELF:\n                    if (this.properties.test === XPathTestEnum.TYPE_NODE) {\n                        return [{\n                                expression: this,\n                                text: \"//\",\n                                type: 'path'\n                            }];\n                    }\n                    break;\n                case XPathAxisEnum.CHILD:\n                    axisPrefix = []; // this is the default\n                    break;\n                case XPathAxisEnum.ATTRIBUTE:\n                    axisPrefix = [{\n                            expression: this,\n                            text: \"@\",\n                            type: 'attribute.sigil'\n                        }];\n                    break;\n                case XPathAxisEnum.SELF:\n                    if (this.properties.test === XPathTestEnum.TYPE_NODE) {\n                        return [{\n                                expression: this,\n                                text: \".\",\n                                type: 'path'\n                            }];\n                    }\n                    break;\n                case XPathAxisEnum.PARENT:\n                    if (this.properties.test === XPathTestEnum.TYPE_NODE) {\n                        return [{\n                                expression: this,\n                                text: \"..\",\n                                type: 'path'\n                            }];\n                    }\n                    break;\n            }\n            return [...axisPrefix, ...this.testTokens(expandHashtags)];\n        }\n        toHashtag() {\n            return XPathModels.CurrentHashtagConfig.toHashtag(this) || this.combine(false, part => part.toHashtag());\n        }\n        toTokens(expandHashtags = true) {\n            if (this.properties.test == XPathTestEnum.TYPE_FUNCTION && this.predicates.length == 1) {\n                return [...this.mainTokens(expandHashtags), ...this.predicates[0].toTokens(expandHashtags)];\n            }\n            return [...this.mainTokens(expandHashtags), ...this.brackets(this.predicates, expandHashtags)];\n        }\n        toString() {\n            var stringArray = [];\n            stringArray.push(\"{step:\");\n            stringArray.push(String(this.properties.axis));\n            stringArray.push(\",\");\n            stringArray.push(this.testTokens(true).map(t => t.text).join(''));\n            if (this.predicates.length > 0) {\n                stringArray.push(\",{\");\n                stringArray.push(this.predicates.join(\",\"));\n                stringArray.push(\"}\");\n            }\n            stringArray.push(\"}\");\n            return stringArray.join(\"\");\n        }\n        ;\n    }\n    XPathModels.XPathStep = XPathStep;\n    class XPathFilterExpr extends XPathExpressionBase {\n        constructor(properties) {\n            super();\n            this.properties = properties;\n            this.type = 'filter';\n            this.predicates = properties.predicates || [];\n        }\n        combine(mapper) {\n            var predicates = \"\";\n            if (this.predicates.length > 0) {\n                predicates = \"[\" + this.predicates.map(mapper).join(\"][\") + \"]\";\n            }\n            var expr = this.properties.expr.toXPath();\n            if (!(this.properties.expr instanceof XPathFuncExpr)) {\n                expr = \"(\" + expr + \")\";\n            }\n            return expr + predicates;\n        }\n        getChildren() {\n            return this.predicates;\n        }\n        toString() {\n            return `{filt-expr:${this.properties.expr.toString()},{${this.predicates.join(',')}}}`;\n        }\n        toHashtag() {\n            return XPathModels.CurrentHashtagConfig.toHashtag(this) || this.combine(part => part.toHashtag());\n        }\n        toTokens(expandHashtags = true) {\n            let tokens = [];\n            let expr = this.properties.expr.toTokens(expandHashtags);\n            if (!(this.properties.expr instanceof XPathFuncExpr) && this.properties.expr.parens) {\n                expr = [\n                    { expression: this, text: \"(\", type: 'paren.left' },\n                    ...expr,\n                    { expression: this, text: ')', type: 'paren.right' }\n                ];\n            }\n            tokens.push(...expr);\n            tokens.push(...this.brackets(this.predicates, expandHashtags));\n            return tokens;\n        }\n    }\n    XPathModels.XPathFilterExpr = XPathFilterExpr;\n    class XPathHashtagExpression extends XPathExpressionBase {\n        constructor(definition) {\n            super();\n            this.type = 'hashtag';\n            if (!XPathModels.CurrentHashtagConfig.isValidNamespace(definition.namespace)) {\n                throw new Error(definition.namespace + \" is not a valid # expression\");\n            }\n            this.initialContext = definition.initialContext;\n            this.namespace = definition.namespace;\n            this.steps = definition.steps || [];\n        }\n        toString() {\n            return `{hashtag-expr:${this.namespace},{${this.steps.join(\",\")}}}`;\n        }\n        toTokens(expandHashtags = true) {\n            if (expandHashtags) {\n                let xpath = XPathModels.CurrentHashtagConfig.hashtagToXPath(this.toHashtag()) || \"\";\n                let parser = new XPathParser(XPathModels.CurrentHashtagConfig);\n                return parser.parse(xpath).toTokens(false);\n            }\n            let tokens = [{ expression: this, text: this.namespace, type: 'namespace' }];\n            for (let i = 0; i < this.steps.length; i++) {\n                let step = this.steps[i];\n                tokens.push({\n                    expression: this,\n                    text: (i === 0) ? '#' : \"/\",\n                    type: 'hashtag'\n                });\n                tokens.push({\n                    expression: this,\n                    text: step,\n                    type: 'hashtag'\n                });\n            }\n            return tokens;\n        }\n        toHashtag() {\n            let parts = [this.namespace].concat(this.steps.map(step => step.toString())), ret = [];\n            for (let i = 0; i < parts.length; i++) {\n                // hashtag to start then /\n                ret.push((i === 0) ? '#' : \"/\");\n                ret.push(parts[i]);\n            }\n            return ret.join(\"\");\n        }\n    }\n    XPathModels.XPathHashtagExpression = XPathHashtagExpression;\n    class XPathStringLiteral extends XPathExpressionBase {\n        constructor(value, location) {\n            super();\n            this.location = location;\n            this.type = 'string';\n            this.stringDelimiter = value[0];\n            this.value = value.substr(1, value.length - 2);\n        }\n        get valueDisplay() {\n            return `${this.stringDelimiter}${this.value}${this.stringDelimiter}`;\n        }\n        toString() {\n            return \"{str:\" + this.valueDisplay + \"}\";\n        }\n        toHashtag() {\n            return this.valueDisplay;\n        }\n        toXPath() {\n            return this.valueDisplay;\n        }\n        toTokens(expandHashtags = true) {\n            return [{\n                    expression: this,\n                    text: this.stringDelimiter,\n                    type: 'string.delimiter'\n                }, {\n                    expression: this,\n                    text: this.value,\n                    type: 'string.value'\n                }, {\n                    expression: this,\n                    text: this.stringDelimiter,\n                    type: 'string.delimiter'\n                }];\n        }\n    }\n    XPathModels.XPathStringLiteral = XPathStringLiteral;\n    class XPathNumericLiteral extends XPathExpressionBase {\n        /**\n         * @param value the string representation of the number as found in the XPATH\n         */\n        constructor(value, location) {\n            super();\n            this.location = location;\n            this.type = 'numeric';\n            this.value = new BigNumber(value);\n        }\n        toString() {\n            return \"{num:\" + this.value.toString() + \"}\";\n        }\n        toHashtag() {\n            return this.toXPath();\n        }\n        toTokens(expandHashtags = true) {\n            return [{\n                    expression: this,\n                    text: this.value.toFixed(),\n                    type: 'numeric'\n                }];\n        }\n    }\n    XPathModels.XPathNumericLiteral = XPathNumericLiteral;\n    class ParseLocation {\n        constructor(yyloc) {\n            this.firstColumn = yyloc.first_column;\n            this.firstLine = yyloc.first_line;\n            this.lastColumn = yyloc.last_column;\n            this.lastLine = yyloc.last_line;\n        }\n    }\n    XPathModels.ParseLocation = ParseLocation;\n})(XPathModels || (XPathModels = {}));\n","\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\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: ..................... es\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: ..................... true\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: .......... true\n    //   assigns location: ................ true\n    //   uses yystack: .................... false\n    //   uses yysstack: ................... false\n    //   uses yysp: ....................... true\n    //   uses yyrulelength: ............... false\n    //   uses yyMergeLocationInfo API: .... true\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  \"AND\": 7,\n  \"AT\": 30,\n  \"COMMA\": 21,\n  \"DBL_COLON\": 29,\n  \"DBL_DOT\": 28,\n  \"DBL_SLASH\": 23,\n  \"DIV\": 17,\n  \"DOT\": 27,\n  \"EOF\": 1,\n  \"EQ\": 8,\n  \"GT\": 12,\n  \"GTE\": 13,\n  \"HASH\": 24,\n  \"LBRACK\": 25,\n  \"LPAREN\": 3,\n  \"LT\": 10,\n  \"LTE\": 11,\n  \"MINUS\": 15,\n  \"MOD\": 18,\n  \"MULT\": 16,\n  \"NEQ\": 9,\n  \"NODETYPE_COMMENT\": 35,\n  \"NODETYPE_NODE\": 33,\n  \"NODETYPE_PROCINSTR\": 36,\n  \"NODETYPE_TEXT\": 34,\n  \"NSWILDCARD\": 32,\n  \"NUM\": 38,\n  \"OR\": 6,\n  \"PLUS\": 14,\n  \"QNAME\": 20,\n  \"RBRACK\": 26,\n  \"RPAREN\": 4,\n  \"SLASH\": 22,\n  \"STR\": 37,\n  \"UNION\": 19,\n  \"VAR\": 5,\n  \"WILDCARD\": 31,\n  \"arg_list\": 44,\n  \"axis_specifier\": 55,\n  \"base_expr\": 41,\n  \"error\": 2,\n  \"expr\": 40,\n  \"filter_expr\": 46,\n  \"func_call\": 43,\n  \"hashtag_expr\": 47,\n  \"hashtag_path\": 48,\n  \"literal\": 57,\n  \"loc_path\": 50,\n  \"node_test\": 56,\n  \"op_expr\": 42,\n  \"path_expr\": 45,\n  \"predicate\": 49,\n  \"rel_loc_path\": 51,\n  \"step\": 52,\n  \"step_body\": 54,\n  \"step_unabbr\": 53,\n  \"xpath_expr\": 39\n},\nterminals_: {\n  1: \"EOF\",\n  2: \"error\",\n  3: \"LPAREN\",\n  4: \"RPAREN\",\n  5: \"VAR\",\n  6: \"OR\",\n  7: \"AND\",\n  8: \"EQ\",\n  9: \"NEQ\",\n  10: \"LT\",\n  11: \"LTE\",\n  12: \"GT\",\n  13: \"GTE\",\n  14: \"PLUS\",\n  15: \"MINUS\",\n  16: \"MULT\",\n  17: \"DIV\",\n  18: \"MOD\",\n  19: \"UNION\",\n  20: \"QNAME\",\n  21: \"COMMA\",\n  22: \"SLASH\",\n  23: \"DBL_SLASH\",\n  24: \"HASH\",\n  25: \"LBRACK\",\n  26: \"RBRACK\",\n  27: \"DOT\",\n  28: \"DBL_DOT\",\n  29: \"DBL_COLON\",\n  30: \"AT\",\n  31: \"WILDCARD\",\n  32: \"NSWILDCARD\",\n  33: \"NODETYPE_NODE\",\n  34: \"NODETYPE_TEXT\",\n  35: \"NODETYPE_COMMENT\",\n  36: \"NODETYPE_PROCINSTR\",\n  37: \"STR\",\n  38: \"NUM\"\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  39,\n  s,\n  [40, 5],\n  s,\n  [41, 4],\n  s,\n  [42, 15],\n  43,\n  43,\n  44,\n  44,\n  s,\n  [45, 5],\n  46,\n  46,\n  47,\n  47,\n  48,\n  48,\n  49,\n  s,\n  [50, 4],\n  s,\n  [51, 4],\n  s,\n  [52, 3],\n  53,\n  53,\n  54,\n  54,\n  55,\n  55,\n  s,\n  [56, 8],\n  57,\n  57\n]),\n  rule: u([\n  2,\n  s,\n  [1, 5],\n  3,\n  c,\n  [4, 4],\n  s,\n  [3, 12],\n  2,\n  3,\n  4,\n  3,\n  c,\n  [21, 3],\n  c,\n  [11, 5],\n  2,\n  4,\n  2,\n  c,\n  [9, 3],\n  1,\n  2,\n  c,\n  [43, 3],\n  s,\n  [3, 3],\n  s,\n  [1, 3],\n  c,\n  [9, 3],\n  c,\n  [13, 4],\n  c,\n  [31, 6],\n  4,\n  1,\n  1\n])\n}),\nperformAction: function parser__PerformAction(yyloc, yystate /* action[1] */, yysp, yyvstack, yylstack) {\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 : xpath_expr $end */\n\n    // default action (generated by JISON mode classic/merge :: 1,VT,VA,-,-,LT,LA,-,-):\n    this.$ = yyvstack[yysp - 1];\n    this._$ = yylstack[yysp - 1];\n    // END of default action (generated by JISON mode classic/merge :: 1,VT,VA,-,-,LT,LA,-,-)\n    break;\n\ncase 1:\n    /*! Production::    xpath_expr : expr EOF */\n\n    // default action (generated by JISON mode classic/merge :: 2,VT,VA,-,-,LT,LA,-,-):\n    this.$ = yyvstack[yysp - 1];\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 1, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 2,VT,VA,-,-,LT,LA,-,-)\n    \n    \n    return yyvstack[yysp - 1];\n    break;\n\ncase 2:\n    /*! Production::    expr : base_expr */\ncase 3:\n    /*! Production::    expr : op_expr */\ncase 4:\n    /*! Production::    expr : path_expr */\ncase 5:\n    /*! Production::    expr : filter_expr */\ncase 6:\n    /*! Production::    expr : hashtag_expr */\ncase 50:\n    /*! Production::    step : step_unabbr */\ncase 54:\n    /*! Production::    step_unabbr : step_body */\n\n    // default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yylstack[yysp];\n    // END of default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = yyvstack[yysp];\n    break;\n\ncase 7:\n    /*! Production::    base_expr : LPAREN expr RPAREN */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    yyvstack[yysp - 1].parens = true; this.$ = yyvstack[yysp - 1];\n    break;\n\ncase 8:\n    /*! Production::    base_expr : func_call */\ncase 10:\n    /*! Production::    base_expr : literal */\ncase 30:\n    /*! Production::    path_expr : loc_path */\n\n    // default action (generated by JISON mode classic/merge :: 1,VT,VA,-,-,LT,LA,-,-):\n    this.$ = yyvstack[yysp];\n    this._$ = yylstack[yysp];\n    // END of default action (generated by JISON mode classic/merge :: 1,VT,VA,-,-,LT,LA,-,-)\n    break;\n\ncase 9:\n    /*! Production::    base_expr : VAR */\n\n    // default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yylstack[yysp];\n    // END of default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathVariableReference(yyvstack[yysp]);\n    break;\n\ncase 11:\n    /*! Production::    op_expr : expr OR expr */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathBoolExpr({\"type\": \"or\", \"left\": yyvstack[yysp - 2], \"right\": yyvstack[yysp]});\n    break;\n\ncase 12:\n    /*! Production::    op_expr : expr AND expr */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathBoolExpr({\"type\": \"and\", \"left\": yyvstack[yysp - 2], \"right\": yyvstack[yysp]});\n    break;\n\ncase 13:\n    /*! Production::    op_expr : expr EQ expr */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathEqExpr({\"type\": \"==\", \"left\": yyvstack[yysp - 2], \"right\": yyvstack[yysp]});\n    break;\n\ncase 14:\n    /*! Production::    op_expr : expr NEQ expr */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathEqExpr({\"type\": \"!=\", \"left\": yyvstack[yysp - 2], \"right\": yyvstack[yysp]});\n    break;\n\ncase 15:\n    /*! Production::    op_expr : expr LT expr */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathCmpExpr({\"type\": \"<\", \"left\":yyvstack[yysp - 2], \"right\": yyvstack[yysp]});\n    break;\n\ncase 16:\n    /*! Production::    op_expr : expr LTE expr */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathCmpExpr({\"type\": \"<=\", \"left\":yyvstack[yysp - 2], \"right\": yyvstack[yysp]});\n    break;\n\ncase 17:\n    /*! Production::    op_expr : expr GT expr */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathCmpExpr({\"type\": \">\", \"left\":yyvstack[yysp - 2], \"right\": yyvstack[yysp]});\n    break;\n\ncase 18:\n    /*! Production::    op_expr : expr GTE expr */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathCmpExpr({\"type\": \">=\", \"left\":yyvstack[yysp - 2], \"right\": yyvstack[yysp]});\n    break;\n\ncase 19:\n    /*! Production::    op_expr : expr PLUS expr */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathArithExpr({\"type\": \"+\", \"left\":yyvstack[yysp - 2], \"right\": yyvstack[yysp]});\n    break;\n\ncase 20:\n    /*! Production::    op_expr : expr MINUS expr */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathArithExpr({\"type\": \"-\", \"left\":yyvstack[yysp - 2], \"right\": yyvstack[yysp]});\n    break;\n\ncase 21:\n    /*! Production::    op_expr : expr MULT expr */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathArithExpr({\"type\": \"*\", \"left\":yyvstack[yysp - 2], \"right\": yyvstack[yysp]});\n    break;\n\ncase 22:\n    /*! Production::    op_expr : expr DIV expr */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathArithExpr({\"type\": \"/\", \"left\":yyvstack[yysp - 2], \"right\": yyvstack[yysp]});\n    break;\n\ncase 23:\n    /*! Production::    op_expr : expr MOD expr */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathArithExpr({\"type\": \"%\", \"left\":yyvstack[yysp - 2], \"right\": yyvstack[yysp]});\n    break;\n\ncase 24:\n    /*! Production::    op_expr : MINUS expr */\n\n    // default action (generated by JISON mode classic/merge :: 2,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 1, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 2,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathNumNegExpr({\"type\": \"num-neg\", \"value\":yyvstack[yysp]});\n    break;\n\ncase 25:\n    /*! Production::    op_expr : expr UNION expr */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathUnionExpr({\"type\": \"union\", \"left\":yyvstack[yysp - 2], \"right\": yyvstack[yysp]});\n    break;\n\ncase 26:\n    /*! Production::    func_call : QNAME LPAREN arg_list RPAREN */\n\n    // default action (generated by JISON mode classic/merge :: 4,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 3, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 4,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathFuncExpr({id: yyvstack[yysp - 3], args: yyvstack[yysp - 1]});\n    break;\n\ncase 27:\n    /*! Production::    func_call : QNAME LPAREN RPAREN */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathFuncExpr({id: yyvstack[yysp - 2], args: []});\n    break;\n\ncase 28:\n    /*! Production::    arg_list : arg_list COMMA expr */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    var args = yyvstack[yysp - 2];\n    args.push(yyvstack[yysp]);\n    this.$ = args;\n    break;\n\ncase 29:\n    /*! Production::    arg_list : expr */\ncase 39:\n    /*! Production::    hashtag_path : QNAME */\ncase 46:\n    /*! Production::    rel_loc_path : step */\n\n    // default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yylstack[yysp];\n    // END of default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = [yyvstack[yysp]];\n    break;\n\ncase 31:\n    /*! Production::    path_expr : filter_expr SLASH rel_loc_path */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathPathExpr({\n    initialContext: yy.xpathModels.XPathInitialContextEnum.EXPR,\n    filter: yyvstack[yysp - 2], steps: yyvstack[yysp]});\n    break;\n\ncase 32:\n    /*! Production::    path_expr : filter_expr DBL_SLASH rel_loc_path */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    var steps = yyvstack[yysp];\n    steps.splice(0, 0, new yy.xpathModels.XPathStep({\n                              axis: yy.xpathModels.XPathAxisEnum.DESCENDANT_OR_SELF, \n                              test: yy.xpathModels.XPathTestEnum.TYPE_NODE,\n                              location: new yy.xpathModels.ParseLocation(yyloc)}));\n    this.$ = new yy.xpathModels.XPathPathExpr({\n                  initialContext: yy.xpathModels.XPathInitialContextEnum.EXPR,\n                  filter: yyvstack[yysp - 2], steps: steps});\n    break;\n\ncase 33:\n    /*! Production::    path_expr : base_expr SLASH rel_loc_path */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    // could eliminate filterExpr wrapper, but this makes tests pass as-is\n    var filterExpr = new yy.xpathModels.XPathFilterExpr({expr: yyvstack[yysp - 2]});\n    this.$ = new yy.xpathModels.XPathPathExpr({\n                  initialContext: yy.xpathModels.XPathInitialContextEnum.EXPR,\n                  filter: filterExpr, steps: yyvstack[yysp]});\n    break;\n\ncase 34:\n    /*! Production::    path_expr : base_expr DBL_SLASH rel_loc_path */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    var steps = yyvstack[yysp];\n    // could eliminate filterExpr wrapper, but this makes tests pass as-is\n    var filterExpr = new yy.xpathModels.XPathFilterExpr({expr: yyvstack[yysp - 2]});\n    steps.splice(0, 0, new yy.xpathModels.XPathStep({\n                              axis: yy.xpathModels.XPathAxisEnum.DESCENDANT_OR_SELF, \n                              test: yy.xpathModels.XPathTestEnum.TYPE_NODE,\n                              location: new yy.xpathModels.ParseLocation(yyloc)}));\n    this.$ = new yy.xpathModels.XPathPathExpr({\n                  initialContext: yy.xpathModels.XPathInitialContextEnum.EXPR,\n                  filter: filterExpr, steps: steps});\n    break;\n\ncase 35:\n    /*! Production::    filter_expr : base_expr predicate */\n\n    // default action (generated by JISON mode classic/merge :: 2,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 1, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 2,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathFilterExpr({expr: yyvstack[yysp - 1], predicates: [yyvstack[yysp]]});\n    break;\n\ncase 36:\n    /*! Production::    filter_expr : filter_expr predicate */\n\n    // default action (generated by JISON mode classic/merge :: 2,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 1, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 2,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    var filterExpr = yyvstack[yysp - 1];\n    filterExpr.predicates.push(yyvstack[yysp]);\n    this.$ = filterExpr;\n    break;\n\ncase 37:\n    /*! Production::    hashtag_expr : HASH QNAME SLASH hashtag_path */\n\n    // default action (generated by JISON mode classic/merge :: 4,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 3, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 4,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathHashtagExpression({initialContext: yy.xpathModels.XPathInitialContextEnum.HASHTAG,\n    namespace: yyvstack[yysp - 2],\n    steps: yyvstack[yysp]});\n    break;\n\ncase 38:\n    /*! Production::    hashtag_expr : HASH QNAME */\n\n    // default action (generated by JISON mode classic/merge :: 2,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 1, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 2,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathHashtagExpression({initialContext: yy.xpathModels.XPathInitialContextEnum.HASHTAG,\n    namespace: yyvstack[yysp],\n    steps: []});\n    break;\n\ncase 40:\n    /*! Production::    hashtag_path : hashtag_path SLASH QNAME */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    var path = yyvstack[yysp - 2]; path.push(yyvstack[yysp]); this.$ = path;\n    break;\n\ncase 41:\n    /*! Production::    predicate : LBRACK expr RBRACK */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = yyvstack[yysp - 1];\n    break;\n\ncase 42:\n    /*! Production::    loc_path : rel_loc_path */\n\n    // default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yylstack[yysp];\n    // END of default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathPathExpr({initialContext: yy.xpathModels.XPathInitialContextEnum.RELATIVE,\n    steps: yyvstack[yysp]});\n    break;\n\ncase 43:\n    /*! Production::    loc_path : SLASH rel_loc_path */\n\n    // default action (generated by JISON mode classic/merge :: 2,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 1, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 2,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathPathExpr({initialContext: yy.xpathModels.XPathInitialContextEnum.ROOT,\n    steps: yyvstack[yysp]});\n    break;\n\ncase 44:\n    /*! Production::    loc_path : DBL_SLASH rel_loc_path */\n\n    // default action (generated by JISON mode classic/merge :: 2,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 1, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 2,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    var steps = yyvstack[yysp];\n    // insert descendant step into beginning\n    steps.splice(0, 0, new yy.xpathModels.XPathStep({axis: yy.xpathModels.XPathAxisEnum.DESCENDANT_OR_SELF,\n            test: yy.xpathModels.XPathTestEnum.TYPE_NODE,\n            location: new yy.xpathModels.ParseLocation(yyloc)}));\n    this.$ = new yy.xpathModels.XPathPathExpr({initialContext: yy.xpathModels.XPathInitialContextEnum.ROOT,\n                            steps: steps});\n    break;\n\ncase 45:\n    /*! Production::    loc_path : SLASH */\n\n    // default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yylstack[yysp];\n    // END of default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathPathExpr({initialContext: yy.xpathModels.XPathInitialContextEnum.ROOT,\n    steps: []});\n    break;\n\ncase 47:\n    /*! Production::    rel_loc_path : rel_loc_path SLASH func_call */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    // placed here instead of in node_test/step_body because\n    // there this expression results in an ambiguous parser\n    var nodeTest = {\n            axis: yy.xpathModels.XPathAxisEnum.CHILD,\n            test: yy.xpathModels.XPathTestEnum.TYPE_FUNCTION,\n            predicates: [yyvstack[yysp]],\n            location: new yy.xpathModels.ParseLocation(yyloc)\n    };\n    var path = yyvstack[yysp - 2];\n    path.push(new yy.xpathModels.XPathStep(nodeTest));\n    this.$ = path;\n    break;\n\ncase 48:\n    /*! Production::    rel_loc_path : rel_loc_path SLASH step */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    var path = yyvstack[yysp - 2];\n    path.push(yyvstack[yysp]);\n    this.$ = path;\n    break;\n\ncase 49:\n    /*! Production::    rel_loc_path : rel_loc_path DBL_SLASH step */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    var path = yyvstack[yysp - 2];\n    path.push(new yy.xpathModels.XPathStep({axis: yy.xpathModels.XPathAxisEnum.DESCENDANT_OR_SELF,\n            test: yy.xpathModels.XPathTestEnum.TYPE_NODE,\n            location: new yy.xpathModels.ParseLocation(yyloc)}));\n    path.push(yyvstack[yysp]);\n    this.$ = path;\n    break;\n\ncase 51:\n    /*! Production::    step : DOT */\n\n    // default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yylstack[yysp];\n    // END of default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathStep({axis: yy.xpathModels.XPathAxisEnum.SELF, \n    test: yy.xpathModels.XPathTestEnum.TYPE_NODE,\n    location: new yy.xpathModels.ParseLocation(yyloc)});\n    break;\n\ncase 52:\n    /*! Production::    step : DBL_DOT */\n\n    // default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yylstack[yysp];\n    // END of default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathStep({axis: yy.xpathModels.XPathAxisEnum.PARENT, \n    test: yy.xpathModels.XPathTestEnum.TYPE_NODE,\n    location: new yy.xpathModels.ParseLocation(yyloc)});\n    break;\n\ncase 53:\n    /*! Production::    step_unabbr : step_unabbr predicate */\n\n    // default action (generated by JISON mode classic/merge :: 2,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 1, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 2,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    var step = yyvstack[yysp - 1];\n    step.predicates.push(yyvstack[yysp]);\n    this.$ = step;\n    break;\n\ncase 55:\n    /*! Production::    step_body : node_test */\n\n    // default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yylstack[yysp];\n    // END of default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    var nodeTest = yyvstack[yysp]; // temporary dict with appropriate args\n    nodeTest.axis = yy.xpathModels.XPathAxisEnum.CHILD;\n    nodeTest.location = new yy.xpathModels.ParseLocation(yyloc);\n    this.$ = new yy.xpathModels.XPathStep(nodeTest);\n    break;\n\ncase 56:\n    /*! Production::    step_body : axis_specifier node_test */\n\n    // default action (generated by JISON mode classic/merge :: 2,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 1, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 2,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    var nodeTest = yyvstack[yysp];  // temporary dict with appropriate args\n    nodeTest.axis = yyvstack[yysp - 1]; // add axis\n    nodeTest.location = new yy.xpathModels.ParseLocation(yyloc);\n    this.$ = new yy.xpathModels.XPathStep(nodeTest);\n    break;\n\ncase 57:\n    /*! Production::    axis_specifier : QNAME DBL_COLON */\n\n    // default action (generated by JISON mode classic/merge :: 2,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 1, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 2,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = yy.xpathModels.testAxisName(yyvstack[yysp - 1]);\n    break;\n\ncase 58:\n    /*! Production::    axis_specifier : AT */\n\n    // default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yylstack[yysp];\n    // END of default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = yy.xpathModels.XPathAxisEnum.ATTRIBUTE;\n    break;\n\ncase 59:\n    /*! Production::    node_test : QNAME */\n\n    // default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yylstack[yysp];\n    // END of default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = {\"test\": yy.xpathModels.XPathTestEnum.NAME, \"name\": yyvstack[yysp]};\n    break;\n\ncase 60:\n    /*! Production::    node_test : WILDCARD */\n\n    // default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yylstack[yysp];\n    // END of default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = {\"test\": yy.xpathModels.XPathTestEnum.NAME_WILDCARD};\n    break;\n\ncase 61:\n    /*! Production::    node_test : NSWILDCARD */\n\n    // default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yylstack[yysp];\n    // END of default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = {\"test\": yy.xpathModels.XPathTestEnum.NAMESPACE_WILDCARD, \"namespace\": yyvstack[yysp]};\n    break;\n\ncase 62:\n    /*! Production::    node_test : NODETYPE_NODE LPAREN RPAREN */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = {\"test\": yy.xpathModels.XPathTestEnum.TYPE_NODE};\n    break;\n\ncase 63:\n    /*! Production::    node_test : NODETYPE_TEXT LPAREN RPAREN */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = {\"test\": yy.xpathModels.XPathTestEnum.TYPE_TEXT};\n    break;\n\ncase 64:\n    /*! Production::    node_test : NODETYPE_COMMENT LPAREN RPAREN */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = {\"test\": yy.xpathModels.XPathTestEnum.TYPE_COMMENT};\n    break;\n\ncase 65:\n    /*! Production::    node_test : NODETYPE_PROCINSTR LPAREN RPAREN */\n\n    // default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 2, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = {\"test\": yy.xpathModels.XPathTestEnum.TYPE_PROCESSING_INSTRUCTION, \"literal\": null};\n    break;\n\ncase 66:\n    /*! Production::    node_test : NODETYPE_PROCINSTR LPAREN STR RPAREN */\n\n    // default action (generated by JISON mode classic/merge :: 4,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yyparser.yyMergeLocationInfo(yysp - 3, yysp);\n    // END of default action (generated by JISON mode classic/merge :: 4,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = {\"test\": yy.xpathModels.XPathTestEnum.TYPE_PROCESSING_INSTRUCTION,\n    \"literal\": new yy.xpathModels.XPathStringLiteral(yyvstack[yysp - 1], new yy.xpathModels.ParseLocation(yyloc))};\n    break;\n\ncase 67:\n    /*! Production::    literal : STR */\n\n    // default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yylstack[yysp];\n    // END of default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathStringLiteral(yyvstack[yysp], new yy.xpathModels.ParseLocation(yyloc));\n    break;\n\ncase 68:\n    /*! Production::    literal : NUM */\n\n    // default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-):\n    this._$ = yylstack[yysp];\n    // END of default action (generated by JISON mode classic/merge :: 1,VT,VA,VU,-,LT,LA,-,-)\n    \n    \n    this.$ = new yy.xpathModels.XPathNumericLiteral(yyvstack[yysp], new yy.xpathModels.ParseLocation(yyloc));\n    break;\n\n}\n},\ntable: bt({\n  len: u([\n  34,\n  1,\n  15,\n  22,\n  0,\n  0,\n  22,\n  0,\n  33,\n  s,\n  [0, 3],\n  33,\n  0,\n  1,\n  23,\n  0,\n  0,\n  20,\n  34,\n  16,\n  c,\n  [16, 3],\n  s,\n  [0, 3],\n  8,\n  0,\n  0,\n  s,\n  [1, 4],\n  c,\n  [24, 3],\n  s,\n  [33, 13],\n  16,\n  16,\n  0,\n  c,\n  [4, 4],\n  15,\n  18,\n  19,\n  35,\n  0,\n  16,\n  15,\n  20,\n  22,\n  20,\n  s,\n  [0, 3],\n  s,\n  [1, 3],\n  2,\n  s,\n  [18, 13],\n  0,\n  20,\n  20,\n  15,\n  20,\n  20,\n  0,\n  2,\n  2,\n  0,\n  16,\n  s,\n  [0, 7],\n  1,\n  0,\n  19,\n  c,\n  [98, 5],\n  16,\n  0\n]),\n  symbol: u([\n  3,\n  5,\n  15,\n  20,\n  22,\n  23,\n  24,\n  27,\n  28,\n  s,\n  [30, 14, 1],\n  45,\n  46,\n  47,\n  s,\n  [50, 8, 1],\n  1,\n  1,\n  s,\n  [6, 14, 1],\n  1,\n  4,\n  c,\n  [16, 14],\n  21,\n  22,\n  23,\n  25,\n  26,\n  49,\n  c,\n  [22, 22],\n  c,\n  [94, 18],\n  c,\n  [93, 15],\n  c,\n  [33, 33],\n  20,\n  1,\n  3,\n  c,\n  [90, 20],\n  29,\n  c,\n  [112, 19],\n  26,\n  c,\n  [20, 16],\n  20,\n  21,\n  26,\n  c,\n  [89, 9],\n  c,\n  [79, 6],\n  20,\n  c,\n  [16, 15],\n  c,\n  [182, 22],\n  20,\n  c,\n  [35, 6],\n  56,\n  s,\n  [3, 5],\n  c,\n  [194, 65],\n  c,\n  [33, 396],\n  c,\n  [512, 16],\n  c,\n  [16, 16],\n  c,\n  [65, 65],\n  c,\n  [592, 15],\n  c,\n  [608, 17],\n  c,\n  [676, 17],\n  21,\n  22,\n  26,\n  3,\n  4,\n  c,\n  [118, 21],\n  s,\n  [44, 4, 1],\n  c,\n  [119, 18],\n  43,\n  c,\n  [119, 15],\n  c,\n  [711, 24],\n  c,\n  [105, 19],\n  c,\n  [823, 24],\n  s,\n  [4, 4],\n  37,\n  c,\n  [170, 35],\n  c,\n  [18, 216],\n  c,\n  [301, 22],\n  26,\n  c,\n  [18, 14],\n  c,\n  [55, 41],\n  20,\n  48,\n  4,\n  21,\n  c,\n  [23, 16],\n  4,\n  c,\n  [502, 20],\n  c,\n  [619, 33],\n  c,\n  [52, 16]\n]),\n  type: u([\n  s,\n  [2, 18],\n  s,\n  [0, 16],\n  1,\n  s,\n  [2, 36],\n  0,\n  c,\n  [22, 40],\n  s,\n  [0, 15],\n  c,\n  [33, 51],\n  s,\n  [2, 54],\n  c,\n  [78, 16],\n  c,\n  [94, 27],\n  c,\n  [22, 8],\n  c,\n  [124, 23],\n  c,\n  [194, 66],\n  c,\n  [33, 388],\n  c,\n  [528, 40],\n  c,\n  [65, 65],\n  c,\n  [686, 59],\n  c,\n  [119, 41],\n  s,\n  [2, 397],\n  c,\n  [398, 57],\n  c,\n  [717, 32]\n]),\n  state: u([\n  s,\n  [1, 4, 1],\n  9,\n  5,\n  6,\n  7,\n  13,\n  18,\n  21,\n  22,\n  25,\n  27,\n  26,\n  11,\n  52,\n  56,\n  57,\n  c,\n  [17, 14],\n  58,\n  c,\n  [15, 14],\n  64,\n  c,\n  [7, 5],\n  66,\n  c,\n  [6, 5],\n  67,\n  68,\n  74,\n  c,\n  [29, 14],\n  75,\n  c,\n  [15, 14],\n  76,\n  c,\n  [15, 14],\n  77,\n  c,\n  [15, 14],\n  78,\n  c,\n  [15, 14],\n  79,\n  c,\n  [15, 14],\n  80,\n  c,\n  [15, 14],\n  81,\n  c,\n  [15, 14],\n  82,\n  c,\n  [15, 14],\n  83,\n  c,\n  [15, 14],\n  84,\n  c,\n  [15, 14],\n  85,\n  c,\n  [15, 14],\n  86,\n  c,\n  [15, 14],\n  87,\n  c,\n  [15, 14],\n  88,\n  c,\n  [7, 5],\n  89,\n  c,\n  [6, 5],\n  90,\n  c,\n  [27, 14],\n  91,\n  c,\n  [7, 5],\n  92,\n  c,\n  [6, 5],\n  97,\n  c,\n  [27, 3],\n  95,\n  c,\n  [28, 11],\n  98,\n  99,\n  c,\n  [7, 4],\n  100,\n  c,\n  [5, 4],\n  107,\n  113,\n  c,\n  [55, 14]\n]),\n  mode: u([\n  s,\n  [1, 33],\n  s,\n  [2, 17],\n  c,\n  [20, 20],\n  c,\n  [21, 5],\n  s,\n  [1, 37],\n  2,\n  c,\n  [61, 19],\n  c,\n  [63, 3],\n  c,\n  [81, 19],\n  c,\n  [37, 20],\n  c,\n  [160, 36],\n  c,\n  [41, 4],\n  s,\n  [1, 336],\n  c,\n  [431, 33],\n  c,\n  [373, 43],\n  c,\n  [491, 36],\n  c,\n  [533, 26],\n  c,\n  [67, 7],\n  c,\n  [83, 19],\n  c,\n  [101, 21],\n  c,\n  [18, 36],\n  c,\n  [22, 10],\n  c,\n  [18, 66],\n  c,\n  [20, 6],\n  c,\n  [18, 32],\n  c,\n  [221, 22],\n  c,\n  [18, 35],\n  c,\n  [301, 22],\n  c,\n  [892, 18],\n  c,\n  [55, 43],\n  c,\n  [331, 16],\n  c,\n  [135, 20],\n  c,\n  [968, 21],\n  c,\n  [15, 14]\n]),\n  goto: u([\n  8,\n  10,\n  12,\n  15,\n  19,\n  20,\n  14,\n  23,\n  24,\n  34,\n  s,\n  [28, 6, 1],\n  16,\n  17,\n  s,\n  [35, 15, 1],\n  s,\n  [2, 17],\n  50,\n  51,\n  53,\n  2,\n  s,\n  [5, 17],\n  54,\n  55,\n  53,\n  5,\n  c,\n  [75, 18],\n  c,\n  [18, 18],\n  59,\n  59,\n  60,\n  s,\n  [59, 20],\n  61,\n  s,\n  [42, 17],\n  62,\n  63,\n  42,\n  s,\n  [45, 16],\n  65,\n  45,\n  45,\n  c,\n  [74, 9],\n  65,\n  c,\n  [10, 9],\n  s,\n  [50, 19],\n  53,\n  50,\n  69,\n  c,\n  [28, 6],\n  s,\n  [70, 4, 1],\n  c,\n  [150, 36],\n  c,\n  [18, 216],\n  c,\n  [294, 10],\n  c,\n  [10, 10],\n  c,\n  [38, 38],\n  93,\n  c,\n  [517, 14],\n  s,\n  [24, 15],\n  c,\n  [16, 3],\n  s,\n  [38, 17],\n  94,\n  38,\n  8,\n  96,\n  c,\n  [91, 17],\n  15,\n  c,\n  [91, 19],\n  s,\n  [43, 17],\n  62,\n  63,\n  43,\n  s,\n  [59, 21],\n  61,\n  s,\n  [44, 17],\n  62,\n  63,\n  44,\n  s,\n  [101, 5, 1],\n  11,\n  11,\n  c,\n  [159, 14],\n  11,\n  11,\n  s,\n  [12, 3],\n  c,\n  [18, 13],\n  12,\n  12,\n  s,\n  [13, 6],\n  c,\n  [18, 10],\n  13,\n  13,\n  s,\n  [14, 6],\n  c,\n  [18, 10],\n  14,\n  14,\n  s,\n  [15, 10],\n  c,\n  [18, 6],\n  15,\n  15,\n  s,\n  [16, 10],\n  c,\n  [18, 6],\n  16,\n  16,\n  s,\n  [17, 10],\n  c,\n  [18, 6],\n  17,\n  17,\n  s,\n  [18, 10],\n  c,\n  [18, 6],\n  18,\n  18,\n  s,\n  [19, 12],\n  c,\n  [18, 4],\n  19,\n  19,\n  s,\n  [20, 12],\n  c,\n  [18, 4],\n  20,\n  20,\n  s,\n  [21, 15],\n  49,\n  21,\n  21,\n  s,\n  [22, 15],\n  49,\n  22,\n  22,\n  s,\n  [23, 15],\n  49,\n  23,\n  23,\n  s,\n  [33, 17],\n  62,\n  63,\n  33,\n  s,\n  [34, 17],\n  62,\n  63,\n  34,\n  c,\n  [272, 14],\n  106,\n  s,\n  [31, 17],\n  62,\n  63,\n  31,\n  s,\n  [32, 17],\n  62,\n  63,\n  32,\n  108,\n  109,\n  110,\n  29,\n  c,\n  [59, 14],\n  29,\n  111,\n  s,\n  [37, 17],\n  112,\n  37,\n  c,\n  [564, 18],\n  114,\n  28,\n  c,\n  [55, 14],\n  28\n])\n}),\ndefaultActions: bda({\n  idx: u([\n  4,\n  5,\n  7,\n  9,\n  10,\n  11,\n  13,\n  16,\n  17,\n  21,\n  s,\n  [23, 4, 1],\n  28,\n  29,\n  34,\n  35,\n  52,\n  56,\n  61,\n  67,\n  68,\n  69,\n  87,\n  93,\n  96,\n  s,\n  [98, 7, 1],\n  106,\n  108,\n  109,\n  111,\n  114\n]),\n  goto: u([\n  3,\n  4,\n  6,\n  8,\n  9,\n  10,\n  30,\n  67,\n  68,\n  46,\n  51,\n  52,\n  54,\n  55,\n  60,\n  61,\n  58,\n  1,\n  35,\n  36,\n  57,\n  53,\n  56,\n  59,\n  25,\n  7,\n  27,\n  47,\n  48,\n  49,\n  s,\n  [62, 4, 1],\n  41,\n  39,\n  26,\n  66,\n  40\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    var lstack = new Array(128);        // location stack\n    var table = this.table;\n    var sp = 0;                         // 'stack pointer': index into the stacks\n    var yyloc;\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, 115 /* === 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    // shallow clone objects, straight copy of simple `src` values\n    // e.g. `lexer.yytext` MAY be a complex value object,\n    // rather than a simple string/value.\n    function shallow_copy(src) {\n        if (typeof src === 'object') {\n            var dst = {};\n            for (var k in src) {\n                if (Object.prototype.hasOwnProperty.call(src, k)) {\n                    dst[k] = src[k];\n                }\n            }\n            return dst;\n        }\n        return src;\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    function copy_yylloc(loc) {\n        var rv = shallow_copy(loc);\n        if (rv && rv.range) {\n            rv.range = rv.range.slice(0);\n        }\n        return rv;\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        lstack.length = 0;\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    // merge yylloc info into a new yylloc instance.\n    //\n    // `first_index` and `last_index` MAY be UNDEFINED/NULL or these are indexes into the `lstack[]` location stack array.\n    //\n    // `first_yylloc` and `last_yylloc` MAY be UNDEFINED/NULL or explicit (custom or regular) `yylloc` instances, in which\n    // case these override the corresponding first/last indexes.\n    //\n    // `dont_look_back` is an optional flag (default: FALSE), which instructs this merge operation NOT to search\n    // through the parse location stack for a location, which would otherwise be used to construct the new (epsilon!)\n    // yylloc info.\n    //\n    // Note: epsilon rule's yylloc situation is detected by passing both `first_index` and `first_yylloc` as UNDEFINED/NULL.\n    this.yyMergeLocationInfo = function parser_yyMergeLocationInfo(first_index, last_index, first_yylloc, last_yylloc, dont_look_back) {\n        var i1 = first_index | 0,\n            i2 = last_index | 0;\n        var l1 = first_yylloc,\n            l2 = last_yylloc;\n        var rv;\n\n        // rules:\n        // - first/last yylloc entries override first/last indexes\n\n        if (!l1) {\n            if (first_index != null) {\n                for (var i = i1; i <= i2; i++) {\n                    l1 = lstack[i];\n                    if (l1) {\n                        break;\n                    }\n                }\n            }\n        }\n\n        if (!l2) {\n            if (last_index != null) {\n                for (var i = i2; i >= i1; i--) {\n                    l2 = lstack[i];\n                    if (l2) {\n                        break;\n                    }\n                }\n            }\n        }\n\n        // - detect if an epsilon rule is being processed and act accordingly:\n        if (!l1 && first_index == null) {\n            // epsilon rule span merger. With optional look-ahead in l2.\n            if (!dont_look_back) {\n                for (var i = (i1 || sp) - 1; i >= 0; i--) {\n                    l1 = lstack[i];\n                    if (l1) {\n                        break;\n                    }\n                }\n            }\n            if (!l1) {\n                if (!l2) {\n                    // when we still don't have any valid yylloc info, we're looking at an epsilon rule\n                    // without look-ahead and no preceding terms and/or `dont_look_back` set:\n                    // in that case we ca do nothing but return NULL/UNDEFINED:\n                    return undefined;\n                } else {\n                    // shallow-copy L2: after all, we MAY be looking\n                    // at unconventional yylloc info objects...\n                    rv = shallow_copy(l2);\n                    if (rv.range) {\n                        // shallow copy the yylloc ranges info to prevent us from modifying the original arguments' entries:\n                        rv.range = rv.range.slice(0);\n                    }\n                    return rv;\n                }\n            } else {\n                // shallow-copy L1, then adjust first col/row 1 column past the end.\n                rv = shallow_copy(l1);\n                rv.first_line = rv.last_line;\n                rv.first_column = rv.last_column;\n                if (rv.range) {\n                    // shallow copy the yylloc ranges info to prevent us from modifying the original arguments' entries:\n                    rv.range = rv.range.slice(0);\n                    rv.range[0] = rv.range[1];\n                }\n\n                if (l2) {\n                    // shallow-mixin L2, then adjust last col/row accordingly.\n                    shallow_copy_noclobber(rv, l2);\n                    rv.last_line = l2.last_line;\n                    rv.last_column = l2.last_column;\n                    if (rv.range && l2.range) {\n                        rv.range[1] = l2.range[1];\n                    }\n                }\n                return rv;\n            }\n        }\n\n        if (!l1) {\n            l1 = l2;\n            l2 = null;\n        }\n        if (!l1) {\n            return undefined;\n        }\n\n        // shallow-copy L1|L2, before we try to adjust the yylloc values: after all, we MAY be looking\n        // at unconventional yylloc info objects...\n        rv = shallow_copy(l1);\n\n        // first_line: ...,\n        // first_column: ...,\n        // last_line: ...,\n        // last_column: ...,\n        if (rv.range) {\n            // shallow copy the yylloc ranges info to prevent us from modifying the original arguments' entries:\n            rv.range = rv.range.slice(0);\n        }\n\n        if (l2) {\n            shallow_copy_noclobber(rv, l2);\n            rv.last_line = l2.last_line;\n            rv.last_column = l2.last_column;\n            if (rv.range && l2.range) {\n                rv.range[1] = l2.range[1];\n            }\n        }\n\n        return rv;\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            loc: copy_yylloc(lexer.yylloc),\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            location_stack: lstack,\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        yyloc = lexer.yylloc;\n        lstack[sp] = yyloc;\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                lstack[sp] = copy_yylloc(lexer.yylloc);\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                yyloc = lexer.yylloc;\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, yyloc, newState, sp - 1, vstack, lstack);\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                lstack[sp] = yyval._$;\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: ..................... true\n//   uses lexer values: ............... true / true\n//   location tracking: ............... true\n//   location assignment: ............. true\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\n      /*\n      Copyright (c) 2010-2011, Dimagi Inc., and individual contributors.\n      All rights reserved.\n\n      Redistribution and use in source and binary forms, with or without\n      modification, are permitted provided that the following conditions are met:\n          * Redistributions of source code must retain the above copyright\n            notice, this list of conditions and the following disclaimer.\n          * Redistributions in binary form must reproduce the above copyright\n            notice, this list of conditions and the following disclaimer in the\n            documentation and/or other materials provided with the distribution.\n          * Neither the name of the Dimagi, nor the names of its contributors may \n            be used to endorse or promote products derived from this software \n            without specific prior written permission.\n\n      THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\n      ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n      WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n      DISCLAIMED. IN NO EVENT SHALL DIMAGI INC. BE LIABLE FOR ANY\n      DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n      (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n      LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n      ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n      (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n      SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n      */\n      var YYSTATE = YY_START;\n\n      switch (yyrulenumber) {\n      case 0:\n        /*! Conditions:: * */\n        /*! Rule::       {WhiteSpace} */\n        /* ignore whitespace */\n        break;\n\n      case 1:\n        /*! Conditions:: * */\n        /*! Rule::       node(?=({WhiteSpace}?\\()) */\n        yy.xpathModels.debugLog('NODETYPE', yy_.yytext);\n\n        return 33;\n        break;\n\n      case 2:\n        /*! Conditions:: * */\n        /*! Rule::       text(?=({WhiteSpace}?\\()) */\n        yy.xpathModels.debugLog('NODETYPE', yy_.yytext);\n\n        return 34;\n        break;\n\n      case 3:\n        /*! Conditions:: * */\n        /*! Rule::       comment(?=({WhiteSpace}?\\()) */\n        yy.xpathModels.debugLog('NODETYPE', yy_.yytext);\n\n        return 35;\n        break;\n\n      case 4:\n        /*! Conditions:: * */\n        /*! Rule::       processing-instruction(?=({WhiteSpace}?\\()) */\n        yy.xpathModels.debugLog('NODETYPE', yy_.yytext);\n\n        return 36;\n        break;\n\n      case 5:\n        /*! Conditions:: * */\n        /*! Rule::       \\${QName} */\n        this.begin('OP_CONTEXT');\n\n        yy_.yytext = yy_.yytext.substr(1, yy_.yyleng - 1);\n        yy.xpathModels.debugLog('VAR', yy_.yytext);\n        return 5;\n        break;\n\n      case 6:\n        /*! Conditions:: VAL_CONTEXT INITIAL */\n        /*! Rule::       {NCName}:\\* */\n        this.begin('OP_CONTEXT');\n\n        yy_.yytext = yy_.yytext.substr(0, yy_.yyleng - 2);\n        yy.xpathModels.debugLog('NSWILDCARD', yy_.yytext);\n        return 32;\n        break;\n\n      case 7:\n        /*! Conditions:: VAL_CONTEXT INITIAL */\n        /*! Rule::       {QName} */\n        this.begin('OP_CONTEXT');\n\n        yy.xpathModels.debugLog('QNAME', yy_.yytext);\n        return 20;\n        break;\n\n      case 8:\n        /*! Conditions:: VAL_CONTEXT INITIAL */\n        /*! Rule::       \\* */\n        this.begin('OP_CONTEXT');\n\n        yy.xpathModels.debugLog('WILDCARD', yy_.yytext);\n        return 31;\n        break;\n\n      case 9:\n        /*! Conditions:: OP_CONTEXT */\n        /*! Rule::       \\* */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('MULT', yy_.yytext);\n        return 16;\n        break;\n\n      case 10:\n        /*! Conditions:: OP_CONTEXT */\n        /*! Rule::       (and(?={NotNameStartChar})) */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('AND', yy_.yytext);\n        return 7;\n        break;\n\n      case 11:\n        /*! Conditions:: OP_CONTEXT */\n        /*! Rule::       (or(?={NotNameStartChar})) */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('OR', yy_.yytext);\n        return 6;\n        break;\n\n      case 12:\n        /*! Conditions:: OP_CONTEXT */\n        /*! Rule::       (div(?={NotNameStartChar})) */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('DIV', yy_.yytext);\n        return 17;\n        break;\n\n      case 13:\n        /*! Conditions:: OP_CONTEXT */\n        /*! Rule::       (mod(?={NotNameStartChar})) */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('MOD', yy_.yytext);\n        return 18;\n        break;\n\n      case 14:\n        /*! Conditions:: * */\n        /*! Rule::       ({Digit}+(\\.{Digit}*)?|(\\.{Digit}+)) */\n        this.begin('OP_CONTEXT');\n\n        yy.xpathModels.debugLog('NUM', yy_.yytext);\n        return 38;\n        break;\n\n      case 15:\n        /*! Conditions:: * */\n        /*! Rule::       = */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('EQ', yy_.yytext);\n        return 8;\n        break;\n\n      case 16:\n        /*! Conditions:: * */\n        /*! Rule::       != */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('NEQ', yy_.yytext);\n        return 9;\n        break;\n\n      case 17:\n        /*! Conditions:: * */\n        /*! Rule::       <= */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('LTE', yy_.yytext);\n        return 11;\n        break;\n\n      case 18:\n        /*! Conditions:: * */\n        /*! Rule::       < */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('LT', yy_.yytext);\n        return 10;\n        break;\n\n      case 19:\n        /*! Conditions:: * */\n        /*! Rule::       >= */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('GTE', yy_.yytext);\n        return 13;\n        break;\n\n      case 20:\n        /*! Conditions:: * */\n        /*! Rule::       > */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('GT', yy_.yytext);\n        return 12;\n        break;\n\n      case 21:\n        /*! Conditions:: * */\n        /*! Rule::       \\+ */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('PLUS', yy_.yytext);\n        return 14;\n        break;\n\n      case 22:\n        /*! Conditions:: * */\n        /*! Rule::       - */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('MINUS', yy_.yytext);\n        return 15;\n        break;\n\n      case 23:\n        /*! Conditions:: * */\n        /*! Rule::       \\| */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('UNION', yy_.yytext);\n        return 19;\n        break;\n\n      case 24:\n        /*! Conditions:: * */\n        /*! Rule::       \\/\\/ */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('DBL', yy_.yytext);\n        return 23;\n        break;\n\n      case 25:\n        /*! Conditions:: * */\n        /*! Rule::       \\/ */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('SLASH', yy_.yytext);\n        return 22;\n        break;\n\n      case 26:\n        /*! Conditions:: * */\n        /*! Rule::       \\[ */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('LBRACK', yy_.yytext);\n        return 25;\n        break;\n\n      case 27:\n        /*! Conditions:: * */\n        /*! Rule::       \\] */\n        this.begin('OP_CONTEXT');\n\n        yy.xpathModels.debugLog('RBRACK', yy_.yytext);\n        return 26;\n        break;\n\n      case 28:\n        /*! Conditions:: * */\n        /*! Rule::       \\( */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('LPAREN', yy_.yytext);\n        return 3;\n        break;\n\n      case 29:\n        /*! Conditions:: * */\n        /*! Rule::       \\) */\n        this.begin('OP_CONTEXT');\n\n        yy.xpathModels.debugLog('RPAREN', yy_.yytext);\n        return 4;\n        break;\n\n      case 30:\n        /*! Conditions:: * */\n        /*! Rule::       \\.\\. */\n        this.begin('OP_CONTEXT');\n\n        yy.xpathModels.debugLog('DBL', yy_.yytext);\n        return 28;\n        break;\n\n      case 31:\n        /*! Conditions:: * */\n        /*! Rule::       \\. */\n        this.begin('OP_CONTEXT');\n\n        yy.xpathModels.debugLog('DOT', yy_.yytext);\n        return 27;\n        break;\n\n      case 32:\n        /*! Conditions:: * */\n        /*! Rule::       @ */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('AT', yy_.yytext);\n        return 30;\n        break;\n\n      case 33:\n        /*! Conditions:: * */\n        /*! Rule::       :: */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('DBL', yy_.yytext);\n        return 29;\n        break;\n\n      case 34:\n        /*! Conditions:: * */\n        /*! Rule::       , */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('COMMA', yy_.yytext);\n        return 21;\n        break;\n\n      case 35:\n        /*! Conditions:: * */\n        /*! Rule::       # */\n        this.begin('VAL_CONTEXT');\n\n        yy.xpathModels.debugLog('HASH', yy_.yytext);\n        return 24;\n        break;\n\n      case 36:\n        /*! Conditions:: * */\n        /*! Rule::       (\"[^\"\\\"\"]*\"|'[^'\\'']*') */\n        this.begin('OP_CONTEXT');\n\n        yy.xpathModels.debugLog('STR', yy_.yytext);\n        return 37;\n        break;\n\n      default:\n        return this.simpleCaseActionClusters[yyrulenumber];\n      }\n    },\n\n    simpleCaseActionClusters: {\n      /*! Conditions:: * */\n      /*! Rule::       $ */\n      37: 1\n    },\n\n    rules: [\n      /*  0: */  /^(?:((\\s+)))/,\n      /*  1: */  /^(?:node(?=(((\\s+))?\\()))/,\n      /*  2: */  /^(?:text(?=(((\\s+))?\\()))/,\n      /*  3: */  /^(?:comment(?=(((\\s+))?\\()))/,\n      /*  4: */  /^(?:processing-instruction(?=(((\\s+))?\\()))/,\n      /*  5: */  /^(?:\\$([^\\W\\d][\\w\\-.]*(:[^\\W\\d][\\w\\-.]*)?))/,\n      /*  6: */  /^(?:([^\\W\\d][\\w\\-.]*):\\*)/,\n      /*  7: */  /^(?:([^\\W\\d][\\w\\-.]*(:[^\\W\\d][\\w\\-.]*)?))/,\n      /*  8: */  /^(?:\\*)/,\n      /*  9: */  /^(?:\\*)/,\n      /* 10: */  /^(?:(and(?=([\\W\\d]))))/,\n      /* 11: */  /^(?:(or(?=([\\W\\d]))))/,\n      /* 12: */  /^(?:(div(?=([\\W\\d]))))/,\n      /* 13: */  /^(?:(mod(?=([\\W\\d]))))/,\n      /* 14: */  /^(?:((\\d)+(\\.(\\d)*)?|(\\.(\\d)+)))/,\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    ],\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          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        ],\n\n        inclusive: true\n      },\n\n      'OP_CONTEXT': {\n        rules: [\n          0,\n          1,\n          2,\n          3,\n          4,\n          5,\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        ],\n\n        inclusive: true\n      },\n\n      'VAL_CONTEXT': {\n        rules: [\n          0,\n          1,\n          2,\n          3,\n          4,\n          5,\n          6,\n          7,\n          8,\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        ],\n\n        inclusive: true\n      }\n    }\n  };\n\n  return lexer;\n}();\nparser.lexer = lexer;\n\n\n\n\nfunction Parser() {\n    this.yy = {};\n}\nParser.prototype = parser;\nparser.Parser = Parser;\n\nfunction yyparse() {\n    return parser.parse.apply(parser, arguments);\n}\n\n\n\nexport default {\n    parser,\n    Parser,\n    parse: yyparse,\n    \n};\n\n","import { XPathModels } from './xpath-models';\nimport jison from './jison/xpath.js';\nexport * from './xpath-models';\n// assign the shared scope\njison.parser.yy = {\n    xpathModels: XPathModels,\n    parseError: XPathModels.parseError\n};\n/**\n * Class for parsing an XPath string.\n */\nexport class XPathParser {\n    constructor(hashtagConfig = XPathModels.DefaultHashtagConfig) {\n        this.hashtagConfig = hashtagConfig;\n    }\n    /**\n     * Parses an XPath string and returns a parse tree or throw a parse exception.\n     * @param input XPath string to parse\n     * @exception @see {XPathModels.ParseError}\n     */\n    parse(input) {\n        XPathModels.CurrentHashtagConfig = this.hashtagConfig;\n        return jison.parse(input);\n    }\n    /**\n     * Parses an XPath string and returns an annotated version of the input string.\n     * @param input XPath string to parse\n     * @exception @see {XPathModels.ParseError}\n     */\n    annotate(input) {\n        let parsed = this.parse(input);\n        let tokens = parsed.toTokens(false).filter(t => t.type != 'whitespace');\n        let index = 0;\n        // preserve whitespace\n        for (let i = 0; i < tokens.length; i++) {\n            let token = tokens[i];\n            // token starts here\n            let textOffset = input.substring(index).indexOf(token.text);\n            if (textOffset == -1) {\n                throw `Misaligned input and parse at ${index}. Could not find ${token.text} in input.`;\n            }\n            if (textOffset > 0) {\n                // inject token containing whitespace\n                tokens.splice(i, 0, {\n                    expression: parsed,\n                    text: input.substr(index, textOffset),\n                    type: 'whitespace'\n                });\n                index += textOffset;\n                i++;\n            }\n            index += token.text.length;\n        }\n        if (index < input.length) {\n            tokens.push({\n                expression: parsed,\n                text: input.substring(index),\n                type: 'whitespace'\n            });\n        }\n        return tokens;\n    }\n}\n"],"names":["__webpack_require__","exports","definition","key","o","Object","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","Symbol","toStringTag","value","isNumeric","mathceil","Math","ceil","mathfloor","floor","bignumberError","tooManyDigits","BASE","LOG_BASE","MAX_SAFE_INTEGER","POWS_TEN","SQRT_BASE","MAX","bitFloor","n","i","coeffToString","a","s","z","j","length","r","charCodeAt","slice","compare","x","y","b","xc","c","yc","k","e","l","intCheck","min","max","name","Error","String","isOdd","toExponential","str","charAt","toFixedPoint","len","zs","XPathModels","BigNumber","clone","configObject","div","convertBase","parseNumeric","pow2_53","random53bitInt","basePrefix","dotAfter","dotBefore","isInfinityOrNaN","whitespaceOrPlus","P","constructor","toString","valueOf","ONE","DECIMAL_PLACES","ROUNDING_MODE","TO_EXP_NEG","TO_EXP_POS","MIN_EXP","MAX_EXP","CRYPTO","MODULO_MODE","POW_PRECISION","FORMAT","prefix","groupSize","secondaryGroupSize","groupSeparator","decimalSeparator","fractionGroupSize","fractionGroupSeparator","suffix","ALPHABET","alphabetHasNormalDecimalDigits","v","alphabet","caseChanged","isNum","this","_isBigNumber","test","indexOf","replace","search","substring","round","DEBUG","toUpperCase","toLowerCase","push","format","rm","id","c0","ne","maxOrMin","args","method","m","normalise","pop","sd","d","ni","rd","pows10","out","ROUND_UP","ROUND_DOWN","ROUND_CEIL","ROUND_FLOOR","ROUND_HALF_UP","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_HALF_CEIL","ROUND_HALF_FLOOR","EUCLID","config","set","p","crypto","getRandomValues","randomBytes","EXPONENTIAL_AT","RANGE","isBigNumber","maximum","arguments","lt","minimum","gt","random","dp","rand","Uint32Array","copy","splice","sum","plus","decimal","toBaseOut","baseIn","baseOut","arrL","arr","reverse","sign","callerIsToString","pow","concat","multiply","base","temp","xlo","xhi","carry","klo","khi","aL","bL","cmp","subtract","more","prod","prodL","q","qc","rem","remL","rem0","xi","xL","yc0","yL","yz","NaN","isNaN","p1","p2","absoluteValue","abs","comparedTo","decimalPlaces","dividedBy","dividedToIntegerBy","idiv","exponentiatedBy","half","isModExp","nIsBig","nIsNeg","nIsOdd","isInteger","mod","times","integerValue","isEqualTo","eq","isFinite","isGreaterThan","isGreaterThanOrEqualTo","gte","isLessThan","isLessThanOrEqualTo","lte","isNegative","isPositive","isZero","minus","t","xLTy","xe","ye","modulo","multipliedBy","xcL","ycL","ylo","yhi","zc","sqrtBase","negated","precision","shiftedBy","squareRoot","sqrt","rep","toFixed","toFormat","split","g1","g2","intPart","fractionPart","isNeg","intDigits","substr","RegExp","toFraction","md","d0","d1","d2","exp","n0","n1","toNumber","toPrecision","toJSON","for","JisonParserError","msg","hash","stacktrace","writable","exception","ex2","message","stack","captureStackTrace","u","rv","apply","DefaultHashtagConfig","isValidNamespace","namespace","hashtagToXPath","hashtagExpr","toHashtag","xpath","toXPath","isDebugging","debugLog","console","debug","join","testAxisName","keys","XPathAxisEnum","ParseError","XPathInitialContextEnum","XPathTestEnum","parseError","XPathExpressionBase","toTokens","map","text","parentheses","expandHashtags","tokens","expression","type","brackets","arg","XPathVariableReference","super","XPathOperationBase","CurrentHashtagConfig","XPathOperator","properties","parens","operationType","combine","formatter","operationTypeLiteral","space","leftParen","rightParen","ret","left","right","getChildren","expr","expressionTypeEnumToXPathLiteral","XPathBoolExpr","XPathEqExpr","XPathCmpExpr","XPathArithExpr","XPathUnionExpr","XPathNumNegExpr","XPathFuncExpr","mapper","part","XPathPathExpr","steps","partMap","curPart","sep","parts","prevPart","root","initialContext","ROOT","filter","EXPR","step","pathWithoutPredicates","mainXPath","XPathStep","axis","predicates","testTokens","NAME","TYPE_PROCESSING_INSTRUCTION","literal","NAMESPACE_WILDCARD","TYPE_FUNCTION","predicateXPath","mainTokens","axisPrefix","DESCENDANT_OR_SELF","TYPE_NODE","CHILD","ATTRIBUTE","SELF","PARENT","stringArray","XPathFilterExpr","XPathHashtagExpression","XPathParser","parse","XPathStringLiteral","location","stringDelimiter","valueDisplay","XPathNumericLiteral","ParseLocation","yyloc","firstColumn","first_column","firstLine","first_line","lastColumn","last_column","lastLine","last_line","setPrototypeOf","create","parser","trace","yy","options","hasPartialLrUpgradeOnConflict","errorRecoveryTokenDiscardCount","symbols_","terminals_","TERROR","EOF","originalQuoteName","originalParseError","cleanupAfterParse","constructParseErrorInfo","yyMergeLocationInfo","__reentrant_call_depth","__error_infos","__error_recovery_infos","quoteName","id_str","getSymbolName","symbol","describeSymbol","terminal_descriptions_","collect_expected_token_set","state","do_not_describe","tokenset","check","state_descriptions_","table","productions_","rule","bp","performAction","yystate","yysp","yyvstack","yylstack","yyparser","lexer","$","_$","xpathModels","filterExpr","HASHTAG","path","RELATIVE","nodeTest","NAME_WILDCARD","TYPE_TEXT","TYPE_COMMENT","mode","g","goto","shift","bt","defaultActions","idx","bda","ExceptionClass","recoverable","destroy","input","self","Array","sstack","vstack","lstack","sp","NO_ACTION","__lexer__","sharedState_yy","undefined","pre_parse","post_parse","pre_lex","post_lex","shallow_copy","src","dst","shallow_copy_noclobber","copy_yylloc","loc","range","assert","yyGetSharedState","resultValue","invoke_post_methods","do_not_nuke_errorinfos","cleanupAfterLex","el","first_index","last_index","first_yylloc","last_yylloc","dont_look_back","i1","i2","l1","l2","ex","expected","pei","errStr","match","yytext","token","token_id","line","yylineno","yylloc","action","new_state","newState","symbol_stack","state_stack","value_stack","location_stack","stack_pointer","rec","yyrulelen","this_production","lex","yyval","retval","setInput","canIUse","fastLex","errSymbolDescr","showPosition","ntsymbol","JisonLexerError","ERROR","__currentRuleSet__","__decompressed","done","_backtrack","_input","_more","_signaled_error_token","conditionStack","matched","matches","offset","yyleng","constructLexErrorInfo","show_input_position","prettyPrintRange","pos_str","yyerror","lineno_msg","lexerErrorsAreRecoverable","extra_error_attributes","clear","col","rules","rule_re","conditions","spec","rule_ids","rule_regexes","rule_new_ids","__rule_regexes","__rule_count","editRemainingInput","callback","cpsArg","ch","slice_len","lines","ch2","unput","pre","pre_lines","reject","backtrack_lexer","less","pastInput","maxSize","maxLines","past","upcomingInput","next","maxPrefix","maxPostfix","deriveLocationInfo","actual","preceding","following","current","context_loc","context_loc2","l0","lineno_display_width","log10","ws_prefix","nonempty_line_indexes","index","lno","errpfx","trim","clip_start","MINIMUM_VISIBLE_NONEMPTY_LINE_COUNT","clip_end","intermediate_line","describeYYLLOC","display_range_too","c1","c2","r1","r2","test_match","indexed_rule","backup","match_str","match_str_len","tempMatch","_currentRules","trackPosition","topState","regexes","flex","pendingInput","activeCondition","conditionStackDepth","begin","condition","pushState","popState","stateStackSize","yyrulenumber","YY_START","yy_","simpleCaseActionClusters","inclusive","Parser","hashtagConfig","annotate","parsed","textOffset"],"sourceRoot":""}