ohm-js 16.1.1 → 16.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (23) hide show
  1. package/dist/ohm.esm.js +6374 -0
  2. package/dist/ohm.esm.mjs +6373 -0
  3. package/dist/ohm.js +3 -315
  4. package/dist/ohm.min.js +1 -1
  5. package/index.js +8 -0
  6. package/package.json +9 -3
  7. package/src/errors.js +1 -1
  8. package/src/main.js +0 -1
  9. package/dist/browser/main.js +0 -8811
  10. package/dist/browser/main.js.map +0 -1
  11. package/dist/built-in-rules.js.old +0 -7
  12. package/dist/main.js.map +0 -1
  13. package/dist/ohm-1444k.js +0 -12006
  14. package/dist/ohm-2166k.js +0 -18009
  15. package/dist/ohm-2887k.js +0 -24012
  16. package/dist/ohm-3609k.js +0 -30015
  17. package/dist/ohm-4331k.js +0 -36018
  18. package/dist/ohm-big2.js +0 -12005
  19. package/dist/ohm-grammar.js.old +0 -2
  20. package/dist/ohm.webpack.js +0 -6000
  21. package/dist/ohm.webpack.min.js +0 -1
  22. package/dist/operations-and-attributes.js.new +0 -0
  23. package/dist/semi +0 -1
package/dist/main.js.map DELETED
@@ -1 +0,0 @@
1
- {"mappings":"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","sources":["packages/ohm-js/src/Failure.js","packages/ohm-js/src/common.js","packages/ohm-js/src/nodes.js","packages/ohm-js/src/pexprs.js","packages/ohm-js/src/CaseInsensitiveTerminal.js","packages/ohm-js/third_party/UnicodeCategories.js","packages/ohm-js/src/pexprs-allowsSkippingPrecedingSpace.js","packages/ohm-js/src/pexprs-assertAllApplicationsAreValid.js","packages/ohm-js/src/Namespace.js","packages/ohm-js/src/errors.js","packages/ohm-js/src/util.js","packages/ohm-js/src/pexprs-assertChoicesHaveUniformArity.js","packages/ohm-js/src/pexprs-assertIteratedExprsAreNotNullable.js","packages/ohm-js/src/Interval.js","packages/ohm-js/src/Trace.js","packages/ohm-js/src/pexprs-eval.js","packages/ohm-js/src/pexprs-outputRecipe.js","packages/ohm-js/src/pexprs-getArity.js","packages/ohm-js/src/pexprs-introduceParams.js","packages/ohm-js/src/pexprs-isNullable.js","packages/ohm-js/src/pexprs-substituteParams.js","packages/ohm-js/src/pexprs-toArgumentNameList.js","packages/ohm-js/src/pexprs-toDisplayString.js","packages/ohm-js/src/pexprs-toFailure.js","packages/ohm-js/src/pexprs-toString.js","packages/ohm-js/src/InputStream.js","packages/ohm-js/src/MatchResult.js","packages/ohm-js/src/PosInfo.js","packages/ohm-js/src/MatchState.js","packages/ohm-js/src/Matcher.js","packages/ohm-js/src/Semantics.js","packages/ohm-js/dist/operations-and-attributes.js","packages/ohm-js/src/Grammar.js","packages/ohm-js/src/GrammarDecl.js","packages/ohm-js/src/Builder.js","packages/ohm-js/src/main.js","packages/ohm-js/package.json","packages/ohm-js/src/version.js","packages/ohm-js/extras/index.js","packages/ohm-js/extras/VisitorFamily.js","packages/ohm-js/extras/semantics-toAST.js","packages/ohm-js/dist/built-in-rules.js","packages/ohm-js/dist/ohm-grammar.js"],"sourcesContent":["'use strict';\n\n// --------------------------------------------------------------------\n// Private stuff\n// --------------------------------------------------------------------\n\n/*\n `Failure`s represent expressions that weren't matched while parsing. They are used to generate\n error messages automatically. The interface of `Failure`s includes the collowing methods:\n\n - getText() : String\n - getType() : String (one of {\"description\", \"string\", \"code\"})\n - isDescription() : bool\n - isStringTerminal() : bool\n - isCode() : bool\n - isFluffy() : bool\n - makeFluffy() : void\n - subsumes(Failure) : bool\n*/\n\nfunction isValidType(type) {\n return type === 'description' || type === 'string' || type === 'code';\n}\n\nfunction Failure(pexpr, text, type) {\n if (!isValidType(type)) {\n throw new Error('invalid Failure type: ' + type);\n }\n this.pexpr = pexpr;\n this.text = text;\n this.type = type;\n this.fluffy = false;\n}\n\nFailure.prototype.getPExpr = function() {\n return this.pexpr;\n};\n\nFailure.prototype.getText = function() {\n return this.text;\n};\n\nFailure.prototype.getType = function() {\n return this.type;\n};\n\nFailure.prototype.isDescription = function() {\n return this.type === 'description';\n};\n\nFailure.prototype.isStringTerminal = function() {\n return this.type === 'string';\n};\n\nFailure.prototype.isCode = function() {\n return this.type === 'code';\n};\n\nFailure.prototype.isFluffy = function() {\n return this.fluffy;\n};\n\nFailure.prototype.makeFluffy = function() {\n this.fluffy = true;\n};\n\nFailure.prototype.clearFluffy = function() {\n this.fluffy = false;\n};\n\nFailure.prototype.subsumes = function(that) {\n return (\n this.getText() === that.getText() &&\n this.type === that.type &&\n (!this.isFluffy() || (this.isFluffy() && that.isFluffy()))\n );\n};\n\nFailure.prototype.toString = function() {\n return this.type === 'string' ? JSON.stringify(this.getText()) : this.getText();\n};\n\nFailure.prototype.clone = function() {\n const failure = new Failure(this.pexpr, this.text, this.type);\n if (this.isFluffy()) {\n failure.makeFluffy();\n }\n return failure;\n};\n\nFailure.prototype.toKey = function() {\n return this.toString() + '#' + this.type;\n};\n\n// --------------------------------------------------------------------\n// Exports\n// --------------------------------------------------------------------\n\nmodule.exports = Failure;\n","'use strict';\n\n// --------------------------------------------------------------------\n// Private Stuff\n// --------------------------------------------------------------------\n\n// Helpers\n\nconst escapeStringFor = {};\nfor (let c = 0; c < 128; c++) {\n escapeStringFor[c] = String.fromCharCode(c);\n}\nescapeStringFor[\"'\".charCodeAt(0)] = \"\\\\'\";\nescapeStringFor['\"'.charCodeAt(0)] = '\\\\\"';\nescapeStringFor['\\\\'.charCodeAt(0)] = '\\\\\\\\';\nescapeStringFor['\\b'.charCodeAt(0)] = '\\\\b';\nescapeStringFor['\\f'.charCodeAt(0)] = '\\\\f';\nescapeStringFor['\\n'.charCodeAt(0)] = '\\\\n';\nescapeStringFor['\\r'.charCodeAt(0)] = '\\\\r';\nescapeStringFor['\\t'.charCodeAt(0)] = '\\\\t';\nescapeStringFor['\\u000b'.charCodeAt(0)] = '\\\\v';\n\n// --------------------------------------------------------------------\n// Exports\n// --------------------------------------------------------------------\n\nexports.abstract = function(optMethodName) {\n const methodName = optMethodName || '';\n return function() {\n throw new Error(\n 'this method ' +\n methodName +\n ' is abstract! ' +\n '(it has no implementation in class ' +\n this.constructor.name +\n ')'\n );\n };\n};\n\nexports.assert = function(cond, message) {\n if (!cond) {\n throw new Error(message);\n }\n};\n\n// Define a lazily-computed, non-enumerable property named `propName`\n// on the object `obj`. `getterFn` will be called to compute the value the\n// first time the property is accessed.\nexports.defineLazyProperty = function(obj, propName, getterFn) {\n let memo;\n Object.defineProperty(obj, propName, {\n get() {\n if (!memo) {\n memo = getterFn.call(this);\n }\n return memo;\n },\n });\n};\n\nexports.clone = function(obj) {\n if (obj) {\n return Object.assign({}, obj);\n }\n return obj;\n};\n\nexports.repeatFn = function(fn, n) {\n const arr = [];\n while (n-- > 0) {\n arr.push(fn());\n }\n return arr;\n};\n\nexports.repeatStr = function(str, n) {\n return new Array(n + 1).join(str);\n};\n\nexports.repeat = function(x, n) {\n return exports.repeatFn(() => x, n);\n};\n\nexports.getDuplicates = function(array) {\n const duplicates = [];\n for (let idx = 0; idx < array.length; idx++) {\n const x = array[idx];\n if (array.lastIndexOf(x) !== idx && duplicates.indexOf(x) < 0) {\n duplicates.push(x);\n }\n }\n return duplicates;\n};\n\nexports.copyWithoutDuplicates = function(array) {\n const noDuplicates = [];\n array.forEach(entry => {\n if (noDuplicates.indexOf(entry) < 0) {\n noDuplicates.push(entry);\n }\n });\n return noDuplicates;\n};\n\nexports.isSyntactic = function(ruleName) {\n const firstChar = ruleName[0];\n return firstChar === firstChar.toUpperCase();\n};\n\nexports.isLexical = function(ruleName) {\n return !exports.isSyntactic(ruleName);\n};\n\nexports.padLeft = function(str, len, optChar) {\n const ch = optChar || ' ';\n if (str.length < len) {\n return exports.repeatStr(ch, len - str.length) + str;\n }\n return str;\n};\n\n// StringBuffer\n\nexports.StringBuffer = function() {\n this.strings = [];\n};\n\nexports.StringBuffer.prototype.append = function(str) {\n this.strings.push(str);\n};\n\nexports.StringBuffer.prototype.contents = function() {\n return this.strings.join('');\n};\n\n// Character escaping and unescaping\n\nexports.escapeChar = function(c, optDelim) {\n const charCode = c.charCodeAt(0);\n if ((c === '\"' || c === \"'\") && optDelim && c !== optDelim) {\n return c;\n } else if (charCode < 128) {\n return escapeStringFor[charCode];\n } else if (128 <= charCode && charCode < 256) {\n return '\\\\x' + exports.padLeft(charCode.toString(16), 2, '0');\n } else {\n return '\\\\u' + exports.padLeft(charCode.toString(16), 4, '0');\n }\n};\n\nexports.unescapeChar = function(s) {\n if (s.charAt(0) === '\\\\') {\n switch (s.charAt(1)) {\n case 'b':\n return '\\b';\n case 'f':\n return '\\f';\n case 'n':\n return '\\n';\n case 'r':\n return '\\r';\n case 't':\n return '\\t';\n case 'v':\n return '\\v';\n case 'x':\n return String.fromCharCode(parseInt(s.substring(2, 4), 16));\n case 'u':\n return String.fromCharCode(parseInt(s.substring(2, 6), 16));\n default:\n return s.charAt(1);\n }\n } else {\n return s;\n }\n};\n\n// Helper for producing a description of an unknown object in a safe way.\n// Especially useful for error messages where an unexpected type of object was encountered.\nexports.unexpectedObjToString = function(obj) {\n if (obj == null) {\n return String(obj);\n }\n const baseToString = Object.prototype.toString.call(obj);\n try {\n let typeName;\n if (obj.constructor && obj.constructor.name) {\n typeName = obj.constructor.name;\n } else if (baseToString.indexOf('[object ') === 0) {\n typeName = baseToString.slice(8, -1); // Extract e.g. \"Array\" from \"[object Array]\".\n } else {\n typeName = typeof obj;\n }\n return typeName + ': ' + JSON.stringify(String(obj));\n } catch (e) {\n return baseToString;\n }\n};\n","'use strict';\n\nconst common = require('./common');\n\n// Ensures that the deprecation warning for `primitiveValue` only appears once.\nlet didWarnForPrimitiveValue = false;\n\n// --------------------------------------------------------------------\n// Private stuff\n// --------------------------------------------------------------------\n\nclass Node {\n constructor(grammar, ctorName, matchLength) {\n this.grammar = grammar;\n this.ctorName = ctorName;\n this.matchLength = matchLength;\n }\n\n numChildren() {\n return this.children ? this.children.length : 0;\n }\n\n childAt(idx) {\n if (this.children) {\n return this.children[idx];\n }\n }\n\n indexOfChild(arg) {\n return this.children.indexOf(arg);\n }\n\n hasChildren() {\n return this.numChildren() > 0;\n }\n\n hasNoChildren() {\n return !this.hasChildren();\n }\n\n onlyChild() {\n if (this.numChildren() !== 1) {\n throw new Error(\n 'cannot get only child of a node of type ' +\n this.ctorName +\n ' (it has ' +\n this.numChildren() +\n ' children)'\n );\n } else {\n return this.firstChild();\n }\n }\n\n firstChild() {\n if (this.hasNoChildren()) {\n throw new Error(\n 'cannot get first child of a ' + this.ctorName + ' node, which has no children'\n );\n } else {\n return this.childAt(0);\n }\n }\n\n lastChild() {\n if (this.hasNoChildren()) {\n throw new Error(\n 'cannot get last child of a ' + this.ctorName + ' node, which has no children'\n );\n } else {\n return this.childAt(this.numChildren() - 1);\n }\n }\n\n childBefore(child) {\n const childIdx = this.indexOfChild(child);\n if (childIdx < 0) {\n throw new Error('Node.childBefore() called w/ an argument that is not a child');\n } else if (childIdx === 0) {\n throw new Error('cannot get child before first child');\n } else {\n return this.childAt(childIdx - 1);\n }\n }\n\n childAfter(child) {\n const childIdx = this.indexOfChild(child);\n if (childIdx < 0) {\n throw new Error('Node.childAfter() called w/ an argument that is not a child');\n } else if (childIdx === this.numChildren() - 1) {\n throw new Error('cannot get child after last child');\n } else {\n return this.childAt(childIdx + 1);\n }\n }\n\n isTerminal() {\n return false;\n }\n\n isNonterminal() {\n return false;\n }\n\n isIteration() {\n return false;\n }\n\n isOptional() {\n return false;\n }\n\n toJSON() {\n return {[this.ctorName]: this.children};\n }\n}\n\n// Terminals\n\nclass TerminalNode extends Node {\n constructor(grammar, value) {\n const matchLength = value ? value.length : 0;\n super(grammar, '_terminal', matchLength);\n this._value = value;\n }\n\n isTerminal() {\n return true;\n }\n\n toJSON() {\n return {[this.ctorName]: this._value};\n }\n\n get primitiveValue() {\n if (!didWarnForPrimitiveValue) {\n // eslint-disable-next-line no-console\n console.warn(\n 'Warning: primitiveValue is deprecated and will be removed in a future version of Ohm. ' +\n 'Use sourceString instead.'\n );\n didWarnForPrimitiveValue = true;\n }\n\n return this._value;\n }\n}\n\n// Nonterminals\n\nclass NonterminalNode extends Node {\n constructor(grammar, ruleName, children, childOffsets, matchLength) {\n super(grammar, ruleName, matchLength);\n this.children = children;\n this.childOffsets = childOffsets;\n }\n\n isNonterminal() {\n return true;\n }\n\n isLexical() {\n return common.isLexical(this.ctorName);\n }\n\n isSyntactic() {\n return common.isSyntactic(this.ctorName);\n }\n}\n\n// Iterations\n\nclass IterationNode extends Node {\n constructor(grammar, children, childOffsets, matchLength, isOptional) {\n super(grammar, '_iter', matchLength);\n this.children = children;\n this.childOffsets = childOffsets;\n this.optional = isOptional;\n }\n\n isIteration() {\n return true;\n }\n\n isOptional() {\n return this.optional;\n }\n}\n\n// --------------------------------------------------------------------\n// Exports\n// --------------------------------------------------------------------\n\nmodule.exports = {\n Node,\n TerminalNode,\n NonterminalNode,\n IterationNode,\n};\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst UnicodeCategories = require('../third_party/UnicodeCategories');\nconst common = require('./common');\n\n// --------------------------------------------------------------------\n// Private stuff\n// --------------------------------------------------------------------\n\n// General stuff\n\nclass PExpr {\n constructor() {\n if (this.constructor === PExpr) {\n throw new Error(\"PExpr cannot be instantiated -- it's abstract\");\n }\n }\n\n // Set the `source` property to the interval containing the source for this expression.\n withSource(interval) {\n if (interval) {\n this.source = interval.trimmed();\n }\n return this;\n }\n}\n\n// Any\n\nconst any = Object.create(PExpr.prototype);\n\n// End\n\nconst end = Object.create(PExpr.prototype);\n\n// Terminals\n\nclass Terminal extends PExpr {\n constructor(obj) {\n super();\n this.obj = obj;\n }\n}\n\n// Ranges\n\nclass Range extends PExpr {\n constructor(from, to) {\n super();\n this.from = from;\n this.to = to;\n }\n}\n\n// Parameters\n\nclass Param extends PExpr {\n constructor(index) {\n super();\n this.index = index;\n }\n}\n\n// Alternation\n\nclass Alt extends PExpr {\n constructor(terms) {\n super();\n this.terms = terms;\n }\n}\n\n// Extend is an implementation detail of rule extension\n\nclass Extend extends Alt {\n constructor(superGrammar, name, body) {\n const origBody = superGrammar.rules[name].body;\n super([body, origBody]);\n\n this.superGrammar = superGrammar;\n this.name = name;\n this.body = body;\n }\n}\n\n// Splice is an implementation detail of rule overriding with the `...` operator.\nclass Splice extends Alt {\n constructor(superGrammar, ruleName, beforeTerms, afterTerms) {\n const origBody = superGrammar.rules[ruleName].body;\n super([...beforeTerms, origBody, ...afterTerms]);\n\n this.superGrammar = superGrammar;\n this.ruleName = ruleName;\n this.expansionPos = beforeTerms.length;\n }\n}\n\n// Sequences\n\nclass Seq extends PExpr {\n constructor(factors) {\n super();\n this.factors = factors;\n }\n}\n\n// Iterators and optionals\n\nclass Iter extends PExpr {\n constructor(expr) {\n super();\n this.expr = expr;\n }\n}\n\nclass Star extends Iter {}\nclass Plus extends Iter {}\nclass Opt extends Iter {}\n\nStar.prototype.operator = '*';\nPlus.prototype.operator = '+';\nOpt.prototype.operator = '?';\n\nStar.prototype.minNumMatches = 0;\nPlus.prototype.minNumMatches = 1;\nOpt.prototype.minNumMatches = 0;\n\nStar.prototype.maxNumMatches = Number.POSITIVE_INFINITY;\nPlus.prototype.maxNumMatches = Number.POSITIVE_INFINITY;\nOpt.prototype.maxNumMatches = 1;\n\n// Predicates\n\nclass Not extends PExpr {\n constructor(expr) {\n super();\n this.expr = expr;\n }\n}\n\nclass Lookahead extends PExpr {\n constructor(expr) {\n super();\n this.expr = expr;\n }\n}\n\n// \"Lexification\"\n\nclass Lex extends PExpr {\n constructor(expr) {\n super();\n this.expr = expr;\n }\n}\n\n// Rule application\n\nclass Apply extends PExpr {\n constructor(ruleName, args = []) {\n super();\n this.ruleName = ruleName;\n this.args = args;\n }\n\n isSyntactic() {\n return common.isSyntactic(this.ruleName);\n }\n\n // This method just caches the result of `this.toString()` in a non-enumerable property.\n toMemoKey() {\n if (!this._memoKey) {\n Object.defineProperty(this, '_memoKey', {value: this.toString()});\n }\n return this._memoKey;\n }\n}\n\n// Unicode character\n\nclass UnicodeChar extends PExpr {\n constructor(category) {\n super();\n this.category = category;\n this.pattern = UnicodeCategories[category];\n }\n}\n\n// --------------------------------------------------------------------\n// Exports\n// --------------------------------------------------------------------\n\nexports.PExpr = PExpr;\nexports.any = any;\nexports.end = end;\nexports.Terminal = Terminal;\nexports.Range = Range;\nexports.Param = Param;\nexports.Alt = Alt;\nexports.Extend = Extend;\nexports.Splice = Splice;\nexports.Seq = Seq;\nexports.Iter = Iter;\nexports.Star = Star;\nexports.Plus = Plus;\nexports.Opt = Opt;\nexports.Not = Not;\nexports.Lookahead = Lookahead;\nexports.Lex = Lex;\nexports.Apply = Apply;\nexports.UnicodeChar = UnicodeChar;\n\n// --------------------------------------------------------------------\n// Extensions\n// --------------------------------------------------------------------\n\nrequire('./pexprs-allowsSkippingPrecedingSpace');\nrequire('./pexprs-assertAllApplicationsAreValid');\nrequire('./pexprs-assertChoicesHaveUniformArity');\nrequire('./pexprs-assertIteratedExprsAreNotNullable');\nrequire('./pexprs-eval');\nrequire('./pexprs-getArity');\nrequire('./pexprs-outputRecipe');\nrequire('./pexprs-introduceParams');\nrequire('./pexprs-isNullable');\nrequire('./pexprs-substituteParams');\nrequire('./pexprs-toArgumentNameList');\nrequire('./pexprs-toDisplayString');\nrequire('./pexprs-toFailure');\nrequire('./pexprs-toString');\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst Failure = require('./Failure');\nconst {TerminalNode} = require('./nodes');\nconst {assert} = require('./common');\nconst {PExpr, Terminal} = require('./pexprs');\n\nclass CaseInsensitiveTerminal extends PExpr {\n constructor(param) {\n super();\n this.obj = param;\n }\n\n _getString(state) {\n const terminal = state.currentApplication().args[this.obj.index];\n assert(terminal instanceof Terminal, 'expected a Terminal expression');\n return terminal.obj;\n }\n\n // Implementation of the PExpr API\n\n allowsSkippingPrecedingSpace() {\n return true;\n }\n\n eval(state) {\n const {inputStream} = state;\n const origPos = inputStream.pos;\n const matchStr = this._getString(state);\n if (!inputStream.matchString(matchStr, true)) {\n state.processFailure(origPos, this);\n return false;\n } else {\n state.pushBinding(new TerminalNode(state.grammar, matchStr), origPos);\n return true;\n }\n }\n\n getArity() {\n return 1;\n }\n\n substituteParams(actuals) {\n return new CaseInsensitiveTerminal(this.obj.substituteParams(actuals));\n }\n\n toDisplayString() {\n return this.obj.toDisplayString() + ' (case-insensitive)';\n }\n\n toFailure(grammar) {\n return new Failure(\n this,\n this.obj.toFailure(grammar) + ' (case-insensitive)',\n 'description'\n );\n }\n\n _isNullable(grammar, memo) {\n return this.obj._isNullable(grammar, memo);\n }\n}\n\nmodule.exports = CaseInsensitiveTerminal;\n","// Based on https://github.com/mathiasbynens/unicode-9.0.0.\n// These are just categories that are used in ES5/ES2015.\n// The full list of Unicode categories is here: http://www.fileformat.info/info/unicode/category/index.htm.\nmodule.exports = {\n // Letters\n Lu: /[A-Z\\xC0-\\xD6\\xD8-\\xDE\\u0100\\u0102\\u0104\\u0106\\u0108\\u010A\\u010C\\u010E\\u0110\\u0112\\u0114\\u0116\\u0118\\u011A\\u011C\\u011E\\u0120\\u0122\\u0124\\u0126\\u0128\\u012A\\u012C\\u012E\\u0130\\u0132\\u0134\\u0136\\u0139\\u013B\\u013D\\u013F\\u0141\\u0143\\u0145\\u0147\\u014A\\u014C\\u014E\\u0150\\u0152\\u0154\\u0156\\u0158\\u015A\\u015C\\u015E\\u0160\\u0162\\u0164\\u0166\\u0168\\u016A\\u016C\\u016E\\u0170\\u0172\\u0174\\u0176\\u0178\\u0179\\u017B\\u017D\\u0181\\u0182\\u0184\\u0186\\u0187\\u0189-\\u018B\\u018E-\\u0191\\u0193\\u0194\\u0196-\\u0198\\u019C\\u019D\\u019F\\u01A0\\u01A2\\u01A4\\u01A6\\u01A7\\u01A9\\u01AC\\u01AE\\u01AF\\u01B1-\\u01B3\\u01B5\\u01B7\\u01B8\\u01BC\\u01C4\\u01C7\\u01CA\\u01CD\\u01CF\\u01D1\\u01D3\\u01D5\\u01D7\\u01D9\\u01DB\\u01DE\\u01E0\\u01E2\\u01E4\\u01E6\\u01E8\\u01EA\\u01EC\\u01EE\\u01F1\\u01F4\\u01F6-\\u01F8\\u01FA\\u01FC\\u01FE\\u0200\\u0202\\u0204\\u0206\\u0208\\u020A\\u020C\\u020E\\u0210\\u0212\\u0214\\u0216\\u0218\\u021A\\u021C\\u021E\\u0220\\u0222\\u0224\\u0226\\u0228\\u022A\\u022C\\u022E\\u0230\\u0232\\u023A\\u023B\\u023D\\u023E\\u0241\\u0243-\\u0246\\u0248\\u024A\\u024C\\u024E\\u0370\\u0372\\u0376\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E\\u038F\\u0391-\\u03A1\\u03A3-\\u03AB\\u03CF\\u03D2-\\u03D4\\u03D8\\u03DA\\u03DC\\u03DE\\u03E0\\u03E2\\u03E4\\u03E6\\u03E8\\u03EA\\u03EC\\u03EE\\u03F4\\u03F7\\u03F9\\u03FA\\u03FD-\\u042F\\u0460\\u0462\\u0464\\u0466\\u0468\\u046A\\u046C\\u046E\\u0470\\u0472\\u0474\\u0476\\u0478\\u047A\\u047C\\u047E\\u0480\\u048A\\u048C\\u048E\\u0490\\u0492\\u0494\\u0496\\u0498\\u049A\\u049C\\u049E\\u04A0\\u04A2\\u04A4\\u04A6\\u04A8\\u04AA\\u04AC\\u04AE\\u04B0\\u04B2\\u04B4\\u04B6\\u04B8\\u04BA\\u04BC\\u04BE\\u04C0\\u04C1\\u04C3\\u04C5\\u04C7\\u04C9\\u04CB\\u04CD\\u04D0\\u04D2\\u04D4\\u04D6\\u04D8\\u04DA\\u04DC\\u04DE\\u04E0\\u04E2\\u04E4\\u04E6\\u04E8\\u04EA\\u04EC\\u04EE\\u04F0\\u04F2\\u04F4\\u04F6\\u04F8\\u04FA\\u04FC\\u04FE\\u0500\\u0502\\u0504\\u0506\\u0508\\u050A\\u050C\\u050E\\u0510\\u0512\\u0514\\u0516\\u0518\\u051A\\u051C\\u051E\\u0520\\u0522\\u0524\\u0526\\u0528\\u052A\\u052C\\u052E\\u0531-\\u0556\\u10A0-\\u10C5\\u10C7\\u10CD\\u13A0-\\u13F5\\u1E00\\u1E02\\u1E04\\u1E06\\u1E08\\u1E0A\\u1E0C\\u1E0E\\u1E10\\u1E12\\u1E14\\u1E16\\u1E18\\u1E1A\\u1E1C\\u1E1E\\u1E20\\u1E22\\u1E24\\u1E26\\u1E28\\u1E2A\\u1E2C\\u1E2E\\u1E30\\u1E32\\u1E34\\u1E36\\u1E38\\u1E3A\\u1E3C\\u1E3E\\u1E40\\u1E42\\u1E44\\u1E46\\u1E48\\u1E4A\\u1E4C\\u1E4E\\u1E50\\u1E52\\u1E54\\u1E56\\u1E58\\u1E5A\\u1E5C\\u1E5E\\u1E60\\u1E62\\u1E64\\u1E66\\u1E68\\u1E6A\\u1E6C\\u1E6E\\u1E70\\u1E72\\u1E74\\u1E76\\u1E78\\u1E7A\\u1E7C\\u1E7E\\u1E80\\u1E82\\u1E84\\u1E86\\u1E88\\u1E8A\\u1E8C\\u1E8E\\u1E90\\u1E92\\u1E94\\u1E9E\\u1EA0\\u1EA2\\u1EA4\\u1EA6\\u1EA8\\u1EAA\\u1EAC\\u1EAE\\u1EB0\\u1EB2\\u1EB4\\u1EB6\\u1EB8\\u1EBA\\u1EBC\\u1EBE\\u1EC0\\u1EC2\\u1EC4\\u1EC6\\u1EC8\\u1ECA\\u1ECC\\u1ECE\\u1ED0\\u1ED2\\u1ED4\\u1ED6\\u1ED8\\u1EDA\\u1EDC\\u1EDE\\u1EE0\\u1EE2\\u1EE4\\u1EE6\\u1EE8\\u1EEA\\u1EEC\\u1EEE\\u1EF0\\u1EF2\\u1EF4\\u1EF6\\u1EF8\\u1EFA\\u1EFC\\u1EFE\\u1F08-\\u1F0F\\u1F18-\\u1F1D\\u1F28-\\u1F2F\\u1F38-\\u1F3F\\u1F48-\\u1F4D\\u1F59\\u1F5B\\u1F5D\\u1F5F\\u1F68-\\u1F6F\\u1FB8-\\u1FBB\\u1FC8-\\u1FCB\\u1FD8-\\u1FDB\\u1FE8-\\u1FEC\\u1FF8-\\u1FFB\\u2102\\u2107\\u210B-\\u210D\\u2110-\\u2112\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u2130-\\u2133\\u213E\\u213F\\u2145\\u2183\\u2C00-\\u2C2E\\u2C60\\u2C62-\\u2C64\\u2C67\\u2C69\\u2C6B\\u2C6D-\\u2C70\\u2C72\\u2C75\\u2C7E-\\u2C80\\u2C82\\u2C84\\u2C86\\u2C88\\u2C8A\\u2C8C\\u2C8E\\u2C90\\u2C92\\u2C94\\u2C96\\u2C98\\u2C9A\\u2C9C\\u2C9E\\u2CA0\\u2CA2\\u2CA4\\u2CA6\\u2CA8\\u2CAA\\u2CAC\\u2CAE\\u2CB0\\u2CB2\\u2CB4\\u2CB6\\u2CB8\\u2CBA\\u2CBC\\u2CBE\\u2CC0\\u2CC2\\u2CC4\\u2CC6\\u2CC8\\u2CCA\\u2CCC\\u2CCE\\u2CD0\\u2CD2\\u2CD4\\u2CD6\\u2CD8\\u2CDA\\u2CDC\\u2CDE\\u2CE0\\u2CE2\\u2CEB\\u2CED\\u2CF2\\uA640\\uA642\\uA644\\uA646\\uA648\\uA64A\\uA64C\\uA64E\\uA650\\uA652\\uA654\\uA656\\uA658\\uA65A\\uA65C\\uA65E\\uA660\\uA662\\uA664\\uA666\\uA668\\uA66A\\uA66C\\uA680\\uA682\\uA684\\uA686\\uA688\\uA68A\\uA68C\\uA68E\\uA690\\uA692\\uA694\\uA696\\uA698\\uA69A\\uA722\\uA724\\uA726\\uA728\\uA72A\\uA72C\\uA72E\\uA732\\uA734\\uA736\\uA738\\uA73A\\uA73C\\uA73E\\uA740\\uA742\\uA744\\uA746\\uA748\\uA74A\\uA74C\\uA74E\\uA750\\uA752\\uA754\\uA756\\uA758\\uA75A\\uA75C\\uA75E\\uA760\\uA762\\uA764\\uA766\\uA768\\uA76A\\uA76C\\uA76E\\uA779\\uA77B\\uA77D\\uA77E\\uA780\\uA782\\uA784\\uA786\\uA78B\\uA78D\\uA790\\uA792\\uA796\\uA798\\uA79A\\uA79C\\uA79E\\uA7A0\\uA7A2\\uA7A4\\uA7A6\\uA7A8\\uA7AA-\\uA7AE\\uA7B0-\\uA7B4\\uA7B6\\uFF21-\\uFF3A]|\\uD801[\\uDC00-\\uDC27\\uDCB0-\\uDCD3]|\\uD803[\\uDC80-\\uDCB2]|\\uD806[\\uDCA0-\\uDCBF]|\\uD835[\\uDC00-\\uDC19\\uDC34-\\uDC4D\\uDC68-\\uDC81\\uDC9C\\uDC9E\\uDC9F\\uDCA2\\uDCA5\\uDCA6\\uDCA9-\\uDCAC\\uDCAE-\\uDCB5\\uDCD0-\\uDCE9\\uDD04\\uDD05\\uDD07-\\uDD0A\\uDD0D-\\uDD14\\uDD16-\\uDD1C\\uDD38\\uDD39\\uDD3B-\\uDD3E\\uDD40-\\uDD44\\uDD46\\uDD4A-\\uDD50\\uDD6C-\\uDD85\\uDDA0-\\uDDB9\\uDDD4-\\uDDED\\uDE08-\\uDE21\\uDE3C-\\uDE55\\uDE70-\\uDE89\\uDEA8-\\uDEC0\\uDEE2-\\uDEFA\\uDF1C-\\uDF34\\uDF56-\\uDF6E\\uDF90-\\uDFA8\\uDFCA]|\\uD83A[\\uDD00-\\uDD21]/,\n Ll: /[a-z\\xB5\\xDF-\\xF6\\xF8-\\xFF\\u0101\\u0103\\u0105\\u0107\\u0109\\u010B\\u010D\\u010F\\u0111\\u0113\\u0115\\u0117\\u0119\\u011B\\u011D\\u011F\\u0121\\u0123\\u0125\\u0127\\u0129\\u012B\\u012D\\u012F\\u0131\\u0133\\u0135\\u0137\\u0138\\u013A\\u013C\\u013E\\u0140\\u0142\\u0144\\u0146\\u0148\\u0149\\u014B\\u014D\\u014F\\u0151\\u0153\\u0155\\u0157\\u0159\\u015B\\u015D\\u015F\\u0161\\u0163\\u0165\\u0167\\u0169\\u016B\\u016D\\u016F\\u0171\\u0173\\u0175\\u0177\\u017A\\u017C\\u017E-\\u0180\\u0183\\u0185\\u0188\\u018C\\u018D\\u0192\\u0195\\u0199-\\u019B\\u019E\\u01A1\\u01A3\\u01A5\\u01A8\\u01AA\\u01AB\\u01AD\\u01B0\\u01B4\\u01B6\\u01B9\\u01BA\\u01BD-\\u01BF\\u01C6\\u01C9\\u01CC\\u01CE\\u01D0\\u01D2\\u01D4\\u01D6\\u01D8\\u01DA\\u01DC\\u01DD\\u01DF\\u01E1\\u01E3\\u01E5\\u01E7\\u01E9\\u01EB\\u01ED\\u01EF\\u01F0\\u01F3\\u01F5\\u01F9\\u01FB\\u01FD\\u01FF\\u0201\\u0203\\u0205\\u0207\\u0209\\u020B\\u020D\\u020F\\u0211\\u0213\\u0215\\u0217\\u0219\\u021B\\u021D\\u021F\\u0221\\u0223\\u0225\\u0227\\u0229\\u022B\\u022D\\u022F\\u0231\\u0233-\\u0239\\u023C\\u023F\\u0240\\u0242\\u0247\\u0249\\u024B\\u024D\\u024F-\\u0293\\u0295-\\u02AF\\u0371\\u0373\\u0377\\u037B-\\u037D\\u0390\\u03AC-\\u03CE\\u03D0\\u03D1\\u03D5-\\u03D7\\u03D9\\u03DB\\u03DD\\u03DF\\u03E1\\u03E3\\u03E5\\u03E7\\u03E9\\u03EB\\u03ED\\u03EF-\\u03F3\\u03F5\\u03F8\\u03FB\\u03FC\\u0430-\\u045F\\u0461\\u0463\\u0465\\u0467\\u0469\\u046B\\u046D\\u046F\\u0471\\u0473\\u0475\\u0477\\u0479\\u047B\\u047D\\u047F\\u0481\\u048B\\u048D\\u048F\\u0491\\u0493\\u0495\\u0497\\u0499\\u049B\\u049D\\u049F\\u04A1\\u04A3\\u04A5\\u04A7\\u04A9\\u04AB\\u04AD\\u04AF\\u04B1\\u04B3\\u04B5\\u04B7\\u04B9\\u04BB\\u04BD\\u04BF\\u04C2\\u04C4\\u04C6\\u04C8\\u04CA\\u04CC\\u04CE\\u04CF\\u04D1\\u04D3\\u04D5\\u04D7\\u04D9\\u04DB\\u04DD\\u04DF\\u04E1\\u04E3\\u04E5\\u04E7\\u04E9\\u04EB\\u04ED\\u04EF\\u04F1\\u04F3\\u04F5\\u04F7\\u04F9\\u04FB\\u04FD\\u04FF\\u0501\\u0503\\u0505\\u0507\\u0509\\u050B\\u050D\\u050F\\u0511\\u0513\\u0515\\u0517\\u0519\\u051B\\u051D\\u051F\\u0521\\u0523\\u0525\\u0527\\u0529\\u052B\\u052D\\u052F\\u0561-\\u0587\\u13F8-\\u13FD\\u1C80-\\u1C88\\u1D00-\\u1D2B\\u1D6B-\\u1D77\\u1D79-\\u1D9A\\u1E01\\u1E03\\u1E05\\u1E07\\u1E09\\u1E0B\\u1E0D\\u1E0F\\u1E11\\u1E13\\u1E15\\u1E17\\u1E19\\u1E1B\\u1E1D\\u1E1F\\u1E21\\u1E23\\u1E25\\u1E27\\u1E29\\u1E2B\\u1E2D\\u1E2F\\u1E31\\u1E33\\u1E35\\u1E37\\u1E39\\u1E3B\\u1E3D\\u1E3F\\u1E41\\u1E43\\u1E45\\u1E47\\u1E49\\u1E4B\\u1E4D\\u1E4F\\u1E51\\u1E53\\u1E55\\u1E57\\u1E59\\u1E5B\\u1E5D\\u1E5F\\u1E61\\u1E63\\u1E65\\u1E67\\u1E69\\u1E6B\\u1E6D\\u1E6F\\u1E71\\u1E73\\u1E75\\u1E77\\u1E79\\u1E7B\\u1E7D\\u1E7F\\u1E81\\u1E83\\u1E85\\u1E87\\u1E89\\u1E8B\\u1E8D\\u1E8F\\u1E91\\u1E93\\u1E95-\\u1E9D\\u1E9F\\u1EA1\\u1EA3\\u1EA5\\u1EA7\\u1EA9\\u1EAB\\u1EAD\\u1EAF\\u1EB1\\u1EB3\\u1EB5\\u1EB7\\u1EB9\\u1EBB\\u1EBD\\u1EBF\\u1EC1\\u1EC3\\u1EC5\\u1EC7\\u1EC9\\u1ECB\\u1ECD\\u1ECF\\u1ED1\\u1ED3\\u1ED5\\u1ED7\\u1ED9\\u1EDB\\u1EDD\\u1EDF\\u1EE1\\u1EE3\\u1EE5\\u1EE7\\u1EE9\\u1EEB\\u1EED\\u1EEF\\u1EF1\\u1EF3\\u1EF5\\u1EF7\\u1EF9\\u1EFB\\u1EFD\\u1EFF-\\u1F07\\u1F10-\\u1F15\\u1F20-\\u1F27\\u1F30-\\u1F37\\u1F40-\\u1F45\\u1F50-\\u1F57\\u1F60-\\u1F67\\u1F70-\\u1F7D\\u1F80-\\u1F87\\u1F90-\\u1F97\\u1FA0-\\u1FA7\\u1FB0-\\u1FB4\\u1FB6\\u1FB7\\u1FBE\\u1FC2-\\u1FC4\\u1FC6\\u1FC7\\u1FD0-\\u1FD3\\u1FD6\\u1FD7\\u1FE0-\\u1FE7\\u1FF2-\\u1FF4\\u1FF6\\u1FF7\\u210A\\u210E\\u210F\\u2113\\u212F\\u2134\\u2139\\u213C\\u213D\\u2146-\\u2149\\u214E\\u2184\\u2C30-\\u2C5E\\u2C61\\u2C65\\u2C66\\u2C68\\u2C6A\\u2C6C\\u2C71\\u2C73\\u2C74\\u2C76-\\u2C7B\\u2C81\\u2C83\\u2C85\\u2C87\\u2C89\\u2C8B\\u2C8D\\u2C8F\\u2C91\\u2C93\\u2C95\\u2C97\\u2C99\\u2C9B\\u2C9D\\u2C9F\\u2CA1\\u2CA3\\u2CA5\\u2CA7\\u2CA9\\u2CAB\\u2CAD\\u2CAF\\u2CB1\\u2CB3\\u2CB5\\u2CB7\\u2CB9\\u2CBB\\u2CBD\\u2CBF\\u2CC1\\u2CC3\\u2CC5\\u2CC7\\u2CC9\\u2CCB\\u2CCD\\u2CCF\\u2CD1\\u2CD3\\u2CD5\\u2CD7\\u2CD9\\u2CDB\\u2CDD\\u2CDF\\u2CE1\\u2CE3\\u2CE4\\u2CEC\\u2CEE\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\uA641\\uA643\\uA645\\uA647\\uA649\\uA64B\\uA64D\\uA64F\\uA651\\uA653\\uA655\\uA657\\uA659\\uA65B\\uA65D\\uA65F\\uA661\\uA663\\uA665\\uA667\\uA669\\uA66B\\uA66D\\uA681\\uA683\\uA685\\uA687\\uA689\\uA68B\\uA68D\\uA68F\\uA691\\uA693\\uA695\\uA697\\uA699\\uA69B\\uA723\\uA725\\uA727\\uA729\\uA72B\\uA72D\\uA72F-\\uA731\\uA733\\uA735\\uA737\\uA739\\uA73B\\uA73D\\uA73F\\uA741\\uA743\\uA745\\uA747\\uA749\\uA74B\\uA74D\\uA74F\\uA751\\uA753\\uA755\\uA757\\uA759\\uA75B\\uA75D\\uA75F\\uA761\\uA763\\uA765\\uA767\\uA769\\uA76B\\uA76D\\uA76F\\uA771-\\uA778\\uA77A\\uA77C\\uA77F\\uA781\\uA783\\uA785\\uA787\\uA78C\\uA78E\\uA791\\uA793-\\uA795\\uA797\\uA799\\uA79B\\uA79D\\uA79F\\uA7A1\\uA7A3\\uA7A5\\uA7A7\\uA7A9\\uA7B5\\uA7B7\\uA7FA\\uAB30-\\uAB5A\\uAB60-\\uAB65\\uAB70-\\uABBF\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFF41-\\uFF5A]|\\uD801[\\uDC28-\\uDC4F\\uDCD8-\\uDCFB]|\\uD803[\\uDCC0-\\uDCF2]|\\uD806[\\uDCC0-\\uDCDF]|\\uD835[\\uDC1A-\\uDC33\\uDC4E-\\uDC54\\uDC56-\\uDC67\\uDC82-\\uDC9B\\uDCB6-\\uDCB9\\uDCBB\\uDCBD-\\uDCC3\\uDCC5-\\uDCCF\\uDCEA-\\uDD03\\uDD1E-\\uDD37\\uDD52-\\uDD6B\\uDD86-\\uDD9F\\uDDBA-\\uDDD3\\uDDEE-\\uDE07\\uDE22-\\uDE3B\\uDE56-\\uDE6F\\uDE8A-\\uDEA5\\uDEC2-\\uDEDA\\uDEDC-\\uDEE1\\uDEFC-\\uDF14\\uDF16-\\uDF1B\\uDF36-\\uDF4E\\uDF50-\\uDF55\\uDF70-\\uDF88\\uDF8A-\\uDF8F\\uDFAA-\\uDFC2\\uDFC4-\\uDFC9\\uDFCB]|\\uD83A[\\uDD22-\\uDD43]/,\n Lt: /[\\u01C5\\u01C8\\u01CB\\u01F2\\u1F88-\\u1F8F\\u1F98-\\u1F9F\\u1FA8-\\u1FAF\\u1FBC\\u1FCC\\u1FFC]/,\n Lm: /[\\u02B0-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0374\\u037A\\u0559\\u0640\\u06E5\\u06E6\\u07F4\\u07F5\\u07FA\\u081A\\u0824\\u0828\\u0971\\u0E46\\u0EC6\\u10FC\\u17D7\\u1843\\u1AA7\\u1C78-\\u1C7D\\u1D2C-\\u1D6A\\u1D78\\u1D9B-\\u1DBF\\u2071\\u207F\\u2090-\\u209C\\u2C7C\\u2C7D\\u2D6F\\u2E2F\\u3005\\u3031-\\u3035\\u303B\\u309D\\u309E\\u30FC-\\u30FE\\uA015\\uA4F8-\\uA4FD\\uA60C\\uA67F\\uA69C\\uA69D\\uA717-\\uA71F\\uA770\\uA788\\uA7F8\\uA7F9\\uA9CF\\uA9E6\\uAA70\\uAADD\\uAAF3\\uAAF4\\uAB5C-\\uAB5F\\uFF70\\uFF9E\\uFF9F]|\\uD81A[\\uDF40-\\uDF43]|\\uD81B[\\uDF93-\\uDF9F\\uDFE0]/,\n Lo: /[\\xAA\\xBA\\u01BB\\u01C0-\\u01C3\\u0294\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u063F\\u0641-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u0800-\\u0815\\u0840-\\u0858\\u08A0-\\u08B4\\u08B6-\\u08BD\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0972-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0AF9\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58-\\u0C5A\\u0C60\\u0C61\\u0C80\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D54-\\u0D56\\u0D5F-\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E45\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10D0-\\u10FA\\u10FD-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16F1-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17DC\\u1820-\\u1842\\u1844-\\u1877\\u1880-\\u1884\\u1887-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C77\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u2135-\\u2138\\u2D30-\\u2D67\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u3006\\u303C\\u3041-\\u3096\\u309F\\u30A1-\\u30FA\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FD5\\uA000-\\uA014\\uA016-\\uA48C\\uA4D0-\\uA4F7\\uA500-\\uA60B\\uA610-\\uA61F\\uA62A\\uA62B\\uA66E\\uA6A0-\\uA6E5\\uA78F\\uA7F7\\uA7FB-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA8FD\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9E0-\\uA9E4\\uA9E7-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA6F\\uAA71-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB\\uAADC\\uAAE0-\\uAAEA\\uAAF2\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uABC0-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF66-\\uFF6F\\uFF71-\\uFF9D\\uFFA0-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]|\\uD800[\\uDC00-\\uDC0B\\uDC0D-\\uDC26\\uDC28-\\uDC3A\\uDC3C\\uDC3D\\uDC3F-\\uDC4D\\uDC50-\\uDC5D\\uDC80-\\uDCFA\\uDE80-\\uDE9C\\uDEA0-\\uDED0\\uDF00-\\uDF1F\\uDF30-\\uDF40\\uDF42-\\uDF49\\uDF50-\\uDF75\\uDF80-\\uDF9D\\uDFA0-\\uDFC3\\uDFC8-\\uDFCF]|\\uD801[\\uDC50-\\uDC9D\\uDD00-\\uDD27\\uDD30-\\uDD63\\uDE00-\\uDF36\\uDF40-\\uDF55\\uDF60-\\uDF67]|\\uD802[\\uDC00-\\uDC05\\uDC08\\uDC0A-\\uDC35\\uDC37\\uDC38\\uDC3C\\uDC3F-\\uDC55\\uDC60-\\uDC76\\uDC80-\\uDC9E\\uDCE0-\\uDCF2\\uDCF4\\uDCF5\\uDD00-\\uDD15\\uDD20-\\uDD39\\uDD80-\\uDDB7\\uDDBE\\uDDBF\\uDE00\\uDE10-\\uDE13\\uDE15-\\uDE17\\uDE19-\\uDE33\\uDE60-\\uDE7C\\uDE80-\\uDE9C\\uDEC0-\\uDEC7\\uDEC9-\\uDEE4\\uDF00-\\uDF35\\uDF40-\\uDF55\\uDF60-\\uDF72\\uDF80-\\uDF91]|\\uD803[\\uDC00-\\uDC48]|\\uD804[\\uDC03-\\uDC37\\uDC83-\\uDCAF\\uDCD0-\\uDCE8\\uDD03-\\uDD26\\uDD50-\\uDD72\\uDD76\\uDD83-\\uDDB2\\uDDC1-\\uDDC4\\uDDDA\\uDDDC\\uDE00-\\uDE11\\uDE13-\\uDE2B\\uDE80-\\uDE86\\uDE88\\uDE8A-\\uDE8D\\uDE8F-\\uDE9D\\uDE9F-\\uDEA8\\uDEB0-\\uDEDE\\uDF05-\\uDF0C\\uDF0F\\uDF10\\uDF13-\\uDF28\\uDF2A-\\uDF30\\uDF32\\uDF33\\uDF35-\\uDF39\\uDF3D\\uDF50\\uDF5D-\\uDF61]|\\uD805[\\uDC00-\\uDC34\\uDC47-\\uDC4A\\uDC80-\\uDCAF\\uDCC4\\uDCC5\\uDCC7\\uDD80-\\uDDAE\\uDDD8-\\uDDDB\\uDE00-\\uDE2F\\uDE44\\uDE80-\\uDEAA\\uDF00-\\uDF19]|\\uD806[\\uDCFF\\uDEC0-\\uDEF8]|\\uD807[\\uDC00-\\uDC08\\uDC0A-\\uDC2E\\uDC40\\uDC72-\\uDC8F]|\\uD808[\\uDC00-\\uDF99]|\\uD809[\\uDC80-\\uDD43]|[\\uD80C\\uD81C-\\uD820\\uD840-\\uD868\\uD86A-\\uD86C\\uD86F-\\uD872][\\uDC00-\\uDFFF]|\\uD80D[\\uDC00-\\uDC2E]|\\uD811[\\uDC00-\\uDE46]|\\uD81A[\\uDC00-\\uDE38\\uDE40-\\uDE5E\\uDED0-\\uDEED\\uDF00-\\uDF2F\\uDF63-\\uDF77\\uDF7D-\\uDF8F]|\\uD81B[\\uDF00-\\uDF44\\uDF50]|\\uD821[\\uDC00-\\uDFEC]|\\uD822[\\uDC00-\\uDEF2]|\\uD82C[\\uDC00\\uDC01]|\\uD82F[\\uDC00-\\uDC6A\\uDC70-\\uDC7C\\uDC80-\\uDC88\\uDC90-\\uDC99]|\\uD83A[\\uDC00-\\uDCC4]|\\uD83B[\\uDE00-\\uDE03\\uDE05-\\uDE1F\\uDE21\\uDE22\\uDE24\\uDE27\\uDE29-\\uDE32\\uDE34-\\uDE37\\uDE39\\uDE3B\\uDE42\\uDE47\\uDE49\\uDE4B\\uDE4D-\\uDE4F\\uDE51\\uDE52\\uDE54\\uDE57\\uDE59\\uDE5B\\uDE5D\\uDE5F\\uDE61\\uDE62\\uDE64\\uDE67-\\uDE6A\\uDE6C-\\uDE72\\uDE74-\\uDE77\\uDE79-\\uDE7C\\uDE7E\\uDE80-\\uDE89\\uDE8B-\\uDE9B\\uDEA1-\\uDEA3\\uDEA5-\\uDEA9\\uDEAB-\\uDEBB]|\\uD869[\\uDC00-\\uDED6\\uDF00-\\uDFFF]|\\uD86D[\\uDC00-\\uDF34\\uDF40-\\uDFFF]|\\uD86E[\\uDC00-\\uDC1D\\uDC20-\\uDFFF]|\\uD873[\\uDC00-\\uDEA1]|\\uD87E[\\uDC00-\\uDE1D]/,\n\n // Numbers\n Nl: /[\\u16EE-\\u16F0\\u2160-\\u2182\\u2185-\\u2188\\u3007\\u3021-\\u3029\\u3038-\\u303A\\uA6E6-\\uA6EF]|\\uD800[\\uDD40-\\uDD74\\uDF41\\uDF4A\\uDFD1-\\uDFD5]|\\uD809[\\uDC00-\\uDC6E]/,\n Nd: /[0-9\\u0660-\\u0669\\u06F0-\\u06F9\\u07C0-\\u07C9\\u0966-\\u096F\\u09E6-\\u09EF\\u0A66-\\u0A6F\\u0AE6-\\u0AEF\\u0B66-\\u0B6F\\u0BE6-\\u0BEF\\u0C66-\\u0C6F\\u0CE6-\\u0CEF\\u0D66-\\u0D6F\\u0DE6-\\u0DEF\\u0E50-\\u0E59\\u0ED0-\\u0ED9\\u0F20-\\u0F29\\u1040-\\u1049\\u1090-\\u1099\\u17E0-\\u17E9\\u1810-\\u1819\\u1946-\\u194F\\u19D0-\\u19D9\\u1A80-\\u1A89\\u1A90-\\u1A99\\u1B50-\\u1B59\\u1BB0-\\u1BB9\\u1C40-\\u1C49\\u1C50-\\u1C59\\uA620-\\uA629\\uA8D0-\\uA8D9\\uA900-\\uA909\\uA9D0-\\uA9D9\\uA9F0-\\uA9F9\\uAA50-\\uAA59\\uABF0-\\uABF9\\uFF10-\\uFF19]|\\uD801[\\uDCA0-\\uDCA9]|\\uD804[\\uDC66-\\uDC6F\\uDCF0-\\uDCF9\\uDD36-\\uDD3F\\uDDD0-\\uDDD9\\uDEF0-\\uDEF9]|[\\uD805\\uD807][\\uDC50-\\uDC59\\uDCD0-\\uDCD9\\uDE50-\\uDE59\\uDEC0-\\uDEC9\\uDF30-\\uDF39]|\\uD806[\\uDCE0-\\uDCE9]|\\uD81A[\\uDE60-\\uDE69\\uDF50-\\uDF59]|\\uD835[\\uDFCE-\\uDFFF]|\\uD83A[\\uDD50-\\uDD59]/,\n\n // Marks\n Mn: /[\\u0300-\\u036F\\u0483-\\u0487\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u065F\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07EB-\\u07F3\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0859-\\u085B\\u08D4-\\u08E1\\u08E3-\\u0902\\u093A\\u093C\\u0941-\\u0948\\u094D\\u0951-\\u0957\\u0962\\u0963\\u0981\\u09BC\\u09C1-\\u09C4\\u09CD\\u09E2\\u09E3\\u0A01\\u0A02\\u0A3C\\u0A41\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A70\\u0A71\\u0A75\\u0A81\\u0A82\\u0ABC\\u0AC1-\\u0AC5\\u0AC7\\u0AC8\\u0ACD\\u0AE2\\u0AE3\\u0B01\\u0B3C\\u0B3F\\u0B41-\\u0B44\\u0B4D\\u0B56\\u0B62\\u0B63\\u0B82\\u0BC0\\u0BCD\\u0C00\\u0C3E-\\u0C40\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0C81\\u0CBC\\u0CBF\\u0CC6\\u0CCC\\u0CCD\\u0CE2\\u0CE3\\u0D01\\u0D41-\\u0D44\\u0D4D\\u0D62\\u0D63\\u0DCA\\u0DD2-\\u0DD4\\u0DD6\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F71-\\u0F7E\\u0F80-\\u0F84\\u0F86\\u0F87\\u0F8D-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102D-\\u1030\\u1032-\\u1037\\u1039\\u103A\\u103D\\u103E\\u1058\\u1059\\u105E-\\u1060\\u1071-\\u1074\\u1082\\u1085\\u1086\\u108D\\u109D\\u135D-\\u135F\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B4\\u17B5\\u17B7-\\u17BD\\u17C6\\u17C9-\\u17D3\\u17DD\\u180B-\\u180D\\u1885\\u1886\\u18A9\\u1920-\\u1922\\u1927\\u1928\\u1932\\u1939-\\u193B\\u1A17\\u1A18\\u1A1B\\u1A56\\u1A58-\\u1A5E\\u1A60\\u1A62\\u1A65-\\u1A6C\\u1A73-\\u1A7C\\u1A7F\\u1AB0-\\u1ABD\\u1B00-\\u1B03\\u1B34\\u1B36-\\u1B3A\\u1B3C\\u1B42\\u1B6B-\\u1B73\\u1B80\\u1B81\\u1BA2-\\u1BA5\\u1BA8\\u1BA9\\u1BAB-\\u1BAD\\u1BE6\\u1BE8\\u1BE9\\u1BED\\u1BEF-\\u1BF1\\u1C2C-\\u1C33\\u1C36\\u1C37\\u1CD0-\\u1CD2\\u1CD4-\\u1CE0\\u1CE2-\\u1CE8\\u1CED\\u1CF4\\u1CF8\\u1CF9\\u1DC0-\\u1DF5\\u1DFB-\\u1DFF\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2CEF-\\u2CF1\\u2D7F\\u2DE0-\\u2DFF\\u302A-\\u302D\\u3099\\u309A\\uA66F\\uA674-\\uA67D\\uA69E\\uA69F\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA825\\uA826\\uA8C4\\uA8C5\\uA8E0-\\uA8F1\\uA926-\\uA92D\\uA947-\\uA951\\uA980-\\uA982\\uA9B3\\uA9B6-\\uA9B9\\uA9BC\\uA9E5\\uAA29-\\uAA2E\\uAA31\\uAA32\\uAA35\\uAA36\\uAA43\\uAA4C\\uAA7C\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uAAEC\\uAAED\\uAAF6\\uABE5\\uABE8\\uABED\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE2F]|\\uD800[\\uDDFD\\uDEE0\\uDF76-\\uDF7A]|\\uD802[\\uDE01-\\uDE03\\uDE05\\uDE06\\uDE0C-\\uDE0F\\uDE38-\\uDE3A\\uDE3F\\uDEE5\\uDEE6]|\\uD804[\\uDC01\\uDC38-\\uDC46\\uDC7F-\\uDC81\\uDCB3-\\uDCB6\\uDCB9\\uDCBA\\uDD00-\\uDD02\\uDD27-\\uDD2B\\uDD2D-\\uDD34\\uDD73\\uDD80\\uDD81\\uDDB6-\\uDDBE\\uDDCA-\\uDDCC\\uDE2F-\\uDE31\\uDE34\\uDE36\\uDE37\\uDE3E\\uDEDF\\uDEE3-\\uDEEA\\uDF00\\uDF01\\uDF3C\\uDF40\\uDF66-\\uDF6C\\uDF70-\\uDF74]|\\uD805[\\uDC38-\\uDC3F\\uDC42-\\uDC44\\uDC46\\uDCB3-\\uDCB8\\uDCBA\\uDCBF\\uDCC0\\uDCC2\\uDCC3\\uDDB2-\\uDDB5\\uDDBC\\uDDBD\\uDDBF\\uDDC0\\uDDDC\\uDDDD\\uDE33-\\uDE3A\\uDE3D\\uDE3F\\uDE40\\uDEAB\\uDEAD\\uDEB0-\\uDEB5\\uDEB7\\uDF1D-\\uDF1F\\uDF22-\\uDF25\\uDF27-\\uDF2B]|\\uD807[\\uDC30-\\uDC36\\uDC38-\\uDC3D\\uDC3F\\uDC92-\\uDCA7\\uDCAA-\\uDCB0\\uDCB2\\uDCB3\\uDCB5\\uDCB6]|\\uD81A[\\uDEF0-\\uDEF4\\uDF30-\\uDF36]|\\uD81B[\\uDF8F-\\uDF92]|\\uD82F[\\uDC9D\\uDC9E]|\\uD834[\\uDD67-\\uDD69\\uDD7B-\\uDD82\\uDD85-\\uDD8B\\uDDAA-\\uDDAD\\uDE42-\\uDE44]|\\uD836[\\uDE00-\\uDE36\\uDE3B-\\uDE6C\\uDE75\\uDE84\\uDE9B-\\uDE9F\\uDEA1-\\uDEAF]|\\uD838[\\uDC00-\\uDC06\\uDC08-\\uDC18\\uDC1B-\\uDC21\\uDC23\\uDC24\\uDC26-\\uDC2A]|\\uD83A[\\uDCD0-\\uDCD6\\uDD44-\\uDD4A]|\\uDB40[\\uDD00-\\uDDEF]/,\n Mc: /[\\u0903-\\u0903]|[\\u093E-\\u0940]|[\\u0949-\\u094C]|[\\u0982-\\u0983]|[\\u09BE-\\u09C0]|[\\u09C7-\\u09C8]|[\\u09CB-\\u09CC]|[\\u09D7-\\u09D7]|[\\u0A3E-\\u0A40]|[\\u0A83-\\u0A83]|[\\u0ABE-\\u0AC0]|[\\u0AC9-\\u0AC9]|[\\u0ACB-\\u0ACC]|[\\u0B02-\\u0B03]|[\\u0B3E-\\u0B3E]|[\\u0B40-\\u0B40]|[\\u0B47-\\u0B48]|[\\u0B4B-\\u0B4C]|[\\u0B57-\\u0B57]|[\\u0B83-\\u0B83]|[\\u0BBE-\\u0BBF]|[\\u0BC1-\\u0BC2]|[\\u0BC6-\\u0BC8]|[\\u0BCA-\\u0BCC]|[\\u0BD7-\\u0BD7]|[\\u0C01-\\u0C03]|[\\u0C41-\\u0C44]|[\\u0C82-\\u0C83]|[\\u0CBE-\\u0CBE]|[\\u0CC0-\\u0CC4]|[\\u0CC7-\\u0CC8]|[\\u0CCA-\\u0CCB]|[\\u0CD5-\\u0CD6]|[\\u0D02-\\u0D03]|[\\u0D3E-\\u0D40]|[\\u0D46-\\u0D48]|[\\u0D4A-\\u0D4C]|[\\u0D57-\\u0D57]|[\\u0F3E-\\u0F3F]|[\\u0F7F-\\u0F7F]/,\n\n // Punctuation, Connector\n Pc: /[_\\u203F\\u2040\\u2054\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFF3F]/,\n\n // Separator, Space\n Zs: /[ \\xA0\\u1680\\u2000-\\u200A\\u202F\\u205F\\u3000]/,\n\n // These two are not real Unicode categories, but our useful for Ohm.\n // L is a combination of all the letter categories.\n // Ltmo is a combination of Lt, Lm, and Lo.\n L: /[A-Za-z\\xAA\\xB5\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u08A0-\\u08B4\\u08B6-\\u08BD\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0AF9\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58-\\u0C5A\\u0C60\\u0C61\\u0C80\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D54-\\u0D56\\u0D5F-\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16F1-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u1884\\u1887-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1C80-\\u1C88\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2183\\u2184\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005\\u3006\\u3031-\\u3035\\u303B\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FD5\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA69D\\uA6A0-\\uA6E5\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7AE\\uA7B0-\\uA7B7\\uA7F7-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA8FD\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uA9E0-\\uA9E4\\uA9E6-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB65\\uAB70-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]|\\uD800[\\uDC00-\\uDC0B\\uDC0D-\\uDC26\\uDC28-\\uDC3A\\uDC3C\\uDC3D\\uDC3F-\\uDC4D\\uDC50-\\uDC5D\\uDC80-\\uDCFA\\uDE80-\\uDE9C\\uDEA0-\\uDED0\\uDF00-\\uDF1F\\uDF30-\\uDF40\\uDF42-\\uDF49\\uDF50-\\uDF75\\uDF80-\\uDF9D\\uDFA0-\\uDFC3\\uDFC8-\\uDFCF]|\\uD801[\\uDC00-\\uDC9D\\uDCB0-\\uDCD3\\uDCD8-\\uDCFB\\uDD00-\\uDD27\\uDD30-\\uDD63\\uDE00-\\uDF36\\uDF40-\\uDF55\\uDF60-\\uDF67]|\\uD802[\\uDC00-\\uDC05\\uDC08\\uDC0A-\\uDC35\\uDC37\\uDC38\\uDC3C\\uDC3F-\\uDC55\\uDC60-\\uDC76\\uDC80-\\uDC9E\\uDCE0-\\uDCF2\\uDCF4\\uDCF5\\uDD00-\\uDD15\\uDD20-\\uDD39\\uDD80-\\uDDB7\\uDDBE\\uDDBF\\uDE00\\uDE10-\\uDE13\\uDE15-\\uDE17\\uDE19-\\uDE33\\uDE60-\\uDE7C\\uDE80-\\uDE9C\\uDEC0-\\uDEC7\\uDEC9-\\uDEE4\\uDF00-\\uDF35\\uDF40-\\uDF55\\uDF60-\\uDF72\\uDF80-\\uDF91]|\\uD803[\\uDC00-\\uDC48\\uDC80-\\uDCB2\\uDCC0-\\uDCF2]|\\uD804[\\uDC03-\\uDC37\\uDC83-\\uDCAF\\uDCD0-\\uDCE8\\uDD03-\\uDD26\\uDD50-\\uDD72\\uDD76\\uDD83-\\uDDB2\\uDDC1-\\uDDC4\\uDDDA\\uDDDC\\uDE00-\\uDE11\\uDE13-\\uDE2B\\uDE80-\\uDE86\\uDE88\\uDE8A-\\uDE8D\\uDE8F-\\uDE9D\\uDE9F-\\uDEA8\\uDEB0-\\uDEDE\\uDF05-\\uDF0C\\uDF0F\\uDF10\\uDF13-\\uDF28\\uDF2A-\\uDF30\\uDF32\\uDF33\\uDF35-\\uDF39\\uDF3D\\uDF50\\uDF5D-\\uDF61]|\\uD805[\\uDC00-\\uDC34\\uDC47-\\uDC4A\\uDC80-\\uDCAF\\uDCC4\\uDCC5\\uDCC7\\uDD80-\\uDDAE\\uDDD8-\\uDDDB\\uDE00-\\uDE2F\\uDE44\\uDE80-\\uDEAA\\uDF00-\\uDF19]|\\uD806[\\uDCA0-\\uDCDF\\uDCFF\\uDEC0-\\uDEF8]|\\uD807[\\uDC00-\\uDC08\\uDC0A-\\uDC2E\\uDC40\\uDC72-\\uDC8F]|\\uD808[\\uDC00-\\uDF99]|\\uD809[\\uDC80-\\uDD43]|[\\uD80C\\uD81C-\\uD820\\uD840-\\uD868\\uD86A-\\uD86C\\uD86F-\\uD872][\\uDC00-\\uDFFF]|\\uD80D[\\uDC00-\\uDC2E]|\\uD811[\\uDC00-\\uDE46]|\\uD81A[\\uDC00-\\uDE38\\uDE40-\\uDE5E\\uDED0-\\uDEED\\uDF00-\\uDF2F\\uDF40-\\uDF43\\uDF63-\\uDF77\\uDF7D-\\uDF8F]|\\uD81B[\\uDF00-\\uDF44\\uDF50\\uDF93-\\uDF9F\\uDFE0]|\\uD821[\\uDC00-\\uDFEC]|\\uD822[\\uDC00-\\uDEF2]|\\uD82C[\\uDC00\\uDC01]|\\uD82F[\\uDC00-\\uDC6A\\uDC70-\\uDC7C\\uDC80-\\uDC88\\uDC90-\\uDC99]|\\uD835[\\uDC00-\\uDC54\\uDC56-\\uDC9C\\uDC9E\\uDC9F\\uDCA2\\uDCA5\\uDCA6\\uDCA9-\\uDCAC\\uDCAE-\\uDCB9\\uDCBB\\uDCBD-\\uDCC3\\uDCC5-\\uDD05\\uDD07-\\uDD0A\\uDD0D-\\uDD14\\uDD16-\\uDD1C\\uDD1E-\\uDD39\\uDD3B-\\uDD3E\\uDD40-\\uDD44\\uDD46\\uDD4A-\\uDD50\\uDD52-\\uDEA5\\uDEA8-\\uDEC0\\uDEC2-\\uDEDA\\uDEDC-\\uDEFA\\uDEFC-\\uDF14\\uDF16-\\uDF34\\uDF36-\\uDF4E\\uDF50-\\uDF6E\\uDF70-\\uDF88\\uDF8A-\\uDFA8\\uDFAA-\\uDFC2\\uDFC4-\\uDFCB]|\\uD83A[\\uDC00-\\uDCC4\\uDD00-\\uDD43]|\\uD83B[\\uDE00-\\uDE03\\uDE05-\\uDE1F\\uDE21\\uDE22\\uDE24\\uDE27\\uDE29-\\uDE32\\uDE34-\\uDE37\\uDE39\\uDE3B\\uDE42\\uDE47\\uDE49\\uDE4B\\uDE4D-\\uDE4F\\uDE51\\uDE52\\uDE54\\uDE57\\uDE59\\uDE5B\\uDE5D\\uDE5F\\uDE61\\uDE62\\uDE64\\uDE67-\\uDE6A\\uDE6C-\\uDE72\\uDE74-\\uDE77\\uDE79-\\uDE7C\\uDE7E\\uDE80-\\uDE89\\uDE8B-\\uDE9B\\uDEA1-\\uDEA3\\uDEA5-\\uDEA9\\uDEAB-\\uDEBB]|\\uD869[\\uDC00-\\uDED6\\uDF00-\\uDFFF]|\\uD86D[\\uDC00-\\uDF34\\uDF40-\\uDFFF]|\\uD86E[\\uDC00-\\uDC1D\\uDC20-\\uDFFF]|\\uD873[\\uDC00-\\uDEA1]|\\uD87E[\\uDC00-\\uDE1D]/,\n Ltmo: /[\\u01C5\\u01C8\\u01CB\\u01F2\\u1F88-\\u1F8F\\u1F98-\\u1F9F\\u1FA8-\\u1FAF\\u1FBC\\u1FCC\\u1FFC]|[\\u02B0-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0374\\u037A\\u0559\\u0640\\u06E5\\u06E6\\u07F4\\u07F5\\u07FA\\u081A\\u0824\\u0828\\u0971\\u0E46\\u0EC6\\u10FC\\u17D7\\u1843\\u1AA7\\u1C78-\\u1C7D\\u1D2C-\\u1D6A\\u1D78\\u1D9B-\\u1DBF\\u2071\\u207F\\u2090-\\u209C\\u2C7C\\u2C7D\\u2D6F\\u2E2F\\u3005\\u3031-\\u3035\\u303B\\u309D\\u309E\\u30FC-\\u30FE\\uA015\\uA4F8-\\uA4FD\\uA60C\\uA67F\\uA69C\\uA69D\\uA717-\\uA71F\\uA770\\uA788\\uA7F8\\uA7F9\\uA9CF\\uA9E6\\uAA70\\uAADD\\uAAF3\\uAAF4\\uAB5C-\\uAB5F\\uFF70\\uFF9E\\uFF9F]|\\uD81A[\\uDF40-\\uDF43]|\\uD81B[\\uDF93-\\uDF9F\\uDFE0]|[\\xAA\\xBA\\u01BB\\u01C0-\\u01C3\\u0294\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u063F\\u0641-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u0800-\\u0815\\u0840-\\u0858\\u08A0-\\u08B4\\u08B6-\\u08BD\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0972-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0AF9\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58-\\u0C5A\\u0C60\\u0C61\\u0C80\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D54-\\u0D56\\u0D5F-\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E45\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10D0-\\u10FA\\u10FD-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16F1-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17DC\\u1820-\\u1842\\u1844-\\u1877\\u1880-\\u1884\\u1887-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C77\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u2135-\\u2138\\u2D30-\\u2D67\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u3006\\u303C\\u3041-\\u3096\\u309F\\u30A1-\\u30FA\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FD5\\uA000-\\uA014\\uA016-\\uA48C\\uA4D0-\\uA4F7\\uA500-\\uA60B\\uA610-\\uA61F\\uA62A\\uA62B\\uA66E\\uA6A0-\\uA6E5\\uA78F\\uA7F7\\uA7FB-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA8FD\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9E0-\\uA9E4\\uA9E7-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA6F\\uAA71-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB\\uAADC\\uAAE0-\\uAAEA\\uAAF2\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uABC0-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF66-\\uFF6F\\uFF71-\\uFF9D\\uFFA0-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]|\\uD800[\\uDC00-\\uDC0B\\uDC0D-\\uDC26\\uDC28-\\uDC3A\\uDC3C\\uDC3D\\uDC3F-\\uDC4D\\uDC50-\\uDC5D\\uDC80-\\uDCFA\\uDE80-\\uDE9C\\uDEA0-\\uDED0\\uDF00-\\uDF1F\\uDF30-\\uDF40\\uDF42-\\uDF49\\uDF50-\\uDF75\\uDF80-\\uDF9D\\uDFA0-\\uDFC3\\uDFC8-\\uDFCF]|\\uD801[\\uDC50-\\uDC9D\\uDD00-\\uDD27\\uDD30-\\uDD63\\uDE00-\\uDF36\\uDF40-\\uDF55\\uDF60-\\uDF67]|\\uD802[\\uDC00-\\uDC05\\uDC08\\uDC0A-\\uDC35\\uDC37\\uDC38\\uDC3C\\uDC3F-\\uDC55\\uDC60-\\uDC76\\uDC80-\\uDC9E\\uDCE0-\\uDCF2\\uDCF4\\uDCF5\\uDD00-\\uDD15\\uDD20-\\uDD39\\uDD80-\\uDDB7\\uDDBE\\uDDBF\\uDE00\\uDE10-\\uDE13\\uDE15-\\uDE17\\uDE19-\\uDE33\\uDE60-\\uDE7C\\uDE80-\\uDE9C\\uDEC0-\\uDEC7\\uDEC9-\\uDEE4\\uDF00-\\uDF35\\uDF40-\\uDF55\\uDF60-\\uDF72\\uDF80-\\uDF91]|\\uD803[\\uDC00-\\uDC48]|\\uD804[\\uDC03-\\uDC37\\uDC83-\\uDCAF\\uDCD0-\\uDCE8\\uDD03-\\uDD26\\uDD50-\\uDD72\\uDD76\\uDD83-\\uDDB2\\uDDC1-\\uDDC4\\uDDDA\\uDDDC\\uDE00-\\uDE11\\uDE13-\\uDE2B\\uDE80-\\uDE86\\uDE88\\uDE8A-\\uDE8D\\uDE8F-\\uDE9D\\uDE9F-\\uDEA8\\uDEB0-\\uDEDE\\uDF05-\\uDF0C\\uDF0F\\uDF10\\uDF13-\\uDF28\\uDF2A-\\uDF30\\uDF32\\uDF33\\uDF35-\\uDF39\\uDF3D\\uDF50\\uDF5D-\\uDF61]|\\uD805[\\uDC00-\\uDC34\\uDC47-\\uDC4A\\uDC80-\\uDCAF\\uDCC4\\uDCC5\\uDCC7\\uDD80-\\uDDAE\\uDDD8-\\uDDDB\\uDE00-\\uDE2F\\uDE44\\uDE80-\\uDEAA\\uDF00-\\uDF19]|\\uD806[\\uDCFF\\uDEC0-\\uDEF8]|\\uD807[\\uDC00-\\uDC08\\uDC0A-\\uDC2E\\uDC40\\uDC72-\\uDC8F]|\\uD808[\\uDC00-\\uDF99]|\\uD809[\\uDC80-\\uDD43]|[\\uD80C\\uD81C-\\uD820\\uD840-\\uD868\\uD86A-\\uD86C\\uD86F-\\uD872][\\uDC00-\\uDFFF]|\\uD80D[\\uDC00-\\uDC2E]|\\uD811[\\uDC00-\\uDE46]|\\uD81A[\\uDC00-\\uDE38\\uDE40-\\uDE5E\\uDED0-\\uDEED\\uDF00-\\uDF2F\\uDF63-\\uDF77\\uDF7D-\\uDF8F]|\\uD81B[\\uDF00-\\uDF44\\uDF50]|\\uD821[\\uDC00-\\uDFEC]|\\uD822[\\uDC00-\\uDEF2]|\\uD82C[\\uDC00\\uDC01]|\\uD82F[\\uDC00-\\uDC6A\\uDC70-\\uDC7C\\uDC80-\\uDC88\\uDC90-\\uDC99]|\\uD83A[\\uDC00-\\uDCC4]|\\uD83B[\\uDE00-\\uDE03\\uDE05-\\uDE1F\\uDE21\\uDE22\\uDE24\\uDE27\\uDE29-\\uDE32\\uDE34-\\uDE37\\uDE39\\uDE3B\\uDE42\\uDE47\\uDE49\\uDE4B\\uDE4D-\\uDE4F\\uDE51\\uDE52\\uDE54\\uDE57\\uDE59\\uDE5B\\uDE5D\\uDE5F\\uDE61\\uDE62\\uDE64\\uDE67-\\uDE6A\\uDE6C-\\uDE72\\uDE74-\\uDE77\\uDE79-\\uDE7C\\uDE7E\\uDE80-\\uDE89\\uDE8B-\\uDE9B\\uDEA1-\\uDEA3\\uDEA5-\\uDEA9\\uDEAB-\\uDEBB]|\\uD869[\\uDC00-\\uDED6\\uDF00-\\uDFFF]|\\uD86D[\\uDC00-\\uDF34\\uDF40-\\uDFFF]|\\uD86E[\\uDC00-\\uDC1D\\uDC20-\\uDFFF]|\\uD873[\\uDC00-\\uDEA1]|\\uD87E[\\uDC00-\\uDE1D]/\n};\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst common = require('./common');\nconst pexprs = require('./pexprs');\n\n// --------------------------------------------------------------------\n// Operations\n// --------------------------------------------------------------------\n\n/*\n Return true if we should skip spaces preceding this expression in a syntactic context.\n*/\npexprs.PExpr.prototype.allowsSkippingPrecedingSpace = common.abstract(\n 'allowsSkippingPrecedingSpace'\n);\n\n/*\n Generally, these are all first-order expressions and (with the exception of Apply)\n directly read from the input stream.\n*/\npexprs.any.allowsSkippingPrecedingSpace =\n pexprs.end.allowsSkippingPrecedingSpace =\n pexprs.Apply.prototype.allowsSkippingPrecedingSpace =\n pexprs.Terminal.prototype.allowsSkippingPrecedingSpace =\n pexprs.Range.prototype.allowsSkippingPrecedingSpace =\n pexprs.UnicodeChar.prototype.allowsSkippingPrecedingSpace =\n function() {\n return true;\n };\n\n/*\n Higher-order expressions that don't directly consume input.\n*/\npexprs.Alt.prototype.allowsSkippingPrecedingSpace =\n pexprs.Iter.prototype.allowsSkippingPrecedingSpace =\n pexprs.Lex.prototype.allowsSkippingPrecedingSpace =\n pexprs.Lookahead.prototype.allowsSkippingPrecedingSpace =\n pexprs.Not.prototype.allowsSkippingPrecedingSpace =\n pexprs.Param.prototype.allowsSkippingPrecedingSpace =\n pexprs.Seq.prototype.allowsSkippingPrecedingSpace =\n function() {\n return false;\n };\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst {abstract, isSyntactic} = require('./common');\nconst errors = require('./errors');\nconst pexprs = require('./pexprs');\nconst util = require('./util');\n\nlet BuiltInRules;\n\nutil.awaitBuiltInRules(g => {\n BuiltInRules = g;\n});\n\n// --------------------------------------------------------------------\n// Operations\n// --------------------------------------------------------------------\n\nlet lexifyCount;\n\npexprs.PExpr.prototype.assertAllApplicationsAreValid = function(ruleName, grammar) {\n lexifyCount = 0;\n this._assertAllApplicationsAreValid(ruleName, grammar);\n};\n\npexprs.PExpr.prototype._assertAllApplicationsAreValid = abstract(\n '_assertAllApplicationsAreValid'\n);\n\npexprs.any._assertAllApplicationsAreValid =\n pexprs.end._assertAllApplicationsAreValid =\n pexprs.Terminal.prototype._assertAllApplicationsAreValid =\n pexprs.Range.prototype._assertAllApplicationsAreValid =\n pexprs.Param.prototype._assertAllApplicationsAreValid =\n pexprs.UnicodeChar.prototype._assertAllApplicationsAreValid =\n function(ruleName, grammar) {\n // no-op\n };\n\npexprs.Lex.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) {\n lexifyCount++;\n this.expr._assertAllApplicationsAreValid(ruleName, grammar);\n lexifyCount--;\n};\n\npexprs.Alt.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) {\n for (let idx = 0; idx < this.terms.length; idx++) {\n this.terms[idx]._assertAllApplicationsAreValid(ruleName, grammar);\n }\n};\n\npexprs.Seq.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) {\n for (let idx = 0; idx < this.factors.length; idx++) {\n this.factors[idx]._assertAllApplicationsAreValid(ruleName, grammar);\n }\n};\n\npexprs.Iter.prototype._assertAllApplicationsAreValid =\n pexprs.Not.prototype._assertAllApplicationsAreValid =\n pexprs.Lookahead.prototype._assertAllApplicationsAreValid =\n function(ruleName, grammar) {\n this.expr._assertAllApplicationsAreValid(ruleName, grammar);\n };\n\npexprs.Apply.prototype._assertAllApplicationsAreValid = function(\n ruleName,\n grammar,\n skipSyntacticCheck = false\n) {\n const ruleInfo = grammar.rules[this.ruleName];\n\n // Make sure that the rule exists...\n if (!ruleInfo) {\n throw errors.undeclaredRule(this.ruleName, grammar.name, this.source);\n }\n\n // ...and that this application is allowed\n if (\n !skipSyntacticCheck &&\n isSyntactic(this.ruleName) &&\n (!isSyntactic(ruleName) || lexifyCount > 0)\n ) {\n throw errors.applicationOfSyntacticRuleFromLexicalContext(this.ruleName, this);\n }\n\n // ...and that this application has the correct number of arguments\n const actual = this.args.length;\n const expected = ruleInfo.formals.length;\n if (actual !== expected) {\n throw errors.wrongNumberOfArguments(this.ruleName, expected, actual, this.source);\n }\n\n const isBuiltInApplySyntactic =\n BuiltInRules && ruleInfo === BuiltInRules.rules.experimentalApplySyntactic;\n const isBuiltInCaseInsensitive =\n BuiltInRules && ruleInfo === BuiltInRules.rules.caseInsensitive;\n\n // ...and that all of the argument expressions only have valid applications and have arity 1.\n // If `this` is an application of the built-in experimentalApplySyntactic rule, then its arg is\n // allowed (and expected) to be a syntactic rule, even if we're in a lexical context.\n this.args.forEach(arg => {\n arg._assertAllApplicationsAreValid(ruleName, grammar, isBuiltInApplySyntactic);\n if (arg.getArity() !== 1) {\n throw errors.invalidParameter(this.ruleName, arg);\n }\n });\n\n // Extra checks for \"special\" applications\n\n // If it's an application of 'caseInsensitive', ensure that the argument is a Terminal.\n if (isBuiltInCaseInsensitive) {\n if (!(this.args[0] instanceof pexprs.Terminal)) {\n throw errors.incorrectArgumentType('a Terminal (e.g. \"abc\")', this.args[0]);\n }\n }\n\n if (isBuiltInApplySyntactic) {\n const arg = this.args[0];\n if (!(arg instanceof pexprs.Apply)) {\n throw errors.incorrectArgumentType('a syntactic rule application', arg);\n }\n if (!isSyntactic(arg.ruleName)) {\n throw errors.experimentalApplySyntacticWithLexicalRuleApplication(arg);\n }\n }\n};\n","'use strict';\n\n// --------------------------------------------------------------------\n// Private stuff\n// --------------------------------------------------------------------\n\nfunction Namespace() {}\nNamespace.prototype = Object.create(null);\n\nNamespace.asNamespace = function(objOrNamespace) {\n if (objOrNamespace instanceof Namespace) {\n return objOrNamespace;\n }\n return Namespace.createNamespace(objOrNamespace);\n};\n\n// Create a new namespace. If `optProps` is specified, all of its properties\n// will be copied to the new namespace.\nNamespace.createNamespace = function(optProps) {\n return Namespace.extend(Namespace.prototype, optProps);\n};\n\n// Create a new namespace which extends another namespace. If `optProps` is\n// specified, all of its properties will be copied to the new namespace.\nNamespace.extend = function(namespace, optProps) {\n if (namespace !== Namespace.prototype && !(namespace instanceof Namespace)) {\n throw new TypeError('not a Namespace object: ' + namespace);\n }\n const ns = Object.create(namespace, {\n constructor: {\n value: Namespace,\n enumerable: false,\n writable: true,\n configurable: true,\n },\n });\n return Object.assign(ns, optProps);\n};\n\n// TODO: Should this be a regular method?\nNamespace.toString = function(ns) {\n return Object.prototype.toString.call(ns);\n};\n\n// --------------------------------------------------------------------\n// Exports\n// --------------------------------------------------------------------\n\nmodule.exports = Namespace;\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst pexprs = require('./pexprs');\n\nconst Namespace = require('./Namespace');\n\n// --------------------------------------------------------------------\n// Private stuff\n// --------------------------------------------------------------------\n\nfunction createError(message, optInterval) {\n let e;\n if (optInterval) {\n e = new Error(optInterval.getLineAndColumnMessage() + message);\n e.shortMessage = message;\n e.interval = optInterval;\n } else {\n e = new Error(message);\n }\n return e;\n}\n\n// ----------------- errors about intervals -----------------\n\nfunction intervalSourcesDontMatch() {\n return createError(\"Interval sources don't match\");\n}\n\n// ----------------- errors about grammars -----------------\n\n// Grammar syntax error\n\nfunction grammarSyntaxError(matchFailure) {\n const e = new Error();\n Object.defineProperty(e, 'message', {\n enumerable: true,\n get() {\n return matchFailure.message;\n },\n });\n Object.defineProperty(e, 'shortMessage', {\n enumerable: true,\n get() {\n return 'Expected ' + matchFailure.getExpectedText();\n },\n });\n e.interval = matchFailure.getInterval();\n return e;\n}\n\n// Undeclared grammar\n\nfunction undeclaredGrammar(grammarName, namespace, interval) {\n const message = namespace ?\n 'Grammar ' +\n grammarName +\n ' is not declared in namespace ' +\n Namespace.toString(namespace) :\n 'Undeclared grammar ' + grammarName;\n return createError(message, interval);\n}\n\n// Duplicate grammar declaration\n\nfunction duplicateGrammarDeclaration(grammar, namespace) {\n return createError('Grammar ' + grammar.name + ' is already declared in this namespace');\n}\n\n// ----------------- rules -----------------\n\n// Undeclared rule\n\nfunction undeclaredRule(ruleName, grammarName, optInterval) {\n return createError(\n 'Rule ' + ruleName + ' is not declared in grammar ' + grammarName,\n optInterval\n );\n}\n\n// Cannot override undeclared rule\n\nfunction cannotOverrideUndeclaredRule(ruleName, grammarName, optSource) {\n return createError(\n 'Cannot override rule ' + ruleName + ' because it is not declared in ' + grammarName,\n optSource\n );\n}\n\n// Cannot extend undeclared rule\n\nfunction cannotExtendUndeclaredRule(ruleName, grammarName, optSource) {\n return createError(\n 'Cannot extend rule ' + ruleName + ' because it is not declared in ' + grammarName,\n optSource\n );\n}\n\n// Duplicate rule declaration\n\nfunction duplicateRuleDeclaration(ruleName, grammarName, declGrammarName, optSource) {\n let message =\n \"Duplicate declaration for rule '\" + ruleName + \"' in grammar '\" + grammarName + \"'\";\n if (grammarName !== declGrammarName) {\n message += \" (originally declared in '\" + declGrammarName + \"')\";\n }\n return createError(message, optSource);\n}\n\n// Wrong number of parameters\n\nfunction wrongNumberOfParameters(ruleName, expected, actual, source) {\n return createError(\n 'Wrong number of parameters for rule ' +\n ruleName +\n ' (expected ' +\n expected +\n ', got ' +\n actual +\n ')',\n source\n );\n}\n\n// Wrong number of arguments\n\nfunction wrongNumberOfArguments(ruleName, expected, actual, expr) {\n return createError(\n 'Wrong number of arguments for rule ' +\n ruleName +\n ' (expected ' +\n expected +\n ', got ' +\n actual +\n ')',\n expr.source\n );\n}\n\n// Duplicate parameter names\n\nfunction duplicateParameterNames(ruleName, duplicates, source) {\n return createError(\n 'Duplicate parameter names in rule ' + ruleName + ': ' + duplicates.join(', '),\n source\n );\n}\n\n// Invalid parameter expression\n\nfunction invalidParameter(ruleName, expr) {\n return createError(\n 'Invalid parameter to rule ' +\n ruleName +\n ': ' +\n expr +\n ' has arity ' +\n expr.getArity() +\n ', but parameter expressions must have arity 1',\n expr.source\n );\n}\n\n// Application of syntactic rule from lexical rule\n\nconst syntacticVsLexicalNote =\n 'NOTE: A _syntactic rule_ is a rule whose name begins with a capital letter. ' +\n 'See https://git.io/JiYgP for more details.';\n\nfunction applicationOfSyntacticRuleFromLexicalContext(ruleName, applyExpr) {\n return createError(\n 'Cannot apply syntactic rule ' + ruleName + ' from here (inside a lexical context)',\n applyExpr.source\n );\n}\n\n// Lexical rule application used with experimentalApplySyntactic\n\nfunction experimentalApplySyntacticWithLexicalRuleApplication(applyExpr) {\n const {ruleName} = applyExpr;\n return createError(\n `experimentalApplySyntactic is for syntactic rules, but '${ruleName}' is a lexical rule. ` +\n syntacticVsLexicalNote,\n applyExpr.source\n );\n}\n\n// Incorrect argument type\n\nfunction incorrectArgumentType(expectedType, expr) {\n return createError('Incorrect argument type: expected ' + expectedType, expr.source);\n}\n\n// Multiple instances of the super-splice operator (`...`) in the rule body.\n\nfunction multipleSuperSplices(expr) {\n return createError(\"'...' can appear at most once in a rule body\", expr.source);\n}\n\n// ----------------- Kleene operators -----------------\n\nfunction kleeneExprHasNullableOperand(kleeneExpr, applicationStack) {\n const actuals =\n applicationStack.length > 0 ? applicationStack[applicationStack.length - 1].args : [];\n const expr = kleeneExpr.expr.substituteParams(actuals);\n let message =\n 'Nullable expression ' +\n expr +\n \" is not allowed inside '\" +\n kleeneExpr.operator +\n \"' (possible infinite loop)\";\n if (applicationStack.length > 0) {\n const stackTrace = applicationStack\n .map(app => new pexprs.Apply(app.ruleName, app.args))\n .join('\\n');\n message += '\\nApplication stack (most recent application last):\\n' + stackTrace;\n }\n return createError(message, kleeneExpr.expr.source);\n}\n\n// ----------------- arity -----------------\n\nfunction inconsistentArity(ruleName, expected, actual, expr) {\n return createError(\n 'Rule ' +\n ruleName +\n ' involves an alternation which has inconsistent arity ' +\n '(expected ' +\n expected +\n ', got ' +\n actual +\n ')',\n expr.source\n );\n}\n\n// ----------------- properties -----------------\n\nfunction duplicatePropertyNames(duplicates) {\n return createError('Object pattern has duplicate property names: ' + duplicates.join(', '));\n}\n\n// ----------------- constructors -----------------\n\nfunction invalidConstructorCall(grammar, ctorName, children) {\n return createError(\n 'Attempt to invoke constructor ' + ctorName + ' with invalid or unexpected arguments'\n );\n}\n\n// ----------------- convenience -----------------\n\nfunction multipleErrors(errors) {\n const messages = errors.map(e => e.message);\n return createError(['Errors:'].concat(messages).join('\\n- '), errors[0].interval);\n}\n\n// ----------------- semantic -----------------\n\nfunction missingSemanticAction(ctorName, name, type, stack) {\n let stackTrace = stack\n .slice(0, -1)\n .map(info => {\n const ans = ' ' + info[0].name + ' > ' + info[1];\n return info.length === 3 ? ans + \" for '\" + info[2] + \"'\" : ans;\n })\n .join('\\n');\n stackTrace += '\\n ' + name + ' > ' + ctorName;\n\n let moreInfo = '';\n if (ctorName === '_iter') {\n moreInfo = [\n '\\nNOTE: as of Ohm v16, there is no default action for iteration nodes — see ',\n ' https://git.io/JRwtG for details.',\n ].join('\\n');\n }\n\n const message = [\n `Missing semantic action for '${ctorName}' in ${type} '${name}'.${moreInfo}`,\n 'Action stack (most recent call last):',\n stackTrace,\n ].join('\\n');\n\n const e = createError(message);\n e.name = 'missingSemanticAction';\n return e;\n}\n\n// --------------------------------------------------------------------\n// Exports\n// --------------------------------------------------------------------\n\nmodule.exports = {\n applicationOfSyntacticRuleFromLexicalContext,\n experimentalApplySyntacticWithLexicalRuleApplication,\n cannotExtendUndeclaredRule,\n cannotOverrideUndeclaredRule,\n duplicateGrammarDeclaration,\n duplicateParameterNames,\n duplicatePropertyNames,\n duplicateRuleDeclaration,\n inconsistentArity,\n incorrectArgumentType,\n intervalSourcesDontMatch,\n invalidConstructorCall,\n invalidParameter,\n grammarSyntaxError,\n kleeneExprHasNullableOperand,\n missingSemanticAction,\n multipleSuperSplices,\n undeclaredGrammar,\n undeclaredRule,\n wrongNumberOfArguments,\n wrongNumberOfParameters,\n\n throwErrors(errors) {\n if (errors.length === 1) {\n throw errors[0];\n }\n if (errors.length > 1) {\n throw multipleErrors(errors);\n }\n },\n};\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst common = require('./common');\n\n// --------------------------------------------------------------------\n// Private stuff\n// --------------------------------------------------------------------\n\n// Given an array of numbers `arr`, return an array of the numbers as strings,\n// right-justified and padded to the same length.\nfunction padNumbersToEqualLength(arr) {\n let maxLen = 0;\n const strings = arr.map(n => {\n const str = n.toString();\n maxLen = Math.max(maxLen, str.length);\n return str;\n });\n return strings.map(s => common.padLeft(s, maxLen));\n}\n\n// Produce a new string that would be the result of copying the contents\n// of the string `src` onto `dest` at offset `offest`.\nfunction strcpy(dest, src, offset) {\n const origDestLen = dest.length;\n const start = dest.slice(0, offset);\n const end = dest.slice(offset + src.length);\n return (start + src + end).substr(0, origDestLen);\n}\n\n// Casts the underlying lineAndCol object to a formatted message string,\n// highlighting `ranges`.\nfunction lineAndColumnToMessage(...ranges) {\n const lineAndCol = this;\n const {offset} = lineAndCol;\n const {repeatStr} = common;\n\n const sb = new common.StringBuffer();\n sb.append('Line ' + lineAndCol.lineNum + ', col ' + lineAndCol.colNum + ':\\n');\n\n // An array of the previous, current, and next line numbers as strings of equal length.\n const lineNumbers = padNumbersToEqualLength([\n lineAndCol.prevLine == null ? 0 : lineAndCol.lineNum - 1,\n lineAndCol.lineNum,\n lineAndCol.nextLine == null ? 0 : lineAndCol.lineNum + 1,\n ]);\n\n // Helper for appending formatting input lines to the buffer.\n const appendLine = (num, content, prefix) => {\n sb.append(prefix + lineNumbers[num] + ' | ' + content + '\\n');\n };\n\n // Include the previous line for context if possible.\n if (lineAndCol.prevLine != null) {\n appendLine(0, lineAndCol.prevLine, ' ');\n }\n // Line that the error occurred on.\n appendLine(1, lineAndCol.line, '> ');\n\n // Build up the line that points to the offset and possible indicates one or more ranges.\n // Start with a blank line, and indicate each range by overlaying a string of `~` chars.\n const lineLen = lineAndCol.line.length;\n let indicationLine = repeatStr(' ', lineLen + 1);\n for (let i = 0; i < ranges.length; ++i) {\n let startIdx = ranges[i][0];\n let endIdx = ranges[i][1];\n common.assert(startIdx >= 0 && startIdx <= endIdx, 'range start must be >= 0 and <= end');\n\n const lineStartOffset = offset - lineAndCol.colNum + 1;\n startIdx = Math.max(0, startIdx - lineStartOffset);\n endIdx = Math.min(endIdx - lineStartOffset, lineLen);\n\n indicationLine = strcpy(indicationLine, repeatStr('~', endIdx - startIdx), startIdx);\n }\n const gutterWidth = 2 + lineNumbers[1].length + 3;\n sb.append(repeatStr(' ', gutterWidth));\n indicationLine = strcpy(indicationLine, '^', lineAndCol.colNum - 1);\n sb.append(indicationLine.replace(/ +$/, '') + '\\n');\n\n // Include the next line for context if possible.\n if (lineAndCol.nextLine != null) {\n appendLine(2, lineAndCol.nextLine, ' ');\n }\n return sb.contents();\n}\n\n// --------------------------------------------------------------------\n// Exports\n// --------------------------------------------------------------------\n\nlet builtInRulesCallbacks = [];\n\n// Since Grammar.BuiltInRules is bootstrapped, most of Ohm can't directly depend it.\n// This function allows modules that do depend on the built-in rules to register a callback\n// that will be called later in the initialization process.\nexports.awaitBuiltInRules = cb => {\n builtInRulesCallbacks.push(cb);\n};\n\nexports.announceBuiltInRules = grammar => {\n builtInRulesCallbacks.forEach(cb => {\n cb(grammar);\n });\n builtInRulesCallbacks = null;\n};\n\n// Return an object with the line and column information for the given\n// offset in `str`.\nexports.getLineAndColumn = (str, offset) => {\n let lineNum = 1;\n let colNum = 1;\n\n let currOffset = 0;\n let lineStartOffset = 0;\n\n let nextLine = null;\n let prevLine = null;\n let prevLineStartOffset = -1;\n\n while (currOffset < offset) {\n const c = str.charAt(currOffset++);\n if (c === '\\n') {\n lineNum++;\n colNum = 1;\n prevLineStartOffset = lineStartOffset;\n lineStartOffset = currOffset;\n } else if (c !== '\\r') {\n colNum++;\n }\n }\n\n // Find the end of the target line.\n let lineEndOffset = str.indexOf('\\n', lineStartOffset);\n if (lineEndOffset === -1) {\n lineEndOffset = str.length;\n } else {\n // Get the next line.\n const nextLineEndOffset = str.indexOf('\\n', lineEndOffset + 1);\n nextLine =\n nextLineEndOffset === -1 ?\n str.slice(lineEndOffset) :\n str.slice(lineEndOffset, nextLineEndOffset);\n // Strip leading and trailing EOL char(s).\n nextLine = nextLine.replace(/^\\r?\\n/, '').replace(/\\r$/, '');\n }\n\n // Get the previous line.\n if (prevLineStartOffset >= 0) {\n // Strip trailing EOL char(s).\n prevLine = str.slice(prevLineStartOffset, lineStartOffset).replace(/\\r?\\n$/, '');\n }\n\n // Get the target line, stripping a trailing carriage return if necessary.\n const line = str.slice(lineStartOffset, lineEndOffset).replace(/\\r$/, '');\n\n return {\n offset,\n lineNum,\n colNum,\n line,\n prevLine,\n nextLine,\n toString: lineAndColumnToMessage,\n };\n};\n\n// Return a nicely-formatted string describing the line and column for the\n// given offset in `str` highlighting `ranges`.\nexports.getLineAndColumnMessage = function(str, offset, ...ranges) {\n return exports.getLineAndColumn(str, offset).toString(...ranges);\n};\n\nexports.uniqueId = (() => {\n let idCounter = 0;\n return prefix => '' + prefix + idCounter++;\n})();\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst common = require('./common');\nconst errors = require('./errors');\nconst pexprs = require('./pexprs');\n\n// --------------------------------------------------------------------\n// Operations\n// --------------------------------------------------------------------\n\npexprs.PExpr.prototype.assertChoicesHaveUniformArity = common.abstract(\n 'assertChoicesHaveUniformArity'\n);\n\npexprs.any.assertChoicesHaveUniformArity =\n pexprs.end.assertChoicesHaveUniformArity =\n pexprs.Terminal.prototype.assertChoicesHaveUniformArity =\n pexprs.Range.prototype.assertChoicesHaveUniformArity =\n pexprs.Param.prototype.assertChoicesHaveUniformArity =\n pexprs.Lex.prototype.assertChoicesHaveUniformArity =\n pexprs.UnicodeChar.prototype.assertChoicesHaveUniformArity =\n function(ruleName) {\n // no-op\n };\n\npexprs.Alt.prototype.assertChoicesHaveUniformArity = function(ruleName) {\n if (this.terms.length === 0) {\n return;\n }\n const arity = this.terms[0].getArity();\n for (let idx = 0; idx < this.terms.length; idx++) {\n const term = this.terms[idx];\n term.assertChoicesHaveUniformArity();\n const otherArity = term.getArity();\n if (arity !== otherArity) {\n throw errors.inconsistentArity(ruleName, arity, otherArity, term);\n }\n }\n};\n\npexprs.Extend.prototype.assertChoicesHaveUniformArity = function(ruleName) {\n // Extend is a special case of Alt that's guaranteed to have exactly two\n // cases: [extensions, origBody].\n const actualArity = this.terms[0].getArity();\n const expectedArity = this.terms[1].getArity();\n if (actualArity !== expectedArity) {\n throw errors.inconsistentArity(ruleName, expectedArity, actualArity, this.terms[0]);\n }\n};\n\npexprs.Seq.prototype.assertChoicesHaveUniformArity = function(ruleName) {\n for (let idx = 0; idx < this.factors.length; idx++) {\n this.factors[idx].assertChoicesHaveUniformArity(ruleName);\n }\n};\n\npexprs.Iter.prototype.assertChoicesHaveUniformArity = function(ruleName) {\n this.expr.assertChoicesHaveUniformArity(ruleName);\n};\n\npexprs.Not.prototype.assertChoicesHaveUniformArity = function(ruleName) {\n // no-op (not required b/c the nested expr doesn't show up in the CST)\n};\n\npexprs.Lookahead.prototype.assertChoicesHaveUniformArity = function(ruleName) {\n this.expr.assertChoicesHaveUniformArity(ruleName);\n};\n\npexprs.Apply.prototype.assertChoicesHaveUniformArity = function(ruleName) {\n // The arities of the parameter expressions is required to be 1 by\n // `assertAllApplicationsAreValid()`.\n};\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst common = require('./common');\nconst errors = require('./errors');\nconst pexprs = require('./pexprs');\n\n// --------------------------------------------------------------------\n// Operations\n// --------------------------------------------------------------------\n\npexprs.PExpr.prototype.assertIteratedExprsAreNotNullable = common.abstract(\n 'assertIteratedExprsAreNotNullable'\n);\n\npexprs.any.assertIteratedExprsAreNotNullable =\n pexprs.end.assertIteratedExprsAreNotNullable =\n pexprs.Terminal.prototype.assertIteratedExprsAreNotNullable =\n pexprs.Range.prototype.assertIteratedExprsAreNotNullable =\n pexprs.Param.prototype.assertIteratedExprsAreNotNullable =\n pexprs.UnicodeChar.prototype.assertIteratedExprsAreNotNullable =\n function(grammar) {\n // no-op\n };\n\npexprs.Alt.prototype.assertIteratedExprsAreNotNullable = function(grammar) {\n for (let idx = 0; idx < this.terms.length; idx++) {\n this.terms[idx].assertIteratedExprsAreNotNullable(grammar);\n }\n};\n\npexprs.Seq.prototype.assertIteratedExprsAreNotNullable = function(grammar) {\n for (let idx = 0; idx < this.factors.length; idx++) {\n this.factors[idx].assertIteratedExprsAreNotNullable(grammar);\n }\n};\n\npexprs.Iter.prototype.assertIteratedExprsAreNotNullable = function(grammar) {\n // Note: this is the implementation of this method for `Star` and `Plus` expressions.\n // It is overridden for `Opt` below.\n this.expr.assertIteratedExprsAreNotNullable(grammar);\n if (this.expr.isNullable(grammar)) {\n throw errors.kleeneExprHasNullableOperand(this, []);\n }\n};\n\npexprs.Opt.prototype.assertIteratedExprsAreNotNullable =\n pexprs.Not.prototype.assertIteratedExprsAreNotNullable =\n pexprs.Lookahead.prototype.assertIteratedExprsAreNotNullable =\n pexprs.Lex.prototype.assertIteratedExprsAreNotNullable =\n function(grammar) {\n this.expr.assertIteratedExprsAreNotNullable(grammar);\n };\n\npexprs.Apply.prototype.assertIteratedExprsAreNotNullable = function(grammar) {\n this.args.forEach(arg => {\n arg.assertIteratedExprsAreNotNullable(grammar);\n });\n};\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst {assert} = require('./common');\nconst errors = require('./errors');\nconst util = require('./util');\n\n// --------------------------------------------------------------------\n// Private stuff\n// --------------------------------------------------------------------\n\nfunction Interval(sourceString, startIdx, endIdx) {\n this.sourceString = sourceString;\n this.startIdx = startIdx;\n this.endIdx = endIdx;\n}\n\nInterval.coverage = function(firstInterval, ...intervals) {\n let {startIdx, endIdx} = firstInterval;\n for (const interval of intervals) {\n if (interval.sourceString !== firstInterval.sourceString) {\n throw errors.intervalSourcesDontMatch();\n } else {\n startIdx = Math.min(startIdx, interval.startIdx);\n endIdx = Math.max(endIdx, interval.endIdx);\n }\n }\n return new Interval(firstInterval.sourceString, startIdx, endIdx);\n};\n\nInterval.prototype = {\n coverageWith(...intervals) {\n return Interval.coverage(...intervals, this);\n },\n\n collapsedLeft() {\n return new Interval(this.sourceString, this.startIdx, this.startIdx);\n },\n\n collapsedRight() {\n return new Interval(this.sourceString, this.endIdx, this.endIdx);\n },\n\n getLineAndColumn() {\n return util.getLineAndColumn(this.sourceString, this.startIdx);\n },\n\n getLineAndColumnMessage() {\n const range = [this.startIdx, this.endIdx];\n return util.getLineAndColumnMessage(this.sourceString, this.startIdx, range);\n },\n\n // Returns an array of 0, 1, or 2 intervals that represents the result of the\n // interval difference operation.\n minus(that) {\n if (this.sourceString !== that.sourceString) {\n throw errors.intervalSourcesDontMatch();\n } else if (this.startIdx === that.startIdx && this.endIdx === that.endIdx) {\n // `this` and `that` are the same interval!\n return [];\n } else if (this.startIdx < that.startIdx && that.endIdx < this.endIdx) {\n // `that` splits `this` into two intervals\n return [\n new Interval(this.sourceString, this.startIdx, that.startIdx),\n new Interval(this.sourceString, that.endIdx, this.endIdx),\n ];\n } else if (this.startIdx < that.endIdx && that.endIdx < this.endIdx) {\n // `that` contains a prefix of `this`\n return [new Interval(this.sourceString, that.endIdx, this.endIdx)];\n } else if (this.startIdx < that.startIdx && that.startIdx < this.endIdx) {\n // `that` contains a suffix of `this`\n return [new Interval(this.sourceString, this.startIdx, that.startIdx)];\n } else {\n // `that` and `this` do not overlap\n return [this];\n }\n },\n\n // Returns a new Interval that has the same extent as this one, but which is relative\n // to `that`, an Interval that fully covers this one.\n relativeTo(that) {\n if (this.sourceString !== that.sourceString) {\n throw errors.intervalSourcesDontMatch();\n }\n assert(\n this.startIdx >= that.startIdx && this.endIdx <= that.endIdx,\n 'other interval does not cover this one'\n );\n return new Interval(\n this.sourceString,\n this.startIdx - that.startIdx,\n this.endIdx - that.startIdx\n );\n },\n\n // Returns a new Interval which contains the same contents as this one,\n // but with whitespace trimmed from both ends. (This only makes sense when\n // the input stream is a string.)\n trimmed() {\n const {contents} = this;\n const startIdx = this.startIdx + contents.match(/^\\s*/)[0].length;\n const endIdx = this.endIdx - contents.match(/\\s*$/)[0].length;\n return new Interval(this.sourceString, startIdx, endIdx);\n },\n\n subInterval(offset, len) {\n const newStartIdx = this.startIdx + offset;\n return new Interval(this.sourceString, newStartIdx, newStartIdx + len);\n },\n};\n\nObject.defineProperties(Interval.prototype, {\n contents: {\n get() {\n if (this._contents === undefined) {\n this._contents = this.sourceString.slice(this.startIdx, this.endIdx);\n }\n return this._contents;\n },\n enumerable: true,\n },\n length: {\n get() {\n return this.endIdx - this.startIdx;\n },\n enumerable: true,\n },\n});\n\n// --------------------------------------------------------------------\n// Exports\n// --------------------------------------------------------------------\n\nmodule.exports = Interval;\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst Interval = require('./Interval');\nconst common = require('./common');\n\n// --------------------------------------------------------------------\n// Private stuff\n// --------------------------------------------------------------------\n\n// Unicode characters that are used in the `toString` output.\nconst BALLOT_X = '\\u2717';\nconst CHECK_MARK = '\\u2713';\nconst DOT_OPERATOR = '\\u22C5';\nconst RIGHTWARDS_DOUBLE_ARROW = '\\u21D2';\nconst SYMBOL_FOR_HORIZONTAL_TABULATION = '\\u2409';\nconst SYMBOL_FOR_LINE_FEED = '\\u240A';\nconst SYMBOL_FOR_CARRIAGE_RETURN = '\\u240D';\n\nconst Flags = {\n succeeded: 1 << 0,\n isRootNode: 1 << 1,\n isImplicitSpaces: 1 << 2,\n isMemoized: 1 << 3,\n isHeadOfLeftRecursion: 1 << 4,\n terminatesLR: 1 << 5,\n};\n\nfunction spaces(n) {\n return common.repeat(' ', n).join('');\n}\n\n// Return a string representation of a portion of `input` at offset `pos`.\n// The result will contain exactly `len` characters.\nfunction getInputExcerpt(input, pos, len) {\n const excerpt = asEscapedString(input.slice(pos, pos + len));\n\n // Pad the output if necessary.\n if (excerpt.length < len) {\n return excerpt + common.repeat(' ', len - excerpt.length).join('');\n }\n return excerpt;\n}\n\nfunction asEscapedString(obj) {\n if (typeof obj === 'string') {\n // Replace non-printable characters with visible symbols.\n return obj\n .replace(/ /g, DOT_OPERATOR)\n .replace(/\\t/g, SYMBOL_FOR_HORIZONTAL_TABULATION)\n .replace(/\\n/g, SYMBOL_FOR_LINE_FEED)\n .replace(/\\r/g, SYMBOL_FOR_CARRIAGE_RETURN);\n }\n return String(obj);\n}\n\n// ----------------- Trace -----------------\n\nfunction Trace(input, pos1, pos2, expr, succeeded, bindings, optChildren) {\n this.input = input;\n this.pos = this.pos1 = pos1;\n this.pos2 = pos2;\n this.source = new Interval(input, pos1, pos2);\n this.expr = expr;\n this.bindings = bindings;\n this.children = optChildren || [];\n this.terminatingLREntry = null;\n\n this._flags = succeeded ? Flags.succeeded : 0;\n}\n\n// A value that can be returned from visitor functions to indicate that a\n// node should not be recursed into.\nTrace.prototype.SKIP = {};\n\nObject.defineProperty(Trace.prototype, 'displayString', {\n get() {\n return this.expr.toDisplayString();\n },\n});\n\n// For convenience, create a getter and setter for the boolean flags in `Flags`.\nObject.keys(Flags).forEach(name => {\n const mask = Flags[name];\n Object.defineProperty(Trace.prototype, name, {\n get() {\n return (this._flags & mask) !== 0;\n },\n set(val) {\n if (val) {\n this._flags |= mask;\n } else {\n this._flags &= ~mask;\n }\n },\n });\n});\n\nTrace.prototype.clone = function() {\n return this.cloneWithExpr(this.expr);\n};\n\nTrace.prototype.cloneWithExpr = function(expr) {\n const ans = new Trace(\n this.input,\n this.pos,\n this.pos2,\n expr,\n this.succeeded,\n this.bindings,\n this.children\n );\n\n ans.isHeadOfLeftRecursion = this.isHeadOfLeftRecursion;\n ans.isImplicitSpaces = this.isImplicitSpaces;\n ans.isMemoized = this.isMemoized;\n ans.isRootNode = this.isRootNode;\n ans.terminatesLR = this.terminatesLR;\n ans.terminatingLREntry = this.terminatingLREntry;\n return ans;\n};\n\n// Record the trace information for the terminating condition of the LR loop.\nTrace.prototype.recordLRTermination = function(ruleBodyTrace, value) {\n this.terminatingLREntry = new Trace(\n this.input,\n this.pos,\n this.pos2,\n this.expr,\n false,\n [value],\n [ruleBodyTrace]\n );\n this.terminatingLREntry.terminatesLR = true;\n};\n\n// Recursively traverse this trace node and all its descendents, calling a visitor function\n// for each node that is visited. If `vistorObjOrFn` is an object, then its 'enter' property\n// is a function to call before visiting the children of a node, and its 'exit' property is\n// a function to call afterwards. If `visitorObjOrFn` is a function, it represents the 'enter'\n// function.\n//\n// The functions are called with three arguments: the Trace node, its parent Trace, and a number\n// representing the depth of the node in the tree. (The root node has depth 0.) `optThisArg`, if\n// specified, is the value to use for `this` when executing the visitor functions.\nTrace.prototype.walk = function(visitorObjOrFn, optThisArg) {\n let visitor = visitorObjOrFn;\n if (typeof visitor === 'function') {\n visitor = {enter: visitor};\n }\n\n function _walk(node, parent, depth) {\n let recurse = true;\n if (visitor.enter) {\n if (visitor.enter.call(optThisArg, node, parent, depth) === Trace.prototype.SKIP) {\n recurse = false;\n }\n }\n if (recurse) {\n node.children.forEach(child => {\n _walk(child, node, depth + 1);\n });\n if (visitor.exit) {\n visitor.exit.call(optThisArg, node, parent, depth);\n }\n }\n }\n if (this.isRootNode) {\n // Don't visit the root node itself, only its children.\n this.children.forEach(c => {\n _walk(c, null, 0);\n });\n } else {\n _walk(this, null, 0);\n }\n};\n\n// Return a string representation of the trace.\n// Sample:\n// 12⋅+⋅2⋅*⋅3 ✓ exp ⇒ \"12\"\n// 12⋅+⋅2⋅*⋅3 ✓ addExp (LR) ⇒ \"12\"\n// 12⋅+⋅2⋅*⋅3 ✗ addExp_plus\nTrace.prototype.toString = function() {\n const sb = new common.StringBuffer();\n this.walk((node, parent, depth) => {\n if (!node) {\n return this.SKIP;\n }\n const ctorName = node.expr.constructor.name;\n // Don't print anything for Alt nodes.\n if (ctorName === 'Alt') {\n return; // eslint-disable-line consistent-return\n }\n sb.append(getInputExcerpt(node.input, node.pos, 10) + spaces(depth * 2 + 1));\n sb.append((node.succeeded ? CHECK_MARK : BALLOT_X) + ' ' + node.displayString);\n if (node.isHeadOfLeftRecursion) {\n sb.append(' (LR)');\n }\n if (node.succeeded) {\n const contents = asEscapedString(node.source.contents);\n sb.append(' ' + RIGHTWARDS_DOUBLE_ARROW + ' ');\n sb.append(typeof contents === 'string' ? '\"' + contents + '\"' : contents);\n }\n sb.append('\\n');\n });\n return sb.contents();\n};\n\n// --------------------------------------------------------------------\n// Exports\n// --------------------------------------------------------------------\n\nmodule.exports = Trace;\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst Trace = require('./Trace');\nconst common = require('./common');\nconst errors = require('./errors');\nconst nodes = require('./nodes');\nconst pexprs = require('./pexprs');\n\nconst {TerminalNode} = nodes;\nconst {NonterminalNode} = nodes;\nconst {IterationNode} = nodes;\n\n// --------------------------------------------------------------------\n// Operations\n// --------------------------------------------------------------------\n\n/*\n Evaluate the expression and return `true` if it succeeds, `false` otherwise. This method should\n only be called directly by `State.prototype.eval(expr)`, which also updates the data structures\n that are used for tracing. (Making those updates in a method of `State` enables the trace-specific\n data structures to be \"secrets\" of that class, which is good for modularity.)\n\n The contract of this method is as follows:\n * When the return value is `true`,\n - the state object will have `expr.getArity()` more bindings than it did before the call.\n * When the return value is `false`,\n - the state object may have more bindings than it did before the call, and\n - its input stream's position may be anywhere.\n\n Note that `State.prototype.eval(expr)`, unlike this method, guarantees that neither the state\n object's bindings nor its input stream's position will change if the expression fails to match.\n*/\npexprs.PExpr.prototype.eval = common.abstract('eval'); // function(state) { ... }\n\npexprs.any.eval = function(state) {\n const {inputStream} = state;\n const origPos = inputStream.pos;\n const ch = inputStream.next();\n if (ch) {\n state.pushBinding(new TerminalNode(state.grammar, ch), origPos);\n return true;\n } else {\n state.processFailure(origPos, this);\n return false;\n }\n};\n\npexprs.end.eval = function(state) {\n const {inputStream} = state;\n const origPos = inputStream.pos;\n if (inputStream.atEnd()) {\n state.pushBinding(new TerminalNode(state.grammar, undefined), origPos);\n return true;\n } else {\n state.processFailure(origPos, this);\n return false;\n }\n};\n\npexprs.Terminal.prototype.eval = function(state) {\n const {inputStream} = state;\n const origPos = inputStream.pos;\n if (!inputStream.matchString(this.obj)) {\n state.processFailure(origPos, this);\n return false;\n } else {\n state.pushBinding(new TerminalNode(state.grammar, this.obj), origPos);\n return true;\n }\n};\n\npexprs.Range.prototype.eval = function(state) {\n const {inputStream} = state;\n const origPos = inputStream.pos;\n const ch = inputStream.next();\n if (ch && this.from <= ch && ch <= this.to) {\n state.pushBinding(new TerminalNode(state.grammar, ch), origPos);\n return true;\n } else {\n state.processFailure(origPos, this);\n return false;\n }\n};\n\npexprs.Param.prototype.eval = function(state) {\n return state.eval(state.currentApplication().args[this.index]);\n};\n\npexprs.Lex.prototype.eval = function(state) {\n state.enterLexifiedContext();\n const ans = state.eval(this.expr);\n state.exitLexifiedContext();\n return ans;\n};\n\npexprs.Alt.prototype.eval = function(state) {\n for (let idx = 0; idx < this.terms.length; idx++) {\n if (state.eval(this.terms[idx])) {\n return true;\n }\n }\n return false;\n};\n\npexprs.Seq.prototype.eval = function(state) {\n for (let idx = 0; idx < this.factors.length; idx++) {\n const factor = this.factors[idx];\n if (!state.eval(factor)) {\n return false;\n }\n }\n return true;\n};\n\npexprs.Iter.prototype.eval = function(state) {\n const {inputStream} = state;\n const origPos = inputStream.pos;\n const arity = this.getArity();\n const cols = [];\n const colOffsets = [];\n while (cols.length < arity) {\n cols.push([]);\n colOffsets.push([]);\n }\n\n let numMatches = 0;\n let prevPos = origPos;\n let idx;\n while (numMatches < this.maxNumMatches && state.eval(this.expr)) {\n if (inputStream.pos === prevPos) {\n throw errors.kleeneExprHasNullableOperand(this, state._applicationStack);\n }\n prevPos = inputStream.pos;\n numMatches++;\n const row = state._bindings.splice(state._bindings.length - arity, arity);\n const rowOffsets = state._bindingOffsets.splice(\n state._bindingOffsets.length - arity,\n arity\n );\n for (idx = 0; idx < row.length; idx++) {\n cols[idx].push(row[idx]);\n colOffsets[idx].push(rowOffsets[idx]);\n }\n }\n if (numMatches < this.minNumMatches) {\n return false;\n }\n let offset = state.posToOffset(origPos);\n let matchLength = 0;\n if (numMatches > 0) {\n const lastCol = cols[arity - 1];\n const lastColOffsets = colOffsets[arity - 1];\n\n const endOffset =\n lastColOffsets[lastColOffsets.length - 1] + lastCol[lastCol.length - 1].matchLength;\n offset = colOffsets[0][0];\n matchLength = endOffset - offset;\n }\n const isOptional = this instanceof pexprs.Opt;\n for (idx = 0; idx < cols.length; idx++) {\n state._bindings.push(\n new IterationNode(state.grammar, cols[idx], colOffsets[idx], matchLength, isOptional)\n );\n state._bindingOffsets.push(offset);\n }\n return true;\n};\n\npexprs.Not.prototype.eval = function(state) {\n /*\n TODO:\n - Right now we're just throwing away all of the failures that happen inside a `not`, and\n recording `this` as a failed expression.\n - Double negation should be equivalent to lookahead, but that's not the case right now wrt\n failures. E.g., ~~'foo' produces a failure for ~~'foo', but maybe it should produce\n a failure for 'foo' instead.\n */\n\n const {inputStream} = state;\n const origPos = inputStream.pos;\n state.pushFailuresInfo();\n\n const ans = state.eval(this.expr);\n\n state.popFailuresInfo();\n if (ans) {\n state.processFailure(origPos, this);\n return false;\n }\n\n inputStream.pos = origPos;\n return true;\n};\n\npexprs.Lookahead.prototype.eval = function(state) {\n const {inputStream} = state;\n const origPos = inputStream.pos;\n if (state.eval(this.expr)) {\n inputStream.pos = origPos;\n return true;\n } else {\n return false;\n }\n};\n\npexprs.Apply.prototype.eval = function(state) {\n const caller = state.currentApplication();\n const actuals = caller ? caller.args : [];\n const app = this.substituteParams(actuals);\n\n const posInfo = state.getCurrentPosInfo();\n if (posInfo.isActive(app)) {\n // This rule is already active at this position, i.e., it is left-recursive.\n return app.handleCycle(state);\n }\n\n const memoKey = app.toMemoKey();\n const memoRec = posInfo.memo[memoKey];\n\n if (memoRec && posInfo.shouldUseMemoizedResult(memoRec)) {\n if (state.hasNecessaryInfo(memoRec)) {\n return state.useMemoizedResult(state.inputStream.pos, memoRec);\n }\n delete posInfo.memo[memoKey];\n }\n return app.reallyEval(state);\n};\n\npexprs.Apply.prototype.handleCycle = function(state) {\n const posInfo = state.getCurrentPosInfo();\n const {currentLeftRecursion} = posInfo;\n const memoKey = this.toMemoKey();\n let memoRec = posInfo.memo[memoKey];\n\n if (currentLeftRecursion && currentLeftRecursion.headApplication.toMemoKey() === memoKey) {\n // We already know about this left recursion, but it's possible there are \"involved\n // applications\" that we don't already know about, so...\n memoRec.updateInvolvedApplicationMemoKeys();\n } else if (!memoRec) {\n // New left recursion detected! Memoize a failure to try to get a seed parse.\n memoRec = posInfo.memoize(memoKey, {\n matchLength: 0,\n examinedLength: 0,\n value: false,\n rightmostFailureOffset: -1,\n });\n posInfo.startLeftRecursion(this, memoRec);\n }\n return state.useMemoizedResult(state.inputStream.pos, memoRec);\n};\n\npexprs.Apply.prototype.reallyEval = function(state) {\n const {inputStream} = state;\n const origPos = inputStream.pos;\n const origPosInfo = state.getCurrentPosInfo();\n const ruleInfo = state.grammar.rules[this.ruleName];\n const {body} = ruleInfo;\n const {description} = ruleInfo;\n\n state.enterApplication(origPosInfo, this);\n\n if (description) {\n state.pushFailuresInfo();\n }\n\n // Reset the input stream's examinedLength property so that we can track\n // the examined length of this particular application.\n const origInputStreamExaminedLength = inputStream.examinedLength;\n inputStream.examinedLength = 0;\n\n let value = this.evalOnce(body, state);\n const currentLR = origPosInfo.currentLeftRecursion;\n const memoKey = this.toMemoKey();\n const isHeadOfLeftRecursion = currentLR && currentLR.headApplication.toMemoKey() === memoKey;\n let memoRec;\n\n if (isHeadOfLeftRecursion) {\n value = this.growSeedResult(body, state, origPos, currentLR, value);\n origPosInfo.endLeftRecursion();\n memoRec = currentLR;\n memoRec.examinedLength = inputStream.examinedLength - origPos;\n memoRec.rightmostFailureOffset = state._getRightmostFailureOffset();\n origPosInfo.memoize(memoKey, memoRec); // updates origPosInfo's maxExaminedLength\n } else if (!currentLR || !currentLR.isInvolved(memoKey)) {\n // This application is not involved in left recursion, so it's ok to memoize it.\n memoRec = origPosInfo.memoize(memoKey, {\n matchLength: inputStream.pos - origPos,\n examinedLength: inputStream.examinedLength - origPos,\n value,\n failuresAtRightmostPosition: state.cloneRecordedFailures(),\n rightmostFailureOffset: state._getRightmostFailureOffset(),\n });\n }\n const succeeded = !!value;\n\n if (description) {\n state.popFailuresInfo();\n if (!succeeded) {\n state.processFailure(origPos, this);\n }\n if (memoRec) {\n memoRec.failuresAtRightmostPosition = state.cloneRecordedFailures();\n }\n }\n\n // Record trace information in the memo table, so that it is available if the memoized result\n // is used later.\n if (state.isTracing() && memoRec) {\n const entry = state.getTraceEntry(origPos, this, succeeded, succeeded ? [value] : []);\n if (isHeadOfLeftRecursion) {\n common.assert(entry.terminatingLREntry != null || !succeeded);\n entry.isHeadOfLeftRecursion = true;\n }\n memoRec.traceEntry = entry;\n }\n\n // Fix the input stream's examinedLength -- it should be the maximum examined length\n // across all applications, not just this one.\n inputStream.examinedLength = Math.max(\n inputStream.examinedLength,\n origInputStreamExaminedLength\n );\n\n state.exitApplication(origPosInfo, value);\n\n return succeeded;\n};\n\npexprs.Apply.prototype.evalOnce = function(expr, state) {\n const {inputStream} = state;\n const origPos = inputStream.pos;\n\n if (state.eval(expr)) {\n const arity = expr.getArity();\n const bindings = state._bindings.splice(state._bindings.length - arity, arity);\n const offsets = state._bindingOffsets.splice(state._bindingOffsets.length - arity, arity);\n return new NonterminalNode(\n state.grammar,\n this.ruleName,\n bindings,\n offsets,\n inputStream.pos - origPos\n );\n } else {\n return false;\n }\n};\n\npexprs.Apply.prototype.growSeedResult = function(body, state, origPos, lrMemoRec, newValue) {\n if (!newValue) {\n return false;\n }\n\n const {inputStream} = state;\n\n while (true) {\n lrMemoRec.matchLength = inputStream.pos - origPos;\n lrMemoRec.value = newValue;\n lrMemoRec.failuresAtRightmostPosition = state.cloneRecordedFailures();\n\n if (state.isTracing()) {\n // Before evaluating the body again, add a trace node for this application to the memo entry.\n // Its only child is a copy of the trace node from `newValue`, which will always be the last\n // element in `state.trace`.\n const seedTrace = state.trace[state.trace.length - 1];\n lrMemoRec.traceEntry = new Trace(\n state.input,\n origPos,\n inputStream.pos,\n this,\n true,\n [newValue],\n [seedTrace.clone()]\n );\n }\n inputStream.pos = origPos;\n newValue = this.evalOnce(body, state);\n if (inputStream.pos - origPos <= lrMemoRec.matchLength) {\n break;\n }\n if (state.isTracing()) {\n state.trace.splice(-2, 1); // Drop the trace for the old seed.\n }\n }\n if (state.isTracing()) {\n // The last entry is for an unused result -- pop it and save it in the \"real\" entry.\n lrMemoRec.traceEntry.recordLRTermination(state.trace.pop(), newValue);\n }\n inputStream.pos = origPos + lrMemoRec.matchLength;\n return lrMemoRec.value;\n};\n\npexprs.UnicodeChar.prototype.eval = function(state) {\n const {inputStream} = state;\n const origPos = inputStream.pos;\n const ch = inputStream.next();\n if (ch && this.pattern.test(ch)) {\n state.pushBinding(new TerminalNode(state.grammar, ch), origPos);\n return true;\n } else {\n state.processFailure(origPos, this);\n return false;\n }\n};\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst common = require('./common');\nconst pexprs = require('./pexprs');\n\n// --------------------------------------------------------------------\n// Private stuff\n// --------------------------------------------------------------------\n\nfunction getMetaInfo(expr, grammarInterval) {\n const metaInfo = {};\n if (expr.source && grammarInterval) {\n const adjusted = expr.source.relativeTo(grammarInterval);\n metaInfo.sourceInterval = [adjusted.startIdx, adjusted.endIdx];\n }\n return metaInfo;\n}\n\n// --------------------------------------------------------------------\n// Operations\n// --------------------------------------------------------------------\n\npexprs.PExpr.prototype.outputRecipe = common.abstract('outputRecipe');\n\npexprs.any.outputRecipe = function(formals, grammarInterval) {\n return ['any', getMetaInfo(this, grammarInterval)];\n};\n\npexprs.end.outputRecipe = function(formals, grammarInterval) {\n return ['end', getMetaInfo(this, grammarInterval)];\n};\n\npexprs.Terminal.prototype.outputRecipe = function(formals, grammarInterval) {\n return ['terminal', getMetaInfo(this, grammarInterval), this.obj];\n};\n\npexprs.Range.prototype.outputRecipe = function(formals, grammarInterval) {\n return ['range', getMetaInfo(this, grammarInterval), this.from, this.to];\n};\n\npexprs.Param.prototype.outputRecipe = function(formals, grammarInterval) {\n return ['param', getMetaInfo(this, grammarInterval), this.index];\n};\n\npexprs.Alt.prototype.outputRecipe = function(formals, grammarInterval) {\n return ['alt', getMetaInfo(this, grammarInterval)].concat(\n this.terms.map(term => term.outputRecipe(formals, grammarInterval))\n );\n};\n\npexprs.Extend.prototype.outputRecipe = function(formals, grammarInterval) {\n const extension = this.terms[0]; // [extension, original]\n return extension.outputRecipe(formals, grammarInterval);\n};\n\npexprs.Splice.prototype.outputRecipe = function(formals, grammarInterval) {\n const beforeTerms = this.terms.slice(0, this.expansionPos);\n const afterTerms = this.terms.slice(this.expansionPos + 1);\n return [\n 'splice',\n getMetaInfo(this, grammarInterval),\n beforeTerms.map(term => term.outputRecipe(formals, grammarInterval)),\n afterTerms.map(term => term.outputRecipe(formals, grammarInterval)),\n ];\n};\n\npexprs.Seq.prototype.outputRecipe = function(formals, grammarInterval) {\n return ['seq', getMetaInfo(this, grammarInterval)].concat(\n this.factors.map(factor => factor.outputRecipe(formals, grammarInterval))\n );\n};\n\npexprs.Star.prototype.outputRecipe =\n pexprs.Plus.prototype.outputRecipe =\n pexprs.Opt.prototype.outputRecipe =\n pexprs.Not.prototype.outputRecipe =\n pexprs.Lookahead.prototype.outputRecipe =\n pexprs.Lex.prototype.outputRecipe =\n function(formals, grammarInterval) {\n return [\n this.constructor.name.toLowerCase(),\n getMetaInfo(this, grammarInterval),\n this.expr.outputRecipe(formals, grammarInterval),\n ];\n };\n\npexprs.Apply.prototype.outputRecipe = function(formals, grammarInterval) {\n return [\n 'app',\n getMetaInfo(this, grammarInterval),\n this.ruleName,\n this.args.map(arg => arg.outputRecipe(formals, grammarInterval)),\n ];\n};\n\npexprs.UnicodeChar.prototype.outputRecipe = function(formals, grammarInterval) {\n return ['unicodeChar', getMetaInfo(this, grammarInterval), this.category];\n};\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst common = require('./common');\nconst pexprs = require('./pexprs');\n\n// --------------------------------------------------------------------\n// Operations\n// --------------------------------------------------------------------\n\npexprs.PExpr.prototype.getArity = common.abstract('getArity');\n\npexprs.any.getArity =\n pexprs.end.getArity =\n pexprs.Terminal.prototype.getArity =\n pexprs.Range.prototype.getArity =\n pexprs.Param.prototype.getArity =\n pexprs.Apply.prototype.getArity =\n pexprs.UnicodeChar.prototype.getArity =\n function() {\n return 1;\n };\n\npexprs.Alt.prototype.getArity = function() {\n // This is ok b/c all terms must have the same arity -- this property is\n // checked by the Grammar constructor.\n return this.terms.length === 0 ? 0 : this.terms[0].getArity();\n};\n\npexprs.Seq.prototype.getArity = function() {\n let arity = 0;\n for (let idx = 0; idx < this.factors.length; idx++) {\n arity += this.factors[idx].getArity();\n }\n return arity;\n};\n\npexprs.Iter.prototype.getArity = function() {\n return this.expr.getArity();\n};\n\npexprs.Not.prototype.getArity = function() {\n return 0;\n};\n\npexprs.Lookahead.prototype.getArity = pexprs.Lex.prototype.getArity = function() {\n return this.expr.getArity();\n};\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst common = require('./common');\nconst pexprs = require('./pexprs');\n\n// --------------------------------------------------------------------\n// Operations\n// --------------------------------------------------------------------\n\n/*\n Called at grammar creation time to rewrite a rule body, replacing each reference to a formal\n parameter with a `Param` node. Returns a PExpr -- either a new one, or the original one if\n it was modified in place.\n*/\npexprs.PExpr.prototype.introduceParams = common.abstract('introduceParams');\n\npexprs.any.introduceParams =\n pexprs.end.introduceParams =\n pexprs.Terminal.prototype.introduceParams =\n pexprs.Range.prototype.introduceParams =\n pexprs.Param.prototype.introduceParams =\n pexprs.UnicodeChar.prototype.introduceParams =\n function(formals) {\n return this;\n };\n\npexprs.Alt.prototype.introduceParams = function(formals) {\n this.terms.forEach((term, idx, terms) => {\n terms[idx] = term.introduceParams(formals);\n });\n return this;\n};\n\npexprs.Seq.prototype.introduceParams = function(formals) {\n this.factors.forEach((factor, idx, factors) => {\n factors[idx] = factor.introduceParams(formals);\n });\n return this;\n};\n\npexprs.Iter.prototype.introduceParams =\n pexprs.Not.prototype.introduceParams =\n pexprs.Lookahead.prototype.introduceParams =\n pexprs.Lex.prototype.introduceParams =\n function(formals) {\n this.expr = this.expr.introduceParams(formals);\n return this;\n };\n\npexprs.Apply.prototype.introduceParams = function(formals) {\n const index = formals.indexOf(this.ruleName);\n if (index >= 0) {\n if (this.args.length > 0) {\n // TODO: Should this be supported? See issue #64.\n throw new Error('Parameterized rules cannot be passed as arguments to another rule.');\n }\n return new pexprs.Param(index).withSource(this.source);\n } else {\n this.args.forEach((arg, idx, args) => {\n args[idx] = arg.introduceParams(formals);\n });\n return this;\n }\n};\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst common = require('./common');\nconst pexprs = require('./pexprs');\n\n// --------------------------------------------------------------------\n// Operations\n// --------------------------------------------------------------------\n\n// Returns `true` if this parsing expression may accept without consuming any input.\npexprs.PExpr.prototype.isNullable = function(grammar) {\n return this._isNullable(grammar, Object.create(null));\n};\n\npexprs.PExpr.prototype._isNullable = common.abstract('_isNullable');\n\npexprs.any._isNullable =\n pexprs.Range.prototype._isNullable =\n pexprs.Param.prototype._isNullable =\n pexprs.Plus.prototype._isNullable =\n pexprs.UnicodeChar.prototype._isNullable =\n function(grammar, memo) {\n return false;\n };\n\npexprs.end._isNullable = function(grammar, memo) {\n return true;\n};\n\npexprs.Terminal.prototype._isNullable = function(grammar, memo) {\n if (typeof this.obj === 'string') {\n // This is an over-simplification: it's only correct if the input is a string. If it's an array\n // or an object, then the empty string parsing expression is not nullable.\n return this.obj === '';\n } else {\n return false;\n }\n};\n\npexprs.Alt.prototype._isNullable = function(grammar, memo) {\n return this.terms.length === 0 || this.terms.some(term => term._isNullable(grammar, memo));\n};\n\npexprs.Seq.prototype._isNullable = function(grammar, memo) {\n return this.factors.every(factor => factor._isNullable(grammar, memo));\n};\n\npexprs.Star.prototype._isNullable =\n pexprs.Opt.prototype._isNullable =\n pexprs.Not.prototype._isNullable =\n pexprs.Lookahead.prototype._isNullable =\n function(grammar, memo) {\n return true;\n };\n\npexprs.Lex.prototype._isNullable = function(grammar, memo) {\n return this.expr._isNullable(grammar, memo);\n};\n\npexprs.Apply.prototype._isNullable = function(grammar, memo) {\n const key = this.toMemoKey();\n if (!Object.prototype.hasOwnProperty.call(memo, key)) {\n const {body} = grammar.rules[this.ruleName];\n const inlined = body.substituteParams(this.args);\n memo[key] = false; // Prevent infinite recursion for recursive rules.\n memo[key] = inlined._isNullable(grammar, memo);\n }\n return memo[key];\n};\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst common = require('./common');\nconst pexprs = require('./pexprs');\n\n// --------------------------------------------------------------------\n// Operations\n// --------------------------------------------------------------------\n\n/*\n Returns a PExpr that results from recursively replacing every formal parameter (i.e., instance\n of `Param`) inside this PExpr with its actual value from `actuals` (an Array).\n\n The receiver must not be modified; a new PExpr must be returned if any replacement is necessary.\n*/\n// function(actuals) { ... }\npexprs.PExpr.prototype.substituteParams = common.abstract('substituteParams');\n\npexprs.any.substituteParams =\n pexprs.end.substituteParams =\n pexprs.Terminal.prototype.substituteParams =\n pexprs.Range.prototype.substituteParams =\n pexprs.UnicodeChar.prototype.substituteParams =\n function(actuals) {\n return this;\n };\n\npexprs.Param.prototype.substituteParams = function(actuals) {\n return actuals[this.index];\n};\n\npexprs.Alt.prototype.substituteParams = function(actuals) {\n return new pexprs.Alt(this.terms.map(term => term.substituteParams(actuals)));\n};\n\npexprs.Seq.prototype.substituteParams = function(actuals) {\n return new pexprs.Seq(this.factors.map(factor => factor.substituteParams(actuals)));\n};\n\npexprs.Iter.prototype.substituteParams =\n pexprs.Not.prototype.substituteParams =\n pexprs.Lookahead.prototype.substituteParams =\n pexprs.Lex.prototype.substituteParams =\n function(actuals) {\n return new this.constructor(this.expr.substituteParams(actuals));\n };\n\npexprs.Apply.prototype.substituteParams = function(actuals) {\n if (this.args.length === 0) {\n // Avoid making a copy of this application, as an optimization\n return this;\n } else {\n const args = this.args.map(arg => arg.substituteParams(actuals));\n return new pexprs.Apply(this.ruleName, args);\n }\n};\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst common = require('./common');\nconst pexprs = require('./pexprs');\n\nconst {copyWithoutDuplicates} = common;\n\n// --------------------------------------------------------------------\n// Private stuff\n// --------------------------------------------------------------------\n\nfunction isRestrictedJSIdentifier(str) {\n return /^[a-zA-Z_$][0-9a-zA-Z_$]*$/.test(str);\n}\n\nfunction resolveDuplicatedNames(argumentNameList) {\n // `count` is used to record the number of times each argument name occurs in the list,\n // this is useful for checking duplicated argument name. It maps argument names to ints.\n const count = Object.create(null);\n argumentNameList.forEach(argName => {\n count[argName] = (count[argName] || 0) + 1;\n });\n\n // Append subscripts ('_1', '_2', ...) to duplicate argument names.\n Object.keys(count).forEach(dupArgName => {\n if (count[dupArgName] <= 1) {\n return;\n }\n\n // This name shows up more than once, so add subscripts.\n let subscript = 1;\n argumentNameList.forEach((argName, idx) => {\n if (argName === dupArgName) {\n argumentNameList[idx] = argName + '_' + subscript++;\n }\n });\n });\n}\n\n// --------------------------------------------------------------------\n// Operations\n// --------------------------------------------------------------------\n\n/*\n Returns a list of strings that will be used as the default argument names for its receiver\n (a pexpr) in a semantic action. This is used exclusively by the Semantics Editor.\n\n `firstArgIndex` is the 1-based index of the first argument name that will be generated for this\n pexpr. It enables us to name arguments positionally, e.g., if the second argument is a\n non-alphanumeric terminal like \"+\", it will be named '$2'.\n\n `noDupCheck` is true if the caller of `toArgumentNameList` is not a top level caller. It enables\n us to avoid nested duplication subscripts appending, e.g., '_1_1', '_1_2', by only checking\n duplicates at the top level.\n\n Here is a more elaborate example that illustrates how this method works:\n `(a \"+\" b).toArgumentNameList(1)` evaluates to `['a', '$2', 'b']` with the following recursive\n calls:\n\n (a).toArgumentNameList(1) -> ['a'],\n (\"+\").toArgumentNameList(2) -> ['$2'],\n (b).toArgumentNameList(3) -> ['b']\n\n Notes:\n * This method must only be called on well-formed expressions, e.g., the receiver must\n not have any Alt sub-expressions with inconsistent arities.\n * e.getArity() === e.toArgumentNameList(1).length\n*/\n// function(firstArgIndex, noDupCheck) { ... }\npexprs.PExpr.prototype.toArgumentNameList = common.abstract('toArgumentNameList');\n\npexprs.any.toArgumentNameList = function(firstArgIndex, noDupCheck) {\n return ['any'];\n};\n\npexprs.end.toArgumentNameList = function(firstArgIndex, noDupCheck) {\n return ['end'];\n};\n\npexprs.Terminal.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {\n if (typeof this.obj === 'string' && /^[_a-zA-Z0-9]+$/.test(this.obj)) {\n // If this terminal is a valid suffix for a JS identifier, just prepend it with '_'\n return ['_' + this.obj];\n } else {\n // Otherwise, name it positionally.\n return ['$' + firstArgIndex];\n }\n};\n\npexprs.Range.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {\n let argName = this.from + '_to_' + this.to;\n // If the `argName` is not valid then try to prepend a `_`.\n if (!isRestrictedJSIdentifier(argName)) {\n argName = '_' + argName;\n }\n // If the `argName` still not valid after prepending a `_`, then name it positionally.\n if (!isRestrictedJSIdentifier(argName)) {\n argName = '$' + firstArgIndex;\n }\n return [argName];\n};\n\npexprs.Alt.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {\n // `termArgNameLists` is an array of arrays where each row is the\n // argument name list that corresponds to a term in this alternation.\n const termArgNameLists = this.terms.map(term =>\n term.toArgumentNameList(firstArgIndex, true)\n );\n\n const argumentNameList = [];\n const numArgs = termArgNameLists[0].length;\n for (let colIdx = 0; colIdx < numArgs; colIdx++) {\n const col = [];\n for (let rowIdx = 0; rowIdx < this.terms.length; rowIdx++) {\n col.push(termArgNameLists[rowIdx][colIdx]);\n }\n const uniqueNames = copyWithoutDuplicates(col);\n argumentNameList.push(uniqueNames.join('_or_'));\n }\n\n if (!noDupCheck) {\n resolveDuplicatedNames(argumentNameList);\n }\n return argumentNameList;\n};\n\npexprs.Seq.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {\n // Generate the argument name list, without worrying about duplicates.\n let argumentNameList = [];\n this.factors.forEach(factor => {\n const factorArgumentNameList = factor.toArgumentNameList(firstArgIndex, true);\n argumentNameList = argumentNameList.concat(factorArgumentNameList);\n\n // Shift the firstArgIndex to take this factor's argument names into account.\n firstArgIndex += factorArgumentNameList.length;\n });\n if (!noDupCheck) {\n resolveDuplicatedNames(argumentNameList);\n }\n return argumentNameList;\n};\n\npexprs.Iter.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {\n const argumentNameList = this.expr\n .toArgumentNameList(firstArgIndex, noDupCheck)\n .map(exprArgumentString =>\n exprArgumentString[exprArgumentString.length - 1] === 's' ?\n exprArgumentString + 'es' :\n exprArgumentString + 's'\n );\n if (!noDupCheck) {\n resolveDuplicatedNames(argumentNameList);\n }\n return argumentNameList;\n};\n\npexprs.Opt.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {\n return this.expr.toArgumentNameList(firstArgIndex, noDupCheck).map(argName => {\n return 'opt' + argName[0].toUpperCase() + argName.slice(1);\n });\n};\n\npexprs.Not.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {\n return [];\n};\n\npexprs.Lookahead.prototype.toArgumentNameList = pexprs.Lex.prototype.toArgumentNameList =\n function(firstArgIndex, noDupCheck) {\n return this.expr.toArgumentNameList(firstArgIndex, noDupCheck);\n };\n\npexprs.Apply.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {\n return [this.ruleName];\n};\n\npexprs.UnicodeChar.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {\n return ['$' + firstArgIndex];\n};\n\npexprs.Param.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {\n return ['param' + this.index];\n};\n\n// \"Value pexprs\" (Value, Str, Arr, Obj) are going away soon, so we don't worry about them here.\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst common = require('./common');\nconst pexprs = require('./pexprs');\n\n// --------------------------------------------------------------------\n// Operations\n// --------------------------------------------------------------------\n\n// Returns a string representing the PExpr, for use as a UI label, etc.\npexprs.PExpr.prototype.toDisplayString = common.abstract('toDisplayString');\n\npexprs.Alt.prototype.toDisplayString = pexprs.Seq.prototype.toDisplayString = function() {\n if (this.source) {\n return this.source.trimmed().contents;\n }\n return '[' + this.constructor.name + ']';\n};\n\npexprs.any.toDisplayString =\n pexprs.end.toDisplayString =\n pexprs.Iter.prototype.toDisplayString =\n pexprs.Not.prototype.toDisplayString =\n pexprs.Lookahead.prototype.toDisplayString =\n pexprs.Lex.prototype.toDisplayString =\n pexprs.Terminal.prototype.toDisplayString =\n pexprs.Range.prototype.toDisplayString =\n pexprs.Param.prototype.toDisplayString =\n function() {\n return this.toString();\n };\n\npexprs.Apply.prototype.toDisplayString = function() {\n if (this.args.length > 0) {\n const ps = this.args.map(arg => arg.toDisplayString());\n return this.ruleName + '<' + ps.join(',') + '>';\n } else {\n return this.ruleName;\n }\n};\n\npexprs.UnicodeChar.prototype.toDisplayString = function() {\n return 'Unicode [' + this.category + '] character';\n};\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst Failure = require('./Failure');\nconst common = require('./common');\nconst pexprs = require('./pexprs');\n\n// --------------------------------------------------------------------\n// Operations\n// --------------------------------------------------------------------\n\npexprs.PExpr.prototype.toFailure = common.abstract('toFailure');\n\npexprs.any.toFailure = function(grammar) {\n return new Failure(this, 'any object', 'description');\n};\n\npexprs.end.toFailure = function(grammar) {\n return new Failure(this, 'end of input', 'description');\n};\n\npexprs.Terminal.prototype.toFailure = function(grammar) {\n return new Failure(this, this.obj, 'string');\n};\n\npexprs.Range.prototype.toFailure = function(grammar) {\n // TODO: come up with something better\n return new Failure(this, JSON.stringify(this.from) + '..' + JSON.stringify(this.to), 'code');\n};\n\npexprs.Not.prototype.toFailure = function(grammar) {\n const description =\n this.expr === pexprs.any ? 'nothing' : 'not ' + this.expr.toFailure(grammar);\n return new Failure(this, description, 'description');\n};\n\npexprs.Lookahead.prototype.toFailure = function(grammar) {\n return this.expr.toFailure(grammar);\n};\n\npexprs.Apply.prototype.toFailure = function(grammar) {\n let {description} = grammar.rules[this.ruleName];\n if (!description) {\n const article = /^[aeiouAEIOU]/.test(this.ruleName) ? 'an' : 'a';\n description = article + ' ' + this.ruleName;\n }\n return new Failure(this, description, 'description');\n};\n\npexprs.UnicodeChar.prototype.toFailure = function(grammar) {\n return new Failure(this, 'a Unicode [' + this.category + '] character', 'description');\n};\n\npexprs.Alt.prototype.toFailure = function(grammar) {\n const fs = this.terms.map(t => t.toFailure(grammar));\n const description = '(' + fs.join(' or ') + ')';\n return new Failure(this, description, 'description');\n};\n\npexprs.Seq.prototype.toFailure = function(grammar) {\n const fs = this.factors.map(f => f.toFailure(grammar));\n const description = '(' + fs.join(' ') + ')';\n return new Failure(this, description, 'description');\n};\n\npexprs.Iter.prototype.toFailure = function(grammar) {\n const description = '(' + this.expr.toFailure(grammar) + this.operator + ')';\n return new Failure(this, description, 'description');\n};\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst common = require('./common');\nconst pexprs = require('./pexprs');\n\n// --------------------------------------------------------------------\n// Operations\n// --------------------------------------------------------------------\n\n/*\n e1.toString() === e2.toString() ==> e1 and e2 are semantically equivalent.\n Note that this is not an iff (<==>): e.g.,\n (~\"b\" \"a\").toString() !== (\"a\").toString(), even though\n ~\"b\" \"a\" and \"a\" are interchangeable in any grammar,\n both in terms of the languages they accept and their arities.\n*/\npexprs.PExpr.prototype.toString = common.abstract('toString');\n\npexprs.any.toString = function() {\n return 'any';\n};\n\npexprs.end.toString = function() {\n return 'end';\n};\n\npexprs.Terminal.prototype.toString = function() {\n return JSON.stringify(this.obj);\n};\n\npexprs.Range.prototype.toString = function() {\n return JSON.stringify(this.from) + '..' + JSON.stringify(this.to);\n};\n\npexprs.Param.prototype.toString = function() {\n return '$' + this.index;\n};\n\npexprs.Lex.prototype.toString = function() {\n return '#(' + this.expr.toString() + ')';\n};\n\npexprs.Alt.prototype.toString = function() {\n return this.terms.length === 1 ?\n this.terms[0].toString() :\n '(' + this.terms.map(term => term.toString()).join(' | ') + ')';\n};\n\npexprs.Seq.prototype.toString = function() {\n return this.factors.length === 1 ?\n this.factors[0].toString() :\n '(' + this.factors.map(factor => factor.toString()).join(' ') + ')';\n};\n\npexprs.Iter.prototype.toString = function() {\n return this.expr + this.operator;\n};\n\npexprs.Not.prototype.toString = function() {\n return '~' + this.expr;\n};\n\npexprs.Lookahead.prototype.toString = function() {\n return '&' + this.expr;\n};\n\npexprs.Apply.prototype.toString = function() {\n if (this.args.length > 0) {\n const ps = this.args.map(arg => arg.toString());\n return this.ruleName + '<' + ps.join(',') + '>';\n } else {\n return this.ruleName;\n }\n};\n\npexprs.UnicodeChar.prototype.toString = function() {\n return '\\\\p{' + this.category + '}';\n};\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst Interval = require('./Interval');\n\n// --------------------------------------------------------------------\n// Private stuff\n// --------------------------------------------------------------------\n\nfunction InputStream(source) {\n this.source = source;\n this.pos = 0;\n this.examinedLength = 0;\n}\n\nInputStream.prototype = {\n atEnd() {\n const ans = this.pos === this.source.length;\n this.examinedLength = Math.max(this.examinedLength, this.pos + 1);\n return ans;\n },\n\n next() {\n const ans = this.source[this.pos++];\n this.examinedLength = Math.max(this.examinedLength, this.pos);\n return ans;\n },\n\n matchString(s, optIgnoreCase) {\n let idx;\n if (optIgnoreCase) {\n /*\n Case-insensitive comparison is a tricky business. Some notable gotchas include the\n \"Turkish I\" problem (http://www.i18nguy.com/unicode/turkish-i18n.html) and the fact\n that the German Esszet (ß) turns into \"SS\" in upper case.\n\n This is intended to be a locale-invariant comparison, which means it may not obey\n locale-specific expectations (e.g. \"i\" => \"İ\").\n */\n for (idx = 0; idx < s.length; idx++) {\n const actual = this.next();\n const expected = s[idx];\n if (actual == null || actual.toUpperCase() !== expected.toUpperCase()) {\n return false;\n }\n }\n return true;\n }\n // Default is case-sensitive comparison.\n for (idx = 0; idx < s.length; idx++) {\n if (this.next() !== s[idx]) {\n return false;\n }\n }\n return true;\n },\n\n sourceSlice(startIdx, endIdx) {\n return this.source.slice(startIdx, endIdx);\n },\n\n interval(startIdx, optEndIdx) {\n return new Interval(this.source, startIdx, optEndIdx ? optEndIdx : this.pos);\n },\n};\n\n// --------------------------------------------------------------------\n// Exports\n// --------------------------------------------------------------------\n\nmodule.exports = InputStream;\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst common = require('./common');\nconst util = require('./util');\nconst Interval = require('./Interval');\n\n// --------------------------------------------------------------------\n// Private stuff\n// --------------------------------------------------------------------\n\nfunction MatchResult(\n matcher,\n input,\n startExpr,\n cst,\n cstOffset,\n rightmostFailurePosition,\n optRecordedFailures\n) {\n this.matcher = matcher;\n this.input = input;\n this.startExpr = startExpr;\n this._cst = cst;\n this._cstOffset = cstOffset;\n this._rightmostFailurePosition = rightmostFailurePosition;\n this._rightmostFailures = optRecordedFailures;\n\n if (this.failed()) {\n /* eslint-disable no-invalid-this */\n common.defineLazyProperty(this, 'message', function() {\n const detail = 'Expected ' + this.getExpectedText();\n return (\n util.getLineAndColumnMessage(this.input, this.getRightmostFailurePosition()) + detail\n );\n });\n common.defineLazyProperty(this, 'shortMessage', function() {\n const detail = 'expected ' + this.getExpectedText();\n const errorInfo = util.getLineAndColumn(this.input, this.getRightmostFailurePosition());\n return 'Line ' + errorInfo.lineNum + ', col ' + errorInfo.colNum + ': ' + detail;\n });\n /* eslint-enable no-invalid-this */\n }\n}\n\nMatchResult.prototype.succeeded = function() {\n return !!this._cst;\n};\n\nMatchResult.prototype.failed = function() {\n return !this.succeeded();\n};\n\nMatchResult.prototype.getRightmostFailurePosition = function() {\n return this._rightmostFailurePosition;\n};\n\nMatchResult.prototype.getRightmostFailures = function() {\n if (!this._rightmostFailures) {\n this.matcher.setInput(this.input);\n const matchResultWithFailures = this.matcher._match(\n this.startExpr,\n false,\n this.getRightmostFailurePosition()\n );\n this._rightmostFailures = matchResultWithFailures.getRightmostFailures();\n }\n return this._rightmostFailures;\n};\n\nMatchResult.prototype.toString = function() {\n return this.succeeded() ?\n '[match succeeded]' :\n '[match failed at position ' + this.getRightmostFailurePosition() + ']';\n};\n\n// Return a string summarizing the expected contents of the input stream when\n// the match failure occurred.\nMatchResult.prototype.getExpectedText = function() {\n if (this.succeeded()) {\n throw new Error('cannot get expected text of a successful MatchResult');\n }\n\n const sb = new common.StringBuffer();\n let failures = this.getRightmostFailures();\n\n // Filter out the fluffy failures to make the default error messages more useful\n failures = failures.filter(failure => !failure.isFluffy());\n\n for (let idx = 0; idx < failures.length; idx++) {\n if (idx > 0) {\n if (idx === failures.length - 1) {\n sb.append(failures.length > 2 ? ', or ' : ' or ');\n } else {\n sb.append(', ');\n }\n }\n sb.append(failures[idx].toString());\n }\n return sb.contents();\n};\n\nMatchResult.prototype.getInterval = function() {\n const pos = this.getRightmostFailurePosition();\n return new Interval(this.input, pos, pos);\n};\n\n// --------------------------------------------------------------------\n// Exports\n// --------------------------------------------------------------------\n\nmodule.exports = MatchResult;\n","'use strict';\n\n// --------------------------------------------------------------------\n// Private stuff\n// --------------------------------------------------------------------\n\nfunction PosInfo() {\n this.applicationMemoKeyStack = []; // active applications at this position\n this.memo = {};\n this.maxExaminedLength = 0;\n this.maxRightmostFailureOffset = -1;\n this.currentLeftRecursion = undefined;\n}\n\nPosInfo.prototype = {\n isActive(application) {\n return this.applicationMemoKeyStack.indexOf(application.toMemoKey()) >= 0;\n },\n\n enter(application) {\n this.applicationMemoKeyStack.push(application.toMemoKey());\n },\n\n exit() {\n this.applicationMemoKeyStack.pop();\n },\n\n startLeftRecursion(headApplication, memoRec) {\n memoRec.isLeftRecursion = true;\n memoRec.headApplication = headApplication;\n memoRec.nextLeftRecursion = this.currentLeftRecursion;\n this.currentLeftRecursion = memoRec;\n\n const {applicationMemoKeyStack} = this;\n const indexOfFirstInvolvedRule =\n applicationMemoKeyStack.indexOf(headApplication.toMemoKey()) + 1;\n const involvedApplicationMemoKeys = applicationMemoKeyStack.slice(\n indexOfFirstInvolvedRule\n );\n\n memoRec.isInvolved = function(applicationMemoKey) {\n return involvedApplicationMemoKeys.indexOf(applicationMemoKey) >= 0;\n };\n\n memoRec.updateInvolvedApplicationMemoKeys = function() {\n for (let idx = indexOfFirstInvolvedRule; idx < applicationMemoKeyStack.length; idx++) {\n const applicationMemoKey = applicationMemoKeyStack[idx];\n if (!this.isInvolved(applicationMemoKey)) {\n involvedApplicationMemoKeys.push(applicationMemoKey);\n }\n }\n };\n },\n\n endLeftRecursion() {\n this.currentLeftRecursion = this.currentLeftRecursion.nextLeftRecursion;\n },\n\n // Note: this method doesn't get called for the \"head\" of a left recursion -- for LR heads,\n // the memoized result (which starts out being a failure) is always used.\n shouldUseMemoizedResult(memoRec) {\n if (!memoRec.isLeftRecursion) {\n return true;\n }\n const {applicationMemoKeyStack} = this;\n for (let idx = 0; idx < applicationMemoKeyStack.length; idx++) {\n const applicationMemoKey = applicationMemoKeyStack[idx];\n if (memoRec.isInvolved(applicationMemoKey)) {\n return false;\n }\n }\n return true;\n },\n\n memoize(memoKey, memoRec) {\n this.memo[memoKey] = memoRec;\n this.maxExaminedLength = Math.max(this.maxExaminedLength, memoRec.examinedLength);\n this.maxRightmostFailureOffset = Math.max(\n this.maxRightmostFailureOffset,\n memoRec.rightmostFailureOffset\n );\n return memoRec;\n },\n\n clearObsoleteEntries(pos, invalidatedIdx) {\n if (pos + this.maxExaminedLength <= invalidatedIdx) {\n // Optimization: none of the rule applications that were memoized here examined the\n // interval of the input that changed, so nothing has to be invalidated.\n return;\n }\n\n const {memo} = this;\n this.maxExaminedLength = 0;\n this.maxRightmostFailureOffset = -1;\n Object.keys(memo).forEach(k => {\n const memoRec = memo[k];\n if (pos + memoRec.examinedLength > invalidatedIdx) {\n delete memo[k];\n } else {\n this.maxExaminedLength = Math.max(this.maxExaminedLength, memoRec.examinedLength);\n this.maxRightmostFailureOffset = Math.max(\n this.maxRightmostFailureOffset,\n memoRec.rightmostFailureOffset\n );\n }\n });\n },\n};\n\n// --------------------------------------------------------------------\n// Exports\n// --------------------------------------------------------------------\n\nmodule.exports = PosInfo;\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst InputStream = require('./InputStream');\nconst MatchResult = require('./MatchResult');\nconst PosInfo = require('./PosInfo');\nconst Trace = require('./Trace');\nconst pexprs = require('./pexprs');\nconst util = require('./util');\n\n// --------------------------------------------------------------------\n// Private stuff\n// --------------------------------------------------------------------\n\nlet builtInApplySyntacticBody;\n\nutil.awaitBuiltInRules(builtInRules => {\n builtInApplySyntacticBody = builtInRules.rules.experimentalApplySyntactic.body;\n});\n\nconst applySpaces = new pexprs.Apply('spaces');\n\nfunction MatchState(matcher, startExpr, optPositionToRecordFailures) {\n this.matcher = matcher;\n this.startExpr = startExpr;\n\n this.grammar = matcher.grammar;\n this.input = matcher.input;\n this.inputStream = new InputStream(matcher.input);\n this.memoTable = matcher.memoTable;\n\n this._bindings = [];\n this._bindingOffsets = [];\n this._applicationStack = [];\n this._posStack = [0];\n this.inLexifiedContextStack = [false];\n\n this.rightmostFailurePosition = -1;\n this._rightmostFailurePositionStack = [];\n this._recordedFailuresStack = [];\n\n if (optPositionToRecordFailures !== undefined) {\n this.positionToRecordFailures = optPositionToRecordFailures;\n this.recordedFailures = Object.create(null);\n }\n}\n\nMatchState.prototype = {\n posToOffset(pos) {\n return pos - this._posStack[this._posStack.length - 1];\n },\n\n enterApplication(posInfo, app) {\n this._posStack.push(this.inputStream.pos);\n this._applicationStack.push(app);\n this.inLexifiedContextStack.push(false);\n posInfo.enter(app);\n this._rightmostFailurePositionStack.push(this.rightmostFailurePosition);\n this.rightmostFailurePosition = -1;\n },\n\n exitApplication(posInfo, optNode) {\n const origPos = this._posStack.pop();\n this._applicationStack.pop();\n this.inLexifiedContextStack.pop();\n posInfo.exit();\n\n this.rightmostFailurePosition = Math.max(\n this.rightmostFailurePosition,\n this._rightmostFailurePositionStack.pop()\n );\n\n if (optNode) {\n this.pushBinding(optNode, origPos);\n }\n },\n\n enterLexifiedContext() {\n this.inLexifiedContextStack.push(true);\n },\n\n exitLexifiedContext() {\n this.inLexifiedContextStack.pop();\n },\n\n currentApplication() {\n return this._applicationStack[this._applicationStack.length - 1];\n },\n\n inSyntacticContext() {\n const currentApplication = this.currentApplication();\n if (currentApplication) {\n return currentApplication.isSyntactic() && !this.inLexifiedContext();\n } else {\n // The top-level context is syntactic if the start application is.\n return this.startExpr.factors[0].isSyntactic();\n }\n },\n\n inLexifiedContext() {\n return this.inLexifiedContextStack[this.inLexifiedContextStack.length - 1];\n },\n\n skipSpaces() {\n this.pushFailuresInfo();\n this.eval(applySpaces);\n this.popBinding();\n this.popFailuresInfo();\n return this.inputStream.pos;\n },\n\n skipSpacesIfInSyntacticContext() {\n return this.inSyntacticContext() ? this.skipSpaces() : this.inputStream.pos;\n },\n\n maybeSkipSpacesBefore(expr) {\n if (expr instanceof pexprs.Apply && expr.isSyntactic()) {\n return this.skipSpaces();\n } else if (expr.allowsSkippingPrecedingSpace() && expr !== applySpaces) {\n return this.skipSpacesIfInSyntacticContext();\n } else {\n return this.inputStream.pos;\n }\n },\n\n pushBinding(node, origPos) {\n this._bindings.push(node);\n this._bindingOffsets.push(this.posToOffset(origPos));\n },\n\n popBinding() {\n this._bindings.pop();\n this._bindingOffsets.pop();\n },\n\n numBindings() {\n return this._bindings.length;\n },\n\n truncateBindings(newLength) {\n // Yes, this is this really faster than setting the `length` property (tested with\n // bin/es5bench on Node v6.1.0).\n // Update 2021-10-25: still true on v14.15.5 — it's ~20% speedup on es5bench.\n while (this._bindings.length > newLength) {\n this.popBinding();\n }\n },\n\n getCurrentPosInfo() {\n return this.getPosInfo(this.inputStream.pos);\n },\n\n getPosInfo(pos) {\n let posInfo = this.memoTable[pos];\n if (!posInfo) {\n posInfo = this.memoTable[pos] = new PosInfo();\n }\n return posInfo;\n },\n\n processFailure(pos, expr) {\n this.rightmostFailurePosition = Math.max(this.rightmostFailurePosition, pos);\n\n if (this.recordedFailures && pos === this.positionToRecordFailures) {\n const app = this.currentApplication();\n if (app) {\n // Substitute parameters with the actual pexprs that were passed to\n // the current rule.\n expr = expr.substituteParams(app.args);\n } else {\n // This branch is only reached for the \"end-check\" that is\n // performed after the top-level application. In that case,\n // expr === pexprs.end so there is no need to substitute\n // parameters.\n }\n\n this.recordFailure(expr.toFailure(this.grammar), false);\n }\n },\n\n recordFailure(failure, shouldCloneIfNew) {\n const key = failure.toKey();\n if (!this.recordedFailures[key]) {\n this.recordedFailures[key] = shouldCloneIfNew ? failure.clone() : failure;\n } else if (this.recordedFailures[key].isFluffy() && !failure.isFluffy()) {\n this.recordedFailures[key].clearFluffy();\n }\n },\n\n recordFailures(failures, shouldCloneIfNew) {\n Object.keys(failures).forEach(key => {\n this.recordFailure(failures[key], shouldCloneIfNew);\n });\n },\n\n cloneRecordedFailures() {\n if (!this.recordedFailures) {\n return undefined;\n }\n\n const ans = Object.create(null);\n Object.keys(this.recordedFailures).forEach(key => {\n ans[key] = this.recordedFailures[key].clone();\n });\n return ans;\n },\n\n getRightmostFailurePosition() {\n return this.rightmostFailurePosition;\n },\n\n _getRightmostFailureOffset() {\n return this.rightmostFailurePosition >= 0 ?\n this.posToOffset(this.rightmostFailurePosition) :\n -1;\n },\n\n // Returns the memoized trace entry for `expr` at `pos`, if one exists, `null` otherwise.\n getMemoizedTraceEntry(pos, expr) {\n const posInfo = this.memoTable[pos];\n if (posInfo && expr.ruleName) {\n const memoRec = posInfo.memo[expr.toMemoKey()];\n if (memoRec && memoRec.traceEntry) {\n const entry = memoRec.traceEntry.cloneWithExpr(expr);\n entry.isMemoized = true;\n return entry;\n }\n }\n return null;\n },\n\n // Returns a new trace entry, with the currently active trace array as its children.\n getTraceEntry(pos, expr, succeeded, bindings) {\n if (expr instanceof pexprs.Apply) {\n const app = this.currentApplication();\n const actuals = app ? app.args : [];\n expr = expr.substituteParams(actuals);\n }\n return (\n this.getMemoizedTraceEntry(pos, expr) ||\n new Trace(this.input, pos, this.inputStream.pos, expr, succeeded, bindings, this.trace)\n );\n },\n\n isTracing() {\n return !!this.trace;\n },\n\n hasNecessaryInfo(memoRec) {\n if (this.trace && !memoRec.traceEntry) {\n return false;\n }\n\n if (\n this.recordedFailures &&\n this.inputStream.pos + memoRec.rightmostFailureOffset === this.positionToRecordFailures\n ) {\n return !!memoRec.failuresAtRightmostPosition;\n }\n\n return true;\n },\n\n useMemoizedResult(origPos, memoRec) {\n if (this.trace) {\n this.trace.push(memoRec.traceEntry);\n }\n\n const memoRecRightmostFailurePosition =\n this.inputStream.pos + memoRec.rightmostFailureOffset;\n this.rightmostFailurePosition = Math.max(\n this.rightmostFailurePosition,\n memoRecRightmostFailurePosition\n );\n if (\n this.recordedFailures &&\n this.positionToRecordFailures === memoRecRightmostFailurePosition &&\n memoRec.failuresAtRightmostPosition\n ) {\n this.recordFailures(memoRec.failuresAtRightmostPosition, true);\n }\n\n this.inputStream.examinedLength = Math.max(\n this.inputStream.examinedLength,\n memoRec.examinedLength + origPos\n );\n\n if (memoRec.value) {\n this.inputStream.pos += memoRec.matchLength;\n this.pushBinding(memoRec.value, origPos);\n return true;\n }\n return false;\n },\n\n // Evaluate `expr` and return `true` if it succeeded, `false` otherwise. On success, `bindings`\n // will have `expr.getArity()` more elements than before, and the input stream's position may\n // have increased. On failure, `bindings` and position will be unchanged.\n eval(expr) {\n const {inputStream} = this;\n const origNumBindings = this._bindings.length;\n\n let origRecordedFailures;\n if (this.recordedFailures) {\n origRecordedFailures = this.recordedFailures;\n this.recordedFailures = Object.create(null);\n }\n\n const origPos = inputStream.pos;\n const memoPos = this.maybeSkipSpacesBefore(expr);\n\n let origTrace;\n if (this.trace) {\n origTrace = this.trace;\n this.trace = [];\n }\n\n // Do the actual evaluation.\n const ans = expr.eval(this);\n\n if (this.trace) {\n const bindings = this._bindings.slice(origNumBindings);\n const traceEntry = this.getTraceEntry(memoPos, expr, ans, bindings);\n traceEntry.isImplicitSpaces = expr === applySpaces;\n traceEntry.isRootNode = expr === this.startExpr;\n origTrace.push(traceEntry);\n this.trace = origTrace;\n }\n\n if (ans) {\n if (this.recordedFailures && inputStream.pos === this.positionToRecordFailures) {\n Object.keys(this.recordedFailures).forEach(key => {\n this.recordedFailures[key].makeFluffy();\n });\n }\n } else {\n // Reset the position and the bindings.\n inputStream.pos = origPos;\n this.truncateBindings(origNumBindings);\n }\n\n if (this.recordedFailures) {\n this.recordFailures(origRecordedFailures, false);\n }\n\n // The built-in experimentalApplySyntactic rule needs special handling: we want to skip\n // trailing spaces, just as with the top-level application of a syntactic rule.\n if (expr === builtInApplySyntacticBody) {\n this.skipSpaces();\n }\n\n return ans;\n },\n\n getMatchResult() {\n this.eval(this.startExpr);\n let rightmostFailures;\n if (this.recordedFailures) {\n rightmostFailures = Object.keys(this.recordedFailures).map(\n key => this.recordedFailures[key]\n );\n }\n return new MatchResult(\n this.matcher,\n this.input,\n this.startExpr,\n this._bindings[0],\n this._bindingOffsets[0],\n this.rightmostFailurePosition,\n rightmostFailures\n );\n },\n\n getTrace() {\n this.trace = [];\n const matchResult = this.getMatchResult();\n\n // The trace node for the start rule is always the last entry. If it is a syntactic rule,\n // the first entry is for an application of 'spaces'.\n // TODO(pdubroy): Clean this up by introducing a special `Match<startAppl>` rule, which will\n // ensure that there is always a single root trace node.\n const rootTrace = this.trace[this.trace.length - 1];\n rootTrace.result = matchResult;\n return rootTrace;\n },\n\n pushFailuresInfo() {\n this._rightmostFailurePositionStack.push(this.rightmostFailurePosition);\n this._recordedFailuresStack.push(this.recordedFailures);\n },\n\n popFailuresInfo() {\n this.rightmostFailurePosition = this._rightmostFailurePositionStack.pop();\n this.recordedFailures = this._recordedFailuresStack.pop();\n },\n};\n\n// --------------------------------------------------------------------\n// Exports\n// --------------------------------------------------------------------\n\nmodule.exports = MatchState;\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst MatchState = require('./MatchState');\n\nconst pexprs = require('./pexprs');\n\n// --------------------------------------------------------------------\n// Private stuff\n// --------------------------------------------------------------------\n\nfunction Matcher(grammar) {\n this.grammar = grammar;\n this.memoTable = [];\n this.input = '';\n}\n\nMatcher.prototype.getInput = function() {\n return this.input;\n};\n\nMatcher.prototype.setInput = function(str) {\n if (this.input !== str) {\n this.replaceInputRange(0, this.input.length, str);\n }\n return this;\n};\n\nMatcher.prototype.replaceInputRange = function(startIdx, endIdx, str) {\n const currentInput = this.input;\n if (\n startIdx < 0 ||\n startIdx > currentInput.length ||\n endIdx < 0 ||\n endIdx > currentInput.length ||\n startIdx > endIdx\n ) {\n throw new Error('Invalid indices: ' + startIdx + ' and ' + endIdx);\n }\n\n // update input\n this.input = currentInput.slice(0, startIdx) + str + currentInput.slice(endIdx);\n\n // update memo table (similar to the above)\n const restOfMemoTable = this.memoTable.slice(endIdx);\n this.memoTable.length = startIdx;\n for (let idx = 0; idx < str.length; idx++) {\n this.memoTable.push(undefined);\n }\n restOfMemoTable.forEach(function(posInfo) {\n this.memoTable.push(posInfo);\n }, this);\n\n // Invalidate memoRecs\n for (let pos = 0; pos < startIdx; pos++) {\n const posInfo = this.memoTable[pos];\n if (posInfo) {\n posInfo.clearObsoleteEntries(pos, startIdx);\n }\n }\n\n return this;\n};\n\nMatcher.prototype.match = function(optStartApplicationStr) {\n return this._match(this._getStartExpr(optStartApplicationStr), false);\n};\n\nMatcher.prototype.trace = function(optStartApplicationStr) {\n return this._match(this._getStartExpr(optStartApplicationStr), true);\n};\n\nMatcher.prototype._match = function(startExpr, tracing, optPositionToRecordFailures) {\n const state = new MatchState(this, startExpr, optPositionToRecordFailures);\n return tracing ? state.getTrace() : state.getMatchResult();\n};\n\n/*\n Returns the starting expression for this Matcher's associated grammar. If `optStartApplicationStr`\n is specified, it is a string expressing a rule application in the grammar. If not specified, the\n grammar's default start rule will be used.\n*/\nMatcher.prototype._getStartExpr = function(optStartApplicationStr) {\n const applicationStr = optStartApplicationStr || this.grammar.defaultStartRule;\n if (!applicationStr) {\n throw new Error('Missing start rule argument -- the grammar has no default start rule.');\n }\n\n const startApp = this.grammar.parseApplication(applicationStr);\n return new pexprs.Seq([startApp, pexprs.end]);\n};\n\n// --------------------------------------------------------------------\n// Exports\n// --------------------------------------------------------------------\n\nmodule.exports = Matcher;\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst InputStream = require('./InputStream');\nconst {IterationNode} = require('./nodes');\nconst MatchResult = require('./MatchResult');\nconst common = require('./common');\nconst errors = require('./errors');\nconst util = require('./util');\n\n// --------------------------------------------------------------------\n// Private stuff\n// --------------------------------------------------------------------\n\nconst globalActionStack = [];\nlet prototypeGrammar;\nlet prototypeGrammarSemantics;\n\nconst hasOwnProperty = (x, prop) => Object.prototype.hasOwnProperty.call(x, prop);\n\n// ----------------- Wrappers -----------------\n\n// Wrappers decorate CST nodes with all of the functionality (i.e., operations and attributes)\n// provided by a Semantics (see below). `Wrapper` is the abstract superclass of all wrappers. A\n// `Wrapper` must have `_node` and `_semantics` instance variables, which refer to the CST node and\n// Semantics (resp.) for which it was created, and a `_childWrappers` instance variable which is\n// used to cache the wrapper instances that are created for its child nodes. Setting these instance\n// variables is the responsibility of the constructor of each Semantics-specific subclass of\n// `Wrapper`.\nclass Wrapper {\n constructor(node, sourceInterval, baseInterval) {\n this._node = node;\n this.source = sourceInterval;\n\n // The interval that the childOffsets of `node` are relative to. It should be the source\n // of the closest Nonterminal node.\n this._baseInterval = baseInterval;\n\n if (node.isNonterminal()) {\n common.assert(sourceInterval === baseInterval);\n }\n this._childWrappers = [];\n }\n\n toString() {\n return '[semantics wrapper for ' + this._node.grammar.name + ']';\n }\n\n // This is used by ohm editor to display a node wrapper appropriately.\n toJSON() {\n return this.toString();\n }\n\n _forgetMemoizedResultFor(attributeName) {\n // Remove the memoized attribute from the cstNode and all its children.\n delete this._node[this._semantics.attributeKeys[attributeName]];\n this.children.forEach(child => {\n child._forgetMemoizedResultFor(attributeName);\n });\n }\n\n // Returns the wrapper of the specified child node. Child wrappers are created lazily and\n // cached in the parent wrapper's `_childWrappers` instance variable.\n child(idx) {\n if (!(0 <= idx && idx < this._node.numChildren())) {\n // TODO: Consider throwing an exception here.\n return undefined;\n }\n let childWrapper = this._childWrappers[idx];\n if (!childWrapper) {\n const childNode = this._node.childAt(idx);\n const offset = this._node.childOffsets[idx];\n\n const source = this._baseInterval.subInterval(offset, childNode.matchLength);\n const base = childNode.isNonterminal() ? source : this._baseInterval;\n childWrapper = this._childWrappers[idx] = this._semantics.wrap(childNode, source, base);\n }\n return childWrapper;\n }\n\n // Returns an array containing the wrappers of all of the children of the node associated\n // with this wrapper.\n _children() {\n // Force the creation of all child wrappers\n for (let idx = 0; idx < this._node.numChildren(); idx++) {\n this.child(idx);\n }\n return this._childWrappers;\n }\n\n // Returns `true` if the CST node associated with this wrapper corresponds to an iteration\n // expression, i.e., a Kleene-*, Kleene-+, or an optional. Returns `false` otherwise.\n isIteration() {\n return this._node.isIteration();\n }\n\n // Returns `true` if the CST node associated with this wrapper is a terminal node, `false`\n // otherwise.\n isTerminal() {\n return this._node.isTerminal();\n }\n\n // Returns `true` if the CST node associated with this wrapper is a nonterminal node, `false`\n // otherwise.\n isNonterminal() {\n return this._node.isNonterminal();\n }\n\n // Returns `true` if the CST node associated with this wrapper is a nonterminal node\n // corresponding to a syntactic rule, `false` otherwise.\n isSyntactic() {\n return this.isNonterminal() && this._node.isSyntactic();\n }\n\n // Returns `true` if the CST node associated with this wrapper is a nonterminal node\n // corresponding to a lexical rule, `false` otherwise.\n isLexical() {\n return this.isNonterminal() && this._node.isLexical();\n }\n\n // Returns `true` if the CST node associated with this wrapper is an iterator node\n // having either one or no child (? operator), `false` otherwise.\n // Otherwise, throws an exception.\n isOptional() {\n return this._node.isOptional();\n }\n\n // Create a new _iter wrapper in the same semantics as this wrapper.\n iteration(optChildWrappers) {\n const childWrappers = optChildWrappers || [];\n\n const childNodes = childWrappers.map(c => c._node);\n const iter = new IterationNode(this._node.grammar, childNodes, [], -1, false);\n\n const wrapper = this._semantics.wrap(iter, null, null);\n wrapper._childWrappers = childWrappers;\n return wrapper;\n }\n\n // Returns an array containing the children of this CST node.\n get children() {\n return this._children();\n }\n\n // Returns the name of grammar rule that created this CST node.\n get ctorName() {\n return this._node.ctorName;\n }\n\n // TODO: Remove this eventually (deprecated in v0.12).\n get interval() {\n throw new Error('The `interval` property is deprecated -- use `source` instead');\n }\n\n // Returns the number of children of this CST node.\n get numChildren() {\n return this._node.numChildren();\n }\n\n // Returns the primitive value of this CST node, if it's a terminal node. Otherwise,\n // throws an exception.\n // DEPRECATED: Use `sourceString` instead.\n get primitiveValue() {\n if (this.isTerminal()) {\n return this._node.primitiveValue;\n }\n throw new TypeError(\n \"tried to access the 'primitiveValue' attribute of a non-terminal CST node\"\n );\n }\n\n // Returns the contents of the input stream consumed by this CST node.\n get sourceString() {\n return this.source.contents;\n }\n}\n\n// ----------------- Semantics -----------------\n\n// A Semantics is a container for a family of Operations and Attributes for a given grammar.\n// Semantics enable modularity (different clients of a grammar can create their set of operations\n// and attributes in isolation) and extensibility even when operations and attributes are mutually-\n// recursive. This constructor should not be called directly except from\n// `Semantics.createSemantics`. The normal ways to create a Semantics, given a grammar 'g', are\n// `g.createSemantics()` and `g.extendSemantics(parentSemantics)`.\nfunction Semantics(grammar, superSemantics) {\n const self = this;\n this.grammar = grammar;\n this.checkedActionDicts = false;\n\n // Constructor for wrapper instances, which are passed as the arguments to the semantic actions\n // of an operation or attribute. Operations and attributes require double dispatch: the semantic\n // action is chosen based on both the node's type and the semantics. Wrappers ensure that\n // the `execute` method is called with the correct (most specific) semantics object as an\n // argument.\n this.Wrapper = class extends (superSemantics ? superSemantics.Wrapper : Wrapper) {\n constructor(node, sourceInterval, baseInterval) {\n super(node, sourceInterval, baseInterval);\n self.checkActionDictsIfHaventAlready();\n this._semantics = self;\n }\n };\n\n this.super = superSemantics;\n if (superSemantics) {\n if (!(grammar.equals(this.super.grammar) || grammar._inheritsFrom(this.super.grammar))) {\n throw new Error(\n \"Cannot extend a semantics for grammar '\" +\n this.super.grammar.name +\n \"' for use with grammar '\" +\n grammar.name +\n \"' (not a sub-grammar)\"\n );\n }\n this.operations = Object.create(this.super.operations);\n this.attributes = Object.create(this.super.attributes);\n this.attributeKeys = Object.create(null);\n\n // Assign unique symbols for each of the attributes inherited from the super-semantics so that\n // they are memoized independently.\n // eslint-disable-next-line guard-for-in\n for (const attributeName in this.attributes) {\n Object.defineProperty(this.attributeKeys, attributeName, {\n value: util.uniqueId(attributeName),\n });\n }\n } else {\n this.operations = Object.create(null);\n this.attributes = Object.create(null);\n this.attributeKeys = Object.create(null);\n }\n}\n\nSemantics.prototype.toString = function() {\n return '[semantics for ' + this.grammar.name + ']';\n};\n\nSemantics.prototype.checkActionDictsIfHaventAlready = function() {\n if (!this.checkedActionDicts) {\n this.checkActionDicts();\n this.checkedActionDicts = true;\n }\n};\n\n// Checks that the action dictionaries for all operations and attributes in this semantics,\n// including the ones that were inherited from the super-semantics, agree with the grammar.\n// Throws an exception if one or more of them doesn't.\nSemantics.prototype.checkActionDicts = function() {\n let name;\n // eslint-disable-next-line guard-for-in\n for (name in this.operations) {\n this.operations[name].checkActionDict(this.grammar);\n }\n // eslint-disable-next-line guard-for-in\n for (name in this.attributes) {\n this.attributes[name].checkActionDict(this.grammar);\n }\n};\n\nSemantics.prototype.toRecipe = function(semanticsOnly) {\n function hasSuperSemantics(s) {\n return s.super !== Semantics.BuiltInSemantics._getSemantics();\n }\n\n let str = '(function(g) {\\n';\n if (hasSuperSemantics(this)) {\n str += ' var semantics = ' + this.super.toRecipe(true) + '(g';\n\n const superSemanticsGrammar = this.super.grammar;\n let relatedGrammar = this.grammar;\n while (relatedGrammar !== superSemanticsGrammar) {\n str += '.superGrammar';\n relatedGrammar = relatedGrammar.superGrammar;\n }\n\n str += ');\\n';\n str += ' return g.extendSemantics(semantics)';\n } else {\n str += ' return g.createSemantics()';\n }\n ['Operation', 'Attribute'].forEach(type => {\n const semanticOperations = this[type.toLowerCase() + 's'];\n Object.keys(semanticOperations).forEach(name => {\n const {actionDict, formals, builtInDefault} = semanticOperations[name];\n\n let signature = name;\n if (formals.length > 0) {\n signature += '(' + formals.join(', ') + ')';\n }\n\n let method;\n if (hasSuperSemantics(this) && this.super[type.toLowerCase() + 's'][name]) {\n method = 'extend' + type;\n } else {\n method = 'add' + type;\n }\n str += '\\n .' + method + '(' + JSON.stringify(signature) + ', {';\n\n const srcArray = [];\n Object.keys(actionDict).forEach(actionName => {\n if (actionDict[actionName] !== builtInDefault) {\n let source = actionDict[actionName].toString().trim();\n\n // Convert method shorthand to plain old function syntax.\n // https://github.com/harc/ohm/issues/263\n source = source.replace(/^.*\\(/, 'function(');\n\n srcArray.push('\\n ' + JSON.stringify(actionName) + ': ' + source);\n }\n });\n str += srcArray.join(',') + '\\n })';\n });\n });\n str += ';\\n })';\n\n if (!semanticsOnly) {\n str =\n '(function() {\\n' +\n ' var grammar = this.fromRecipe(' +\n this.grammar.toRecipe() +\n ');\\n' +\n ' var semantics = ' +\n str +\n '(grammar);\\n' +\n ' return semantics;\\n' +\n '});\\n';\n }\n\n return str;\n};\n\nfunction parseSignature(signature, type) {\n if (!prototypeGrammar) {\n // The Operations and Attributes grammar won't be available while Ohm is loading,\n // but we can get away the following simplification b/c none of the operations\n // that are used while loading take arguments.\n common.assert(signature.indexOf('(') === -1);\n return {\n name: signature,\n formals: [],\n };\n }\n\n const r = prototypeGrammar.match(\n signature,\n type === 'operation' ? 'OperationSignature' : 'AttributeSignature'\n );\n if (r.failed()) {\n throw new Error(r.message);\n }\n\n return prototypeGrammarSemantics(r).parse();\n}\n\nfunction newDefaultAction(type, name, doIt) {\n return function(...children) {\n const thisThing = this._semantics.operations[name] || this._semantics.attributes[name];\n const args = thisThing.formals.map(formal => this.args[formal]);\n\n if (!this.isIteration() && children.length === 1) {\n // This CST node corresponds to a non-terminal in the grammar (e.g., AddExpr). The fact that\n // we got here means that this action dictionary doesn't have an action for this particular\n // non-terminal or a generic `_nonterminal` action.\n // As a convenience, if this node only has one child, we just return the result of applying\n // this operation / attribute to the child node.\n return doIt.apply(children[0], args);\n } else {\n // Otherwise, we throw an exception to let the programmer know that we don't know what\n // to do with this node.\n throw errors.missingSemanticAction(this.ctorName, name, type, globalActionStack);\n }\n };\n}\n\nSemantics.prototype.addOperationOrAttribute = function(type, signature, actionDict) {\n const typePlural = type + 's';\n\n const parsedNameAndFormalArgs = parseSignature(signature, type);\n const {name} = parsedNameAndFormalArgs;\n const {formals} = parsedNameAndFormalArgs;\n\n // TODO: check that there are no duplicate formal arguments\n\n this.assertNewName(name, type);\n\n // Create the action dictionary for this operation / attribute that contains a `_default` action\n // which defines the default behavior of iteration, terminal, and non-terminal nodes...\n const builtInDefault = newDefaultAction(type, name, doIt);\n const realActionDict = {_default: builtInDefault};\n // ... and add in the actions supplied by the programmer, which may override some or all of the\n // default ones.\n Object.keys(actionDict).forEach(name => {\n realActionDict[name] = actionDict[name];\n });\n\n const entry =\n type === 'operation' ?\n new Operation(name, formals, realActionDict, builtInDefault) :\n new Attribute(name, realActionDict, builtInDefault);\n\n // The following check is not strictly necessary (it will happen later anyway) but it's better to\n // catch errors early.\n entry.checkActionDict(this.grammar);\n\n this[typePlural][name] = entry;\n\n function doIt(...args) {\n // Dispatch to most specific version of this operation / attribute -- it may have been\n // overridden by a sub-semantics.\n const thisThing = this._semantics[typePlural][name];\n\n // Check that the caller passed the correct number of arguments.\n if (arguments.length !== thisThing.formals.length) {\n throw new Error(\n 'Invalid number of arguments passed to ' +\n name +\n ' ' +\n type +\n ' (expected ' +\n thisThing.formals.length +\n ', got ' +\n arguments.length +\n ')'\n );\n }\n\n // Create an \"arguments object\" from the arguments that were passed to this\n // operation / attribute.\n const argsObj = Object.create(null);\n for (const [idx, val] of Object.entries(args)) {\n const formal = thisThing.formals[idx];\n argsObj[formal] = val;\n }\n\n const oldArgs = this.args;\n this.args = argsObj;\n const ans = thisThing.execute(this._semantics, this);\n this.args = oldArgs;\n return ans;\n }\n\n if (type === 'operation') {\n this.Wrapper.prototype[name] = doIt;\n this.Wrapper.prototype[name].toString = function() {\n return '[' + name + ' operation]';\n };\n } else {\n Object.defineProperty(this.Wrapper.prototype, name, {\n get: doIt,\n configurable: true, // So the property can be deleted.\n });\n Object.defineProperty(this.attributeKeys, name, {\n value: util.uniqueId(name),\n });\n }\n};\n\nSemantics.prototype.extendOperationOrAttribute = function(type, name, actionDict) {\n const typePlural = type + 's';\n\n // Make sure that `name` really is just a name, i.e., that it doesn't also contain formals.\n parseSignature(name, 'attribute');\n\n if (!(this.super && name in this.super[typePlural])) {\n throw new Error(\n 'Cannot extend ' +\n type +\n \" '\" +\n name +\n \"': did not inherit an \" +\n type +\n ' with that name'\n );\n }\n if (hasOwnProperty(this[typePlural], name)) {\n throw new Error('Cannot extend ' + type + \" '\" + name + \"' again\");\n }\n\n // Create a new operation / attribute whose actionDict delegates to the super operation /\n // attribute's actionDict, and which has all the keys from `inheritedActionDict`.\n const inheritedFormals = this[typePlural][name].formals;\n const inheritedActionDict = this[typePlural][name].actionDict;\n const newActionDict = Object.create(inheritedActionDict);\n Object.keys(actionDict).forEach(name => {\n newActionDict[name] = actionDict[name];\n });\n\n this[typePlural][name] =\n type === 'operation' ?\n new Operation(name, inheritedFormals, newActionDict) :\n new Attribute(name, newActionDict);\n\n // The following check is not strictly necessary (it will happen later anyway) but it's better to\n // catch errors early.\n this[typePlural][name].checkActionDict(this.grammar);\n};\n\nSemantics.prototype.assertNewName = function(name, type) {\n if (hasOwnProperty(Wrapper.prototype, name)) {\n throw new Error('Cannot add ' + type + \" '\" + name + \"': that's a reserved name\");\n }\n if (name in this.operations) {\n throw new Error(\n 'Cannot add ' + type + \" '\" + name + \"': an operation with that name already exists\"\n );\n }\n if (name in this.attributes) {\n throw new Error(\n 'Cannot add ' + type + \" '\" + name + \"': an attribute with that name already exists\"\n );\n }\n};\n\n// Returns a wrapper for the given CST `node` in this semantics.\n// If `node` is already a wrapper, returns `node` itself. // TODO: why is this needed?\nSemantics.prototype.wrap = function(node, source, optBaseInterval) {\n const baseInterval = optBaseInterval || source;\n return node instanceof this.Wrapper ? node : new this.Wrapper(node, source, baseInterval);\n};\n\n// Creates a new Semantics instance for `grammar`, inheriting operations and attributes from\n// `optSuperSemantics`, if it is specified. Returns a function that acts as a proxy for the new\n// Semantics instance. When that function is invoked with a CST node as an argument, it returns\n// a wrapper for that node which gives access to the operations and attributes provided by this\n// semantics.\nSemantics.createSemantics = function(grammar, optSuperSemantics) {\n const s = new Semantics(\n grammar,\n optSuperSemantics !== undefined ?\n optSuperSemantics :\n Semantics.BuiltInSemantics._getSemantics()\n );\n\n // To enable clients to invoke a semantics like a function, return a function that acts as a proxy\n // for `s`, which is the real `Semantics` instance.\n const proxy = function ASemantics(matchResult) {\n if (!(matchResult instanceof MatchResult)) {\n throw new TypeError(\n 'Semantics expected a MatchResult, but got ' +\n common.unexpectedObjToString(matchResult)\n );\n }\n if (matchResult.failed()) {\n throw new TypeError('cannot apply Semantics to ' + matchResult.toString());\n }\n\n const cst = matchResult._cst;\n if (cst.grammar !== grammar) {\n throw new Error(\n \"Cannot use a MatchResult from grammar '\" +\n cst.grammar.name +\n \"' with a semantics for '\" +\n grammar.name +\n \"'\"\n );\n }\n const inputStream = new InputStream(matchResult.input);\n return s.wrap(cst, inputStream.interval(matchResult._cstOffset, matchResult.input.length));\n };\n\n // Forward public methods from the proxy to the semantics instance.\n proxy.addOperation = function(signature, actionDict) {\n s.addOperationOrAttribute('operation', signature, actionDict);\n return proxy;\n };\n proxy.extendOperation = function(name, actionDict) {\n s.extendOperationOrAttribute('operation', name, actionDict);\n return proxy;\n };\n proxy.addAttribute = function(name, actionDict) {\n s.addOperationOrAttribute('attribute', name, actionDict);\n return proxy;\n };\n proxy.extendAttribute = function(name, actionDict) {\n s.extendOperationOrAttribute('attribute', name, actionDict);\n return proxy;\n };\n proxy._getActionDict = function(operationOrAttributeName) {\n const action =\n s.operations[operationOrAttributeName] || s.attributes[operationOrAttributeName];\n if (!action) {\n throw new Error(\n '\"' +\n operationOrAttributeName +\n '\" is not a valid operation or attribute ' +\n 'name in this semantics for \"' +\n grammar.name +\n '\"'\n );\n }\n return action.actionDict;\n };\n proxy._remove = function(operationOrAttributeName) {\n let semantic;\n if (operationOrAttributeName in s.operations) {\n semantic = s.operations[operationOrAttributeName];\n delete s.operations[operationOrAttributeName];\n } else if (operationOrAttributeName in s.attributes) {\n semantic = s.attributes[operationOrAttributeName];\n delete s.attributes[operationOrAttributeName];\n }\n delete s.Wrapper.prototype[operationOrAttributeName];\n return semantic;\n };\n proxy.getOperationNames = function() {\n return Object.keys(s.operations);\n };\n proxy.getAttributeNames = function() {\n return Object.keys(s.attributes);\n };\n proxy.getGrammar = function() {\n return s.grammar;\n };\n proxy.toRecipe = function(semanticsOnly) {\n return s.toRecipe(semanticsOnly);\n };\n\n // Make the proxy's toString() work.\n proxy.toString = s.toString.bind(s);\n\n // Returns the semantics for the proxy.\n proxy._getSemantics = function() {\n return s;\n };\n\n return proxy;\n};\n\n// ----------------- Operation -----------------\n\n// An Operation represents a function to be applied to a concrete syntax tree (CST) -- it's very\n// similar to a Visitor (http://en.wikipedia.org/wiki/Visitor_pattern). An operation is executed by\n// recursively walking the CST, and at each node, invoking the matching semantic action from\n// `actionDict`. See `Operation.prototype.execute` for details of how a CST node's matching semantic\n// action is found.\nclass Operation {\n constructor(name, formals, actionDict, builtInDefault) {\n this.name = name;\n this.formals = formals;\n this.actionDict = actionDict;\n this.builtInDefault = builtInDefault;\n }\n\n checkActionDict(grammar) {\n grammar._checkTopDownActionDict(this.typeName, this.name, this.actionDict);\n }\n\n // Execute this operation on the CST node associated with `nodeWrapper` in the context of the\n // given Semantics instance.\n execute(semantics, nodeWrapper) {\n try {\n // Look for a semantic action whose name matches the node's constructor name, which is either\n // the name of a rule in the grammar, or '_terminal' (for a terminal node), or '_iter' (for an\n // iteration node).\n const {ctorName} = nodeWrapper._node;\n let actionFn = this.actionDict[ctorName];\n if (actionFn) {\n globalActionStack.push([this, ctorName]);\n return actionFn.apply(nodeWrapper, nodeWrapper._children());\n }\n\n // The action dictionary does not contain a semantic action for this specific type of node.\n // If this is a nonterminal node and the programmer has provided a `_nonterminal` semantic\n // action, we invoke it:\n if (nodeWrapper.isNonterminal()) {\n actionFn = this.actionDict._nonterminal;\n if (actionFn) {\n globalActionStack.push([this, '_nonterminal', ctorName]);\n return actionFn.apply(nodeWrapper, nodeWrapper._children());\n }\n }\n\n // Otherwise, we invoke the '_default' semantic action.\n globalActionStack.push([this, 'default action', ctorName]);\n return this.actionDict._default.apply(nodeWrapper, nodeWrapper._children());\n } finally {\n globalActionStack.pop();\n }\n }\n}\n\nOperation.prototype.typeName = 'operation';\n\n// ----------------- Attribute -----------------\n\n// Attributes are Operations whose results are memoized. This means that, for any given semantics,\n// the semantic action for a CST node will be invoked no more than once.\nclass Attribute extends Operation {\n constructor(name, actionDict, builtInDefault) {\n super(name, [], actionDict, builtInDefault);\n }\n\n execute(semantics, nodeWrapper) {\n const node = nodeWrapper._node;\n const key = semantics.attributeKeys[this.name];\n if (!hasOwnProperty(node, key)) {\n // The following is a super-send -- isn't JS beautiful? :/\n node[key] = Operation.prototype.execute.call(this, semantics, nodeWrapper);\n }\n return node[key];\n }\n}\n\nAttribute.prototype.typeName = 'attribute';\n\n// ----------------- Deferred initialization -----------------\n\nutil.awaitBuiltInRules(builtInRules => {\n const operationsAndAttributesGrammar = require('../dist/operations-and-attributes');\n initBuiltInSemantics(builtInRules);\n initPrototypeParser(operationsAndAttributesGrammar); // requires BuiltInSemantics\n});\n\nfunction initBuiltInSemantics(builtInRules) {\n const actions = {\n empty() {\n return this.iteration();\n },\n nonEmpty(first, _, rest) {\n return this.iteration([first].concat(rest.children));\n },\n };\n\n Semantics.BuiltInSemantics = Semantics.createSemantics(builtInRules, null).addOperation(\n 'asIteration',\n {\n emptyListOf: actions.empty,\n nonemptyListOf: actions.nonEmpty,\n EmptyListOf: actions.empty,\n NonemptyListOf: actions.nonEmpty,\n }\n );\n}\n\nfunction initPrototypeParser(grammar) {\n prototypeGrammarSemantics = grammar.createSemantics().addOperation('parse', {\n AttributeSignature(name) {\n return {\n name: name.parse(),\n formals: [],\n };\n },\n OperationSignature(name, optFormals) {\n return {\n name: name.parse(),\n formals: optFormals.children.map(c => c.parse())[0] || [],\n };\n },\n Formals(oparen, fs, cparen) {\n return fs.asIteration().children.map(c => c.parse());\n },\n name(first, rest) {\n return this.sourceString;\n },\n });\n prototypeGrammar = grammar;\n}\n\n// --------------------------------------------------------------------\n// Exports\n// --------------------------------------------------------------------\n\nmodule.exports = Semantics;\n","var ohm = require('..');\nmodule.exports = ohm.makeRecipe([\"grammar\",{\"source\":\"OperationsAndAttributes {\\n\\n AttributeSignature =\\n name\\n\\n OperationSignature =\\n name Formals?\\n\\n Formals\\n = \\\"(\\\" ListOf<name, \\\",\\\"> \\\")\\\"\\n\\n name (a name)\\n = nameFirst nameRest*\\n\\n nameFirst\\n = \\\"_\\\"\\n | letter\\n\\n nameRest\\n = \\\"_\\\"\\n | alnum\\n\\n}\"},\"OperationsAndAttributes\",null,\"AttributeSignature\",{\"AttributeSignature\":[\"define\",{\"sourceInterval\":[29,58]},null,[],[\"app\",{\"sourceInterval\":[54,58]},\"name\",[]]],\"OperationSignature\":[\"define\",{\"sourceInterval\":[62,100]},null,[],[\"seq\",{\"sourceInterval\":[87,100]},[\"app\",{\"sourceInterval\":[87,91]},\"name\",[]],[\"opt\",{\"sourceInterval\":[92,100]},[\"app\",{\"sourceInterval\":[92,99]},\"Formals\",[]]]]],\"Formals\":[\"define\",{\"sourceInterval\":[104,143]},null,[],[\"seq\",{\"sourceInterval\":[118,143]},[\"terminal\",{\"sourceInterval\":[118,121]},\"(\"],[\"app\",{\"sourceInterval\":[122,139]},\"ListOf\",[[\"app\",{\"sourceInterval\":[129,133]},\"name\",[]],[\"terminal\",{\"sourceInterval\":[135,138]},\",\"]]],[\"terminal\",{\"sourceInterval\":[140,143]},\")\"]]],\"name\":[\"define\",{\"sourceInterval\":[147,187]},\"a name\",[],[\"seq\",{\"sourceInterval\":[168,187]},[\"app\",{\"sourceInterval\":[168,177]},\"nameFirst\",[]],[\"star\",{\"sourceInterval\":[178,187]},[\"app\",{\"sourceInterval\":[178,186]},\"nameRest\",[]]]]],\"nameFirst\":[\"define\",{\"sourceInterval\":[191,223]},null,[],[\"alt\",{\"sourceInterval\":[207,223]},[\"terminal\",{\"sourceInterval\":[207,210]},\"_\"],[\"app\",{\"sourceInterval\":[217,223]},\"letter\",[]]]],\"nameRest\":[\"define\",{\"sourceInterval\":[227,257]},null,[],[\"alt\",{\"sourceInterval\":[242,257]},[\"terminal\",{\"sourceInterval\":[242,245]},\"_\"],[\"app\",{\"sourceInterval\":[252,257]},\"alnum\",[]]]]}]);\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst CaseInsensitiveTerminal = require('./CaseInsensitiveTerminal');\nconst Matcher = require('./Matcher');\nconst Semantics = require('./Semantics');\nconst common = require('./common');\nconst errors = require('./errors');\nconst pexprs = require('./pexprs');\n\n// --------------------------------------------------------------------\n// Private stuff\n// --------------------------------------------------------------------\n\nconst SPECIAL_ACTION_NAMES = ['_iter', '_terminal', '_nonterminal', '_default'];\n\nfunction getSortedRuleValues(grammar) {\n return Object.keys(grammar.rules)\n .sort()\n .map(name => grammar.rules[name]);\n}\n\n// Until ES2019, JSON was not a valid subset of JavaScript because U+2028 (line separator)\n// and U+2029 (paragraph separator) are allowed in JSON string literals, but not in JS.\n// This function properly encodes those two characters so that the resulting string is\n// represents both valid JSON, and valid JavaScript (for ES2018 and below).\n// See https://v8.dev/features/subsume-json for more details.\nconst jsonToJS = str => str.replace(/\\u2028/g, '\\\\u2028').replace(/\\u2029/g, '\\\\u2029');\n\nfunction Grammar(name, superGrammar, rules, optDefaultStartRule) {\n this.name = name;\n this.superGrammar = superGrammar;\n this.rules = rules;\n if (optDefaultStartRule) {\n if (!(optDefaultStartRule in rules)) {\n throw new Error(\n \"Invalid start rule: '\" +\n optDefaultStartRule +\n \"' is not a rule in grammar '\" +\n name +\n \"'\"\n );\n }\n this.defaultStartRule = optDefaultStartRule;\n }\n}\n\nlet ohmGrammar;\nlet buildGrammar;\n\n// This method is called from main.js once Ohm has loaded.\nGrammar.initApplicationParser = function(grammar, builderFn) {\n ohmGrammar = grammar;\n buildGrammar = builderFn;\n};\n\nGrammar.prototype = {\n matcher() {\n return new Matcher(this);\n },\n\n // Return true if the grammar is a built-in grammar, otherwise false.\n // NOTE: This might give an unexpected result if called before BuiltInRules is defined!\n isBuiltIn() {\n return this === Grammar.ProtoBuiltInRules || this === Grammar.BuiltInRules;\n },\n\n equals(g) {\n if (this === g) {\n return true;\n }\n // Do the cheapest comparisons first.\n if (\n g == null ||\n this.name !== g.name ||\n this.defaultStartRule !== g.defaultStartRule ||\n !(this.superGrammar === g.superGrammar || this.superGrammar.equals(g.superGrammar))\n ) {\n return false;\n }\n const myRules = getSortedRuleValues(this);\n const otherRules = getSortedRuleValues(g);\n return (\n myRules.length === otherRules.length &&\n myRules.every((rule, i) => {\n return (\n rule.description === otherRules[i].description &&\n rule.formals.join(',') === otherRules[i].formals.join(',') &&\n rule.body.toString() === otherRules[i].body.toString()\n );\n })\n );\n },\n\n match(input, optStartApplication) {\n const m = this.matcher();\n m.replaceInputRange(0, 0, input);\n return m.match(optStartApplication);\n },\n\n trace(input, optStartApplication) {\n const m = this.matcher();\n m.replaceInputRange(0, 0, input);\n return m.trace(optStartApplication);\n },\n\n createSemantics() {\n return Semantics.createSemantics(this);\n },\n\n extendSemantics(superSemantics) {\n return Semantics.createSemantics(this, superSemantics._getSemantics());\n },\n\n // Check that every key in `actionDict` corresponds to a semantic action, and that it maps to\n // a function of the correct arity. If not, throw an exception.\n _checkTopDownActionDict(what, name, actionDict) {\n const problems = [];\n\n // eslint-disable-next-line guard-for-in\n for (const k in actionDict) {\n const v = actionDict[k];\n const isSpecialAction = SPECIAL_ACTION_NAMES.includes(k);\n\n if (!isSpecialAction && !(k in this.rules)) {\n problems.push(`'${k}' is not a valid semantic action for '${this.name}'`);\n continue;\n }\n if (typeof v !== 'function') {\n problems.push(`'${k}' must be a function in an action dictionary for '${this.name}'`);\n continue;\n }\n const actual = v.length;\n const expected = this._topDownActionArity(k);\n if (actual !== expected) {\n let details;\n if (k === '_iter' || k === '_nonterminal') {\n details =\n `it should use a rest parameter, e.g. \\`${k}(...children) {}\\`. ` +\n 'NOTE: this is new in Ohm v16 — see https://git.io/Jz4CI for details.';\n } else {\n details = `expected ${expected}, got ${actual}`;\n }\n problems.push(`Semantic action '${k}' has the wrong arity: ${details}`);\n }\n }\n if (problems.length > 0) {\n const prettyProblems = problems.map(problem => '- ' + problem);\n const error = new Error(\n [\n `Found errors in the action dictionary of the '${name}' ${what}:`,\n ...prettyProblems,\n ].join('\\n')\n );\n error.problems = problems;\n throw error;\n }\n },\n\n // Return the expected arity for a semantic action named `actionName`, which\n // is either a rule name or a special action name like '_nonterminal'.\n _topDownActionArity(actionName) {\n // All special actions have an expected arity of 0, though all but _terminal\n // are expected to use the rest parameter syntax (e.g. `_iter(...children)`).\n // This is considered to have arity 0, i.e. `((...args) => {}).length` is 0.\n return SPECIAL_ACTION_NAMES.includes(actionName) ?\n 0 :\n this.rules[actionName].body.getArity();\n },\n\n _inheritsFrom(grammar) {\n let g = this.superGrammar;\n while (g) {\n if (g.equals(grammar, true)) {\n return true;\n }\n g = g.superGrammar;\n }\n return false;\n },\n\n toRecipe(superGrammarExpr = undefined) {\n const metaInfo = {};\n // Include the grammar source if it is available.\n if (this.source) {\n metaInfo.source = this.source.contents;\n }\n\n let startRule = null;\n if (this.defaultStartRule) {\n startRule = this.defaultStartRule;\n }\n\n const rules = {};\n Object.keys(this.rules).forEach(ruleName => {\n const ruleInfo = this.rules[ruleName];\n const {body} = ruleInfo;\n const isDefinition = !this.superGrammar || !this.superGrammar.rules[ruleName];\n\n let operation;\n if (isDefinition) {\n operation = 'define';\n } else {\n operation = body instanceof pexprs.Extend ? 'extend' : 'override';\n }\n\n const metaInfo = {};\n if (ruleInfo.source && this.source) {\n const adjusted = ruleInfo.source.relativeTo(this.source);\n metaInfo.sourceInterval = [adjusted.startIdx, adjusted.endIdx];\n }\n\n const description = isDefinition ? ruleInfo.description : null;\n const bodyRecipe = body.outputRecipe(ruleInfo.formals, this.source);\n\n rules[ruleName] = [\n operation, // \"define\"/\"extend\"/\"override\"\n metaInfo,\n description,\n ruleInfo.formals,\n bodyRecipe,\n ];\n });\n\n // If the caller provided an expression to use for the supergrammar, use that.\n // Otherwise, if the supergrammar is a user grammar, use its recipe inline.\n let superGrammarOutput = 'null';\n if (superGrammarExpr) {\n superGrammarOutput = superGrammarExpr;\n } else if (this.superGrammar && !this.superGrammar.isBuiltIn()) {\n superGrammarOutput = this.superGrammar.toRecipe();\n }\n\n const recipeElements = [\n ...['grammar', metaInfo, this.name].map(JSON.stringify),\n superGrammarOutput,\n ...[startRule, rules].map(JSON.stringify),\n ];\n return jsonToJS(`[${recipeElements.join(',')}]`);\n },\n\n // TODO: Come up with better names for these methods.\n // TODO: Write the analog of these methods for inherited attributes.\n toOperationActionDictionaryTemplate() {\n return this._toOperationOrAttributeActionDictionaryTemplate();\n },\n toAttributeActionDictionaryTemplate() {\n return this._toOperationOrAttributeActionDictionaryTemplate();\n },\n\n _toOperationOrAttributeActionDictionaryTemplate() {\n // TODO: add the super-grammar's templates at the right place, e.g., a case for AddExpr_plus\n // should appear next to other cases of AddExpr.\n\n const sb = new common.StringBuffer();\n sb.append('{');\n\n let first = true;\n // eslint-disable-next-line guard-for-in\n for (const ruleName in this.rules) {\n const {body} = this.rules[ruleName];\n if (first) {\n first = false;\n } else {\n sb.append(',');\n }\n sb.append('\\n');\n sb.append(' ');\n this.addSemanticActionTemplate(ruleName, body, sb);\n }\n\n sb.append('\\n}');\n return sb.contents();\n },\n\n addSemanticActionTemplate(ruleName, body, sb) {\n sb.append(ruleName);\n sb.append(': function(');\n const arity = this._topDownActionArity(ruleName);\n sb.append(common.repeat('_', arity).join(', '));\n sb.append(') {\\n');\n sb.append(' }');\n },\n\n // Parse a string which expresses a rule application in this grammar, and return the\n // resulting Apply node.\n parseApplication(str) {\n let app;\n if (str.indexOf('<') === -1) {\n // simple application\n app = new pexprs.Apply(str);\n } else {\n // parameterized application\n const cst = ohmGrammar.match(str, 'Base_application');\n app = buildGrammar(cst, {});\n }\n\n // Ensure that the application is valid.\n if (!(app.ruleName in this.rules)) {\n throw errors.undeclaredRule(app.ruleName, this.name);\n }\n const {formals} = this.rules[app.ruleName];\n if (formals.length !== app.args.length) {\n const {source} = this.rules[app.ruleName];\n throw errors.wrongNumberOfParameters(\n app.ruleName,\n formals.length,\n app.args.length,\n source\n );\n }\n return app;\n },\n};\n\n// The following grammar contains a few rules that couldn't be written in \"userland\".\n// At the bottom of src/main.js, we create a sub-grammar of this grammar that's called\n// `BuiltInRules`. That grammar contains several convenience rules, e.g., `letter` and\n// `digit`, and is implicitly the super-grammar of any grammar whose super-grammar\n// isn't specified.\nGrammar.ProtoBuiltInRules = new Grammar(\n 'ProtoBuiltInRules', // name\n undefined, // supergrammar\n {\n any: {\n body: pexprs.any,\n formals: [],\n description: 'any character',\n primitive: true,\n },\n end: {\n body: pexprs.end,\n formals: [],\n description: 'end of input',\n primitive: true,\n },\n\n caseInsensitive: {\n body: new CaseInsensitiveTerminal(new pexprs.Param(0)),\n formals: ['str'],\n primitive: true,\n },\n lower: {\n body: new pexprs.UnicodeChar('Ll'),\n formals: [],\n description: 'a lowercase letter',\n primitive: true,\n },\n upper: {\n body: new pexprs.UnicodeChar('Lu'),\n formals: [],\n description: 'an uppercase letter',\n primitive: true,\n },\n // Union of Lt (titlecase), Lm (modifier), and Lo (other), i.e. any letter not in Ll or Lu.\n unicodeLtmo: {\n body: new pexprs.UnicodeChar('Ltmo'),\n formals: [],\n description: 'a Unicode character in Lt, Lm, or Lo',\n primitive: true,\n },\n\n // These rules are not truly primitive (they could be written in userland) but are defined\n // here for bootstrapping purposes.\n spaces: {\n body: new pexprs.Star(new pexprs.Apply('space')),\n formals: [],\n },\n space: {\n body: new pexprs.Range('\\x00', ' '),\n formals: [],\n description: 'a space',\n },\n }\n);\n\n// --------------------------------------------------------------------\n// Exports\n// --------------------------------------------------------------------\n\nmodule.exports = Grammar;\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst Grammar = require('./Grammar');\nconst InputStream = require('./InputStream');\nconst common = require('./common');\nconst errors = require('./errors');\nconst pexprs = require('./pexprs');\n\n// --------------------------------------------------------------------\n// Private Stuff\n// --------------------------------------------------------------------\n\n// Constructors\n\nfunction GrammarDecl(name) {\n this.name = name;\n}\n\n// Helpers\n\nGrammarDecl.prototype.sourceInterval = function(startIdx, endIdx) {\n return this.source.subInterval(startIdx, endIdx - startIdx);\n};\n\nGrammarDecl.prototype.ensureSuperGrammar = function() {\n if (!this.superGrammar) {\n this.withSuperGrammar(\n // TODO: The conditional expression below is an ugly hack. It's kind of ok because\n // I doubt anyone will ever try to declare a grammar called `BuiltInRules`. Still,\n // we should try to find a better way to do this.\n this.name === 'BuiltInRules' ? Grammar.ProtoBuiltInRules : Grammar.BuiltInRules\n );\n }\n return this.superGrammar;\n};\n\nGrammarDecl.prototype.ensureSuperGrammarRuleForOverriding = function(name, source) {\n const ruleInfo = this.ensureSuperGrammar().rules[name];\n if (!ruleInfo) {\n throw errors.cannotOverrideUndeclaredRule(name, this.superGrammar.name, source);\n }\n return ruleInfo;\n};\n\nGrammarDecl.prototype.installOverriddenOrExtendedRule = function(\n name,\n formals,\n body,\n source\n) {\n const duplicateParameterNames = common.getDuplicates(formals);\n if (duplicateParameterNames.length > 0) {\n throw errors.duplicateParameterNames(name, duplicateParameterNames, source);\n }\n const ruleInfo = this.ensureSuperGrammar().rules[name];\n const expectedFormals = ruleInfo.formals;\n const expectedNumFormals = expectedFormals ? expectedFormals.length : 0;\n if (formals.length !== expectedNumFormals) {\n throw errors.wrongNumberOfParameters(name, expectedNumFormals, formals.length, source);\n }\n return this.install(name, formals, body, ruleInfo.description, source);\n};\n\nGrammarDecl.prototype.install = function(name, formals, body, description, source) {\n this.rules[name] = {\n body: body.introduceParams(formals),\n formals,\n description,\n source,\n };\n return this;\n};\n\n// Stuff that you should only do once\n\nGrammarDecl.prototype.withSuperGrammar = function(superGrammar) {\n if (this.superGrammar) {\n throw new Error('the super grammar of a GrammarDecl cannot be set more than once');\n }\n this.superGrammar = superGrammar;\n this.rules = Object.create(superGrammar.rules);\n\n // Grammars with an explicit supergrammar inherit a default start rule.\n if (!superGrammar.isBuiltIn()) {\n this.defaultStartRule = superGrammar.defaultStartRule;\n }\n return this;\n};\n\nGrammarDecl.prototype.withDefaultStartRule = function(ruleName) {\n this.defaultStartRule = ruleName;\n return this;\n};\n\nGrammarDecl.prototype.withSource = function(source) {\n this.source = new InputStream(source).interval(0, source.length);\n return this;\n};\n\n// Creates a Grammar instance, and if it passes the sanity checks, returns it.\nGrammarDecl.prototype.build = function() {\n const grammar = new Grammar(\n this.name,\n this.ensureSuperGrammar(),\n this.rules,\n this.defaultStartRule\n );\n\n // TODO: change the pexpr.prototype.assert... methods to make them add\n // exceptions to an array that's provided as an arg. Then we'll be able to\n // show more than one error of the same type at a time.\n // TODO: include the offending pexpr in the errors, that way we can show\n // the part of the source that caused it.\n const grammarErrors = [];\n let grammarHasInvalidApplications = false;\n Object.keys(grammar.rules).forEach(ruleName => {\n const {body} = grammar.rules[ruleName];\n try {\n body.assertChoicesHaveUniformArity(ruleName);\n } catch (e) {\n grammarErrors.push(e);\n }\n try {\n body.assertAllApplicationsAreValid(ruleName, grammar);\n } catch (e) {\n grammarErrors.push(e);\n grammarHasInvalidApplications = true;\n }\n });\n if (!grammarHasInvalidApplications) {\n // The following check can only be done if the grammar has no invalid applications.\n Object.keys(grammar.rules).forEach(ruleName => {\n const {body} = grammar.rules[ruleName];\n try {\n body.assertIteratedExprsAreNotNullable(grammar, []);\n } catch (e) {\n grammarErrors.push(e);\n }\n });\n }\n if (grammarErrors.length > 0) {\n errors.throwErrors(grammarErrors);\n }\n if (this.source) {\n grammar.source = this.source;\n }\n\n return grammar;\n};\n\n// Rule declarations\n\nGrammarDecl.prototype.define = function(name, formals, body, description, source) {\n this.ensureSuperGrammar();\n if (this.superGrammar.rules[name]) {\n throw errors.duplicateRuleDeclaration(name, this.name, this.superGrammar.name, source);\n } else if (this.rules[name]) {\n throw errors.duplicateRuleDeclaration(name, this.name, this.name, source);\n }\n const duplicateParameterNames = common.getDuplicates(formals);\n if (duplicateParameterNames.length > 0) {\n throw errors.duplicateParameterNames(name, duplicateParameterNames, source);\n }\n return this.install(name, formals, body, description, source);\n};\n\nGrammarDecl.prototype.override = function(name, formals, body, descIgnored, source) {\n this.ensureSuperGrammarRuleForOverriding(name, source);\n this.installOverriddenOrExtendedRule(name, formals, body, source);\n return this;\n};\n\nGrammarDecl.prototype.extend = function(name, formals, fragment, descIgnored, source) {\n const ruleInfo = this.ensureSuperGrammar().rules[name];\n if (!ruleInfo) {\n throw errors.cannotExtendUndeclaredRule(name, this.superGrammar.name, source);\n }\n const body = new pexprs.Extend(this.superGrammar, name, fragment);\n body.source = fragment.source;\n this.installOverriddenOrExtendedRule(name, formals, body, source);\n return this;\n};\n\n// --------------------------------------------------------------------\n// Exports\n// --------------------------------------------------------------------\n\nmodule.exports = GrammarDecl;\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst Grammar = require('./Grammar');\nconst GrammarDecl = require('./GrammarDecl');\nconst pexprs = require('./pexprs');\n\n// --------------------------------------------------------------------\n// Private stuff\n// --------------------------------------------------------------------\n\nfunction Builder() {}\n\nBuilder.prototype = {\n currentDecl: null,\n currentRuleName: null,\n\n newGrammar(name) {\n return new GrammarDecl(name);\n },\n\n grammar(metaInfo, name, superGrammar, defaultStartRule, rules) {\n const gDecl = new GrammarDecl(name);\n if (superGrammar) {\n // `superGrammar` may be a recipe (i.e. an Array), or an actual grammar instance.\n gDecl.withSuperGrammar(\n superGrammar instanceof Grammar ? superGrammar : this.fromRecipe(superGrammar)\n );\n }\n if (defaultStartRule) {\n gDecl.withDefaultStartRule(defaultStartRule);\n }\n if (metaInfo && metaInfo.source) {\n gDecl.withSource(metaInfo.source);\n }\n\n this.currentDecl = gDecl;\n Object.keys(rules).forEach(ruleName => {\n this.currentRuleName = ruleName;\n const ruleRecipe = rules[ruleName];\n\n const action = ruleRecipe[0]; // define/extend/override\n const metaInfo = ruleRecipe[1];\n const description = ruleRecipe[2];\n const formals = ruleRecipe[3];\n const body = this.fromRecipe(ruleRecipe[4]);\n\n let source;\n if (gDecl.source && metaInfo && metaInfo.sourceInterval) {\n source = gDecl.source.subInterval(\n metaInfo.sourceInterval[0],\n metaInfo.sourceInterval[1] - metaInfo.sourceInterval[0]\n );\n }\n gDecl[action](ruleName, formals, body, description, source);\n });\n this.currentRuleName = this.currentDecl = null;\n return gDecl.build();\n },\n\n terminal(x) {\n return new pexprs.Terminal(x);\n },\n\n range(from, to) {\n return new pexprs.Range(from, to);\n },\n\n param(index) {\n return new pexprs.Param(index);\n },\n\n alt(...termArgs) {\n let terms = [];\n for (let arg of termArgs) {\n if (!(arg instanceof pexprs.PExpr)) {\n arg = this.fromRecipe(arg);\n }\n if (arg instanceof pexprs.Alt) {\n terms = terms.concat(arg.terms);\n } else {\n terms.push(arg);\n }\n }\n return terms.length === 1 ? terms[0] : new pexprs.Alt(terms);\n },\n\n seq(...factorArgs) {\n let factors = [];\n for (let arg of factorArgs) {\n if (!(arg instanceof pexprs.PExpr)) {\n arg = this.fromRecipe(arg);\n }\n if (arg instanceof pexprs.Seq) {\n factors = factors.concat(arg.factors);\n } else {\n factors.push(arg);\n }\n }\n return factors.length === 1 ? factors[0] : new pexprs.Seq(factors);\n },\n\n star(expr) {\n if (!(expr instanceof pexprs.PExpr)) {\n expr = this.fromRecipe(expr);\n }\n return new pexprs.Star(expr);\n },\n\n plus(expr) {\n if (!(expr instanceof pexprs.PExpr)) {\n expr = this.fromRecipe(expr);\n }\n return new pexprs.Plus(expr);\n },\n\n opt(expr) {\n if (!(expr instanceof pexprs.PExpr)) {\n expr = this.fromRecipe(expr);\n }\n return new pexprs.Opt(expr);\n },\n\n not(expr) {\n if (!(expr instanceof pexprs.PExpr)) {\n expr = this.fromRecipe(expr);\n }\n return new pexprs.Not(expr);\n },\n\n la(expr) {\n // TODO: temporary to still be able to read old recipes\n return this.lookahead(expr);\n },\n\n lookahead(expr) {\n if (!(expr instanceof pexprs.PExpr)) {\n expr = this.fromRecipe(expr);\n }\n return new pexprs.Lookahead(expr);\n },\n\n lex(expr) {\n if (!(expr instanceof pexprs.PExpr)) {\n expr = this.fromRecipe(expr);\n }\n return new pexprs.Lex(expr);\n },\n\n app(ruleName, optParams) {\n if (optParams && optParams.length > 0) {\n optParams = optParams.map(function(param) {\n return param instanceof pexprs.PExpr ? param : this.fromRecipe(param);\n }, this);\n }\n return new pexprs.Apply(ruleName, optParams);\n },\n\n // Note that unlike other methods in this class, this method cannot be used as a\n // convenience constructor. It only works with recipes, because it relies on\n // `this.currentDecl` and `this.currentRuleName` being set.\n splice(beforeTerms, afterTerms) {\n return new pexprs.Splice(\n this.currentDecl.superGrammar,\n this.currentRuleName,\n beforeTerms.map(term => this.fromRecipe(term)),\n afterTerms.map(term => this.fromRecipe(term))\n );\n },\n\n fromRecipe(recipe) {\n // the meta-info of 'grammar' is processed in Builder.grammar\n const args = recipe[0] === 'grammar' ? recipe.slice(1) : recipe.slice(2);\n const result = this[recipe[0]](...args);\n\n const metaInfo = recipe[1];\n if (metaInfo) {\n if (metaInfo.sourceInterval && this.currentDecl) {\n result.withSource(this.currentDecl.sourceInterval(...metaInfo.sourceInterval));\n }\n }\n return result;\n },\n};\n\n// --------------------------------------------------------------------\n// Exports\n// --------------------------------------------------------------------\n\nmodule.exports = Builder;\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst Builder = require('./Builder');\nconst Grammar = require('./Grammar');\nconst Namespace = require('./Namespace');\nconst common = require('./common');\nconst errors = require('./errors');\nconst pexprs = require('./pexprs');\nconst util = require('./util');\nconst version = require('./version');\n\n// --------------------------------------------------------------------\n// Private stuff\n// --------------------------------------------------------------------\n\n// The metagrammar, i.e. the grammar for Ohm grammars. Initialized at the\n// bottom of this file because loading the grammar requires Ohm itself.\nlet ohmGrammar;\n\nconst superSplicePlaceholder = Object.create(pexprs.PExpr.prototype);\n\nconst isBuffer = obj =>\n !!obj.constructor &&\n typeof obj.constructor.isBuffer === 'function' &&\n obj.constructor.isBuffer(obj);\n\n// Returns a Grammar instance (i.e., an object with a `match` method) for\n// `tree`, which is the concrete syntax tree of a user-written grammar.\n// The grammar will be assigned into `namespace` under the name of the grammar\n// as specified in the source.\nfunction buildGrammar(match, namespace, optOhmGrammarForTesting) {\n const builder = new Builder();\n let decl;\n let currentRuleName;\n let currentRuleFormals;\n let overriding = false;\n const metaGrammar = optOhmGrammarForTesting || ohmGrammar;\n\n // A visitor that produces a Grammar instance from the CST.\n const helpers = metaGrammar.createSemantics().addOperation('visit', {\n Grammars(grammarIter) {\n return grammarIter.children.map(c => c.visit());\n },\n Grammar(id, s, _open, rules, _close) {\n const grammarName = id.visit();\n decl = builder.newGrammar(grammarName, namespace);\n s.child(0) && s.child(0).visit();\n rules.children.map(c => c.visit());\n const g = decl.build();\n g.source = this.source.trimmed();\n if (grammarName in namespace) {\n throw errors.duplicateGrammarDeclaration(g, namespace);\n }\n namespace[grammarName] = g;\n return g;\n },\n\n SuperGrammar(_, n) {\n const superGrammarName = n.visit();\n if (superGrammarName === 'null') {\n decl.withSuperGrammar(null);\n } else {\n if (!namespace || !(superGrammarName in namespace)) {\n throw errors.undeclaredGrammar(superGrammarName, namespace, n.source);\n }\n decl.withSuperGrammar(namespace[superGrammarName]);\n }\n },\n\n Rule_define(n, fs, d, _, b) {\n currentRuleName = n.visit();\n currentRuleFormals = fs.children.map(c => c.visit())[0] || [];\n // If there is no default start rule yet, set it now. This must be done before visiting\n // the body, because it might contain an inline rule definition.\n if (!decl.defaultStartRule && decl.ensureSuperGrammar() !== Grammar.ProtoBuiltInRules) {\n decl.withDefaultStartRule(currentRuleName);\n }\n const body = b.visit();\n const description = d.children.map(c => c.visit())[0];\n const source = this.source.trimmed();\n return decl.define(currentRuleName, currentRuleFormals, body, description, source);\n },\n Rule_override(n, fs, _, b) {\n currentRuleName = n.visit();\n currentRuleFormals = fs.children.map(c => c.visit())[0] || [];\n\n const source = this.source.trimmed();\n decl.ensureSuperGrammarRuleForOverriding(currentRuleName, source);\n\n overriding = true;\n const body = b.visit();\n overriding = false;\n return decl.override(currentRuleName, currentRuleFormals, body, null, source);\n },\n Rule_extend(n, fs, _, b) {\n currentRuleName = n.visit();\n currentRuleFormals = fs.children.map(c => c.visit())[0] || [];\n const body = b.visit();\n const source = this.source.trimmed();\n return decl.extend(currentRuleName, currentRuleFormals, body, null, source);\n },\n RuleBody(_, terms) {\n return builder.alt(...terms.visit()).withSource(this.source);\n },\n OverrideRuleBody(_, terms) {\n const args = terms.visit();\n\n // Check if the super-splice operator (`...`) appears in the terms.\n const expansionPos = args.indexOf(superSplicePlaceholder);\n if (expansionPos >= 0) {\n const beforeTerms = args.slice(0, expansionPos);\n const afterTerms = args.slice(expansionPos + 1);\n\n // Ensure it appears no more than once.\n afterTerms.forEach(t => {\n if (t === superSplicePlaceholder) throw errors.multipleSuperSplices(t);\n });\n\n return new pexprs.Splice(\n decl.superGrammar,\n currentRuleName,\n beforeTerms,\n afterTerms\n ).withSource(this.source);\n } else {\n return builder.alt(...args).withSource(this.source);\n }\n },\n Formals(opointy, fs, cpointy) {\n return fs.visit();\n },\n\n Params(opointy, ps, cpointy) {\n return ps.visit();\n },\n\n Alt(seqs) {\n return builder.alt(...seqs.visit()).withSource(this.source);\n },\n\n TopLevelTerm_inline(b, n) {\n const inlineRuleName = currentRuleName + '_' + n.visit();\n const body = b.visit();\n const source = this.source.trimmed();\n const isNewRuleDeclaration = !(\n decl.superGrammar && decl.superGrammar.rules[inlineRuleName]\n );\n if (overriding && !isNewRuleDeclaration) {\n decl.override(inlineRuleName, currentRuleFormals, body, null, source);\n } else {\n decl.define(inlineRuleName, currentRuleFormals, body, null, source);\n }\n const params = currentRuleFormals.map(formal => builder.app(formal));\n return builder.app(inlineRuleName, params).withSource(body.source);\n },\n OverrideTopLevelTerm_superSplice(_) {\n return superSplicePlaceholder;\n },\n\n Seq(expr) {\n return builder.seq(...expr.children.map(c => c.visit())).withSource(this.source);\n },\n\n Iter_star(x, _) {\n return builder.star(x.visit()).withSource(this.source);\n },\n Iter_plus(x, _) {\n return builder.plus(x.visit()).withSource(this.source);\n },\n Iter_opt(x, _) {\n return builder.opt(x.visit()).withSource(this.source);\n },\n\n Pred_not(_, x) {\n return builder.not(x.visit()).withSource(this.source);\n },\n Pred_lookahead(_, x) {\n return builder.lookahead(x.visit()).withSource(this.source);\n },\n\n Lex_lex(_, x) {\n return builder.lex(x.visit()).withSource(this.source);\n },\n\n Base_application(rule, ps) {\n const params = ps.children.map(c => c.visit())[0] || [];\n return builder.app(rule.visit(), params).withSource(this.source);\n },\n Base_range(from, _, to) {\n return builder.range(from.visit(), to.visit()).withSource(this.source);\n },\n Base_terminal(expr) {\n return builder.terminal(expr.visit()).withSource(this.source);\n },\n Base_paren(open, x, close) {\n return x.visit();\n },\n\n ruleDescr(open, t, close) {\n return t.visit();\n },\n ruleDescrText(_) {\n return this.sourceString.trim();\n },\n\n caseName(_, space1, n, space2, end) {\n return n.visit();\n },\n\n name(first, rest) {\n return this.sourceString;\n },\n nameFirst(expr) {},\n nameRest(expr) {},\n\n terminal(open, cs, close) {\n return cs.children.map(c => c.visit()).join('');\n },\n\n oneCharTerminal(open, c, close) {\n return c.visit();\n },\n\n terminalChar(_) {\n return common.unescapeChar(this.sourceString);\n },\n\n escapeChar(_) {\n return this.sourceString;\n },\n\n NonemptyListOf(x, _, xs) {\n return [x.visit()].concat(xs.children.map(c => c.visit()));\n },\n EmptyListOf() {\n return [];\n },\n\n _terminal() {\n return this.sourceString;\n },\n });\n return helpers(match).visit();\n}\n\nfunction compileAndLoad(source, namespace) {\n const m = ohmGrammar.match(source, 'Grammars');\n if (m.failed()) {\n throw errors.grammarSyntaxError(m);\n }\n return buildGrammar(m, namespace);\n}\n\nfunction grammar(source, optNamespace) {\n const ns = grammars(source, optNamespace);\n\n // Ensure that the source contained no more than one grammar definition.\n const grammarNames = Object.keys(ns);\n if (grammarNames.length === 0) {\n throw new Error('Missing grammar definition');\n } else if (grammarNames.length > 1) {\n const secondGrammar = ns[grammarNames[1]];\n const interval = secondGrammar.source;\n throw new Error(\n util.getLineAndColumnMessage(interval.sourceString, interval.startIdx) +\n 'Found more than one grammar definition -- use ohm.grammars() instead.'\n );\n }\n return ns[grammarNames[0]]; // Return the one and only grammar.\n}\n\nfunction grammars(source, optNamespace) {\n const ns = Namespace.extend(Namespace.asNamespace(optNamespace));\n if (typeof source !== 'string') {\n // For convenience, detect Node.js Buffer objects and automatically call toString().\n if (isBuffer(source)) {\n source = source.toString();\n } else {\n throw new TypeError(\n 'Expected string as first argument, got ' + common.unexpectedObjToString(source)\n );\n }\n }\n compileAndLoad(source, ns);\n return ns;\n}\n\nfunction grammarFromScriptElement(optNode) {\n throw new Error(\n 'grammarFromScriptElement was removed in Ohm v16.0. See https://git.io/Jwow5 for more info.'\n );\n}\n\nfunction grammarsFromScriptElements(optNodeOrNodeList) {\n throw new Error(\n 'grammarsFromScriptElements was removed in Ohm v16.0. See https://git.io/Jwow5 for more info.'\n );\n}\n\nfunction makeRecipe(recipe) {\n if (typeof recipe === 'function') {\n return recipe.call(new Builder());\n } else {\n if (typeof recipe === 'string') {\n // stringified JSON recipe\n recipe = JSON.parse(recipe);\n }\n return new Builder().fromRecipe(recipe);\n }\n}\n\n// --------------------------------------------------------------------\n// Exports\n// --------------------------------------------------------------------\n\n// Stuff that users should know about\nmodule.exports = {\n createNamespace: Namespace.createNamespace,\n grammar,\n grammars,\n grammarFromScriptElement,\n grammarsFromScriptElements,\n makeRecipe,\n ohmGrammar: null, // Initialized below, after Grammar.BuiltInRules.\n pexprs,\n util,\n extras: require('../extras'),\n version,\n};\n\n// Stuff for testing, etc.\nmodule.exports._buildGrammar = buildGrammar;\n\n// Late initialization for stuff that is bootstrapped.\n\nGrammar.BuiltInRules = require('../dist/built-in-rules');\nutil.announceBuiltInRules(Grammar.BuiltInRules);\n\nmodule.exports.ohmGrammar = ohmGrammar = require('../dist/ohm-grammar');\nGrammar.initApplicationParser(ohmGrammar, buildGrammar);\n","{\n \"name\": \"ohm-js\",\n \"version\": \"16.0.0\",\n \"description\": \"An object-oriented language for parsing and pattern matching\",\n \"repository\": \"https://github.com/harc/ohm\",\n \"keywords\": [\n \"parser\",\n \"compiler\",\n \"pattern matching\",\n \"pattern-matching\",\n \"ometa\",\n \"ometa/js\",\n \"ometa-js\",\n \"ometajs\",\n \"rapid\",\n \"prototyping\"\n ],\n \"homepage\": \"https://ohmlang.github.io/\",\n \"bugs\": \"https://github.com/harc/ohm/issues\",\n \"main\": \"src/main.js\",\n \"files\": [\n \"src\",\n \"dist\",\n \"extras\",\n \"third_party\",\n \"index.d.ts\"\n ],\n \"types\": \"index.d.ts\",\n \"scripts\": {\n \"prebootstrap\": \"bash scripts/prebootstrap\",\n \"bootstrap\": \"bash scripts/bootstrap --test || (echo 'Bootstrap failed.' && mv -v dist/ohm-grammar.js.old dist/ohm-grammar.js && mv -v dist/built-in-rules.js.old dist/built-in-rules.js && mv -v dist/operations-and-attributes.js.old dist/operations-and-attributes.js)\",\n \"build\": \"yarn build-debug && webpack --mode=production\",\n \"build-debug\": \"webpack --mode=development && node scripts/generate-types.mjs\",\n \"clean\": \"rm -f dist/ohm.js dist/ohm.min.js\",\n \"lint\": \"eslint . --ignore-path ../.eslintignore\",\n \"format\": \"prettier . --write --ignore-path ../.prettierignore --config ../.prettierrc && eslint . --ignore-path ../.eslintignore --fix\",\n \"test\": \"ava && ava --config ava-ts.config.js test/test-typings.ts\",\n \"test-watch\": \"ava --watch\",\n \"pre-commit\": \"yarn run lint && yarn run build && yarn run test\",\n \"prepack\": \"cp ../../README.md . && yarn build\",\n \"postpack\": \"rm README.md\",\n \"unsafe-bootstrap\": \"bash scripts/bootstrap\",\n \"version-package\": \"bash scripts/version\",\n \"watch\": \"webpack --mode=development --watch\"\n },\n \"license\": \"MIT\",\n \"author\": \"Alex Warth <alexwarth@gmail.com> (http://tinlizzie.org/~awarth)\",\n \"contributors\": [\n \"Patrick Dubroy <pdubroy@gmail.com>\",\n \"Meixian Li <lmeixian@gmail.com>\",\n \"Marko Röder <m.roeder@photon-software.de>\",\n \"Tony Garnock-Jones <tonygarnockjones@gmail.com>\",\n \"Saketh Kasibatla <sake.kasi@gmail.com>\",\n \"Lionel Landwerlin <llandwerlin@gmail.com>\",\n \"Ray Toal <rtoal@lmu.edu>\",\n \"Jason Merrill <jwmerrill@gmail.com>\",\n \"Yoshiki Ohshima <Yoshiki.Ohshima@acm.org>\",\n \"stagas <gstagas@gmail.com>\",\n \"Jonathan Edwards <JonathanMEdwards@gmail.com>\",\n \"Milan Lajtoš <milan.lajtos@me.com>\",\n \"Neil Jewers <njjewers@uwaterloo.ca>\",\n \"Mike Niebling <(none)>\",\n \"AngryPowman <angrypowman@qq.com>\",\n \"Leslie Ying <acetophore@users.noreply.github.com>\",\n \"Pierre Donias <pierre.donias@gmail.com>\",\n \"Justin Chase <justin.m.chase@gmail.com>\",\n \"Daniel Tomlinson <DanielTomlinson@me.com>\",\n \"Stan Rozenraukh <stan@stanistan.com>\",\n \"Stephan Seidt <stephan.seidt@gmail.com>\",\n \"Steve Phillips <steve@tryingtobeawesome.com>\",\n \"Szymon Kaliski <kaliskiszymon@gmail.com>\",\n \"Thomas Nyberg <tomnyberg@gmail.com>\",\n \"Casey Olson <casey.m.olson@gmail.com>\",\n \"Vse Mozhet Byt <vsemozhetbyt@gmail.com>\",\n \"Wil Chung <10446+iamwilhelm@users.noreply.github.com>\",\n \"Arthur Carabott <arthurc@gmail.com>\",\n \"abego <ub@abego-software.de>\",\n \"acslk <d_vd415@hotmail.com>\",\n \"codeZeilen <codeZeilen@users.noreply.github.com>\",\n \"owch <bowenrainyday@gmail.com>\",\n \"Luca Guzzon <luca.guzzon@gmail.com>\",\n \"sfinnie <scott.finnie@gmail.com>\"\n ],\n \"dependencies\": {},\n \"devDependencies\": {\n \"@ohm-js/cli\": \"^1.0.0\",\n \"ava\": \"^3.15.0\",\n \"ava-spec\": \"^1.1.1\",\n \"dedent\": \"^0.7.0\",\n \"eslint\": \"^7.9.0\",\n \"eslint-config-google\": \"^0.14.0\",\n \"eslint-plugin-ava\": \"^11.0.0\",\n \"eslint-plugin-camelcase-ohm\": \"^0.2.1\",\n \"eslint-plugin-no-extension-in-require\": \"^0.2.0\",\n \"husky\": \"^4.2.5\",\n \"jsdom\": \"^9.9.1\",\n \"json\": \"^9.0.6\",\n \"markscript\": \"^0.5.0\",\n \"node-static\": \"^0.7.11\",\n \"ohm-grammar-ecmascript\": \"^1.0.0\",\n \"parcel\": \"^2.0.0\",\n \"ts-loader\": \"^8.0.4\",\n \"ts-node\": \"^9.0.0\",\n \"typescript\": \"^4.0.3\",\n \"walk-sync\": \"^2.2.0\",\n \"webpack\": \"^4.44.2\",\n \"webpack-cli\": \"^3.3.12\"\n },\n \"engines\": {\n \"node\": \">=0.12.1\"\n },\n \"targets\": {\n \"default\": {\n \"context\": \"browser\",\n \"source\": \"src/main.js\",\n \"distDir\": \"dist\"\n }\n }\n}\n","/* global __GLOBAL_OHM_VERSION__ */\n\n'use strict';\n\n// When running under Node, read the version from package.json. For the browser,\n// use a special global variable defined in the build process (see webpack.config.js).\nmodule.exports =\n typeof __GLOBAL_OHM_VERSION__ === 'string' ?\n __GLOBAL_OHM_VERSION__ :\n require('../package.json').version;\n","'use strict';\n\nmodule.exports = {\n VisitorFamily: require('./VisitorFamily'),\n semanticsForToAST: require('./semantics-toAST').semantics,\n toAST: require('./semantics-toAST').helper,\n};\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst {assert} = require('../src/common');\n\n// --------------------------------------------------------------------\n// Private stuff\n// --------------------------------------------------------------------\n\n// Helpers\n\nfunction getProp(name, thing, fn) {\n return fn(thing[name]);\n}\n\nfunction mapProp(name, thing, fn) {\n return thing[name].map(fn);\n}\n\n// Returns a function that will walk a single property of a node.\n// `descriptor` is a string indicating the property name, optionally ending\n// with '[]' (e.g., 'children[]').\nfunction getPropWalkFn(descriptor) {\n const parts = descriptor.split(/ ?\\[\\]/);\n if (parts.length === 2) {\n return mapProp.bind(null, parts[0]);\n }\n return getProp.bind(null, descriptor);\n}\n\nfunction getProps(walkFns, thing, fn) {\n return walkFns.map(walkFn => walkFn(thing, fn));\n}\n\nfunction getWalkFn(shape) {\n if (typeof shape === 'string') {\n return getProps.bind(null, [getPropWalkFn(shape)]);\n } else if (Array.isArray(shape)) {\n return getProps.bind(null, shape.map(getPropWalkFn));\n } else {\n assert(typeof shape === 'function', 'Expected a string, Array, or function');\n assert(shape.length === 2, 'Expected a function of arity 2, got ' + shape.length);\n return shape;\n }\n}\n\nfunction isRestrictedIdentifier(str) {\n return /^[a-zA-Z_][0-9a-zA-Z_]*$/.test(str);\n}\n\nfunction trim(s) {\n return s.trim();\n}\n\nfunction parseSignature(sig) {\n const parts = sig.split(/[()]/).map(trim);\n if (parts.length === 3 && parts[2] === '') {\n const name = parts[0];\n let params = [];\n if (parts[1].length > 0) {\n params = parts[1].split(',').map(trim);\n }\n if (isRestrictedIdentifier(name) && params.every(isRestrictedIdentifier)) {\n return {name, formals: params};\n }\n }\n throw new Error('Invalid operation signature: ' + sig);\n}\n\n/*\n A VisitorFamily contains a set of recursive operations that are defined over some kind of\n tree structure. The `config` parameter specifies how to walk the tree:\n - 'getTag' is function which, given a node in the tree, returns the node's 'tag' (type)\n - 'shapes' an object that maps from a tag to a value that describes how to recursively\n evaluate the operation for nodes of that type. The value can be:\n * a string indicating the property name that holds that node's only child\n * an Array of property names (or an empty array indicating a leaf type), or\n * a function taking two arguments (node, fn), and returning an Array which is the result\n of apply `fn` to each of the node's children.\n */\nfunction VisitorFamily(config) {\n this._shapes = config.shapes;\n this._getTag = config.getTag;\n\n this.Adapter = function(thing, family) {\n this._adaptee = thing;\n this._family = family;\n };\n this.Adapter.prototype.valueOf = function() {\n throw new Error('heeey!');\n };\n this.operations = {};\n\n this._arities = Object.create(null);\n this._getChildren = Object.create(null);\n\n Object.keys(this._shapes).forEach(k => {\n const shape = this._shapes[k];\n this._getChildren[k] = getWalkFn(shape);\n\n // A function means the arity isn't fixed, so don't put an entry in the arity map.\n if (typeof shape !== 'function') {\n this._arities[k] = Array.isArray(shape) ? shape.length : 1;\n }\n });\n this._wrap = thing => new this.Adapter(thing, this);\n}\n\nVisitorFamily.prototype.wrap = function(thing) {\n return this._wrap(thing);\n};\n\nVisitorFamily.prototype._checkActionDict = function(dict) {\n Object.keys(dict).forEach(k => {\n assert(k in this._getChildren, \"Unrecognized action name '\" + k + \"'\");\n const action = dict[k];\n assert(typeof action === 'function', \"Key '\" + k + \"': expected function, got \" + action);\n if (k in this._arities) {\n const expected = this._arities[k];\n const actual = dict[k].length;\n assert(\n actual === expected,\n \"Action '\" + k + \"' has the wrong arity: expected \" + expected + ', got ' + actual\n );\n }\n });\n};\n\nVisitorFamily.prototype.addOperation = function(signature, actions) {\n const sig = parseSignature(signature);\n const {name} = sig;\n this._checkActionDict(actions);\n this.operations[name] = {\n name,\n formals: sig.formals,\n actions,\n };\n\n const family = this;\n this.Adapter.prototype[name] = function(...args) {\n const tag = family._getTag(this._adaptee);\n assert(tag in family._getChildren, \"getTag returned unrecognized tag '\" + tag + \"'\");\n assert(tag in actions, \"No action for '\" + tag + \"' in operation '\" + name + \"'\");\n\n // Create an \"arguments object\" from the arguments that were passed to this\n // operation / attribute.\n const argsObj = Object.create(null);\n for (const [i, val] of Object.entries(args)) {\n argsObj[sig.formals[i]] = val;\n }\n\n const oldArgs = this.args;\n this.args = argsObj;\n const ans = actions[tag].apply(\n this,\n family._getChildren[tag](this._adaptee, family._wrap)\n );\n this.args = oldArgs;\n return ans;\n };\n return this;\n};\n\n// --------------------------------------------------------------------\n// Exports\n// --------------------------------------------------------------------\n\nmodule.exports = VisitorFamily;\n","'use strict';\n\n// --------------------------------------------------------------------\n// Imports\n// --------------------------------------------------------------------\n\nconst pexprs = require('../src/pexprs');\nconst MatchResult = require('../src/MatchResult');\nconst Grammar = require('../src/Grammar');\n\n// --------------------------------------------------------------------\n// Operations\n// --------------------------------------------------------------------\n\nconst defaultOperation = {\n _terminal() {\n return this.sourceString;\n },\n\n _nonterminal(...children) {\n const {ctorName} = this._node;\n const {mapping} = this.args;\n\n // without customization\n if (!Object.prototype.hasOwnProperty.call(mapping, ctorName)) {\n // intermediate node\n if (this._node instanceof pexprs.Alt || this._node instanceof pexprs.Apply) {\n return children[0].toAST(mapping);\n }\n\n // lexical rule\n if (this.isLexical()) {\n return this.sourceString;\n }\n\n // singular node (e.g. only surrounded by literals or lookaheads)\n const realChildren = children.filter(child => !child.isTerminal());\n if (realChildren.length === 1) {\n return realChildren[0].toAST(mapping);\n }\n\n // rest: terms with multiple children\n }\n\n // direct forward\n if (typeof mapping[ctorName] === 'number') {\n return children[mapping[ctorName]].toAST(mapping);\n }\n\n // named/mapped children or unnamed children ('0', '1', '2', ...)\n const propMap = mapping[ctorName] || children;\n const node = {\n type: ctorName,\n };\n // eslint-disable-next-line guard-for-in\n for (const prop in propMap) {\n const mappedProp = mapping[ctorName] && mapping[ctorName][prop];\n if (typeof mappedProp === 'number') {\n // direct forward\n node[prop] = children[mappedProp].toAST(mapping);\n } else if (\n typeof mappedProp === 'string' ||\n typeof mappedProp === 'boolean' ||\n mappedProp === null\n ) {\n // primitive value\n node[prop] = mappedProp;\n } else if (typeof mappedProp === 'object' && mappedProp instanceof Number) {\n // primitive number (must be unboxed)\n node[prop] = Number(mappedProp);\n } else if (typeof mappedProp === 'function') {\n // computed value\n node[prop] = mappedProp.call(this, children);\n } else if (mappedProp === undefined) {\n if (children[prop] && !children[prop].isTerminal()) {\n node[prop] = children[prop].toAST(mapping);\n } else {\n // delete predefined 'type' properties, like 'type', if explicitely removed\n delete node[prop];\n }\n }\n }\n return node;\n },\n\n _iter(...children) {\n if (this._node.isOptional()) {\n if (this.numChildren === 0) {\n return null;\n } else {\n return children[0].toAST(this.args.mapping);\n }\n }\n\n return children.map(function(child) {\n return child.toAST(this.args.mapping);\n }, this);\n },\n\n NonemptyListOf(first, sep, rest) {\n return [first.toAST(this.args.mapping)].concat(rest.toAST(this.args.mapping));\n },\n\n EmptyListOf() {\n return [];\n },\n};\n\n// Returns a plain JavaScript object that includes an abstract syntax tree (AST)\n// for the given match result `res` containg a concrete syntax tree (CST) and grammar.\n// The optional `mapping` parameter can be used to customize how the nodes of the CST\n// are mapped to the AST (see /doc/extras.md#toastmatchresult-mapping).\nfunction toAST(res, mapping) {\n if (!(res instanceof MatchResult) || res.failed()) {\n throw new Error('toAST() expects a succesfull MatchResult as first parameter');\n }\n\n mapping = Object.assign({}, mapping);\n const operation = Object.assign({}, defaultOperation);\n for (const termName in mapping) {\n if (typeof mapping[termName] === 'function') {\n operation[termName] = mapping[termName];\n delete mapping[termName];\n }\n }\n const g = res._cst.grammar;\n const s = g.createSemantics().addOperation('toAST(mapping)', operation);\n return s(res).toAST(mapping);\n}\n\n// Returns a semantics containg the toAST(mapping) operation for the given grammar g.\nfunction semanticsForToAST(g) {\n if (!(g instanceof Grammar)) {\n throw new Error('semanticsToAST() expects a Grammar as parameter');\n }\n\n return g.createSemantics().addOperation('toAST(mapping)', defaultOperation);\n}\n\nmodule.exports = {\n helper: toAST,\n semantics: semanticsForToAST,\n};\n","var ohm = require('..');\nmodule.exports = ohm.makeRecipe([\"grammar\",{\"source\":\"BuiltInRules {\\n\\n alnum (an alpha-numeric character)\\n = letter\\n | digit\\n\\n letter (a letter)\\n = lower\\n | upper\\n | unicodeLtmo\\n\\n digit (a digit)\\n = \\\"0\\\"..\\\"9\\\"\\n\\n hexDigit (a hexadecimal digit)\\n = digit\\n | \\\"a\\\"..\\\"f\\\"\\n | \\\"A\\\"..\\\"F\\\"\\n\\n ListOf<elem, sep>\\n = NonemptyListOf<elem, sep>\\n | EmptyListOf<elem, sep>\\n\\n NonemptyListOf<elem, sep>\\n = elem (sep elem)*\\n\\n EmptyListOf<elem, sep>\\n = /* nothing */\\n\\n listOf<elem, sep>\\n = nonemptyListOf<elem, sep>\\n | emptyListOf<elem, sep>\\n\\n nonemptyListOf<elem, sep>\\n = elem (sep elem)*\\n\\n emptyListOf<elem, sep>\\n = /* nothing */\\n\\n // Allows a syntactic rule application within a lexical context.\\n experimentalApplySyntactic<app> = app\\n}\"},\"BuiltInRules\",null,null,{\"alnum\":[\"define\",{\"sourceInterval\":[18,78]},\"an alpha-numeric character\",[],[\"alt\",{\"sourceInterval\":[60,78]},[\"app\",{\"sourceInterval\":[60,66]},\"letter\",[]],[\"app\",{\"sourceInterval\":[73,78]},\"digit\",[]]]],\"letter\":[\"define\",{\"sourceInterval\":[82,142]},\"a letter\",[],[\"alt\",{\"sourceInterval\":[107,142]},[\"app\",{\"sourceInterval\":[107,112]},\"lower\",[]],[\"app\",{\"sourceInterval\":[119,124]},\"upper\",[]],[\"app\",{\"sourceInterval\":[131,142]},\"unicodeLtmo\",[]]]],\"digit\":[\"define\",{\"sourceInterval\":[146,177]},\"a digit\",[],[\"range\",{\"sourceInterval\":[169,177]},\"0\",\"9\"]],\"hexDigit\":[\"define\",{\"sourceInterval\":[181,254]},\"a hexadecimal digit\",[],[\"alt\",{\"sourceInterval\":[219,254]},[\"app\",{\"sourceInterval\":[219,224]},\"digit\",[]],[\"range\",{\"sourceInterval\":[231,239]},\"a\",\"f\"],[\"range\",{\"sourceInterval\":[246,254]},\"A\",\"F\"]]],\"ListOf\":[\"define\",{\"sourceInterval\":[258,336]},null,[\"elem\",\"sep\"],[\"alt\",{\"sourceInterval\":[282,336]},[\"app\",{\"sourceInterval\":[282,307]},\"NonemptyListOf\",[[\"param\",{\"sourceInterval\":[297,301]},0],[\"param\",{\"sourceInterval\":[303,306]},1]]],[\"app\",{\"sourceInterval\":[314,336]},\"EmptyListOf\",[[\"param\",{\"sourceInterval\":[326,330]},0],[\"param\",{\"sourceInterval\":[332,335]},1]]]]],\"NonemptyListOf\":[\"define\",{\"sourceInterval\":[340,388]},null,[\"elem\",\"sep\"],[\"seq\",{\"sourceInterval\":[372,388]},[\"param\",{\"sourceInterval\":[372,376]},0],[\"star\",{\"sourceInterval\":[377,388]},[\"seq\",{\"sourceInterval\":[378,386]},[\"param\",{\"sourceInterval\":[378,381]},1],[\"param\",{\"sourceInterval\":[382,386]},0]]]]],\"EmptyListOf\":[\"define\",{\"sourceInterval\":[392,434]},null,[\"elem\",\"sep\"],[\"seq\",{\"sourceInterval\":[438,438]}]],\"listOf\":[\"define\",{\"sourceInterval\":[438,516]},null,[\"elem\",\"sep\"],[\"alt\",{\"sourceInterval\":[462,516]},[\"app\",{\"sourceInterval\":[462,487]},\"nonemptyListOf\",[[\"param\",{\"sourceInterval\":[477,481]},0],[\"param\",{\"sourceInterval\":[483,486]},1]]],[\"app\",{\"sourceInterval\":[494,516]},\"emptyListOf\",[[\"param\",{\"sourceInterval\":[506,510]},0],[\"param\",{\"sourceInterval\":[512,515]},1]]]]],\"nonemptyListOf\":[\"define\",{\"sourceInterval\":[520,568]},null,[\"elem\",\"sep\"],[\"seq\",{\"sourceInterval\":[552,568]},[\"param\",{\"sourceInterval\":[552,556]},0],[\"star\",{\"sourceInterval\":[557,568]},[\"seq\",{\"sourceInterval\":[558,566]},[\"param\",{\"sourceInterval\":[558,561]},1],[\"param\",{\"sourceInterval\":[562,566]},0]]]]],\"emptyListOf\":[\"define\",{\"sourceInterval\":[572,682]},null,[\"elem\",\"sep\"],[\"seq\",{\"sourceInterval\":[685,685]}]],\"experimentalApplySyntactic\":[\"define\",{\"sourceInterval\":[685,722]},null,[\"app\"],[\"param\",{\"sourceInterval\":[719,722]},0]]}]);\n","var ohm = require('..');\nmodule.exports = ohm.makeRecipe([\"grammar\",{\"source\":\"Ohm {\\n\\n Grammars\\n = Grammar*\\n\\n Grammar\\n = ident SuperGrammar? \\\"{\\\" Rule* \\\"}\\\"\\n\\n SuperGrammar\\n = \\\"<:\\\" ident\\n\\n Rule\\n = ident Formals? ruleDescr? \\\"=\\\" RuleBody -- define\\n | ident Formals? \\\":=\\\" OverrideRuleBody -- override\\n | ident Formals? \\\"+=\\\" RuleBody -- extend\\n\\n RuleBody\\n = \\\"|\\\"? NonemptyListOf<TopLevelTerm, \\\"|\\\">\\n\\n TopLevelTerm\\n = Seq caseName -- inline\\n | Seq\\n\\n OverrideRuleBody\\n = \\\"|\\\"? NonemptyListOf<OverrideTopLevelTerm, \\\"|\\\">\\n\\n OverrideTopLevelTerm\\n = \\\"...\\\" -- superSplice\\n | TopLevelTerm\\n\\n Formals\\n = \\\"<\\\" ListOf<ident, \\\",\\\"> \\\">\\\"\\n\\n Params\\n = \\\"<\\\" ListOf<Seq, \\\",\\\"> \\\">\\\"\\n\\n Alt\\n = NonemptyListOf<Seq, \\\"|\\\">\\n\\n Seq\\n = Iter*\\n\\n Iter\\n = Pred \\\"*\\\" -- star\\n | Pred \\\"+\\\" -- plus\\n | Pred \\\"?\\\" -- opt\\n | Pred\\n\\n Pred\\n = \\\"~\\\" Lex -- not\\n | \\\"&\\\" Lex -- lookahead\\n | Lex\\n\\n Lex\\n = \\\"#\\\" Base -- lex\\n | Base\\n\\n Base\\n = ident Params? ~(ruleDescr? \\\"=\\\" | \\\":=\\\" | \\\"+=\\\") -- application\\n | oneCharTerminal \\\"..\\\" oneCharTerminal -- range\\n | terminal -- terminal\\n | \\\"(\\\" Alt \\\")\\\" -- paren\\n\\n ruleDescr (a rule description)\\n = \\\"(\\\" ruleDescrText \\\")\\\"\\n\\n ruleDescrText\\n = (~\\\")\\\" any)*\\n\\n caseName\\n = \\\"--\\\" (~\\\"\\\\n\\\" space)* name (~\\\"\\\\n\\\" space)* (\\\"\\\\n\\\" | &\\\"}\\\")\\n\\n name (a name)\\n = nameFirst nameRest*\\n\\n nameFirst\\n = \\\"_\\\"\\n | letter\\n\\n nameRest\\n = \\\"_\\\"\\n | alnum\\n\\n ident (an identifier)\\n = name\\n\\n terminal\\n = \\\"\\\\\\\"\\\" terminalChar* \\\"\\\\\\\"\\\"\\n\\n oneCharTerminal\\n = \\\"\\\\\\\"\\\" terminalChar \\\"\\\\\\\"\\\"\\n\\n terminalChar\\n = escapeChar\\n | ~\\\"\\\\\\\\\\\" ~\\\"\\\\\\\"\\\" ~\\\"\\\\n\\\" any\\n\\n escapeChar (an escape sequence)\\n = \\\"\\\\\\\\\\\\\\\\\\\" -- backslash\\n | \\\"\\\\\\\\\\\\\\\"\\\" -- doubleQuote\\n | \\\"\\\\\\\\\\\\'\\\" -- singleQuote\\n | \\\"\\\\\\\\b\\\" -- backspace\\n | \\\"\\\\\\\\n\\\" -- lineFeed\\n | \\\"\\\\\\\\r\\\" -- carriageReturn\\n | \\\"\\\\\\\\t\\\" -- tab\\n | \\\"\\\\\\\\u\\\" hexDigit hexDigit hexDigit hexDigit -- unicodeEscape\\n | \\\"\\\\\\\\x\\\" hexDigit hexDigit -- hexEscape\\n\\n space\\n += comment\\n\\n comment\\n = \\\"//\\\" (~\\\"\\\\n\\\" any)* &(\\\"\\\\n\\\" | end) -- singleLine\\n | \\\"/*\\\" (~\\\"*/\\\" any)* \\\"*/\\\" -- multiLine\\n\\n tokens = token*\\n\\n token = caseName | comment | ident | operator | punctuation | terminal | any\\n\\n operator = \\\"<:\\\" | \\\"=\\\" | \\\":=\\\" | \\\"+=\\\" | \\\"*\\\" | \\\"+\\\" | \\\"?\\\" | \\\"~\\\" | \\\"&\\\"\\n\\n punctuation = \\\"<\\\" | \\\">\\\" | \\\",\\\" | \\\"--\\\"\\n}\"},\"Ohm\",null,\"Grammars\",{\"Grammars\":[\"define\",{\"sourceInterval\":[9,32]},null,[],[\"star\",{\"sourceInterval\":[24,32]},[\"app\",{\"sourceInterval\":[24,31]},\"Grammar\",[]]]],\"Grammar\":[\"define\",{\"sourceInterval\":[36,83]},null,[],[\"seq\",{\"sourceInterval\":[50,83]},[\"app\",{\"sourceInterval\":[50,55]},\"ident\",[]],[\"opt\",{\"sourceInterval\":[56,69]},[\"app\",{\"sourceInterval\":[56,68]},\"SuperGrammar\",[]]],[\"terminal\",{\"sourceInterval\":[70,73]},\"{\"],[\"star\",{\"sourceInterval\":[74,79]},[\"app\",{\"sourceInterval\":[74,78]},\"Rule\",[]]],[\"terminal\",{\"sourceInterval\":[80,83]},\"}\"]]],\"SuperGrammar\":[\"define\",{\"sourceInterval\":[87,116]},null,[],[\"seq\",{\"sourceInterval\":[106,116]},[\"terminal\",{\"sourceInterval\":[106,110]},\"<:\"],[\"app\",{\"sourceInterval\":[111,116]},\"ident\",[]]]],\"Rule_define\":[\"define\",{\"sourceInterval\":[131,181]},null,[],[\"seq\",{\"sourceInterval\":[131,170]},[\"app\",{\"sourceInterval\":[131,136]},\"ident\",[]],[\"opt\",{\"sourceInterval\":[137,145]},[\"app\",{\"sourceInterval\":[137,144]},\"Formals\",[]]],[\"opt\",{\"sourceInterval\":[146,156]},[\"app\",{\"sourceInterval\":[146,155]},\"ruleDescr\",[]]],[\"terminal\",{\"sourceInterval\":[157,160]},\"=\"],[\"app\",{\"sourceInterval\":[162,170]},\"RuleBody\",[]]]],\"Rule_override\":[\"define\",{\"sourceInterval\":[188,248]},null,[],[\"seq\",{\"sourceInterval\":[188,235]},[\"app\",{\"sourceInterval\":[188,193]},\"ident\",[]],[\"opt\",{\"sourceInterval\":[194,202]},[\"app\",{\"sourceInterval\":[194,201]},\"Formals\",[]]],[\"terminal\",{\"sourceInterval\":[214,218]},\":=\"],[\"app\",{\"sourceInterval\":[219,235]},\"OverrideRuleBody\",[]]]],\"Rule_extend\":[\"define\",{\"sourceInterval\":[255,305]},null,[],[\"seq\",{\"sourceInterval\":[255,294]},[\"app\",{\"sourceInterval\":[255,260]},\"ident\",[]],[\"opt\",{\"sourceInterval\":[261,269]},[\"app\",{\"sourceInterval\":[261,268]},\"Formals\",[]]],[\"terminal\",{\"sourceInterval\":[281,285]},\"+=\"],[\"app\",{\"sourceInterval\":[286,294]},\"RuleBody\",[]]]],\"Rule\":[\"define\",{\"sourceInterval\":[120,305]},null,[],[\"alt\",{\"sourceInterval\":[131,305]},[\"app\",{\"sourceInterval\":[131,170]},\"Rule_define\",[]],[\"app\",{\"sourceInterval\":[188,235]},\"Rule_override\",[]],[\"app\",{\"sourceInterval\":[255,294]},\"Rule_extend\",[]]]],\"RuleBody\":[\"define\",{\"sourceInterval\":[309,362]},null,[],[\"seq\",{\"sourceInterval\":[324,362]},[\"opt\",{\"sourceInterval\":[324,328]},[\"terminal\",{\"sourceInterval\":[324,327]},\"|\"]],[\"app\",{\"sourceInterval\":[329,362]},\"NonemptyListOf\",[[\"app\",{\"sourceInterval\":[344,356]},\"TopLevelTerm\",[]],[\"terminal\",{\"sourceInterval\":[358,361]},\"|\"]]]]],\"TopLevelTerm_inline\":[\"define\",{\"sourceInterval\":[385,408]},null,[],[\"seq\",{\"sourceInterval\":[385,397]},[\"app\",{\"sourceInterval\":[385,388]},\"Seq\",[]],[\"app\",{\"sourceInterval\":[389,397]},\"caseName\",[]]]],\"TopLevelTerm\":[\"define\",{\"sourceInterval\":[366,418]},null,[],[\"alt\",{\"sourceInterval\":[385,418]},[\"app\",{\"sourceInterval\":[385,397]},\"TopLevelTerm_inline\",[]],[\"app\",{\"sourceInterval\":[415,418]},\"Seq\",[]]]],\"OverrideRuleBody\":[\"define\",{\"sourceInterval\":[422,491]},null,[],[\"seq\",{\"sourceInterval\":[445,491]},[\"opt\",{\"sourceInterval\":[445,449]},[\"terminal\",{\"sourceInterval\":[445,448]},\"|\"]],[\"app\",{\"sourceInterval\":[450,491]},\"NonemptyListOf\",[[\"app\",{\"sourceInterval\":[465,485]},\"OverrideTopLevelTerm\",[]],[\"terminal\",{\"sourceInterval\":[487,490]},\"|\"]]]]],\"OverrideTopLevelTerm_superSplice\":[\"define\",{\"sourceInterval\":[522,543]},null,[],[\"terminal\",{\"sourceInterval\":[522,527]},\"...\"]],\"OverrideTopLevelTerm\":[\"define\",{\"sourceInterval\":[495,562]},null,[],[\"alt\",{\"sourceInterval\":[522,562]},[\"app\",{\"sourceInterval\":[522,527]},\"OverrideTopLevelTerm_superSplice\",[]],[\"app\",{\"sourceInterval\":[550,562]},\"TopLevelTerm\",[]]]],\"Formals\":[\"define\",{\"sourceInterval\":[566,606]},null,[],[\"seq\",{\"sourceInterval\":[580,606]},[\"terminal\",{\"sourceInterval\":[580,583]},\"<\"],[\"app\",{\"sourceInterval\":[584,602]},\"ListOf\",[[\"app\",{\"sourceInterval\":[591,596]},\"ident\",[]],[\"terminal\",{\"sourceInterval\":[598,601]},\",\"]]],[\"terminal\",{\"sourceInterval\":[603,606]},\">\"]]],\"Params\":[\"define\",{\"sourceInterval\":[610,647]},null,[],[\"seq\",{\"sourceInterval\":[623,647]},[\"terminal\",{\"sourceInterval\":[623,626]},\"<\"],[\"app\",{\"sourceInterval\":[627,643]},\"ListOf\",[[\"app\",{\"sourceInterval\":[634,637]},\"Seq\",[]],[\"terminal\",{\"sourceInterval\":[639,642]},\",\"]]],[\"terminal\",{\"sourceInterval\":[644,647]},\">\"]]],\"Alt\":[\"define\",{\"sourceInterval\":[651,685]},null,[],[\"app\",{\"sourceInterval\":[661,685]},\"NonemptyListOf\",[[\"app\",{\"sourceInterval\":[676,679]},\"Seq\",[]],[\"terminal\",{\"sourceInterval\":[681,684]},\"|\"]]]],\"Seq\":[\"define\",{\"sourceInterval\":[689,704]},null,[],[\"star\",{\"sourceInterval\":[699,704]},[\"app\",{\"sourceInterval\":[699,703]},\"Iter\",[]]]],\"Iter_star\":[\"define\",{\"sourceInterval\":[719,736]},null,[],[\"seq\",{\"sourceInterval\":[719,727]},[\"app\",{\"sourceInterval\":[719,723]},\"Pred\",[]],[\"terminal\",{\"sourceInterval\":[724,727]},\"*\"]]],\"Iter_plus\":[\"define\",{\"sourceInterval\":[743,760]},null,[],[\"seq\",{\"sourceInterval\":[743,751]},[\"app\",{\"sourceInterval\":[743,747]},\"Pred\",[]],[\"terminal\",{\"sourceInterval\":[748,751]},\"+\"]]],\"Iter_opt\":[\"define\",{\"sourceInterval\":[767,783]},null,[],[\"seq\",{\"sourceInterval\":[767,775]},[\"app\",{\"sourceInterval\":[767,771]},\"Pred\",[]],[\"terminal\",{\"sourceInterval\":[772,775]},\"?\"]]],\"Iter\":[\"define\",{\"sourceInterval\":[708,794]},null,[],[\"alt\",{\"sourceInterval\":[719,794]},[\"app\",{\"sourceInterval\":[719,727]},\"Iter_star\",[]],[\"app\",{\"sourceInterval\":[743,751]},\"Iter_plus\",[]],[\"app\",{\"sourceInterval\":[767,775]},\"Iter_opt\",[]],[\"app\",{\"sourceInterval\":[790,794]},\"Pred\",[]]]],\"Pred_not\":[\"define\",{\"sourceInterval\":[809,824]},null,[],[\"seq\",{\"sourceInterval\":[809,816]},[\"terminal\",{\"sourceInterval\":[809,812]},\"~\"],[\"app\",{\"sourceInterval\":[813,816]},\"Lex\",[]]]],\"Pred_lookahead\":[\"define\",{\"sourceInterval\":[831,852]},null,[],[\"seq\",{\"sourceInterval\":[831,838]},[\"terminal\",{\"sourceInterval\":[831,834]},\"&\"],[\"app\",{\"sourceInterval\":[835,838]},\"Lex\",[]]]],\"Pred\":[\"define\",{\"sourceInterval\":[798,862]},null,[],[\"alt\",{\"sourceInterval\":[809,862]},[\"app\",{\"sourceInterval\":[809,816]},\"Pred_not\",[]],[\"app\",{\"sourceInterval\":[831,838]},\"Pred_lookahead\",[]],[\"app\",{\"sourceInterval\":[859,862]},\"Lex\",[]]]],\"Lex_lex\":[\"define\",{\"sourceInterval\":[876,892]},null,[],[\"seq\",{\"sourceInterval\":[876,884]},[\"terminal\",{\"sourceInterval\":[876,879]},\"#\"],[\"app\",{\"sourceInterval\":[880,884]},\"Base\",[]]]],\"Lex\":[\"define\",{\"sourceInterval\":[866,903]},null,[],[\"alt\",{\"sourceInterval\":[876,903]},[\"app\",{\"sourceInterval\":[876,884]},\"Lex_lex\",[]],[\"app\",{\"sourceInterval\":[899,903]},\"Base\",[]]]],\"Base_application\":[\"define\",{\"sourceInterval\":[918,979]},null,[],[\"seq\",{\"sourceInterval\":[918,963]},[\"app\",{\"sourceInterval\":[918,923]},\"ident\",[]],[\"opt\",{\"sourceInterval\":[924,931]},[\"app\",{\"sourceInterval\":[924,930]},\"Params\",[]]],[\"not\",{\"sourceInterval\":[932,963]},[\"alt\",{\"sourceInterval\":[934,962]},[\"seq\",{\"sourceInterval\":[934,948]},[\"opt\",{\"sourceInterval\":[934,944]},[\"app\",{\"sourceInterval\":[934,943]},\"ruleDescr\",[]]],[\"terminal\",{\"sourceInterval\":[945,948]},\"=\"]],[\"terminal\",{\"sourceInterval\":[951,955]},\":=\"],[\"terminal\",{\"sourceInterval\":[958,962]},\"+=\"]]]]],\"Base_range\":[\"define\",{\"sourceInterval\":[986,1041]},null,[],[\"seq\",{\"sourceInterval\":[986,1022]},[\"app\",{\"sourceInterval\":[986,1001]},\"oneCharTerminal\",[]],[\"terminal\",{\"sourceInterval\":[1002,1006]},\"..\"],[\"app\",{\"sourceInterval\":[1007,1022]},\"oneCharTerminal\",[]]]],\"Base_terminal\":[\"define\",{\"sourceInterval\":[1048,1106]},null,[],[\"app\",{\"sourceInterval\":[1048,1056]},\"terminal\",[]]],\"Base_paren\":[\"define\",{\"sourceInterval\":[1113,1168]},null,[],[\"seq\",{\"sourceInterval\":[1113,1124]},[\"terminal\",{\"sourceInterval\":[1113,1116]},\"(\"],[\"app\",{\"sourceInterval\":[1117,1120]},\"Alt\",[]],[\"terminal\",{\"sourceInterval\":[1121,1124]},\")\"]]],\"Base\":[\"define\",{\"sourceInterval\":[907,1168]},null,[],[\"alt\",{\"sourceInterval\":[918,1168]},[\"app\",{\"sourceInterval\":[918,963]},\"Base_application\",[]],[\"app\",{\"sourceInterval\":[986,1022]},\"Base_range\",[]],[\"app\",{\"sourceInterval\":[1048,1056]},\"Base_terminal\",[]],[\"app\",{\"sourceInterval\":[1113,1124]},\"Base_paren\",[]]]],\"ruleDescr\":[\"define\",{\"sourceInterval\":[1172,1231]},\"a rule description\",[],[\"seq\",{\"sourceInterval\":[1210,1231]},[\"terminal\",{\"sourceInterval\":[1210,1213]},\"(\"],[\"app\",{\"sourceInterval\":[1214,1227]},\"ruleDescrText\",[]],[\"terminal\",{\"sourceInterval\":[1228,1231]},\")\"]]],\"ruleDescrText\":[\"define\",{\"sourceInterval\":[1235,1266]},null,[],[\"star\",{\"sourceInterval\":[1255,1266]},[\"seq\",{\"sourceInterval\":[1256,1264]},[\"not\",{\"sourceInterval\":[1256,1260]},[\"terminal\",{\"sourceInterval\":[1257,1260]},\")\"]],[\"app\",{\"sourceInterval\":[1261,1264]},\"any\",[]]]]],\"caseName\":[\"define\",{\"sourceInterval\":[1270,1338]},null,[],[\"seq\",{\"sourceInterval\":[1285,1338]},[\"terminal\",{\"sourceInterval\":[1285,1289]},\"--\"],[\"star\",{\"sourceInterval\":[1290,1304]},[\"seq\",{\"sourceInterval\":[1291,1302]},[\"not\",{\"sourceInterval\":[1291,1296]},[\"terminal\",{\"sourceInterval\":[1292,1296]},\"\\n\"]],[\"app\",{\"sourceInterval\":[1297,1302]},\"space\",[]]]],[\"app\",{\"sourceInterval\":[1305,1309]},\"name\",[]],[\"star\",{\"sourceInterval\":[1310,1324]},[\"seq\",{\"sourceInterval\":[1311,1322]},[\"not\",{\"sourceInterval\":[1311,1316]},[\"terminal\",{\"sourceInterval\":[1312,1316]},\"\\n\"]],[\"app\",{\"sourceInterval\":[1317,1322]},\"space\",[]]]],[\"alt\",{\"sourceInterval\":[1326,1337]},[\"terminal\",{\"sourceInterval\":[1326,1330]},\"\\n\"],[\"lookahead\",{\"sourceInterval\":[1333,1337]},[\"terminal\",{\"sourceInterval\":[1334,1337]},\"}\"]]]]],\"name\":[\"define\",{\"sourceInterval\":[1342,1382]},\"a name\",[],[\"seq\",{\"sourceInterval\":[1363,1382]},[\"app\",{\"sourceInterval\":[1363,1372]},\"nameFirst\",[]],[\"star\",{\"sourceInterval\":[1373,1382]},[\"app\",{\"sourceInterval\":[1373,1381]},\"nameRest\",[]]]]],\"nameFirst\":[\"define\",{\"sourceInterval\":[1386,1418]},null,[],[\"alt\",{\"sourceInterval\":[1402,1418]},[\"terminal\",{\"sourceInterval\":[1402,1405]},\"_\"],[\"app\",{\"sourceInterval\":[1412,1418]},\"letter\",[]]]],\"nameRest\":[\"define\",{\"sourceInterval\":[1422,1452]},null,[],[\"alt\",{\"sourceInterval\":[1437,1452]},[\"terminal\",{\"sourceInterval\":[1437,1440]},\"_\"],[\"app\",{\"sourceInterval\":[1447,1452]},\"alnum\",[]]]],\"ident\":[\"define\",{\"sourceInterval\":[1456,1489]},\"an identifier\",[],[\"app\",{\"sourceInterval\":[1485,1489]},\"name\",[]]],\"terminal\":[\"define\",{\"sourceInterval\":[1493,1531]},null,[],[\"seq\",{\"sourceInterval\":[1508,1531]},[\"terminal\",{\"sourceInterval\":[1508,1512]},\"\\\"\"],[\"star\",{\"sourceInterval\":[1513,1526]},[\"app\",{\"sourceInterval\":[1513,1525]},\"terminalChar\",[]]],[\"terminal\",{\"sourceInterval\":[1527,1531]},\"\\\"\"]]],\"oneCharTerminal\":[\"define\",{\"sourceInterval\":[1535,1579]},null,[],[\"seq\",{\"sourceInterval\":[1557,1579]},[\"terminal\",{\"sourceInterval\":[1557,1561]},\"\\\"\"],[\"app\",{\"sourceInterval\":[1562,1574]},\"terminalChar\",[]],[\"terminal\",{\"sourceInterval\":[1575,1579]},\"\\\"\"]]],\"terminalChar\":[\"define\",{\"sourceInterval\":[1583,1640]},null,[],[\"alt\",{\"sourceInterval\":[1602,1640]},[\"app\",{\"sourceInterval\":[1602,1612]},\"escapeChar\",[]],[\"seq\",{\"sourceInterval\":[1619,1640]},[\"not\",{\"sourceInterval\":[1619,1624]},[\"terminal\",{\"sourceInterval\":[1620,1624]},\"\\\\\"]],[\"not\",{\"sourceInterval\":[1625,1630]},[\"terminal\",{\"sourceInterval\":[1626,1630]},\"\\\"\"]],[\"not\",{\"sourceInterval\":[1631,1636]},[\"terminal\",{\"sourceInterval\":[1632,1636]},\"\\n\"]],[\"app\",{\"sourceInterval\":[1637,1640]},\"any\",[]]]]],\"escapeChar_backslash\":[\"define\",{\"sourceInterval\":[1683,1738]},null,[],[\"terminal\",{\"sourceInterval\":[1683,1689]},\"\\\\\\\\\"]],\"escapeChar_doubleQuote\":[\"define\",{\"sourceInterval\":[1745,1802]},null,[],[\"terminal\",{\"sourceInterval\":[1745,1751]},\"\\\\\\\"\"]],\"escapeChar_singleQuote\":[\"define\",{\"sourceInterval\":[1809,1866]},null,[],[\"terminal\",{\"sourceInterval\":[1809,1815]},\"\\\\'\"]],\"escapeChar_backspace\":[\"define\",{\"sourceInterval\":[1873,1928]},null,[],[\"terminal\",{\"sourceInterval\":[1873,1878]},\"\\\\b\"]],\"escapeChar_lineFeed\":[\"define\",{\"sourceInterval\":[1935,1989]},null,[],[\"terminal\",{\"sourceInterval\":[1935,1940]},\"\\\\n\"]],\"escapeChar_carriageReturn\":[\"define\",{\"sourceInterval\":[1996,2056]},null,[],[\"terminal\",{\"sourceInterval\":[1996,2001]},\"\\\\r\"]],\"escapeChar_tab\":[\"define\",{\"sourceInterval\":[2063,2112]},null,[],[\"terminal\",{\"sourceInterval\":[2063,2068]},\"\\\\t\"]],\"escapeChar_unicodeEscape\":[\"define\",{\"sourceInterval\":[2119,2178]},null,[],[\"seq\",{\"sourceInterval\":[2119,2160]},[\"terminal\",{\"sourceInterval\":[2119,2124]},\"\\\\u\"],[\"app\",{\"sourceInterval\":[2125,2133]},\"hexDigit\",[]],[\"app\",{\"sourceInterval\":[2134,2142]},\"hexDigit\",[]],[\"app\",{\"sourceInterval\":[2143,2151]},\"hexDigit\",[]],[\"app\",{\"sourceInterval\":[2152,2160]},\"hexDigit\",[]]]],\"escapeChar_hexEscape\":[\"define\",{\"sourceInterval\":[2185,2240]},null,[],[\"seq\",{\"sourceInterval\":[2185,2208]},[\"terminal\",{\"sourceInterval\":[2185,2190]},\"\\\\x\"],[\"app\",{\"sourceInterval\":[2191,2199]},\"hexDigit\",[]],[\"app\",{\"sourceInterval\":[2200,2208]},\"hexDigit\",[]]]],\"escapeChar\":[\"define\",{\"sourceInterval\":[1644,2240]},\"an escape sequence\",[],[\"alt\",{\"sourceInterval\":[1683,2240]},[\"app\",{\"sourceInterval\":[1683,1689]},\"escapeChar_backslash\",[]],[\"app\",{\"sourceInterval\":[1745,1751]},\"escapeChar_doubleQuote\",[]],[\"app\",{\"sourceInterval\":[1809,1815]},\"escapeChar_singleQuote\",[]],[\"app\",{\"sourceInterval\":[1873,1878]},\"escapeChar_backspace\",[]],[\"app\",{\"sourceInterval\":[1935,1940]},\"escapeChar_lineFeed\",[]],[\"app\",{\"sourceInterval\":[1996,2001]},\"escapeChar_carriageReturn\",[]],[\"app\",{\"sourceInterval\":[2063,2068]},\"escapeChar_tab\",[]],[\"app\",{\"sourceInterval\":[2119,2160]},\"escapeChar_unicodeEscape\",[]],[\"app\",{\"sourceInterval\":[2185,2208]},\"escapeChar_hexEscape\",[]]]],\"space\":[\"extend\",{\"sourceInterval\":[2244,2263]},null,[],[\"app\",{\"sourceInterval\":[2256,2263]},\"comment\",[]]],\"comment_singleLine\":[\"define\",{\"sourceInterval\":[2281,2327]},null,[],[\"seq\",{\"sourceInterval\":[2281,2312]},[\"terminal\",{\"sourceInterval\":[2281,2285]},\"//\"],[\"star\",{\"sourceInterval\":[2286,2298]},[\"seq\",{\"sourceInterval\":[2287,2296]},[\"not\",{\"sourceInterval\":[2287,2292]},[\"terminal\",{\"sourceInterval\":[2288,2292]},\"\\n\"]],[\"app\",{\"sourceInterval\":[2293,2296]},\"any\",[]]]],[\"lookahead\",{\"sourceInterval\":[2299,2312]},[\"alt\",{\"sourceInterval\":[2301,2311]},[\"terminal\",{\"sourceInterval\":[2301,2305]},\"\\n\"],[\"app\",{\"sourceInterval\":[2308,2311]},\"end\",[]]]]]],\"comment_multiLine\":[\"define\",{\"sourceInterval\":[2334,2370]},null,[],[\"seq\",{\"sourceInterval\":[2334,2356]},[\"terminal\",{\"sourceInterval\":[2334,2338]},\"/*\"],[\"star\",{\"sourceInterval\":[2339,2351]},[\"seq\",{\"sourceInterval\":[2340,2349]},[\"not\",{\"sourceInterval\":[2340,2345]},[\"terminal\",{\"sourceInterval\":[2341,2345]},\"*/\"]],[\"app\",{\"sourceInterval\":[2346,2349]},\"any\",[]]]],[\"terminal\",{\"sourceInterval\":[2352,2356]},\"*/\"]]],\"comment\":[\"define\",{\"sourceInterval\":[2267,2370]},null,[],[\"alt\",{\"sourceInterval\":[2281,2370]},[\"app\",{\"sourceInterval\":[2281,2312]},\"comment_singleLine\",[]],[\"app\",{\"sourceInterval\":[2334,2356]},\"comment_multiLine\",[]]]],\"tokens\":[\"define\",{\"sourceInterval\":[2374,2389]},null,[],[\"star\",{\"sourceInterval\":[2383,2389]},[\"app\",{\"sourceInterval\":[2383,2388]},\"token\",[]]]],\"token\":[\"define\",{\"sourceInterval\":[2393,2469]},null,[],[\"alt\",{\"sourceInterval\":[2401,2469]},[\"app\",{\"sourceInterval\":[2401,2409]},\"caseName\",[]],[\"app\",{\"sourceInterval\":[2412,2419]},\"comment\",[]],[\"app\",{\"sourceInterval\":[2422,2427]},\"ident\",[]],[\"app\",{\"sourceInterval\":[2430,2438]},\"operator\",[]],[\"app\",{\"sourceInterval\":[2441,2452]},\"punctuation\",[]],[\"app\",{\"sourceInterval\":[2455,2463]},\"terminal\",[]],[\"app\",{\"sourceInterval\":[2466,2469]},\"any\",[]]]],\"operator\":[\"define\",{\"sourceInterval\":[2473,2538]},null,[],[\"alt\",{\"sourceInterval\":[2484,2538]},[\"terminal\",{\"sourceInterval\":[2484,2488]},\"<:\"],[\"terminal\",{\"sourceInterval\":[2491,2494]},\"=\"],[\"terminal\",{\"sourceInterval\":[2497,2501]},\":=\"],[\"terminal\",{\"sourceInterval\":[2504,2508]},\"+=\"],[\"terminal\",{\"sourceInterval\":[2511,2514]},\"*\"],[\"terminal\",{\"sourceInterval\":[2517,2520]},\"+\"],[\"terminal\",{\"sourceInterval\":[2523,2526]},\"?\"],[\"terminal\",{\"sourceInterval\":[2529,2532]},\"~\"],[\"terminal\",{\"sourceInterval\":[2535,2538]},\"&\"]]],\"punctuation\":[\"define\",{\"sourceInterval\":[2542,2578]},null,[],[\"alt\",{\"sourceInterval\":[2556,2578]},[\"terminal\",{\"sourceInterval\":[2556,2559]},\"<\"],[\"terminal\",{\"sourceInterval\":[2562,2565]},\">\"],[\"terminal\",{\"sourceInterval\":[2568,2571]},\",\"],[\"terminal\",{\"sourceInterval\":[2574,2578]},\"--\"]]]}]);\n"],"names":["$11c66a64a5a88e06$var$Failure","pexpr","text","type","$11c66a64a5a88e06$var$isValidType","Error","this","fluffy","prototype","getPExpr","getText","getType","isDescription","isStringTerminal","isCode","isFluffy","makeFluffy","clearFluffy","subsumes","that","toString","JSON","stringify","clone","failure","toKey","$11c66a64a5a88e06$exports","$cb6ed35a9e21f48a$export$817eb92a8194bab0","$cb6ed35a9e21f48a$export$a7a9523472993e97","$cb6ed35a9e21f48a$export$1eb31d8ccbbbc638","$cb6ed35a9e21f48a$export$9cd59f9826255e47","$cb6ed35a9e21f48a$export$8f8128772e09cd81","$cb6ed35a9e21f48a$export$d6a6a8e48e4bad63","$cb6ed35a9e21f48a$export$76d90c956114f2c2","$cb6ed35a9e21f48a$export$1a47093b60e54e96","$cb6ed35a9e21f48a$export$8c70279880500ad3","$cb6ed35a9e21f48a$export$41fdc1de1da6ab9b","$cb6ed35a9e21f48a$export$f9f4599cdf73f828","$cb6ed35a9e21f48a$export$bc3bea8325045070","$cb6ed35a9e21f48a$export$83347051c3437dc9","$cb6ed35a9e21f48a$export$1e68cbf5a045c801","$cb6ed35a9e21f48a$export$999d5a1f9e17426e","$cb6ed35a9e21f48a$export$81c9cb19ca23770e","$cb6ed35a9e21f48a$var$escapeStringFor","c","String","fromCharCode","charCodeAt","optMethodName","methodName","constructor","name","cond","message","obj","propName","getterFn","memo","Object","defineProperty","get","call","assign","fn","n","arr","push","str","Array","join","x","array","duplicates","idx","length","lastIndexOf","indexOf","noDuplicates","forEach","entry","ruleName","firstChar","toUpperCase","len","optChar","ch","strings","append","contents","optDelim","charCode","s","charAt","parseInt","substring","baseToString","typeName","slice","e","$fb9cd8261316a99f$var$didWarnForPrimitiveValue","$fb9cd8261316a99f$var$Node","grammar","ctorName","matchLength","numChildren","children","childAt","indexOfChild","arg","hasChildren","hasNoChildren","onlyChild","firstChild","lastChild","childBefore","child","childIdx","childAfter","isTerminal","isNonterminal","isIteration","isOptional","toJSON","$93923a81e4fd7f44$export$f1bb6ea3bbab87ba","$93923a81e4fd7f44$export$4154a199d7d90455","$93923a81e4fd7f44$export$bd5df0f255a350f8","$93923a81e4fd7f44$export$8dd80f06eb58bfe1","$93923a81e4fd7f44$export$9a58ef0d7ad3278c","$93923a81e4fd7f44$export$1ca45c9a47aec42c","$93923a81e4fd7f44$export$25ba4469a069167","$93923a81e4fd7f44$export$5b5dd0e212d2a5bc","$93923a81e4fd7f44$export$ceb3ee475cfd64d1","$93923a81e4fd7f44$export$4802c350533dc67e","$93923a81e4fd7f44$export$ffbe1b4f1e592c3a","$93923a81e4fd7f44$export$1644ba17714857f1","$93923a81e4fd7f44$export$2d9ac7aa84f97a08","$93923a81e4fd7f44$export$a76800b3cc430f35","$93923a81e4fd7f44$export$8c5a605c8776de77","$93923a81e4fd7f44$export$580268a9119fd710","$93923a81e4fd7f44$export$43a76c134e83307c","$93923a81e4fd7f44$export$efc21ddc6aeb363d","$93923a81e4fd7f44$export$82f2f2b3ec52904","$fb9cd8261316a99f$exports","value","super","_value","primitiveValue","console","warn","childOffsets","isLexical","isSyntactic","optional","TerminalNode","$b9687b4f7417dd47$exports","Lu","Ll","Lt","Lm","Lo","Nl","Nd","Mn","Mc","Pc","Zs","L","Ltmo","$93923a81e4fd7f44$var$PExpr","withSource","interval","source","trimmed","$93923a81e4fd7f44$var$any","create","$93923a81e4fd7f44$var$end","$93923a81e4fd7f44$var$Alt","terms","$93923a81e4fd7f44$var$Iter","expr","$93923a81e4fd7f44$var$Star","$93923a81e4fd7f44$var$Plus","$93923a81e4fd7f44$var$Opt","operator","minNumMatches","maxNumMatches","Number","POSITIVE_INFINITY","from","to","index","superGrammar","body","rules","beforeTerms","afterTerms","origBody","expansionPos","factors","args","toMemoKey","_memoKey","category","pattern","allowsSkippingPrecedingSpace","$3f4ec1364805b278$var$Namespace","$46b6d70649971a22$var$createError","optInterval","getLineAndColumnMessage","shortMessage","asNamespace","objOrNamespace","createNamespace","optProps","extend","namespace","TypeError","ns","enumerable","writable","configurable","$3f4ec1364805b278$exports","$46b6d70649971a22$exports","applyExpr","grammarName","optSource","declGrammarName","expected","actual","expectedType","getArity","matchFailure","getExpectedText","getInterval","kleeneExpr","applicationStack","actuals","substituteParams","map","app","stack","stackTrace","info","ans","moreInfo","throwErrors","errors","messages","concat","$46b6d70649971a22$var$multipleErrors","$e847203d48b8b99b$export$1781a71bf0bc728d","$e847203d48b8b99b$export$be176d47c2921f22","$e847203d48b8b99b$export$e25e9b0111c8d659","$e847203d48b8b99b$export$c5fbb07c01caabdd","$e847203d48b8b99b$export$8b15d37bc3f197d4","$e847203d48b8b99b$var$strcpy","dest","src","offset","origDestLen","substr","$e847203d48b8b99b$var$lineAndColumnToMessage","ranges","lineAndCol","repeatStr","$cb6ed35a9e21f48a$exports","sb","StringBuffer","lineNum","colNum","lineNumbers","maxLen","Math","max","padLeft","$e847203d48b8b99b$var$padNumbersToEqualLength","prevLine","nextLine","appendLine","num","content","prefix","line","lineLen","indicationLine","i","startIdx","endIdx","assert","lineStartOffset","min","gutterWidth","replace","$d8c50d90e73d6ec1$var$BuiltInRules","$d8c50d90e73d6ec1$var$lexifyCount","$e847203d48b8b99b$var$builtInRulesCallbacks","cb","currOffset","prevLineStartOffset","lineEndOffset","nextLineEndOffset","idCounter","g","assertAllApplicationsAreValid","_assertAllApplicationsAreValid","$d8c50d90e73d6ec1$require$abstract","skipSyntacticCheck","ruleInfo","undeclaredRule","$d8c50d90e73d6ec1$require$isSyntactic","applicationOfSyntacticRuleFromLexicalContext","formals","wrongNumberOfArguments","isBuiltInApplySyntactic","experimentalApplySyntactic","isBuiltInCaseInsensitive","caseInsensitive","invalidParameter","incorrectArgumentType","experimentalApplySyntacticWithLexicalRuleApplication","assertChoicesHaveUniformArity","arity","term","otherArity","inconsistentArity","actualArity","expectedArity","assertIteratedExprsAreNotNullable","isNullable","kleeneExprHasNullableOperand","$96997716f7a8f475$var$Interval","sourceString","coverage","firstInterval","intervals","intervalSourcesDontMatch","coverageWith","collapsedLeft","collapsedRight","getLineAndColumn","range","minus","relativeTo","match","subInterval","newStartIdx","defineProperties","undefined","_contents","$96997716f7a8f475$exports","$f7368bebf450ed66$var$Flags","succeeded","isRootNode","isImplicitSpaces","isMemoized","isHeadOfLeftRecursion","terminatesLR","$f7368bebf450ed66$var$asEscapedString","$f7368bebf450ed66$var$Trace","input","pos1","pos2","bindings","optChildren","pos","terminatingLREntry","_flags","SKIP","toDisplayString","keys","mask","set","val","cloneWithExpr","recordLRTermination","ruleBodyTrace","walk","visitorObjOrFn","optThisArg","visitor","_walk","node","parent","depth","recurse","enter","exit","excerpt","$f7368bebf450ed66$var$getInputExcerpt","displayString","$f7368bebf450ed66$exports","$918004d506b8242c$var$TerminalNode","NonterminalNode","$918004d506b8242c$var$NonterminalNode","IterationNode","$918004d506b8242c$var$IterationNode","$2865004b486b57f5$var$getMetaInfo","grammarInterval","metaInfo","adjusted","sourceInterval","eval","state","inputStream","origPos","next","pushBinding","processFailure","atEnd","matchString","currentApplication","enterLexifiedContext","exitLexifiedContext","factor","cols","colOffsets","numMatches","prevPos","_applicationStack","row","_bindings","splice","rowOffsets","_bindingOffsets","posToOffset","lastCol","lastColOffsets","endOffset","pushFailuresInfo","popFailuresInfo","caller","posInfo","getCurrentPosInfo","isActive","handleCycle","memoKey","memoRec","shouldUseMemoizedResult","hasNecessaryInfo","useMemoizedResult","reallyEval","currentLeftRecursion","headApplication","updateInvolvedApplicationMemoKeys","memoize","examinedLength","rightmostFailureOffset","startLeftRecursion","origPosInfo","description","enterApplication","origInputStreamExaminedLength","evalOnce","currentLR","growSeedResult","endLeftRecursion","_getRightmostFailureOffset","isInvolved","failuresAtRightmostPosition","cloneRecordedFailures","isTracing","getTraceEntry","traceEntry","exitApplication","offsets","lrMemoRec","newValue","seedTrace","trace","pop","test","outputRecipe","toLowerCase","introduceParams","_isNullable","some","every","key","hasOwnProperty","inlined","copyWithoutDuplicates","$c4c7835ce1acfaff$var$copyWithoutDuplicates","$c4c7835ce1acfaff$var$isRestrictedJSIdentifier","$c4c7835ce1acfaff$var$resolveDuplicatedNames","argumentNameList","count","argName","dupArgName","subscript","toArgumentNameList","abstract","firstArgIndex","noDupCheck","termArgNameLists","numArgs","colIdx","col","rowIdx","uniqueNames","factorArgumentNameList","exprArgumentString","ps","toFailure","t","f","$85665160fb8f362c$var$CaseInsensitiveTerminal","$85665160fb8f362c$require$PExpr","param","_getString","terminal","$85665160fb8f362c$require$Terminal","matchStr","$85665160fb8f362c$require$TerminalNode","$85665160fb8f362c$exports","$6ca09e5ace88f0ae$var$InputStream","optIgnoreCase","sourceSlice","optEndIdx","$6ca09e5ace88f0ae$exports","$423e136c86b2ffa6$var$MatchResult","matcher","startExpr","cst","cstOffset","rightmostFailurePosition","optRecordedFailures","_cst","_cstOffset","_rightmostFailurePosition","_rightmostFailures","failed","detail","getRightmostFailurePosition","errorInfo","getRightmostFailures","setInput","matchResultWithFailures","_match","failures","filter","$423e136c86b2ffa6$exports","$9d5d6c286b284d97$var$PosInfo","applicationMemoKeyStack","maxExaminedLength","maxRightmostFailureOffset","$2f0d859d7d94a9ca$var$builtInApplySyntacticBody","application","isLeftRecursion","nextLeftRecursion","indexOfFirstInvolvedRule","involvedApplicationMemoKeys","applicationMemoKey","clearObsoleteEntries","invalidatedIdx","k","$9d5d6c286b284d97$exports","builtInRules","$2f0d859d7d94a9ca$var$applySpaces","$2f0d859d7d94a9ca$var$MatchState","optPositionToRecordFailures","memoTable","_posStack","inLexifiedContextStack","_rightmostFailurePositionStack","_recordedFailuresStack","positionToRecordFailures","recordedFailures","$6d1ca06b119389ba$var$Matcher","optNode","inSyntacticContext","inLexifiedContext","skipSpaces","popBinding","skipSpacesIfInSyntacticContext","maybeSkipSpacesBefore","numBindings","truncateBindings","newLength","getPosInfo","recordFailure","shouldCloneIfNew","recordFailures","getMemoizedTraceEntry","memoRecRightmostFailurePosition","origNumBindings","origRecordedFailures","memoPos","origTrace","getMatchResult","rightmostFailures","getTrace","matchResult","rootTrace","result","$2f0d859d7d94a9ca$exports","getInput","replaceInputRange","currentInput","restOfMemoTable","optStartApplicationStr","_getStartExpr","tracing","applicationStr","defaultStartRule","startApp","parseApplication","$6d1ca06b119389ba$exports","$8e72d2bd46de1096$var$globalActionStack","$8e72d2bd46de1096$var$prototypeGrammar","$8e72d2bd46de1096$var$prototypeGrammarSemantics","$8e72d2bd46de1096$var$hasOwnProperty","prop","$8e72d2bd46de1096$var$Wrapper","baseInterval","_node","_baseInterval","_childWrappers","_forgetMemoizedResultFor","attributeName","_semantics","attributeKeys","childWrapper","childNode","base","wrap","_children","iteration","optChildWrappers","childWrappers","childNodes","iter","$8e72d2bd46de1096$require$IterationNode","wrapper","$8e72d2bd46de1096$var$Semantics","superSemantics","self","checkedActionDicts","Wrapper","checkActionDictsIfHaventAlready","equals","_inheritsFrom","operations","attributes","$8e72d2bd46de1096$var$parseSignature","signature","r","parse","checkActionDicts","checkActionDict","toRecipe","semanticsOnly","hasSuperSemantics","BuiltInSemantics","_getSemantics","superSemanticsGrammar","relatedGrammar","semanticOperations","actionDict","builtInDefault","method","srcArray","actionName","trim","addOperationOrAttribute","typePlural","parsedNameAndFormalArgs","assertNewName","doIt","formal","missingSemanticAction","apply","$8e72d2bd46de1096$var$newDefaultAction","realActionDict","_default","$8e72d2bd46de1096$var$Operation","$8e72d2bd46de1096$var$Attribute","thisThing","arguments","argsObj","entries","oldArgs","execute","extendOperationOrAttribute","inheritedFormals","inheritedActionDict","newActionDict","optBaseInterval","createSemantics","optSuperSemantics","proxy","addOperation","extendOperation","addAttribute","extendAttribute","_getActionDict","operationOrAttributeName","action","_remove","semantic","getOperationNames","getAttributeNames","getGrammar","bind","_checkTopDownActionDict","semantics","nodeWrapper","actionFn","_nonterminal","module","exports","$fce7ed0fecea3609$exports","makeRecipe","AttributeSignature","OperationSignature","Formals","nameFirst","nameRest","operationsAndAttributesGrammar","parcelRequire","actions","empty","nonEmpty","first","_","rest","emptyListOf","nonemptyListOf","EmptyListOf","NonemptyListOf","$8e72d2bd46de1096$var$initBuiltInSemantics","optFormals","oparen","fs","cparen","asIteration","$8e72d2bd46de1096$exports","$f9697f7a5ded4a61$var$SPECIAL_ACTION_NAMES","$f9697f7a5ded4a61$var$getSortedRuleValues","sort","$f9697f7a5ded4a61$var$Grammar","optDefaultStartRule","$f9697f7a5ded4a61$var$ohmGrammar","$f9697f7a5ded4a61$var$buildGrammar","initApplicationParser","builderFn","isBuiltIn","ProtoBuiltInRules","BuiltInRules","myRules","otherRules","rule","optStartApplication","m","extendSemantics","what","problems","v","includes","_topDownActionArity","details","prettyProblems","problem","error","superGrammarExpr","startRule","isDefinition","operation","bodyRecipe","superGrammarOutput","recipeElements","toOperationActionDictionaryTemplate","_toOperationOrAttributeActionDictionaryTemplate","toAttributeActionDictionaryTemplate","addSemanticActionTemplate","wrongNumberOfParameters","any","primitive","end","lower","upper","unicodeLtmo","spaces","space","$f9697f7a5ded4a61$exports","$0963dadbfa19f7d8$var$GrammarDecl","$02ffbb5c681998e1$var$Builder","ensureSuperGrammar","withSuperGrammar","ensureSuperGrammarRuleForOverriding","cannotOverrideUndeclaredRule","installOverriddenOrExtendedRule","duplicateParameterNames","expectedFormals","expectedNumFormals","install","withDefaultStartRule","build","grammarErrors","grammarHasInvalidApplications","e1","define","duplicateRuleDeclaration","override","descIgnored","fragment","cannotExtendUndeclaredRule","$0963dadbfa19f7d8$exports","currentDecl","currentRuleName","newGrammar","gDecl","fromRecipe","ruleRecipe","alt","termArgs","seq","factorArgs","star","plus","opt","not","la","lookahead","lex","optParams","recipe","$02ffbb5c681998e1$exports","$fce7ed0fecea3609$var$ohmGrammar","$d9b41dca5c8c8e99$exports","__GLOBAL_OHM_VERSION__","version","$fce7ed0fecea3609$var$superSplicePlaceholder","$fce7ed0fecea3609$var$buildGrammar","optOhmGrammarForTesting","builder","decl","currentRuleFormals","overriding","Grammars","grammarIter","visit","Grammar","id","_open","_close","duplicateGrammarDeclaration","SuperGrammar","superGrammarName","undeclaredGrammar","Rule_define","d","b","Rule_override","Rule_extend","RuleBody","OverrideRuleBody","multipleSuperSplices","opointy","cpointy","Params","Alt","seqs","TopLevelTerm_inline","inlineRuleName","isNewRuleDeclaration","params","OverrideTopLevelTerm_superSplice","Seq","Iter_star","Iter_plus","Iter_opt","Pred_not","Pred_lookahead","Lex_lex","Base_application","Base_range","Base_terminal","Base_paren","open","close","ruleDescr","ruleDescrText","caseName","space1","space2","cs","oneCharTerminal","terminalChar","escapeChar","xs","_terminal","helpers","$fce7ed0fecea3609$var$grammars","optNamespace","isBuffer","grammarSyntaxError","$fce7ed0fecea3609$var$compileAndLoad","VisitorFamily","semanticsForToAST","toAST","helper","$98ec399d36ddcccf$var$getProp","thing","$98ec399d36ddcccf$var$mapProp","$98ec399d36ddcccf$var$getPropWalkFn","descriptor","parts","split","$98ec399d36ddcccf$var$getProps","walkFns","walkFn","$98ec399d36ddcccf$var$isRestrictedIdentifier","$98ec399d36ddcccf$var$trim","$98ec399d36ddcccf$var$VisitorFamily","config","_shapes","shapes","_getTag","getTag","Adapter","family","_adaptee","_family","valueOf","_arities","_getChildren","shape","isArray","$98ec399d36ddcccf$var$getWalkFn","_wrap","_checkActionDict","dict","sig","$98ec399d36ddcccf$var$parseSignature","tag","$5ddfc6934df319e1$var$defaultOperation","mapping","realChildren","propMap","mappedProp","_iter","sep","res","termName","grammarNames","optNodeOrNodeList","ohmGrammar","$93923a81e4fd7f44$exports","$e847203d48b8b99b$exports","extras","_buildGrammar","alnum","letter","digit","hexDigit","ListOf","listOf","Rule","TopLevelTerm","OverrideTopLevelTerm","Iter","Pred","Lex","Base","ident","escapeChar_backslash","escapeChar_doubleQuote","escapeChar_singleQuote","escapeChar_backspace","escapeChar_lineFeed","escapeChar_carriageReturn","escapeChar_tab","escapeChar_unicodeEscape","escapeChar_hexEscape","comment_singleLine","comment_multiLine","comment","tokens","token","punctuation"],"version":3,"file":"main.js.map"}