{"version":3,"file":"731-a72eac494ce65a7ee317.js","mappings":"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","sources":["webpack:///./node_modules/lodash-es/clone.js","webpack:///./node_modules/lodash-es/findIndex.js","webpack:///./node_modules/lodash-es/find.js","webpack:///./node_modules/lodash-es/_createFind.js","webpack:///./node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-EQFLFMNE.mjs","webpack:///./node_modules/lodash-es/_baseExtremum.js","webpack:///./node_modules/lodash-es/_baseMap.js","webpack:///./node_modules/vscode-jsonrpc/lib/common/events.js","webpack:///./node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-NCMFTTUW.mjs","webpack:///./node_modules/lodash-es/defaults.js","webpack:///./node_modules/lodash-es/_trimmedEndIndex.js","webpack:///./node_modules/lodash-es/_baseTrim.js","webpack:///./node_modules/lodash-es/toNumber.js","webpack:///./node_modules/lodash-es/toFinite.js","webpack:///./node_modules/langium/lib/syntax-tree.js","webpack:///./node_modules/langium/lib/utils/stream.js","webpack:///./node_modules/langium/lib/utils/cst-utils.js","webpack:///./node_modules/langium/lib/utils/errors.js","webpack:///./node_modules/langium/lib/languages/generated/ast.js","webpack:///./node_modules/langium/lib/utils/ast-utils.js","webpack:///./node_modules/@chevrotain/regexp-to-ast/lib/src/utils.js","webpack:///./node_modules/@chevrotain/regexp-to-ast/lib/src/character-classes.js","webpack:///./node_modules/@chevrotain/regexp-to-ast/lib/src/regexp-parser.js","webpack:///./node_modules/@chevrotain/regexp-to-ast/lib/src/base-regexp-visitor.js","webpack:///./node_modules/langium/lib/utils/regexp-utils.js","webpack:///./node_modules/langium/lib/utils/grammar-utils.js","webpack:///./node_modules/@chevrotain/utils/lib/src/to-fast-properties.js","webpack:///./node_modules/lodash-es/_baseSlice.js","webpack:///./node_modules/lodash-es/drop.js","webpack:///./node_modules/lodash-es/assign.js","webpack:///./node_modules/lodash-es/pickBy.js","webpack:///./node_modules/lodash-es/isRegExp.js","webpack:///./node_modules/lodash-es/_baseIsRegExp.js","webpack:///./node_modules/@chevrotain/gast/lib/src/model.js","webpack:///./node_modules/@chevrotain/gast/lib/src/visitor.js","webpack:///./node_modules/lodash-es/_baseSome.js","webpack:///./node_modules/lodash-es/some.js","webpack:///./node_modules/lodash-es/includes.js","webpack:///./node_modules/lodash-es/_arrayEvery.js","webpack:///./node_modules/lodash-es/_baseEvery.js","webpack:///./node_modules/lodash-es/every.js","webpack:///./node_modules/@chevrotain/gast/lib/src/helpers.js","webpack:///./node_modules/chevrotain/lib/src/parse/grammar/rest.js","webpack:///./node_modules/lodash-es/uniq.js","webpack:///./node_modules/chevrotain/lib/src/parse/grammar/first.js","webpack:///./node_modules/chevrotain/lib/src/parse/constants.js","webpack:///./node_modules/chevrotain/lib/src/parse/grammar/follow.js","webpack:///./node_modules/lodash-es/negate.js","webpack:///./node_modules/lodash-es/reject.js","webpack:///./node_modules/lodash-es/indexOf.js","webpack:///./node_modules/lodash-es/difference.js","webpack:///./node_modules/lodash-es/_baseDifference.js","webpack:///./node_modules/lodash-es/compact.js","webpack:///./node_modules/lodash-es/head.js","webpack:///./node_modules/@chevrotain/utils/lib/src/print.js","webpack:///./node_modules/chevrotain/lib/src/scan/reg_exp_parser.js","webpack:///./node_modules/chevrotain/lib/src/scan/reg_exp.js","webpack:///./node_modules/chevrotain/lib/src/scan/lexer.js","webpack:///./node_modules/@chevrotain/utils/lib/src/timer.js","webpack:///./node_modules/chevrotain/lib/src/scan/tokens.js","webpack:///./node_modules/chevrotain/lib/src/scan/lexer_public.js","webpack:///./node_modules/chevrotain/lib/src/scan/lexer_errors_public.js","webpack:///./node_modules/chevrotain/lib/src/scan/tokens_public.js","webpack:///./node_modules/chevrotain/lib/src/parse/errors_public.js","webpack:///./node_modules/chevrotain/lib/src/parse/grammar/resolver.js","webpack:///./node_modules/lodash-es/flatMap.js","webpack:///./node_modules/lodash-es/_arrayAggregator.js","webpack:///./node_modules/lodash-es/_baseAggregator.js","webpack:///./node_modules/lodash-es/groupBy.js","webpack:///./node_modules/lodash-es/_createAggregator.js","webpack:///./node_modules/lodash-es/dropRight.js","webpack:///./node_modules/chevrotain/lib/src/parse/grammar/interpreter.js","webpack:///./node_modules/chevrotain/lib/src/parse/grammar/lookahead.js","webpack:///./node_modules/chevrotain/lib/src/parse/grammar/checks.js","webpack:///./node_modules/chevrotain/lib/src/parse/exceptions_public.js","webpack:///./node_modules/chevrotain/lib/src/parse/parser/traits/recoverable.js","webpack:///./node_modules/chevrotain/lib/src/parse/grammar/keys.js","webpack:///./node_modules/chevrotain/lib/src/parse/grammar/llk_lookahead.js","webpack:///./node_modules/chevrotain/lib/src/parse/parser/traits/looksahead.js","webpack:///./node_modules/chevrotain/lib/src/parse/cst/cst.js","webpack:///./node_modules/chevrotain/lib/src/lang/lang_extensions.js","webpack:///./node_modules/chevrotain/lib/src/parse/cst/cst_visitor.js","webpack:///./node_modules/chevrotain/lib/src/parse/parser/traits/gast_recorder.js","webpack:///./node_modules/chevrotain/lib/src/parse/parser/parser.js","webpack:///./node_modules/chevrotain/lib/src/parse/parser/utils/apply_mixins.js","webpack:///./node_modules/chevrotain/lib/src/parse/grammar/gast/gast_resolver_public.js","webpack:///./node_modules/chevrotain/lib/src/parse/parser/traits/tree_builder.js","webpack:///./node_modules/chevrotain/lib/src/parse/parser/traits/lexer_adapter.js","webpack:///./node_modules/chevrotain/lib/src/parse/parser/traits/recognizer_engine.js","webpack:///./node_modules/chevrotain/lib/src/parse/parser/traits/recognizer_api.js","webpack:///./node_modules/chevrotain/lib/src/parse/parser/traits/error_handler.js","webpack:///./node_modules/chevrotain/lib/src/parse/parser/traits/context_assist.js","webpack:///./node_modules/chevrotain/lib/src/parse/parser/traits/perf_tracer.js","webpack:///./node_modules/chevrotain-allstar/lib/atn.js","webpack:///./node_modules/chevrotain-allstar/lib/dfa.js","webpack:///./node_modules/chevrotain-allstar/lib/all-star-lookahead.js","webpack:///./node_modules/lodash-es/uniqBy.js","webpack:///./node_modules/vscode-languageserver-types/lib/esm/main.js","webpack:///./node_modules/langium/lib/parser/cst-node-builder.js","webpack:///./node_modules/langium/lib/parser/langium-parser.js","webpack:///./node_modules/langium/lib/parser/parser-builder-base.js","webpack:///./node_modules/langium/lib/parser/token-builder.js","webpack:///./node_modules/langium/lib/parser/value-converter.js","webpack:///./node_modules/langium/lib/utils/promise-utils.js","webpack:///./node_modules/vscode-languageserver-textdocument/lib/esm/main.js","webpack:///./node_modules/vscode-uri/lib/esm/index.mjs","webpack:///./node_modules/langium/lib/utils/uri-utils.js","webpack:///./node_modules/langium/lib/workspace/documents.js","webpack:///./node_modules/langium/lib/validation/validation-registry.js","webpack:///./node_modules/langium/lib/validation/document-validator.js","webpack:///./node_modules/langium/lib/utils/disposable.js","webpack:///./node_modules/langium/lib/references/linker.js","webpack:///./node_modules/langium/lib/references/name-provider.js","webpack:///./node_modules/langium/lib/references/references.js","webpack:///./node_modules/langium/lib/utils/collections.js","webpack:///./node_modules/langium/lib/references/scope-computation.js","webpack:///./node_modules/langium/lib/references/scope.js","webpack:///./node_modules/langium/lib/utils/caching.js","webpack:///./node_modules/langium/lib/references/scope-provider.js","webpack:///./node_modules/langium/lib/serializer/json-serializer.js","webpack:///./node_modules/langium/lib/service-registry.js","webpack:///./node_modules/langium/lib/workspace/ast-descriptions.js","webpack:///./node_modules/langium/lib/workspace/ast-node-locator.js","webpack:///./node_modules/langium/lib/workspace/configuration.js","webpack:///./node_modules/langium/lib/workspace/document-builder.js","webpack:///./node_modules/langium/lib/workspace/index-manager.js","webpack:///./node_modules/langium/lib/workspace/workspace-manager.js","webpack:///./node_modules/langium/lib/parser/lexer.js","webpack:///./node_modules/langium/lib/documentation/jsdoc.js","webpack:///./node_modules/langium/lib/documentation/documentation-provider.js","webpack:///./node_modules/langium/lib/documentation/comment-provider.js","webpack:///./node_modules/langium/lib/dependency-injection.js","webpack:///./node_modules/langium/lib/parser/async-parser.js","webpack:///./node_modules/langium/lib/workspace/workspace-lock.js","webpack:///./node_modules/langium/lib/serializer/hydrator.js","webpack:///./node_modules/langium/lib/default-module.js","webpack:///./node_modules/langium/lib/languages/grammar-config.js","webpack:///./node_modules/langium/lib/parser/langium-parser-builder.js","webpack:///./node_modules/langium/lib/parser/completion-parser-builder.js","webpack:///./node_modules/langium/lib/workspace/file-system-provider.js","webpack:///./node_modules/langium/lib/utils/grammar-loader.js","webpack:///./node_modules/lodash-es/flatten.js","webpack:///./node_modules/lodash-es/map.js","webpack:///./node_modules/lodash-es/_baseSet.js","webpack:///./node_modules/lodash-es/_basePickBy.js","webpack:///./node_modules/process/browser.js","webpack:///./node_modules/lodash-es/_baseLt.js","webpack:///./node_modules/lodash-es/min.js","webpack:///./node_modules/lodash-es/last.js","webpack:///./node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-4YFB5VUC.mjs","webpack:///./node_modules/vscode-jsonrpc/lib/common/is.js","webpack:///./node_modules/lodash-es/toInteger.js","webpack:///./node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-BI6EQKOQ.mjs","webpack:///./node_modules/@mermaid-js/parser/dist/mermaid-parser.core.mjs","webpack:///./node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-Y27MQZ3U.mjs","webpack:///./node_modules/vscode-jsonrpc/lib/common/ral.js","webpack:///./node_modules/lodash-es/_baseHas.js","webpack:///./node_modules/lodash-es/has.js","webpack:///./node_modules/lodash-es/isString.js","webpack:///./node_modules/vscode-jsonrpc/lib/common/cancellation.js","webpack:///./node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-FF7BQXOH.mjs"],"sourcesContent":["import baseClone from './_baseClone.js';\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_SYMBOLS_FLAG = 4;\n\n/**\n * Creates a shallow clone of `value`.\n *\n * **Note:** This method is loosely based on the\n * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)\n * and supports cloning arrays, array buffers, booleans, date objects, maps,\n * numbers, `Object` objects, regexes, sets, strings, symbols, and typed\n * arrays. The own enumerable properties of `arguments` objects are cloned\n * as plain objects. An empty object is returned for uncloneable values such\n * as error objects, functions, DOM nodes, and WeakMaps.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to clone.\n * @returns {*} Returns the cloned value.\n * @see _.cloneDeep\n * @example\n *\n * var objects = [{ 'a': 1 }, { 'b': 2 }];\n *\n * var shallow = _.clone(objects);\n * console.log(shallow[0] === objects[0]);\n * // => true\n */\nfunction clone(value) {\n  return baseClone(value, CLONE_SYMBOLS_FLAG);\n}\n\nexport default clone;\n","import baseFindIndex from './_baseFindIndex.js';\nimport baseIteratee from './_baseIteratee.js';\nimport toInteger from './toInteger.js';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * This method is like `_.find` except that it returns the index of the first\n * element `predicate` returns truthy for instead of the element itself.\n *\n * @static\n * @memberOf _\n * @since 1.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param {number} [fromIndex=0] The index to search from.\n * @returns {number} Returns the index of the found element, else `-1`.\n * @example\n *\n * var users = [\n *   { 'user': 'barney',  'active': false },\n *   { 'user': 'fred',    'active': false },\n *   { 'user': 'pebbles', 'active': true }\n * ];\n *\n * _.findIndex(users, function(o) { return o.user == 'barney'; });\n * // => 0\n *\n * // The `_.matches` iteratee shorthand.\n * _.findIndex(users, { 'user': 'fred', 'active': false });\n * // => 1\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.findIndex(users, ['active', false]);\n * // => 0\n *\n * // The `_.property` iteratee shorthand.\n * _.findIndex(users, 'active');\n * // => 2\n */\nfunction findIndex(array, predicate, fromIndex) {\n  var length = array == null ? 0 : array.length;\n  if (!length) {\n    return -1;\n  }\n  var index = fromIndex == null ? 0 : toInteger(fromIndex);\n  if (index < 0) {\n    index = nativeMax(length + index, 0);\n  }\n  return baseFindIndex(array, baseIteratee(predicate, 3), index);\n}\n\nexport default findIndex;\n","import createFind from './_createFind.js';\nimport findIndex from './findIndex.js';\n\n/**\n * Iterates over elements of `collection`, returning the first element\n * `predicate` returns truthy for. The predicate is invoked with three\n * arguments: (value, index|key, collection).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to inspect.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param {number} [fromIndex=0] The index to search from.\n * @returns {*} Returns the matched element, else `undefined`.\n * @example\n *\n * var users = [\n *   { 'user': 'barney',  'age': 36, 'active': true },\n *   { 'user': 'fred',    'age': 40, 'active': false },\n *   { 'user': 'pebbles', 'age': 1,  'active': true }\n * ];\n *\n * _.find(users, function(o) { return o.age < 40; });\n * // => object for 'barney'\n *\n * // The `_.matches` iteratee shorthand.\n * _.find(users, { 'age': 1, 'active': true });\n * // => object for 'pebbles'\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.find(users, ['active', false]);\n * // => object for 'fred'\n *\n * // The `_.property` iteratee shorthand.\n * _.find(users, 'active');\n * // => object for 'barney'\n */\nvar find = createFind(findIndex);\n\nexport default find;\n","import baseIteratee from './_baseIteratee.js';\nimport isArrayLike from './isArrayLike.js';\nimport keys from './keys.js';\n\n/**\n * Creates a `_.find` or `_.findLast` function.\n *\n * @private\n * @param {Function} findIndexFunc The function to find the collection index.\n * @returns {Function} Returns the new find function.\n */\nfunction createFind(findIndexFunc) {\n  return function(collection, predicate, fromIndex) {\n    var iterable = Object(collection);\n    if (!isArrayLike(collection)) {\n      var iteratee = baseIteratee(predicate, 3);\n      collection = keys(collection);\n      predicate = function(key) { return iteratee(iterable[key], key, iterable); };\n    }\n    var index = findIndexFunc(collection, predicate, fromIndex);\n    return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;\n  };\n}\n\nexport default createFind;\n","import {\n  AbstractMermaidTokenBuilder,\n  CommonValueConverter,\n  MermaidGeneratedSharedModule,\n  PacketGeneratedModule,\n  __name\n} from \"./chunk-Y27MQZ3U.mjs\";\n\n// src/language/packet/module.ts\nimport {\n  EmptyFileSystem,\n  createDefaultCoreModule,\n  createDefaultSharedCoreModule,\n  inject\n} from \"langium\";\n\n// src/language/packet/tokenBuilder.ts\nvar PacketTokenBuilder = class extends AbstractMermaidTokenBuilder {\n  static {\n    __name(this, \"PacketTokenBuilder\");\n  }\n  constructor() {\n    super([\"packet-beta\"]);\n  }\n};\n\n// src/language/packet/module.ts\nvar PacketModule = {\n  parser: {\n    TokenBuilder: /* @__PURE__ */ __name(() => new PacketTokenBuilder(), \"TokenBuilder\"),\n    ValueConverter: /* @__PURE__ */ __name(() => new CommonValueConverter(), \"ValueConverter\")\n  }\n};\nfunction createPacketServices(context = EmptyFileSystem) {\n  const shared = inject(\n    createDefaultSharedCoreModule(context),\n    MermaidGeneratedSharedModule\n  );\n  const Packet = inject(\n    createDefaultCoreModule({ shared }),\n    PacketGeneratedModule,\n    PacketModule\n  );\n  shared.ServiceRegistry.register(Packet);\n  return { shared, Packet };\n}\n__name(createPacketServices, \"createPacketServices\");\n\nexport {\n  PacketModule,\n  createPacketServices\n};\n","import isSymbol from './isSymbol.js';\n\n/**\n * The base implementation of methods like `_.max` and `_.min` which accepts a\n * `comparator` to determine the extremum value.\n *\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} iteratee The iteratee invoked per iteration.\n * @param {Function} comparator The comparator used to compare values.\n * @returns {*} Returns the extremum value.\n */\nfunction baseExtremum(array, iteratee, comparator) {\n  var index = -1,\n      length = array.length;\n\n  while (++index < length) {\n    var value = array[index],\n        current = iteratee(value);\n\n    if (current != null && (computed === undefined\n          ? (current === current && !isSymbol(current))\n          : comparator(current, computed)\n        )) {\n      var computed = current,\n          result = value;\n    }\n  }\n  return result;\n}\n\nexport default baseExtremum;\n","import baseEach from './_baseEach.js';\nimport isArrayLike from './isArrayLike.js';\n\n/**\n * The base implementation of `_.map` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction baseMap(collection, iteratee) {\n  var index = -1,\n      result = isArrayLike(collection) ? Array(collection.length) : [];\n\n  baseEach(collection, function(value, key, collection) {\n    result[++index] = iteratee(value, key, collection);\n  });\n  return result;\n}\n\nexport default baseMap;\n","\"use strict\";\n/* --------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n * ------------------------------------------------------------------------------------------ */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Emitter = exports.Event = void 0;\nconst ral_1 = require(\"./ral\");\nvar Event;\n(function (Event) {\n    const _disposable = { dispose() { } };\n    Event.None = function () { return _disposable; };\n})(Event || (exports.Event = Event = {}));\nclass CallbackList {\n    add(callback, context = null, bucket) {\n        if (!this._callbacks) {\n            this._callbacks = [];\n            this._contexts = [];\n        }\n        this._callbacks.push(callback);\n        this._contexts.push(context);\n        if (Array.isArray(bucket)) {\n            bucket.push({ dispose: () => this.remove(callback, context) });\n        }\n    }\n    remove(callback, context = null) {\n        if (!this._callbacks) {\n            return;\n        }\n        let foundCallbackWithDifferentContext = false;\n        for (let i = 0, len = this._callbacks.length; i < len; i++) {\n            if (this._callbacks[i] === callback) {\n                if (this._contexts[i] === context) {\n                    // callback & context match => remove it\n                    this._callbacks.splice(i, 1);\n                    this._contexts.splice(i, 1);\n                    return;\n                }\n                else {\n                    foundCallbackWithDifferentContext = true;\n                }\n            }\n        }\n        if (foundCallbackWithDifferentContext) {\n            throw new Error('When adding a listener with a context, you should remove it with the same context');\n        }\n    }\n    invoke(...args) {\n        if (!this._callbacks) {\n            return [];\n        }\n        const ret = [], callbacks = this._callbacks.slice(0), contexts = this._contexts.slice(0);\n        for (let i = 0, len = callbacks.length; i < len; i++) {\n            try {\n                ret.push(callbacks[i].apply(contexts[i], args));\n            }\n            catch (e) {\n                // eslint-disable-next-line no-console\n                (0, ral_1.default)().console.error(e);\n            }\n        }\n        return ret;\n    }\n    isEmpty() {\n        return !this._callbacks || this._callbacks.length === 0;\n    }\n    dispose() {\n        this._callbacks = undefined;\n        this._contexts = undefined;\n    }\n}\nclass Emitter {\n    constructor(_options) {\n        this._options = _options;\n    }\n    /**\n     * For the public to allow to subscribe\n     * to events from this Emitter\n     */\n    get event() {\n        if (!this._event) {\n            this._event = (listener, thisArgs, disposables) => {\n                if (!this._callbacks) {\n                    this._callbacks = new CallbackList();\n                }\n                if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {\n                    this._options.onFirstListenerAdd(this);\n                }\n                this._callbacks.add(listener, thisArgs);\n                const result = {\n                    dispose: () => {\n                        if (!this._callbacks) {\n                            // disposable is disposed after emitter is disposed.\n                            return;\n                        }\n                        this._callbacks.remove(listener, thisArgs);\n                        result.dispose = Emitter._noop;\n                        if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) {\n                            this._options.onLastListenerRemove(this);\n                        }\n                    }\n                };\n                if (Array.isArray(disposables)) {\n                    disposables.push(result);\n                }\n                return result;\n            };\n        }\n        return this._event;\n    }\n    /**\n     * To be kept private to fire an event to\n     * subscribers\n     */\n    fire(event) {\n        if (this._callbacks) {\n            this._callbacks.invoke.call(this._callbacks, event);\n        }\n    }\n    dispose() {\n        if (this._callbacks) {\n            this._callbacks.dispose();\n            this._callbacks = undefined;\n        }\n    }\n}\nexports.Emitter = Emitter;\nEmitter._noop = function () { };\n","import {\n  AbstractMermaidTokenBuilder,\n  CommonValueConverter,\n  GitGraphGeneratedModule,\n  MermaidGeneratedSharedModule,\n  __name\n} from \"./chunk-Y27MQZ3U.mjs\";\n\n// src/language/gitGraph/module.ts\nimport {\n  inject,\n  createDefaultCoreModule,\n  createDefaultSharedCoreModule,\n  EmptyFileSystem\n} from \"langium\";\n\n// src/language/gitGraph/tokenBuilder.ts\nvar GitGraphTokenBuilder = class extends AbstractMermaidTokenBuilder {\n  static {\n    __name(this, \"GitGraphTokenBuilder\");\n  }\n  constructor() {\n    super([\"gitGraph\"]);\n  }\n};\n\n// src/language/gitGraph/module.ts\nvar GitGraphModule = {\n  parser: {\n    TokenBuilder: /* @__PURE__ */ __name(() => new GitGraphTokenBuilder(), \"TokenBuilder\"),\n    ValueConverter: /* @__PURE__ */ __name(() => new CommonValueConverter(), \"ValueConverter\")\n  }\n};\nfunction createGitGraphServices(context = EmptyFileSystem) {\n  const shared = inject(\n    createDefaultSharedCoreModule(context),\n    MermaidGeneratedSharedModule\n  );\n  const GitGraph = inject(\n    createDefaultCoreModule({ shared }),\n    GitGraphGeneratedModule,\n    GitGraphModule\n  );\n  shared.ServiceRegistry.register(GitGraph);\n  return { shared, GitGraph };\n}\n__name(createGitGraphServices, \"createGitGraphServices\");\n\nexport {\n  GitGraphModule,\n  createGitGraphServices\n};\n","import baseRest from './_baseRest.js';\nimport eq from './eq.js';\nimport isIterateeCall from './_isIterateeCall.js';\nimport keysIn from './keysIn.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Assigns own and inherited enumerable string keyed properties of source\n * objects to the destination object for all destination properties that\n * resolve to `undefined`. Source objects are applied from left to right.\n * Once a property is set, additional values of the same property are ignored.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @see _.defaultsDeep\n * @example\n *\n * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n * // => { 'a': 1, 'b': 2 }\n */\nvar defaults = baseRest(function(object, sources) {\n  object = Object(object);\n\n  var index = -1;\n  var length = sources.length;\n  var guard = length > 2 ? sources[2] : undefined;\n\n  if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n    length = 1;\n  }\n\n  while (++index < length) {\n    var source = sources[index];\n    var props = keysIn(source);\n    var propsIndex = -1;\n    var propsLength = props.length;\n\n    while (++propsIndex < propsLength) {\n      var key = props[propsIndex];\n      var value = object[key];\n\n      if (value === undefined ||\n          (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {\n        object[key] = source[key];\n      }\n    }\n  }\n\n  return object;\n});\n\nexport default defaults;\n","/** Used to match a single whitespace character. */\nvar reWhitespace = /\\s/;\n\n/**\n * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n * character of `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the index of the last non-whitespace character.\n */\nfunction trimmedEndIndex(string) {\n  var index = string.length;\n\n  while (index-- && reWhitespace.test(string.charAt(index))) {}\n  return index;\n}\n\nexport default trimmedEndIndex;\n","import trimmedEndIndex from './_trimmedEndIndex.js';\n\n/** Used to match leading whitespace. */\nvar reTrimStart = /^\\s+/;\n\n/**\n * The base implementation of `_.trim`.\n *\n * @private\n * @param {string} string The string to trim.\n * @returns {string} Returns the trimmed string.\n */\nfunction baseTrim(string) {\n  return string\n    ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')\n    : string;\n}\n\nexport default baseTrim;\n","import baseTrim from './_baseTrim.js';\nimport isObject from './isObject.js';\nimport isSymbol from './isSymbol.js';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = baseTrim(value);\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nexport default toNumber;\n","import toNumber from './toNumber.js';\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0,\n    MAX_INTEGER = 1.7976931348623157e+308;\n\n/**\n * Converts `value` to a finite number.\n *\n * @static\n * @memberOf _\n * @since 4.12.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted number.\n * @example\n *\n * _.toFinite(3.2);\n * // => 3.2\n *\n * _.toFinite(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toFinite(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toFinite('3.2');\n * // => 3.2\n */\nfunction toFinite(value) {\n  if (!value) {\n    return value === 0 ? value : 0;\n  }\n  value = toNumber(value);\n  if (value === INFINITY || value === -INFINITY) {\n    var sign = (value < 0 ? -1 : 1);\n    return sign * MAX_INTEGER;\n  }\n  return value === value ? value : 0;\n}\n\nexport default toFinite;\n","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nexport function isAstNode(obj) {\n    return typeof obj === 'object' && obj !== null && typeof obj.$type === 'string';\n}\nexport function isReference(obj) {\n    return typeof obj === 'object' && obj !== null && typeof obj.$refText === 'string';\n}\nexport function isAstNodeDescription(obj) {\n    return typeof obj === 'object' && obj !== null\n        && typeof obj.name === 'string'\n        && typeof obj.type === 'string'\n        && typeof obj.path === 'string';\n}\nexport function isLinkingError(obj) {\n    return typeof obj === 'object' && obj !== null\n        && isAstNode(obj.container)\n        && isReference(obj.reference)\n        && typeof obj.message === 'string';\n}\n/**\n * An abstract implementation of the {@link AstReflection} interface.\n * Serves to cache subtype computation results to improve performance throughout different parts of Langium.\n */\nexport class AbstractAstReflection {\n    constructor() {\n        this.subtypes = {};\n        this.allSubtypes = {};\n    }\n    isInstance(node, type) {\n        return isAstNode(node) && this.isSubtype(node.$type, type);\n    }\n    isSubtype(subtype, supertype) {\n        if (subtype === supertype) {\n            return true;\n        }\n        let nested = this.subtypes[subtype];\n        if (!nested) {\n            nested = this.subtypes[subtype] = {};\n        }\n        const existing = nested[supertype];\n        if (existing !== undefined) {\n            return existing;\n        }\n        else {\n            const result = this.computeIsSubtype(subtype, supertype);\n            nested[supertype] = result;\n            return result;\n        }\n    }\n    getAllSubTypes(type) {\n        const existing = this.allSubtypes[type];\n        if (existing) {\n            return existing;\n        }\n        else {\n            const allTypes = this.getAllTypes();\n            const types = [];\n            for (const possibleSubType of allTypes) {\n                if (this.isSubtype(possibleSubType, type)) {\n                    types.push(possibleSubType);\n                }\n            }\n            this.allSubtypes[type] = types;\n            return types;\n        }\n    }\n}\nexport function isCompositeCstNode(node) {\n    return typeof node === 'object' && node !== null && Array.isArray(node.content);\n}\nexport function isLeafCstNode(node) {\n    return typeof node === 'object' && node !== null && typeof node.tokenType === 'object';\n}\nexport function isRootCstNode(node) {\n    return isCompositeCstNode(node) && typeof node.fullText === 'string';\n}\n//# sourceMappingURL=syntax-tree.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\n/**\n * The default implementation of `Stream` works with two input functions:\n *  - The first function creates the initial state of an iteration.\n *  - The second function gets the current state as argument and returns an `IteratorResult`.\n */\nexport class StreamImpl {\n    constructor(startFn, nextFn) {\n        this.startFn = startFn;\n        this.nextFn = nextFn;\n    }\n    iterator() {\n        const iterator = {\n            state: this.startFn(),\n            next: () => this.nextFn(iterator.state),\n            [Symbol.iterator]: () => iterator\n        };\n        return iterator;\n    }\n    [Symbol.iterator]() {\n        return this.iterator();\n    }\n    isEmpty() {\n        const iterator = this.iterator();\n        return Boolean(iterator.next().done);\n    }\n    count() {\n        const iterator = this.iterator();\n        let count = 0;\n        let next = iterator.next();\n        while (!next.done) {\n            count++;\n            next = iterator.next();\n        }\n        return count;\n    }\n    toArray() {\n        const result = [];\n        const iterator = this.iterator();\n        let next;\n        do {\n            next = iterator.next();\n            if (next.value !== undefined) {\n                result.push(next.value);\n            }\n        } while (!next.done);\n        return result;\n    }\n    toSet() {\n        return new Set(this);\n    }\n    toMap(keyFn, valueFn) {\n        const entryStream = this.map(element => [\n            keyFn ? keyFn(element) : element,\n            valueFn ? valueFn(element) : element\n        ]);\n        return new Map(entryStream);\n    }\n    toString() {\n        return this.join();\n    }\n    concat(other) {\n        const iterator = other[Symbol.iterator]();\n        return new StreamImpl(() => ({ first: this.startFn(), firstDone: false }), state => {\n            let result;\n            if (!state.firstDone) {\n                do {\n                    result = this.nextFn(state.first);\n                    if (!result.done) {\n                        return result;\n                    }\n                } while (!result.done);\n                state.firstDone = true;\n            }\n            do {\n                result = iterator.next();\n                if (!result.done) {\n                    return result;\n                }\n            } while (!result.done);\n            return DONE_RESULT;\n        });\n    }\n    join(separator = ',') {\n        const iterator = this.iterator();\n        let value = '';\n        let result;\n        let addSeparator = false;\n        do {\n            result = iterator.next();\n            if (!result.done) {\n                if (addSeparator) {\n                    value += separator;\n                }\n                value += toString(result.value);\n            }\n            addSeparator = true;\n        } while (!result.done);\n        return value;\n    }\n    indexOf(searchElement, fromIndex = 0) {\n        const iterator = this.iterator();\n        let index = 0;\n        let next = iterator.next();\n        while (!next.done) {\n            if (index >= fromIndex && next.value === searchElement) {\n                return index;\n            }\n            next = iterator.next();\n            index++;\n        }\n        return -1;\n    }\n    every(predicate) {\n        const iterator = this.iterator();\n        let next = iterator.next();\n        while (!next.done) {\n            if (!predicate(next.value)) {\n                return false;\n            }\n            next = iterator.next();\n        }\n        return true;\n    }\n    some(predicate) {\n        const iterator = this.iterator();\n        let next = iterator.next();\n        while (!next.done) {\n            if (predicate(next.value)) {\n                return true;\n            }\n            next = iterator.next();\n        }\n        return false;\n    }\n    forEach(callbackfn) {\n        const iterator = this.iterator();\n        let index = 0;\n        let next = iterator.next();\n        while (!next.done) {\n            callbackfn(next.value, index);\n            next = iterator.next();\n            index++;\n        }\n    }\n    map(callbackfn) {\n        return new StreamImpl(this.startFn, (state) => {\n            const { done, value } = this.nextFn(state);\n            if (done) {\n                return DONE_RESULT;\n            }\n            else {\n                return { done: false, value: callbackfn(value) };\n            }\n        });\n    }\n    filter(predicate) {\n        return new StreamImpl(this.startFn, state => {\n            let result;\n            do {\n                result = this.nextFn(state);\n                if (!result.done && predicate(result.value)) {\n                    return result;\n                }\n            } while (!result.done);\n            return DONE_RESULT;\n        });\n    }\n    nonNullable() {\n        return this.filter(e => e !== undefined && e !== null);\n    }\n    reduce(callbackfn, initialValue) {\n        const iterator = this.iterator();\n        let previousValue = initialValue;\n        let next = iterator.next();\n        while (!next.done) {\n            if (previousValue === undefined) {\n                previousValue = next.value;\n            }\n            else {\n                previousValue = callbackfn(previousValue, next.value);\n            }\n            next = iterator.next();\n        }\n        return previousValue;\n    }\n    reduceRight(callbackfn, initialValue) {\n        return this.recursiveReduce(this.iterator(), callbackfn, initialValue);\n    }\n    recursiveReduce(iterator, callbackfn, initialValue) {\n        const next = iterator.next();\n        if (next.done) {\n            return initialValue;\n        }\n        const previousValue = this.recursiveReduce(iterator, callbackfn, initialValue);\n        if (previousValue === undefined) {\n            return next.value;\n        }\n        return callbackfn(previousValue, next.value);\n    }\n    find(predicate) {\n        const iterator = this.iterator();\n        let next = iterator.next();\n        while (!next.done) {\n            if (predicate(next.value)) {\n                return next.value;\n            }\n            next = iterator.next();\n        }\n        return undefined;\n    }\n    findIndex(predicate) {\n        const iterator = this.iterator();\n        let index = 0;\n        let next = iterator.next();\n        while (!next.done) {\n            if (predicate(next.value)) {\n                return index;\n            }\n            next = iterator.next();\n            index++;\n        }\n        return -1;\n    }\n    includes(searchElement) {\n        const iterator = this.iterator();\n        let next = iterator.next();\n        while (!next.done) {\n            if (next.value === searchElement) {\n                return true;\n            }\n            next = iterator.next();\n        }\n        return false;\n    }\n    flatMap(callbackfn) {\n        return new StreamImpl(() => ({ this: this.startFn() }), (state) => {\n            do {\n                if (state.iterator) {\n                    const next = state.iterator.next();\n                    if (next.done) {\n                        state.iterator = undefined;\n                    }\n                    else {\n                        return next;\n                    }\n                }\n                const { done, value } = this.nextFn(state.this);\n                if (!done) {\n                    const mapped = callbackfn(value);\n                    if (isIterable(mapped)) {\n                        state.iterator = mapped[Symbol.iterator]();\n                    }\n                    else {\n                        return { done: false, value: mapped };\n                    }\n                }\n            } while (state.iterator);\n            return DONE_RESULT;\n        });\n    }\n    flat(depth) {\n        if (depth === undefined) {\n            depth = 1;\n        }\n        if (depth <= 0) {\n            return this;\n        }\n        const stream = depth > 1 ? this.flat(depth - 1) : this;\n        return new StreamImpl(() => ({ this: stream.startFn() }), (state) => {\n            do {\n                if (state.iterator) {\n                    const next = state.iterator.next();\n                    if (next.done) {\n                        state.iterator = undefined;\n                    }\n                    else {\n                        return next;\n                    }\n                }\n                const { done, value } = stream.nextFn(state.this);\n                if (!done) {\n                    if (isIterable(value)) {\n                        state.iterator = value[Symbol.iterator]();\n                    }\n                    else {\n                        return { done: false, value: value };\n                    }\n                }\n            } while (state.iterator);\n            return DONE_RESULT;\n        });\n    }\n    head() {\n        const iterator = this.iterator();\n        const result = iterator.next();\n        if (result.done) {\n            return undefined;\n        }\n        return result.value;\n    }\n    tail(skipCount = 1) {\n        return new StreamImpl(() => {\n            const state = this.startFn();\n            for (let i = 0; i < skipCount; i++) {\n                const next = this.nextFn(state);\n                if (next.done) {\n                    return state;\n                }\n            }\n            return state;\n        }, this.nextFn);\n    }\n    limit(maxSize) {\n        return new StreamImpl(() => ({ size: 0, state: this.startFn() }), state => {\n            state.size++;\n            if (state.size > maxSize) {\n                return DONE_RESULT;\n            }\n            return this.nextFn(state.state);\n        });\n    }\n    distinct(by) {\n        const set = new Set();\n        return this.filter(e => {\n            const value = by ? by(e) : e;\n            if (set.has(value)) {\n                return false;\n            }\n            else {\n                set.add(value);\n                return true;\n            }\n        });\n    }\n    exclude(other, key) {\n        const otherKeySet = new Set();\n        for (const item of other) {\n            const value = key ? key(item) : item;\n            otherKeySet.add(value);\n        }\n        return this.filter(e => {\n            const ownKey = key ? key(e) : e;\n            return !otherKeySet.has(ownKey);\n        });\n    }\n}\nfunction toString(item) {\n    if (typeof item === 'string') {\n        return item;\n    }\n    if (typeof item === 'undefined') {\n        return 'undefined';\n    }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    if (typeof item.toString === 'function') {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return item.toString();\n    }\n    return Object.prototype.toString.call(item);\n}\nfunction isIterable(obj) {\n    return !!obj && typeof obj[Symbol.iterator] === 'function';\n}\n/**\n * An empty stream of any type.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const EMPTY_STREAM = new StreamImpl(() => undefined, () => DONE_RESULT);\n/**\n * Use this `IteratorResult` when implementing a `StreamImpl` to indicate that there are no more elements in the stream.\n */\nexport const DONE_RESULT = Object.freeze({ done: true, value: undefined });\n/**\n * Create a stream from one or more iterables or array-likes.\n */\nexport function stream(...collections) {\n    if (collections.length === 1) {\n        const collection = collections[0];\n        if (collection instanceof StreamImpl) {\n            return collection;\n        }\n        if (isIterable(collection)) {\n            return new StreamImpl(() => collection[Symbol.iterator](), (iterator) => iterator.next());\n        }\n        if (typeof collection.length === 'number') {\n            return new StreamImpl(() => ({ index: 0 }), (state) => {\n                if (state.index < collection.length) {\n                    return { done: false, value: collection[state.index++] };\n                }\n                else {\n                    return DONE_RESULT;\n                }\n            });\n        }\n    }\n    if (collections.length > 1) {\n        return new StreamImpl(() => ({ collIndex: 0, arrIndex: 0 }), (state) => {\n            do {\n                if (state.iterator) {\n                    const next = state.iterator.next();\n                    if (!next.done) {\n                        return next;\n                    }\n                    state.iterator = undefined;\n                }\n                if (state.array) {\n                    if (state.arrIndex < state.array.length) {\n                        return { done: false, value: state.array[state.arrIndex++] };\n                    }\n                    state.array = undefined;\n                    state.arrIndex = 0;\n                }\n                if (state.collIndex < collections.length) {\n                    const collection = collections[state.collIndex++];\n                    if (isIterable(collection)) {\n                        state.iterator = collection[Symbol.iterator]();\n                    }\n                    else if (collection && typeof collection.length === 'number') {\n                        state.array = collection;\n                    }\n                }\n            } while (state.iterator || state.array || state.collIndex < collections.length);\n            return DONE_RESULT;\n        });\n    }\n    return EMPTY_STREAM;\n}\n/**\n * The default implementation of `TreeStream` takes a root element and a function that computes the\n * children of its argument. Whether the root node included in the stream is controlled with the\n * `includeRoot` option, which defaults to `false`.\n */\nexport class TreeStreamImpl extends StreamImpl {\n    constructor(root, children, options) {\n        super(() => ({\n            iterators: (options === null || options === void 0 ? void 0 : options.includeRoot) ? [[root][Symbol.iterator]()] : [children(root)[Symbol.iterator]()],\n            pruned: false\n        }), state => {\n            if (state.pruned) {\n                state.iterators.pop();\n                state.pruned = false;\n            }\n            while (state.iterators.length > 0) {\n                const iterator = state.iterators[state.iterators.length - 1];\n                const next = iterator.next();\n                if (next.done) {\n                    state.iterators.pop();\n                }\n                else {\n                    state.iterators.push(children(next.value)[Symbol.iterator]());\n                    return next;\n                }\n            }\n            return DONE_RESULT;\n        });\n    }\n    iterator() {\n        const iterator = {\n            state: this.startFn(),\n            next: () => this.nextFn(iterator.state),\n            prune: () => {\n                iterator.state.pruned = true;\n            },\n            [Symbol.iterator]: () => iterator\n        };\n        return iterator;\n    }\n}\n/**\n * A set of utility functions that reduce a stream to a single value.\n */\nexport var Reduction;\n(function (Reduction) {\n    /**\n     * Compute the sum of a number stream.\n     */\n    function sum(stream) {\n        return stream.reduce((a, b) => a + b, 0);\n    }\n    Reduction.sum = sum;\n    /**\n     * Compute the product of a number stream.\n     */\n    function product(stream) {\n        return stream.reduce((a, b) => a * b, 0);\n    }\n    Reduction.product = product;\n    /**\n     * Compute the minimum of a number stream. Returns `undefined` if the stream is empty.\n     */\n    function min(stream) {\n        return stream.reduce((a, b) => Math.min(a, b));\n    }\n    Reduction.min = min;\n    /**\n     * Compute the maximum of a number stream. Returns `undefined` if the stream is empty.\n     */\n    function max(stream) {\n        return stream.reduce((a, b) => Math.max(a, b));\n    }\n    Reduction.max = max;\n})(Reduction || (Reduction = {}));\n//# sourceMappingURL=stream.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { isCompositeCstNode, isLeafCstNode, isRootCstNode } from '../syntax-tree.js';\nimport { TreeStreamImpl } from './stream.js';\n/**\n * Create a stream of all CST nodes that are directly and indirectly contained in the given root node,\n * including the root node itself.\n */\nexport function streamCst(node) {\n    return new TreeStreamImpl(node, element => {\n        if (isCompositeCstNode(element)) {\n            return element.content;\n        }\n        else {\n            return [];\n        }\n    }, { includeRoot: true });\n}\n/**\n * Create a stream of all leaf nodes that are directly and indirectly contained in the given root node.\n */\nexport function flattenCst(node) {\n    return streamCst(node).filter(isLeafCstNode);\n}\n/**\n * Determines whether the specified cst node is a child of the specified parent node.\n */\nexport function isChildNode(child, parent) {\n    while (child.container) {\n        child = child.container;\n        if (child === parent) {\n            return true;\n        }\n    }\n    return false;\n}\nexport function tokenToRange(token) {\n    // Chevrotain uses 1-based indices everywhere\n    // So we subtract 1 from every value to align with the LSP\n    return {\n        start: {\n            character: token.startColumn - 1,\n            line: token.startLine - 1\n        },\n        end: {\n            character: token.endColumn,\n            line: token.endLine - 1\n        }\n    };\n}\nexport function toDocumentSegment(node) {\n    if (!node) {\n        return undefined;\n    }\n    const { offset, end, range } = node;\n    return {\n        range,\n        offset,\n        end,\n        length: end - offset\n    };\n}\nexport var RangeComparison;\n(function (RangeComparison) {\n    RangeComparison[RangeComparison[\"Before\"] = 0] = \"Before\";\n    RangeComparison[RangeComparison[\"After\"] = 1] = \"After\";\n    RangeComparison[RangeComparison[\"OverlapFront\"] = 2] = \"OverlapFront\";\n    RangeComparison[RangeComparison[\"OverlapBack\"] = 3] = \"OverlapBack\";\n    RangeComparison[RangeComparison[\"Inside\"] = 4] = \"Inside\";\n})(RangeComparison || (RangeComparison = {}));\nexport function compareRange(range, to) {\n    if (range.end.line < to.start.line || (range.end.line === to.start.line && range.end.character < range.start.character)) {\n        return RangeComparison.Before;\n    }\n    else if (range.start.line > to.end.line || (range.start.line === to.end.line && range.start.character > to.end.character)) {\n        return RangeComparison.After;\n    }\n    const startInside = range.start.line > to.start.line || (range.start.line === to.start.line && range.start.character >= to.start.character);\n    const endInside = range.end.line < to.end.line || (range.end.line === to.end.line && range.end.character <= to.end.character);\n    if (startInside && endInside) {\n        return RangeComparison.Inside;\n    }\n    else if (startInside) {\n        return RangeComparison.OverlapBack;\n    }\n    else {\n        return RangeComparison.OverlapFront;\n    }\n}\nexport function inRange(range, to) {\n    const comparison = compareRange(range, to);\n    return comparison > RangeComparison.After;\n}\n// The \\p{L} regex matches any unicode letter character, i.e. characters from non-english alphabets\n// Together with \\w it matches any kind of character which can commonly appear in IDs\nexport const DefaultNameRegexp = /^[\\w\\p{L}]$/u;\n/**\n * Performs `findLeafNodeAtOffset` with a minor difference: When encountering a character that matches the `nameRegexp` argument,\n * it will instead return the leaf node at the `offset - 1` position.\n *\n * For LSP services, users expect that the declaration of an element is available if the cursor is directly after the element.\n */\nexport function findDeclarationNodeAtOffset(cstNode, offset, nameRegexp = DefaultNameRegexp) {\n    if (cstNode) {\n        if (offset > 0) {\n            const localOffset = offset - cstNode.offset;\n            const textAtOffset = cstNode.text.charAt(localOffset);\n            if (!nameRegexp.test(textAtOffset)) {\n                offset--;\n            }\n        }\n        return findLeafNodeAtOffset(cstNode, offset);\n    }\n    return undefined;\n}\nexport function findCommentNode(cstNode, commentNames) {\n    if (cstNode) {\n        const previous = getPreviousNode(cstNode, true);\n        if (previous && isCommentNode(previous, commentNames)) {\n            return previous;\n        }\n        if (isRootCstNode(cstNode)) {\n            // Go from the first non-hidden node through all nodes in reverse order\n            // We do this to find the comment node which directly precedes the root node\n            const endIndex = cstNode.content.findIndex(e => !e.hidden);\n            for (let i = endIndex - 1; i >= 0; i--) {\n                const child = cstNode.content[i];\n                if (isCommentNode(child, commentNames)) {\n                    return child;\n                }\n            }\n        }\n    }\n    return undefined;\n}\nexport function isCommentNode(cstNode, commentNames) {\n    return isLeafCstNode(cstNode) && commentNames.includes(cstNode.tokenType.name);\n}\n/**\n * Finds the leaf CST node at the specified 0-based string offset.\n * Note that the given offset will be within the range of the returned leaf node.\n *\n * If the offset does not point to a CST node (but just white space), this method will return `undefined`.\n *\n * @param node The CST node to search through.\n * @param offset The specified offset.\n * @returns The CST node at the specified offset.\n */\nexport function findLeafNodeAtOffset(node, offset) {\n    if (isLeafCstNode(node)) {\n        return node;\n    }\n    else if (isCompositeCstNode(node)) {\n        const searchResult = binarySearch(node, offset, false);\n        if (searchResult) {\n            return findLeafNodeAtOffset(searchResult, offset);\n        }\n    }\n    return undefined;\n}\n/**\n * Finds the leaf CST node at the specified 0-based string offset.\n * If no CST node exists at the specified position, it will return the leaf node before it.\n *\n * If there is no leaf node before the specified offset, this method will return `undefined`.\n *\n * @param node The CST node to search through.\n * @param offset The specified offset.\n * @returns The CST node closest to the specified offset.\n */\nexport function findLeafNodeBeforeOffset(node, offset) {\n    if (isLeafCstNode(node)) {\n        return node;\n    }\n    else if (isCompositeCstNode(node)) {\n        const searchResult = binarySearch(node, offset, true);\n        if (searchResult) {\n            return findLeafNodeBeforeOffset(searchResult, offset);\n        }\n    }\n    return undefined;\n}\nfunction binarySearch(node, offset, closest) {\n    let left = 0;\n    let right = node.content.length - 1;\n    let closestNode = undefined;\n    while (left <= right) {\n        const middle = Math.floor((left + right) / 2);\n        const middleNode = node.content[middle];\n        if (middleNode.offset <= offset && middleNode.end > offset) {\n            // Found an exact match\n            return middleNode;\n        }\n        if (middleNode.end <= offset) {\n            // Update the closest node (less than offset) and move to the right half\n            closestNode = closest ? middleNode : undefined;\n            left = middle + 1;\n        }\n        else {\n            // Move to the left half\n            right = middle - 1;\n        }\n    }\n    return closestNode;\n}\nexport function getPreviousNode(node, hidden = true) {\n    while (node.container) {\n        const parent = node.container;\n        let index = parent.content.indexOf(node);\n        while (index > 0) {\n            index--;\n            const previous = parent.content[index];\n            if (hidden || !previous.hidden) {\n                return previous;\n            }\n        }\n        node = parent;\n    }\n    return undefined;\n}\nexport function getNextNode(node, hidden = true) {\n    while (node.container) {\n        const parent = node.container;\n        let index = parent.content.indexOf(node);\n        const last = parent.content.length - 1;\n        while (index < last) {\n            index++;\n            const next = parent.content[index];\n            if (hidden || !next.hidden) {\n                return next;\n            }\n        }\n        node = parent;\n    }\n    return undefined;\n}\nexport function getStartlineNode(node) {\n    if (node.range.start.character === 0) {\n        return node;\n    }\n    const line = node.range.start.line;\n    let last = node;\n    let index;\n    while (node.container) {\n        const parent = node.container;\n        const selfIndex = index !== null && index !== void 0 ? index : parent.content.indexOf(node);\n        if (selfIndex === 0) {\n            node = parent;\n            index = undefined;\n        }\n        else {\n            index = selfIndex - 1;\n            node = parent.content[index];\n        }\n        if (node.range.start.line !== line) {\n            break;\n        }\n        last = node;\n    }\n    return last;\n}\nexport function getInteriorNodes(start, end) {\n    const commonParent = getCommonParent(start, end);\n    if (!commonParent) {\n        return [];\n    }\n    return commonParent.parent.content.slice(commonParent.a + 1, commonParent.b);\n}\nfunction getCommonParent(a, b) {\n    const aParents = getParentChain(a);\n    const bParents = getParentChain(b);\n    let current;\n    for (let i = 0; i < aParents.length && i < bParents.length; i++) {\n        const aParent = aParents[i];\n        const bParent = bParents[i];\n        if (aParent.parent === bParent.parent) {\n            current = {\n                parent: aParent.parent,\n                a: aParent.index,\n                b: bParent.index\n            };\n        }\n        else {\n            break;\n        }\n    }\n    return current;\n}\nfunction getParentChain(node) {\n    const chain = [];\n    while (node.container) {\n        const parent = node.container;\n        const index = parent.content.indexOf(node);\n        chain.push({\n            parent,\n            index\n        });\n        node = parent;\n    }\n    return chain.reverse();\n}\n//# sourceMappingURL=cst-utils.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nexport class ErrorWithLocation extends Error {\n    constructor(node, message) {\n        super(node ? `${message} at ${node.range.start.line}:${node.range.start.character}` : message);\n    }\n}\nexport function assertUnreachable(_) {\n    throw new Error('Error! The input value was not handled.');\n}\n//# sourceMappingURL=errors.js.map","/******************************************************************************\n * This file was generated by langium-cli 3.0.0.\n * DO NOT EDIT MANUALLY!\n ******************************************************************************/\nimport { AbstractAstReflection } from '../../syntax-tree.js';\nexport const LangiumGrammarTerminals = {\n    ID: /\\^?[_a-zA-Z][\\w_]*/,\n    STRING: /\"(\\\\.|[^\"\\\\])*\"|'(\\\\.|[^'\\\\])*'/,\n    NUMBER: /NaN|-?((\\d*\\.\\d+|\\d+)([Ee][+-]?\\d+)?|Infinity)/,\n    RegexLiteral: /\\/(?![*+?])(?:[^\\r\\n\\[/\\\\]|\\\\.|\\[(?:[^\\r\\n\\]\\\\]|\\\\.)*\\])+\\/[a-z]*/,\n    WS: /\\s+/,\n    ML_COMMENT: /\\/\\*[\\s\\S]*?\\*\\//,\n    SL_COMMENT: /\\/\\/[^\\n\\r]*/,\n};\nexport const AbstractRule = 'AbstractRule';\nexport function isAbstractRule(item) {\n    return reflection.isInstance(item, AbstractRule);\n}\nexport const AbstractType = 'AbstractType';\nexport function isAbstractType(item) {\n    return reflection.isInstance(item, AbstractType);\n}\nexport const Condition = 'Condition';\nexport function isCondition(item) {\n    return reflection.isInstance(item, Condition);\n}\nexport function isFeatureName(item) {\n    return isPrimitiveType(item) || item === 'current' || item === 'entry' || item === 'extends' || item === 'false' || item === 'fragment' || item === 'grammar' || item === 'hidden' || item === 'import' || item === 'interface' || item === 'returns' || item === 'terminal' || item === 'true' || item === 'type' || item === 'infer' || item === 'infers' || item === 'with' || (typeof item === 'string' && (/\\^?[_a-zA-Z][\\w_]*/.test(item)));\n}\nexport function isPrimitiveType(item) {\n    return item === 'string' || item === 'number' || item === 'boolean' || item === 'Date' || item === 'bigint';\n}\nexport const TypeDefinition = 'TypeDefinition';\nexport function isTypeDefinition(item) {\n    return reflection.isInstance(item, TypeDefinition);\n}\nexport const ValueLiteral = 'ValueLiteral';\nexport function isValueLiteral(item) {\n    return reflection.isInstance(item, ValueLiteral);\n}\nexport const AbstractElement = 'AbstractElement';\nexport function isAbstractElement(item) {\n    return reflection.isInstance(item, AbstractElement);\n}\nexport const ArrayLiteral = 'ArrayLiteral';\nexport function isArrayLiteral(item) {\n    return reflection.isInstance(item, ArrayLiteral);\n}\nexport const ArrayType = 'ArrayType';\nexport function isArrayType(item) {\n    return reflection.isInstance(item, ArrayType);\n}\nexport const BooleanLiteral = 'BooleanLiteral';\nexport function isBooleanLiteral(item) {\n    return reflection.isInstance(item, BooleanLiteral);\n}\nexport const Conjunction = 'Conjunction';\nexport function isConjunction(item) {\n    return reflection.isInstance(item, Conjunction);\n}\nexport const Disjunction = 'Disjunction';\nexport function isDisjunction(item) {\n    return reflection.isInstance(item, Disjunction);\n}\nexport const Grammar = 'Grammar';\nexport function isGrammar(item) {\n    return reflection.isInstance(item, Grammar);\n}\nexport const GrammarImport = 'GrammarImport';\nexport function isGrammarImport(item) {\n    return reflection.isInstance(item, GrammarImport);\n}\nexport const InferredType = 'InferredType';\nexport function isInferredType(item) {\n    return reflection.isInstance(item, InferredType);\n}\nexport const Interface = 'Interface';\nexport function isInterface(item) {\n    return reflection.isInstance(item, Interface);\n}\nexport const NamedArgument = 'NamedArgument';\nexport function isNamedArgument(item) {\n    return reflection.isInstance(item, NamedArgument);\n}\nexport const Negation = 'Negation';\nexport function isNegation(item) {\n    return reflection.isInstance(item, Negation);\n}\nexport const NumberLiteral = 'NumberLiteral';\nexport function isNumberLiteral(item) {\n    return reflection.isInstance(item, NumberLiteral);\n}\nexport const Parameter = 'Parameter';\nexport function isParameter(item) {\n    return reflection.isInstance(item, Parameter);\n}\nexport const ParameterReference = 'ParameterReference';\nexport function isParameterReference(item) {\n    return reflection.isInstance(item, ParameterReference);\n}\nexport const ParserRule = 'ParserRule';\nexport function isParserRule(item) {\n    return reflection.isInstance(item, ParserRule);\n}\nexport const ReferenceType = 'ReferenceType';\nexport function isReferenceType(item) {\n    return reflection.isInstance(item, ReferenceType);\n}\nexport const ReturnType = 'ReturnType';\nexport function isReturnType(item) {\n    return reflection.isInstance(item, ReturnType);\n}\nexport const SimpleType = 'SimpleType';\nexport function isSimpleType(item) {\n    return reflection.isInstance(item, SimpleType);\n}\nexport const StringLiteral = 'StringLiteral';\nexport function isStringLiteral(item) {\n    return reflection.isInstance(item, StringLiteral);\n}\nexport const TerminalRule = 'TerminalRule';\nexport function isTerminalRule(item) {\n    return reflection.isInstance(item, TerminalRule);\n}\nexport const Type = 'Type';\nexport function isType(item) {\n    return reflection.isInstance(item, Type);\n}\nexport const TypeAttribute = 'TypeAttribute';\nexport function isTypeAttribute(item) {\n    return reflection.isInstance(item, TypeAttribute);\n}\nexport const UnionType = 'UnionType';\nexport function isUnionType(item) {\n    return reflection.isInstance(item, UnionType);\n}\nexport const Action = 'Action';\nexport function isAction(item) {\n    return reflection.isInstance(item, Action);\n}\nexport const Alternatives = 'Alternatives';\nexport function isAlternatives(item) {\n    return reflection.isInstance(item, Alternatives);\n}\nexport const Assignment = 'Assignment';\nexport function isAssignment(item) {\n    return reflection.isInstance(item, Assignment);\n}\nexport const CharacterRange = 'CharacterRange';\nexport function isCharacterRange(item) {\n    return reflection.isInstance(item, CharacterRange);\n}\nexport const CrossReference = 'CrossReference';\nexport function isCrossReference(item) {\n    return reflection.isInstance(item, CrossReference);\n}\nexport const EndOfFile = 'EndOfFile';\nexport function isEndOfFile(item) {\n    return reflection.isInstance(item, EndOfFile);\n}\nexport const Group = 'Group';\nexport function isGroup(item) {\n    return reflection.isInstance(item, Group);\n}\nexport const Keyword = 'Keyword';\nexport function isKeyword(item) {\n    return reflection.isInstance(item, Keyword);\n}\nexport const NegatedToken = 'NegatedToken';\nexport function isNegatedToken(item) {\n    return reflection.isInstance(item, NegatedToken);\n}\nexport const RegexToken = 'RegexToken';\nexport function isRegexToken(item) {\n    return reflection.isInstance(item, RegexToken);\n}\nexport const RuleCall = 'RuleCall';\nexport function isRuleCall(item) {\n    return reflection.isInstance(item, RuleCall);\n}\nexport const TerminalAlternatives = 'TerminalAlternatives';\nexport function isTerminalAlternatives(item) {\n    return reflection.isInstance(item, TerminalAlternatives);\n}\nexport const TerminalGroup = 'TerminalGroup';\nexport function isTerminalGroup(item) {\n    return reflection.isInstance(item, TerminalGroup);\n}\nexport const TerminalRuleCall = 'TerminalRuleCall';\nexport function isTerminalRuleCall(item) {\n    return reflection.isInstance(item, TerminalRuleCall);\n}\nexport const UnorderedGroup = 'UnorderedGroup';\nexport function isUnorderedGroup(item) {\n    return reflection.isInstance(item, UnorderedGroup);\n}\nexport const UntilToken = 'UntilToken';\nexport function isUntilToken(item) {\n    return reflection.isInstance(item, UntilToken);\n}\nexport const Wildcard = 'Wildcard';\nexport function isWildcard(item) {\n    return reflection.isInstance(item, Wildcard);\n}\nexport class LangiumGrammarAstReflection extends AbstractAstReflection {\n    getAllTypes() {\n        return ['AbstractElement', 'AbstractRule', 'AbstractType', 'Action', 'Alternatives', 'ArrayLiteral', 'ArrayType', 'Assignment', 'BooleanLiteral', 'CharacterRange', 'Condition', 'Conjunction', 'CrossReference', 'Disjunction', 'EndOfFile', 'Grammar', 'GrammarImport', 'Group', 'InferredType', 'Interface', 'Keyword', 'NamedArgument', 'NegatedToken', 'Negation', 'NumberLiteral', 'Parameter', 'ParameterReference', 'ParserRule', 'ReferenceType', 'RegexToken', 'ReturnType', 'RuleCall', 'SimpleType', 'StringLiteral', 'TerminalAlternatives', 'TerminalGroup', 'TerminalRule', 'TerminalRuleCall', 'Type', 'TypeAttribute', 'TypeDefinition', 'UnionType', 'UnorderedGroup', 'UntilToken', 'ValueLiteral', 'Wildcard'];\n    }\n    computeIsSubtype(subtype, supertype) {\n        switch (subtype) {\n            case Action:\n            case Alternatives:\n            case Assignment:\n            case CharacterRange:\n            case CrossReference:\n            case EndOfFile:\n            case Group:\n            case Keyword:\n            case NegatedToken:\n            case RegexToken:\n            case RuleCall:\n            case TerminalAlternatives:\n            case TerminalGroup:\n            case TerminalRuleCall:\n            case UnorderedGroup:\n            case UntilToken:\n            case Wildcard: {\n                return this.isSubtype(AbstractElement, supertype);\n            }\n            case ArrayLiteral:\n            case NumberLiteral:\n            case StringLiteral: {\n                return this.isSubtype(ValueLiteral, supertype);\n            }\n            case ArrayType:\n            case ReferenceType:\n            case SimpleType:\n            case UnionType: {\n                return this.isSubtype(TypeDefinition, supertype);\n            }\n            case BooleanLiteral: {\n                return this.isSubtype(Condition, supertype) || this.isSubtype(ValueLiteral, supertype);\n            }\n            case Conjunction:\n            case Disjunction:\n            case Negation:\n            case ParameterReference: {\n                return this.isSubtype(Condition, supertype);\n            }\n            case InferredType:\n            case Interface:\n            case Type: {\n                return this.isSubtype(AbstractType, supertype);\n            }\n            case ParserRule: {\n                return this.isSubtype(AbstractRule, supertype) || this.isSubtype(AbstractType, supertype);\n            }\n            case TerminalRule: {\n                return this.isSubtype(AbstractRule, supertype);\n            }\n            default: {\n                return false;\n            }\n        }\n    }\n    getReferenceType(refInfo) {\n        const referenceId = `${refInfo.container.$type}:${refInfo.property}`;\n        switch (referenceId) {\n            case 'Action:type':\n            case 'CrossReference:type':\n            case 'Interface:superTypes':\n            case 'ParserRule:returnType':\n            case 'SimpleType:typeRef': {\n                return AbstractType;\n            }\n            case 'Grammar:hiddenTokens':\n            case 'ParserRule:hiddenTokens':\n            case 'RuleCall:rule': {\n                return AbstractRule;\n            }\n            case 'Grammar:usedGrammars': {\n                return Grammar;\n            }\n            case 'NamedArgument:parameter':\n            case 'ParameterReference:parameter': {\n                return Parameter;\n            }\n            case 'TerminalRuleCall:rule': {\n                return TerminalRule;\n            }\n            default: {\n                throw new Error(`${referenceId} is not a valid reference id.`);\n            }\n        }\n    }\n    getTypeMetaData(type) {\n        switch (type) {\n            case 'AbstractElement': {\n                return {\n                    name: 'AbstractElement',\n                    properties: [\n                        { name: 'cardinality' },\n                        { name: 'lookahead' }\n                    ]\n                };\n            }\n            case 'ArrayLiteral': {\n                return {\n                    name: 'ArrayLiteral',\n                    properties: [\n                        { name: 'elements', defaultValue: [] }\n                    ]\n                };\n            }\n            case 'ArrayType': {\n                return {\n                    name: 'ArrayType',\n                    properties: [\n                        { name: 'elementType' }\n                    ]\n                };\n            }\n            case 'BooleanLiteral': {\n                return {\n                    name: 'BooleanLiteral',\n                    properties: [\n                        { name: 'true', defaultValue: false }\n                    ]\n                };\n            }\n            case 'Conjunction': {\n                return {\n                    name: 'Conjunction',\n                    properties: [\n                        { name: 'left' },\n                        { name: 'right' }\n                    ]\n                };\n            }\n            case 'Disjunction': {\n                return {\n                    name: 'Disjunction',\n                    properties: [\n                        { name: 'left' },\n                        { name: 'right' }\n                    ]\n                };\n            }\n            case 'Grammar': {\n                return {\n                    name: 'Grammar',\n                    properties: [\n                        { name: 'definesHiddenTokens', defaultValue: false },\n                        { name: 'hiddenTokens', defaultValue: [] },\n                        { name: 'imports', defaultValue: [] },\n                        { name: 'interfaces', defaultValue: [] },\n                        { name: 'isDeclared', defaultValue: false },\n                        { name: 'name' },\n                        { name: 'rules', defaultValue: [] },\n                        { name: 'types', defaultValue: [] },\n                        { name: 'usedGrammars', defaultValue: [] }\n                    ]\n                };\n            }\n            case 'GrammarImport': {\n                return {\n                    name: 'GrammarImport',\n                    properties: [\n                        { name: 'path' }\n                    ]\n                };\n            }\n            case 'InferredType': {\n                return {\n                    name: 'InferredType',\n                    properties: [\n                        { name: 'name' }\n                    ]\n                };\n            }\n            case 'Interface': {\n                return {\n                    name: 'Interface',\n                    properties: [\n                        { name: 'attributes', defaultValue: [] },\n                        { name: 'name' },\n                        { name: 'superTypes', defaultValue: [] }\n                    ]\n                };\n            }\n            case 'NamedArgument': {\n                return {\n                    name: 'NamedArgument',\n                    properties: [\n                        { name: 'calledByName', defaultValue: false },\n                        { name: 'parameter' },\n                        { name: 'value' }\n                    ]\n                };\n            }\n            case 'Negation': {\n                return {\n                    name: 'Negation',\n                    properties: [\n                        { name: 'value' }\n                    ]\n                };\n            }\n            case 'NumberLiteral': {\n                return {\n                    name: 'NumberLiteral',\n                    properties: [\n                        { name: 'value' }\n                    ]\n                };\n            }\n            case 'Parameter': {\n                return {\n                    name: 'Parameter',\n                    properties: [\n                        { name: 'name' }\n                    ]\n                };\n            }\n            case 'ParameterReference': {\n                return {\n                    name: 'ParameterReference',\n                    properties: [\n                        { name: 'parameter' }\n                    ]\n                };\n            }\n            case 'ParserRule': {\n                return {\n                    name: 'ParserRule',\n                    properties: [\n                        { name: 'dataType' },\n                        { name: 'definesHiddenTokens', defaultValue: false },\n                        { name: 'definition' },\n                        { name: 'entry', defaultValue: false },\n                        { name: 'fragment', defaultValue: false },\n                        { name: 'hiddenTokens', defaultValue: [] },\n                        { name: 'inferredType' },\n                        { name: 'name' },\n                        { name: 'parameters', defaultValue: [] },\n                        { name: 'returnType' },\n                        { name: 'wildcard', defaultValue: false }\n                    ]\n                };\n            }\n            case 'ReferenceType': {\n                return {\n                    name: 'ReferenceType',\n                    properties: [\n                        { name: 'referenceType' }\n                    ]\n                };\n            }\n            case 'ReturnType': {\n                return {\n                    name: 'ReturnType',\n                    properties: [\n                        { name: 'name' }\n                    ]\n                };\n            }\n            case 'SimpleType': {\n                return {\n                    name: 'SimpleType',\n                    properties: [\n                        { name: 'primitiveType' },\n                        { name: 'stringType' },\n                        { name: 'typeRef' }\n                    ]\n                };\n            }\n            case 'StringLiteral': {\n                return {\n                    name: 'StringLiteral',\n                    properties: [\n                        { name: 'value' }\n                    ]\n                };\n            }\n            case 'TerminalRule': {\n                return {\n                    name: 'TerminalRule',\n                    properties: [\n                        { name: 'definition' },\n                        { name: 'fragment', defaultValue: false },\n                        { name: 'hidden', defaultValue: false },\n                        { name: 'name' },\n                        { name: 'type' }\n                    ]\n                };\n            }\n            case 'Type': {\n                return {\n                    name: 'Type',\n                    properties: [\n                        { name: 'name' },\n                        { name: 'type' }\n                    ]\n                };\n            }\n            case 'TypeAttribute': {\n                return {\n                    name: 'TypeAttribute',\n                    properties: [\n                        { name: 'defaultValue' },\n                        { name: 'isOptional', defaultValue: false },\n                        { name: 'name' },\n                        { name: 'type' }\n                    ]\n                };\n            }\n            case 'UnionType': {\n                return {\n                    name: 'UnionType',\n                    properties: [\n                        { name: 'types', defaultValue: [] }\n                    ]\n                };\n            }\n            case 'Action': {\n                return {\n                    name: 'Action',\n                    properties: [\n                        { name: 'cardinality' },\n                        { name: 'feature' },\n                        { name: 'inferredType' },\n                        { name: 'lookahead' },\n                        { name: 'operator' },\n                        { name: 'type' }\n                    ]\n                };\n            }\n            case 'Alternatives': {\n                return {\n                    name: 'Alternatives',\n                    properties: [\n                        { name: 'cardinality' },\n                        { name: 'elements', defaultValue: [] },\n                        { name: 'lookahead' }\n                    ]\n                };\n            }\n            case 'Assignment': {\n                return {\n                    name: 'Assignment',\n                    properties: [\n                        { name: 'cardinality' },\n                        { name: 'feature' },\n                        { name: 'lookahead' },\n                        { name: 'operator' },\n                        { name: 'terminal' }\n                    ]\n                };\n            }\n            case 'CharacterRange': {\n                return {\n                    name: 'CharacterRange',\n                    properties: [\n                        { name: 'cardinality' },\n                        { name: 'left' },\n                        { name: 'lookahead' },\n                        { name: 'right' }\n                    ]\n                };\n            }\n            case 'CrossReference': {\n                return {\n                    name: 'CrossReference',\n                    properties: [\n                        { name: 'cardinality' },\n                        { name: 'deprecatedSyntax', defaultValue: false },\n                        { name: 'lookahead' },\n                        { name: 'terminal' },\n                        { name: 'type' }\n                    ]\n                };\n            }\n            case 'EndOfFile': {\n                return {\n                    name: 'EndOfFile',\n                    properties: [\n                        { name: 'cardinality' },\n                        { name: 'lookahead' }\n                    ]\n                };\n            }\n            case 'Group': {\n                return {\n                    name: 'Group',\n                    properties: [\n                        { name: 'cardinality' },\n                        { name: 'elements', defaultValue: [] },\n                        { name: 'guardCondition' },\n                        { name: 'lookahead' }\n                    ]\n                };\n            }\n            case 'Keyword': {\n                return {\n                    name: 'Keyword',\n                    properties: [\n                        { name: 'cardinality' },\n                        { name: 'lookahead' },\n                        { name: 'value' }\n                    ]\n                };\n            }\n            case 'NegatedToken': {\n                return {\n                    name: 'NegatedToken',\n                    properties: [\n                        { name: 'cardinality' },\n                        { name: 'lookahead' },\n                        { name: 'terminal' }\n                    ]\n                };\n            }\n            case 'RegexToken': {\n                return {\n                    name: 'RegexToken',\n                    properties: [\n                        { name: 'cardinality' },\n                        { name: 'lookahead' },\n                        { name: 'regex' }\n                    ]\n                };\n            }\n            case 'RuleCall': {\n                return {\n                    name: 'RuleCall',\n                    properties: [\n                        { name: 'arguments', defaultValue: [] },\n                        { name: 'cardinality' },\n                        { name: 'lookahead' },\n                        { name: 'rule' }\n                    ]\n                };\n            }\n            case 'TerminalAlternatives': {\n                return {\n                    name: 'TerminalAlternatives',\n                    properties: [\n                        { name: 'cardinality' },\n                        { name: 'elements', defaultValue: [] },\n                        { name: 'lookahead' }\n                    ]\n                };\n            }\n            case 'TerminalGroup': {\n                return {\n                    name: 'TerminalGroup',\n                    properties: [\n                        { name: 'cardinality' },\n                        { name: 'elements', defaultValue: [] },\n                        { name: 'lookahead' }\n                    ]\n                };\n            }\n            case 'TerminalRuleCall': {\n                return {\n                    name: 'TerminalRuleCall',\n                    properties: [\n                        { name: 'cardinality' },\n                        { name: 'lookahead' },\n                        { name: 'rule' }\n                    ]\n                };\n            }\n            case 'UnorderedGroup': {\n                return {\n                    name: 'UnorderedGroup',\n                    properties: [\n                        { name: 'cardinality' },\n                        { name: 'elements', defaultValue: [] },\n                        { name: 'lookahead' }\n                    ]\n                };\n            }\n            case 'UntilToken': {\n                return {\n                    name: 'UntilToken',\n                    properties: [\n                        { name: 'cardinality' },\n                        { name: 'lookahead' },\n                        { name: 'terminal' }\n                    ]\n                };\n            }\n            case 'Wildcard': {\n                return {\n                    name: 'Wildcard',\n                    properties: [\n                        { name: 'cardinality' },\n                        { name: 'lookahead' }\n                    ]\n                };\n            }\n            default: {\n                return {\n                    name: type,\n                    properties: []\n                };\n            }\n        }\n    }\n}\nexport const reflection = new LangiumGrammarAstReflection();\n//# sourceMappingURL=ast.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { isAstNode, isReference } from '../syntax-tree.js';\nimport { DONE_RESULT, stream, StreamImpl, TreeStreamImpl } from './stream.js';\nimport { inRange } from './cst-utils.js';\n/**\n * Link the `$container` and other related properties of every AST node that is directly contained\n * in the given `node`.\n */\nexport function linkContentToContainer(node) {\n    for (const [name, value] of Object.entries(node)) {\n        if (!name.startsWith('$')) {\n            if (Array.isArray(value)) {\n                value.forEach((item, index) => {\n                    if (isAstNode(item)) {\n                        item.$container = node;\n                        item.$containerProperty = name;\n                        item.$containerIndex = index;\n                    }\n                });\n            }\n            else if (isAstNode(value)) {\n                value.$container = node;\n                value.$containerProperty = name;\n            }\n        }\n    }\n}\n/**\n * Walk along the hierarchy of containers from the given AST node to the root and return the first\n * node that matches the type predicate. If the start node itself matches, it is returned.\n * If no container matches, `undefined` is returned.\n */\nexport function getContainerOfType(node, typePredicate) {\n    let item = node;\n    while (item) {\n        if (typePredicate(item)) {\n            return item;\n        }\n        item = item.$container;\n    }\n    return undefined;\n}\n/**\n * Walk along the hierarchy of containers from the given AST node to the root and check for existence\n * of a container that matches the given predicate. The start node is included in the checks.\n */\nexport function hasContainerOfType(node, predicate) {\n    let item = node;\n    while (item) {\n        if (predicate(item)) {\n            return true;\n        }\n        item = item.$container;\n    }\n    return false;\n}\n/**\n * Retrieve the document in which the given AST node is contained. A reference to the document is\n * usually held by the root node of the AST.\n *\n * @throws an error if the node is not contained in a document.\n */\nexport function getDocument(node) {\n    const rootNode = findRootNode(node);\n    const result = rootNode.$document;\n    if (!result) {\n        throw new Error('AST node has no document.');\n    }\n    return result;\n}\n/**\n * Returns the root node of the given AST node by following the `$container` references.\n */\nexport function findRootNode(node) {\n    while (node.$container) {\n        node = node.$container;\n    }\n    return node;\n}\n/**\n * Create a stream of all AST nodes that are directly contained in the given node. This includes\n * single-valued as well as multi-valued (array) properties.\n */\nexport function streamContents(node, options) {\n    if (!node) {\n        throw new Error('Node must be an AstNode.');\n    }\n    const range = options === null || options === void 0 ? void 0 : options.range;\n    return new StreamImpl(() => ({\n        keys: Object.keys(node),\n        keyIndex: 0,\n        arrayIndex: 0\n    }), state => {\n        while (state.keyIndex < state.keys.length) {\n            const property = state.keys[state.keyIndex];\n            if (!property.startsWith('$')) {\n                const value = node[property];\n                if (isAstNode(value)) {\n                    state.keyIndex++;\n                    if (isAstNodeInRange(value, range)) {\n                        return { done: false, value };\n                    }\n                }\n                else if (Array.isArray(value)) {\n                    while (state.arrayIndex < value.length) {\n                        const index = state.arrayIndex++;\n                        const element = value[index];\n                        if (isAstNode(element) && isAstNodeInRange(element, range)) {\n                            return { done: false, value: element };\n                        }\n                    }\n                    state.arrayIndex = 0;\n                }\n            }\n            state.keyIndex++;\n        }\n        return DONE_RESULT;\n    });\n}\n/**\n * Create a stream of all AST nodes that are directly and indirectly contained in the given root node.\n * This does not include the root node itself.\n */\nexport function streamAllContents(root, options) {\n    if (!root) {\n        throw new Error('Root node must be an AstNode.');\n    }\n    return new TreeStreamImpl(root, node => streamContents(node, options));\n}\n/**\n * Create a stream of all AST nodes that are directly and indirectly contained in the given root node,\n * including the root node itself.\n */\nexport function streamAst(root, options) {\n    if (!root) {\n        throw new Error('Root node must be an AstNode.');\n    }\n    else if ((options === null || options === void 0 ? void 0 : options.range) && !isAstNodeInRange(root, options.range)) {\n        // Return an empty stream if the root node isn't in range\n        return new TreeStreamImpl(root, () => []);\n    }\n    return new TreeStreamImpl(root, node => streamContents(node, options), { includeRoot: true });\n}\nfunction isAstNodeInRange(astNode, range) {\n    var _a;\n    if (!range) {\n        return true;\n    }\n    const nodeRange = (_a = astNode.$cstNode) === null || _a === void 0 ? void 0 : _a.range;\n    if (!nodeRange) {\n        return false;\n    }\n    return inRange(nodeRange, range);\n}\n/**\n * Create a stream of all cross-references that are held by the given AST node. This includes\n * single-valued as well as multi-valued (array) properties.\n */\nexport function streamReferences(node) {\n    return new StreamImpl(() => ({\n        keys: Object.keys(node),\n        keyIndex: 0,\n        arrayIndex: 0\n    }), state => {\n        while (state.keyIndex < state.keys.length) {\n            const property = state.keys[state.keyIndex];\n            if (!property.startsWith('$')) {\n                const value = node[property];\n                if (isReference(value)) {\n                    state.keyIndex++;\n                    return { done: false, value: { reference: value, container: node, property } };\n                }\n                else if (Array.isArray(value)) {\n                    while (state.arrayIndex < value.length) {\n                        const index = state.arrayIndex++;\n                        const element = value[index];\n                        if (isReference(element)) {\n                            return { done: false, value: { reference: element, container: node, property, index } };\n                        }\n                    }\n                    state.arrayIndex = 0;\n                }\n            }\n            state.keyIndex++;\n        }\n        return DONE_RESULT;\n    });\n}\n/**\n * Returns a Stream of references to the target node from the AstNode tree\n *\n * @param targetNode AstNode we are looking for\n * @param lookup AstNode where we search for references. If not provided, the root node of the document is used as the default value\n */\nexport function findLocalReferences(targetNode, lookup = getDocument(targetNode).parseResult.value) {\n    const refs = [];\n    streamAst(lookup).forEach(node => {\n        streamReferences(node).forEach(refInfo => {\n            if (refInfo.reference.ref === targetNode) {\n                refs.push(refInfo.reference);\n            }\n        });\n    });\n    return stream(refs);\n}\n/**\n * Assigns all mandatory AST properties to the specified node.\n *\n * @param reflection Reflection object used to gather mandatory properties for the node.\n * @param node Specified node is modified in place and properties are directly assigned.\n */\nexport function assignMandatoryProperties(reflection, node) {\n    const typeMetaData = reflection.getTypeMetaData(node.$type);\n    const genericNode = node;\n    for (const property of typeMetaData.properties) {\n        // Only set the value if the property is not already set and if it has a default value\n        if (property.defaultValue !== undefined && genericNode[property.name] === undefined) {\n            genericNode[property.name] = copyDefaultValue(property.defaultValue);\n        }\n    }\n}\nfunction copyDefaultValue(propertyType) {\n    if (Array.isArray(propertyType)) {\n        return [...propertyType.map(copyDefaultValue)];\n    }\n    else {\n        return propertyType;\n    }\n}\n/**\n * Creates a deep copy of the specified AST node.\n * The resulting copy will only contain semantically relevant information, such as the `$type` property and AST properties.\n *\n * References are copied without resolved cross reference. The specified function is used to rebuild them.\n */\nexport function copyAstNode(node, buildReference) {\n    const copy = { $type: node.$type };\n    for (const [name, value] of Object.entries(node)) {\n        if (!name.startsWith('$')) {\n            if (isAstNode(value)) {\n                copy[name] = copyAstNode(value, buildReference);\n            }\n            else if (isReference(value)) {\n                copy[name] = buildReference(copy, name, value.$refNode, value.$refText);\n            }\n            else if (Array.isArray(value)) {\n                const copiedArray = [];\n                for (const element of value) {\n                    if (isAstNode(element)) {\n                        copiedArray.push(copyAstNode(element, buildReference));\n                    }\n                    else if (isReference(element)) {\n                        copiedArray.push(buildReference(copy, name, element.$refNode, element.$refText));\n                    }\n                    else {\n                        copiedArray.push(element);\n                    }\n                }\n                copy[name] = copiedArray;\n            }\n            else {\n                copy[name] = value;\n            }\n        }\n    }\n    linkContentToContainer(copy);\n    return copy;\n}\n//# sourceMappingURL=ast-utils.js.map","export function cc(char) {\n    return char.charCodeAt(0);\n}\nexport function insertToSet(item, set) {\n    if (Array.isArray(item)) {\n        item.forEach(function (subItem) {\n            set.push(subItem);\n        });\n    }\n    else {\n        set.push(item);\n    }\n}\nexport function addFlag(flagObj, flagKey) {\n    if (flagObj[flagKey] === true) {\n        throw \"duplicate flag \" + flagKey;\n    }\n    const x = flagObj[flagKey];\n    flagObj[flagKey] = true;\n}\nexport function ASSERT_EXISTS(obj) {\n    // istanbul ignore next\n    if (obj === undefined) {\n        throw Error(\"Internal Error - Should never get here!\");\n    }\n    return true;\n}\n// istanbul ignore next\nexport function ASSERT_NEVER_REACH_HERE() {\n    throw Error(\"Internal Error - Should never get here!\");\n}\nexport function isCharacter(obj) {\n    return obj[\"type\"] === \"Character\";\n}\n//# sourceMappingURL=utils.js.map","import { cc } from \"./utils.js\";\nexport const digitsCharCodes = [];\nfor (let i = cc(\"0\"); i <= cc(\"9\"); i++) {\n    digitsCharCodes.push(i);\n}\nexport const wordCharCodes = [cc(\"_\")].concat(digitsCharCodes);\nfor (let i = cc(\"a\"); i <= cc(\"z\"); i++) {\n    wordCharCodes.push(i);\n}\nfor (let i = cc(\"A\"); i <= cc(\"Z\"); i++) {\n    wordCharCodes.push(i);\n}\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#character-classes\nexport const whitespaceCodes = [\n    cc(\" \"),\n    cc(\"\\f\"),\n    cc(\"\\n\"),\n    cc(\"\\r\"),\n    cc(\"\\t\"),\n    cc(\"\\v\"),\n    cc(\"\\t\"),\n    cc(\"\\u00a0\"),\n    cc(\"\\u1680\"),\n    cc(\"\\u2000\"),\n    cc(\"\\u2001\"),\n    cc(\"\\u2002\"),\n    cc(\"\\u2003\"),\n    cc(\"\\u2004\"),\n    cc(\"\\u2005\"),\n    cc(\"\\u2006\"),\n    cc(\"\\u2007\"),\n    cc(\"\\u2008\"),\n    cc(\"\\u2009\"),\n    cc(\"\\u200a\"),\n    cc(\"\\u2028\"),\n    cc(\"\\u2029\"),\n    cc(\"\\u202f\"),\n    cc(\"\\u205f\"),\n    cc(\"\\u3000\"),\n    cc(\"\\ufeff\"),\n];\n//# sourceMappingURL=character-classes.js.map","import { addFlag, ASSERT_EXISTS, ASSERT_NEVER_REACH_HERE, cc, insertToSet, isCharacter, } from \"./utils.js\";\nimport { digitsCharCodes, whitespaceCodes, wordCharCodes, } from \"./character-classes.js\";\n// consts and utilities\nconst hexDigitPattern = /[0-9a-fA-F]/;\nconst decimalPattern = /[0-9]/;\nconst decimalPatternNoZero = /[1-9]/;\n// https://hackernoon.com/the-madness-of-parsing-real-world-javascript-regexps-d9ee336df983\n// https://www.ecma-international.org/ecma-262/8.0/index.html#prod-Pattern\nexport class RegExpParser {\n    constructor() {\n        this.idx = 0;\n        this.input = \"\";\n        this.groupIdx = 0;\n    }\n    saveState() {\n        return {\n            idx: this.idx,\n            input: this.input,\n            groupIdx: this.groupIdx,\n        };\n    }\n    restoreState(newState) {\n        this.idx = newState.idx;\n        this.input = newState.input;\n        this.groupIdx = newState.groupIdx;\n    }\n    pattern(input) {\n        // parser state\n        this.idx = 0;\n        this.input = input;\n        this.groupIdx = 0;\n        this.consumeChar(\"/\");\n        const value = this.disjunction();\n        this.consumeChar(\"/\");\n        const flags = {\n            type: \"Flags\",\n            loc: { begin: this.idx, end: input.length },\n            global: false,\n            ignoreCase: false,\n            multiLine: false,\n            unicode: false,\n            sticky: false,\n        };\n        while (this.isRegExpFlag()) {\n            switch (this.popChar()) {\n                case \"g\":\n                    addFlag(flags, \"global\");\n                    break;\n                case \"i\":\n                    addFlag(flags, \"ignoreCase\");\n                    break;\n                case \"m\":\n                    addFlag(flags, \"multiLine\");\n                    break;\n                case \"u\":\n                    addFlag(flags, \"unicode\");\n                    break;\n                case \"y\":\n                    addFlag(flags, \"sticky\");\n                    break;\n            }\n        }\n        if (this.idx !== this.input.length) {\n            throw Error(\"Redundant input: \" + this.input.substring(this.idx));\n        }\n        return {\n            type: \"Pattern\",\n            flags: flags,\n            value: value,\n            loc: this.loc(0),\n        };\n    }\n    disjunction() {\n        const alts = [];\n        const begin = this.idx;\n        alts.push(this.alternative());\n        while (this.peekChar() === \"|\") {\n            this.consumeChar(\"|\");\n            alts.push(this.alternative());\n        }\n        return { type: \"Disjunction\", value: alts, loc: this.loc(begin) };\n    }\n    alternative() {\n        const terms = [];\n        const begin = this.idx;\n        while (this.isTerm()) {\n            terms.push(this.term());\n        }\n        return { type: \"Alternative\", value: terms, loc: this.loc(begin) };\n    }\n    term() {\n        if (this.isAssertion()) {\n            return this.assertion();\n        }\n        else {\n            return this.atom();\n        }\n    }\n    assertion() {\n        const begin = this.idx;\n        switch (this.popChar()) {\n            case \"^\":\n                return {\n                    type: \"StartAnchor\",\n                    loc: this.loc(begin),\n                };\n            case \"$\":\n                return { type: \"EndAnchor\", loc: this.loc(begin) };\n            // '\\b' or '\\B'\n            case \"\\\\\":\n                switch (this.popChar()) {\n                    case \"b\":\n                        return {\n                            type: \"WordBoundary\",\n                            loc: this.loc(begin),\n                        };\n                    case \"B\":\n                        return {\n                            type: \"NonWordBoundary\",\n                            loc: this.loc(begin),\n                        };\n                }\n                // istanbul ignore next\n                throw Error(\"Invalid Assertion Escape\");\n            // '(?=' or '(?!'\n            case \"(\":\n                this.consumeChar(\"?\");\n                let type;\n                switch (this.popChar()) {\n                    case \"=\":\n                        type = \"Lookahead\";\n                        break;\n                    case \"!\":\n                        type = \"NegativeLookahead\";\n                        break;\n                }\n                ASSERT_EXISTS(type);\n                const disjunction = this.disjunction();\n                this.consumeChar(\")\");\n                return {\n                    type: type,\n                    value: disjunction,\n                    loc: this.loc(begin),\n                };\n        }\n        // istanbul ignore next\n        return ASSERT_NEVER_REACH_HERE();\n    }\n    quantifier(isBacktracking = false) {\n        let range = undefined;\n        const begin = this.idx;\n        switch (this.popChar()) {\n            case \"*\":\n                range = {\n                    atLeast: 0,\n                    atMost: Infinity,\n                };\n                break;\n            case \"+\":\n                range = {\n                    atLeast: 1,\n                    atMost: Infinity,\n                };\n                break;\n            case \"?\":\n                range = {\n                    atLeast: 0,\n                    atMost: 1,\n                };\n                break;\n            case \"{\":\n                const atLeast = this.integerIncludingZero();\n                switch (this.popChar()) {\n                    case \"}\":\n                        range = {\n                            atLeast: atLeast,\n                            atMost: atLeast,\n                        };\n                        break;\n                    case \",\":\n                        let atMost;\n                        if (this.isDigit()) {\n                            atMost = this.integerIncludingZero();\n                            range = {\n                                atLeast: atLeast,\n                                atMost: atMost,\n                            };\n                        }\n                        else {\n                            range = {\n                                atLeast: atLeast,\n                                atMost: Infinity,\n                            };\n                        }\n                        this.consumeChar(\"}\");\n                        break;\n                }\n                // throwing exceptions from \"ASSERT_EXISTS\" during backtracking\n                // causes severe performance degradations\n                if (isBacktracking === true && range === undefined) {\n                    return undefined;\n                }\n                ASSERT_EXISTS(range);\n                break;\n        }\n        // throwing exceptions from \"ASSERT_EXISTS\" during backtracking\n        // causes severe performance degradations\n        if (isBacktracking === true && range === undefined) {\n            return undefined;\n        }\n        // istanbul ignore else\n        if (ASSERT_EXISTS(range)) {\n            if (this.peekChar(0) === \"?\") {\n                this.consumeChar(\"?\");\n                range.greedy = false;\n            }\n            else {\n                range.greedy = true;\n            }\n            range.type = \"Quantifier\";\n            range.loc = this.loc(begin);\n            return range;\n        }\n    }\n    atom() {\n        let atom;\n        const begin = this.idx;\n        switch (this.peekChar()) {\n            case \".\":\n                atom = this.dotAll();\n                break;\n            case \"\\\\\":\n                atom = this.atomEscape();\n                break;\n            case \"[\":\n                atom = this.characterClass();\n                break;\n            case \"(\":\n                atom = this.group();\n                break;\n        }\n        if (atom === undefined && this.isPatternCharacter()) {\n            atom = this.patternCharacter();\n        }\n        // istanbul ignore else\n        if (ASSERT_EXISTS(atom)) {\n            atom.loc = this.loc(begin);\n            if (this.isQuantifier()) {\n                atom.quantifier = this.quantifier();\n            }\n            return atom;\n        }\n        // istanbul ignore next\n        return ASSERT_NEVER_REACH_HERE();\n    }\n    dotAll() {\n        this.consumeChar(\".\");\n        return {\n            type: \"Set\",\n            complement: true,\n            value: [cc(\"\\n\"), cc(\"\\r\"), cc(\"\\u2028\"), cc(\"\\u2029\")],\n        };\n    }\n    atomEscape() {\n        this.consumeChar(\"\\\\\");\n        switch (this.peekChar()) {\n            case \"1\":\n            case \"2\":\n            case \"3\":\n            case \"4\":\n            case \"5\":\n            case \"6\":\n            case \"7\":\n            case \"8\":\n            case \"9\":\n                return this.decimalEscapeAtom();\n            case \"d\":\n            case \"D\":\n            case \"s\":\n            case \"S\":\n            case \"w\":\n            case \"W\":\n                return this.characterClassEscape();\n            case \"f\":\n            case \"n\":\n            case \"r\":\n            case \"t\":\n            case \"v\":\n                return this.controlEscapeAtom();\n            case \"c\":\n                return this.controlLetterEscapeAtom();\n            case \"0\":\n                return this.nulCharacterAtom();\n            case \"x\":\n                return this.hexEscapeSequenceAtom();\n            case \"u\":\n                return this.regExpUnicodeEscapeSequenceAtom();\n            default:\n                return this.identityEscapeAtom();\n        }\n    }\n    decimalEscapeAtom() {\n        const value = this.positiveInteger();\n        return { type: \"GroupBackReference\", value: value };\n    }\n    characterClassEscape() {\n        let set;\n        let complement = false;\n        switch (this.popChar()) {\n            case \"d\":\n                set = digitsCharCodes;\n                break;\n            case \"D\":\n                set = digitsCharCodes;\n                complement = true;\n                break;\n            case \"s\":\n                set = whitespaceCodes;\n                break;\n            case \"S\":\n                set = whitespaceCodes;\n                complement = true;\n                break;\n            case \"w\":\n                set = wordCharCodes;\n                break;\n            case \"W\":\n                set = wordCharCodes;\n                complement = true;\n                break;\n        }\n        // istanbul ignore else\n        if (ASSERT_EXISTS(set)) {\n            return { type: \"Set\", value: set, complement: complement };\n        }\n        // istanbul ignore next\n        return ASSERT_NEVER_REACH_HERE();\n    }\n    controlEscapeAtom() {\n        let escapeCode;\n        switch (this.popChar()) {\n            case \"f\":\n                escapeCode = cc(\"\\f\");\n                break;\n            case \"n\":\n                escapeCode = cc(\"\\n\");\n                break;\n            case \"r\":\n                escapeCode = cc(\"\\r\");\n                break;\n            case \"t\":\n                escapeCode = cc(\"\\t\");\n                break;\n            case \"v\":\n                escapeCode = cc(\"\\v\");\n                break;\n        }\n        // istanbul ignore else\n        if (ASSERT_EXISTS(escapeCode)) {\n            return { type: \"Character\", value: escapeCode };\n        }\n        // istanbul ignore next\n        return ASSERT_NEVER_REACH_HERE();\n    }\n    controlLetterEscapeAtom() {\n        this.consumeChar(\"c\");\n        const letter = this.popChar();\n        if (/[a-zA-Z]/.test(letter) === false) {\n            throw Error(\"Invalid \");\n        }\n        const letterCode = letter.toUpperCase().charCodeAt(0) - 64;\n        return { type: \"Character\", value: letterCode };\n    }\n    nulCharacterAtom() {\n        // TODO implement '[lookahead ∉ DecimalDigit]'\n        // TODO: for the deprecated octal escape sequence\n        this.consumeChar(\"0\");\n        return { type: \"Character\", value: cc(\"\\0\") };\n    }\n    hexEscapeSequenceAtom() {\n        this.consumeChar(\"x\");\n        return this.parseHexDigits(2);\n    }\n    regExpUnicodeEscapeSequenceAtom() {\n        this.consumeChar(\"u\");\n        return this.parseHexDigits(4);\n    }\n    identityEscapeAtom() {\n        // TODO: implement \"SourceCharacter but not UnicodeIDContinue\"\n        // // http://unicode.org/reports/tr31/#Specific_Character_Adjustments\n        const escapedChar = this.popChar();\n        return { type: \"Character\", value: cc(escapedChar) };\n    }\n    classPatternCharacterAtom() {\n        switch (this.peekChar()) {\n            // istanbul ignore next\n            case \"\\n\":\n            // istanbul ignore next\n            case \"\\r\":\n            // istanbul ignore next\n            case \"\\u2028\":\n            // istanbul ignore next\n            case \"\\u2029\":\n            // istanbul ignore next\n            case \"\\\\\":\n            // istanbul ignore next\n            case \"]\":\n                throw Error(\"TBD\");\n            default:\n                const nextChar = this.popChar();\n                return { type: \"Character\", value: cc(nextChar) };\n        }\n    }\n    characterClass() {\n        const set = [];\n        let complement = false;\n        this.consumeChar(\"[\");\n        if (this.peekChar(0) === \"^\") {\n            this.consumeChar(\"^\");\n            complement = true;\n        }\n        while (this.isClassAtom()) {\n            const from = this.classAtom();\n            const isFromSingleChar = from.type === \"Character\";\n            if (isCharacter(from) && this.isRangeDash()) {\n                this.consumeChar(\"-\");\n                const to = this.classAtom();\n                const isToSingleChar = to.type === \"Character\";\n                // a range can only be used when both sides are single characters\n                if (isCharacter(to)) {\n                    if (to.value < from.value) {\n                        throw Error(\"Range out of order in character class\");\n                    }\n                    set.push({ from: from.value, to: to.value });\n                }\n                else {\n                    // literal dash\n                    insertToSet(from.value, set);\n                    set.push(cc(\"-\"));\n                    insertToSet(to.value, set);\n                }\n            }\n            else {\n                insertToSet(from.value, set);\n            }\n        }\n        this.consumeChar(\"]\");\n        return { type: \"Set\", complement: complement, value: set };\n    }\n    classAtom() {\n        switch (this.peekChar()) {\n            // istanbul ignore next\n            case \"]\":\n            // istanbul ignore next\n            case \"\\n\":\n            // istanbul ignore next\n            case \"\\r\":\n            // istanbul ignore next\n            case \"\\u2028\":\n            // istanbul ignore next\n            case \"\\u2029\":\n                throw Error(\"TBD\");\n            case \"\\\\\":\n                return this.classEscape();\n            default:\n                return this.classPatternCharacterAtom();\n        }\n    }\n    classEscape() {\n        this.consumeChar(\"\\\\\");\n        switch (this.peekChar()) {\n            // Matches a backspace.\n            // (Not to be confused with \\b word boundary outside characterClass)\n            case \"b\":\n                this.consumeChar(\"b\");\n                return { type: \"Character\", value: cc(\"\\u0008\") };\n            case \"d\":\n            case \"D\":\n            case \"s\":\n            case \"S\":\n            case \"w\":\n            case \"W\":\n                return this.characterClassEscape();\n            case \"f\":\n            case \"n\":\n            case \"r\":\n            case \"t\":\n            case \"v\":\n                return this.controlEscapeAtom();\n            case \"c\":\n                return this.controlLetterEscapeAtom();\n            case \"0\":\n                return this.nulCharacterAtom();\n            case \"x\":\n                return this.hexEscapeSequenceAtom();\n            case \"u\":\n                return this.regExpUnicodeEscapeSequenceAtom();\n            default:\n                return this.identityEscapeAtom();\n        }\n    }\n    group() {\n        let capturing = true;\n        this.consumeChar(\"(\");\n        switch (this.peekChar(0)) {\n            case \"?\":\n                this.consumeChar(\"?\");\n                this.consumeChar(\":\");\n                capturing = false;\n                break;\n            default:\n                this.groupIdx++;\n                break;\n        }\n        const value = this.disjunction();\n        this.consumeChar(\")\");\n        const groupAst = {\n            type: \"Group\",\n            capturing: capturing,\n            value: value,\n        };\n        if (capturing) {\n            groupAst[\"idx\"] = this.groupIdx;\n        }\n        return groupAst;\n    }\n    positiveInteger() {\n        let number = this.popChar();\n        // istanbul ignore next - can't ever get here due to previous lookahead checks\n        // still implementing this error checking in case this ever changes.\n        if (decimalPatternNoZero.test(number) === false) {\n            throw Error(\"Expecting a positive integer\");\n        }\n        while (decimalPattern.test(this.peekChar(0))) {\n            number += this.popChar();\n        }\n        return parseInt(number, 10);\n    }\n    integerIncludingZero() {\n        let number = this.popChar();\n        if (decimalPattern.test(number) === false) {\n            throw Error(\"Expecting an integer\");\n        }\n        while (decimalPattern.test(this.peekChar(0))) {\n            number += this.popChar();\n        }\n        return parseInt(number, 10);\n    }\n    patternCharacter() {\n        const nextChar = this.popChar();\n        switch (nextChar) {\n            // istanbul ignore next\n            case \"\\n\":\n            // istanbul ignore next\n            case \"\\r\":\n            // istanbul ignore next\n            case \"\\u2028\":\n            // istanbul ignore next\n            case \"\\u2029\":\n            // istanbul ignore next\n            case \"^\":\n            // istanbul ignore next\n            case \"$\":\n            // istanbul ignore next\n            case \"\\\\\":\n            // istanbul ignore next\n            case \".\":\n            // istanbul ignore next\n            case \"*\":\n            // istanbul ignore next\n            case \"+\":\n            // istanbul ignore next\n            case \"?\":\n            // istanbul ignore next\n            case \"(\":\n            // istanbul ignore next\n            case \")\":\n            // istanbul ignore next\n            case \"[\":\n            // istanbul ignore next\n            case \"|\":\n                // istanbul ignore next\n                throw Error(\"TBD\");\n            default:\n                return { type: \"Character\", value: cc(nextChar) };\n        }\n    }\n    isRegExpFlag() {\n        switch (this.peekChar(0)) {\n            case \"g\":\n            case \"i\":\n            case \"m\":\n            case \"u\":\n            case \"y\":\n                return true;\n            default:\n                return false;\n        }\n    }\n    isRangeDash() {\n        return this.peekChar() === \"-\" && this.isClassAtom(1);\n    }\n    isDigit() {\n        return decimalPattern.test(this.peekChar(0));\n    }\n    isClassAtom(howMuch = 0) {\n        switch (this.peekChar(howMuch)) {\n            case \"]\":\n            case \"\\n\":\n            case \"\\r\":\n            case \"\\u2028\":\n            case \"\\u2029\":\n                return false;\n            default:\n                return true;\n        }\n    }\n    isTerm() {\n        return this.isAtom() || this.isAssertion();\n    }\n    isAtom() {\n        if (this.isPatternCharacter()) {\n            return true;\n        }\n        switch (this.peekChar(0)) {\n            case \".\":\n            case \"\\\\\": // atomEscape\n            case \"[\": // characterClass\n            // TODO: isAtom must be called before isAssertion - disambiguate\n            case \"(\": // group\n                return true;\n            default:\n                return false;\n        }\n    }\n    isAssertion() {\n        switch (this.peekChar(0)) {\n            case \"^\":\n            case \"$\":\n                return true;\n            // '\\b' or '\\B'\n            case \"\\\\\":\n                switch (this.peekChar(1)) {\n                    case \"b\":\n                    case \"B\":\n                        return true;\n                    default:\n                        return false;\n                }\n            // '(?=' or '(?!'\n            case \"(\":\n                return (this.peekChar(1) === \"?\" &&\n                    (this.peekChar(2) === \"=\" || this.peekChar(2) === \"!\"));\n            default:\n                return false;\n        }\n    }\n    isQuantifier() {\n        const prevState = this.saveState();\n        try {\n            return this.quantifier(true) !== undefined;\n        }\n        catch (e) {\n            return false;\n        }\n        finally {\n            this.restoreState(prevState);\n        }\n    }\n    isPatternCharacter() {\n        switch (this.peekChar()) {\n            case \"^\":\n            case \"$\":\n            case \"\\\\\":\n            case \".\":\n            case \"*\":\n            case \"+\":\n            case \"?\":\n            case \"(\":\n            case \")\":\n            case \"[\":\n            case \"|\":\n            case \"/\":\n            case \"\\n\":\n            case \"\\r\":\n            case \"\\u2028\":\n            case \"\\u2029\":\n                return false;\n            default:\n                return true;\n        }\n    }\n    parseHexDigits(howMany) {\n        let hexString = \"\";\n        for (let i = 0; i < howMany; i++) {\n            const hexChar = this.popChar();\n            if (hexDigitPattern.test(hexChar) === false) {\n                throw Error(\"Expecting a HexDecimal digits\");\n            }\n            hexString += hexChar;\n        }\n        const charCode = parseInt(hexString, 16);\n        return { type: \"Character\", value: charCode };\n    }\n    peekChar(howMuch = 0) {\n        return this.input[this.idx + howMuch];\n    }\n    popChar() {\n        const nextChar = this.peekChar(0);\n        this.consumeChar(undefined);\n        return nextChar;\n    }\n    consumeChar(char) {\n        if (char !== undefined && this.input[this.idx] !== char) {\n            throw Error(\"Expected: '\" +\n                char +\n                \"' but found: '\" +\n                this.input[this.idx] +\n                \"' at offset: \" +\n                this.idx);\n        }\n        if (this.idx >= this.input.length) {\n            throw Error(\"Unexpected end of input\");\n        }\n        this.idx++;\n    }\n    loc(begin) {\n        return { begin: begin, end: this.idx };\n    }\n}\n//# sourceMappingURL=regexp-parser.js.map","export class BaseRegExpVisitor {\n    visitChildren(node) {\n        for (const key in node) {\n            const child = node[key];\n            /* istanbul ignore else */\n            if (node.hasOwnProperty(key)) {\n                if (child.type !== undefined) {\n                    this.visit(child);\n                }\n                else if (Array.isArray(child)) {\n                    child.forEach((subChild) => {\n                        this.visit(subChild);\n                    }, this);\n                }\n            }\n        }\n    }\n    visit(node) {\n        switch (node.type) {\n            case \"Pattern\":\n                this.visitPattern(node);\n                break;\n            case \"Flags\":\n                this.visitFlags(node);\n                break;\n            case \"Disjunction\":\n                this.visitDisjunction(node);\n                break;\n            case \"Alternative\":\n                this.visitAlternative(node);\n                break;\n            case \"StartAnchor\":\n                this.visitStartAnchor(node);\n                break;\n            case \"EndAnchor\":\n                this.visitEndAnchor(node);\n                break;\n            case \"WordBoundary\":\n                this.visitWordBoundary(node);\n                break;\n            case \"NonWordBoundary\":\n                this.visitNonWordBoundary(node);\n                break;\n            case \"Lookahead\":\n                this.visitLookahead(node);\n                break;\n            case \"NegativeLookahead\":\n                this.visitNegativeLookahead(node);\n                break;\n            case \"Character\":\n                this.visitCharacter(node);\n                break;\n            case \"Set\":\n                this.visitSet(node);\n                break;\n            case \"Group\":\n                this.visitGroup(node);\n                break;\n            case \"GroupBackReference\":\n                this.visitGroupBackReference(node);\n                break;\n            case \"Quantifier\":\n                this.visitQuantifier(node);\n                break;\n        }\n        this.visitChildren(node);\n    }\n    visitPattern(node) { }\n    visitFlags(node) { }\n    visitDisjunction(node) { }\n    visitAlternative(node) { }\n    // Assertion\n    visitStartAnchor(node) { }\n    visitEndAnchor(node) { }\n    visitWordBoundary(node) { }\n    visitNonWordBoundary(node) { }\n    visitLookahead(node) { }\n    visitNegativeLookahead(node) { }\n    // atoms\n    visitCharacter(node) { }\n    visitSet(node) { }\n    visitGroup(node) { }\n    visitGroupBackReference(node) { }\n    visitQuantifier(node) { }\n}\n//# sourceMappingURL=base-regexp-visitor.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { RegExpParser, BaseRegExpVisitor } from '@chevrotain/regexp-to-ast';\nexport const NEWLINE_REGEXP = /\\r?\\n/gm;\nconst regexpParser = new RegExpParser();\n/**\n * This class is in charge of heuristically identifying start/end tokens of terminals.\n *\n * The way this works is by doing the following:\n * 1. Traverse the regular expression in the \"start state\"\n * 2. Add any encountered sets/single characters to the \"start regexp\"\n * 3. Once we encounter any variable-length content (i.e. with quantifiers such as +/?/*), we enter the \"end state\"\n * 4. In the end state, any sets/single characters are added to an \"end stack\".\n * 5. If we re-encounter any variable-length content we reset the end stack\n * 6. We continue visiting the regex until the end, reseting the end stack and rebuilding it as necessary\n *\n * After traversing a regular expression the `startRegexp/endRegexp` properties allow access to the stored start/end of the terminal\n */\nclass TerminalRegExpVisitor extends BaseRegExpVisitor {\n    constructor() {\n        super(...arguments);\n        this.isStarting = true;\n        this.endRegexpStack = [];\n        this.multiline = false;\n    }\n    get endRegex() {\n        return this.endRegexpStack.join('');\n    }\n    reset(regex) {\n        this.multiline = false;\n        this.regex = regex;\n        this.startRegexp = '';\n        this.isStarting = true;\n        this.endRegexpStack = [];\n    }\n    visitGroup(node) {\n        if (node.quantifier) {\n            this.isStarting = false;\n            this.endRegexpStack = [];\n        }\n    }\n    visitCharacter(node) {\n        const char = String.fromCharCode(node.value);\n        if (!this.multiline && char === '\\n') {\n            this.multiline = true;\n        }\n        if (node.quantifier) {\n            this.isStarting = false;\n            this.endRegexpStack = [];\n        }\n        else {\n            const escapedChar = escapeRegExp(char);\n            this.endRegexpStack.push(escapedChar);\n            if (this.isStarting) {\n                this.startRegexp += escapedChar;\n            }\n        }\n    }\n    visitSet(node) {\n        if (!this.multiline) {\n            const set = this.regex.substring(node.loc.begin, node.loc.end);\n            const regex = new RegExp(set);\n            this.multiline = Boolean('\\n'.match(regex));\n        }\n        if (node.quantifier) {\n            this.isStarting = false;\n            this.endRegexpStack = [];\n        }\n        else {\n            const set = this.regex.substring(node.loc.begin, node.loc.end);\n            this.endRegexpStack.push(set);\n            if (this.isStarting) {\n                this.startRegexp += set;\n            }\n        }\n    }\n    visitChildren(node) {\n        if (node.type === 'Group') {\n            // Ignore children of groups with quantifier (+/*/?)\n            // These groups are unrelated to start/end tokens of terminals\n            const group = node;\n            if (group.quantifier) {\n                return;\n            }\n        }\n        super.visitChildren(node);\n    }\n}\nconst visitor = new TerminalRegExpVisitor();\nexport function getTerminalParts(regexp) {\n    try {\n        if (typeof regexp !== 'string') {\n            regexp = regexp.source;\n        }\n        regexp = `/${regexp}/`;\n        const pattern = regexpParser.pattern(regexp);\n        const parts = [];\n        for (const alternative of pattern.value.value) {\n            visitor.reset(regexp);\n            visitor.visit(alternative);\n            parts.push({\n                start: visitor.startRegexp,\n                end: visitor.endRegex\n            });\n        }\n        return parts;\n    }\n    catch (_a) {\n        return [];\n    }\n}\nexport function isMultilineComment(regexp) {\n    try {\n        if (typeof regexp === 'string') {\n            regexp = new RegExp(regexp);\n        }\n        regexp = regexp.toString();\n        visitor.reset(regexp);\n        // Parsing the pattern might fail (since it's user code)\n        visitor.visit(regexpParser.pattern(regexp));\n        return visitor.multiline;\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function isWhitespace(value) {\n    const regexp = typeof value === 'string' ? new RegExp(value) : value;\n    return regexp.test(' ');\n}\nexport function escapeRegExp(value) {\n    return value.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\nexport function getCaseInsensitivePattern(keyword) {\n    return Array.prototype.map.call(keyword, letter => /\\w/.test(letter) ? `[${letter.toLowerCase()}${letter.toUpperCase()}]` : escapeRegExp(letter)).join('');\n}\n/**\n * Determines whether the given input has a partial match with the specified regex.\n * @param regex The regex to partially match against\n * @param input The input string\n * @returns Whether any match exists.\n */\nexport function partialMatches(regex, input) {\n    const partial = partialRegExp(regex);\n    const match = input.match(partial);\n    return !!match && match[0].length > 0;\n}\n/**\n * Builds a partial regex from the input regex. A partial regex is able to match incomplete input strings. E.g.\n * a partial regex constructed from `/ab/` is able to match the string `a` without needing a following `b` character. However it won't match `b` alone.\n * @param regex The input regex to be converted.\n * @returns A partial regex constructed from the input regex.\n */\nexport function partialRegExp(regex) {\n    if (typeof regex === 'string') {\n        regex = new RegExp(regex);\n    }\n    const re = regex, source = regex.source;\n    let i = 0;\n    function process() {\n        let result = '', tmp;\n        function appendRaw(nbChars) {\n            result += source.substr(i, nbChars);\n            i += nbChars;\n        }\n        function appendOptional(nbChars) {\n            result += '(?:' + source.substr(i, nbChars) + '|$)';\n            i += nbChars;\n        }\n        while (i < source.length) {\n            switch (source[i]) {\n                case '\\\\':\n                    switch (source[i + 1]) {\n                        case 'c':\n                            appendOptional(3);\n                            break;\n                        case 'x':\n                            appendOptional(4);\n                            break;\n                        case 'u':\n                            if (re.unicode) {\n                                if (source[i + 2] === '{') {\n                                    appendOptional(source.indexOf('}', i) - i + 1);\n                                }\n                                else {\n                                    appendOptional(6);\n                                }\n                            }\n                            else {\n                                appendOptional(2);\n                            }\n                            break;\n                        case 'p':\n                        case 'P':\n                            if (re.unicode) {\n                                appendOptional(source.indexOf('}', i) - i + 1);\n                            }\n                            else {\n                                appendOptional(2);\n                            }\n                            break;\n                        case 'k':\n                            appendOptional(source.indexOf('>', i) - i + 1);\n                            break;\n                        default:\n                            appendOptional(2);\n                            break;\n                    }\n                    break;\n                case '[':\n                    tmp = /\\[(?:\\\\.|.)*?\\]/g;\n                    tmp.lastIndex = i;\n                    tmp = tmp.exec(source) || [];\n                    appendOptional(tmp[0].length);\n                    break;\n                case '|':\n                case '^':\n                case '$':\n                case '*':\n                case '+':\n                case '?':\n                    appendRaw(1);\n                    break;\n                case '{':\n                    tmp = /\\{\\d+,?\\d*\\}/g;\n                    tmp.lastIndex = i;\n                    tmp = tmp.exec(source);\n                    if (tmp) {\n                        appendRaw(tmp[0].length);\n                    }\n                    else {\n                        appendOptional(1);\n                    }\n                    break;\n                case '(':\n                    if (source[i + 1] === '?') {\n                        switch (source[i + 2]) {\n                            case ':':\n                                result += '(?:';\n                                i += 3;\n                                result += process() + '|$)';\n                                break;\n                            case '=':\n                                result += '(?=';\n                                i += 3;\n                                result += process() + ')';\n                                break;\n                            case '!':\n                                tmp = i;\n                                i += 3;\n                                process();\n                                result += source.substr(tmp, i - tmp);\n                                break;\n                            case '<':\n                                switch (source[i + 3]) {\n                                    case '=':\n                                    case '!':\n                                        tmp = i;\n                                        i += 4;\n                                        process();\n                                        result += source.substr(tmp, i - tmp);\n                                        break;\n                                    default:\n                                        appendRaw(source.indexOf('>', i) - i + 1);\n                                        result += process() + '|$)';\n                                        break;\n                                }\n                                break;\n                        }\n                    }\n                    else {\n                        appendRaw(1);\n                        result += process() + '|$)';\n                    }\n                    break;\n                case ')':\n                    ++i;\n                    return result;\n                default:\n                    appendOptional(1);\n                    break;\n            }\n        }\n        return result;\n    }\n    return new RegExp(process(), regex.flags);\n}\n//# sourceMappingURL=regexp-utils.js.map","/******************************************************************************\n * Copyright 2021-2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { assertUnreachable } from '../utils/errors.js';\nimport * as ast from '../languages/generated/ast.js';\nimport { isCompositeCstNode } from '../syntax-tree.js';\nimport { getContainerOfType, streamAllContents } from './ast-utils.js';\nimport { streamCst } from './cst-utils.js';\nimport { escapeRegExp } from './regexp-utils.js';\n/**\n * Returns the entry rule of the given grammar, if any. If the grammar file does not contain an entry rule,\n * the result is `undefined`.\n */\nexport function getEntryRule(grammar) {\n    return grammar.rules.find(e => ast.isParserRule(e) && e.entry);\n}\n/**\n * Returns all hidden terminal rules of the given grammar, if any.\n */\nexport function getHiddenRules(grammar) {\n    return grammar.rules.filter((e) => ast.isTerminalRule(e) && e.hidden);\n}\n/**\n * Returns all rules that can be reached from the topmost rules of the specified grammar (entry and hidden terminal rules).\n *\n * @param grammar The grammar that contains all rules\n * @param allTerminals Whether or not to include terminals that are referenced only by other terminals\n * @returns A list of referenced parser and terminal rules. If the grammar contains no entry rule,\n *      this function returns all rules of the specified grammar.\n */\nexport function getAllReachableRules(grammar, allTerminals) {\n    const ruleNames = new Set();\n    const entryRule = getEntryRule(grammar);\n    if (!entryRule) {\n        return new Set(grammar.rules);\n    }\n    const topMostRules = [entryRule].concat(getHiddenRules(grammar));\n    for (const rule of topMostRules) {\n        ruleDfs(rule, ruleNames, allTerminals);\n    }\n    const rules = new Set();\n    for (const rule of grammar.rules) {\n        if (ruleNames.has(rule.name) || (ast.isTerminalRule(rule) && rule.hidden)) {\n            rules.add(rule);\n        }\n    }\n    return rules;\n}\nfunction ruleDfs(rule, visitedSet, allTerminals) {\n    visitedSet.add(rule.name);\n    streamAllContents(rule).forEach(node => {\n        if (ast.isRuleCall(node) || (allTerminals && ast.isTerminalRuleCall(node))) {\n            const refRule = node.rule.ref;\n            if (refRule && !visitedSet.has(refRule.name)) {\n                ruleDfs(refRule, visitedSet, allTerminals);\n            }\n        }\n    });\n}\n/**\n * Determines the grammar expression used to parse a cross-reference (usually a reference to a terminal rule).\n * A cross-reference can declare this expression explicitly in the form `[Type : Terminal]`, but if `Terminal`\n * is omitted, this function attempts to infer it from the name of the referenced `Type` (using `findNameAssignment`).\n *\n * Returns the grammar expression used to parse the given cross-reference, or `undefined` if it is not declared\n * and cannot be inferred.\n */\nexport function getCrossReferenceTerminal(crossRef) {\n    if (crossRef.terminal) {\n        return crossRef.terminal;\n    }\n    else if (crossRef.type.ref) {\n        const nameAssigment = findNameAssignment(crossRef.type.ref);\n        return nameAssigment === null || nameAssigment === void 0 ? void 0 : nameAssigment.terminal;\n    }\n    return undefined;\n}\n/**\n * Determines whether the given terminal rule represents a comment. This is true if the rule is marked\n * as `hidden` and it does not match white space. This means every hidden token (i.e. excluded from the AST)\n * that contains visible characters is considered a comment.\n */\nexport function isCommentTerminal(terminalRule) {\n    return terminalRule.hidden && !terminalRegex(terminalRule).test(' ');\n}\n/**\n * Find all CST nodes within the given node that contribute to the specified property.\n *\n * @param node A CST node in which to look for property assignments. If this is undefined, the result is an empty array.\n * @param property A property name of the constructed AST node. If this is undefined, the result is an empty array.\n */\nexport function findNodesForProperty(node, property) {\n    if (!node || !property) {\n        return [];\n    }\n    return findNodesForPropertyInternal(node, property, node.astNode, true);\n}\n/**\n * Find a single CST node within the given node that contributes to the specified property.\n *\n * @param node A CST node in which to look for property assignments. If this is undefined, the result is `undefined`.\n * @param property A property name of the constructed AST node. If this is undefined, the result is `undefined`.\n * @param index If no index is specified or the index is less than zero, the first found node is returned. If the\n *        specified index exceeds the number of assignments to the property, the last found node is returned. Otherwise,\n *        the node with the specified index is returned.\n */\nexport function findNodeForProperty(node, property, index) {\n    if (!node || !property) {\n        return undefined;\n    }\n    const nodes = findNodesForPropertyInternal(node, property, node.astNode, true);\n    if (nodes.length === 0) {\n        return undefined;\n    }\n    if (index !== undefined) {\n        index = Math.max(0, Math.min(index, nodes.length - 1));\n    }\n    else {\n        index = 0;\n    }\n    return nodes[index];\n}\nfunction findNodesForPropertyInternal(node, property, element, first) {\n    if (!first) {\n        const nodeFeature = getContainerOfType(node.grammarSource, ast.isAssignment);\n        if (nodeFeature && nodeFeature.feature === property) {\n            return [node];\n        }\n    }\n    if (isCompositeCstNode(node) && node.astNode === element) {\n        return node.content.flatMap(e => findNodesForPropertyInternal(e, property, element, false));\n    }\n    return [];\n}\n/**\n * Find all CST nodes within the given node that correspond to the specified keyword.\n *\n * @param node A CST node in which to look for keywords. If this is undefined, the result is an empty array.\n * @param keyword A keyword as specified in the grammar.\n */\nexport function findNodesForKeyword(node, keyword) {\n    if (!node) {\n        return [];\n    }\n    return findNodesForKeywordInternal(node, keyword, node === null || node === void 0 ? void 0 : node.astNode);\n}\n/**\n * Find a single CST node within the given node that corresponds to the specified keyword.\n *\n * @param node A CST node in which to look for keywords. If this is undefined, the result is `undefined`.\n * @param keyword A keyword as specified in the grammar.\n * @param index If no index is specified or the index is less than zero, the first found node is returned. If the\n *        specified index exceeds the number of keyword occurrences, the last found node is returned. Otherwise,\n *        the node with the specified index is returned.\n */\nexport function findNodeForKeyword(node, keyword, index) {\n    if (!node) {\n        return undefined;\n    }\n    const nodes = findNodesForKeywordInternal(node, keyword, node === null || node === void 0 ? void 0 : node.astNode);\n    if (nodes.length === 0) {\n        return undefined;\n    }\n    if (index !== undefined) {\n        index = Math.max(0, Math.min(index, nodes.length - 1));\n    }\n    else {\n        index = 0;\n    }\n    return nodes[index];\n}\nexport function findNodesForKeywordInternal(node, keyword, element) {\n    if (node.astNode !== element) {\n        return [];\n    }\n    if (ast.isKeyword(node.grammarSource) && node.grammarSource.value === keyword) {\n        return [node];\n    }\n    const treeIterator = streamCst(node).iterator();\n    let result;\n    const keywordNodes = [];\n    do {\n        result = treeIterator.next();\n        if (!result.done) {\n            const childNode = result.value;\n            if (childNode.astNode === element) {\n                if (ast.isKeyword(childNode.grammarSource) && childNode.grammarSource.value === keyword) {\n                    keywordNodes.push(childNode);\n                }\n            }\n            else {\n                treeIterator.prune();\n            }\n        }\n    } while (!result.done);\n    return keywordNodes;\n}\n/**\n * If the given CST node was parsed in the context of a property assignment, the respective `Assignment` grammar\n * node is returned. If no assignment is found, the result is `undefined`.\n *\n * @param cstNode A CST node for which to find a property assignment.\n */\nexport function findAssignment(cstNode) {\n    var _a;\n    const astNode = cstNode.astNode;\n    // Only search until the ast node of the parent cst node is no longer the original ast node\n    // This would make us jump to a preceding rule call, which contains only unrelated assignments\n    while (astNode === ((_a = cstNode.container) === null || _a === void 0 ? void 0 : _a.astNode)) {\n        const assignment = getContainerOfType(cstNode.grammarSource, ast.isAssignment);\n        if (assignment) {\n            return assignment;\n        }\n        cstNode = cstNode.container;\n    }\n    return undefined;\n}\n/**\n * Find an assignment to the `name` property for the given grammar type. This requires the `type` to be inferred\n * from a parser rule, and that rule must contain an assignment to the `name` property. In all other cases,\n * this function returns `undefined`.\n */\nexport function findNameAssignment(type) {\n    let startNode = type;\n    if (ast.isInferredType(startNode)) {\n        // for inferred types, the location to start searching for the name-assignment is different\n        if (ast.isAction(startNode.$container)) {\n            // a type which is explicitly inferred by an action: investigate the sibbling of the Action node, i.e. start searching at the Action's parent\n            startNode = startNode.$container.$container;\n        }\n        else if (ast.isParserRule(startNode.$container)) {\n            // investigate the parser rule with the explicitly inferred type\n            startNode = startNode.$container;\n        }\n        else {\n            assertUnreachable(startNode.$container);\n        }\n    }\n    return findNameAssignmentInternal(type, startNode, new Map());\n}\nfunction findNameAssignmentInternal(type, startNode, cache) {\n    var _a;\n    // the cache is only required to prevent infinite loops\n    function go(node, refType) {\n        let childAssignment = undefined;\n        const parentAssignment = getContainerOfType(node, ast.isAssignment);\n        // No parent assignment implies unassigned rule call\n        if (!parentAssignment) {\n            childAssignment = findNameAssignmentInternal(refType, refType, cache);\n        }\n        cache.set(type, childAssignment);\n        return childAssignment;\n    }\n    if (cache.has(type)) {\n        return cache.get(type);\n    }\n    cache.set(type, undefined);\n    for (const node of streamAllContents(startNode)) {\n        if (ast.isAssignment(node) && node.feature.toLowerCase() === 'name') {\n            cache.set(type, node);\n            return node;\n        }\n        else if (ast.isRuleCall(node) && ast.isParserRule(node.rule.ref)) {\n            return go(node, node.rule.ref);\n        }\n        else if (ast.isSimpleType(node) && ((_a = node.typeRef) === null || _a === void 0 ? void 0 : _a.ref)) {\n            return go(node, node.typeRef.ref);\n        }\n    }\n    return undefined;\n}\nexport function getActionAtElement(element) {\n    const parent = element.$container;\n    if (ast.isGroup(parent)) {\n        const elements = parent.elements;\n        const index = elements.indexOf(element);\n        for (let i = index - 1; i >= 0; i--) {\n            const item = elements[i];\n            if (ast.isAction(item)) {\n                return item;\n            }\n            else {\n                const action = streamAllContents(elements[i]).find(ast.isAction);\n                if (action) {\n                    return action;\n                }\n            }\n        }\n    }\n    if (ast.isAbstractElement(parent)) {\n        return getActionAtElement(parent);\n    }\n    else {\n        return undefined;\n    }\n}\nexport function isOptionalCardinality(cardinality, element) {\n    return cardinality === '?' || cardinality === '*' || (ast.isGroup(element) && Boolean(element.guardCondition));\n}\nexport function isArrayCardinality(cardinality) {\n    return cardinality === '*' || cardinality === '+';\n}\nexport function isArrayOperator(operator) {\n    return operator === '+=';\n}\n/**\n * Determines whether the given parser rule is a _data type rule_, meaning that it has a\n * primitive return type like `number`, `boolean`, etc.\n */\nexport function isDataTypeRule(rule) {\n    return isDataTypeRuleInternal(rule, new Set());\n}\nfunction isDataTypeRuleInternal(rule, visited) {\n    if (visited.has(rule)) {\n        return true;\n    }\n    else {\n        visited.add(rule);\n    }\n    for (const node of streamAllContents(rule)) {\n        if (ast.isRuleCall(node)) {\n            if (!node.rule.ref) {\n                // RuleCall to unresolved rule. Don't assume `rule` is a DataType rule.\n                return false;\n            }\n            if (ast.isParserRule(node.rule.ref) && !isDataTypeRuleInternal(node.rule.ref, visited)) {\n                return false;\n            }\n        }\n        else if (ast.isAssignment(node)) {\n            return false;\n        }\n        else if (ast.isAction(node)) {\n            return false;\n        }\n    }\n    return Boolean(rule.definition);\n}\nexport function isDataType(type) {\n    return isDataTypeInternal(type.type, new Set());\n}\nfunction isDataTypeInternal(type, visited) {\n    if (visited.has(type)) {\n        return true;\n    }\n    else {\n        visited.add(type);\n    }\n    if (ast.isArrayType(type)) {\n        return false;\n    }\n    else if (ast.isReferenceType(type)) {\n        return false;\n    }\n    else if (ast.isUnionType(type)) {\n        return type.types.every(e => isDataTypeInternal(e, visited));\n    }\n    else if (ast.isSimpleType(type)) {\n        if (type.primitiveType !== undefined) {\n            return true;\n        }\n        else if (type.stringType !== undefined) {\n            return true;\n        }\n        else if (type.typeRef !== undefined) {\n            const ref = type.typeRef.ref;\n            if (ast.isType(ref)) {\n                return isDataTypeInternal(ref.type, visited);\n            }\n            else {\n                return false;\n            }\n        }\n        else {\n            return false;\n        }\n    }\n    else {\n        return false;\n    }\n}\nexport function getExplicitRuleType(rule) {\n    if (rule.inferredType) {\n        return rule.inferredType.name;\n    }\n    else if (rule.dataType) {\n        return rule.dataType;\n    }\n    else if (rule.returnType) {\n        const refType = rule.returnType.ref;\n        if (refType) {\n            // check if we need to check Action as return type\n            if (ast.isParserRule(refType)) {\n                return refType.name;\n            }\n            else if (ast.isInterface(refType) || ast.isType(refType)) {\n                return refType.name;\n            }\n        }\n    }\n    return undefined;\n}\nexport function getTypeName(type) {\n    var _a;\n    if (ast.isParserRule(type)) {\n        return isDataTypeRule(type) ? type.name : (_a = getExplicitRuleType(type)) !== null && _a !== void 0 ? _a : type.name;\n    }\n    else if (ast.isInterface(type) || ast.isType(type) || ast.isReturnType(type)) {\n        return type.name;\n    }\n    else if (ast.isAction(type)) {\n        const actionType = getActionType(type);\n        if (actionType) {\n            return actionType;\n        }\n    }\n    else if (ast.isInferredType(type)) {\n        return type.name;\n    }\n    throw new Error('Cannot get name of Unknown Type');\n}\nexport function getActionType(action) {\n    var _a;\n    if (action.inferredType) {\n        return action.inferredType.name;\n    }\n    else if ((_a = action.type) === null || _a === void 0 ? void 0 : _a.ref) {\n        return getTypeName(action.type.ref);\n    }\n    return undefined; // not inferring and not referencing a valid type\n}\nexport function getRuleType(rule) {\n    var _a, _b, _c;\n    if (ast.isTerminalRule(rule)) {\n        return (_b = (_a = rule.type) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : 'string';\n    }\n    else {\n        return isDataTypeRule(rule) ? rule.name : (_c = getExplicitRuleType(rule)) !== null && _c !== void 0 ? _c : rule.name;\n    }\n}\nexport function terminalRegex(terminalRule) {\n    const flags = {\n        s: false,\n        i: false,\n        u: false\n    };\n    const source = abstractElementToRegex(terminalRule.definition, flags);\n    const flagText = Object.entries(flags).filter(([, value]) => value).map(([name]) => name).join('');\n    return new RegExp(source, flagText);\n}\n// Using [\\s\\S]* allows to match everything, compared to . which doesn't match line terminators\nconst WILDCARD = /[\\s\\S]/.source;\nfunction abstractElementToRegex(element, flags) {\n    if (ast.isTerminalAlternatives(element)) {\n        return terminalAlternativesToRegex(element);\n    }\n    else if (ast.isTerminalGroup(element)) {\n        return terminalGroupToRegex(element);\n    }\n    else if (ast.isCharacterRange(element)) {\n        return characterRangeToRegex(element);\n    }\n    else if (ast.isTerminalRuleCall(element)) {\n        const rule = element.rule.ref;\n        if (!rule) {\n            throw new Error('Missing rule reference.');\n        }\n        return withCardinality(abstractElementToRegex(rule.definition), {\n            cardinality: element.cardinality,\n            lookahead: element.lookahead\n        });\n    }\n    else if (ast.isNegatedToken(element)) {\n        return negateTokenToRegex(element);\n    }\n    else if (ast.isUntilToken(element)) {\n        return untilTokenToRegex(element);\n    }\n    else if (ast.isRegexToken(element)) {\n        const lastSlash = element.regex.lastIndexOf('/');\n        const source = element.regex.substring(1, lastSlash);\n        const regexFlags = element.regex.substring(lastSlash + 1);\n        if (flags) {\n            flags.i = regexFlags.includes('i');\n            flags.s = regexFlags.includes('s');\n            flags.u = regexFlags.includes('u');\n        }\n        return withCardinality(source, {\n            cardinality: element.cardinality,\n            lookahead: element.lookahead,\n            wrap: false\n        });\n    }\n    else if (ast.isWildcard(element)) {\n        return withCardinality(WILDCARD, {\n            cardinality: element.cardinality,\n            lookahead: element.lookahead\n        });\n    }\n    else {\n        throw new Error(`Invalid terminal element: ${element === null || element === void 0 ? void 0 : element.$type}`);\n    }\n}\nfunction terminalAlternativesToRegex(alternatives) {\n    return withCardinality(alternatives.elements.map(e => abstractElementToRegex(e)).join('|'), {\n        cardinality: alternatives.cardinality,\n        lookahead: alternatives.lookahead\n    });\n}\nfunction terminalGroupToRegex(group) {\n    return withCardinality(group.elements.map(e => abstractElementToRegex(e)).join(''), {\n        cardinality: group.cardinality,\n        lookahead: group.lookahead\n    });\n}\nfunction untilTokenToRegex(until) {\n    return withCardinality(`${WILDCARD}*?${abstractElementToRegex(until.terminal)}`, {\n        cardinality: until.cardinality,\n        lookahead: until.lookahead\n    });\n}\nfunction negateTokenToRegex(negate) {\n    return withCardinality(`(?!${abstractElementToRegex(negate.terminal)})${WILDCARD}*?`, {\n        cardinality: negate.cardinality,\n        lookahead: negate.lookahead\n    });\n}\nfunction characterRangeToRegex(range) {\n    if (range.right) {\n        return withCardinality(`[${keywordToRegex(range.left)}-${keywordToRegex(range.right)}]`, {\n            cardinality: range.cardinality,\n            lookahead: range.lookahead,\n            wrap: false\n        });\n    }\n    return withCardinality(keywordToRegex(range.left), {\n        cardinality: range.cardinality,\n        lookahead: range.lookahead,\n        wrap: false\n    });\n}\nfunction keywordToRegex(keyword) {\n    return escapeRegExp(keyword.value);\n}\nfunction withCardinality(regex, options) {\n    var _a;\n    if (options.wrap !== false || options.lookahead) {\n        regex = `(${(_a = options.lookahead) !== null && _a !== void 0 ? _a : ''}${regex})`;\n    }\n    if (options.cardinality) {\n        return `${regex}${options.cardinality}`;\n    }\n    return regex;\n}\n//# sourceMappingURL=grammar-utils.js.map","// based on: https://github.com/petkaantonov/bluebird/blob/b97c0d2d487e8c5076e8bd897e0dcd4622d31846/src/util.js#L201-L216\nexport function toFastProperties(toBecomeFast) {\n    function FakeConstructor() { }\n    // If our object is used as a constructor, it would receive\n    FakeConstructor.prototype = toBecomeFast;\n    const fakeInstance = new FakeConstructor();\n    function fakeAccess() {\n        return typeof fakeInstance.bar;\n    }\n    // help V8 understand this is a \"real\" prototype by actually using\n    // the fake instance.\n    fakeAccess();\n    fakeAccess();\n    // Always true condition to suppress the Firefox warning of unreachable\n    // code after a return statement.\n    if (1)\n        return toBecomeFast;\n    // Eval prevents optimization of this method (even though this is dead code)\n    // - https://esbuild.github.io/content-types/#direct-eval\n    /* istanbul ignore next */\n    // tslint:disable-next-line\n    (0, eval)(toBecomeFast);\n}\n//# sourceMappingURL=to-fast-properties.js.map","/**\n * The base implementation of `_.slice` without an iteratee call guard.\n *\n * @private\n * @param {Array} array The array to slice.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the slice of `array`.\n */\nfunction baseSlice(array, start, end) {\n  var index = -1,\n      length = array.length;\n\n  if (start < 0) {\n    start = -start > length ? 0 : (length + start);\n  }\n  end = end > length ? length : end;\n  if (end < 0) {\n    end += length;\n  }\n  length = start > end ? 0 : ((end - start) >>> 0);\n  start >>>= 0;\n\n  var result = Array(length);\n  while (++index < length) {\n    result[index] = array[index + start];\n  }\n  return result;\n}\n\nexport default baseSlice;\n","import baseSlice from './_baseSlice.js';\nimport toInteger from './toInteger.js';\n\n/**\n * Creates a slice of `array` with `n` elements dropped from the beginning.\n *\n * @static\n * @memberOf _\n * @since 0.5.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {number} [n=1] The number of elements to drop.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * _.drop([1, 2, 3]);\n * // => [2, 3]\n *\n * _.drop([1, 2, 3], 2);\n * // => [3]\n *\n * _.drop([1, 2, 3], 5);\n * // => []\n *\n * _.drop([1, 2, 3], 0);\n * // => [1, 2, 3]\n */\nfunction drop(array, n, guard) {\n  var length = array == null ? 0 : array.length;\n  if (!length) {\n    return [];\n  }\n  n = (guard || n === undefined) ? 1 : toInteger(n);\n  return baseSlice(array, n < 0 ? 0 : n, length);\n}\n\nexport default drop;\n","import assignValue from './_assignValue.js';\nimport copyObject from './_copyObject.js';\nimport createAssigner from './_createAssigner.js';\nimport isArrayLike from './isArrayLike.js';\nimport isPrototype from './_isPrototype.js';\nimport keys from './keys.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Assigns own enumerable string keyed properties of source objects to the\n * destination object. Source objects are applied from left to right.\n * Subsequent sources overwrite property assignments of previous sources.\n *\n * **Note:** This method mutates `object` and is loosely based on\n * [`Object.assign`](https://mdn.io/Object/assign).\n *\n * @static\n * @memberOf _\n * @since 0.10.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @see _.assignIn\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n * }\n *\n * function Bar() {\n *   this.c = 3;\n * }\n *\n * Foo.prototype.b = 2;\n * Bar.prototype.d = 4;\n *\n * _.assign({ 'a': 0 }, new Foo, new Bar);\n * // => { 'a': 1, 'c': 3 }\n */\nvar assign = createAssigner(function(object, source) {\n  if (isPrototype(source) || isArrayLike(source)) {\n    copyObject(source, keys(source), object);\n    return;\n  }\n  for (var key in source) {\n    if (hasOwnProperty.call(source, key)) {\n      assignValue(object, key, source[key]);\n    }\n  }\n});\n\nexport default assign;\n","import arrayMap from './_arrayMap.js';\nimport baseIteratee from './_baseIteratee.js';\nimport basePickBy from './_basePickBy.js';\nimport getAllKeysIn from './_getAllKeysIn.js';\n\n/**\n * Creates an object composed of the `object` properties `predicate` returns\n * truthy for. The predicate is invoked with two arguments: (value, key).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The source object.\n * @param {Function} [predicate=_.identity] The function invoked per property.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.pickBy(object, _.isNumber);\n * // => { 'a': 1, 'c': 3 }\n */\nfunction pickBy(object, predicate) {\n  if (object == null) {\n    return {};\n  }\n  var props = arrayMap(getAllKeysIn(object), function(prop) {\n    return [prop];\n  });\n  predicate = baseIteratee(predicate);\n  return basePickBy(object, props, function(value, path) {\n    return predicate(value, path[0]);\n  });\n}\n\nexport default pickBy;\n","import baseIsRegExp from './_baseIsRegExp.js';\nimport baseUnary from './_baseUnary.js';\nimport nodeUtil from './_nodeUtil.js';\n\n/* Node.js helper references. */\nvar nodeIsRegExp = nodeUtil && nodeUtil.isRegExp;\n\n/**\n * Checks if `value` is classified as a `RegExp` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\n * @example\n *\n * _.isRegExp(/abc/);\n * // => true\n *\n * _.isRegExp('/abc/');\n * // => false\n */\nvar isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;\n\nexport default isRegExp;\n","import baseGetTag from './_baseGetTag.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar regexpTag = '[object RegExp]';\n\n/**\n * The base implementation of `_.isRegExp` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\n */\nfunction baseIsRegExp(value) {\n  return isObjectLike(value) && baseGetTag(value) == regexpTag;\n}\n\nexport default baseIsRegExp;\n","import { assign, forEach, isRegExp, isString, map, pickBy } from \"lodash-es\";\n// TODO: duplicated code to avoid extracting another sub-package -- how to avoid?\nfunction tokenLabel(tokType) {\n    if (hasTokenLabel(tokType)) {\n        return tokType.LABEL;\n    }\n    else {\n        return tokType.name;\n    }\n}\n// TODO: duplicated code to avoid extracting another sub-package -- how to avoid?\nfunction hasTokenLabel(obj) {\n    return isString(obj.LABEL) && obj.LABEL !== \"\";\n}\nexport class AbstractProduction {\n    get definition() {\n        return this._definition;\n    }\n    set definition(value) {\n        this._definition = value;\n    }\n    constructor(_definition) {\n        this._definition = _definition;\n    }\n    accept(visitor) {\n        visitor.visit(this);\n        forEach(this.definition, (prod) => {\n            prod.accept(visitor);\n        });\n    }\n}\nexport class NonTerminal extends AbstractProduction {\n    constructor(options) {\n        super([]);\n        this.idx = 1;\n        assign(this, pickBy(options, (v) => v !== undefined));\n    }\n    set definition(definition) {\n        // immutable\n    }\n    get definition() {\n        if (this.referencedRule !== undefined) {\n            return this.referencedRule.definition;\n        }\n        return [];\n    }\n    accept(visitor) {\n        visitor.visit(this);\n        // don't visit children of a reference, we will get cyclic infinite loops if we do so\n    }\n}\nexport class Rule extends AbstractProduction {\n    constructor(options) {\n        super(options.definition);\n        this.orgText = \"\";\n        assign(this, pickBy(options, (v) => v !== undefined));\n    }\n}\nexport class Alternative extends AbstractProduction {\n    constructor(options) {\n        super(options.definition);\n        this.ignoreAmbiguities = false;\n        assign(this, pickBy(options, (v) => v !== undefined));\n    }\n}\nexport class Option extends AbstractProduction {\n    constructor(options) {\n        super(options.definition);\n        this.idx = 1;\n        assign(this, pickBy(options, (v) => v !== undefined));\n    }\n}\nexport class RepetitionMandatory extends AbstractProduction {\n    constructor(options) {\n        super(options.definition);\n        this.idx = 1;\n        assign(this, pickBy(options, (v) => v !== undefined));\n    }\n}\nexport class RepetitionMandatoryWithSeparator extends AbstractProduction {\n    constructor(options) {\n        super(options.definition);\n        this.idx = 1;\n        assign(this, pickBy(options, (v) => v !== undefined));\n    }\n}\nexport class Repetition extends AbstractProduction {\n    constructor(options) {\n        super(options.definition);\n        this.idx = 1;\n        assign(this, pickBy(options, (v) => v !== undefined));\n    }\n}\nexport class RepetitionWithSeparator extends AbstractProduction {\n    constructor(options) {\n        super(options.definition);\n        this.idx = 1;\n        assign(this, pickBy(options, (v) => v !== undefined));\n    }\n}\nexport class Alternation extends AbstractProduction {\n    get definition() {\n        return this._definition;\n    }\n    set definition(value) {\n        this._definition = value;\n    }\n    constructor(options) {\n        super(options.definition);\n        this.idx = 1;\n        this.ignoreAmbiguities = false;\n        this.hasPredicates = false;\n        assign(this, pickBy(options, (v) => v !== undefined));\n    }\n}\nexport class Terminal {\n    constructor(options) {\n        this.idx = 1;\n        assign(this, pickBy(options, (v) => v !== undefined));\n    }\n    accept(visitor) {\n        visitor.visit(this);\n    }\n}\nexport function serializeGrammar(topRules) {\n    return map(topRules, serializeProduction);\n}\nexport function serializeProduction(node) {\n    function convertDefinition(definition) {\n        return map(definition, serializeProduction);\n    }\n    /* istanbul ignore else */\n    if (node instanceof NonTerminal) {\n        const serializedNonTerminal = {\n            type: \"NonTerminal\",\n            name: node.nonTerminalName,\n            idx: node.idx,\n        };\n        if (isString(node.label)) {\n            serializedNonTerminal.label = node.label;\n        }\n        return serializedNonTerminal;\n    }\n    else if (node instanceof Alternative) {\n        return {\n            type: \"Alternative\",\n            definition: convertDefinition(node.definition),\n        };\n    }\n    else if (node instanceof Option) {\n        return {\n            type: \"Option\",\n            idx: node.idx,\n            definition: convertDefinition(node.definition),\n        };\n    }\n    else if (node instanceof RepetitionMandatory) {\n        return {\n            type: \"RepetitionMandatory\",\n            idx: node.idx,\n            definition: convertDefinition(node.definition),\n        };\n    }\n    else if (node instanceof RepetitionMandatoryWithSeparator) {\n        return {\n            type: \"RepetitionMandatoryWithSeparator\",\n            idx: node.idx,\n            separator: (serializeProduction(new Terminal({ terminalType: node.separator }))),\n            definition: convertDefinition(node.definition),\n        };\n    }\n    else if (node instanceof RepetitionWithSeparator) {\n        return {\n            type: \"RepetitionWithSeparator\",\n            idx: node.idx,\n            separator: (serializeProduction(new Terminal({ terminalType: node.separator }))),\n            definition: convertDefinition(node.definition),\n        };\n    }\n    else if (node instanceof Repetition) {\n        return {\n            type: \"Repetition\",\n            idx: node.idx,\n            definition: convertDefinition(node.definition),\n        };\n    }\n    else if (node instanceof Alternation) {\n        return {\n            type: \"Alternation\",\n            idx: node.idx,\n            definition: convertDefinition(node.definition),\n        };\n    }\n    else if (node instanceof Terminal) {\n        const serializedTerminal = {\n            type: \"Terminal\",\n            name: node.terminalType.name,\n            label: tokenLabel(node.terminalType),\n            idx: node.idx,\n        };\n        if (isString(node.label)) {\n            serializedTerminal.terminalLabel = node.label;\n        }\n        const pattern = node.terminalType.PATTERN;\n        if (node.terminalType.PATTERN) {\n            serializedTerminal.pattern = isRegExp(pattern)\n                ? pattern.source\n                : pattern;\n        }\n        return serializedTerminal;\n    }\n    else if (node instanceof Rule) {\n        return {\n            type: \"Rule\",\n            name: node.name,\n            orgText: node.orgText,\n            definition: convertDefinition(node.definition),\n        };\n        /* c8 ignore next 3 */\n    }\n    else {\n        throw Error(\"non exhaustive match\");\n    }\n}\n//# sourceMappingURL=model.js.map","import { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Rule, Terminal, } from \"./model.js\";\nexport class GAstVisitor {\n    visit(node) {\n        const nodeAny = node;\n        switch (nodeAny.constructor) {\n            case NonTerminal:\n                return this.visitNonTerminal(nodeAny);\n            case Alternative:\n                return this.visitAlternative(nodeAny);\n            case Option:\n                return this.visitOption(nodeAny);\n            case RepetitionMandatory:\n                return this.visitRepetitionMandatory(nodeAny);\n            case RepetitionMandatoryWithSeparator:\n                return this.visitRepetitionMandatoryWithSeparator(nodeAny);\n            case RepetitionWithSeparator:\n                return this.visitRepetitionWithSeparator(nodeAny);\n            case Repetition:\n                return this.visitRepetition(nodeAny);\n            case Alternation:\n                return this.visitAlternation(nodeAny);\n            case Terminal:\n                return this.visitTerminal(nodeAny);\n            case Rule:\n                return this.visitRule(nodeAny);\n            /* c8 ignore next 2 */\n            default:\n                throw Error(\"non exhaustive match\");\n        }\n    }\n    /* c8 ignore next */\n    visitNonTerminal(node) { }\n    /* c8 ignore next */\n    visitAlternative(node) { }\n    /* c8 ignore next */\n    visitOption(node) { }\n    /* c8 ignore next */\n    visitRepetition(node) { }\n    /* c8 ignore next */\n    visitRepetitionMandatory(node) { }\n    /* c8 ignore next 3 */\n    visitRepetitionMandatoryWithSeparator(node) { }\n    /* c8 ignore next */\n    visitRepetitionWithSeparator(node) { }\n    /* c8 ignore next */\n    visitAlternation(node) { }\n    /* c8 ignore next */\n    visitTerminal(node) { }\n    /* c8 ignore next */\n    visitRule(node) { }\n}\n//# sourceMappingURL=visitor.js.map","import baseEach from './_baseEach.js';\n\n/**\n * The base implementation of `_.some` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n *  else `false`.\n */\nfunction baseSome(collection, predicate) {\n  var result;\n\n  baseEach(collection, function(value, index, collection) {\n    result = predicate(value, index, collection);\n    return !result;\n  });\n  return !!result;\n}\n\nexport default baseSome;\n","import arraySome from './_arraySome.js';\nimport baseIteratee from './_baseIteratee.js';\nimport baseSome from './_baseSome.js';\nimport isArray from './isArray.js';\nimport isIterateeCall from './_isIterateeCall.js';\n\n/**\n * Checks if `predicate` returns truthy for **any** element of `collection`.\n * Iteration is stopped once `predicate` returns truthy. The predicate is\n * invoked with three arguments: (value, index|key, collection).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n *  else `false`.\n * @example\n *\n * _.some([null, 0, 'yes', false], Boolean);\n * // => true\n *\n * var users = [\n *   { 'user': 'barney', 'active': true },\n *   { 'user': 'fred',   'active': false }\n * ];\n *\n * // The `_.matches` iteratee shorthand.\n * _.some(users, { 'user': 'barney', 'active': false });\n * // => false\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.some(users, ['active', false]);\n * // => true\n *\n * // The `_.property` iteratee shorthand.\n * _.some(users, 'active');\n * // => true\n */\nfunction some(collection, predicate, guard) {\n  var func = isArray(collection) ? arraySome : baseSome;\n  if (guard && isIterateeCall(collection, predicate, guard)) {\n    predicate = undefined;\n  }\n  return func(collection, baseIteratee(predicate, 3));\n}\n\nexport default some;\n","import baseIndexOf from './_baseIndexOf.js';\nimport isArrayLike from './isArrayLike.js';\nimport isString from './isString.js';\nimport toInteger from './toInteger.js';\nimport values from './values.js';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * Checks if `value` is in `collection`. If `collection` is a string, it's\n * checked for a substring of `value`, otherwise\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * is used for equality comparisons. If `fromIndex` is negative, it's used as\n * the offset from the end of `collection`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object|string} collection The collection to inspect.\n * @param {*} value The value to search for.\n * @param {number} [fromIndex=0] The index to search from.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n * @returns {boolean} Returns `true` if `value` is found, else `false`.\n * @example\n *\n * _.includes([1, 2, 3], 1);\n * // => true\n *\n * _.includes([1, 2, 3], 1, 2);\n * // => false\n *\n * _.includes({ 'a': 1, 'b': 2 }, 1);\n * // => true\n *\n * _.includes('abcd', 'bc');\n * // => true\n */\nfunction includes(collection, value, fromIndex, guard) {\n  collection = isArrayLike(collection) ? collection : values(collection);\n  fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;\n\n  var length = collection.length;\n  if (fromIndex < 0) {\n    fromIndex = nativeMax(length + fromIndex, 0);\n  }\n  return isString(collection)\n    ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)\n    : (!!length && baseIndexOf(collection, value, fromIndex) > -1);\n}\n\nexport default includes;\n","/**\n * A specialized version of `_.every` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if all elements pass the predicate check,\n *  else `false`.\n */\nfunction arrayEvery(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length;\n\n  while (++index < length) {\n    if (!predicate(array[index], index, array)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport default arrayEvery;\n","import baseEach from './_baseEach.js';\n\n/**\n * The base implementation of `_.every` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if all elements pass the predicate check,\n *  else `false`\n */\nfunction baseEvery(collection, predicate) {\n  var result = true;\n  baseEach(collection, function(value, index, collection) {\n    result = !!predicate(value, index, collection);\n    return result;\n  });\n  return result;\n}\n\nexport default baseEvery;\n","import arrayEvery from './_arrayEvery.js';\nimport baseEvery from './_baseEvery.js';\nimport baseIteratee from './_baseIteratee.js';\nimport isArray from './isArray.js';\nimport isIterateeCall from './_isIterateeCall.js';\n\n/**\n * Checks if `predicate` returns truthy for **all** elements of `collection`.\n * Iteration is stopped once `predicate` returns falsey. The predicate is\n * invoked with three arguments: (value, index|key, collection).\n *\n * **Note:** This method returns `true` for\n * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because\n * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of\n * elements of empty collections.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {boolean} Returns `true` if all elements pass the predicate check,\n *  else `false`.\n * @example\n *\n * _.every([true, 1, null, 'yes'], Boolean);\n * // => false\n *\n * var users = [\n *   { 'user': 'barney', 'age': 36, 'active': false },\n *   { 'user': 'fred',   'age': 40, 'active': false }\n * ];\n *\n * // The `_.matches` iteratee shorthand.\n * _.every(users, { 'user': 'barney', 'active': false });\n * // => false\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.every(users, ['active', false]);\n * // => true\n *\n * // The `_.property` iteratee shorthand.\n * _.every(users, 'active');\n * // => false\n */\nfunction every(collection, predicate, guard) {\n  var func = isArray(collection) ? arrayEvery : baseEvery;\n  if (guard && isIterateeCall(collection, predicate, guard)) {\n    predicate = undefined;\n  }\n  return func(collection, baseIteratee(predicate, 3));\n}\n\nexport default every;\n","import { every, includes, some } from \"lodash-es\";\nimport { AbstractProduction, Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Rule, Terminal, } from \"./model.js\";\nexport function isSequenceProd(prod) {\n    return (prod instanceof Alternative ||\n        prod instanceof Option ||\n        prod instanceof Repetition ||\n        prod instanceof RepetitionMandatory ||\n        prod instanceof RepetitionMandatoryWithSeparator ||\n        prod instanceof RepetitionWithSeparator ||\n        prod instanceof Terminal ||\n        prod instanceof Rule);\n}\nexport function isOptionalProd(prod, alreadyVisited = []) {\n    const isDirectlyOptional = prod instanceof Option ||\n        prod instanceof Repetition ||\n        prod instanceof RepetitionWithSeparator;\n    if (isDirectlyOptional) {\n        return true;\n    }\n    // note that this can cause infinite loop if one optional empty TOP production has a cyclic dependency with another\n    // empty optional top rule\n    // may be indirectly optional ((A?B?C?) | (D?E?F?))\n    if (prod instanceof Alternation) {\n        // for OR its enough for just one of the alternatives to be optional\n        return some(prod.definition, (subProd) => {\n            return isOptionalProd(subProd, alreadyVisited);\n        });\n    }\n    else if (prod instanceof NonTerminal && includes(alreadyVisited, prod)) {\n        // avoiding stack overflow due to infinite recursion\n        return false;\n    }\n    else if (prod instanceof AbstractProduction) {\n        if (prod instanceof NonTerminal) {\n            alreadyVisited.push(prod);\n        }\n        return every(prod.definition, (subProd) => {\n            return isOptionalProd(subProd, alreadyVisited);\n        });\n    }\n    else {\n        return false;\n    }\n}\nexport function isBranchingProd(prod) {\n    return prod instanceof Alternation;\n}\nexport function getProductionDslName(prod) {\n    /* istanbul ignore else */\n    if (prod instanceof NonTerminal) {\n        return \"SUBRULE\";\n    }\n    else if (prod instanceof Option) {\n        return \"OPTION\";\n    }\n    else if (prod instanceof Alternation) {\n        return \"OR\";\n    }\n    else if (prod instanceof RepetitionMandatory) {\n        return \"AT_LEAST_ONE\";\n    }\n    else if (prod instanceof RepetitionMandatoryWithSeparator) {\n        return \"AT_LEAST_ONE_SEP\";\n    }\n    else if (prod instanceof RepetitionWithSeparator) {\n        return \"MANY_SEP\";\n    }\n    else if (prod instanceof Repetition) {\n        return \"MANY\";\n    }\n    else if (prod instanceof Terminal) {\n        return \"CONSUME\";\n        /* c8 ignore next 3 */\n    }\n    else {\n        throw Error(\"non exhaustive match\");\n    }\n}\n//# sourceMappingURL=helpers.js.map","import { drop, forEach } from \"lodash-es\";\nimport { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Terminal, } from \"@chevrotain/gast\";\n/**\n *  A Grammar Walker that computes the \"remaining\" grammar \"after\" a productions in the grammar.\n */\nexport class RestWalker {\n    walk(prod, prevRest = []) {\n        forEach(prod.definition, (subProd, index) => {\n            const currRest = drop(prod.definition, index + 1);\n            /* istanbul ignore else */\n            if (subProd instanceof NonTerminal) {\n                this.walkProdRef(subProd, currRest, prevRest);\n            }\n            else if (subProd instanceof Terminal) {\n                this.walkTerminal(subProd, currRest, prevRest);\n            }\n            else if (subProd instanceof Alternative) {\n                this.walkFlat(subProd, currRest, prevRest);\n            }\n            else if (subProd instanceof Option) {\n                this.walkOption(subProd, currRest, prevRest);\n            }\n            else if (subProd instanceof RepetitionMandatory) {\n                this.walkAtLeastOne(subProd, currRest, prevRest);\n            }\n            else if (subProd instanceof RepetitionMandatoryWithSeparator) {\n                this.walkAtLeastOneSep(subProd, currRest, prevRest);\n            }\n            else if (subProd instanceof RepetitionWithSeparator) {\n                this.walkManySep(subProd, currRest, prevRest);\n            }\n            else if (subProd instanceof Repetition) {\n                this.walkMany(subProd, currRest, prevRest);\n            }\n            else if (subProd instanceof Alternation) {\n                this.walkOr(subProd, currRest, prevRest);\n            }\n            else {\n                throw Error(\"non exhaustive match\");\n            }\n        });\n    }\n    walkTerminal(terminal, currRest, prevRest) { }\n    walkProdRef(refProd, currRest, prevRest) { }\n    walkFlat(flatProd, currRest, prevRest) {\n        // ABCDEF => after the D the rest is EF\n        const fullOrRest = currRest.concat(prevRest);\n        this.walk(flatProd, fullOrRest);\n    }\n    walkOption(optionProd, currRest, prevRest) {\n        // ABC(DE)?F => after the (DE)? the rest is F\n        const fullOrRest = currRest.concat(prevRest);\n        this.walk(optionProd, fullOrRest);\n    }\n    walkAtLeastOne(atLeastOneProd, currRest, prevRest) {\n        // ABC(DE)+F => after the (DE)+ the rest is (DE)?F\n        const fullAtLeastOneRest = [\n            new Option({ definition: atLeastOneProd.definition }),\n        ].concat(currRest, prevRest);\n        this.walk(atLeastOneProd, fullAtLeastOneRest);\n    }\n    walkAtLeastOneSep(atLeastOneSepProd, currRest, prevRest) {\n        // ABC DE(,DE)* F => after the (,DE)+ the rest is (,DE)?F\n        const fullAtLeastOneSepRest = restForRepetitionWithSeparator(atLeastOneSepProd, currRest, prevRest);\n        this.walk(atLeastOneSepProd, fullAtLeastOneSepRest);\n    }\n    walkMany(manyProd, currRest, prevRest) {\n        // ABC(DE)*F => after the (DE)* the rest is (DE)?F\n        const fullManyRest = [\n            new Option({ definition: manyProd.definition }),\n        ].concat(currRest, prevRest);\n        this.walk(manyProd, fullManyRest);\n    }\n    walkManySep(manySepProd, currRest, prevRest) {\n        // ABC (DE(,DE)*)? F => after the (,DE)* the rest is (,DE)?F\n        const fullManySepRest = restForRepetitionWithSeparator(manySepProd, currRest, prevRest);\n        this.walk(manySepProd, fullManySepRest);\n    }\n    walkOr(orProd, currRest, prevRest) {\n        // ABC(D|E|F)G => when finding the (D|E|F) the rest is G\n        const fullOrRest = currRest.concat(prevRest);\n        // walk all different alternatives\n        forEach(orProd.definition, (alt) => {\n            // wrapping each alternative in a single definition wrapper\n            // to avoid errors in computing the rest of that alternative in the invocation to computeInProdFollows\n            // (otherwise for OR([alt1,alt2]) alt2 will be considered in 'rest' of alt1\n            const prodWrapper = new Alternative({ definition: [alt] });\n            this.walk(prodWrapper, fullOrRest);\n        });\n    }\n}\nfunction restForRepetitionWithSeparator(repSepProd, currRest, prevRest) {\n    const repSepRest = [\n        new Option({\n            definition: [\n                new Terminal({ terminalType: repSepProd.separator }),\n            ].concat(repSepProd.definition),\n        }),\n    ];\n    const fullRepSepRest = repSepRest.concat(currRest, prevRest);\n    return fullRepSepRest;\n}\n//# sourceMappingURL=rest.js.map","import baseUniq from './_baseUniq.js';\n\n/**\n * Creates a duplicate-free version of an array, using\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons, in which only the first occurrence of each element\n * is kept. The order of result values is determined by the order they occur\n * in the array.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @returns {Array} Returns the new duplicate free array.\n * @example\n *\n * _.uniq([2, 1, 2]);\n * // => [2, 1]\n */\nfunction uniq(array) {\n  return (array && array.length) ? baseUniq(array) : [];\n}\n\nexport default uniq;\n","import { flatten, map, uniq } from \"lodash-es\";\nimport { isBranchingProd, isOptionalProd, isSequenceProd, NonTerminal, Terminal, } from \"@chevrotain/gast\";\nexport function first(prod) {\n    /* istanbul ignore else */\n    if (prod instanceof NonTerminal) {\n        // this could in theory cause infinite loops if\n        // (1) prod A refs prod B.\n        // (2) prod B refs prod A\n        // (3) AB can match the empty set\n        // in other words a cycle where everything is optional so the first will keep\n        // looking ahead for the next optional part and will never exit\n        // currently there is no safeguard for this unique edge case because\n        // (1) not sure a grammar in which this can happen is useful for anything (productive)\n        return first(prod.referencedRule);\n    }\n    else if (prod instanceof Terminal) {\n        return firstForTerminal(prod);\n    }\n    else if (isSequenceProd(prod)) {\n        return firstForSequence(prod);\n    }\n    else if (isBranchingProd(prod)) {\n        return firstForBranching(prod);\n    }\n    else {\n        throw Error(\"non exhaustive match\");\n    }\n}\nexport function firstForSequence(prod) {\n    let firstSet = [];\n    const seq = prod.definition;\n    let nextSubProdIdx = 0;\n    let hasInnerProdsRemaining = seq.length > nextSubProdIdx;\n    let currSubProd;\n    // so we enter the loop at least once (if the definition is not empty\n    let isLastInnerProdOptional = true;\n    // scan a sequence until it's end or until we have found a NONE optional production in it\n    while (hasInnerProdsRemaining && isLastInnerProdOptional) {\n        currSubProd = seq[nextSubProdIdx];\n        isLastInnerProdOptional = isOptionalProd(currSubProd);\n        firstSet = firstSet.concat(first(currSubProd));\n        nextSubProdIdx = nextSubProdIdx + 1;\n        hasInnerProdsRemaining = seq.length > nextSubProdIdx;\n    }\n    return uniq(firstSet);\n}\nexport function firstForBranching(prod) {\n    const allAlternativesFirsts = map(prod.definition, (innerProd) => {\n        return first(innerProd);\n    });\n    return uniq(flatten(allAlternativesFirsts));\n}\nexport function firstForTerminal(terminal) {\n    return [terminal.terminalType];\n}\n//# sourceMappingURL=first.js.map","// TODO: can this be removed? where is it used?\nexport const IN = \"_~IN~_\";\n//# sourceMappingURL=constants.js.map","import { RestWalker } from \"./rest.js\";\nimport { first } from \"./first.js\";\nimport { assign, forEach } from \"lodash-es\";\nimport { IN } from \"../constants.js\";\nimport { Alternative } from \"@chevrotain/gast\";\n// This ResyncFollowsWalker computes all of the follows required for RESYNC\n// (skipping reference production).\nexport class ResyncFollowsWalker extends RestWalker {\n    constructor(topProd) {\n        super();\n        this.topProd = topProd;\n        this.follows = {};\n    }\n    startWalking() {\n        this.walk(this.topProd);\n        return this.follows;\n    }\n    walkTerminal(terminal, currRest, prevRest) {\n        // do nothing! just like in the public sector after 13:00\n    }\n    walkProdRef(refProd, currRest, prevRest) {\n        const followName = buildBetweenProdsFollowPrefix(refProd.referencedRule, refProd.idx) +\n            this.topProd.name;\n        const fullRest = currRest.concat(prevRest);\n        const restProd = new Alternative({ definition: fullRest });\n        const t_in_topProd_follows = first(restProd);\n        this.follows[followName] = t_in_topProd_follows;\n    }\n}\nexport function computeAllProdsFollows(topProductions) {\n    const reSyncFollows = {};\n    forEach(topProductions, (topProd) => {\n        const currRefsFollow = new ResyncFollowsWalker(topProd).startWalking();\n        assign(reSyncFollows, currRefsFollow);\n    });\n    return reSyncFollows;\n}\nexport function buildBetweenProdsFollowPrefix(inner, occurenceInParent) {\n    return inner.name + occurenceInParent + IN;\n}\nexport function buildInProdFollowPrefix(terminal) {\n    const terminalName = terminal.terminalType.name;\n    return terminalName + terminal.idx + IN;\n}\n//# sourceMappingURL=follow.js.map","/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a function that negates the result of the predicate `func`. The\n * `func` predicate is invoked with the `this` binding and arguments of the\n * created function.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Function\n * @param {Function} predicate The predicate to negate.\n * @returns {Function} Returns the new negated function.\n * @example\n *\n * function isEven(n) {\n *   return n % 2 == 0;\n * }\n *\n * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));\n * // => [1, 3, 5]\n */\nfunction negate(predicate) {\n  if (typeof predicate != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  return function() {\n    var args = arguments;\n    switch (args.length) {\n      case 0: return !predicate.call(this);\n      case 1: return !predicate.call(this, args[0]);\n      case 2: return !predicate.call(this, args[0], args[1]);\n      case 3: return !predicate.call(this, args[0], args[1], args[2]);\n    }\n    return !predicate.apply(this, args);\n  };\n}\n\nexport default negate;\n","import arrayFilter from './_arrayFilter.js';\nimport baseFilter from './_baseFilter.js';\nimport baseIteratee from './_baseIteratee.js';\nimport isArray from './isArray.js';\nimport negate from './negate.js';\n\n/**\n * The opposite of `_.filter`; this method returns the elements of `collection`\n * that `predicate` does **not** return truthy for.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n * @see _.filter\n * @example\n *\n * var users = [\n *   { 'user': 'barney', 'age': 36, 'active': false },\n *   { 'user': 'fred',   'age': 40, 'active': true }\n * ];\n *\n * _.reject(users, function(o) { return !o.active; });\n * // => objects for ['fred']\n *\n * // The `_.matches` iteratee shorthand.\n * _.reject(users, { 'age': 40, 'active': true });\n * // => objects for ['barney']\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.reject(users, ['active', false]);\n * // => objects for ['fred']\n *\n * // The `_.property` iteratee shorthand.\n * _.reject(users, 'active');\n * // => objects for ['barney']\n */\nfunction reject(collection, predicate) {\n  var func = isArray(collection) ? arrayFilter : baseFilter;\n  return func(collection, negate(baseIteratee(predicate, 3)));\n}\n\nexport default reject;\n","import baseIndexOf from './_baseIndexOf.js';\nimport toInteger from './toInteger.js';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * Gets the index at which the first occurrence of `value` is found in `array`\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons. If `fromIndex` is negative, it's used as the\n * offset from the end of `array`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} [fromIndex=0] The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n * @example\n *\n * _.indexOf([1, 2, 1, 2], 2);\n * // => 1\n *\n * // Search from the `fromIndex`.\n * _.indexOf([1, 2, 1, 2], 2, 2);\n * // => 3\n */\nfunction indexOf(array, value, fromIndex) {\n  var length = array == null ? 0 : array.length;\n  if (!length) {\n    return -1;\n  }\n  var index = fromIndex == null ? 0 : toInteger(fromIndex);\n  if (index < 0) {\n    index = nativeMax(length + index, 0);\n  }\n  return baseIndexOf(array, value, index);\n}\n\nexport default indexOf;\n","import baseDifference from './_baseDifference.js';\nimport baseFlatten from './_baseFlatten.js';\nimport baseRest from './_baseRest.js';\nimport isArrayLikeObject from './isArrayLikeObject.js';\n\n/**\n * Creates an array of `array` values not included in the other given arrays\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons. The order and references of result values are\n * determined by the first array.\n *\n * **Note:** Unlike `_.pullAll`, this method returns a new array.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {...Array} [values] The values to exclude.\n * @returns {Array} Returns the new array of filtered values.\n * @see _.without, _.xor\n * @example\n *\n * _.difference([2, 1], [2, 3]);\n * // => [1]\n */\nvar difference = baseRest(function(array, values) {\n  return isArrayLikeObject(array)\n    ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))\n    : [];\n});\n\nexport default difference;\n","import SetCache from './_SetCache.js';\nimport arrayIncludes from './_arrayIncludes.js';\nimport arrayIncludesWith from './_arrayIncludesWith.js';\nimport arrayMap from './_arrayMap.js';\nimport baseUnary from './_baseUnary.js';\nimport cacheHas from './_cacheHas.js';\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * The base implementation of methods like `_.difference` without support\n * for excluding multiple arrays or iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Array} values The values to exclude.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new array of filtered values.\n */\nfunction baseDifference(array, values, iteratee, comparator) {\n  var index = -1,\n      includes = arrayIncludes,\n      isCommon = true,\n      length = array.length,\n      result = [],\n      valuesLength = values.length;\n\n  if (!length) {\n    return result;\n  }\n  if (iteratee) {\n    values = arrayMap(values, baseUnary(iteratee));\n  }\n  if (comparator) {\n    includes = arrayIncludesWith;\n    isCommon = false;\n  }\n  else if (values.length >= LARGE_ARRAY_SIZE) {\n    includes = cacheHas;\n    isCommon = false;\n    values = new SetCache(values);\n  }\n  outer:\n  while (++index < length) {\n    var value = array[index],\n        computed = iteratee == null ? value : iteratee(value);\n\n    value = (comparator || value !== 0) ? value : 0;\n    if (isCommon && computed === computed) {\n      var valuesIndex = valuesLength;\n      while (valuesIndex--) {\n        if (values[valuesIndex] === computed) {\n          continue outer;\n        }\n      }\n      result.push(value);\n    }\n    else if (!includes(values, computed, comparator)) {\n      result.push(value);\n    }\n  }\n  return result;\n}\n\nexport default baseDifference;\n","/**\n * Creates an array with all falsey values removed. The values `false`, `null`,\n * `0`, `\"\"`, `undefined`, and `NaN` are falsey.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to compact.\n * @returns {Array} Returns the new array of filtered values.\n * @example\n *\n * _.compact([0, 1, false, 2, '', 3]);\n * // => [1, 2, 3]\n */\nfunction compact(array) {\n  var index = -1,\n      length = array == null ? 0 : array.length,\n      resIndex = 0,\n      result = [];\n\n  while (++index < length) {\n    var value = array[index];\n    if (value) {\n      result[resIndex++] = value;\n    }\n  }\n  return result;\n}\n\nexport default compact;\n","/**\n * Gets the first element of `array`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @alias first\n * @category Array\n * @param {Array} array The array to query.\n * @returns {*} Returns the first element of `array`.\n * @example\n *\n * _.head([1, 2, 3]);\n * // => 1\n *\n * _.head([]);\n * // => undefined\n */\nfunction head(array) {\n  return (array && array.length) ? array[0] : undefined;\n}\n\nexport default head;\n","export function PRINT_ERROR(msg) {\n    /* istanbul ignore else - can't override global.console in node.js */\n    if (console && console.error) {\n        console.error(`Error: ${msg}`);\n    }\n}\nexport function PRINT_WARNING(msg) {\n    /* istanbul ignore else - can't override global.console in node.js*/\n    if (console && console.warn) {\n        // TODO: modify docs accordingly\n        console.warn(`Warning: ${msg}`);\n    }\n}\n//# sourceMappingURL=print.js.map","import { RegExpParser, } from \"@chevrotain/regexp-to-ast\";\nlet regExpAstCache = {};\nconst regExpParser = new RegExpParser();\nexport function getRegExpAst(regExp) {\n    const regExpStr = regExp.toString();\n    if (regExpAstCache.hasOwnProperty(regExpStr)) {\n        return regExpAstCache[regExpStr];\n    }\n    else {\n        const regExpAst = regExpParser.pattern(regExpStr);\n        regExpAstCache[regExpStr] = regExpAst;\n        return regExpAst;\n    }\n}\nexport function clearRegExpParserCache() {\n    regExpAstCache = {};\n}\n//# sourceMappingURL=reg_exp_parser.js.map","import { BaseRegExpVisitor, } from \"@chevrotain/regexp-to-ast\";\nimport { every, find, forEach, includes, isArray, values } from \"lodash-es\";\nimport { PRINT_ERROR, PRINT_WARNING } from \"@chevrotain/utils\";\nimport { getRegExpAst } from \"./reg_exp_parser.js\";\nimport { charCodeToOptimizedIndex, minOptimizationVal } from \"./lexer.js\";\nconst complementErrorMessage = \"Complement Sets are not supported for first char optimization\";\nexport const failedOptimizationPrefixMsg = 'Unable to use \"first char\" lexer optimizations:\\n';\nexport function getOptimizedStartCodesIndices(regExp, ensureOptimizations = false) {\n    try {\n        const ast = getRegExpAst(regExp);\n        const firstChars = firstCharOptimizedIndices(ast.value, {}, ast.flags.ignoreCase);\n        return firstChars;\n    }\n    catch (e) {\n        /* istanbul ignore next */\n        // Testing this relies on the regexp-to-ast library having a bug... */\n        // TODO: only the else branch needs to be ignored, try to fix with newer prettier / tsc\n        if (e.message === complementErrorMessage) {\n            if (ensureOptimizations) {\n                PRINT_WARNING(`${failedOptimizationPrefixMsg}` +\n                    `\\tUnable to optimize: < ${regExp.toString()} >\\n` +\n                    \"\\tComplement Sets cannot be automatically optimized.\\n\" +\n                    \"\\tThis will disable the lexer's first char optimizations.\\n\" +\n                    \"\\tSee: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#COMPLEMENT for details.\");\n            }\n        }\n        else {\n            let msgSuffix = \"\";\n            if (ensureOptimizations) {\n                msgSuffix =\n                    \"\\n\\tThis will disable the lexer's first char optimizations.\\n\" +\n                        \"\\tSee: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#REGEXP_PARSING for details.\";\n            }\n            PRINT_ERROR(`${failedOptimizationPrefixMsg}\\n` +\n                `\\tFailed parsing: < ${regExp.toString()} >\\n` +\n                `\\tUsing the @chevrotain/regexp-to-ast library\\n` +\n                \"\\tPlease open an issue at: https://github.com/chevrotain/chevrotain/issues\" +\n                msgSuffix);\n        }\n    }\n    return [];\n}\nexport function firstCharOptimizedIndices(ast, result, ignoreCase) {\n    switch (ast.type) {\n        case \"Disjunction\":\n            for (let i = 0; i < ast.value.length; i++) {\n                firstCharOptimizedIndices(ast.value[i], result, ignoreCase);\n            }\n            break;\n        case \"Alternative\":\n            const terms = ast.value;\n            for (let i = 0; i < terms.length; i++) {\n                const term = terms[i];\n                // skip terms that cannot effect the first char results\n                switch (term.type) {\n                    case \"EndAnchor\":\n                    // A group back reference cannot affect potential starting char.\n                    // because if a back reference is the first production than automatically\n                    // the group being referenced has had to come BEFORE so its codes have already been added\n                    case \"GroupBackReference\":\n                    // assertions do not affect potential starting codes\n                    case \"Lookahead\":\n                    case \"NegativeLookahead\":\n                    case \"StartAnchor\":\n                    case \"WordBoundary\":\n                    case \"NonWordBoundary\":\n                        continue;\n                }\n                const atom = term;\n                switch (atom.type) {\n                    case \"Character\":\n                        addOptimizedIdxToResult(atom.value, result, ignoreCase);\n                        break;\n                    case \"Set\":\n                        if (atom.complement === true) {\n                            throw Error(complementErrorMessage);\n                        }\n                        forEach(atom.value, (code) => {\n                            if (typeof code === \"number\") {\n                                addOptimizedIdxToResult(code, result, ignoreCase);\n                            }\n                            else {\n                                // range\n                                const range = code;\n                                // cannot optimize when ignoreCase is\n                                if (ignoreCase === true) {\n                                    for (let rangeCode = range.from; rangeCode <= range.to; rangeCode++) {\n                                        addOptimizedIdxToResult(rangeCode, result, ignoreCase);\n                                    }\n                                }\n                                // Optimization (2 orders of magnitude less work for very large ranges)\n                                else {\n                                    // handle unoptimized values\n                                    for (let rangeCode = range.from; rangeCode <= range.to && rangeCode < minOptimizationVal; rangeCode++) {\n                                        addOptimizedIdxToResult(rangeCode, result, ignoreCase);\n                                    }\n                                    // Less common charCode where we optimize for faster init time, by using larger \"buckets\"\n                                    if (range.to >= minOptimizationVal) {\n                                        const minUnOptVal = range.from >= minOptimizationVal\n                                            ? range.from\n                                            : minOptimizationVal;\n                                        const maxUnOptVal = range.to;\n                                        const minOptIdx = charCodeToOptimizedIndex(minUnOptVal);\n                                        const maxOptIdx = charCodeToOptimizedIndex(maxUnOptVal);\n                                        for (let currOptIdx = minOptIdx; currOptIdx <= maxOptIdx; currOptIdx++) {\n                                            result[currOptIdx] = currOptIdx;\n                                        }\n                                    }\n                                }\n                            }\n                        });\n                        break;\n                    case \"Group\":\n                        firstCharOptimizedIndices(atom.value, result, ignoreCase);\n                        break;\n                    /* istanbul ignore next */\n                    default:\n                        throw Error(\"Non Exhaustive Match\");\n                }\n                // reached a mandatory production, no more **start** codes can be found on this alternative\n                const isOptionalQuantifier = atom.quantifier !== undefined && atom.quantifier.atLeast === 0;\n                if (\n                // A group may be optional due to empty contents /(?:)/\n                // or if everything inside it is optional /((a)?)/\n                (atom.type === \"Group\" && isWholeOptional(atom) === false) ||\n                    // If this term is not a group it may only be optional if it has an optional quantifier\n                    (atom.type !== \"Group\" && isOptionalQuantifier === false)) {\n                    break;\n                }\n            }\n            break;\n        /* istanbul ignore next */\n        default:\n            throw Error(\"non exhaustive match!\");\n    }\n    // console.log(Object.keys(result).length)\n    return values(result);\n}\nfunction addOptimizedIdxToResult(code, result, ignoreCase) {\n    const optimizedCharIdx = charCodeToOptimizedIndex(code);\n    result[optimizedCharIdx] = optimizedCharIdx;\n    if (ignoreCase === true) {\n        handleIgnoreCase(code, result);\n    }\n}\nfunction handleIgnoreCase(code, result) {\n    const char = String.fromCharCode(code);\n    const upperChar = char.toUpperCase();\n    /* istanbul ignore else */\n    if (upperChar !== char) {\n        const optimizedCharIdx = charCodeToOptimizedIndex(upperChar.charCodeAt(0));\n        result[optimizedCharIdx] = optimizedCharIdx;\n    }\n    else {\n        const lowerChar = char.toLowerCase();\n        if (lowerChar !== char) {\n            const optimizedCharIdx = charCodeToOptimizedIndex(lowerChar.charCodeAt(0));\n            result[optimizedCharIdx] = optimizedCharIdx;\n        }\n    }\n}\nfunction findCode(setNode, targetCharCodes) {\n    return find(setNode.value, (codeOrRange) => {\n        if (typeof codeOrRange === \"number\") {\n            return includes(targetCharCodes, codeOrRange);\n        }\n        else {\n            // range\n            const range = codeOrRange;\n            return (find(targetCharCodes, (targetCode) => range.from <= targetCode && targetCode <= range.to) !== undefined);\n        }\n    });\n}\nfunction isWholeOptional(ast) {\n    const quantifier = ast.quantifier;\n    if (quantifier && quantifier.atLeast === 0) {\n        return true;\n    }\n    if (!ast.value) {\n        return false;\n    }\n    return isArray(ast.value)\n        ? every(ast.value, isWholeOptional)\n        : isWholeOptional(ast.value);\n}\nclass CharCodeFinder extends BaseRegExpVisitor {\n    constructor(targetCharCodes) {\n        super();\n        this.targetCharCodes = targetCharCodes;\n        this.found = false;\n    }\n    visitChildren(node) {\n        // No need to keep looking...\n        if (this.found === true) {\n            return;\n        }\n        // switch lookaheads as they do not actually consume any characters thus\n        // finding a charCode at lookahead context does not mean that regexp can actually contain it in a match.\n        switch (node.type) {\n            case \"Lookahead\":\n                this.visitLookahead(node);\n                return;\n            case \"NegativeLookahead\":\n                this.visitNegativeLookahead(node);\n                return;\n        }\n        super.visitChildren(node);\n    }\n    visitCharacter(node) {\n        if (includes(this.targetCharCodes, node.value)) {\n            this.found = true;\n        }\n    }\n    visitSet(node) {\n        if (node.complement) {\n            if (findCode(node, this.targetCharCodes) === undefined) {\n                this.found = true;\n            }\n        }\n        else {\n            if (findCode(node, this.targetCharCodes) !== undefined) {\n                this.found = true;\n            }\n        }\n    }\n}\nexport function canMatchCharCode(charCodes, pattern) {\n    if (pattern instanceof RegExp) {\n        const ast = getRegExpAst(pattern);\n        const charCodeFinder = new CharCodeFinder(charCodes);\n        charCodeFinder.visit(ast);\n        return charCodeFinder.found;\n    }\n    else {\n        return (find(pattern, (char) => {\n            return includes(charCodes, char.charCodeAt(0));\n        }) !== undefined);\n    }\n}\n//# sourceMappingURL=reg_exp.js.map","import { BaseRegExpVisitor } from \"@chevrotain/regexp-to-ast\";\nimport { Lexer, LexerDefinitionErrorType, } from \"./lexer_public.js\";\nimport { compact, defaults, difference, filter, find, first, flatten, forEach, has, includes, indexOf, isArray, isEmpty, isFunction, isRegExp, isString, isUndefined, keys, map, reduce, reject, values, } from \"lodash-es\";\nimport { PRINT_ERROR } from \"@chevrotain/utils\";\nimport { canMatchCharCode, failedOptimizationPrefixMsg, getOptimizedStartCodesIndices, } from \"./reg_exp.js\";\nimport { getRegExpAst } from \"./reg_exp_parser.js\";\nconst PATTERN = \"PATTERN\";\nexport const DEFAULT_MODE = \"defaultMode\";\nexport const MODES = \"modes\";\nexport let SUPPORT_STICKY = typeof new RegExp(\"(?:)\").sticky === \"boolean\";\nexport function disableSticky() {\n    SUPPORT_STICKY = false;\n}\nexport function enableSticky() {\n    SUPPORT_STICKY = true;\n}\nexport function analyzeTokenTypes(tokenTypes, options) {\n    options = defaults(options, {\n        useSticky: SUPPORT_STICKY,\n        debug: false,\n        safeMode: false,\n        positionTracking: \"full\",\n        lineTerminatorCharacters: [\"\\r\", \"\\n\"],\n        tracer: (msg, action) => action(),\n    });\n    const tracer = options.tracer;\n    tracer(\"initCharCodeToOptimizedIndexMap\", () => {\n        initCharCodeToOptimizedIndexMap();\n    });\n    let onlyRelevantTypes;\n    tracer(\"Reject Lexer.NA\", () => {\n        onlyRelevantTypes = reject(tokenTypes, (currType) => {\n            return currType[PATTERN] === Lexer.NA;\n        });\n    });\n    let hasCustom = false;\n    let allTransformedPatterns;\n    tracer(\"Transform Patterns\", () => {\n        hasCustom = false;\n        allTransformedPatterns = map(onlyRelevantTypes, (currType) => {\n            const currPattern = currType[PATTERN];\n            /* istanbul ignore else */\n            if (isRegExp(currPattern)) {\n                const regExpSource = currPattern.source;\n                if (regExpSource.length === 1 &&\n                    // only these regExp meta characters which can appear in a length one regExp\n                    regExpSource !== \"^\" &&\n                    regExpSource !== \"$\" &&\n                    regExpSource !== \".\" &&\n                    !currPattern.ignoreCase) {\n                    return regExpSource;\n                }\n                else if (regExpSource.length === 2 &&\n                    regExpSource[0] === \"\\\\\" &&\n                    // not a meta character\n                    !includes([\n                        \"d\",\n                        \"D\",\n                        \"s\",\n                        \"S\",\n                        \"t\",\n                        \"r\",\n                        \"n\",\n                        \"t\",\n                        \"0\",\n                        \"c\",\n                        \"b\",\n                        \"B\",\n                        \"f\",\n                        \"v\",\n                        \"w\",\n                        \"W\",\n                    ], regExpSource[1])) {\n                    // escaped meta Characters: /\\+/ /\\[/\n                    // or redundant escaping: /\\a/\n                    // without the escaping \"\\\"\n                    return regExpSource[1];\n                }\n                else {\n                    return options.useSticky\n                        ? addStickyFlag(currPattern)\n                        : addStartOfInput(currPattern);\n                }\n            }\n            else if (isFunction(currPattern)) {\n                hasCustom = true;\n                // CustomPatternMatcherFunc - custom patterns do not require any transformations, only wrapping in a RegExp Like object\n                return { exec: currPattern };\n            }\n            else if (typeof currPattern === \"object\") {\n                hasCustom = true;\n                // ICustomPattern\n                return currPattern;\n            }\n            else if (typeof currPattern === \"string\") {\n                if (currPattern.length === 1) {\n                    return currPattern;\n                }\n                else {\n                    const escapedRegExpString = currPattern.replace(/[\\\\^$.*+?()[\\]{}|]/g, \"\\\\$&\");\n                    const wrappedRegExp = new RegExp(escapedRegExpString);\n                    return options.useSticky\n                        ? addStickyFlag(wrappedRegExp)\n                        : addStartOfInput(wrappedRegExp);\n                }\n            }\n            else {\n                throw Error(\"non exhaustive match\");\n            }\n        });\n    });\n    let patternIdxToType;\n    let patternIdxToGroup;\n    let patternIdxToLongerAltIdxArr;\n    let patternIdxToPushMode;\n    let patternIdxToPopMode;\n    tracer(\"misc mapping\", () => {\n        patternIdxToType = map(onlyRelevantTypes, (currType) => currType.tokenTypeIdx);\n        patternIdxToGroup = map(onlyRelevantTypes, (clazz) => {\n            const groupName = clazz.GROUP;\n            /* istanbul ignore next */\n            if (groupName === Lexer.SKIPPED) {\n                return undefined;\n            }\n            else if (isString(groupName)) {\n                return groupName;\n            }\n            else if (isUndefined(groupName)) {\n                return false;\n            }\n            else {\n                throw Error(\"non exhaustive match\");\n            }\n        });\n        patternIdxToLongerAltIdxArr = map(onlyRelevantTypes, (clazz) => {\n            const longerAltType = clazz.LONGER_ALT;\n            if (longerAltType) {\n                const longerAltIdxArr = isArray(longerAltType)\n                    ? map(longerAltType, (type) => indexOf(onlyRelevantTypes, type))\n                    : [indexOf(onlyRelevantTypes, longerAltType)];\n                return longerAltIdxArr;\n            }\n        });\n        patternIdxToPushMode = map(onlyRelevantTypes, (clazz) => clazz.PUSH_MODE);\n        patternIdxToPopMode = map(onlyRelevantTypes, (clazz) => has(clazz, \"POP_MODE\"));\n    });\n    let patternIdxToCanLineTerminator;\n    tracer(\"Line Terminator Handling\", () => {\n        const lineTerminatorCharCodes = getCharCodes(options.lineTerminatorCharacters);\n        patternIdxToCanLineTerminator = map(onlyRelevantTypes, (tokType) => false);\n        if (options.positionTracking !== \"onlyOffset\") {\n            patternIdxToCanLineTerminator = map(onlyRelevantTypes, (tokType) => {\n                if (has(tokType, \"LINE_BREAKS\")) {\n                    return !!tokType.LINE_BREAKS;\n                }\n                else {\n                    return (checkLineBreaksIssues(tokType, lineTerminatorCharCodes) === false &&\n                        canMatchCharCode(lineTerminatorCharCodes, tokType.PATTERN));\n                }\n            });\n        }\n    });\n    let patternIdxToIsCustom;\n    let patternIdxToShort;\n    let emptyGroups;\n    let patternIdxToConfig;\n    tracer(\"Misc Mapping #2\", () => {\n        patternIdxToIsCustom = map(onlyRelevantTypes, isCustomPattern);\n        patternIdxToShort = map(allTransformedPatterns, isShortPattern);\n        emptyGroups = reduce(onlyRelevantTypes, (acc, clazz) => {\n            const groupName = clazz.GROUP;\n            if (isString(groupName) && !(groupName === Lexer.SKIPPED)) {\n                acc[groupName] = [];\n            }\n            return acc;\n        }, {});\n        patternIdxToConfig = map(allTransformedPatterns, (x, idx) => {\n            return {\n                pattern: allTransformedPatterns[idx],\n                longerAlt: patternIdxToLongerAltIdxArr[idx],\n                canLineTerminator: patternIdxToCanLineTerminator[idx],\n                isCustom: patternIdxToIsCustom[idx],\n                short: patternIdxToShort[idx],\n                group: patternIdxToGroup[idx],\n                push: patternIdxToPushMode[idx],\n                pop: patternIdxToPopMode[idx],\n                tokenTypeIdx: patternIdxToType[idx],\n                tokenType: onlyRelevantTypes[idx],\n            };\n        });\n    });\n    let canBeOptimized = true;\n    let charCodeToPatternIdxToConfig = [];\n    if (!options.safeMode) {\n        tracer(\"First Char Optimization\", () => {\n            charCodeToPatternIdxToConfig = reduce(onlyRelevantTypes, (result, currTokType, idx) => {\n                if (typeof currTokType.PATTERN === \"string\") {\n                    const charCode = currTokType.PATTERN.charCodeAt(0);\n                    const optimizedIdx = charCodeToOptimizedIndex(charCode);\n                    addToMapOfArrays(result, optimizedIdx, patternIdxToConfig[idx]);\n                }\n                else if (isArray(currTokType.START_CHARS_HINT)) {\n                    let lastOptimizedIdx;\n                    forEach(currTokType.START_CHARS_HINT, (charOrInt) => {\n                        const charCode = typeof charOrInt === \"string\"\n                            ? charOrInt.charCodeAt(0)\n                            : charOrInt;\n                        const currOptimizedIdx = charCodeToOptimizedIndex(charCode);\n                        // Avoid adding the config multiple times\n                        /* istanbul ignore else */\n                        // - Difficult to check this scenario effects as it is only a performance\n                        //   optimization that does not change correctness\n                        if (lastOptimizedIdx !== currOptimizedIdx) {\n                            lastOptimizedIdx = currOptimizedIdx;\n                            addToMapOfArrays(result, currOptimizedIdx, patternIdxToConfig[idx]);\n                        }\n                    });\n                }\n                else if (isRegExp(currTokType.PATTERN)) {\n                    if (currTokType.PATTERN.unicode) {\n                        canBeOptimized = false;\n                        if (options.ensureOptimizations) {\n                            PRINT_ERROR(`${failedOptimizationPrefixMsg}` +\n                                `\\tUnable to analyze < ${currTokType.PATTERN.toString()} > pattern.\\n` +\n                                \"\\tThe regexp unicode flag is not currently supported by the regexp-to-ast library.\\n\" +\n                                \"\\tThis will disable the lexer's first char optimizations.\\n\" +\n                                \"\\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#UNICODE_OPTIMIZE\");\n                        }\n                    }\n                    else {\n                        const optimizedCodes = getOptimizedStartCodesIndices(currTokType.PATTERN, options.ensureOptimizations);\n                        /* istanbul ignore if */\n                        // start code will only be empty given an empty regExp or failure of regexp-to-ast library\n                        // the first should be a different validation and the second cannot be tested.\n                        if (isEmpty(optimizedCodes)) {\n                            // we cannot understand what codes may start possible matches\n                            // The optimization correctness requires knowing start codes for ALL patterns.\n                            // Not actually sure this is an error, no debug message\n                            canBeOptimized = false;\n                        }\n                        forEach(optimizedCodes, (code) => {\n                            addToMapOfArrays(result, code, patternIdxToConfig[idx]);\n                        });\n                    }\n                }\n                else {\n                    if (options.ensureOptimizations) {\n                        PRINT_ERROR(`${failedOptimizationPrefixMsg}` +\n                            `\\tTokenType: <${currTokType.name}> is using a custom token pattern without providing <start_chars_hint> parameter.\\n` +\n                            \"\\tThis will disable the lexer's first char optimizations.\\n\" +\n                            \"\\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#CUSTOM_OPTIMIZE\");\n                    }\n                    canBeOptimized = false;\n                }\n                return result;\n            }, []);\n        });\n    }\n    return {\n        emptyGroups: emptyGroups,\n        patternIdxToConfig: patternIdxToConfig,\n        charCodeToPatternIdxToConfig: charCodeToPatternIdxToConfig,\n        hasCustom: hasCustom,\n        canBeOptimized: canBeOptimized,\n    };\n}\nexport function validatePatterns(tokenTypes, validModesNames) {\n    let errors = [];\n    const missingResult = findMissingPatterns(tokenTypes);\n    errors = errors.concat(missingResult.errors);\n    const invalidResult = findInvalidPatterns(missingResult.valid);\n    const validTokenTypes = invalidResult.valid;\n    errors = errors.concat(invalidResult.errors);\n    errors = errors.concat(validateRegExpPattern(validTokenTypes));\n    errors = errors.concat(findInvalidGroupType(validTokenTypes));\n    errors = errors.concat(findModesThatDoNotExist(validTokenTypes, validModesNames));\n    errors = errors.concat(findUnreachablePatterns(validTokenTypes));\n    return errors;\n}\nfunction validateRegExpPattern(tokenTypes) {\n    let errors = [];\n    const withRegExpPatterns = filter(tokenTypes, (currTokType) => isRegExp(currTokType[PATTERN]));\n    errors = errors.concat(findEndOfInputAnchor(withRegExpPatterns));\n    errors = errors.concat(findStartOfInputAnchor(withRegExpPatterns));\n    errors = errors.concat(findUnsupportedFlags(withRegExpPatterns));\n    errors = errors.concat(findDuplicatePatterns(withRegExpPatterns));\n    errors = errors.concat(findEmptyMatchRegExps(withRegExpPatterns));\n    return errors;\n}\nexport function findMissingPatterns(tokenTypes) {\n    const tokenTypesWithMissingPattern = filter(tokenTypes, (currType) => {\n        return !has(currType, PATTERN);\n    });\n    const errors = map(tokenTypesWithMissingPattern, (currType) => {\n        return {\n            message: \"Token Type: ->\" +\n                currType.name +\n                \"<- missing static 'PATTERN' property\",\n            type: LexerDefinitionErrorType.MISSING_PATTERN,\n            tokenTypes: [currType],\n        };\n    });\n    const valid = difference(tokenTypes, tokenTypesWithMissingPattern);\n    return { errors, valid };\n}\nexport function findInvalidPatterns(tokenTypes) {\n    const tokenTypesWithInvalidPattern = filter(tokenTypes, (currType) => {\n        const pattern = currType[PATTERN];\n        return (!isRegExp(pattern) &&\n            !isFunction(pattern) &&\n            !has(pattern, \"exec\") &&\n            !isString(pattern));\n    });\n    const errors = map(tokenTypesWithInvalidPattern, (currType) => {\n        return {\n            message: \"Token Type: ->\" +\n                currType.name +\n                \"<- static 'PATTERN' can only be a RegExp, a\" +\n                \" Function matching the {CustomPatternMatcherFunc} type or an Object matching the {ICustomPattern} interface.\",\n            type: LexerDefinitionErrorType.INVALID_PATTERN,\n            tokenTypes: [currType],\n        };\n    });\n    const valid = difference(tokenTypes, tokenTypesWithInvalidPattern);\n    return { errors, valid };\n}\nconst end_of_input = /[^\\\\][$]/;\nexport function findEndOfInputAnchor(tokenTypes) {\n    class EndAnchorFinder extends BaseRegExpVisitor {\n        constructor() {\n            super(...arguments);\n            this.found = false;\n        }\n        visitEndAnchor(node) {\n            this.found = true;\n        }\n    }\n    const invalidRegex = filter(tokenTypes, (currType) => {\n        const pattern = currType.PATTERN;\n        try {\n            const regexpAst = getRegExpAst(pattern);\n            const endAnchorVisitor = new EndAnchorFinder();\n            endAnchorVisitor.visit(regexpAst);\n            return endAnchorVisitor.found;\n        }\n        catch (e) {\n            // old behavior in case of runtime exceptions with regexp-to-ast.\n            /* istanbul ignore next - cannot ensure an error in regexp-to-ast*/\n            return end_of_input.test(pattern.source);\n        }\n    });\n    const errors = map(invalidRegex, (currType) => {\n        return {\n            message: \"Unexpected RegExp Anchor Error:\\n\" +\n                \"\\tToken Type: ->\" +\n                currType.name +\n                \"<- static 'PATTERN' cannot contain end of input anchor '$'\\n\" +\n                \"\\tSee chevrotain.io/docs/guide/resolving_lexer_errors.html#ANCHORS\" +\n                \"\\tfor details.\",\n            type: LexerDefinitionErrorType.EOI_ANCHOR_FOUND,\n            tokenTypes: [currType],\n        };\n    });\n    return errors;\n}\nexport function findEmptyMatchRegExps(tokenTypes) {\n    const matchesEmptyString = filter(tokenTypes, (currType) => {\n        const pattern = currType.PATTERN;\n        return pattern.test(\"\");\n    });\n    const errors = map(matchesEmptyString, (currType) => {\n        return {\n            message: \"Token Type: ->\" +\n                currType.name +\n                \"<- static 'PATTERN' must not match an empty string\",\n            type: LexerDefinitionErrorType.EMPTY_MATCH_PATTERN,\n            tokenTypes: [currType],\n        };\n    });\n    return errors;\n}\nconst start_of_input = /[^\\\\[][\\^]|^\\^/;\nexport function findStartOfInputAnchor(tokenTypes) {\n    class StartAnchorFinder extends BaseRegExpVisitor {\n        constructor() {\n            super(...arguments);\n            this.found = false;\n        }\n        visitStartAnchor(node) {\n            this.found = true;\n        }\n    }\n    const invalidRegex = filter(tokenTypes, (currType) => {\n        const pattern = currType.PATTERN;\n        try {\n            const regexpAst = getRegExpAst(pattern);\n            const startAnchorVisitor = new StartAnchorFinder();\n            startAnchorVisitor.visit(regexpAst);\n            return startAnchorVisitor.found;\n        }\n        catch (e) {\n            // old behavior in case of runtime exceptions with regexp-to-ast.\n            /* istanbul ignore next - cannot ensure an error in regexp-to-ast*/\n            return start_of_input.test(pattern.source);\n        }\n    });\n    const errors = map(invalidRegex, (currType) => {\n        return {\n            message: \"Unexpected RegExp Anchor Error:\\n\" +\n                \"\\tToken Type: ->\" +\n                currType.name +\n                \"<- static 'PATTERN' cannot contain start of input anchor '^'\\n\" +\n                \"\\tSee https://chevrotain.io/docs/guide/resolving_lexer_errors.html#ANCHORS\" +\n                \"\\tfor details.\",\n            type: LexerDefinitionErrorType.SOI_ANCHOR_FOUND,\n            tokenTypes: [currType],\n        };\n    });\n    return errors;\n}\nexport function findUnsupportedFlags(tokenTypes) {\n    const invalidFlags = filter(tokenTypes, (currType) => {\n        const pattern = currType[PATTERN];\n        return pattern instanceof RegExp && (pattern.multiline || pattern.global);\n    });\n    const errors = map(invalidFlags, (currType) => {\n        return {\n            message: \"Token Type: ->\" +\n                currType.name +\n                \"<- static 'PATTERN' may NOT contain global('g') or multiline('m')\",\n            type: LexerDefinitionErrorType.UNSUPPORTED_FLAGS_FOUND,\n            tokenTypes: [currType],\n        };\n    });\n    return errors;\n}\n// This can only test for identical duplicate RegExps, not semantically equivalent ones.\nexport function findDuplicatePatterns(tokenTypes) {\n    const found = [];\n    let identicalPatterns = map(tokenTypes, (outerType) => {\n        return reduce(tokenTypes, (result, innerType) => {\n            if (outerType.PATTERN.source === innerType.PATTERN.source &&\n                !includes(found, innerType) &&\n                innerType.PATTERN !== Lexer.NA) {\n                // this avoids duplicates in the result, each Token Type may only appear in one \"set\"\n                // in essence we are creating Equivalence classes on equality relation.\n                found.push(innerType);\n                result.push(innerType);\n                return result;\n            }\n            return result;\n        }, []);\n    });\n    identicalPatterns = compact(identicalPatterns);\n    const duplicatePatterns = filter(identicalPatterns, (currIdenticalSet) => {\n        return currIdenticalSet.length > 1;\n    });\n    const errors = map(duplicatePatterns, (setOfIdentical) => {\n        const tokenTypeNames = map(setOfIdentical, (currType) => {\n            return currType.name;\n        });\n        const dupPatternSrc = first(setOfIdentical).PATTERN;\n        return {\n            message: `The same RegExp pattern ->${dupPatternSrc}<-` +\n                `has been used in all of the following Token Types: ${tokenTypeNames.join(\", \")} <-`,\n            type: LexerDefinitionErrorType.DUPLICATE_PATTERNS_FOUND,\n            tokenTypes: setOfIdentical,\n        };\n    });\n    return errors;\n}\nexport function findInvalidGroupType(tokenTypes) {\n    const invalidTypes = filter(tokenTypes, (clazz) => {\n        if (!has(clazz, \"GROUP\")) {\n            return false;\n        }\n        const group = clazz.GROUP;\n        return group !== Lexer.SKIPPED && group !== Lexer.NA && !isString(group);\n    });\n    const errors = map(invalidTypes, (currType) => {\n        return {\n            message: \"Token Type: ->\" +\n                currType.name +\n                \"<- static 'GROUP' can only be Lexer.SKIPPED/Lexer.NA/A String\",\n            type: LexerDefinitionErrorType.INVALID_GROUP_TYPE_FOUND,\n            tokenTypes: [currType],\n        };\n    });\n    return errors;\n}\nexport function findModesThatDoNotExist(tokenTypes, validModes) {\n    const invalidModes = filter(tokenTypes, (clazz) => {\n        return (clazz.PUSH_MODE !== undefined && !includes(validModes, clazz.PUSH_MODE));\n    });\n    const errors = map(invalidModes, (tokType) => {\n        const msg = `Token Type: ->${tokType.name}<- static 'PUSH_MODE' value cannot refer to a Lexer Mode ->${tokType.PUSH_MODE}<-` +\n            `which does not exist`;\n        return {\n            message: msg,\n            type: LexerDefinitionErrorType.PUSH_MODE_DOES_NOT_EXIST,\n            tokenTypes: [tokType],\n        };\n    });\n    return errors;\n}\nexport function findUnreachablePatterns(tokenTypes) {\n    const errors = [];\n    const canBeTested = reduce(tokenTypes, (result, tokType, idx) => {\n        const pattern = tokType.PATTERN;\n        if (pattern === Lexer.NA) {\n            return result;\n        }\n        // a more comprehensive validation for all forms of regExps would require\n        // deeper regExp analysis capabilities\n        if (isString(pattern)) {\n            result.push({ str: pattern, idx, tokenType: tokType });\n        }\n        else if (isRegExp(pattern) && noMetaChar(pattern)) {\n            result.push({ str: pattern.source, idx, tokenType: tokType });\n        }\n        return result;\n    }, []);\n    forEach(tokenTypes, (tokType, testIdx) => {\n        forEach(canBeTested, ({ str, idx, tokenType }) => {\n            if (testIdx < idx && testTokenType(str, tokType.PATTERN)) {\n                const msg = `Token: ->${tokenType.name}<- can never be matched.\\n` +\n                    `Because it appears AFTER the Token Type ->${tokType.name}<-` +\n                    `in the lexer's definition.\\n` +\n                    `See https://chevrotain.io/docs/guide/resolving_lexer_errors.html#UNREACHABLE`;\n                errors.push({\n                    message: msg,\n                    type: LexerDefinitionErrorType.UNREACHABLE_PATTERN,\n                    tokenTypes: [tokType, tokenType],\n                });\n            }\n        });\n    });\n    return errors;\n}\nfunction testTokenType(str, pattern) {\n    /* istanbul ignore else */\n    if (isRegExp(pattern)) {\n        const regExpArray = pattern.exec(str);\n        return regExpArray !== null && regExpArray.index === 0;\n    }\n    else if (isFunction(pattern)) {\n        // maintain the API of custom patterns\n        return pattern(str, 0, [], {});\n    }\n    else if (has(pattern, \"exec\")) {\n        // maintain the API of custom patterns\n        return pattern.exec(str, 0, [], {});\n    }\n    else if (typeof pattern === \"string\") {\n        return pattern === str;\n    }\n    else {\n        throw Error(\"non exhaustive match\");\n    }\n}\nfunction noMetaChar(regExp) {\n    //https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp\n    const metaChars = [\n        \".\",\n        \"\\\\\",\n        \"[\",\n        \"]\",\n        \"|\",\n        \"^\",\n        \"$\",\n        \"(\",\n        \")\",\n        \"?\",\n        \"*\",\n        \"+\",\n        \"{\",\n    ];\n    return (find(metaChars, (char) => regExp.source.indexOf(char) !== -1) === undefined);\n}\nexport function addStartOfInput(pattern) {\n    const flags = pattern.ignoreCase ? \"i\" : \"\";\n    // always wrapping in a none capturing group preceded by '^' to make sure matching can only work on start of input.\n    // duplicate/redundant start of input markers have no meaning (/^^^^A/ === /^A/)\n    return new RegExp(`^(?:${pattern.source})`, flags);\n}\nexport function addStickyFlag(pattern) {\n    const flags = pattern.ignoreCase ? \"iy\" : \"y\";\n    // always wrapping in a none capturing group preceded by '^' to make sure matching can only work on start of input.\n    // duplicate/redundant start of input markers have no meaning (/^^^^A/ === /^A/)\n    return new RegExp(`${pattern.source}`, flags);\n}\nexport function performRuntimeChecks(lexerDefinition, trackLines, lineTerminatorCharacters) {\n    const errors = [];\n    // some run time checks to help the end users.\n    if (!has(lexerDefinition, DEFAULT_MODE)) {\n        errors.push({\n            message: \"A MultiMode Lexer cannot be initialized without a <\" +\n                DEFAULT_MODE +\n                \"> property in its definition\\n\",\n            type: LexerDefinitionErrorType.MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE,\n        });\n    }\n    if (!has(lexerDefinition, MODES)) {\n        errors.push({\n            message: \"A MultiMode Lexer cannot be initialized without a <\" +\n                MODES +\n                \"> property in its definition\\n\",\n            type: LexerDefinitionErrorType.MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY,\n        });\n    }\n    if (has(lexerDefinition, MODES) &&\n        has(lexerDefinition, DEFAULT_MODE) &&\n        !has(lexerDefinition.modes, lexerDefinition.defaultMode)) {\n        errors.push({\n            message: `A MultiMode Lexer cannot be initialized with a ${DEFAULT_MODE}: <${lexerDefinition.defaultMode}>` +\n                `which does not exist\\n`,\n            type: LexerDefinitionErrorType.MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST,\n        });\n    }\n    if (has(lexerDefinition, MODES)) {\n        forEach(lexerDefinition.modes, (currModeValue, currModeName) => {\n            forEach(currModeValue, (currTokType, currIdx) => {\n                if (isUndefined(currTokType)) {\n                    errors.push({\n                        message: `A Lexer cannot be initialized using an undefined Token Type. Mode:` +\n                            `<${currModeName}> at index: <${currIdx}>\\n`,\n                        type: LexerDefinitionErrorType.LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED,\n                    });\n                }\n                else if (has(currTokType, \"LONGER_ALT\")) {\n                    const longerAlt = isArray(currTokType.LONGER_ALT)\n                        ? currTokType.LONGER_ALT\n                        : [currTokType.LONGER_ALT];\n                    forEach(longerAlt, (currLongerAlt) => {\n                        if (!isUndefined(currLongerAlt) &&\n                            !includes(currModeValue, currLongerAlt)) {\n                            errors.push({\n                                message: `A MultiMode Lexer cannot be initialized with a longer_alt <${currLongerAlt.name}> on token <${currTokType.name}> outside of mode <${currModeName}>\\n`,\n                                type: LexerDefinitionErrorType.MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE,\n                            });\n                        }\n                    });\n                }\n            });\n        });\n    }\n    return errors;\n}\nexport function performWarningRuntimeChecks(lexerDefinition, trackLines, lineTerminatorCharacters) {\n    const warnings = [];\n    let hasAnyLineBreak = false;\n    const allTokenTypes = compact(flatten(values(lexerDefinition.modes)));\n    const concreteTokenTypes = reject(allTokenTypes, (currType) => currType[PATTERN] === Lexer.NA);\n    const terminatorCharCodes = getCharCodes(lineTerminatorCharacters);\n    if (trackLines) {\n        forEach(concreteTokenTypes, (tokType) => {\n            const currIssue = checkLineBreaksIssues(tokType, terminatorCharCodes);\n            if (currIssue !== false) {\n                const message = buildLineBreakIssueMessage(tokType, currIssue);\n                const warningDescriptor = {\n                    message,\n                    type: currIssue.issue,\n                    tokenType: tokType,\n                };\n                warnings.push(warningDescriptor);\n            }\n            else {\n                // we don't want to attempt to scan if the user explicitly specified the line_breaks option.\n                if (has(tokType, \"LINE_BREAKS\")) {\n                    if (tokType.LINE_BREAKS === true) {\n                        hasAnyLineBreak = true;\n                    }\n                }\n                else {\n                    if (canMatchCharCode(terminatorCharCodes, tokType.PATTERN)) {\n                        hasAnyLineBreak = true;\n                    }\n                }\n            }\n        });\n    }\n    if (trackLines && !hasAnyLineBreak) {\n        warnings.push({\n            message: \"Warning: No LINE_BREAKS Found.\\n\" +\n                \"\\tThis Lexer has been defined to track line and column information,\\n\" +\n                \"\\tBut none of the Token Types can be identified as matching a line terminator.\\n\" +\n                \"\\tSee https://chevrotain.io/docs/guide/resolving_lexer_errors.html#LINE_BREAKS \\n\" +\n                \"\\tfor details.\",\n            type: LexerDefinitionErrorType.NO_LINE_BREAKS_FLAGS,\n        });\n    }\n    return warnings;\n}\nexport function cloneEmptyGroups(emptyGroups) {\n    const clonedResult = {};\n    const groupKeys = keys(emptyGroups);\n    forEach(groupKeys, (currKey) => {\n        const currGroupValue = emptyGroups[currKey];\n        /* istanbul ignore else */\n        if (isArray(currGroupValue)) {\n            clonedResult[currKey] = [];\n        }\n        else {\n            throw Error(\"non exhaustive match\");\n        }\n    });\n    return clonedResult;\n}\n// TODO: refactor to avoid duplication\nexport function isCustomPattern(tokenType) {\n    const pattern = tokenType.PATTERN;\n    /* istanbul ignore else */\n    if (isRegExp(pattern)) {\n        return false;\n    }\n    else if (isFunction(pattern)) {\n        // CustomPatternMatcherFunc - custom patterns do not require any transformations, only wrapping in a RegExp Like object\n        return true;\n    }\n    else if (has(pattern, \"exec\")) {\n        // ICustomPattern\n        return true;\n    }\n    else if (isString(pattern)) {\n        return false;\n    }\n    else {\n        throw Error(\"non exhaustive match\");\n    }\n}\nexport function isShortPattern(pattern) {\n    if (isString(pattern) && pattern.length === 1) {\n        return pattern.charCodeAt(0);\n    }\n    else {\n        return false;\n    }\n}\n/**\n * Faster than using a RegExp for default newline detection during lexing.\n */\nexport const LineTerminatorOptimizedTester = {\n    // implements /\\n|\\r\\n?/g.test\n    test: function (text) {\n        const len = text.length;\n        for (let i = this.lastIndex; i < len; i++) {\n            const c = text.charCodeAt(i);\n            if (c === 10) {\n                this.lastIndex = i + 1;\n                return true;\n            }\n            else if (c === 13) {\n                if (text.charCodeAt(i + 1) === 10) {\n                    this.lastIndex = i + 2;\n                }\n                else {\n                    this.lastIndex = i + 1;\n                }\n                return true;\n            }\n        }\n        return false;\n    },\n    lastIndex: 0,\n};\nfunction checkLineBreaksIssues(tokType, lineTerminatorCharCodes) {\n    if (has(tokType, \"LINE_BREAKS\")) {\n        // if the user explicitly declared the line_breaks option we will respect their choice\n        // and assume it is correct.\n        return false;\n    }\n    else {\n        /* istanbul ignore else */\n        if (isRegExp(tokType.PATTERN)) {\n            try {\n                // TODO: why is the casting suddenly needed?\n                canMatchCharCode(lineTerminatorCharCodes, tokType.PATTERN);\n            }\n            catch (e) {\n                /* istanbul ignore next - to test this we would have to mock <canMatchCharCode> to throw an error */\n                return {\n                    issue: LexerDefinitionErrorType.IDENTIFY_TERMINATOR,\n                    errMsg: e.message,\n                };\n            }\n            return false;\n        }\n        else if (isString(tokType.PATTERN)) {\n            // string literal patterns can always be analyzed to detect line terminator usage\n            return false;\n        }\n        else if (isCustomPattern(tokType)) {\n            // custom token types\n            return { issue: LexerDefinitionErrorType.CUSTOM_LINE_BREAK };\n        }\n        else {\n            throw Error(\"non exhaustive match\");\n        }\n    }\n}\nexport function buildLineBreakIssueMessage(tokType, details) {\n    /* istanbul ignore else */\n    if (details.issue === LexerDefinitionErrorType.IDENTIFY_TERMINATOR) {\n        return (\"Warning: unable to identify line terminator usage in pattern.\\n\" +\n            `\\tThe problem is in the <${tokType.name}> Token Type\\n` +\n            `\\t Root cause: ${details.errMsg}.\\n` +\n            \"\\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#IDENTIFY_TERMINATOR\");\n    }\n    else if (details.issue === LexerDefinitionErrorType.CUSTOM_LINE_BREAK) {\n        return (\"Warning: A Custom Token Pattern should specify the <line_breaks> option.\\n\" +\n            `\\tThe problem is in the <${tokType.name}> Token Type\\n` +\n            \"\\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#CUSTOM_LINE_BREAK\");\n    }\n    else {\n        throw Error(\"non exhaustive match\");\n    }\n}\nfunction getCharCodes(charsOrCodes) {\n    const charCodes = map(charsOrCodes, (numOrString) => {\n        if (isString(numOrString)) {\n            return numOrString.charCodeAt(0);\n        }\n        else {\n            return numOrString;\n        }\n    });\n    return charCodes;\n}\nfunction addToMapOfArrays(map, key, value) {\n    if (map[key] === undefined) {\n        map[key] = [value];\n    }\n    else {\n        map[key].push(value);\n    }\n}\nexport const minOptimizationVal = 256;\n/**\n * We are mapping charCode above ASCI (256) into buckets each in the size of 256.\n * This is because ASCI are the most common start chars so each one of those will get its own\n * possible token configs vector.\n *\n * Tokens starting with charCodes \"above\" ASCI are uncommon, so we can \"afford\"\n * to place these into buckets of possible token configs, What we gain from\n * this is avoiding the case of creating an optimization 'charCodeToPatternIdxToConfig'\n * which would contain 10,000+ arrays of small size (e.g unicode Identifiers scenario).\n * Our 'charCodeToPatternIdxToConfig' max size will now be:\n * 256 + (2^16 / 2^8) - 1 === 511\n *\n * note the hack for fast division integer part extraction\n * See: https://stackoverflow.com/a/4228528\n */\nlet charCodeToOptimizedIdxMap = [];\nexport function charCodeToOptimizedIndex(charCode) {\n    return charCode < minOptimizationVal\n        ? charCode\n        : charCodeToOptimizedIdxMap[charCode];\n}\n/**\n * This is a compromise between cold start / hot running performance\n * Creating this array takes ~3ms on a modern machine,\n * But if we perform the computation at runtime as needed the CSS Lexer benchmark\n * performance degrades by ~10%\n *\n * TODO: Perhaps it should be lazy initialized only if a charCode > 255 is used.\n */\nfunction initCharCodeToOptimizedIndexMap() {\n    if (isEmpty(charCodeToOptimizedIdxMap)) {\n        charCodeToOptimizedIdxMap = new Array(65536);\n        for (let i = 0; i < 65536; i++) {\n            charCodeToOptimizedIdxMap[i] = i > 255 ? 255 + ~~(i / 255) : i;\n        }\n    }\n}\n//# sourceMappingURL=lexer.js.map","export function timer(func) {\n    const start = new Date().getTime();\n    const val = func();\n    const end = new Date().getTime();\n    const total = end - start;\n    return { time: total, value: val };\n}\n//# sourceMappingURL=timer.js.map","import { clone, compact, difference, flatten, forEach, has, includes, isArray, isEmpty, map, } from \"lodash-es\";\nexport function tokenStructuredMatcher(tokInstance, tokConstructor) {\n    const instanceType = tokInstance.tokenTypeIdx;\n    if (instanceType === tokConstructor.tokenTypeIdx) {\n        return true;\n    }\n    else {\n        return (tokConstructor.isParent === true &&\n            tokConstructor.categoryMatchesMap[instanceType] === true);\n    }\n}\n// Optimized tokenMatcher in case our grammar does not use token categories\n// Being so tiny it is much more likely to be in-lined and this avoid the function call overhead\nexport function tokenStructuredMatcherNoCategories(token, tokType) {\n    return token.tokenTypeIdx === tokType.tokenTypeIdx;\n}\nexport let tokenShortNameIdx = 1;\nexport const tokenIdxToClass = {};\nexport function augmentTokenTypes(tokenTypes) {\n    // collect the parent Token Types as well.\n    const tokenTypesAndParents = expandCategories(tokenTypes);\n    // add required tokenType and categoryMatches properties\n    assignTokenDefaultProps(tokenTypesAndParents);\n    // fill up the categoryMatches\n    assignCategoriesMapProp(tokenTypesAndParents);\n    assignCategoriesTokensProp(tokenTypesAndParents);\n    forEach(tokenTypesAndParents, (tokType) => {\n        tokType.isParent = tokType.categoryMatches.length > 0;\n    });\n}\nexport function expandCategories(tokenTypes) {\n    let result = clone(tokenTypes);\n    let categories = tokenTypes;\n    let searching = true;\n    while (searching) {\n        categories = compact(flatten(map(categories, (currTokType) => currTokType.CATEGORIES)));\n        const newCategories = difference(categories, result);\n        result = result.concat(newCategories);\n        if (isEmpty(newCategories)) {\n            searching = false;\n        }\n        else {\n            categories = newCategories;\n        }\n    }\n    return result;\n}\nexport function assignTokenDefaultProps(tokenTypes) {\n    forEach(tokenTypes, (currTokType) => {\n        if (!hasShortKeyProperty(currTokType)) {\n            tokenIdxToClass[tokenShortNameIdx] = currTokType;\n            currTokType.tokenTypeIdx = tokenShortNameIdx++;\n        }\n        // CATEGORIES? : TokenType | TokenType[]\n        if (hasCategoriesProperty(currTokType) &&\n            !isArray(currTokType.CATEGORIES)\n        // &&\n        // !isUndefined(currTokType.CATEGORIES.PATTERN)\n        ) {\n            currTokType.CATEGORIES = [currTokType.CATEGORIES];\n        }\n        if (!hasCategoriesProperty(currTokType)) {\n            currTokType.CATEGORIES = [];\n        }\n        if (!hasExtendingTokensTypesProperty(currTokType)) {\n            currTokType.categoryMatches = [];\n        }\n        if (!hasExtendingTokensTypesMapProperty(currTokType)) {\n            currTokType.categoryMatchesMap = {};\n        }\n    });\n}\nexport function assignCategoriesTokensProp(tokenTypes) {\n    forEach(tokenTypes, (currTokType) => {\n        // avoid duplications\n        currTokType.categoryMatches = [];\n        forEach(currTokType.categoryMatchesMap, (val, key) => {\n            currTokType.categoryMatches.push(tokenIdxToClass[key].tokenTypeIdx);\n        });\n    });\n}\nexport function assignCategoriesMapProp(tokenTypes) {\n    forEach(tokenTypes, (currTokType) => {\n        singleAssignCategoriesToksMap([], currTokType);\n    });\n}\nexport function singleAssignCategoriesToksMap(path, nextNode) {\n    forEach(path, (pathNode) => {\n        nextNode.categoryMatchesMap[pathNode.tokenTypeIdx] = true;\n    });\n    forEach(nextNode.CATEGORIES, (nextCategory) => {\n        const newPath = path.concat(nextNode);\n        // avoids infinite loops due to cyclic categories.\n        if (!includes(newPath, nextCategory)) {\n            singleAssignCategoriesToksMap(newPath, nextCategory);\n        }\n    });\n}\nexport function hasShortKeyProperty(tokType) {\n    return has(tokType, \"tokenTypeIdx\");\n}\nexport function hasCategoriesProperty(tokType) {\n    return has(tokType, \"CATEGORIES\");\n}\nexport function hasExtendingTokensTypesProperty(tokType) {\n    return has(tokType, \"categoryMatches\");\n}\nexport function hasExtendingTokensTypesMapProperty(tokType) {\n    return has(tokType, \"categoryMatchesMap\");\n}\nexport function isTokenType(tokType) {\n    return has(tokType, \"tokenTypeIdx\");\n}\n//# sourceMappingURL=tokens.js.map","import { analyzeTokenTypes, charCodeToOptimizedIndex, cloneEmptyGroups, DEFAULT_MODE, LineTerminatorOptimizedTester, performRuntimeChecks, performWarningRuntimeChecks, SUPPORT_STICKY, validatePatterns, } from \"./lexer.js\";\nimport { assign, clone, forEach, identity, isArray, isEmpty, isUndefined, keys, last, map, noop, reduce, reject, } from \"lodash-es\";\nimport { PRINT_WARNING, timer, toFastProperties } from \"@chevrotain/utils\";\nimport { augmentTokenTypes } from \"./tokens.js\";\nimport { defaultLexerErrorProvider } from \"./lexer_errors_public.js\";\nimport { clearRegExpParserCache } from \"./reg_exp_parser.js\";\nexport var LexerDefinitionErrorType;\n(function (LexerDefinitionErrorType) {\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"MISSING_PATTERN\"] = 0] = \"MISSING_PATTERN\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"INVALID_PATTERN\"] = 1] = \"INVALID_PATTERN\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"EOI_ANCHOR_FOUND\"] = 2] = \"EOI_ANCHOR_FOUND\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"UNSUPPORTED_FLAGS_FOUND\"] = 3] = \"UNSUPPORTED_FLAGS_FOUND\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"DUPLICATE_PATTERNS_FOUND\"] = 4] = \"DUPLICATE_PATTERNS_FOUND\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"INVALID_GROUP_TYPE_FOUND\"] = 5] = \"INVALID_GROUP_TYPE_FOUND\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"PUSH_MODE_DOES_NOT_EXIST\"] = 6] = \"PUSH_MODE_DOES_NOT_EXIST\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE\"] = 7] = \"MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY\"] = 8] = \"MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST\"] = 9] = \"MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED\"] = 10] = \"LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"SOI_ANCHOR_FOUND\"] = 11] = \"SOI_ANCHOR_FOUND\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"EMPTY_MATCH_PATTERN\"] = 12] = \"EMPTY_MATCH_PATTERN\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"NO_LINE_BREAKS_FLAGS\"] = 13] = \"NO_LINE_BREAKS_FLAGS\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"UNREACHABLE_PATTERN\"] = 14] = \"UNREACHABLE_PATTERN\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"IDENTIFY_TERMINATOR\"] = 15] = \"IDENTIFY_TERMINATOR\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"CUSTOM_LINE_BREAK\"] = 16] = \"CUSTOM_LINE_BREAK\";\n    LexerDefinitionErrorType[LexerDefinitionErrorType[\"MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE\"] = 17] = \"MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE\";\n})(LexerDefinitionErrorType || (LexerDefinitionErrorType = {}));\nconst DEFAULT_LEXER_CONFIG = {\n    deferDefinitionErrorsHandling: false,\n    positionTracking: \"full\",\n    lineTerminatorsPattern: /\\n|\\r\\n?/g,\n    lineTerminatorCharacters: [\"\\n\", \"\\r\"],\n    ensureOptimizations: false,\n    safeMode: false,\n    errorMessageProvider: defaultLexerErrorProvider,\n    traceInitPerf: false,\n    skipValidations: false,\n    recoveryEnabled: true,\n};\nObject.freeze(DEFAULT_LEXER_CONFIG);\nexport class Lexer {\n    constructor(lexerDefinition, config = DEFAULT_LEXER_CONFIG) {\n        this.lexerDefinition = lexerDefinition;\n        this.lexerDefinitionErrors = [];\n        this.lexerDefinitionWarning = [];\n        this.patternIdxToConfig = {};\n        this.charCodeToPatternIdxToConfig = {};\n        this.modes = [];\n        this.emptyGroups = {};\n        this.trackStartLines = true;\n        this.trackEndLines = true;\n        this.hasCustom = false;\n        this.canModeBeOptimized = {};\n        // Duplicated from the parser's perf trace trait to allow future extraction\n        // of the lexer to a separate package.\n        this.TRACE_INIT = (phaseDesc, phaseImpl) => {\n            // No need to optimize this using NOOP pattern because\n            // It is not called in a hot spot...\n            if (this.traceInitPerf === true) {\n                this.traceInitIndent++;\n                const indent = new Array(this.traceInitIndent + 1).join(\"\\t\");\n                if (this.traceInitIndent < this.traceInitMaxIdent) {\n                    console.log(`${indent}--> <${phaseDesc}>`);\n                }\n                const { time, value } = timer(phaseImpl);\n                /* istanbul ignore next - Difficult to reproduce specific performance behavior (>10ms) in tests */\n                const traceMethod = time > 10 ? console.warn : console.log;\n                if (this.traceInitIndent < this.traceInitMaxIdent) {\n                    traceMethod(`${indent}<-- <${phaseDesc}> time: ${time}ms`);\n                }\n                this.traceInitIndent--;\n                return value;\n            }\n            else {\n                return phaseImpl();\n            }\n        };\n        if (typeof config === \"boolean\") {\n            throw Error(\"The second argument to the Lexer constructor is now an ILexerConfig Object.\\n\" +\n                \"a boolean 2nd argument is no longer supported\");\n        }\n        // todo: defaults func?\n        this.config = assign({}, DEFAULT_LEXER_CONFIG, config);\n        const traceInitVal = this.config.traceInitPerf;\n        if (traceInitVal === true) {\n            this.traceInitMaxIdent = Infinity;\n            this.traceInitPerf = true;\n        }\n        else if (typeof traceInitVal === \"number\") {\n            this.traceInitMaxIdent = traceInitVal;\n            this.traceInitPerf = true;\n        }\n        this.traceInitIndent = -1;\n        this.TRACE_INIT(\"Lexer Constructor\", () => {\n            let actualDefinition;\n            let hasOnlySingleMode = true;\n            this.TRACE_INIT(\"Lexer Config handling\", () => {\n                if (this.config.lineTerminatorsPattern ===\n                    DEFAULT_LEXER_CONFIG.lineTerminatorsPattern) {\n                    // optimized built-in implementation for the defaults definition of lineTerminators\n                    this.config.lineTerminatorsPattern = LineTerminatorOptimizedTester;\n                }\n                else {\n                    if (this.config.lineTerminatorCharacters ===\n                        DEFAULT_LEXER_CONFIG.lineTerminatorCharacters) {\n                        throw Error(\"Error: Missing <lineTerminatorCharacters> property on the Lexer config.\\n\" +\n                            \"\\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#MISSING_LINE_TERM_CHARS\");\n                    }\n                }\n                if (config.safeMode && config.ensureOptimizations) {\n                    throw Error('\"safeMode\" and \"ensureOptimizations\" flags are mutually exclusive.');\n                }\n                this.trackStartLines = /full|onlyStart/i.test(this.config.positionTracking);\n                this.trackEndLines = /full/i.test(this.config.positionTracking);\n                // Convert SingleModeLexerDefinition into a IMultiModeLexerDefinition.\n                if (isArray(lexerDefinition)) {\n                    actualDefinition = {\n                        modes: { defaultMode: clone(lexerDefinition) },\n                        defaultMode: DEFAULT_MODE,\n                    };\n                }\n                else {\n                    // no conversion needed, input should already be a IMultiModeLexerDefinition\n                    hasOnlySingleMode = false;\n                    actualDefinition = clone(lexerDefinition);\n                }\n            });\n            if (this.config.skipValidations === false) {\n                this.TRACE_INIT(\"performRuntimeChecks\", () => {\n                    this.lexerDefinitionErrors = this.lexerDefinitionErrors.concat(performRuntimeChecks(actualDefinition, this.trackStartLines, this.config.lineTerminatorCharacters));\n                });\n                this.TRACE_INIT(\"performWarningRuntimeChecks\", () => {\n                    this.lexerDefinitionWarning = this.lexerDefinitionWarning.concat(performWarningRuntimeChecks(actualDefinition, this.trackStartLines, this.config.lineTerminatorCharacters));\n                });\n            }\n            // for extra robustness to avoid throwing an none informative error message\n            actualDefinition.modes = actualDefinition.modes\n                ? actualDefinition.modes\n                : {};\n            // an error of undefined TokenTypes will be detected in \"performRuntimeChecks\" above.\n            // this transformation is to increase robustness in the case of partially invalid lexer definition.\n            forEach(actualDefinition.modes, (currModeValue, currModeName) => {\n                actualDefinition.modes[currModeName] = reject(currModeValue, (currTokType) => isUndefined(currTokType));\n            });\n            const allModeNames = keys(actualDefinition.modes);\n            forEach(actualDefinition.modes, (currModDef, currModName) => {\n                this.TRACE_INIT(`Mode: <${currModName}> processing`, () => {\n                    this.modes.push(currModName);\n                    if (this.config.skipValidations === false) {\n                        this.TRACE_INIT(`validatePatterns`, () => {\n                            this.lexerDefinitionErrors = this.lexerDefinitionErrors.concat(validatePatterns(currModDef, allModeNames));\n                        });\n                    }\n                    // If definition errors were encountered, the analysis phase may fail unexpectedly/\n                    // Considering a lexer with definition errors may never be used, there is no point\n                    // to performing the analysis anyhow...\n                    if (isEmpty(this.lexerDefinitionErrors)) {\n                        augmentTokenTypes(currModDef);\n                        let currAnalyzeResult;\n                        this.TRACE_INIT(`analyzeTokenTypes`, () => {\n                            currAnalyzeResult = analyzeTokenTypes(currModDef, {\n                                lineTerminatorCharacters: this.config.lineTerminatorCharacters,\n                                positionTracking: config.positionTracking,\n                                ensureOptimizations: config.ensureOptimizations,\n                                safeMode: config.safeMode,\n                                tracer: this.TRACE_INIT,\n                            });\n                        });\n                        this.patternIdxToConfig[currModName] =\n                            currAnalyzeResult.patternIdxToConfig;\n                        this.charCodeToPatternIdxToConfig[currModName] =\n                            currAnalyzeResult.charCodeToPatternIdxToConfig;\n                        this.emptyGroups = assign({}, this.emptyGroups, currAnalyzeResult.emptyGroups);\n                        this.hasCustom = currAnalyzeResult.hasCustom || this.hasCustom;\n                        this.canModeBeOptimized[currModName] =\n                            currAnalyzeResult.canBeOptimized;\n                    }\n                });\n            });\n            this.defaultMode = actualDefinition.defaultMode;\n            if (!isEmpty(this.lexerDefinitionErrors) &&\n                !this.config.deferDefinitionErrorsHandling) {\n                const allErrMessages = map(this.lexerDefinitionErrors, (error) => {\n                    return error.message;\n                });\n                const allErrMessagesString = allErrMessages.join(\"-----------------------\\n\");\n                throw new Error(\"Errors detected in definition of Lexer:\\n\" + allErrMessagesString);\n            }\n            // Only print warning if there are no errors, This will avoid pl\n            forEach(this.lexerDefinitionWarning, (warningDescriptor) => {\n                PRINT_WARNING(warningDescriptor.message);\n            });\n            this.TRACE_INIT(\"Choosing sub-methods implementations\", () => {\n                // Choose the relevant internal implementations for this specific parser.\n                // These implementations should be in-lined by the JavaScript engine\n                // to provide optimal performance in each scenario.\n                if (SUPPORT_STICKY) {\n                    this.chopInput = identity;\n                    this.match = this.matchWithTest;\n                }\n                else {\n                    this.updateLastIndex = noop;\n                    this.match = this.matchWithExec;\n                }\n                if (hasOnlySingleMode) {\n                    this.handleModes = noop;\n                }\n                if (this.trackStartLines === false) {\n                    this.computeNewColumn = identity;\n                }\n                if (this.trackEndLines === false) {\n                    this.updateTokenEndLineColumnLocation = noop;\n                }\n                if (/full/i.test(this.config.positionTracking)) {\n                    this.createTokenInstance = this.createFullToken;\n                }\n                else if (/onlyStart/i.test(this.config.positionTracking)) {\n                    this.createTokenInstance = this.createStartOnlyToken;\n                }\n                else if (/onlyOffset/i.test(this.config.positionTracking)) {\n                    this.createTokenInstance = this.createOffsetOnlyToken;\n                }\n                else {\n                    throw Error(`Invalid <positionTracking> config option: \"${this.config.positionTracking}\"`);\n                }\n                if (this.hasCustom) {\n                    this.addToken = this.addTokenUsingPush;\n                    this.handlePayload = this.handlePayloadWithCustom;\n                }\n                else {\n                    this.addToken = this.addTokenUsingMemberAccess;\n                    this.handlePayload = this.handlePayloadNoCustom;\n                }\n            });\n            this.TRACE_INIT(\"Failed Optimization Warnings\", () => {\n                const unOptimizedModes = reduce(this.canModeBeOptimized, (cannotBeOptimized, canBeOptimized, modeName) => {\n                    if (canBeOptimized === false) {\n                        cannotBeOptimized.push(modeName);\n                    }\n                    return cannotBeOptimized;\n                }, []);\n                if (config.ensureOptimizations && !isEmpty(unOptimizedModes)) {\n                    throw Error(`Lexer Modes: < ${unOptimizedModes.join(\", \")} > cannot be optimized.\\n` +\n                        '\\t Disable the \"ensureOptimizations\" lexer config flag to silently ignore this and run the lexer in an un-optimized mode.\\n' +\n                        \"\\t Or inspect the console log for details on how to resolve these issues.\");\n                }\n            });\n            this.TRACE_INIT(\"clearRegExpParserCache\", () => {\n                clearRegExpParserCache();\n            });\n            this.TRACE_INIT(\"toFastProperties\", () => {\n                toFastProperties(this);\n            });\n        });\n    }\n    tokenize(text, initialMode = this.defaultMode) {\n        if (!isEmpty(this.lexerDefinitionErrors)) {\n            const allErrMessages = map(this.lexerDefinitionErrors, (error) => {\n                return error.message;\n            });\n            const allErrMessagesString = allErrMessages.join(\"-----------------------\\n\");\n            throw new Error(\"Unable to Tokenize because Errors detected in definition of Lexer:\\n\" +\n                allErrMessagesString);\n        }\n        return this.tokenizeInternal(text, initialMode);\n    }\n    // There is quite a bit of duplication between this and \"tokenizeInternalLazy\"\n    // This is intentional due to performance considerations.\n    // this method also used quite a bit of `!` none null assertions because it is too optimized\n    // for `tsc` to always understand it is \"safe\"\n    tokenizeInternal(text, initialMode) {\n        let i, j, k, matchAltImage, longerAlt, matchedImage, payload, altPayload, imageLength, group, tokType, newToken, errLength, droppedChar, msg, match;\n        const orgText = text;\n        const orgLength = orgText.length;\n        let offset = 0;\n        let matchedTokensIndex = 0;\n        // initializing the tokensArray to the \"guessed\" size.\n        // guessing too little will still reduce the number of array re-sizes on pushes.\n        // guessing too large (Tested by guessing x4 too large) may cost a bit more of memory\n        // but would still have a faster runtime by avoiding (All but one) array resizing.\n        const guessedNumberOfTokens = this.hasCustom\n            ? 0 // will break custom token pattern APIs the matchedTokens array will contain undefined elements.\n            : Math.floor(text.length / 10);\n        const matchedTokens = new Array(guessedNumberOfTokens);\n        const errors = [];\n        let line = this.trackStartLines ? 1 : undefined;\n        let column = this.trackStartLines ? 1 : undefined;\n        const groups = cloneEmptyGroups(this.emptyGroups);\n        const trackLines = this.trackStartLines;\n        const lineTerminatorPattern = this.config.lineTerminatorsPattern;\n        let currModePatternsLength = 0;\n        let patternIdxToConfig = [];\n        let currCharCodeToPatternIdxToConfig = [];\n        const modeStack = [];\n        const emptyArray = [];\n        Object.freeze(emptyArray);\n        let getPossiblePatterns;\n        function getPossiblePatternsSlow() {\n            return patternIdxToConfig;\n        }\n        function getPossiblePatternsOptimized(charCode) {\n            const optimizedCharIdx = charCodeToOptimizedIndex(charCode);\n            const possiblePatterns = currCharCodeToPatternIdxToConfig[optimizedCharIdx];\n            if (possiblePatterns === undefined) {\n                return emptyArray;\n            }\n            else {\n                return possiblePatterns;\n            }\n        }\n        const pop_mode = (popToken) => {\n            // TODO: perhaps avoid this error in the edge case there is no more input?\n            if (modeStack.length === 1 &&\n                // if we have both a POP_MODE and a PUSH_MODE this is in-fact a \"transition\"\n                // So no error should occur.\n                popToken.tokenType.PUSH_MODE === undefined) {\n                // if we try to pop the last mode there lexer will no longer have ANY mode.\n                // thus the pop is ignored, an error will be created and the lexer will continue parsing in the previous mode.\n                const msg = this.config.errorMessageProvider.buildUnableToPopLexerModeMessage(popToken);\n                errors.push({\n                    offset: popToken.startOffset,\n                    line: popToken.startLine,\n                    column: popToken.startColumn,\n                    length: popToken.image.length,\n                    message: msg,\n                });\n            }\n            else {\n                modeStack.pop();\n                const newMode = last(modeStack);\n                patternIdxToConfig = this.patternIdxToConfig[newMode];\n                currCharCodeToPatternIdxToConfig =\n                    this.charCodeToPatternIdxToConfig[newMode];\n                currModePatternsLength = patternIdxToConfig.length;\n                const modeCanBeOptimized = this.canModeBeOptimized[newMode] && this.config.safeMode === false;\n                if (currCharCodeToPatternIdxToConfig && modeCanBeOptimized) {\n                    getPossiblePatterns = getPossiblePatternsOptimized;\n                }\n                else {\n                    getPossiblePatterns = getPossiblePatternsSlow;\n                }\n            }\n        };\n        function push_mode(newMode) {\n            modeStack.push(newMode);\n            currCharCodeToPatternIdxToConfig =\n                this.charCodeToPatternIdxToConfig[newMode];\n            patternIdxToConfig = this.patternIdxToConfig[newMode];\n            currModePatternsLength = patternIdxToConfig.length;\n            currModePatternsLength = patternIdxToConfig.length;\n            const modeCanBeOptimized = this.canModeBeOptimized[newMode] && this.config.safeMode === false;\n            if (currCharCodeToPatternIdxToConfig && modeCanBeOptimized) {\n                getPossiblePatterns = getPossiblePatternsOptimized;\n            }\n            else {\n                getPossiblePatterns = getPossiblePatternsSlow;\n            }\n        }\n        // this pattern seems to avoid a V8 de-optimization, although that de-optimization does not\n        // seem to matter performance wise.\n        push_mode.call(this, initialMode);\n        let currConfig;\n        const recoveryEnabled = this.config.recoveryEnabled;\n        while (offset < orgLength) {\n            matchedImage = null;\n            const nextCharCode = orgText.charCodeAt(offset);\n            const chosenPatternIdxToConfig = getPossiblePatterns(nextCharCode);\n            const chosenPatternsLength = chosenPatternIdxToConfig.length;\n            for (i = 0; i < chosenPatternsLength; i++) {\n                currConfig = chosenPatternIdxToConfig[i];\n                const currPattern = currConfig.pattern;\n                payload = null;\n                // manually in-lined because > 600 chars won't be in-lined in V8\n                const singleCharCode = currConfig.short;\n                if (singleCharCode !== false) {\n                    if (nextCharCode === singleCharCode) {\n                        // single character string\n                        matchedImage = currPattern;\n                    }\n                }\n                else if (currConfig.isCustom === true) {\n                    match = currPattern.exec(orgText, offset, matchedTokens, groups);\n                    if (match !== null) {\n                        matchedImage = match[0];\n                        if (match.payload !== undefined) {\n                            payload = match.payload;\n                        }\n                    }\n                    else {\n                        matchedImage = null;\n                    }\n                }\n                else {\n                    this.updateLastIndex(currPattern, offset);\n                    matchedImage = this.match(currPattern, text, offset);\n                }\n                if (matchedImage !== null) {\n                    // even though this pattern matched we must try a another longer alternative.\n                    // this can be used to prioritize keywords over identifiers\n                    longerAlt = currConfig.longerAlt;\n                    if (longerAlt !== undefined) {\n                        // TODO: micro optimize, avoid extra prop access\n                        // by saving/linking longerAlt on the original config?\n                        const longerAltLength = longerAlt.length;\n                        for (k = 0; k < longerAltLength; k++) {\n                            const longerAltConfig = patternIdxToConfig[longerAlt[k]];\n                            const longerAltPattern = longerAltConfig.pattern;\n                            altPayload = null;\n                            // single Char can never be a longer alt so no need to test it.\n                            // manually in-lined because > 600 chars won't be in-lined in V8\n                            if (longerAltConfig.isCustom === true) {\n                                match = longerAltPattern.exec(orgText, offset, matchedTokens, groups);\n                                if (match !== null) {\n                                    matchAltImage = match[0];\n                                    if (match.payload !== undefined) {\n                                        altPayload = match.payload;\n                                    }\n                                }\n                                else {\n                                    matchAltImage = null;\n                                }\n                            }\n                            else {\n                                this.updateLastIndex(longerAltPattern, offset);\n                                matchAltImage = this.match(longerAltPattern, text, offset);\n                            }\n                            if (matchAltImage && matchAltImage.length > matchedImage.length) {\n                                matchedImage = matchAltImage;\n                                payload = altPayload;\n                                currConfig = longerAltConfig;\n                                // Exit the loop early after matching one of the longer alternatives\n                                // The first matched alternative takes precedence\n                                break;\n                            }\n                        }\n                    }\n                    break;\n                }\n            }\n            // successful match\n            if (matchedImage !== null) {\n                imageLength = matchedImage.length;\n                group = currConfig.group;\n                if (group !== undefined) {\n                    tokType = currConfig.tokenTypeIdx;\n                    // TODO: \"offset + imageLength\" and the new column may be computed twice in case of \"full\" location information inside\n                    // createFullToken method\n                    newToken = this.createTokenInstance(matchedImage, offset, tokType, currConfig.tokenType, line, column, imageLength);\n                    this.handlePayload(newToken, payload);\n                    // TODO: optimize NOOP in case there are no special groups?\n                    if (group === false) {\n                        matchedTokensIndex = this.addToken(matchedTokens, matchedTokensIndex, newToken);\n                    }\n                    else {\n                        groups[group].push(newToken);\n                    }\n                }\n                text = this.chopInput(text, imageLength);\n                offset = offset + imageLength;\n                // TODO: with newlines the column may be assigned twice\n                column = this.computeNewColumn(column, imageLength);\n                if (trackLines === true && currConfig.canLineTerminator === true) {\n                    let numOfLTsInMatch = 0;\n                    let foundTerminator;\n                    let lastLTEndOffset;\n                    lineTerminatorPattern.lastIndex = 0;\n                    do {\n                        foundTerminator = lineTerminatorPattern.test(matchedImage);\n                        if (foundTerminator === true) {\n                            lastLTEndOffset = lineTerminatorPattern.lastIndex - 1;\n                            numOfLTsInMatch++;\n                        }\n                    } while (foundTerminator === true);\n                    if (numOfLTsInMatch !== 0) {\n                        line = line + numOfLTsInMatch;\n                        column = imageLength - lastLTEndOffset;\n                        this.updateTokenEndLineColumnLocation(newToken, group, lastLTEndOffset, numOfLTsInMatch, line, column, imageLength);\n                    }\n                }\n                // will be NOOP if no modes present\n                this.handleModes(currConfig, pop_mode, push_mode, newToken);\n            }\n            else {\n                // error recovery, drop characters until we identify a valid token's start point\n                const errorStartOffset = offset;\n                const errorLine = line;\n                const errorColumn = column;\n                let foundResyncPoint = recoveryEnabled === false;\n                while (foundResyncPoint === false && offset < orgLength) {\n                    // Identity Func (when sticky flag is enabled)\n                    text = this.chopInput(text, 1);\n                    offset++;\n                    for (j = 0; j < currModePatternsLength; j++) {\n                        const currConfig = patternIdxToConfig[j];\n                        const currPattern = currConfig.pattern;\n                        // manually in-lined because > 600 chars won't be in-lined in V8\n                        const singleCharCode = currConfig.short;\n                        if (singleCharCode !== false) {\n                            if (orgText.charCodeAt(offset) === singleCharCode) {\n                                // single character string\n                                foundResyncPoint = true;\n                            }\n                        }\n                        else if (currConfig.isCustom === true) {\n                            foundResyncPoint =\n                                currPattern.exec(orgText, offset, matchedTokens, groups) !== null;\n                        }\n                        else {\n                            this.updateLastIndex(currPattern, offset);\n                            foundResyncPoint = currPattern.exec(text) !== null;\n                        }\n                        if (foundResyncPoint === true) {\n                            break;\n                        }\n                    }\n                }\n                errLength = offset - errorStartOffset;\n                column = this.computeNewColumn(column, errLength);\n                // at this point we either re-synced or reached the end of the input text\n                msg = this.config.errorMessageProvider.buildUnexpectedCharactersMessage(orgText, errorStartOffset, errLength, errorLine, errorColumn);\n                errors.push({\n                    offset: errorStartOffset,\n                    line: errorLine,\n                    column: errorColumn,\n                    length: errLength,\n                    message: msg,\n                });\n                if (recoveryEnabled === false) {\n                    break;\n                }\n            }\n        }\n        // if we do have custom patterns which push directly into the\n        // TODO: custom tokens should not push directly??\n        if (!this.hasCustom) {\n            // if we guessed a too large size for the tokens array this will shrink it to the right size.\n            matchedTokens.length = matchedTokensIndex;\n        }\n        return {\n            tokens: matchedTokens,\n            groups: groups,\n            errors: errors,\n        };\n    }\n    handleModes(config, pop_mode, push_mode, newToken) {\n        if (config.pop === true) {\n            // need to save the PUSH_MODE property as if the mode is popped\n            // patternIdxToPopMode is updated to reflect the new mode after popping the stack\n            const pushMode = config.push;\n            pop_mode(newToken);\n            if (pushMode !== undefined) {\n                push_mode.call(this, pushMode);\n            }\n        }\n        else if (config.push !== undefined) {\n            push_mode.call(this, config.push);\n        }\n    }\n    chopInput(text, length) {\n        return text.substring(length);\n    }\n    updateLastIndex(regExp, newLastIndex) {\n        regExp.lastIndex = newLastIndex;\n    }\n    // TODO: decrease this under 600 characters? inspect stripping comments option in TSC compiler\n    updateTokenEndLineColumnLocation(newToken, group, lastLTIdx, numOfLTsInMatch, line, column, imageLength) {\n        let lastCharIsLT, fixForEndingInLT;\n        if (group !== undefined) {\n            // a none skipped multi line Token, need to update endLine/endColumn\n            lastCharIsLT = lastLTIdx === imageLength - 1;\n            fixForEndingInLT = lastCharIsLT ? -1 : 0;\n            if (!(numOfLTsInMatch === 1 && lastCharIsLT === true)) {\n                // if a token ends in a LT that last LT only affects the line numbering of following Tokens\n                newToken.endLine = line + fixForEndingInLT;\n                // the last LT in a token does not affect the endColumn either as the [columnStart ... columnEnd)\n                // inclusive to exclusive range.\n                newToken.endColumn = column - 1 + -fixForEndingInLT;\n            }\n            // else single LT in the last character of a token, no need to modify the endLine/EndColumn\n        }\n    }\n    computeNewColumn(oldColumn, imageLength) {\n        return oldColumn + imageLength;\n    }\n    createOffsetOnlyToken(image, startOffset, tokenTypeIdx, tokenType) {\n        return {\n            image,\n            startOffset,\n            tokenTypeIdx,\n            tokenType,\n        };\n    }\n    createStartOnlyToken(image, startOffset, tokenTypeIdx, tokenType, startLine, startColumn) {\n        return {\n            image,\n            startOffset,\n            startLine,\n            startColumn,\n            tokenTypeIdx,\n            tokenType,\n        };\n    }\n    createFullToken(image, startOffset, tokenTypeIdx, tokenType, startLine, startColumn, imageLength) {\n        return {\n            image,\n            startOffset,\n            endOffset: startOffset + imageLength - 1,\n            startLine,\n            endLine: startLine,\n            startColumn,\n            endColumn: startColumn + imageLength - 1,\n            tokenTypeIdx,\n            tokenType,\n        };\n    }\n    addTokenUsingPush(tokenVector, index, tokenToAdd) {\n        tokenVector.push(tokenToAdd);\n        return index;\n    }\n    addTokenUsingMemberAccess(tokenVector, index, tokenToAdd) {\n        tokenVector[index] = tokenToAdd;\n        index++;\n        return index;\n    }\n    handlePayloadNoCustom(token, payload) { }\n    handlePayloadWithCustom(token, payload) {\n        if (payload !== null) {\n            token.payload = payload;\n        }\n    }\n    matchWithTest(pattern, text, offset) {\n        const found = pattern.test(text);\n        if (found === true) {\n            return text.substring(offset, pattern.lastIndex);\n        }\n        return null;\n    }\n    matchWithExec(pattern, text) {\n        const regExpArray = pattern.exec(text);\n        return regExpArray !== null ? regExpArray[0] : null;\n    }\n}\nLexer.SKIPPED = \"This marks a skipped Token pattern, this means each token identified by it will\" +\n    \"be consumed and then thrown into oblivion, this can be used to for example to completely ignore whitespace.\";\nLexer.NA = /NOT_APPLICABLE/;\n//# sourceMappingURL=lexer_public.js.map","export const defaultLexerErrorProvider = {\n    buildUnableToPopLexerModeMessage(token) {\n        return `Unable to pop Lexer Mode after encountering Token ->${token.image}<- The Mode Stack is empty`;\n    },\n    buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column) {\n        return (`unexpected character: ->${fullText.charAt(startOffset)}<- at offset: ${startOffset},` + ` skipped ${length} characters.`);\n    },\n};\n//# sourceMappingURL=lexer_errors_public.js.map","import { has, isString, isUndefined } from \"lodash-es\";\nimport { Lexer } from \"./lexer_public.js\";\nimport { augmentTokenTypes, tokenStructuredMatcher } from \"./tokens.js\";\nexport function tokenLabel(tokType) {\n    if (hasTokenLabel(tokType)) {\n        return tokType.LABEL;\n    }\n    else {\n        return tokType.name;\n    }\n}\nexport function tokenName(tokType) {\n    return tokType.name;\n}\nexport function hasTokenLabel(obj) {\n    return isString(obj.LABEL) && obj.LABEL !== \"\";\n}\nconst PARENT = \"parent\";\nconst CATEGORIES = \"categories\";\nconst LABEL = \"label\";\nconst GROUP = \"group\";\nconst PUSH_MODE = \"push_mode\";\nconst POP_MODE = \"pop_mode\";\nconst LONGER_ALT = \"longer_alt\";\nconst LINE_BREAKS = \"line_breaks\";\nconst START_CHARS_HINT = \"start_chars_hint\";\nexport function createToken(config) {\n    return createTokenInternal(config);\n}\nfunction createTokenInternal(config) {\n    const pattern = config.pattern;\n    const tokenType = {};\n    tokenType.name = config.name;\n    if (!isUndefined(pattern)) {\n        tokenType.PATTERN = pattern;\n    }\n    if (has(config, PARENT)) {\n        throw (\"The parent property is no longer supported.\\n\" +\n            \"See: https://github.com/chevrotain/chevrotain/issues/564#issuecomment-349062346 for details.\");\n    }\n    if (has(config, CATEGORIES)) {\n        // casting to ANY as this will be fixed inside `augmentTokenTypes``\n        tokenType.CATEGORIES = config[CATEGORIES];\n    }\n    augmentTokenTypes([tokenType]);\n    if (has(config, LABEL)) {\n        tokenType.LABEL = config[LABEL];\n    }\n    if (has(config, GROUP)) {\n        tokenType.GROUP = config[GROUP];\n    }\n    if (has(config, POP_MODE)) {\n        tokenType.POP_MODE = config[POP_MODE];\n    }\n    if (has(config, PUSH_MODE)) {\n        tokenType.PUSH_MODE = config[PUSH_MODE];\n    }\n    if (has(config, LONGER_ALT)) {\n        tokenType.LONGER_ALT = config[LONGER_ALT];\n    }\n    if (has(config, LINE_BREAKS)) {\n        tokenType.LINE_BREAKS = config[LINE_BREAKS];\n    }\n    if (has(config, START_CHARS_HINT)) {\n        tokenType.START_CHARS_HINT = config[START_CHARS_HINT];\n    }\n    return tokenType;\n}\nexport const EOF = createToken({ name: \"EOF\", pattern: Lexer.NA });\naugmentTokenTypes([EOF]);\nexport function createTokenInstance(tokType, image, startOffset, endOffset, startLine, endLine, startColumn, endColumn) {\n    return {\n        image,\n        startOffset,\n        endOffset,\n        startLine,\n        endLine,\n        startColumn,\n        endColumn,\n        tokenTypeIdx: tokType.tokenTypeIdx,\n        tokenType: tokType,\n    };\n}\nexport function tokenMatcher(token, tokType) {\n    return tokenStructuredMatcher(token, tokType);\n}\n//# sourceMappingURL=tokens_public.js.map","import { hasTokenLabel, tokenLabel } from \"../scan/tokens_public.js\";\nimport { first, map, reduce } from \"lodash-es\";\nimport { getProductionDslName, NonTerminal, Rule, Terminal, } from \"@chevrotain/gast\";\nexport const defaultParserErrorProvider = {\n    buildMismatchTokenMessage({ expected, actual, previous, ruleName }) {\n        const hasLabel = hasTokenLabel(expected);\n        const expectedMsg = hasLabel\n            ? `--> ${tokenLabel(expected)} <--`\n            : `token of type --> ${expected.name} <--`;\n        const msg = `Expecting ${expectedMsg} but found --> '${actual.image}' <--`;\n        return msg;\n    },\n    buildNotAllInputParsedMessage({ firstRedundant, ruleName }) {\n        return \"Redundant input, expecting EOF but found: \" + firstRedundant.image;\n    },\n    buildNoViableAltMessage({ expectedPathsPerAlt, actual, previous, customUserDescription, ruleName, }) {\n        const errPrefix = \"Expecting: \";\n        // TODO: issue: No Viable Alternative Error may have incomplete details. #502\n        const actualText = first(actual).image;\n        const errSuffix = \"\\nbut found: '\" + actualText + \"'\";\n        if (customUserDescription) {\n            return errPrefix + customUserDescription + errSuffix;\n        }\n        else {\n            const allLookAheadPaths = reduce(expectedPathsPerAlt, (result, currAltPaths) => result.concat(currAltPaths), []);\n            const nextValidTokenSequences = map(allLookAheadPaths, (currPath) => `[${map(currPath, (currTokenType) => tokenLabel(currTokenType)).join(\", \")}]`);\n            const nextValidSequenceItems = map(nextValidTokenSequences, (itemMsg, idx) => `  ${idx + 1}. ${itemMsg}`);\n            const calculatedDescription = `one of these possible Token sequences:\\n${nextValidSequenceItems.join(\"\\n\")}`;\n            return errPrefix + calculatedDescription + errSuffix;\n        }\n    },\n    buildEarlyExitMessage({ expectedIterationPaths, actual, customUserDescription, ruleName, }) {\n        const errPrefix = \"Expecting: \";\n        // TODO: issue: No Viable Alternative Error may have incomplete details. #502\n        const actualText = first(actual).image;\n        const errSuffix = \"\\nbut found: '\" + actualText + \"'\";\n        if (customUserDescription) {\n            return errPrefix + customUserDescription + errSuffix;\n        }\n        else {\n            const nextValidTokenSequences = map(expectedIterationPaths, (currPath) => `[${map(currPath, (currTokenType) => tokenLabel(currTokenType)).join(\",\")}]`);\n            const calculatedDescription = `expecting at least one iteration which starts with one of these possible Token sequences::\\n  ` +\n                `<${nextValidTokenSequences.join(\" ,\")}>`;\n            return errPrefix + calculatedDescription + errSuffix;\n        }\n    },\n};\nObject.freeze(defaultParserErrorProvider);\nexport const defaultGrammarResolverErrorProvider = {\n    buildRuleNotFoundError(topLevelRule, undefinedRule) {\n        const msg = \"Invalid grammar, reference to a rule which is not defined: ->\" +\n            undefinedRule.nonTerminalName +\n            \"<-\\n\" +\n            \"inside top level rule: ->\" +\n            topLevelRule.name +\n            \"<-\";\n        return msg;\n    },\n};\nexport const defaultGrammarValidatorErrorProvider = {\n    buildDuplicateFoundError(topLevelRule, duplicateProds) {\n        function getExtraProductionArgument(prod) {\n            if (prod instanceof Terminal) {\n                return prod.terminalType.name;\n            }\n            else if (prod instanceof NonTerminal) {\n                return prod.nonTerminalName;\n            }\n            else {\n                return \"\";\n            }\n        }\n        const topLevelName = topLevelRule.name;\n        const duplicateProd = first(duplicateProds);\n        const index = duplicateProd.idx;\n        const dslName = getProductionDslName(duplicateProd);\n        const extraArgument = getExtraProductionArgument(duplicateProd);\n        const hasExplicitIndex = index > 0;\n        let msg = `->${dslName}${hasExplicitIndex ? index : \"\"}<- ${extraArgument ? `with argument: ->${extraArgument}<-` : \"\"}\n                  appears more than once (${duplicateProds.length} times) in the top level rule: ->${topLevelName}<-.                  \n                  For further details see: https://chevrotain.io/docs/FAQ.html#NUMERICAL_SUFFIXES \n                  `;\n        // white space trimming time! better to trim afterwards as it allows to use WELL formatted multi line template strings...\n        msg = msg.replace(/[ \\t]+/g, \" \");\n        msg = msg.replace(/\\s\\s+/g, \"\\n\");\n        return msg;\n    },\n    buildNamespaceConflictError(rule) {\n        const errMsg = `Namespace conflict found in grammar.\\n` +\n            `The grammar has both a Terminal(Token) and a Non-Terminal(Rule) named: <${rule.name}>.\\n` +\n            `To resolve this make sure each Terminal and Non-Terminal names are unique\\n` +\n            `This is easy to accomplish by using the convention that Terminal names start with an uppercase letter\\n` +\n            `and Non-Terminal names start with a lower case letter.`;\n        return errMsg;\n    },\n    buildAlternationPrefixAmbiguityError(options) {\n        const pathMsg = map(options.prefixPath, (currTok) => tokenLabel(currTok)).join(\", \");\n        const occurrence = options.alternation.idx === 0 ? \"\" : options.alternation.idx;\n        const errMsg = `Ambiguous alternatives: <${options.ambiguityIndices.join(\" ,\")}> due to common lookahead prefix\\n` +\n            `in <OR${occurrence}> inside <${options.topLevelRule.name}> Rule,\\n` +\n            `<${pathMsg}> may appears as a prefix path in all these alternatives.\\n` +\n            `See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#COMMON_PREFIX\\n` +\n            `For Further details.`;\n        return errMsg;\n    },\n    buildAlternationAmbiguityError(options) {\n        const pathMsg = map(options.prefixPath, (currtok) => tokenLabel(currtok)).join(\", \");\n        const occurrence = options.alternation.idx === 0 ? \"\" : options.alternation.idx;\n        let currMessage = `Ambiguous Alternatives Detected: <${options.ambiguityIndices.join(\" ,\")}> in <OR${occurrence}>` +\n            ` inside <${options.topLevelRule.name}> Rule,\\n` +\n            `<${pathMsg}> may appears as a prefix path in all these alternatives.\\n`;\n        currMessage =\n            currMessage +\n                `See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#AMBIGUOUS_ALTERNATIVES\\n` +\n                `For Further details.`;\n        return currMessage;\n    },\n    buildEmptyRepetitionError(options) {\n        let dslName = getProductionDslName(options.repetition);\n        if (options.repetition.idx !== 0) {\n            dslName += options.repetition.idx;\n        }\n        const errMsg = `The repetition <${dslName}> within Rule <${options.topLevelRule.name}> can never consume any tokens.\\n` +\n            `This could lead to an infinite loop.`;\n        return errMsg;\n    },\n    // TODO: remove - `errors_public` from nyc.config.js exclude\n    //       once this method is fully removed from this file\n    buildTokenNameError(options) {\n        /* istanbul ignore next */\n        return \"deprecated\";\n    },\n    buildEmptyAlternationError(options) {\n        const errMsg = `Ambiguous empty alternative: <${options.emptyChoiceIdx + 1}>` +\n            ` in <OR${options.alternation.idx}> inside <${options.topLevelRule.name}> Rule.\\n` +\n            `Only the last alternative may be an empty alternative.`;\n        return errMsg;\n    },\n    buildTooManyAlternativesError(options) {\n        const errMsg = `An Alternation cannot have more than 256 alternatives:\\n` +\n            `<OR${options.alternation.idx}> inside <${options.topLevelRule.name}> Rule.\\n has ${options.alternation.definition.length + 1} alternatives.`;\n        return errMsg;\n    },\n    buildLeftRecursionError(options) {\n        const ruleName = options.topLevelRule.name;\n        const pathNames = map(options.leftRecursionPath, (currRule) => currRule.name);\n        const leftRecursivePath = `${ruleName} --> ${pathNames\n            .concat([ruleName])\n            .join(\" --> \")}`;\n        const errMsg = `Left Recursion found in grammar.\\n` +\n            `rule: <${ruleName}> can be invoked from itself (directly or indirectly)\\n` +\n            `without consuming any Tokens. The grammar path that causes this is: \\n ${leftRecursivePath}\\n` +\n            ` To fix this refactor your grammar to remove the left recursion.\\n` +\n            `see: https://en.wikipedia.org/wiki/LL_parser#Left_factoring.`;\n        return errMsg;\n    },\n    // TODO: remove - `errors_public` from nyc.config.js exclude\n    //       once this method is fully removed from this file\n    buildInvalidRuleNameError(options) {\n        /* istanbul ignore next */\n        return \"deprecated\";\n    },\n    buildDuplicateRuleNameError(options) {\n        let ruleName;\n        if (options.topLevelRule instanceof Rule) {\n            ruleName = options.topLevelRule.name;\n        }\n        else {\n            ruleName = options.topLevelRule;\n        }\n        const errMsg = `Duplicate definition, rule: ->${ruleName}<- is already defined in the grammar: ->${options.grammarName}<-`;\n        return errMsg;\n    },\n};\n//# sourceMappingURL=errors_public.js.map","import { ParserDefinitionErrorType, } from \"../parser/parser.js\";\nimport { forEach, values } from \"lodash-es\";\nimport { GAstVisitor } from \"@chevrotain/gast\";\nexport function resolveGrammar(topLevels, errMsgProvider) {\n    const refResolver = new GastRefResolverVisitor(topLevels, errMsgProvider);\n    refResolver.resolveRefs();\n    return refResolver.errors;\n}\nexport class GastRefResolverVisitor extends GAstVisitor {\n    constructor(nameToTopRule, errMsgProvider) {\n        super();\n        this.nameToTopRule = nameToTopRule;\n        this.errMsgProvider = errMsgProvider;\n        this.errors = [];\n    }\n    resolveRefs() {\n        forEach(values(this.nameToTopRule), (prod) => {\n            this.currTopLevel = prod;\n            prod.accept(this);\n        });\n    }\n    visitNonTerminal(node) {\n        const ref = this.nameToTopRule[node.nonTerminalName];\n        if (!ref) {\n            const msg = this.errMsgProvider.buildRuleNotFoundError(this.currTopLevel, node);\n            this.errors.push({\n                message: msg,\n                type: ParserDefinitionErrorType.UNRESOLVED_SUBRULE_REF,\n                ruleName: this.currTopLevel.name,\n                unresolvedRefName: node.nonTerminalName,\n            });\n        }\n        else {\n            node.referencedRule = ref;\n        }\n    }\n}\n//# sourceMappingURL=resolver.js.map","import baseFlatten from './_baseFlatten.js';\nimport map from './map.js';\n\n/**\n * Creates a flattened array of values by running each element in `collection`\n * thru `iteratee` and flattening the mapped results. The iteratee is invoked\n * with three arguments: (value, index|key, collection).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * function duplicate(n) {\n *   return [n, n];\n * }\n *\n * _.flatMap([1, 2], duplicate);\n * // => [1, 1, 2, 2]\n */\nfunction flatMap(collection, iteratee) {\n  return baseFlatten(map(collection, iteratee), 1);\n}\n\nexport default flatMap;\n","/**\n * A specialized version of `baseAggregator` for arrays.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} setter The function to set `accumulator` values.\n * @param {Function} iteratee The iteratee to transform keys.\n * @param {Object} accumulator The initial aggregated object.\n * @returns {Function} Returns `accumulator`.\n */\nfunction arrayAggregator(array, setter, iteratee, accumulator) {\n  var index = -1,\n      length = array == null ? 0 : array.length;\n\n  while (++index < length) {\n    var value = array[index];\n    setter(accumulator, value, iteratee(value), array);\n  }\n  return accumulator;\n}\n\nexport default arrayAggregator;\n","import baseEach from './_baseEach.js';\n\n/**\n * Aggregates elements of `collection` on `accumulator` with keys transformed\n * by `iteratee` and values set by `setter`.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} setter The function to set `accumulator` values.\n * @param {Function} iteratee The iteratee to transform keys.\n * @param {Object} accumulator The initial aggregated object.\n * @returns {Function} Returns `accumulator`.\n */\nfunction baseAggregator(collection, setter, iteratee, accumulator) {\n  baseEach(collection, function(value, key, collection) {\n    setter(accumulator, value, iteratee(value), collection);\n  });\n  return accumulator;\n}\n\nexport default baseAggregator;\n","import baseAssignValue from './_baseAssignValue.js';\nimport createAggregator from './_createAggregator.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Creates an object composed of keys generated from the results of running\n * each element of `collection` thru `iteratee`. The order of grouped values\n * is determined by the order they occur in `collection`. The corresponding\n * value of each key is an array of elements responsible for generating the\n * key. The iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n * @returns {Object} Returns the composed aggregate object.\n * @example\n *\n * _.groupBy([6.1, 4.2, 6.3], Math.floor);\n * // => { '4': [4.2], '6': [6.1, 6.3] }\n *\n * // The `_.property` iteratee shorthand.\n * _.groupBy(['one', 'two', 'three'], 'length');\n * // => { '3': ['one', 'two'], '5': ['three'] }\n */\nvar groupBy = createAggregator(function(result, value, key) {\n  if (hasOwnProperty.call(result, key)) {\n    result[key].push(value);\n  } else {\n    baseAssignValue(result, key, [value]);\n  }\n});\n\nexport default groupBy;\n","import arrayAggregator from './_arrayAggregator.js';\nimport baseAggregator from './_baseAggregator.js';\nimport baseIteratee from './_baseIteratee.js';\nimport isArray from './isArray.js';\n\n/**\n * Creates a function like `_.groupBy`.\n *\n * @private\n * @param {Function} setter The function to set accumulator values.\n * @param {Function} [initializer] The accumulator object initializer.\n * @returns {Function} Returns the new aggregator function.\n */\nfunction createAggregator(setter, initializer) {\n  return function(collection, iteratee) {\n    var func = isArray(collection) ? arrayAggregator : baseAggregator,\n        accumulator = initializer ? initializer() : {};\n\n    return func(collection, setter, baseIteratee(iteratee, 2), accumulator);\n  };\n}\n\nexport default createAggregator;\n","import baseSlice from './_baseSlice.js';\nimport toInteger from './toInteger.js';\n\n/**\n * Creates a slice of `array` with `n` elements dropped from the end.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {number} [n=1] The number of elements to drop.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * _.dropRight([1, 2, 3]);\n * // => [1, 2]\n *\n * _.dropRight([1, 2, 3], 2);\n * // => [1]\n *\n * _.dropRight([1, 2, 3], 5);\n * // => []\n *\n * _.dropRight([1, 2, 3], 0);\n * // => [1, 2, 3]\n */\nfunction dropRight(array, n, guard) {\n  var length = array == null ? 0 : array.length;\n  if (!length) {\n    return [];\n  }\n  n = (guard || n === undefined) ? 1 : toInteger(n);\n  n = length - n;\n  return baseSlice(array, 0, n < 0 ? 0 : n);\n}\n\nexport default dropRight;\n","import { clone, drop, dropRight, first as _first, forEach, isEmpty, last, } from \"lodash-es\";\nimport { first } from \"./first.js\";\nimport { RestWalker } from \"./rest.js\";\nimport { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Rule, Terminal, } from \"@chevrotain/gast\";\nexport class AbstractNextPossibleTokensWalker extends RestWalker {\n    constructor(topProd, path) {\n        super();\n        this.topProd = topProd;\n        this.path = path;\n        this.possibleTokTypes = [];\n        this.nextProductionName = \"\";\n        this.nextProductionOccurrence = 0;\n        this.found = false;\n        this.isAtEndOfPath = false;\n    }\n    startWalking() {\n        this.found = false;\n        if (this.path.ruleStack[0] !== this.topProd.name) {\n            throw Error(\"The path does not start with the walker's top Rule!\");\n        }\n        // immutable for the win\n        this.ruleStack = clone(this.path.ruleStack).reverse(); // intelij bug requires assertion\n        this.occurrenceStack = clone(this.path.occurrenceStack).reverse(); // intelij bug requires assertion\n        // already verified that the first production is valid, we now seek the 2nd production\n        this.ruleStack.pop();\n        this.occurrenceStack.pop();\n        this.updateExpectedNext();\n        this.walk(this.topProd);\n        return this.possibleTokTypes;\n    }\n    walk(prod, prevRest = []) {\n        // stop scanning once we found the path\n        if (!this.found) {\n            super.walk(prod, prevRest);\n        }\n    }\n    walkProdRef(refProd, currRest, prevRest) {\n        // found the next production, need to keep walking in it\n        if (refProd.referencedRule.name === this.nextProductionName &&\n            refProd.idx === this.nextProductionOccurrence) {\n            const fullRest = currRest.concat(prevRest);\n            this.updateExpectedNext();\n            this.walk(refProd.referencedRule, fullRest);\n        }\n    }\n    updateExpectedNext() {\n        // need to consume the Terminal\n        if (isEmpty(this.ruleStack)) {\n            // must reset nextProductionXXX to avoid walking down another Top Level production while what we are\n            // really seeking is the last Terminal...\n            this.nextProductionName = \"\";\n            this.nextProductionOccurrence = 0;\n            this.isAtEndOfPath = true;\n        }\n        else {\n            this.nextProductionName = this.ruleStack.pop();\n            this.nextProductionOccurrence = this.occurrenceStack.pop();\n        }\n    }\n}\nexport class NextAfterTokenWalker extends AbstractNextPossibleTokensWalker {\n    constructor(topProd, path) {\n        super(topProd, path);\n        this.path = path;\n        this.nextTerminalName = \"\";\n        this.nextTerminalOccurrence = 0;\n        this.nextTerminalName = this.path.lastTok.name;\n        this.nextTerminalOccurrence = this.path.lastTokOccurrence;\n    }\n    walkTerminal(terminal, currRest, prevRest) {\n        if (this.isAtEndOfPath &&\n            terminal.terminalType.name === this.nextTerminalName &&\n            terminal.idx === this.nextTerminalOccurrence &&\n            !this.found) {\n            const fullRest = currRest.concat(prevRest);\n            const restProd = new Alternative({ definition: fullRest });\n            this.possibleTokTypes = first(restProd);\n            this.found = true;\n        }\n    }\n}\n/**\n * This walker only \"walks\" a single \"TOP\" level in the Grammar Ast, this means\n * it never \"follows\" production refs\n */\nexport class AbstractNextTerminalAfterProductionWalker extends RestWalker {\n    constructor(topRule, occurrence) {\n        super();\n        this.topRule = topRule;\n        this.occurrence = occurrence;\n        this.result = {\n            token: undefined,\n            occurrence: undefined,\n            isEndOfRule: undefined,\n        };\n    }\n    startWalking() {\n        this.walk(this.topRule);\n        return this.result;\n    }\n}\nexport class NextTerminalAfterManyWalker extends AbstractNextTerminalAfterProductionWalker {\n    walkMany(manyProd, currRest, prevRest) {\n        if (manyProd.idx === this.occurrence) {\n            const firstAfterMany = _first(currRest.concat(prevRest));\n            this.result.isEndOfRule = firstAfterMany === undefined;\n            if (firstAfterMany instanceof Terminal) {\n                this.result.token = firstAfterMany.terminalType;\n                this.result.occurrence = firstAfterMany.idx;\n            }\n        }\n        else {\n            super.walkMany(manyProd, currRest, prevRest);\n        }\n    }\n}\nexport class NextTerminalAfterManySepWalker extends AbstractNextTerminalAfterProductionWalker {\n    walkManySep(manySepProd, currRest, prevRest) {\n        if (manySepProd.idx === this.occurrence) {\n            const firstAfterManySep = _first(currRest.concat(prevRest));\n            this.result.isEndOfRule = firstAfterManySep === undefined;\n            if (firstAfterManySep instanceof Terminal) {\n                this.result.token = firstAfterManySep.terminalType;\n                this.result.occurrence = firstAfterManySep.idx;\n            }\n        }\n        else {\n            super.walkManySep(manySepProd, currRest, prevRest);\n        }\n    }\n}\nexport class NextTerminalAfterAtLeastOneWalker extends AbstractNextTerminalAfterProductionWalker {\n    walkAtLeastOne(atLeastOneProd, currRest, prevRest) {\n        if (atLeastOneProd.idx === this.occurrence) {\n            const firstAfterAtLeastOne = _first(currRest.concat(prevRest));\n            this.result.isEndOfRule = firstAfterAtLeastOne === undefined;\n            if (firstAfterAtLeastOne instanceof Terminal) {\n                this.result.token = firstAfterAtLeastOne.terminalType;\n                this.result.occurrence = firstAfterAtLeastOne.idx;\n            }\n        }\n        else {\n            super.walkAtLeastOne(atLeastOneProd, currRest, prevRest);\n        }\n    }\n}\n// TODO: reduce code duplication in the AfterWalkers\nexport class NextTerminalAfterAtLeastOneSepWalker extends AbstractNextTerminalAfterProductionWalker {\n    walkAtLeastOneSep(atleastOneSepProd, currRest, prevRest) {\n        if (atleastOneSepProd.idx === this.occurrence) {\n            const firstAfterfirstAfterAtLeastOneSep = _first(currRest.concat(prevRest));\n            this.result.isEndOfRule = firstAfterfirstAfterAtLeastOneSep === undefined;\n            if (firstAfterfirstAfterAtLeastOneSep instanceof Terminal) {\n                this.result.token = firstAfterfirstAfterAtLeastOneSep.terminalType;\n                this.result.occurrence = firstAfterfirstAfterAtLeastOneSep.idx;\n            }\n        }\n        else {\n            super.walkAtLeastOneSep(atleastOneSepProd, currRest, prevRest);\n        }\n    }\n}\nexport function possiblePathsFrom(targetDef, maxLength, currPath = []) {\n    // avoid side effects\n    currPath = clone(currPath);\n    let result = [];\n    let i = 0;\n    // TODO: avoid inner funcs\n    function remainingPathWith(nextDef) {\n        return nextDef.concat(drop(targetDef, i + 1));\n    }\n    // TODO: avoid inner funcs\n    function getAlternativesForProd(definition) {\n        const alternatives = possiblePathsFrom(remainingPathWith(definition), maxLength, currPath);\n        return result.concat(alternatives);\n    }\n    /**\n     * Mandatory productions will halt the loop as the paths computed from their recursive calls will already contain the\n     * following (rest) of the targetDef.\n     *\n     * For optional productions (Option/Repetition/...) the loop will continue to represent the paths that do not include the\n     * the optional production.\n     */\n    while (currPath.length < maxLength && i < targetDef.length) {\n        const prod = targetDef[i];\n        /* istanbul ignore else */\n        if (prod instanceof Alternative) {\n            return getAlternativesForProd(prod.definition);\n        }\n        else if (prod instanceof NonTerminal) {\n            return getAlternativesForProd(prod.definition);\n        }\n        else if (prod instanceof Option) {\n            result = getAlternativesForProd(prod.definition);\n        }\n        else if (prod instanceof RepetitionMandatory) {\n            const newDef = prod.definition.concat([\n                new Repetition({\n                    definition: prod.definition,\n                }),\n            ]);\n            return getAlternativesForProd(newDef);\n        }\n        else if (prod instanceof RepetitionMandatoryWithSeparator) {\n            const newDef = [\n                new Alternative({ definition: prod.definition }),\n                new Repetition({\n                    definition: [new Terminal({ terminalType: prod.separator })].concat(prod.definition),\n                }),\n            ];\n            return getAlternativesForProd(newDef);\n        }\n        else if (prod instanceof RepetitionWithSeparator) {\n            const newDef = prod.definition.concat([\n                new Repetition({\n                    definition: [new Terminal({ terminalType: prod.separator })].concat(prod.definition),\n                }),\n            ]);\n            result = getAlternativesForProd(newDef);\n        }\n        else if (prod instanceof Repetition) {\n            const newDef = prod.definition.concat([\n                new Repetition({\n                    definition: prod.definition,\n                }),\n            ]);\n            result = getAlternativesForProd(newDef);\n        }\n        else if (prod instanceof Alternation) {\n            forEach(prod.definition, (currAlt) => {\n                // TODO: this is a limited check for empty alternatives\n                //   It would prevent a common case of infinite loops during parser initialization.\n                //   However **in-directly** empty alternatives may still cause issues.\n                if (isEmpty(currAlt.definition) === false) {\n                    result = getAlternativesForProd(currAlt.definition);\n                }\n            });\n            return result;\n        }\n        else if (prod instanceof Terminal) {\n            currPath.push(prod.terminalType);\n        }\n        else {\n            throw Error(\"non exhaustive match\");\n        }\n        i++;\n    }\n    result.push({\n        partialPath: currPath,\n        suffixDef: drop(targetDef, i),\n    });\n    return result;\n}\nexport function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhead) {\n    const EXIT_NON_TERMINAL = \"EXIT_NONE_TERMINAL\";\n    // to avoid creating a new Array each time.\n    const EXIT_NON_TERMINAL_ARR = [EXIT_NON_TERMINAL];\n    const EXIT_ALTERNATIVE = \"EXIT_ALTERNATIVE\";\n    let foundCompletePath = false;\n    const tokenVectorLength = tokenVector.length;\n    const minimalAlternativesIndex = tokenVectorLength - maxLookAhead - 1;\n    const result = [];\n    const possiblePaths = [];\n    possiblePaths.push({\n        idx: -1,\n        def: initialDef,\n        ruleStack: [],\n        occurrenceStack: [],\n    });\n    while (!isEmpty(possiblePaths)) {\n        const currPath = possiblePaths.pop();\n        // skip alternatives if no more results can be found (assuming deterministic grammar with fixed lookahead)\n        if (currPath === EXIT_ALTERNATIVE) {\n            if (foundCompletePath &&\n                last(possiblePaths).idx <= minimalAlternativesIndex) {\n                // remove irrelevant alternative\n                possiblePaths.pop();\n            }\n            continue;\n        }\n        const currDef = currPath.def;\n        const currIdx = currPath.idx;\n        const currRuleStack = currPath.ruleStack;\n        const currOccurrenceStack = currPath.occurrenceStack;\n        // For Example: an empty path could exist in a valid grammar in the case of an EMPTY_ALT\n        if (isEmpty(currDef)) {\n            continue;\n        }\n        const prod = currDef[0];\n        /* istanbul ignore else */\n        if (prod === EXIT_NON_TERMINAL) {\n            const nextPath = {\n                idx: currIdx,\n                def: drop(currDef),\n                ruleStack: dropRight(currRuleStack),\n                occurrenceStack: dropRight(currOccurrenceStack),\n            };\n            possiblePaths.push(nextPath);\n        }\n        else if (prod instanceof Terminal) {\n            /* istanbul ignore else */\n            if (currIdx < tokenVectorLength - 1) {\n                const nextIdx = currIdx + 1;\n                const actualToken = tokenVector[nextIdx];\n                if (tokMatcher(actualToken, prod.terminalType)) {\n                    const nextPath = {\n                        idx: nextIdx,\n                        def: drop(currDef),\n                        ruleStack: currRuleStack,\n                        occurrenceStack: currOccurrenceStack,\n                    };\n                    possiblePaths.push(nextPath);\n                }\n                // end of the line\n            }\n            else if (currIdx === tokenVectorLength - 1) {\n                // IGNORE ABOVE ELSE\n                result.push({\n                    nextTokenType: prod.terminalType,\n                    nextTokenOccurrence: prod.idx,\n                    ruleStack: currRuleStack,\n                    occurrenceStack: currOccurrenceStack,\n                });\n                foundCompletePath = true;\n            }\n            else {\n                throw Error(\"non exhaustive match\");\n            }\n        }\n        else if (prod instanceof NonTerminal) {\n            const newRuleStack = clone(currRuleStack);\n            newRuleStack.push(prod.nonTerminalName);\n            const newOccurrenceStack = clone(currOccurrenceStack);\n            newOccurrenceStack.push(prod.idx);\n            const nextPath = {\n                idx: currIdx,\n                def: prod.definition.concat(EXIT_NON_TERMINAL_ARR, drop(currDef)),\n                ruleStack: newRuleStack,\n                occurrenceStack: newOccurrenceStack,\n            };\n            possiblePaths.push(nextPath);\n        }\n        else if (prod instanceof Option) {\n            // the order of alternatives is meaningful, FILO (Last path will be traversed first).\n            const nextPathWithout = {\n                idx: currIdx,\n                def: drop(currDef),\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPathWithout);\n            // required marker to avoid backtracking paths whose higher priority alternatives already matched\n            possiblePaths.push(EXIT_ALTERNATIVE);\n            const nextPathWith = {\n                idx: currIdx,\n                def: prod.definition.concat(drop(currDef)),\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPathWith);\n        }\n        else if (prod instanceof RepetitionMandatory) {\n            // TODO:(THE NEW operators here take a while...) (convert once?)\n            const secondIteration = new Repetition({\n                definition: prod.definition,\n                idx: prod.idx,\n            });\n            const nextDef = prod.definition.concat([secondIteration], drop(currDef));\n            const nextPath = {\n                idx: currIdx,\n                def: nextDef,\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPath);\n        }\n        else if (prod instanceof RepetitionMandatoryWithSeparator) {\n            // TODO:(THE NEW operators here take a while...) (convert once?)\n            const separatorGast = new Terminal({\n                terminalType: prod.separator,\n            });\n            const secondIteration = new Repetition({\n                definition: [separatorGast].concat(prod.definition),\n                idx: prod.idx,\n            });\n            const nextDef = prod.definition.concat([secondIteration], drop(currDef));\n            const nextPath = {\n                idx: currIdx,\n                def: nextDef,\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPath);\n        }\n        else if (prod instanceof RepetitionWithSeparator) {\n            // the order of alternatives is meaningful, FILO (Last path will be traversed first).\n            const nextPathWithout = {\n                idx: currIdx,\n                def: drop(currDef),\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPathWithout);\n            // required marker to avoid backtracking paths whose higher priority alternatives already matched\n            possiblePaths.push(EXIT_ALTERNATIVE);\n            const separatorGast = new Terminal({\n                terminalType: prod.separator,\n            });\n            const nthRepetition = new Repetition({\n                definition: [separatorGast].concat(prod.definition),\n                idx: prod.idx,\n            });\n            const nextDef = prod.definition.concat([nthRepetition], drop(currDef));\n            const nextPathWith = {\n                idx: currIdx,\n                def: nextDef,\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPathWith);\n        }\n        else if (prod instanceof Repetition) {\n            // the order of alternatives is meaningful, FILO (Last path will be traversed first).\n            const nextPathWithout = {\n                idx: currIdx,\n                def: drop(currDef),\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPathWithout);\n            // required marker to avoid backtracking paths whose higher priority alternatives already matched\n            possiblePaths.push(EXIT_ALTERNATIVE);\n            // TODO: an empty repetition will cause infinite loops here, will the parser detect this in selfAnalysis?\n            const nthRepetition = new Repetition({\n                definition: prod.definition,\n                idx: prod.idx,\n            });\n            const nextDef = prod.definition.concat([nthRepetition], drop(currDef));\n            const nextPathWith = {\n                idx: currIdx,\n                def: nextDef,\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPathWith);\n        }\n        else if (prod instanceof Alternation) {\n            // the order of alternatives is meaningful, FILO (Last path will be traversed first).\n            for (let i = prod.definition.length - 1; i >= 0; i--) {\n                const currAlt = prod.definition[i];\n                const currAltPath = {\n                    idx: currIdx,\n                    def: currAlt.definition.concat(drop(currDef)),\n                    ruleStack: currRuleStack,\n                    occurrenceStack: currOccurrenceStack,\n                };\n                possiblePaths.push(currAltPath);\n                possiblePaths.push(EXIT_ALTERNATIVE);\n            }\n        }\n        else if (prod instanceof Alternative) {\n            possiblePaths.push({\n                idx: currIdx,\n                def: prod.definition.concat(drop(currDef)),\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            });\n        }\n        else if (prod instanceof Rule) {\n            // last because we should only encounter at most a single one of these per invocation.\n            possiblePaths.push(expandTopLevelRule(prod, currIdx, currRuleStack, currOccurrenceStack));\n        }\n        else {\n            throw Error(\"non exhaustive match\");\n        }\n    }\n    return result;\n}\nfunction expandTopLevelRule(topRule, currIdx, currRuleStack, currOccurrenceStack) {\n    const newRuleStack = clone(currRuleStack);\n    newRuleStack.push(topRule.name);\n    const newCurrOccurrenceStack = clone(currOccurrenceStack);\n    // top rule is always assumed to have been called with occurrence index 1\n    newCurrOccurrenceStack.push(1);\n    return {\n        idx: currIdx,\n        def: topRule.definition,\n        ruleStack: newRuleStack,\n        occurrenceStack: newCurrOccurrenceStack,\n    };\n}\n//# sourceMappingURL=interpreter.js.map","import { every, flatten, forEach, has, isEmpty, map, reduce } from \"lodash-es\";\nimport { possiblePathsFrom } from \"./interpreter.js\";\nimport { RestWalker } from \"./rest.js\";\nimport { tokenStructuredMatcher, tokenStructuredMatcherNoCategories, } from \"../../scan/tokens.js\";\nimport { Alternation, Alternative as AlternativeGAST, GAstVisitor, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, } from \"@chevrotain/gast\";\nexport var PROD_TYPE;\n(function (PROD_TYPE) {\n    PROD_TYPE[PROD_TYPE[\"OPTION\"] = 0] = \"OPTION\";\n    PROD_TYPE[PROD_TYPE[\"REPETITION\"] = 1] = \"REPETITION\";\n    PROD_TYPE[PROD_TYPE[\"REPETITION_MANDATORY\"] = 2] = \"REPETITION_MANDATORY\";\n    PROD_TYPE[PROD_TYPE[\"REPETITION_MANDATORY_WITH_SEPARATOR\"] = 3] = \"REPETITION_MANDATORY_WITH_SEPARATOR\";\n    PROD_TYPE[PROD_TYPE[\"REPETITION_WITH_SEPARATOR\"] = 4] = \"REPETITION_WITH_SEPARATOR\";\n    PROD_TYPE[PROD_TYPE[\"ALTERNATION\"] = 5] = \"ALTERNATION\";\n})(PROD_TYPE || (PROD_TYPE = {}));\nexport function getProdType(prod) {\n    /* istanbul ignore else */\n    if (prod instanceof Option || prod === \"Option\") {\n        return PROD_TYPE.OPTION;\n    }\n    else if (prod instanceof Repetition || prod === \"Repetition\") {\n        return PROD_TYPE.REPETITION;\n    }\n    else if (prod instanceof RepetitionMandatory ||\n        prod === \"RepetitionMandatory\") {\n        return PROD_TYPE.REPETITION_MANDATORY;\n    }\n    else if (prod instanceof RepetitionMandatoryWithSeparator ||\n        prod === \"RepetitionMandatoryWithSeparator\") {\n        return PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR;\n    }\n    else if (prod instanceof RepetitionWithSeparator ||\n        prod === \"RepetitionWithSeparator\") {\n        return PROD_TYPE.REPETITION_WITH_SEPARATOR;\n    }\n    else if (prod instanceof Alternation || prod === \"Alternation\") {\n        return PROD_TYPE.ALTERNATION;\n    }\n    else {\n        throw Error(\"non exhaustive match\");\n    }\n}\nexport function getLookaheadPaths(options) {\n    const { occurrence, rule, prodType, maxLookahead } = options;\n    const type = getProdType(prodType);\n    if (type === PROD_TYPE.ALTERNATION) {\n        return getLookaheadPathsForOr(occurrence, rule, maxLookahead);\n    }\n    else {\n        return getLookaheadPathsForOptionalProd(occurrence, rule, type, maxLookahead);\n    }\n}\nexport function buildLookaheadFuncForOr(occurrence, ruleGrammar, maxLookahead, hasPredicates, dynamicTokensEnabled, laFuncBuilder) {\n    const lookAheadPaths = getLookaheadPathsForOr(occurrence, ruleGrammar, maxLookahead);\n    const tokenMatcher = areTokenCategoriesNotUsed(lookAheadPaths)\n        ? tokenStructuredMatcherNoCategories\n        : tokenStructuredMatcher;\n    return laFuncBuilder(lookAheadPaths, hasPredicates, tokenMatcher, dynamicTokensEnabled);\n}\n/**\n *  When dealing with an Optional production (OPTION/MANY/2nd iteration of AT_LEAST_ONE/...) we need to compare\n *  the lookahead \"inside\" the production and the lookahead immediately \"after\" it in the same top level rule (context free).\n *\n *  Example: given a production:\n *  ABC(DE)?DF\n *\n *  The optional '(DE)?' should only be entered if we see 'DE'. a single Token 'D' is not sufficient to distinguish between the two\n *  alternatives.\n *\n *  @returns A Lookahead function which will return true IFF the parser should parse the Optional production.\n */\nexport function buildLookaheadFuncForOptionalProd(occurrence, ruleGrammar, k, dynamicTokensEnabled, prodType, lookaheadBuilder) {\n    const lookAheadPaths = getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, k);\n    const tokenMatcher = areTokenCategoriesNotUsed(lookAheadPaths)\n        ? tokenStructuredMatcherNoCategories\n        : tokenStructuredMatcher;\n    return lookaheadBuilder(lookAheadPaths[0], tokenMatcher, dynamicTokensEnabled);\n}\nexport function buildAlternativesLookAheadFunc(alts, hasPredicates, tokenMatcher, dynamicTokensEnabled) {\n    const numOfAlts = alts.length;\n    const areAllOneTokenLookahead = every(alts, (currAlt) => {\n        return every(currAlt, (currPath) => {\n            return currPath.length === 1;\n        });\n    });\n    // This version takes into account the predicates as well.\n    if (hasPredicates) {\n        /**\n         * @returns {number} - The chosen alternative index\n         */\n        return function (orAlts) {\n            // unfortunately the predicates must be extracted every single time\n            // as they cannot be cached due to references to parameters(vars) which are no longer valid.\n            // note that in the common case of no predicates, no cpu time will be wasted on this (see else block)\n            const predicates = map(orAlts, (currAlt) => currAlt.GATE);\n            for (let t = 0; t < numOfAlts; t++) {\n                const currAlt = alts[t];\n                const currNumOfPaths = currAlt.length;\n                const currPredicate = predicates[t];\n                if (currPredicate !== undefined && currPredicate.call(this) === false) {\n                    // if the predicate does not match there is no point in checking the paths\n                    continue;\n                }\n                nextPath: for (let j = 0; j < currNumOfPaths; j++) {\n                    const currPath = currAlt[j];\n                    const currPathLength = currPath.length;\n                    for (let i = 0; i < currPathLength; i++) {\n                        const nextToken = this.LA(i + 1);\n                        if (tokenMatcher(nextToken, currPath[i]) === false) {\n                            // mismatch in current path\n                            // try the next pth\n                            continue nextPath;\n                        }\n                    }\n                    // found a full path that matches.\n                    // this will also work for an empty ALT as the loop will be skipped\n                    return t;\n                }\n                // none of the paths for the current alternative matched\n                // try the next alternative\n            }\n            // none of the alternatives could be matched\n            return undefined;\n        };\n    }\n    else if (areAllOneTokenLookahead && !dynamicTokensEnabled) {\n        // optimized (common) case of all the lookaheads paths requiring only\n        // a single token lookahead. These Optimizations cannot work if dynamically defined Tokens are used.\n        const singleTokenAlts = map(alts, (currAlt) => {\n            return flatten(currAlt);\n        });\n        const choiceToAlt = reduce(singleTokenAlts, (result, currAlt, idx) => {\n            forEach(currAlt, (currTokType) => {\n                if (!has(result, currTokType.tokenTypeIdx)) {\n                    result[currTokType.tokenTypeIdx] = idx;\n                }\n                forEach(currTokType.categoryMatches, (currExtendingType) => {\n                    if (!has(result, currExtendingType)) {\n                        result[currExtendingType] = idx;\n                    }\n                });\n            });\n            return result;\n        }, {});\n        /**\n         * @returns {number} - The chosen alternative index\n         */\n        return function () {\n            const nextToken = this.LA(1);\n            return choiceToAlt[nextToken.tokenTypeIdx];\n        };\n    }\n    else {\n        // optimized lookahead without needing to check the predicates at all.\n        // this causes code duplication which is intentional to improve performance.\n        /**\n         * @returns {number} - The chosen alternative index\n         */\n        return function () {\n            for (let t = 0; t < numOfAlts; t++) {\n                const currAlt = alts[t];\n                const currNumOfPaths = currAlt.length;\n                nextPath: for (let j = 0; j < currNumOfPaths; j++) {\n                    const currPath = currAlt[j];\n                    const currPathLength = currPath.length;\n                    for (let i = 0; i < currPathLength; i++) {\n                        const nextToken = this.LA(i + 1);\n                        if (tokenMatcher(nextToken, currPath[i]) === false) {\n                            // mismatch in current path\n                            // try the next pth\n                            continue nextPath;\n                        }\n                    }\n                    // found a full path that matches.\n                    // this will also work for an empty ALT as the loop will be skipped\n                    return t;\n                }\n                // none of the paths for the current alternative matched\n                // try the next alternative\n            }\n            // none of the alternatives could be matched\n            return undefined;\n        };\n    }\n}\nexport function buildSingleAlternativeLookaheadFunction(alt, tokenMatcher, dynamicTokensEnabled) {\n    const areAllOneTokenLookahead = every(alt, (currPath) => {\n        return currPath.length === 1;\n    });\n    const numOfPaths = alt.length;\n    // optimized (common) case of all the lookaheads paths requiring only\n    // a single token lookahead.\n    if (areAllOneTokenLookahead && !dynamicTokensEnabled) {\n        const singleTokensTypes = flatten(alt);\n        if (singleTokensTypes.length === 1 &&\n            isEmpty(singleTokensTypes[0].categoryMatches)) {\n            const expectedTokenType = singleTokensTypes[0];\n            const expectedTokenUniqueKey = expectedTokenType.tokenTypeIdx;\n            return function () {\n                return this.LA(1).tokenTypeIdx === expectedTokenUniqueKey;\n            };\n        }\n        else {\n            const choiceToAlt = reduce(singleTokensTypes, (result, currTokType, idx) => {\n                result[currTokType.tokenTypeIdx] = true;\n                forEach(currTokType.categoryMatches, (currExtendingType) => {\n                    result[currExtendingType] = true;\n                });\n                return result;\n            }, []);\n            return function () {\n                const nextToken = this.LA(1);\n                return choiceToAlt[nextToken.tokenTypeIdx] === true;\n            };\n        }\n    }\n    else {\n        return function () {\n            nextPath: for (let j = 0; j < numOfPaths; j++) {\n                const currPath = alt[j];\n                const currPathLength = currPath.length;\n                for (let i = 0; i < currPathLength; i++) {\n                    const nextToken = this.LA(i + 1);\n                    if (tokenMatcher(nextToken, currPath[i]) === false) {\n                        // mismatch in current path\n                        // try the next pth\n                        continue nextPath;\n                    }\n                }\n                // found a full path that matches.\n                return true;\n            }\n            // none of the paths matched\n            return false;\n        };\n    }\n}\nclass RestDefinitionFinderWalker extends RestWalker {\n    constructor(topProd, targetOccurrence, targetProdType) {\n        super();\n        this.topProd = topProd;\n        this.targetOccurrence = targetOccurrence;\n        this.targetProdType = targetProdType;\n    }\n    startWalking() {\n        this.walk(this.topProd);\n        return this.restDef;\n    }\n    checkIsTarget(node, expectedProdType, currRest, prevRest) {\n        if (node.idx === this.targetOccurrence &&\n            this.targetProdType === expectedProdType) {\n            this.restDef = currRest.concat(prevRest);\n            return true;\n        }\n        // performance optimization, do not iterate over the entire Grammar ast after we have found the target\n        return false;\n    }\n    walkOption(optionProd, currRest, prevRest) {\n        if (!this.checkIsTarget(optionProd, PROD_TYPE.OPTION, currRest, prevRest)) {\n            super.walkOption(optionProd, currRest, prevRest);\n        }\n    }\n    walkAtLeastOne(atLeastOneProd, currRest, prevRest) {\n        if (!this.checkIsTarget(atLeastOneProd, PROD_TYPE.REPETITION_MANDATORY, currRest, prevRest)) {\n            super.walkOption(atLeastOneProd, currRest, prevRest);\n        }\n    }\n    walkAtLeastOneSep(atLeastOneSepProd, currRest, prevRest) {\n        if (!this.checkIsTarget(atLeastOneSepProd, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR, currRest, prevRest)) {\n            super.walkOption(atLeastOneSepProd, currRest, prevRest);\n        }\n    }\n    walkMany(manyProd, currRest, prevRest) {\n        if (!this.checkIsTarget(manyProd, PROD_TYPE.REPETITION, currRest, prevRest)) {\n            super.walkOption(manyProd, currRest, prevRest);\n        }\n    }\n    walkManySep(manySepProd, currRest, prevRest) {\n        if (!this.checkIsTarget(manySepProd, PROD_TYPE.REPETITION_WITH_SEPARATOR, currRest, prevRest)) {\n            super.walkOption(manySepProd, currRest, prevRest);\n        }\n    }\n}\n/**\n * Returns the definition of a target production in a top level level rule.\n */\nclass InsideDefinitionFinderVisitor extends GAstVisitor {\n    constructor(targetOccurrence, targetProdType, targetRef) {\n        super();\n        this.targetOccurrence = targetOccurrence;\n        this.targetProdType = targetProdType;\n        this.targetRef = targetRef;\n        this.result = [];\n    }\n    checkIsTarget(node, expectedProdName) {\n        if (node.idx === this.targetOccurrence &&\n            this.targetProdType === expectedProdName &&\n            (this.targetRef === undefined || node === this.targetRef)) {\n            this.result = node.definition;\n        }\n    }\n    visitOption(node) {\n        this.checkIsTarget(node, PROD_TYPE.OPTION);\n    }\n    visitRepetition(node) {\n        this.checkIsTarget(node, PROD_TYPE.REPETITION);\n    }\n    visitRepetitionMandatory(node) {\n        this.checkIsTarget(node, PROD_TYPE.REPETITION_MANDATORY);\n    }\n    visitRepetitionMandatoryWithSeparator(node) {\n        this.checkIsTarget(node, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR);\n    }\n    visitRepetitionWithSeparator(node) {\n        this.checkIsTarget(node, PROD_TYPE.REPETITION_WITH_SEPARATOR);\n    }\n    visitAlternation(node) {\n        this.checkIsTarget(node, PROD_TYPE.ALTERNATION);\n    }\n}\nfunction initializeArrayOfArrays(size) {\n    const result = new Array(size);\n    for (let i = 0; i < size; i++) {\n        result[i] = [];\n    }\n    return result;\n}\n/**\n * A sort of hash function between a Path in the grammar and a string.\n * Note that this returns multiple \"hashes\" to support the scenario of token categories.\n * -  A single path with categories may match multiple **actual** paths.\n */\nfunction pathToHashKeys(path) {\n    let keys = [\"\"];\n    for (let i = 0; i < path.length; i++) {\n        const tokType = path[i];\n        const longerKeys = [];\n        for (let j = 0; j < keys.length; j++) {\n            const currShorterKey = keys[j];\n            longerKeys.push(currShorterKey + \"_\" + tokType.tokenTypeIdx);\n            for (let t = 0; t < tokType.categoryMatches.length; t++) {\n                const categoriesKeySuffix = \"_\" + tokType.categoryMatches[t];\n                longerKeys.push(currShorterKey + categoriesKeySuffix);\n            }\n        }\n        keys = longerKeys;\n    }\n    return keys;\n}\n/**\n * Imperative style due to being called from a hot spot\n */\nfunction isUniquePrefixHash(altKnownPathsKeys, searchPathKeys, idx) {\n    for (let currAltIdx = 0; currAltIdx < altKnownPathsKeys.length; currAltIdx++) {\n        // We only want to test vs the other alternatives\n        if (currAltIdx === idx) {\n            continue;\n        }\n        const otherAltKnownPathsKeys = altKnownPathsKeys[currAltIdx];\n        for (let searchIdx = 0; searchIdx < searchPathKeys.length; searchIdx++) {\n            const searchKey = searchPathKeys[searchIdx];\n            if (otherAltKnownPathsKeys[searchKey] === true) {\n                return false;\n            }\n        }\n    }\n    // None of the SearchPathKeys were found in any of the other alternatives\n    return true;\n}\nexport function lookAheadSequenceFromAlternatives(altsDefs, k) {\n    const partialAlts = map(altsDefs, (currAlt) => possiblePathsFrom([currAlt], 1));\n    const finalResult = initializeArrayOfArrays(partialAlts.length);\n    const altsHashes = map(partialAlts, (currAltPaths) => {\n        const dict = {};\n        forEach(currAltPaths, (item) => {\n            const keys = pathToHashKeys(item.partialPath);\n            forEach(keys, (currKey) => {\n                dict[currKey] = true;\n            });\n        });\n        return dict;\n    });\n    let newData = partialAlts;\n    // maxLookahead loop\n    for (let pathLength = 1; pathLength <= k; pathLength++) {\n        const currDataset = newData;\n        newData = initializeArrayOfArrays(currDataset.length);\n        // alternatives loop\n        for (let altIdx = 0; altIdx < currDataset.length; altIdx++) {\n            const currAltPathsAndSuffixes = currDataset[altIdx];\n            // paths in current alternative loop\n            for (let currPathIdx = 0; currPathIdx < currAltPathsAndSuffixes.length; currPathIdx++) {\n                const currPathPrefix = currAltPathsAndSuffixes[currPathIdx].partialPath;\n                const suffixDef = currAltPathsAndSuffixes[currPathIdx].suffixDef;\n                const prefixKeys = pathToHashKeys(currPathPrefix);\n                const isUnique = isUniquePrefixHash(altsHashes, prefixKeys, altIdx);\n                // End of the line for this path.\n                if (isUnique || isEmpty(suffixDef) || currPathPrefix.length === k) {\n                    const currAltResult = finalResult[altIdx];\n                    // TODO: Can we implement a containsPath using Maps/Dictionaries?\n                    if (containsPath(currAltResult, currPathPrefix) === false) {\n                        currAltResult.push(currPathPrefix);\n                        // Update all new  keys for the current path.\n                        for (let j = 0; j < prefixKeys.length; j++) {\n                            const currKey = prefixKeys[j];\n                            altsHashes[altIdx][currKey] = true;\n                        }\n                    }\n                }\n                // Expand longer paths\n                else {\n                    const newPartialPathsAndSuffixes = possiblePathsFrom(suffixDef, pathLength + 1, currPathPrefix);\n                    newData[altIdx] = newData[altIdx].concat(newPartialPathsAndSuffixes);\n                    // Update keys for new known paths\n                    forEach(newPartialPathsAndSuffixes, (item) => {\n                        const prefixKeys = pathToHashKeys(item.partialPath);\n                        forEach(prefixKeys, (key) => {\n                            altsHashes[altIdx][key] = true;\n                        });\n                    });\n                }\n            }\n        }\n    }\n    return finalResult;\n}\nexport function getLookaheadPathsForOr(occurrence, ruleGrammar, k, orProd) {\n    const visitor = new InsideDefinitionFinderVisitor(occurrence, PROD_TYPE.ALTERNATION, orProd);\n    ruleGrammar.accept(visitor);\n    return lookAheadSequenceFromAlternatives(visitor.result, k);\n}\nexport function getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, k) {\n    const insideDefVisitor = new InsideDefinitionFinderVisitor(occurrence, prodType);\n    ruleGrammar.accept(insideDefVisitor);\n    const insideDef = insideDefVisitor.result;\n    const afterDefWalker = new RestDefinitionFinderWalker(ruleGrammar, occurrence, prodType);\n    const afterDef = afterDefWalker.startWalking();\n    const insideFlat = new AlternativeGAST({ definition: insideDef });\n    const afterFlat = new AlternativeGAST({ definition: afterDef });\n    return lookAheadSequenceFromAlternatives([insideFlat, afterFlat], k);\n}\nexport function containsPath(alternative, searchPath) {\n    compareOtherPath: for (let i = 0; i < alternative.length; i++) {\n        const otherPath = alternative[i];\n        if (otherPath.length !== searchPath.length) {\n            continue;\n        }\n        for (let j = 0; j < otherPath.length; j++) {\n            const searchTok = searchPath[j];\n            const otherTok = otherPath[j];\n            const matchingTokens = searchTok === otherTok ||\n                otherTok.categoryMatchesMap[searchTok.tokenTypeIdx] !== undefined;\n            if (matchingTokens === false) {\n                continue compareOtherPath;\n            }\n        }\n        return true;\n    }\n    return false;\n}\nexport function isStrictPrefixOfPath(prefix, other) {\n    return (prefix.length < other.length &&\n        every(prefix, (tokType, idx) => {\n            const otherTokType = other[idx];\n            return (tokType === otherTokType ||\n                otherTokType.categoryMatchesMap[tokType.tokenTypeIdx]);\n        }));\n}\nexport function areTokenCategoriesNotUsed(lookAheadPaths) {\n    return every(lookAheadPaths, (singleAltPaths) => every(singleAltPaths, (singlePath) => every(singlePath, (token) => isEmpty(token.categoryMatches))));\n}\n//# sourceMappingURL=lookahead.js.map","import { clone, compact, difference, drop, dropRight, filter, first, flatMap, flatten, forEach, groupBy, includes, isEmpty, map, pickBy, reduce, reject, values, } from \"lodash-es\";\nimport { ParserDefinitionErrorType, } from \"../parser/parser.js\";\nimport { Alternation, Alternative as AlternativeGAST, GAstVisitor, getProductionDslName, isOptionalProd, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Terminal, } from \"@chevrotain/gast\";\nimport { containsPath, getLookaheadPathsForOptionalProd, getLookaheadPathsForOr, getProdType, isStrictPrefixOfPath, } from \"./lookahead.js\";\nimport { nextPossibleTokensAfter } from \"./interpreter.js\";\nimport { tokenStructuredMatcher } from \"../../scan/tokens.js\";\nexport function validateLookahead(options) {\n    const lookaheadValidationErrorMessages = options.lookaheadStrategy.validate({\n        rules: options.rules,\n        tokenTypes: options.tokenTypes,\n        grammarName: options.grammarName,\n    });\n    return map(lookaheadValidationErrorMessages, (errorMessage) => (Object.assign({ type: ParserDefinitionErrorType.CUSTOM_LOOKAHEAD_VALIDATION }, errorMessage)));\n}\nexport function validateGrammar(topLevels, tokenTypes, errMsgProvider, grammarName) {\n    const duplicateErrors = flatMap(topLevels, (currTopLevel) => validateDuplicateProductions(currTopLevel, errMsgProvider));\n    const termsNamespaceConflictErrors = checkTerminalAndNoneTerminalsNameSpace(topLevels, tokenTypes, errMsgProvider);\n    const tooManyAltsErrors = flatMap(topLevels, (curRule) => validateTooManyAlts(curRule, errMsgProvider));\n    const duplicateRulesError = flatMap(topLevels, (curRule) => validateRuleDoesNotAlreadyExist(curRule, topLevels, grammarName, errMsgProvider));\n    return duplicateErrors.concat(termsNamespaceConflictErrors, tooManyAltsErrors, duplicateRulesError);\n}\nfunction validateDuplicateProductions(topLevelRule, errMsgProvider) {\n    const collectorVisitor = new OccurrenceValidationCollector();\n    topLevelRule.accept(collectorVisitor);\n    const allRuleProductions = collectorVisitor.allProductions;\n    const productionGroups = groupBy(allRuleProductions, identifyProductionForDuplicates);\n    const duplicates = pickBy(productionGroups, (currGroup) => {\n        return currGroup.length > 1;\n    });\n    const errors = map(values(duplicates), (currDuplicates) => {\n        const firstProd = first(currDuplicates);\n        const msg = errMsgProvider.buildDuplicateFoundError(topLevelRule, currDuplicates);\n        const dslName = getProductionDslName(firstProd);\n        const defError = {\n            message: msg,\n            type: ParserDefinitionErrorType.DUPLICATE_PRODUCTIONS,\n            ruleName: topLevelRule.name,\n            dslName: dslName,\n            occurrence: firstProd.idx,\n        };\n        const param = getExtraProductionArgument(firstProd);\n        if (param) {\n            defError.parameter = param;\n        }\n        return defError;\n    });\n    return errors;\n}\nexport function identifyProductionForDuplicates(prod) {\n    return `${getProductionDslName(prod)}_#_${prod.idx}_#_${getExtraProductionArgument(prod)}`;\n}\nfunction getExtraProductionArgument(prod) {\n    if (prod instanceof Terminal) {\n        return prod.terminalType.name;\n    }\n    else if (prod instanceof NonTerminal) {\n        return prod.nonTerminalName;\n    }\n    else {\n        return \"\";\n    }\n}\nexport class OccurrenceValidationCollector extends GAstVisitor {\n    constructor() {\n        super(...arguments);\n        this.allProductions = [];\n    }\n    visitNonTerminal(subrule) {\n        this.allProductions.push(subrule);\n    }\n    visitOption(option) {\n        this.allProductions.push(option);\n    }\n    visitRepetitionWithSeparator(manySep) {\n        this.allProductions.push(manySep);\n    }\n    visitRepetitionMandatory(atLeastOne) {\n        this.allProductions.push(atLeastOne);\n    }\n    visitRepetitionMandatoryWithSeparator(atLeastOneSep) {\n        this.allProductions.push(atLeastOneSep);\n    }\n    visitRepetition(many) {\n        this.allProductions.push(many);\n    }\n    visitAlternation(or) {\n        this.allProductions.push(or);\n    }\n    visitTerminal(terminal) {\n        this.allProductions.push(terminal);\n    }\n}\nexport function validateRuleDoesNotAlreadyExist(rule, allRules, className, errMsgProvider) {\n    const errors = [];\n    const occurrences = reduce(allRules, (result, curRule) => {\n        if (curRule.name === rule.name) {\n            return result + 1;\n        }\n        return result;\n    }, 0);\n    if (occurrences > 1) {\n        const errMsg = errMsgProvider.buildDuplicateRuleNameError({\n            topLevelRule: rule,\n            grammarName: className,\n        });\n        errors.push({\n            message: errMsg,\n            type: ParserDefinitionErrorType.DUPLICATE_RULE_NAME,\n            ruleName: rule.name,\n        });\n    }\n    return errors;\n}\n// TODO: is there anyway to get only the rule names of rules inherited from the super grammars?\n// This is not part of the IGrammarErrorProvider because the validation cannot be performed on\n// The grammar structure, only at runtime.\nexport function validateRuleIsOverridden(ruleName, definedRulesNames, className) {\n    const errors = [];\n    let errMsg;\n    if (!includes(definedRulesNames, ruleName)) {\n        errMsg =\n            `Invalid rule override, rule: ->${ruleName}<- cannot be overridden in the grammar: ->${className}<-` +\n                `as it is not defined in any of the super grammars `;\n        errors.push({\n            message: errMsg,\n            type: ParserDefinitionErrorType.INVALID_RULE_OVERRIDE,\n            ruleName: ruleName,\n        });\n    }\n    return errors;\n}\nexport function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path = []) {\n    const errors = [];\n    const nextNonTerminals = getFirstNoneTerminal(currRule.definition);\n    if (isEmpty(nextNonTerminals)) {\n        return [];\n    }\n    else {\n        const ruleName = topRule.name;\n        const foundLeftRecursion = includes(nextNonTerminals, topRule);\n        if (foundLeftRecursion) {\n            errors.push({\n                message: errMsgProvider.buildLeftRecursionError({\n                    topLevelRule: topRule,\n                    leftRecursionPath: path,\n                }),\n                type: ParserDefinitionErrorType.LEFT_RECURSION,\n                ruleName: ruleName,\n            });\n        }\n        // we are only looking for cyclic paths leading back to the specific topRule\n        // other cyclic paths are ignored, we still need this difference to avoid infinite loops...\n        const validNextSteps = difference(nextNonTerminals, path.concat([topRule]));\n        const errorsFromNextSteps = flatMap(validNextSteps, (currRefRule) => {\n            const newPath = clone(path);\n            newPath.push(currRefRule);\n            return validateNoLeftRecursion(topRule, currRefRule, errMsgProvider, newPath);\n        });\n        return errors.concat(errorsFromNextSteps);\n    }\n}\nexport function getFirstNoneTerminal(definition) {\n    let result = [];\n    if (isEmpty(definition)) {\n        return result;\n    }\n    const firstProd = first(definition);\n    /* istanbul ignore else */\n    if (firstProd instanceof NonTerminal) {\n        result.push(firstProd.referencedRule);\n    }\n    else if (firstProd instanceof AlternativeGAST ||\n        firstProd instanceof Option ||\n        firstProd instanceof RepetitionMandatory ||\n        firstProd instanceof RepetitionMandatoryWithSeparator ||\n        firstProd instanceof RepetitionWithSeparator ||\n        firstProd instanceof Repetition) {\n        result = result.concat(getFirstNoneTerminal(firstProd.definition));\n    }\n    else if (firstProd instanceof Alternation) {\n        // each sub definition in alternation is a FLAT\n        result = flatten(map(firstProd.definition, (currSubDef) => getFirstNoneTerminal(currSubDef.definition)));\n    }\n    else if (firstProd instanceof Terminal) {\n        // nothing to see, move along\n    }\n    else {\n        throw Error(\"non exhaustive match\");\n    }\n    const isFirstOptional = isOptionalProd(firstProd);\n    const hasMore = definition.length > 1;\n    if (isFirstOptional && hasMore) {\n        const rest = drop(definition);\n        return result.concat(getFirstNoneTerminal(rest));\n    }\n    else {\n        return result;\n    }\n}\nclass OrCollector extends GAstVisitor {\n    constructor() {\n        super(...arguments);\n        this.alternations = [];\n    }\n    visitAlternation(node) {\n        this.alternations.push(node);\n    }\n}\nexport function validateEmptyOrAlternative(topLevelRule, errMsgProvider) {\n    const orCollector = new OrCollector();\n    topLevelRule.accept(orCollector);\n    const ors = orCollector.alternations;\n    const errors = flatMap(ors, (currOr) => {\n        const exceptLast = dropRight(currOr.definition);\n        return flatMap(exceptLast, (currAlternative, currAltIdx) => {\n            const possibleFirstInAlt = nextPossibleTokensAfter([currAlternative], [], tokenStructuredMatcher, 1);\n            if (isEmpty(possibleFirstInAlt)) {\n                return [\n                    {\n                        message: errMsgProvider.buildEmptyAlternationError({\n                            topLevelRule: topLevelRule,\n                            alternation: currOr,\n                            emptyChoiceIdx: currAltIdx,\n                        }),\n                        type: ParserDefinitionErrorType.NONE_LAST_EMPTY_ALT,\n                        ruleName: topLevelRule.name,\n                        occurrence: currOr.idx,\n                        alternative: currAltIdx + 1,\n                    },\n                ];\n            }\n            else {\n                return [];\n            }\n        });\n    });\n    return errors;\n}\nexport function validateAmbiguousAlternationAlternatives(topLevelRule, globalMaxLookahead, errMsgProvider) {\n    const orCollector = new OrCollector();\n    topLevelRule.accept(orCollector);\n    let ors = orCollector.alternations;\n    // New Handling of ignoring ambiguities\n    // - https://github.com/chevrotain/chevrotain/issues/869\n    ors = reject(ors, (currOr) => currOr.ignoreAmbiguities === true);\n    const errors = flatMap(ors, (currOr) => {\n        const currOccurrence = currOr.idx;\n        const actualMaxLookahead = currOr.maxLookahead || globalMaxLookahead;\n        const alternatives = getLookaheadPathsForOr(currOccurrence, topLevelRule, actualMaxLookahead, currOr);\n        const altsAmbiguityErrors = checkAlternativesAmbiguities(alternatives, currOr, topLevelRule, errMsgProvider);\n        const altsPrefixAmbiguityErrors = checkPrefixAlternativesAmbiguities(alternatives, currOr, topLevelRule, errMsgProvider);\n        return altsAmbiguityErrors.concat(altsPrefixAmbiguityErrors);\n    });\n    return errors;\n}\nexport class RepetitionCollector extends GAstVisitor {\n    constructor() {\n        super(...arguments);\n        this.allProductions = [];\n    }\n    visitRepetitionWithSeparator(manySep) {\n        this.allProductions.push(manySep);\n    }\n    visitRepetitionMandatory(atLeastOne) {\n        this.allProductions.push(atLeastOne);\n    }\n    visitRepetitionMandatoryWithSeparator(atLeastOneSep) {\n        this.allProductions.push(atLeastOneSep);\n    }\n    visitRepetition(many) {\n        this.allProductions.push(many);\n    }\n}\nexport function validateTooManyAlts(topLevelRule, errMsgProvider) {\n    const orCollector = new OrCollector();\n    topLevelRule.accept(orCollector);\n    const ors = orCollector.alternations;\n    const errors = flatMap(ors, (currOr) => {\n        if (currOr.definition.length > 255) {\n            return [\n                {\n                    message: errMsgProvider.buildTooManyAlternativesError({\n                        topLevelRule: topLevelRule,\n                        alternation: currOr,\n                    }),\n                    type: ParserDefinitionErrorType.TOO_MANY_ALTS,\n                    ruleName: topLevelRule.name,\n                    occurrence: currOr.idx,\n                },\n            ];\n        }\n        else {\n            return [];\n        }\n    });\n    return errors;\n}\nexport function validateSomeNonEmptyLookaheadPath(topLevelRules, maxLookahead, errMsgProvider) {\n    const errors = [];\n    forEach(topLevelRules, (currTopRule) => {\n        const collectorVisitor = new RepetitionCollector();\n        currTopRule.accept(collectorVisitor);\n        const allRuleProductions = collectorVisitor.allProductions;\n        forEach(allRuleProductions, (currProd) => {\n            const prodType = getProdType(currProd);\n            const actualMaxLookahead = currProd.maxLookahead || maxLookahead;\n            const currOccurrence = currProd.idx;\n            const paths = getLookaheadPathsForOptionalProd(currOccurrence, currTopRule, prodType, actualMaxLookahead);\n            const pathsInsideProduction = paths[0];\n            if (isEmpty(flatten(pathsInsideProduction))) {\n                const errMsg = errMsgProvider.buildEmptyRepetitionError({\n                    topLevelRule: currTopRule,\n                    repetition: currProd,\n                });\n                errors.push({\n                    message: errMsg,\n                    type: ParserDefinitionErrorType.NO_NON_EMPTY_LOOKAHEAD,\n                    ruleName: currTopRule.name,\n                });\n            }\n        });\n    });\n    return errors;\n}\nfunction checkAlternativesAmbiguities(alternatives, alternation, rule, errMsgProvider) {\n    const foundAmbiguousPaths = [];\n    const identicalAmbiguities = reduce(alternatives, (result, currAlt, currAltIdx) => {\n        // ignore (skip) ambiguities with this alternative\n        if (alternation.definition[currAltIdx].ignoreAmbiguities === true) {\n            return result;\n        }\n        forEach(currAlt, (currPath) => {\n            const altsCurrPathAppearsIn = [currAltIdx];\n            forEach(alternatives, (currOtherAlt, currOtherAltIdx) => {\n                if (currAltIdx !== currOtherAltIdx &&\n                    containsPath(currOtherAlt, currPath) &&\n                    // ignore (skip) ambiguities with this \"other\" alternative\n                    alternation.definition[currOtherAltIdx].ignoreAmbiguities !== true) {\n                    altsCurrPathAppearsIn.push(currOtherAltIdx);\n                }\n            });\n            if (altsCurrPathAppearsIn.length > 1 &&\n                !containsPath(foundAmbiguousPaths, currPath)) {\n                foundAmbiguousPaths.push(currPath);\n                result.push({\n                    alts: altsCurrPathAppearsIn,\n                    path: currPath,\n                });\n            }\n        });\n        return result;\n    }, []);\n    const currErrors = map(identicalAmbiguities, (currAmbDescriptor) => {\n        const ambgIndices = map(currAmbDescriptor.alts, (currAltIdx) => currAltIdx + 1);\n        const currMessage = errMsgProvider.buildAlternationAmbiguityError({\n            topLevelRule: rule,\n            alternation: alternation,\n            ambiguityIndices: ambgIndices,\n            prefixPath: currAmbDescriptor.path,\n        });\n        return {\n            message: currMessage,\n            type: ParserDefinitionErrorType.AMBIGUOUS_ALTS,\n            ruleName: rule.name,\n            occurrence: alternation.idx,\n            alternatives: currAmbDescriptor.alts,\n        };\n    });\n    return currErrors;\n}\nexport function checkPrefixAlternativesAmbiguities(alternatives, alternation, rule, errMsgProvider) {\n    // flatten\n    const pathsAndIndices = reduce(alternatives, (result, currAlt, idx) => {\n        const currPathsAndIdx = map(currAlt, (currPath) => {\n            return { idx: idx, path: currPath };\n        });\n        return result.concat(currPathsAndIdx);\n    }, []);\n    const errors = compact(flatMap(pathsAndIndices, (currPathAndIdx) => {\n        const alternativeGast = alternation.definition[currPathAndIdx.idx];\n        // ignore (skip) ambiguities with this alternative\n        if (alternativeGast.ignoreAmbiguities === true) {\n            return [];\n        }\n        const targetIdx = currPathAndIdx.idx;\n        const targetPath = currPathAndIdx.path;\n        const prefixAmbiguitiesPathsAndIndices = filter(pathsAndIndices, (searchPathAndIdx) => {\n            // prefix ambiguity can only be created from lower idx (higher priority) path\n            return (\n            // ignore (skip) ambiguities with this \"other\" alternative\n            alternation.definition[searchPathAndIdx.idx].ignoreAmbiguities !==\n                true &&\n                searchPathAndIdx.idx < targetIdx &&\n                // checking for strict prefix because identical lookaheads\n                // will be be detected using a different validation.\n                isStrictPrefixOfPath(searchPathAndIdx.path, targetPath));\n        });\n        const currPathPrefixErrors = map(prefixAmbiguitiesPathsAndIndices, (currAmbPathAndIdx) => {\n            const ambgIndices = [currAmbPathAndIdx.idx + 1, targetIdx + 1];\n            const occurrence = alternation.idx === 0 ? \"\" : alternation.idx;\n            const message = errMsgProvider.buildAlternationPrefixAmbiguityError({\n                topLevelRule: rule,\n                alternation: alternation,\n                ambiguityIndices: ambgIndices,\n                prefixPath: currAmbPathAndIdx.path,\n            });\n            return {\n                message: message,\n                type: ParserDefinitionErrorType.AMBIGUOUS_PREFIX_ALTS,\n                ruleName: rule.name,\n                occurrence: occurrence,\n                alternatives: ambgIndices,\n            };\n        });\n        return currPathPrefixErrors;\n    }));\n    return errors;\n}\nfunction checkTerminalAndNoneTerminalsNameSpace(topLevels, tokenTypes, errMsgProvider) {\n    const errors = [];\n    const tokenNames = map(tokenTypes, (currToken) => currToken.name);\n    forEach(topLevels, (currRule) => {\n        const currRuleName = currRule.name;\n        if (includes(tokenNames, currRuleName)) {\n            const errMsg = errMsgProvider.buildNamespaceConflictError(currRule);\n            errors.push({\n                message: errMsg,\n                type: ParserDefinitionErrorType.CONFLICT_TOKENS_RULES_NAMESPACE,\n                ruleName: currRuleName,\n            });\n        }\n    });\n    return errors;\n}\n//# sourceMappingURL=checks.js.map","import { includes } from \"lodash-es\";\nconst MISMATCHED_TOKEN_EXCEPTION = \"MismatchedTokenException\";\nconst NO_VIABLE_ALT_EXCEPTION = \"NoViableAltException\";\nconst EARLY_EXIT_EXCEPTION = \"EarlyExitException\";\nconst NOT_ALL_INPUT_PARSED_EXCEPTION = \"NotAllInputParsedException\";\nconst RECOGNITION_EXCEPTION_NAMES = [\n    MISMATCHED_TOKEN_EXCEPTION,\n    NO_VIABLE_ALT_EXCEPTION,\n    EARLY_EXIT_EXCEPTION,\n    NOT_ALL_INPUT_PARSED_EXCEPTION,\n];\nObject.freeze(RECOGNITION_EXCEPTION_NAMES);\n// hacks to bypass no support for custom Errors in javascript/typescript\nexport function isRecognitionException(error) {\n    // can't do instanceof on hacked custom js exceptions\n    return includes(RECOGNITION_EXCEPTION_NAMES, error.name);\n}\nclass RecognitionException extends Error {\n    constructor(message, token) {\n        super(message);\n        this.token = token;\n        this.resyncedTokens = [];\n        // fix prototype chain when typescript target is ES5\n        Object.setPrototypeOf(this, new.target.prototype);\n        /* istanbul ignore next - V8 workaround to remove constructor from stacktrace when typescript target is ES5 */\n        if (Error.captureStackTrace) {\n            Error.captureStackTrace(this, this.constructor);\n        }\n    }\n}\nexport class MismatchedTokenException extends RecognitionException {\n    constructor(message, token, previousToken) {\n        super(message, token);\n        this.previousToken = previousToken;\n        this.name = MISMATCHED_TOKEN_EXCEPTION;\n    }\n}\nexport class NoViableAltException extends RecognitionException {\n    constructor(message, token, previousToken) {\n        super(message, token);\n        this.previousToken = previousToken;\n        this.name = NO_VIABLE_ALT_EXCEPTION;\n    }\n}\nexport class NotAllInputParsedException extends RecognitionException {\n    constructor(message, token) {\n        super(message, token);\n        this.name = NOT_ALL_INPUT_PARSED_EXCEPTION;\n    }\n}\nexport class EarlyExitException extends RecognitionException {\n    constructor(message, token, previousToken) {\n        super(message, token);\n        this.previousToken = previousToken;\n        this.name = EARLY_EXIT_EXCEPTION;\n    }\n}\n//# sourceMappingURL=exceptions_public.js.map","import { createTokenInstance, EOF, tokenMatcher, } from \"../../../scan/tokens_public.js\";\nimport { clone, dropRight, find, flatten, has, includes, isEmpty, map, } from \"lodash-es\";\nimport { MismatchedTokenException } from \"../../exceptions_public.js\";\nimport { IN } from \"../../constants.js\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser.js\";\nexport const EOF_FOLLOW_KEY = {};\nexport const IN_RULE_RECOVERY_EXCEPTION = \"InRuleRecoveryException\";\nexport class InRuleRecoveryException extends Error {\n    constructor(message) {\n        super(message);\n        this.name = IN_RULE_RECOVERY_EXCEPTION;\n    }\n}\n/**\n * This trait is responsible for the error recovery and fault tolerant logic\n */\nexport class Recoverable {\n    initRecoverable(config) {\n        this.firstAfterRepMap = {};\n        this.resyncFollows = {};\n        this.recoveryEnabled = has(config, \"recoveryEnabled\")\n            ? config.recoveryEnabled // assumes end user provides the correct config value/type\n            : DEFAULT_PARSER_CONFIG.recoveryEnabled;\n        // performance optimization, NOOP will be inlined which\n        // effectively means that this optional feature does not exist\n        // when not used.\n        if (this.recoveryEnabled) {\n            this.attemptInRepetitionRecovery = attemptInRepetitionRecovery;\n        }\n    }\n    getTokenToInsert(tokType) {\n        const tokToInsert = createTokenInstance(tokType, \"\", NaN, NaN, NaN, NaN, NaN, NaN);\n        tokToInsert.isInsertedInRecovery = true;\n        return tokToInsert;\n    }\n    canTokenTypeBeInsertedInRecovery(tokType) {\n        return true;\n    }\n    canTokenTypeBeDeletedInRecovery(tokType) {\n        return true;\n    }\n    tryInRepetitionRecovery(grammarRule, grammarRuleArgs, lookAheadFunc, expectedTokType) {\n        // TODO: can the resyncTokenType be cached?\n        const reSyncTokType = this.findReSyncTokenType();\n        const savedLexerState = this.exportLexerState();\n        const resyncedTokens = [];\n        let passedResyncPoint = false;\n        const nextTokenWithoutResync = this.LA(1);\n        let currToken = this.LA(1);\n        const generateErrorMessage = () => {\n            const previousToken = this.LA(0);\n            // we are preemptively re-syncing before an error has been detected, therefor we must reproduce\n            // the error that would have been thrown\n            const msg = this.errorMessageProvider.buildMismatchTokenMessage({\n                expected: expectedTokType,\n                actual: nextTokenWithoutResync,\n                previous: previousToken,\n                ruleName: this.getCurrRuleFullName(),\n            });\n            const error = new MismatchedTokenException(msg, nextTokenWithoutResync, this.LA(0));\n            // the first token here will be the original cause of the error, this is not part of the resyncedTokens property.\n            error.resyncedTokens = dropRight(resyncedTokens);\n            this.SAVE_ERROR(error);\n        };\n        while (!passedResyncPoint) {\n            // re-synced to a point where we can safely exit the repetition/\n            if (this.tokenMatcher(currToken, expectedTokType)) {\n                generateErrorMessage();\n                return; // must return here to avoid reverting the inputIdx\n            }\n            else if (lookAheadFunc.call(this)) {\n                // we skipped enough tokens so we can resync right back into another iteration of the repetition grammar rule\n                generateErrorMessage();\n                // recursive invocation in other to support multiple re-syncs in the same top level repetition grammar rule\n                grammarRule.apply(this, grammarRuleArgs);\n                return; // must return here to avoid reverting the inputIdx\n            }\n            else if (this.tokenMatcher(currToken, reSyncTokType)) {\n                passedResyncPoint = true;\n            }\n            else {\n                currToken = this.SKIP_TOKEN();\n                this.addToResyncTokens(currToken, resyncedTokens);\n            }\n        }\n        // we were unable to find a CLOSER point to resync inside the Repetition, reset the state.\n        // The parsing exception we were trying to prevent will happen in the NEXT parsing step. it may be handled by\n        // \"between rules\" resync recovery later in the flow.\n        this.importLexerState(savedLexerState);\n    }\n    shouldInRepetitionRecoveryBeTried(expectTokAfterLastMatch, nextTokIdx, notStuck) {\n        // Edge case of arriving from a MANY repetition which is stuck\n        // Attempting recovery in this case could cause an infinite loop\n        if (notStuck === false) {\n            return false;\n        }\n        // no need to recover, next token is what we expect...\n        if (this.tokenMatcher(this.LA(1), expectTokAfterLastMatch)) {\n            return false;\n        }\n        // error recovery is disabled during backtracking as it can make the parser ignore a valid grammar path\n        // and prefer some backtracking path that includes recovered errors.\n        if (this.isBackTracking()) {\n            return false;\n        }\n        // if we can perform inRule recovery (single token insertion or deletion) we always prefer that recovery algorithm\n        // because if it works, it makes the least amount of changes to the input stream (greedy algorithm)\n        //noinspection RedundantIfStatementJS\n        if (this.canPerformInRuleRecovery(expectTokAfterLastMatch, this.getFollowsForInRuleRecovery(expectTokAfterLastMatch, nextTokIdx))) {\n            return false;\n        }\n        return true;\n    }\n    // Error Recovery functionality\n    getFollowsForInRuleRecovery(tokType, tokIdxInRule) {\n        const grammarPath = this.getCurrentGrammarPath(tokType, tokIdxInRule);\n        const follows = this.getNextPossibleTokenTypes(grammarPath);\n        return follows;\n    }\n    tryInRuleRecovery(expectedTokType, follows) {\n        if (this.canRecoverWithSingleTokenInsertion(expectedTokType, follows)) {\n            const tokToInsert = this.getTokenToInsert(expectedTokType);\n            return tokToInsert;\n        }\n        if (this.canRecoverWithSingleTokenDeletion(expectedTokType)) {\n            const nextTok = this.SKIP_TOKEN();\n            this.consumeToken();\n            return nextTok;\n        }\n        throw new InRuleRecoveryException(\"sad sad panda\");\n    }\n    canPerformInRuleRecovery(expectedToken, follows) {\n        return (this.canRecoverWithSingleTokenInsertion(expectedToken, follows) ||\n            this.canRecoverWithSingleTokenDeletion(expectedToken));\n    }\n    canRecoverWithSingleTokenInsertion(expectedTokType, follows) {\n        if (!this.canTokenTypeBeInsertedInRecovery(expectedTokType)) {\n            return false;\n        }\n        // must know the possible following tokens to perform single token insertion\n        if (isEmpty(follows)) {\n            return false;\n        }\n        const mismatchedTok = this.LA(1);\n        const isMisMatchedTokInFollows = find(follows, (possibleFollowsTokType) => {\n            return this.tokenMatcher(mismatchedTok, possibleFollowsTokType);\n        }) !== undefined;\n        return isMisMatchedTokInFollows;\n    }\n    canRecoverWithSingleTokenDeletion(expectedTokType) {\n        if (!this.canTokenTypeBeDeletedInRecovery(expectedTokType)) {\n            return false;\n        }\n        const isNextTokenWhatIsExpected = this.tokenMatcher(this.LA(2), expectedTokType);\n        return isNextTokenWhatIsExpected;\n    }\n    isInCurrentRuleReSyncSet(tokenTypeIdx) {\n        const followKey = this.getCurrFollowKey();\n        const currentRuleReSyncSet = this.getFollowSetFromFollowKey(followKey);\n        return includes(currentRuleReSyncSet, tokenTypeIdx);\n    }\n    findReSyncTokenType() {\n        const allPossibleReSyncTokTypes = this.flattenFollowSet();\n        // this loop will always terminate as EOF is always in the follow stack and also always (virtually) in the input\n        let nextToken = this.LA(1);\n        let k = 2;\n        while (true) {\n            const foundMatch = find(allPossibleReSyncTokTypes, (resyncTokType) => {\n                const canMatch = tokenMatcher(nextToken, resyncTokType);\n                return canMatch;\n            });\n            if (foundMatch !== undefined) {\n                return foundMatch;\n            }\n            nextToken = this.LA(k);\n            k++;\n        }\n    }\n    getCurrFollowKey() {\n        // the length is at least one as we always add the ruleName to the stack before invoking the rule.\n        if (this.RULE_STACK.length === 1) {\n            return EOF_FOLLOW_KEY;\n        }\n        const currRuleShortName = this.getLastExplicitRuleShortName();\n        const currRuleIdx = this.getLastExplicitRuleOccurrenceIndex();\n        const prevRuleShortName = this.getPreviousExplicitRuleShortName();\n        return {\n            ruleName: this.shortRuleNameToFullName(currRuleShortName),\n            idxInCallingRule: currRuleIdx,\n            inRule: this.shortRuleNameToFullName(prevRuleShortName),\n        };\n    }\n    buildFullFollowKeyStack() {\n        const explicitRuleStack = this.RULE_STACK;\n        const explicitOccurrenceStack = this.RULE_OCCURRENCE_STACK;\n        return map(explicitRuleStack, (ruleName, idx) => {\n            if (idx === 0) {\n                return EOF_FOLLOW_KEY;\n            }\n            return {\n                ruleName: this.shortRuleNameToFullName(ruleName),\n                idxInCallingRule: explicitOccurrenceStack[idx],\n                inRule: this.shortRuleNameToFullName(explicitRuleStack[idx - 1]),\n            };\n        });\n    }\n    flattenFollowSet() {\n        const followStack = map(this.buildFullFollowKeyStack(), (currKey) => {\n            return this.getFollowSetFromFollowKey(currKey);\n        });\n        return flatten(followStack);\n    }\n    getFollowSetFromFollowKey(followKey) {\n        if (followKey === EOF_FOLLOW_KEY) {\n            return [EOF];\n        }\n        const followName = followKey.ruleName + followKey.idxInCallingRule + IN + followKey.inRule;\n        return this.resyncFollows[followName];\n    }\n    // It does not make any sense to include a virtual EOF token in the list of resynced tokens\n    // as EOF does not really exist and thus does not contain any useful information (line/column numbers)\n    addToResyncTokens(token, resyncTokens) {\n        if (!this.tokenMatcher(token, EOF)) {\n            resyncTokens.push(token);\n        }\n        return resyncTokens;\n    }\n    reSyncTo(tokType) {\n        const resyncedTokens = [];\n        let nextTok = this.LA(1);\n        while (this.tokenMatcher(nextTok, tokType) === false) {\n            nextTok = this.SKIP_TOKEN();\n            this.addToResyncTokens(nextTok, resyncedTokens);\n        }\n        // the last token is not part of the error.\n        return dropRight(resyncedTokens);\n    }\n    attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, dslMethodIdx, prodOccurrence, nextToksWalker, notStuck) {\n        // by default this is a NO-OP\n        // The actual implementation is with the function(not method) below\n    }\n    getCurrentGrammarPath(tokType, tokIdxInRule) {\n        const pathRuleStack = this.getHumanReadableRuleStack();\n        const pathOccurrenceStack = clone(this.RULE_OCCURRENCE_STACK);\n        const grammarPath = {\n            ruleStack: pathRuleStack,\n            occurrenceStack: pathOccurrenceStack,\n            lastTok: tokType,\n            lastTokOccurrence: tokIdxInRule,\n        };\n        return grammarPath;\n    }\n    getHumanReadableRuleStack() {\n        return map(this.RULE_STACK, (currShortName) => this.shortRuleNameToFullName(currShortName));\n    }\n}\nexport function attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, dslMethodIdx, prodOccurrence, nextToksWalker, notStuck) {\n    const key = this.getKeyForAutomaticLookahead(dslMethodIdx, prodOccurrence);\n    let firstAfterRepInfo = this.firstAfterRepMap[key];\n    if (firstAfterRepInfo === undefined) {\n        const currRuleName = this.getCurrRuleFullName();\n        const ruleGrammar = this.getGAstProductions()[currRuleName];\n        const walker = new nextToksWalker(ruleGrammar, prodOccurrence);\n        firstAfterRepInfo = walker.startWalking();\n        this.firstAfterRepMap[key] = firstAfterRepInfo;\n    }\n    let expectTokAfterLastMatch = firstAfterRepInfo.token;\n    let nextTokIdx = firstAfterRepInfo.occurrence;\n    const isEndOfRule = firstAfterRepInfo.isEndOfRule;\n    // special edge case of a TOP most repetition after which the input should END.\n    // this will force an attempt for inRule recovery in that scenario.\n    if (this.RULE_STACK.length === 1 &&\n        isEndOfRule &&\n        expectTokAfterLastMatch === undefined) {\n        expectTokAfterLastMatch = EOF;\n        nextTokIdx = 1;\n    }\n    // We don't have anything to re-sync to...\n    // this condition was extracted from `shouldInRepetitionRecoveryBeTried` to act as a type-guard\n    if (expectTokAfterLastMatch === undefined || nextTokIdx === undefined) {\n        return;\n    }\n    if (this.shouldInRepetitionRecoveryBeTried(expectTokAfterLastMatch, nextTokIdx, notStuck)) {\n        // TODO: performance optimization: instead of passing the original args here, we modify\n        // the args param (or create a new one) and make sure the lookahead func is explicitly provided\n        // to avoid searching the cache for it once more.\n        this.tryInRepetitionRecovery(prodFunc, args, lookaheadFunc, expectTokAfterLastMatch);\n    }\n}\n//# sourceMappingURL=recoverable.js.map","// Lookahead keys are 32Bit integers in the form\n// TTTTTTTT-ZZZZZZZZZZZZ-YYYY-XXXXXXXX\n// XXXX -> Occurrence Index bitmap.\n// YYYY -> DSL Method Type bitmap.\n// ZZZZZZZZZZZZZZZ -> Rule short Index bitmap.\n// TTTTTTTTT -> alternation alternative index bitmap\nexport const BITS_FOR_METHOD_TYPE = 4;\nexport const BITS_FOR_OCCURRENCE_IDX = 8;\nexport const BITS_FOR_RULE_IDX = 12;\n// TODO: validation, this means that there may at most 2^8 --> 256 alternatives for an alternation.\nexport const BITS_FOR_ALT_IDX = 8;\n// short string used as part of mapping keys.\n// being short improves the performance when composing KEYS for maps out of these\n// The 5 - 8 bits (16 possible values, are reserved for the DSL method indices)\nexport const OR_IDX = 1 << BITS_FOR_OCCURRENCE_IDX;\nexport const OPTION_IDX = 2 << BITS_FOR_OCCURRENCE_IDX;\nexport const MANY_IDX = 3 << BITS_FOR_OCCURRENCE_IDX;\nexport const AT_LEAST_ONE_IDX = 4 << BITS_FOR_OCCURRENCE_IDX;\nexport const MANY_SEP_IDX = 5 << BITS_FOR_OCCURRENCE_IDX;\nexport const AT_LEAST_ONE_SEP_IDX = 6 << BITS_FOR_OCCURRENCE_IDX;\n// this actually returns a number, but it is always used as a string (object prop key)\nexport function getKeyForAutomaticLookahead(ruleIdx, dslMethodIdx, occurrence) {\n    return occurrence | dslMethodIdx | ruleIdx;\n}\nconst BITS_START_FOR_ALT_IDX = 32 - BITS_FOR_ALT_IDX;\n//# sourceMappingURL=keys.js.map","import { flatMap, isEmpty } from \"lodash-es\";\nimport { defaultGrammarValidatorErrorProvider } from \"../errors_public.js\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser/parser.js\";\nimport { validateAmbiguousAlternationAlternatives, validateEmptyOrAlternative, validateNoLeftRecursion, validateSomeNonEmptyLookaheadPath, } from \"./checks.js\";\nimport { buildAlternativesLookAheadFunc, buildLookaheadFuncForOptionalProd, buildLookaheadFuncForOr, buildSingleAlternativeLookaheadFunction, getProdType, } from \"./lookahead.js\";\nexport class LLkLookaheadStrategy {\n    constructor(options) {\n        var _a;\n        this.maxLookahead =\n            (_a = options === null || options === void 0 ? void 0 : options.maxLookahead) !== null && _a !== void 0 ? _a : DEFAULT_PARSER_CONFIG.maxLookahead;\n    }\n    validate(options) {\n        const leftRecursionErrors = this.validateNoLeftRecursion(options.rules);\n        if (isEmpty(leftRecursionErrors)) {\n            const emptyAltErrors = this.validateEmptyOrAlternatives(options.rules);\n            const ambiguousAltsErrors = this.validateAmbiguousAlternationAlternatives(options.rules, this.maxLookahead);\n            const emptyRepetitionErrors = this.validateSomeNonEmptyLookaheadPath(options.rules, this.maxLookahead);\n            const allErrors = [\n                ...leftRecursionErrors,\n                ...emptyAltErrors,\n                ...ambiguousAltsErrors,\n                ...emptyRepetitionErrors,\n            ];\n            return allErrors;\n        }\n        return leftRecursionErrors;\n    }\n    validateNoLeftRecursion(rules) {\n        return flatMap(rules, (currTopRule) => validateNoLeftRecursion(currTopRule, currTopRule, defaultGrammarValidatorErrorProvider));\n    }\n    validateEmptyOrAlternatives(rules) {\n        return flatMap(rules, (currTopRule) => validateEmptyOrAlternative(currTopRule, defaultGrammarValidatorErrorProvider));\n    }\n    validateAmbiguousAlternationAlternatives(rules, maxLookahead) {\n        return flatMap(rules, (currTopRule) => validateAmbiguousAlternationAlternatives(currTopRule, maxLookahead, defaultGrammarValidatorErrorProvider));\n    }\n    validateSomeNonEmptyLookaheadPath(rules, maxLookahead) {\n        return validateSomeNonEmptyLookaheadPath(rules, maxLookahead, defaultGrammarValidatorErrorProvider);\n    }\n    buildLookaheadForAlternation(options) {\n        return buildLookaheadFuncForOr(options.prodOccurrence, options.rule, options.maxLookahead, options.hasPredicates, options.dynamicTokensEnabled, buildAlternativesLookAheadFunc);\n    }\n    buildLookaheadForOptional(options) {\n        return buildLookaheadFuncForOptionalProd(options.prodOccurrence, options.rule, options.maxLookahead, options.dynamicTokensEnabled, getProdType(options.prodType), buildSingleAlternativeLookaheadFunction);\n    }\n}\n//# sourceMappingURL=llk_lookahead.js.map","import { forEach, has } from \"lodash-es\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser.js\";\nimport { AT_LEAST_ONE_IDX, AT_LEAST_ONE_SEP_IDX, getKeyForAutomaticLookahead, MANY_IDX, MANY_SEP_IDX, OPTION_IDX, OR_IDX, } from \"../../grammar/keys.js\";\nimport { GAstVisitor, getProductionDslName, } from \"@chevrotain/gast\";\nimport { LLkLookaheadStrategy } from \"../../grammar/llk_lookahead.js\";\n/**\n * Trait responsible for the lookahead related utilities and optimizations.\n */\nexport class LooksAhead {\n    initLooksAhead(config) {\n        this.dynamicTokensEnabled = has(config, \"dynamicTokensEnabled\")\n            ? config.dynamicTokensEnabled // assumes end user provides the correct config value/type\n            : DEFAULT_PARSER_CONFIG.dynamicTokensEnabled;\n        this.maxLookahead = has(config, \"maxLookahead\")\n            ? config.maxLookahead // assumes end user provides the correct config value/type\n            : DEFAULT_PARSER_CONFIG.maxLookahead;\n        this.lookaheadStrategy = has(config, \"lookaheadStrategy\")\n            ? config.lookaheadStrategy // assumes end user provides the correct config value/type\n            : new LLkLookaheadStrategy({ maxLookahead: this.maxLookahead });\n        this.lookAheadFuncsCache = new Map();\n    }\n    preComputeLookaheadFunctions(rules) {\n        forEach(rules, (currRule) => {\n            this.TRACE_INIT(`${currRule.name} Rule Lookahead`, () => {\n                const { alternation, repetition, option, repetitionMandatory, repetitionMandatoryWithSeparator, repetitionWithSeparator, } = collectMethods(currRule);\n                forEach(alternation, (currProd) => {\n                    const prodIdx = currProd.idx === 0 ? \"\" : currProd.idx;\n                    this.TRACE_INIT(`${getProductionDslName(currProd)}${prodIdx}`, () => {\n                        const laFunc = this.lookaheadStrategy.buildLookaheadForAlternation({\n                            prodOccurrence: currProd.idx,\n                            rule: currRule,\n                            maxLookahead: currProd.maxLookahead || this.maxLookahead,\n                            hasPredicates: currProd.hasPredicates,\n                            dynamicTokensEnabled: this.dynamicTokensEnabled,\n                        });\n                        const key = getKeyForAutomaticLookahead(this.fullRuleNameToShort[currRule.name], OR_IDX, currProd.idx);\n                        this.setLaFuncCache(key, laFunc);\n                    });\n                });\n                forEach(repetition, (currProd) => {\n                    this.computeLookaheadFunc(currRule, currProd.idx, MANY_IDX, \"Repetition\", currProd.maxLookahead, getProductionDslName(currProd));\n                });\n                forEach(option, (currProd) => {\n                    this.computeLookaheadFunc(currRule, currProd.idx, OPTION_IDX, \"Option\", currProd.maxLookahead, getProductionDslName(currProd));\n                });\n                forEach(repetitionMandatory, (currProd) => {\n                    this.computeLookaheadFunc(currRule, currProd.idx, AT_LEAST_ONE_IDX, \"RepetitionMandatory\", currProd.maxLookahead, getProductionDslName(currProd));\n                });\n                forEach(repetitionMandatoryWithSeparator, (currProd) => {\n                    this.computeLookaheadFunc(currRule, currProd.idx, AT_LEAST_ONE_SEP_IDX, \"RepetitionMandatoryWithSeparator\", currProd.maxLookahead, getProductionDslName(currProd));\n                });\n                forEach(repetitionWithSeparator, (currProd) => {\n                    this.computeLookaheadFunc(currRule, currProd.idx, MANY_SEP_IDX, \"RepetitionWithSeparator\", currProd.maxLookahead, getProductionDslName(currProd));\n                });\n            });\n        });\n    }\n    computeLookaheadFunc(rule, prodOccurrence, prodKey, prodType, prodMaxLookahead, dslMethodName) {\n        this.TRACE_INIT(`${dslMethodName}${prodOccurrence === 0 ? \"\" : prodOccurrence}`, () => {\n            const laFunc = this.lookaheadStrategy.buildLookaheadForOptional({\n                prodOccurrence,\n                rule,\n                maxLookahead: prodMaxLookahead || this.maxLookahead,\n                dynamicTokensEnabled: this.dynamicTokensEnabled,\n                prodType,\n            });\n            const key = getKeyForAutomaticLookahead(this.fullRuleNameToShort[rule.name], prodKey, prodOccurrence);\n            this.setLaFuncCache(key, laFunc);\n        });\n    }\n    // this actually returns a number, but it is always used as a string (object prop key)\n    getKeyForAutomaticLookahead(dslMethodIdx, occurrence) {\n        const currRuleShortName = this.getLastExplicitRuleShortName();\n        return getKeyForAutomaticLookahead(currRuleShortName, dslMethodIdx, occurrence);\n    }\n    getLaFuncFromCache(key) {\n        return this.lookAheadFuncsCache.get(key);\n    }\n    /* istanbul ignore next */\n    setLaFuncCache(key, value) {\n        this.lookAheadFuncsCache.set(key, value);\n    }\n}\nclass DslMethodsCollectorVisitor extends GAstVisitor {\n    constructor() {\n        super(...arguments);\n        this.dslMethods = {\n            option: [],\n            alternation: [],\n            repetition: [],\n            repetitionWithSeparator: [],\n            repetitionMandatory: [],\n            repetitionMandatoryWithSeparator: [],\n        };\n    }\n    reset() {\n        this.dslMethods = {\n            option: [],\n            alternation: [],\n            repetition: [],\n            repetitionWithSeparator: [],\n            repetitionMandatory: [],\n            repetitionMandatoryWithSeparator: [],\n        };\n    }\n    visitOption(option) {\n        this.dslMethods.option.push(option);\n    }\n    visitRepetitionWithSeparator(manySep) {\n        this.dslMethods.repetitionWithSeparator.push(manySep);\n    }\n    visitRepetitionMandatory(atLeastOne) {\n        this.dslMethods.repetitionMandatory.push(atLeastOne);\n    }\n    visitRepetitionMandatoryWithSeparator(atLeastOneSep) {\n        this.dslMethods.repetitionMandatoryWithSeparator.push(atLeastOneSep);\n    }\n    visitRepetition(many) {\n        this.dslMethods.repetition.push(many);\n    }\n    visitAlternation(or) {\n        this.dslMethods.alternation.push(or);\n    }\n}\nconst collectorVisitor = new DslMethodsCollectorVisitor();\nexport function collectMethods(rule) {\n    collectorVisitor.reset();\n    rule.accept(collectorVisitor);\n    const dslMethods = collectorVisitor.dslMethods;\n    // avoid uncleaned references\n    collectorVisitor.reset();\n    return dslMethods;\n}\n//# sourceMappingURL=looksahead.js.map","/**\n * This nodeLocation tracking is not efficient and should only be used\n * when error recovery is enabled or the Token Vector contains virtual Tokens\n * (e.g, Python Indent/Outdent)\n * As it executes the calculation for every single terminal/nonTerminal\n * and does not rely on the fact the token vector is **sorted**\n */\nexport function setNodeLocationOnlyOffset(currNodeLocation, newLocationInfo) {\n    // First (valid) update for this cst node\n    if (isNaN(currNodeLocation.startOffset) === true) {\n        // assumption1: Token location information is either NaN or a valid number\n        // assumption2: Token location information is fully valid if it exist\n        // (both start/end offsets exist and are numbers).\n        currNodeLocation.startOffset = newLocationInfo.startOffset;\n        currNodeLocation.endOffset = newLocationInfo.endOffset;\n    }\n    // Once the startOffset has been updated with a valid number it should never receive\n    // any farther updates as the Token vector is sorted.\n    // We still have to check this this condition for every new possible location info\n    // because with error recovery enabled we may encounter invalid tokens (NaN location props)\n    else if (currNodeLocation.endOffset < newLocationInfo.endOffset === true) {\n        currNodeLocation.endOffset = newLocationInfo.endOffset;\n    }\n}\n/**\n * This nodeLocation tracking is not efficient and should only be used\n * when error recovery is enabled or the Token Vector contains virtual Tokens\n * (e.g, Python Indent/Outdent)\n * As it executes the calculation for every single terminal/nonTerminal\n * and does not rely on the fact the token vector is **sorted**\n */\nexport function setNodeLocationFull(currNodeLocation, newLocationInfo) {\n    // First (valid) update for this cst node\n    if (isNaN(currNodeLocation.startOffset) === true) {\n        // assumption1: Token location information is either NaN or a valid number\n        // assumption2: Token location information is fully valid if it exist\n        // (all start/end props exist and are numbers).\n        currNodeLocation.startOffset = newLocationInfo.startOffset;\n        currNodeLocation.startColumn = newLocationInfo.startColumn;\n        currNodeLocation.startLine = newLocationInfo.startLine;\n        currNodeLocation.endOffset = newLocationInfo.endOffset;\n        currNodeLocation.endColumn = newLocationInfo.endColumn;\n        currNodeLocation.endLine = newLocationInfo.endLine;\n    }\n    // Once the start props has been updated with a valid number it should never receive\n    // any farther updates as the Token vector is sorted.\n    // We still have to check this this condition for every new possible location info\n    // because with error recovery enabled we may encounter invalid tokens (NaN location props)\n    else if (currNodeLocation.endOffset < newLocationInfo.endOffset === true) {\n        currNodeLocation.endOffset = newLocationInfo.endOffset;\n        currNodeLocation.endColumn = newLocationInfo.endColumn;\n        currNodeLocation.endLine = newLocationInfo.endLine;\n    }\n}\nexport function addTerminalToCst(node, token, tokenTypeName) {\n    if (node.children[tokenTypeName] === undefined) {\n        node.children[tokenTypeName] = [token];\n    }\n    else {\n        node.children[tokenTypeName].push(token);\n    }\n}\nexport function addNoneTerminalToCst(node, ruleName, ruleResult) {\n    if (node.children[ruleName] === undefined) {\n        node.children[ruleName] = [ruleResult];\n    }\n    else {\n        node.children[ruleName].push(ruleResult);\n    }\n}\n//# sourceMappingURL=cst.js.map","const NAME = \"name\";\nexport function defineNameProp(obj, nameValue) {\n    Object.defineProperty(obj, NAME, {\n        enumerable: false,\n        configurable: true,\n        writable: false,\n        value: nameValue,\n    });\n}\n//# sourceMappingURL=lang_extensions.js.map","import { compact, filter, forEach, isArray, isEmpty, isFunction, isUndefined, keys, map, } from \"lodash-es\";\nimport { defineNameProp } from \"../../lang/lang_extensions.js\";\nexport function defaultVisit(ctx, param) {\n    const childrenNames = keys(ctx);\n    const childrenNamesLength = childrenNames.length;\n    for (let i = 0; i < childrenNamesLength; i++) {\n        const currChildName = childrenNames[i];\n        const currChildArray = ctx[currChildName];\n        const currChildArrayLength = currChildArray.length;\n        for (let j = 0; j < currChildArrayLength; j++) {\n            const currChild = currChildArray[j];\n            // distinction between Tokens Children and CstNode children\n            if (currChild.tokenTypeIdx === undefined) {\n                this[currChild.name](currChild.children, param);\n            }\n        }\n    }\n    // defaultVisit does not support generic out param\n}\nexport function createBaseSemanticVisitorConstructor(grammarName, ruleNames) {\n    const derivedConstructor = function () { };\n    // can be overwritten according to:\n    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/\n    // name?redirectlocale=en-US&redirectslug=JavaScript%2FReference%2FGlobal_Objects%2FFunction%2Fname\n    defineNameProp(derivedConstructor, grammarName + \"BaseSemantics\");\n    const semanticProto = {\n        visit: function (cstNode, param) {\n            // enables writing more concise visitor methods when CstNode has only a single child\n            if (isArray(cstNode)) {\n                // A CST Node's children dictionary can never have empty arrays as values\n                // If a key is defined there will be at least one element in the corresponding value array.\n                cstNode = cstNode[0];\n            }\n            // enables passing optional CstNodes concisely.\n            if (isUndefined(cstNode)) {\n                return undefined;\n            }\n            return this[cstNode.name](cstNode.children, param);\n        },\n        validateVisitor: function () {\n            const semanticDefinitionErrors = validateVisitor(this, ruleNames);\n            if (!isEmpty(semanticDefinitionErrors)) {\n                const errorMessages = map(semanticDefinitionErrors, (currDefError) => currDefError.msg);\n                throw Error(`Errors Detected in CST Visitor <${this.constructor.name}>:\\n\\t` +\n                    `${errorMessages.join(\"\\n\\n\").replace(/\\n/g, \"\\n\\t\")}`);\n            }\n        },\n    };\n    derivedConstructor.prototype = semanticProto;\n    derivedConstructor.prototype.constructor = derivedConstructor;\n    derivedConstructor._RULE_NAMES = ruleNames;\n    return derivedConstructor;\n}\nexport function createBaseVisitorConstructorWithDefaults(grammarName, ruleNames, baseConstructor) {\n    const derivedConstructor = function () { };\n    // can be overwritten according to:\n    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/\n    // name?redirectlocale=en-US&redirectslug=JavaScript%2FReference%2FGlobal_Objects%2FFunction%2Fname\n    defineNameProp(derivedConstructor, grammarName + \"BaseSemanticsWithDefaults\");\n    const withDefaultsProto = Object.create(baseConstructor.prototype);\n    forEach(ruleNames, (ruleName) => {\n        withDefaultsProto[ruleName] = defaultVisit;\n    });\n    derivedConstructor.prototype = withDefaultsProto;\n    derivedConstructor.prototype.constructor = derivedConstructor;\n    return derivedConstructor;\n}\nexport var CstVisitorDefinitionError;\n(function (CstVisitorDefinitionError) {\n    CstVisitorDefinitionError[CstVisitorDefinitionError[\"REDUNDANT_METHOD\"] = 0] = \"REDUNDANT_METHOD\";\n    CstVisitorDefinitionError[CstVisitorDefinitionError[\"MISSING_METHOD\"] = 1] = \"MISSING_METHOD\";\n})(CstVisitorDefinitionError || (CstVisitorDefinitionError = {}));\nexport function validateVisitor(visitorInstance, ruleNames) {\n    const missingErrors = validateMissingCstMethods(visitorInstance, ruleNames);\n    return missingErrors;\n}\nexport function validateMissingCstMethods(visitorInstance, ruleNames) {\n    const missingRuleNames = filter(ruleNames, (currRuleName) => {\n        return isFunction(visitorInstance[currRuleName]) === false;\n    });\n    const errors = map(missingRuleNames, (currRuleName) => {\n        return {\n            msg: `Missing visitor method: <${currRuleName}> on ${(visitorInstance.constructor.name)} CST Visitor.`,\n            type: CstVisitorDefinitionError.MISSING_METHOD,\n            methodName: currRuleName,\n        };\n    });\n    return compact(errors);\n}\n//# sourceMappingURL=cst_visitor.js.map","import { forEach, has, isArray, isFunction, last as peek, some, } from \"lodash-es\";\nimport { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Rule, Terminal, } from \"@chevrotain/gast\";\nimport { Lexer } from \"../../../scan/lexer_public.js\";\nimport { augmentTokenTypes, hasShortKeyProperty, } from \"../../../scan/tokens.js\";\nimport { createToken, createTokenInstance, } from \"../../../scan/tokens_public.js\";\nimport { END_OF_FILE } from \"../parser.js\";\nimport { BITS_FOR_OCCURRENCE_IDX } from \"../../grammar/keys.js\";\nconst RECORDING_NULL_OBJECT = {\n    description: \"This Object indicates the Parser is during Recording Phase\",\n};\nObject.freeze(RECORDING_NULL_OBJECT);\nconst HANDLE_SEPARATOR = true;\nconst MAX_METHOD_IDX = Math.pow(2, BITS_FOR_OCCURRENCE_IDX) - 1;\nconst RFT = createToken({ name: \"RECORDING_PHASE_TOKEN\", pattern: Lexer.NA });\naugmentTokenTypes([RFT]);\nconst RECORDING_PHASE_TOKEN = createTokenInstance(RFT, \"This IToken indicates the Parser is in Recording Phase\\n\\t\" +\n    \"\" +\n    \"See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details\", \n// Using \"-1\" instead of NaN (as in EOF) because an actual number is less likely to\n// cause errors if the output of LA or CONSUME would be (incorrectly) used during the recording phase.\n-1, -1, -1, -1, -1, -1);\nObject.freeze(RECORDING_PHASE_TOKEN);\nconst RECORDING_PHASE_CSTNODE = {\n    name: \"This CSTNode indicates the Parser is in Recording Phase\\n\\t\" +\n        \"See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details\",\n    children: {},\n};\n/**\n * This trait handles the creation of the GAST structure for Chevrotain Grammars\n */\nexport class GastRecorder {\n    initGastRecorder(config) {\n        this.recordingProdStack = [];\n        this.RECORDING_PHASE = false;\n    }\n    enableRecording() {\n        this.RECORDING_PHASE = true;\n        this.TRACE_INIT(\"Enable Recording\", () => {\n            /**\n             * Warning Dark Voodoo Magic upcoming!\n             * We are \"replacing\" the public parsing DSL methods API\n             * With **new** alternative implementations on the Parser **instance**\n             *\n             * So far this is the only way I've found to avoid performance regressions during parsing time.\n             * - Approx 30% performance regression was measured on Chrome 75 Canary when attempting to replace the \"internal\"\n             *   implementations directly instead.\n             */\n            for (let i = 0; i < 10; i++) {\n                const idx = i > 0 ? i : \"\";\n                this[`CONSUME${idx}`] = function (arg1, arg2) {\n                    return this.consumeInternalRecord(arg1, i, arg2);\n                };\n                this[`SUBRULE${idx}`] = function (arg1, arg2) {\n                    return this.subruleInternalRecord(arg1, i, arg2);\n                };\n                this[`OPTION${idx}`] = function (arg1) {\n                    return this.optionInternalRecord(arg1, i);\n                };\n                this[`OR${idx}`] = function (arg1) {\n                    return this.orInternalRecord(arg1, i);\n                };\n                this[`MANY${idx}`] = function (arg1) {\n                    this.manyInternalRecord(i, arg1);\n                };\n                this[`MANY_SEP${idx}`] = function (arg1) {\n                    this.manySepFirstInternalRecord(i, arg1);\n                };\n                this[`AT_LEAST_ONE${idx}`] = function (arg1) {\n                    this.atLeastOneInternalRecord(i, arg1);\n                };\n                this[`AT_LEAST_ONE_SEP${idx}`] = function (arg1) {\n                    this.atLeastOneSepFirstInternalRecord(i, arg1);\n                };\n            }\n            // DSL methods with the idx(suffix) as an argument\n            this[`consume`] = function (idx, arg1, arg2) {\n                return this.consumeInternalRecord(arg1, idx, arg2);\n            };\n            this[`subrule`] = function (idx, arg1, arg2) {\n                return this.subruleInternalRecord(arg1, idx, arg2);\n            };\n            this[`option`] = function (idx, arg1) {\n                return this.optionInternalRecord(arg1, idx);\n            };\n            this[`or`] = function (idx, arg1) {\n                return this.orInternalRecord(arg1, idx);\n            };\n            this[`many`] = function (idx, arg1) {\n                this.manyInternalRecord(idx, arg1);\n            };\n            this[`atLeastOne`] = function (idx, arg1) {\n                this.atLeastOneInternalRecord(idx, arg1);\n            };\n            this.ACTION = this.ACTION_RECORD;\n            this.BACKTRACK = this.BACKTRACK_RECORD;\n            this.LA = this.LA_RECORD;\n        });\n    }\n    disableRecording() {\n        this.RECORDING_PHASE = false;\n        // By deleting these **instance** properties, any future invocation\n        // will be deferred to the original methods on the **prototype** object\n        // This seems to get rid of any incorrect optimizations that V8 may\n        // do during the recording phase.\n        this.TRACE_INIT(\"Deleting Recording methods\", () => {\n            const that = this;\n            for (let i = 0; i < 10; i++) {\n                const idx = i > 0 ? i : \"\";\n                delete that[`CONSUME${idx}`];\n                delete that[`SUBRULE${idx}`];\n                delete that[`OPTION${idx}`];\n                delete that[`OR${idx}`];\n                delete that[`MANY${idx}`];\n                delete that[`MANY_SEP${idx}`];\n                delete that[`AT_LEAST_ONE${idx}`];\n                delete that[`AT_LEAST_ONE_SEP${idx}`];\n            }\n            delete that[`consume`];\n            delete that[`subrule`];\n            delete that[`option`];\n            delete that[`or`];\n            delete that[`many`];\n            delete that[`atLeastOne`];\n            delete that.ACTION;\n            delete that.BACKTRACK;\n            delete that.LA;\n        });\n    }\n    //   Parser methods are called inside an ACTION?\n    //   Maybe try/catch/finally on ACTIONS while disabling the recorders state changes?\n    // @ts-expect-error -- noop place holder\n    ACTION_RECORD(impl) {\n        // NO-OP during recording\n    }\n    // Executing backtracking logic will break our recording logic assumptions\n    BACKTRACK_RECORD(grammarRule, args) {\n        return () => true;\n    }\n    // LA is part of the official API and may be used for custom lookahead logic\n    // by end users who may forget to wrap it in ACTION or inside a GATE\n    LA_RECORD(howMuch) {\n        // We cannot use the RECORD_PHASE_TOKEN here because someone may depend\n        // On LA return EOF at the end of the input so an infinite loop may occur.\n        return END_OF_FILE;\n    }\n    topLevelRuleRecord(name, def) {\n        try {\n            const newTopLevelRule = new Rule({ definition: [], name: name });\n            newTopLevelRule.name = name;\n            this.recordingProdStack.push(newTopLevelRule);\n            def.call(this);\n            this.recordingProdStack.pop();\n            return newTopLevelRule;\n        }\n        catch (originalError) {\n            if (originalError.KNOWN_RECORDER_ERROR !== true) {\n                try {\n                    originalError.message =\n                        originalError.message +\n                            '\\n\\t This error was thrown during the \"grammar recording phase\" For more info see:\\n\\t' +\n                            \"https://chevrotain.io/docs/guide/internals.html#grammar-recording\";\n                }\n                catch (mutabilityError) {\n                    // We may not be able to modify the original error object\n                    throw originalError;\n                }\n            }\n            throw originalError;\n        }\n    }\n    // Implementation of parsing DSL\n    optionInternalRecord(actionORMethodDef, occurrence) {\n        return recordProd.call(this, Option, actionORMethodDef, occurrence);\n    }\n    atLeastOneInternalRecord(occurrence, actionORMethodDef) {\n        recordProd.call(this, RepetitionMandatory, actionORMethodDef, occurrence);\n    }\n    atLeastOneSepFirstInternalRecord(occurrence, options) {\n        recordProd.call(this, RepetitionMandatoryWithSeparator, options, occurrence, HANDLE_SEPARATOR);\n    }\n    manyInternalRecord(occurrence, actionORMethodDef) {\n        recordProd.call(this, Repetition, actionORMethodDef, occurrence);\n    }\n    manySepFirstInternalRecord(occurrence, options) {\n        recordProd.call(this, RepetitionWithSeparator, options, occurrence, HANDLE_SEPARATOR);\n    }\n    orInternalRecord(altsOrOpts, occurrence) {\n        return recordOrProd.call(this, altsOrOpts, occurrence);\n    }\n    subruleInternalRecord(ruleToCall, occurrence, options) {\n        assertMethodIdxIsValid(occurrence);\n        if (!ruleToCall || has(ruleToCall, \"ruleName\") === false) {\n            const error = new Error(`<SUBRULE${getIdxSuffix(occurrence)}> argument is invalid` +\n                ` expecting a Parser method reference but got: <${JSON.stringify(ruleToCall)}>` +\n                `\\n inside top level rule: <${this.recordingProdStack[0].name}>`);\n            error.KNOWN_RECORDER_ERROR = true;\n            throw error;\n        }\n        const prevProd = peek(this.recordingProdStack);\n        const ruleName = ruleToCall.ruleName;\n        const newNoneTerminal = new NonTerminal({\n            idx: occurrence,\n            nonTerminalName: ruleName,\n            label: options === null || options === void 0 ? void 0 : options.LABEL,\n            // The resolving of the `referencedRule` property will be done once all the Rule's GASTs have been created\n            referencedRule: undefined,\n        });\n        prevProd.definition.push(newNoneTerminal);\n        return this.outputCst\n            ? RECORDING_PHASE_CSTNODE\n            : RECORDING_NULL_OBJECT;\n    }\n    consumeInternalRecord(tokType, occurrence, options) {\n        assertMethodIdxIsValid(occurrence);\n        if (!hasShortKeyProperty(tokType)) {\n            const error = new Error(`<CONSUME${getIdxSuffix(occurrence)}> argument is invalid` +\n                ` expecting a TokenType reference but got: <${JSON.stringify(tokType)}>` +\n                `\\n inside top level rule: <${this.recordingProdStack[0].name}>`);\n            error.KNOWN_RECORDER_ERROR = true;\n            throw error;\n        }\n        const prevProd = peek(this.recordingProdStack);\n        const newNoneTerminal = new Terminal({\n            idx: occurrence,\n            terminalType: tokType,\n            label: options === null || options === void 0 ? void 0 : options.LABEL,\n        });\n        prevProd.definition.push(newNoneTerminal);\n        return RECORDING_PHASE_TOKEN;\n    }\n}\nfunction recordProd(prodConstructor, mainProdArg, occurrence, handleSep = false) {\n    assertMethodIdxIsValid(occurrence);\n    const prevProd = peek(this.recordingProdStack);\n    const grammarAction = isFunction(mainProdArg) ? mainProdArg : mainProdArg.DEF;\n    const newProd = new prodConstructor({ definition: [], idx: occurrence });\n    if (handleSep) {\n        newProd.separator = mainProdArg.SEP;\n    }\n    if (has(mainProdArg, \"MAX_LOOKAHEAD\")) {\n        newProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;\n    }\n    this.recordingProdStack.push(newProd);\n    grammarAction.call(this);\n    prevProd.definition.push(newProd);\n    this.recordingProdStack.pop();\n    return RECORDING_NULL_OBJECT;\n}\nfunction recordOrProd(mainProdArg, occurrence) {\n    assertMethodIdxIsValid(occurrence);\n    const prevProd = peek(this.recordingProdStack);\n    // Only an array of alternatives\n    const hasOptions = isArray(mainProdArg) === false;\n    const alts = hasOptions === false ? mainProdArg : mainProdArg.DEF;\n    const newOrProd = new Alternation({\n        definition: [],\n        idx: occurrence,\n        ignoreAmbiguities: hasOptions && mainProdArg.IGNORE_AMBIGUITIES === true,\n    });\n    if (has(mainProdArg, \"MAX_LOOKAHEAD\")) {\n        newOrProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;\n    }\n    const hasPredicates = some(alts, (currAlt) => isFunction(currAlt.GATE));\n    newOrProd.hasPredicates = hasPredicates;\n    prevProd.definition.push(newOrProd);\n    forEach(alts, (currAlt) => {\n        const currAltFlat = new Alternative({ definition: [] });\n        newOrProd.definition.push(currAltFlat);\n        if (has(currAlt, \"IGNORE_AMBIGUITIES\")) {\n            currAltFlat.ignoreAmbiguities = currAlt.IGNORE_AMBIGUITIES; // assumes end user provides the correct config value/type\n        }\n        // **implicit** ignoreAmbiguities due to usage of gate\n        else if (has(currAlt, \"GATE\")) {\n            currAltFlat.ignoreAmbiguities = true;\n        }\n        this.recordingProdStack.push(currAltFlat);\n        currAlt.ALT.call(this);\n        this.recordingProdStack.pop();\n    });\n    return RECORDING_NULL_OBJECT;\n}\nfunction getIdxSuffix(idx) {\n    return idx === 0 ? \"\" : `${idx}`;\n}\nfunction assertMethodIdxIsValid(idx) {\n    if (idx < 0 || idx > MAX_METHOD_IDX) {\n        const error = new Error(\n        // The stack trace will contain all the needed details\n        `Invalid DSL Method idx value: <${idx}>\\n\\t` +\n            `Idx value must be a none negative value smaller than ${MAX_METHOD_IDX + 1}`);\n        error.KNOWN_RECORDER_ERROR = true;\n        throw error;\n    }\n}\n//# sourceMappingURL=gast_recorder.js.map","import { clone, forEach, has, isEmpty, map, values } from \"lodash-es\";\nimport { toFastProperties } from \"@chevrotain/utils\";\nimport { computeAllProdsFollows } from \"../grammar/follow.js\";\nimport { createTokenInstance, EOF } from \"../../scan/tokens_public.js\";\nimport { defaultGrammarValidatorErrorProvider, defaultParserErrorProvider, } from \"../errors_public.js\";\nimport { resolveGrammar, validateGrammar, } from \"../grammar/gast/gast_resolver_public.js\";\nimport { Recoverable } from \"./traits/recoverable.js\";\nimport { LooksAhead } from \"./traits/looksahead.js\";\nimport { TreeBuilder } from \"./traits/tree_builder.js\";\nimport { LexerAdapter } from \"./traits/lexer_adapter.js\";\nimport { RecognizerApi } from \"./traits/recognizer_api.js\";\nimport { RecognizerEngine } from \"./traits/recognizer_engine.js\";\nimport { ErrorHandler } from \"./traits/error_handler.js\";\nimport { ContentAssist } from \"./traits/context_assist.js\";\nimport { GastRecorder } from \"./traits/gast_recorder.js\";\nimport { PerformanceTracer } from \"./traits/perf_tracer.js\";\nimport { applyMixins } from \"./utils/apply_mixins.js\";\nimport { validateLookahead } from \"../grammar/checks.js\";\nexport const END_OF_FILE = createTokenInstance(EOF, \"\", NaN, NaN, NaN, NaN, NaN, NaN);\nObject.freeze(END_OF_FILE);\nexport const DEFAULT_PARSER_CONFIG = Object.freeze({\n    recoveryEnabled: false,\n    maxLookahead: 3,\n    dynamicTokensEnabled: false,\n    outputCst: true,\n    errorMessageProvider: defaultParserErrorProvider,\n    nodeLocationTracking: \"none\",\n    traceInitPerf: false,\n    skipValidations: false,\n});\nexport const DEFAULT_RULE_CONFIG = Object.freeze({\n    recoveryValueFunc: () => undefined,\n    resyncEnabled: true,\n});\nexport var ParserDefinitionErrorType;\n(function (ParserDefinitionErrorType) {\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"INVALID_RULE_NAME\"] = 0] = \"INVALID_RULE_NAME\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"DUPLICATE_RULE_NAME\"] = 1] = \"DUPLICATE_RULE_NAME\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"INVALID_RULE_OVERRIDE\"] = 2] = \"INVALID_RULE_OVERRIDE\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"DUPLICATE_PRODUCTIONS\"] = 3] = \"DUPLICATE_PRODUCTIONS\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"UNRESOLVED_SUBRULE_REF\"] = 4] = \"UNRESOLVED_SUBRULE_REF\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"LEFT_RECURSION\"] = 5] = \"LEFT_RECURSION\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"NONE_LAST_EMPTY_ALT\"] = 6] = \"NONE_LAST_EMPTY_ALT\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"AMBIGUOUS_ALTS\"] = 7] = \"AMBIGUOUS_ALTS\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"CONFLICT_TOKENS_RULES_NAMESPACE\"] = 8] = \"CONFLICT_TOKENS_RULES_NAMESPACE\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"INVALID_TOKEN_NAME\"] = 9] = \"INVALID_TOKEN_NAME\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"NO_NON_EMPTY_LOOKAHEAD\"] = 10] = \"NO_NON_EMPTY_LOOKAHEAD\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"AMBIGUOUS_PREFIX_ALTS\"] = 11] = \"AMBIGUOUS_PREFIX_ALTS\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"TOO_MANY_ALTS\"] = 12] = \"TOO_MANY_ALTS\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"CUSTOM_LOOKAHEAD_VALIDATION\"] = 13] = \"CUSTOM_LOOKAHEAD_VALIDATION\";\n})(ParserDefinitionErrorType || (ParserDefinitionErrorType = {}));\nexport function EMPTY_ALT(value = undefined) {\n    return function () {\n        return value;\n    };\n}\nexport class Parser {\n    /**\n     *  @deprecated use the **instance** method with the same name instead\n     */\n    static performSelfAnalysis(parserInstance) {\n        throw Error(\"The **static** `performSelfAnalysis` method has been deprecated.\" +\n            \"\\t\\nUse the **instance** method with the same name instead.\");\n    }\n    performSelfAnalysis() {\n        this.TRACE_INIT(\"performSelfAnalysis\", () => {\n            let defErrorsMsgs;\n            this.selfAnalysisDone = true;\n            const className = this.className;\n            this.TRACE_INIT(\"toFastProps\", () => {\n                // Without this voodoo magic the parser would be x3-x4 slower\n                // It seems it is better to invoke `toFastProperties` **before**\n                // Any manipulations of the `this` object done during the recording phase.\n                toFastProperties(this);\n            });\n            this.TRACE_INIT(\"Grammar Recording\", () => {\n                try {\n                    this.enableRecording();\n                    // Building the GAST\n                    forEach(this.definedRulesNames, (currRuleName) => {\n                        const wrappedRule = this[currRuleName];\n                        const originalGrammarAction = wrappedRule[\"originalGrammarAction\"];\n                        let recordedRuleGast;\n                        this.TRACE_INIT(`${currRuleName} Rule`, () => {\n                            recordedRuleGast = this.topLevelRuleRecord(currRuleName, originalGrammarAction);\n                        });\n                        this.gastProductionsCache[currRuleName] = recordedRuleGast;\n                    });\n                }\n                finally {\n                    this.disableRecording();\n                }\n            });\n            let resolverErrors = [];\n            this.TRACE_INIT(\"Grammar Resolving\", () => {\n                resolverErrors = resolveGrammar({\n                    rules: values(this.gastProductionsCache),\n                });\n                this.definitionErrors = this.definitionErrors.concat(resolverErrors);\n            });\n            this.TRACE_INIT(\"Grammar Validations\", () => {\n                // only perform additional grammar validations IFF no resolving errors have occurred.\n                // as unresolved grammar may lead to unhandled runtime exceptions in the follow up validations.\n                if (isEmpty(resolverErrors) && this.skipValidations === false) {\n                    const validationErrors = validateGrammar({\n                        rules: values(this.gastProductionsCache),\n                        tokenTypes: values(this.tokensMap),\n                        errMsgProvider: defaultGrammarValidatorErrorProvider,\n                        grammarName: className,\n                    });\n                    const lookaheadValidationErrors = validateLookahead({\n                        lookaheadStrategy: this.lookaheadStrategy,\n                        rules: values(this.gastProductionsCache),\n                        tokenTypes: values(this.tokensMap),\n                        grammarName: className,\n                    });\n                    this.definitionErrors = this.definitionErrors.concat(validationErrors, lookaheadValidationErrors);\n                }\n            });\n            // this analysis may fail if the grammar is not perfectly valid\n            if (isEmpty(this.definitionErrors)) {\n                // The results of these computations are not needed unless error recovery is enabled.\n                if (this.recoveryEnabled) {\n                    this.TRACE_INIT(\"computeAllProdsFollows\", () => {\n                        const allFollows = computeAllProdsFollows(values(this.gastProductionsCache));\n                        this.resyncFollows = allFollows;\n                    });\n                }\n                this.TRACE_INIT(\"ComputeLookaheadFunctions\", () => {\n                    var _a, _b;\n                    (_b = (_a = this.lookaheadStrategy).initialize) === null || _b === void 0 ? void 0 : _b.call(_a, {\n                        rules: values(this.gastProductionsCache),\n                    });\n                    this.preComputeLookaheadFunctions(values(this.gastProductionsCache));\n                });\n            }\n            if (!Parser.DEFER_DEFINITION_ERRORS_HANDLING &&\n                !isEmpty(this.definitionErrors)) {\n                defErrorsMsgs = map(this.definitionErrors, (defError) => defError.message);\n                throw new Error(`Parser Definition Errors detected:\\n ${defErrorsMsgs.join(\"\\n-------------------------------\\n\")}`);\n            }\n        });\n    }\n    constructor(tokenVocabulary, config) {\n        this.definitionErrors = [];\n        this.selfAnalysisDone = false;\n        const that = this;\n        that.initErrorHandler(config);\n        that.initLexerAdapter();\n        that.initLooksAhead(config);\n        that.initRecognizerEngine(tokenVocabulary, config);\n        that.initRecoverable(config);\n        that.initTreeBuilder(config);\n        that.initContentAssist();\n        that.initGastRecorder(config);\n        that.initPerformanceTracer(config);\n        if (has(config, \"ignoredIssues\")) {\n            throw new Error(\"The <ignoredIssues> IParserConfig property has been deprecated.\\n\\t\" +\n                \"Please use the <IGNORE_AMBIGUITIES> flag on the relevant DSL method instead.\\n\\t\" +\n                \"See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#IGNORING_AMBIGUITIES\\n\\t\" +\n                \"For further details.\");\n        }\n        this.skipValidations = has(config, \"skipValidations\")\n            ? config.skipValidations // casting assumes the end user passing the correct type\n            : DEFAULT_PARSER_CONFIG.skipValidations;\n    }\n}\n// Set this flag to true if you don't want the Parser to throw error when problems in it's definition are detected.\n// (normally during the parser's constructor).\n// This is a design time flag, it will not affect the runtime error handling of the parser, just design time errors,\n// for example: duplicate rule names, referencing an unresolved subrule, ect...\n// This flag should not be enabled during normal usage, it is used in special situations, for example when\n// needing to display the parser definition errors in some GUI(online playground).\nParser.DEFER_DEFINITION_ERRORS_HANDLING = false;\napplyMixins(Parser, [\n    Recoverable,\n    LooksAhead,\n    TreeBuilder,\n    LexerAdapter,\n    RecognizerEngine,\n    RecognizerApi,\n    ErrorHandler,\n    ContentAssist,\n    GastRecorder,\n    PerformanceTracer,\n]);\nexport class CstParser extends Parser {\n    constructor(tokenVocabulary, config = DEFAULT_PARSER_CONFIG) {\n        const configClone = clone(config);\n        configClone.outputCst = true;\n        super(tokenVocabulary, configClone);\n    }\n}\nexport class EmbeddedActionsParser extends Parser {\n    constructor(tokenVocabulary, config = DEFAULT_PARSER_CONFIG) {\n        const configClone = clone(config);\n        configClone.outputCst = false;\n        super(tokenVocabulary, configClone);\n    }\n}\n//# sourceMappingURL=parser.js.map","export function applyMixins(derivedCtor, baseCtors) {\n    baseCtors.forEach((baseCtor) => {\n        const baseProto = baseCtor.prototype;\n        Object.getOwnPropertyNames(baseProto).forEach((propName) => {\n            if (propName === \"constructor\") {\n                return;\n            }\n            const basePropDescriptor = Object.getOwnPropertyDescriptor(baseProto, propName);\n            // Handle Accessors\n            if (basePropDescriptor &&\n                (basePropDescriptor.get || basePropDescriptor.set)) {\n                Object.defineProperty(derivedCtor.prototype, propName, basePropDescriptor);\n            }\n            else {\n                derivedCtor.prototype[propName] = baseCtor.prototype[propName];\n            }\n        });\n    });\n}\n//# sourceMappingURL=apply_mixins.js.map","import { defaults, forEach } from \"lodash-es\";\nimport { resolveGrammar as orgResolveGrammar } from \"../resolver.js\";\nimport { validateGrammar as orgValidateGrammar } from \"../checks.js\";\nimport { defaultGrammarResolverErrorProvider, defaultGrammarValidatorErrorProvider, } from \"../../errors_public.js\";\nexport function resolveGrammar(options) {\n    const actualOptions = defaults(options, {\n        errMsgProvider: defaultGrammarResolverErrorProvider,\n    });\n    const topRulesTable = {};\n    forEach(options.rules, (rule) => {\n        topRulesTable[rule.name] = rule;\n    });\n    return orgResolveGrammar(topRulesTable, actualOptions.errMsgProvider);\n}\nexport function validateGrammar(options) {\n    options = defaults(options, {\n        errMsgProvider: defaultGrammarValidatorErrorProvider,\n    });\n    return orgValidateGrammar(options.rules, options.tokenTypes, options.errMsgProvider, options.grammarName);\n}\n//# sourceMappingURL=gast_resolver_public.js.map","import { addNoneTerminalToCst, addTerminalToCst, setNodeLocationFull, setNodeLocationOnlyOffset, } from \"../../cst/cst.js\";\nimport { has, isUndefined, keys, noop } from \"lodash-es\";\nimport { createBaseSemanticVisitorConstructor, createBaseVisitorConstructorWithDefaults, } from \"../../cst/cst_visitor.js\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser.js\";\n/**\n * This trait is responsible for the CST building logic.\n */\nexport class TreeBuilder {\n    initTreeBuilder(config) {\n        this.CST_STACK = [];\n        // outputCst is no longer exposed/defined in the pubic API\n        this.outputCst = config.outputCst;\n        this.nodeLocationTracking = has(config, \"nodeLocationTracking\")\n            ? config.nodeLocationTracking // assumes end user provides the correct config value/type\n            : DEFAULT_PARSER_CONFIG.nodeLocationTracking;\n        if (!this.outputCst) {\n            this.cstInvocationStateUpdate = noop;\n            this.cstFinallyStateUpdate = noop;\n            this.cstPostTerminal = noop;\n            this.cstPostNonTerminal = noop;\n            this.cstPostRule = noop;\n        }\n        else {\n            if (/full/i.test(this.nodeLocationTracking)) {\n                if (this.recoveryEnabled) {\n                    this.setNodeLocationFromToken = setNodeLocationFull;\n                    this.setNodeLocationFromNode = setNodeLocationFull;\n                    this.cstPostRule = noop;\n                    this.setInitialNodeLocation = this.setInitialNodeLocationFullRecovery;\n                }\n                else {\n                    this.setNodeLocationFromToken = noop;\n                    this.setNodeLocationFromNode = noop;\n                    this.cstPostRule = this.cstPostRuleFull;\n                    this.setInitialNodeLocation = this.setInitialNodeLocationFullRegular;\n                }\n            }\n            else if (/onlyOffset/i.test(this.nodeLocationTracking)) {\n                if (this.recoveryEnabled) {\n                    this.setNodeLocationFromToken = setNodeLocationOnlyOffset;\n                    this.setNodeLocationFromNode = setNodeLocationOnlyOffset;\n                    this.cstPostRule = noop;\n                    this.setInitialNodeLocation =\n                        this.setInitialNodeLocationOnlyOffsetRecovery;\n                }\n                else {\n                    this.setNodeLocationFromToken = noop;\n                    this.setNodeLocationFromNode = noop;\n                    this.cstPostRule = this.cstPostRuleOnlyOffset;\n                    this.setInitialNodeLocation =\n                        this.setInitialNodeLocationOnlyOffsetRegular;\n                }\n            }\n            else if (/none/i.test(this.nodeLocationTracking)) {\n                this.setNodeLocationFromToken = noop;\n                this.setNodeLocationFromNode = noop;\n                this.cstPostRule = noop;\n                this.setInitialNodeLocation = noop;\n            }\n            else {\n                throw Error(`Invalid <nodeLocationTracking> config option: \"${config.nodeLocationTracking}\"`);\n            }\n        }\n    }\n    setInitialNodeLocationOnlyOffsetRecovery(cstNode) {\n        cstNode.location = {\n            startOffset: NaN,\n            endOffset: NaN,\n        };\n    }\n    setInitialNodeLocationOnlyOffsetRegular(cstNode) {\n        cstNode.location = {\n            // without error recovery the starting Location of a new CstNode is guaranteed\n            // To be the next Token's startOffset (for valid inputs).\n            // For invalid inputs there won't be any CSTOutput so this potential\n            // inaccuracy does not matter\n            startOffset: this.LA(1).startOffset,\n            endOffset: NaN,\n        };\n    }\n    setInitialNodeLocationFullRecovery(cstNode) {\n        cstNode.location = {\n            startOffset: NaN,\n            startLine: NaN,\n            startColumn: NaN,\n            endOffset: NaN,\n            endLine: NaN,\n            endColumn: NaN,\n        };\n    }\n    /**\n       *  @see setInitialNodeLocationOnlyOffsetRegular for explanation why this work\n  \n       * @param cstNode\n       */\n    setInitialNodeLocationFullRegular(cstNode) {\n        const nextToken = this.LA(1);\n        cstNode.location = {\n            startOffset: nextToken.startOffset,\n            startLine: nextToken.startLine,\n            startColumn: nextToken.startColumn,\n            endOffset: NaN,\n            endLine: NaN,\n            endColumn: NaN,\n        };\n    }\n    cstInvocationStateUpdate(fullRuleName) {\n        const cstNode = {\n            name: fullRuleName,\n            children: Object.create(null),\n        };\n        this.setInitialNodeLocation(cstNode);\n        this.CST_STACK.push(cstNode);\n    }\n    cstFinallyStateUpdate() {\n        this.CST_STACK.pop();\n    }\n    cstPostRuleFull(ruleCstNode) {\n        // casts to `required<CstNodeLocation>` are safe because `cstPostRuleFull` should only be invoked when full location is enabled\n        const prevToken = this.LA(0);\n        const loc = ruleCstNode.location;\n        // If this condition is true it means we consumed at least one Token\n        // In this CstNode.\n        if (loc.startOffset <= prevToken.startOffset === true) {\n            loc.endOffset = prevToken.endOffset;\n            loc.endLine = prevToken.endLine;\n            loc.endColumn = prevToken.endColumn;\n        }\n        // \"empty\" CstNode edge case\n        else {\n            loc.startOffset = NaN;\n            loc.startLine = NaN;\n            loc.startColumn = NaN;\n        }\n    }\n    cstPostRuleOnlyOffset(ruleCstNode) {\n        const prevToken = this.LA(0);\n        // `location' is not null because `cstPostRuleOnlyOffset` will only be invoked when location tracking is enabled.\n        const loc = ruleCstNode.location;\n        // If this condition is true it means we consumed at least one Token\n        // In this CstNode.\n        if (loc.startOffset <= prevToken.startOffset === true) {\n            loc.endOffset = prevToken.endOffset;\n        }\n        // \"empty\" CstNode edge case\n        else {\n            loc.startOffset = NaN;\n        }\n    }\n    cstPostTerminal(key, consumedToken) {\n        const rootCst = this.CST_STACK[this.CST_STACK.length - 1];\n        addTerminalToCst(rootCst, consumedToken, key);\n        // This is only used when **both** error recovery and CST Output are enabled.\n        this.setNodeLocationFromToken(rootCst.location, consumedToken);\n    }\n    cstPostNonTerminal(ruleCstResult, ruleName) {\n        const preCstNode = this.CST_STACK[this.CST_STACK.length - 1];\n        addNoneTerminalToCst(preCstNode, ruleName, ruleCstResult);\n        // This is only used when **both** error recovery and CST Output are enabled.\n        this.setNodeLocationFromNode(preCstNode.location, ruleCstResult.location);\n    }\n    getBaseCstVisitorConstructor() {\n        if (isUndefined(this.baseCstVisitorConstructor)) {\n            const newBaseCstVisitorConstructor = createBaseSemanticVisitorConstructor(this.className, keys(this.gastProductionsCache));\n            this.baseCstVisitorConstructor = newBaseCstVisitorConstructor;\n            return newBaseCstVisitorConstructor;\n        }\n        return this.baseCstVisitorConstructor;\n    }\n    getBaseCstVisitorConstructorWithDefaults() {\n        if (isUndefined(this.baseCstVisitorWithDefaultsConstructor)) {\n            const newConstructor = createBaseVisitorConstructorWithDefaults(this.className, keys(this.gastProductionsCache), this.getBaseCstVisitorConstructor());\n            this.baseCstVisitorWithDefaultsConstructor = newConstructor;\n            return newConstructor;\n        }\n        return this.baseCstVisitorWithDefaultsConstructor;\n    }\n    getLastExplicitRuleShortName() {\n        const ruleStack = this.RULE_STACK;\n        return ruleStack[ruleStack.length - 1];\n    }\n    getPreviousExplicitRuleShortName() {\n        const ruleStack = this.RULE_STACK;\n        return ruleStack[ruleStack.length - 2];\n    }\n    getLastExplicitRuleOccurrenceIndex() {\n        const occurrenceStack = this.RULE_OCCURRENCE_STACK;\n        return occurrenceStack[occurrenceStack.length - 1];\n    }\n}\n//# sourceMappingURL=tree_builder.js.map","import { END_OF_FILE } from \"../parser.js\";\n/**\n * Trait responsible abstracting over the interaction with Lexer output (Token vector).\n *\n * This could be generalized to support other kinds of lexers, e.g.\n * - Just in Time Lexing / Lexer-Less parsing.\n * - Streaming Lexer.\n */\nexport class LexerAdapter {\n    initLexerAdapter() {\n        this.tokVector = [];\n        this.tokVectorLength = 0;\n        this.currIdx = -1;\n    }\n    set input(newInput) {\n        // @ts-ignore - `this parameter` not supported in setters/getters\n        //   - https://www.typescriptlang.org/docs/handbook/functions.html#this-parameters\n        if (this.selfAnalysisDone !== true) {\n            throw Error(`Missing <performSelfAnalysis> invocation at the end of the Parser's constructor.`);\n        }\n        // @ts-ignore - `this parameter` not supported in setters/getters\n        //   - https://www.typescriptlang.org/docs/handbook/functions.html#this-parameters\n        this.reset();\n        this.tokVector = newInput;\n        this.tokVectorLength = newInput.length;\n    }\n    get input() {\n        return this.tokVector;\n    }\n    // skips a token and returns the next token\n    SKIP_TOKEN() {\n        if (this.currIdx <= this.tokVector.length - 2) {\n            this.consumeToken();\n            return this.LA(1);\n        }\n        else {\n            return END_OF_FILE;\n        }\n    }\n    // Lexer (accessing Token vector) related methods which can be overridden to implement lazy lexers\n    // or lexers dependent on parser context.\n    LA(howMuch) {\n        const soughtIdx = this.currIdx + howMuch;\n        if (soughtIdx < 0 || this.tokVectorLength <= soughtIdx) {\n            return END_OF_FILE;\n        }\n        else {\n            return this.tokVector[soughtIdx];\n        }\n    }\n    consumeToken() {\n        this.currIdx++;\n    }\n    exportLexerState() {\n        return this.currIdx;\n    }\n    importLexerState(newState) {\n        this.currIdx = newState;\n    }\n    resetLexerState() {\n        this.currIdx = -1;\n    }\n    moveToTerminatedState() {\n        this.currIdx = this.tokVector.length - 1;\n    }\n    getLexerPosition() {\n        return this.exportLexerState();\n    }\n}\n//# sourceMappingURL=lexer_adapter.js.map","import { clone, every, flatten, has, isArray, isEmpty, isObject, reduce, uniq, values, } from \"lodash-es\";\nimport { AT_LEAST_ONE_IDX, AT_LEAST_ONE_SEP_IDX, BITS_FOR_METHOD_TYPE, BITS_FOR_OCCURRENCE_IDX, MANY_IDX, MANY_SEP_IDX, OPTION_IDX, OR_IDX, } from \"../../grammar/keys.js\";\nimport { isRecognitionException, MismatchedTokenException, NotAllInputParsedException, } from \"../../exceptions_public.js\";\nimport { PROD_TYPE } from \"../../grammar/lookahead.js\";\nimport { NextTerminalAfterAtLeastOneSepWalker, NextTerminalAfterAtLeastOneWalker, NextTerminalAfterManySepWalker, NextTerminalAfterManyWalker, } from \"../../grammar/interpreter.js\";\nimport { DEFAULT_RULE_CONFIG } from \"../parser.js\";\nimport { IN_RULE_RECOVERY_EXCEPTION } from \"./recoverable.js\";\nimport { EOF } from \"../../../scan/tokens_public.js\";\nimport { augmentTokenTypes, isTokenType, tokenStructuredMatcher, tokenStructuredMatcherNoCategories, } from \"../../../scan/tokens.js\";\n/**\n * This trait is responsible for the runtime parsing engine\n * Used by the official API (recognizer_api.ts)\n */\nexport class RecognizerEngine {\n    initRecognizerEngine(tokenVocabulary, config) {\n        this.className = this.constructor.name;\n        // TODO: would using an ES6 Map or plain object be faster (CST building scenario)\n        this.shortRuleNameToFull = {};\n        this.fullRuleNameToShort = {};\n        this.ruleShortNameIdx = 256;\n        this.tokenMatcher = tokenStructuredMatcherNoCategories;\n        this.subruleIdx = 0;\n        this.definedRulesNames = [];\n        this.tokensMap = {};\n        this.isBackTrackingStack = [];\n        this.RULE_STACK = [];\n        this.RULE_OCCURRENCE_STACK = [];\n        this.gastProductionsCache = {};\n        if (has(config, \"serializedGrammar\")) {\n            throw Error(\"The Parser's configuration can no longer contain a <serializedGrammar> property.\\n\" +\n                \"\\tSee: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_6-0-0\\n\" +\n                \"\\tFor Further details.\");\n        }\n        if (isArray(tokenVocabulary)) {\n            // This only checks for Token vocabularies provided as arrays.\n            // That is good enough because the main objective is to detect users of pre-V4.0 APIs\n            // rather than all edge cases of empty Token vocabularies.\n            if (isEmpty(tokenVocabulary)) {\n                throw Error(\"A Token Vocabulary cannot be empty.\\n\" +\n                    \"\\tNote that the first argument for the parser constructor\\n\" +\n                    \"\\tis no longer a Token vector (since v4.0).\");\n            }\n            if (typeof tokenVocabulary[0].startOffset === \"number\") {\n                throw Error(\"The Parser constructor no longer accepts a token vector as the first argument.\\n\" +\n                    \"\\tSee: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_4-0-0\\n\" +\n                    \"\\tFor Further details.\");\n            }\n        }\n        if (isArray(tokenVocabulary)) {\n            this.tokensMap = reduce(tokenVocabulary, (acc, tokType) => {\n                acc[tokType.name] = tokType;\n                return acc;\n            }, {});\n        }\n        else if (has(tokenVocabulary, \"modes\") &&\n            every(flatten(values(tokenVocabulary.modes)), isTokenType)) {\n            const allTokenTypes = flatten(values(tokenVocabulary.modes));\n            const uniqueTokens = uniq(allTokenTypes);\n            this.tokensMap = reduce(uniqueTokens, (acc, tokType) => {\n                acc[tokType.name] = tokType;\n                return acc;\n            }, {});\n        }\n        else if (isObject(tokenVocabulary)) {\n            this.tokensMap = clone(tokenVocabulary);\n        }\n        else {\n            throw new Error(\"<tokensDictionary> argument must be An Array of Token constructors,\" +\n                \" A dictionary of Token constructors or an IMultiModeLexerDefinition\");\n        }\n        // always add EOF to the tokenNames -> constructors map. it is useful to assure all the input has been\n        // parsed with a clear error message (\"expecting EOF but found ...\")\n        this.tokensMap[\"EOF\"] = EOF;\n        const allTokenTypes = has(tokenVocabulary, \"modes\")\n            ? flatten(values(tokenVocabulary.modes))\n            : values(tokenVocabulary);\n        const noTokenCategoriesUsed = every(allTokenTypes, (tokenConstructor) => isEmpty(tokenConstructor.categoryMatches));\n        this.tokenMatcher = noTokenCategoriesUsed\n            ? tokenStructuredMatcherNoCategories\n            : tokenStructuredMatcher;\n        // Because ES2015+ syntax should be supported for creating Token classes\n        // We cannot assume that the Token classes were created using the \"extendToken\" utilities\n        // Therefore we must augment the Token classes both on Lexer initialization and on Parser initialization\n        augmentTokenTypes(values(this.tokensMap));\n    }\n    defineRule(ruleName, impl, config) {\n        if (this.selfAnalysisDone) {\n            throw Error(`Grammar rule <${ruleName}> may not be defined after the 'performSelfAnalysis' method has been called'\\n` +\n                `Make sure that all grammar rule definitions are done before 'performSelfAnalysis' is called.`);\n        }\n        const resyncEnabled = has(config, \"resyncEnabled\")\n            ? config.resyncEnabled // assumes end user provides the correct config value/type\n            : DEFAULT_RULE_CONFIG.resyncEnabled;\n        const recoveryValueFunc = has(config, \"recoveryValueFunc\")\n            ? config.recoveryValueFunc // assumes end user provides the correct config value/type\n            : DEFAULT_RULE_CONFIG.recoveryValueFunc;\n        // performance optimization: Use small integers as keys for the longer human readable \"full\" rule names.\n        // this greatly improves Map access time (as much as 8% for some performance benchmarks).\n        const shortName = this.ruleShortNameIdx << (BITS_FOR_METHOD_TYPE + BITS_FOR_OCCURRENCE_IDX);\n        this.ruleShortNameIdx++;\n        this.shortRuleNameToFull[shortName] = ruleName;\n        this.fullRuleNameToShort[ruleName] = shortName;\n        let invokeRuleWithTry;\n        // Micro optimization, only check the condition **once** on rule definition\n        // instead of **every single** rule invocation.\n        if (this.outputCst === true) {\n            invokeRuleWithTry = function invokeRuleWithTry(...args) {\n                try {\n                    this.ruleInvocationStateUpdate(shortName, ruleName, this.subruleIdx);\n                    impl.apply(this, args);\n                    const cst = this.CST_STACK[this.CST_STACK.length - 1];\n                    this.cstPostRule(cst);\n                    return cst;\n                }\n                catch (e) {\n                    return this.invokeRuleCatch(e, resyncEnabled, recoveryValueFunc);\n                }\n                finally {\n                    this.ruleFinallyStateUpdate();\n                }\n            };\n        }\n        else {\n            invokeRuleWithTry = function invokeRuleWithTryCst(...args) {\n                try {\n                    this.ruleInvocationStateUpdate(shortName, ruleName, this.subruleIdx);\n                    return impl.apply(this, args);\n                }\n                catch (e) {\n                    return this.invokeRuleCatch(e, resyncEnabled, recoveryValueFunc);\n                }\n                finally {\n                    this.ruleFinallyStateUpdate();\n                }\n            };\n        }\n        const wrappedGrammarRule = Object.assign(invokeRuleWithTry, { ruleName, originalGrammarAction: impl });\n        return wrappedGrammarRule;\n    }\n    invokeRuleCatch(e, resyncEnabledConfig, recoveryValueFunc) {\n        const isFirstInvokedRule = this.RULE_STACK.length === 1;\n        // note the reSync is always enabled for the first rule invocation, because we must always be able to\n        // reSync with EOF and just output some INVALID ParseTree\n        // during backtracking reSync recovery is disabled, otherwise we can't be certain the backtracking\n        // path is really the most valid one\n        const reSyncEnabled = resyncEnabledConfig && !this.isBackTracking() && this.recoveryEnabled;\n        if (isRecognitionException(e)) {\n            const recogError = e;\n            if (reSyncEnabled) {\n                const reSyncTokType = this.findReSyncTokenType();\n                if (this.isInCurrentRuleReSyncSet(reSyncTokType)) {\n                    recogError.resyncedTokens = this.reSyncTo(reSyncTokType);\n                    if (this.outputCst) {\n                        const partialCstResult = this.CST_STACK[this.CST_STACK.length - 1];\n                        partialCstResult.recoveredNode = true;\n                        return partialCstResult;\n                    }\n                    else {\n                        return recoveryValueFunc(e);\n                    }\n                }\n                else {\n                    if (this.outputCst) {\n                        const partialCstResult = this.CST_STACK[this.CST_STACK.length - 1];\n                        partialCstResult.recoveredNode = true;\n                        recogError.partialCstResult = partialCstResult;\n                    }\n                    // to be handled Further up the call stack\n                    throw recogError;\n                }\n            }\n            else if (isFirstInvokedRule) {\n                // otherwise a Redundant input error will be created as well and we cannot guarantee that this is indeed the case\n                this.moveToTerminatedState();\n                // the parser should never throw one of its own errors outside its flow.\n                // even if error recovery is disabled\n                return recoveryValueFunc(e);\n            }\n            else {\n                // to be recovered Further up the call stack\n                throw recogError;\n            }\n        }\n        else {\n            // some other Error type which we don't know how to handle (for example a built in JavaScript Error)\n            throw e;\n        }\n    }\n    // Implementation of parsing DSL\n    optionInternal(actionORMethodDef, occurrence) {\n        const key = this.getKeyForAutomaticLookahead(OPTION_IDX, occurrence);\n        return this.optionInternalLogic(actionORMethodDef, occurrence, key);\n    }\n    optionInternalLogic(actionORMethodDef, occurrence, key) {\n        let lookAheadFunc = this.getLaFuncFromCache(key);\n        let action;\n        if (typeof actionORMethodDef !== \"function\") {\n            action = actionORMethodDef.DEF;\n            const predicate = actionORMethodDef.GATE;\n            // predicate present\n            if (predicate !== undefined) {\n                const orgLookaheadFunction = lookAheadFunc;\n                lookAheadFunc = () => {\n                    return predicate.call(this) && orgLookaheadFunction.call(this);\n                };\n            }\n        }\n        else {\n            action = actionORMethodDef;\n        }\n        if (lookAheadFunc.call(this) === true) {\n            return action.call(this);\n        }\n        return undefined;\n    }\n    atLeastOneInternal(prodOccurrence, actionORMethodDef) {\n        const laKey = this.getKeyForAutomaticLookahead(AT_LEAST_ONE_IDX, prodOccurrence);\n        return this.atLeastOneInternalLogic(prodOccurrence, actionORMethodDef, laKey);\n    }\n    atLeastOneInternalLogic(prodOccurrence, actionORMethodDef, key) {\n        let lookAheadFunc = this.getLaFuncFromCache(key);\n        let action;\n        if (typeof actionORMethodDef !== \"function\") {\n            action = actionORMethodDef.DEF;\n            const predicate = actionORMethodDef.GATE;\n            // predicate present\n            if (predicate !== undefined) {\n                const orgLookaheadFunction = lookAheadFunc;\n                lookAheadFunc = () => {\n                    return predicate.call(this) && orgLookaheadFunction.call(this);\n                };\n            }\n        }\n        else {\n            action = actionORMethodDef;\n        }\n        if (lookAheadFunc.call(this) === true) {\n            let notStuck = this.doSingleRepetition(action);\n            while (lookAheadFunc.call(this) === true &&\n                notStuck === true) {\n                notStuck = this.doSingleRepetition(action);\n            }\n        }\n        else {\n            throw this.raiseEarlyExitException(prodOccurrence, PROD_TYPE.REPETITION_MANDATORY, actionORMethodDef.ERR_MSG);\n        }\n        // note that while it may seem that this can cause an error because by using a recursive call to\n        // AT_LEAST_ONE we change the grammar to AT_LEAST_TWO, AT_LEAST_THREE ... , the possible recursive call\n        // from the tryInRepetitionRecovery(...) will only happen IFF there really are TWO/THREE/.... items.\n        // Performance optimization: \"attemptInRepetitionRecovery\" will be defined as NOOP unless recovery is enabled\n        this.attemptInRepetitionRecovery(this.atLeastOneInternal, [prodOccurrence, actionORMethodDef], lookAheadFunc, AT_LEAST_ONE_IDX, prodOccurrence, NextTerminalAfterAtLeastOneWalker);\n    }\n    atLeastOneSepFirstInternal(prodOccurrence, options) {\n        const laKey = this.getKeyForAutomaticLookahead(AT_LEAST_ONE_SEP_IDX, prodOccurrence);\n        this.atLeastOneSepFirstInternalLogic(prodOccurrence, options, laKey);\n    }\n    atLeastOneSepFirstInternalLogic(prodOccurrence, options, key) {\n        const action = options.DEF;\n        const separator = options.SEP;\n        const firstIterationLookaheadFunc = this.getLaFuncFromCache(key);\n        // 1st iteration\n        if (firstIterationLookaheadFunc.call(this) === true) {\n            action.call(this);\n            //  TODO: Optimization can move this function construction into \"attemptInRepetitionRecovery\"\n            //  because it is only needed in error recovery scenarios.\n            const separatorLookAheadFunc = () => {\n                return this.tokenMatcher(this.LA(1), separator);\n            };\n            // 2nd..nth iterations\n            while (this.tokenMatcher(this.LA(1), separator) === true) {\n                // note that this CONSUME will never enter recovery because\n                // the separatorLookAheadFunc checks that the separator really does exist.\n                this.CONSUME(separator);\n                // No need for checking infinite loop here due to consuming the separator.\n                action.call(this);\n            }\n            // Performance optimization: \"attemptInRepetitionRecovery\" will be defined as NOOP unless recovery is enabled\n            this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [\n                prodOccurrence,\n                separator,\n                separatorLookAheadFunc,\n                action,\n                NextTerminalAfterAtLeastOneSepWalker,\n            ], separatorLookAheadFunc, AT_LEAST_ONE_SEP_IDX, prodOccurrence, NextTerminalAfterAtLeastOneSepWalker);\n        }\n        else {\n            throw this.raiseEarlyExitException(prodOccurrence, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR, options.ERR_MSG);\n        }\n    }\n    manyInternal(prodOccurrence, actionORMethodDef) {\n        const laKey = this.getKeyForAutomaticLookahead(MANY_IDX, prodOccurrence);\n        return this.manyInternalLogic(prodOccurrence, actionORMethodDef, laKey);\n    }\n    manyInternalLogic(prodOccurrence, actionORMethodDef, key) {\n        let lookaheadFunction = this.getLaFuncFromCache(key);\n        let action;\n        if (typeof actionORMethodDef !== \"function\") {\n            action = actionORMethodDef.DEF;\n            const predicate = actionORMethodDef.GATE;\n            // predicate present\n            if (predicate !== undefined) {\n                const orgLookaheadFunction = lookaheadFunction;\n                lookaheadFunction = () => {\n                    return predicate.call(this) && orgLookaheadFunction.call(this);\n                };\n            }\n        }\n        else {\n            action = actionORMethodDef;\n        }\n        let notStuck = true;\n        while (lookaheadFunction.call(this) === true && notStuck === true) {\n            notStuck = this.doSingleRepetition(action);\n        }\n        // Performance optimization: \"attemptInRepetitionRecovery\" will be defined as NOOP unless recovery is enabled\n        this.attemptInRepetitionRecovery(this.manyInternal, [prodOccurrence, actionORMethodDef], lookaheadFunction, MANY_IDX, prodOccurrence, NextTerminalAfterManyWalker, \n        // The notStuck parameter is only relevant when \"attemptInRepetitionRecovery\"\n        // is invoked from manyInternal, in the MANY_SEP case and AT_LEAST_ONE[_SEP]\n        // An infinite loop cannot occur as:\n        // - Either the lookahead is guaranteed to consume something (Single Token Separator)\n        // - AT_LEAST_ONE by definition is guaranteed to consume something (or error out).\n        notStuck);\n    }\n    manySepFirstInternal(prodOccurrence, options) {\n        const laKey = this.getKeyForAutomaticLookahead(MANY_SEP_IDX, prodOccurrence);\n        this.manySepFirstInternalLogic(prodOccurrence, options, laKey);\n    }\n    manySepFirstInternalLogic(prodOccurrence, options, key) {\n        const action = options.DEF;\n        const separator = options.SEP;\n        const firstIterationLaFunc = this.getLaFuncFromCache(key);\n        // 1st iteration\n        if (firstIterationLaFunc.call(this) === true) {\n            action.call(this);\n            const separatorLookAheadFunc = () => {\n                return this.tokenMatcher(this.LA(1), separator);\n            };\n            // 2nd..nth iterations\n            while (this.tokenMatcher(this.LA(1), separator) === true) {\n                // note that this CONSUME will never enter recovery because\n                // the separatorLookAheadFunc checks that the separator really does exist.\n                this.CONSUME(separator);\n                // No need for checking infinite loop here due to consuming the separator.\n                action.call(this);\n            }\n            // Performance optimization: \"attemptInRepetitionRecovery\" will be defined as NOOP unless recovery is enabled\n            this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [\n                prodOccurrence,\n                separator,\n                separatorLookAheadFunc,\n                action,\n                NextTerminalAfterManySepWalker,\n            ], separatorLookAheadFunc, MANY_SEP_IDX, prodOccurrence, NextTerminalAfterManySepWalker);\n        }\n    }\n    repetitionSepSecondInternal(prodOccurrence, separator, separatorLookAheadFunc, action, nextTerminalAfterWalker) {\n        while (separatorLookAheadFunc()) {\n            // note that this CONSUME will never enter recovery because\n            // the separatorLookAheadFunc checks that the separator really does exist.\n            this.CONSUME(separator);\n            action.call(this);\n        }\n        // we can only arrive to this function after an error\n        // has occurred (hence the name 'second') so the following\n        // IF will always be entered, its possible to remove it...\n        // however it is kept to avoid confusion and be consistent.\n        // Performance optimization: \"attemptInRepetitionRecovery\" will be defined as NOOP unless recovery is enabled\n        /* istanbul ignore else */\n        this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [\n            prodOccurrence,\n            separator,\n            separatorLookAheadFunc,\n            action,\n            nextTerminalAfterWalker,\n        ], separatorLookAheadFunc, AT_LEAST_ONE_SEP_IDX, prodOccurrence, nextTerminalAfterWalker);\n    }\n    doSingleRepetition(action) {\n        const beforeIteration = this.getLexerPosition();\n        action.call(this);\n        const afterIteration = this.getLexerPosition();\n        // This boolean will indicate if this repetition progressed\n        // or if we are \"stuck\" (potential infinite loop in the repetition).\n        return afterIteration > beforeIteration;\n    }\n    orInternal(altsOrOpts, occurrence) {\n        const laKey = this.getKeyForAutomaticLookahead(OR_IDX, occurrence);\n        const alts = isArray(altsOrOpts) ? altsOrOpts : altsOrOpts.DEF;\n        const laFunc = this.getLaFuncFromCache(laKey);\n        const altIdxToTake = laFunc.call(this, alts);\n        if (altIdxToTake !== undefined) {\n            const chosenAlternative = alts[altIdxToTake];\n            return chosenAlternative.ALT.call(this);\n        }\n        this.raiseNoAltException(occurrence, altsOrOpts.ERR_MSG);\n    }\n    ruleFinallyStateUpdate() {\n        this.RULE_STACK.pop();\n        this.RULE_OCCURRENCE_STACK.pop();\n        // NOOP when cst is disabled\n        this.cstFinallyStateUpdate();\n        if (this.RULE_STACK.length === 0 && this.isAtEndOfInput() === false) {\n            const firstRedundantTok = this.LA(1);\n            const errMsg = this.errorMessageProvider.buildNotAllInputParsedMessage({\n                firstRedundant: firstRedundantTok,\n                ruleName: this.getCurrRuleFullName(),\n            });\n            this.SAVE_ERROR(new NotAllInputParsedException(errMsg, firstRedundantTok));\n        }\n    }\n    subruleInternal(ruleToCall, idx, options) {\n        let ruleResult;\n        try {\n            const args = options !== undefined ? options.ARGS : undefined;\n            this.subruleIdx = idx;\n            ruleResult = ruleToCall.apply(this, args);\n            this.cstPostNonTerminal(ruleResult, options !== undefined && options.LABEL !== undefined\n                ? options.LABEL\n                : ruleToCall.ruleName);\n            return ruleResult;\n        }\n        catch (e) {\n            throw this.subruleInternalError(e, options, ruleToCall.ruleName);\n        }\n    }\n    subruleInternalError(e, options, ruleName) {\n        if (isRecognitionException(e) && e.partialCstResult !== undefined) {\n            this.cstPostNonTerminal(e.partialCstResult, options !== undefined && options.LABEL !== undefined\n                ? options.LABEL\n                : ruleName);\n            delete e.partialCstResult;\n        }\n        throw e;\n    }\n    consumeInternal(tokType, idx, options) {\n        let consumedToken;\n        try {\n            const nextToken = this.LA(1);\n            if (this.tokenMatcher(nextToken, tokType) === true) {\n                this.consumeToken();\n                consumedToken = nextToken;\n            }\n            else {\n                this.consumeInternalError(tokType, nextToken, options);\n            }\n        }\n        catch (eFromConsumption) {\n            consumedToken = this.consumeInternalRecovery(tokType, idx, eFromConsumption);\n        }\n        this.cstPostTerminal(options !== undefined && options.LABEL !== undefined\n            ? options.LABEL\n            : tokType.name, consumedToken);\n        return consumedToken;\n    }\n    consumeInternalError(tokType, nextToken, options) {\n        let msg;\n        const previousToken = this.LA(0);\n        if (options !== undefined && options.ERR_MSG) {\n            msg = options.ERR_MSG;\n        }\n        else {\n            msg = this.errorMessageProvider.buildMismatchTokenMessage({\n                expected: tokType,\n                actual: nextToken,\n                previous: previousToken,\n                ruleName: this.getCurrRuleFullName(),\n            });\n        }\n        throw this.SAVE_ERROR(new MismatchedTokenException(msg, nextToken, previousToken));\n    }\n    consumeInternalRecovery(tokType, idx, eFromConsumption) {\n        // no recovery allowed during backtracking, otherwise backtracking may recover invalid syntax and accept it\n        // but the original syntax could have been parsed successfully without any backtracking + recovery\n        if (this.recoveryEnabled &&\n            // TODO: more robust checking of the exception type. Perhaps Typescript extending expressions?\n            eFromConsumption.name === \"MismatchedTokenException\" &&\n            !this.isBackTracking()) {\n            const follows = this.getFollowsForInRuleRecovery(tokType, idx);\n            try {\n                return this.tryInRuleRecovery(tokType, follows);\n            }\n            catch (eFromInRuleRecovery) {\n                if (eFromInRuleRecovery.name === IN_RULE_RECOVERY_EXCEPTION) {\n                    // failed in RuleRecovery.\n                    // throw the original error in order to trigger reSync error recovery\n                    throw eFromConsumption;\n                }\n                else {\n                    throw eFromInRuleRecovery;\n                }\n            }\n        }\n        else {\n            throw eFromConsumption;\n        }\n    }\n    saveRecogState() {\n        // errors is a getter which will clone the errors array\n        const savedErrors = this.errors;\n        const savedRuleStack = clone(this.RULE_STACK);\n        return {\n            errors: savedErrors,\n            lexerState: this.exportLexerState(),\n            RULE_STACK: savedRuleStack,\n            CST_STACK: this.CST_STACK,\n        };\n    }\n    reloadRecogState(newState) {\n        this.errors = newState.errors;\n        this.importLexerState(newState.lexerState);\n        this.RULE_STACK = newState.RULE_STACK;\n    }\n    ruleInvocationStateUpdate(shortName, fullName, idxInCallingRule) {\n        this.RULE_OCCURRENCE_STACK.push(idxInCallingRule);\n        this.RULE_STACK.push(shortName);\n        // NOOP when cst is disabled\n        this.cstInvocationStateUpdate(fullName);\n    }\n    isBackTracking() {\n        return this.isBackTrackingStack.length !== 0;\n    }\n    getCurrRuleFullName() {\n        const shortName = this.getLastExplicitRuleShortName();\n        return this.shortRuleNameToFull[shortName];\n    }\n    shortRuleNameToFullName(shortName) {\n        return this.shortRuleNameToFull[shortName];\n    }\n    isAtEndOfInput() {\n        return this.tokenMatcher(this.LA(1), EOF);\n    }\n    reset() {\n        this.resetLexerState();\n        this.subruleIdx = 0;\n        this.isBackTrackingStack = [];\n        this.errors = [];\n        this.RULE_STACK = [];\n        // TODO: extract a specific reset for TreeBuilder trait\n        this.CST_STACK = [];\n        this.RULE_OCCURRENCE_STACK = [];\n    }\n}\n//# sourceMappingURL=recognizer_engine.js.map","import { includes, values } from \"lodash-es\";\nimport { isRecognitionException } from \"../../exceptions_public.js\";\nimport { DEFAULT_RULE_CONFIG, ParserDefinitionErrorType } from \"../parser.js\";\nimport { defaultGrammarValidatorErrorProvider } from \"../../errors_public.js\";\nimport { validateRuleIsOverridden } from \"../../grammar/checks.js\";\nimport { serializeGrammar } from \"@chevrotain/gast\";\n/**\n * This trait is responsible for implementing the public API\n * for defining Chevrotain parsers, i.e:\n * - CONSUME\n * - RULE\n * - OPTION\n * - ...\n */\nexport class RecognizerApi {\n    ACTION(impl) {\n        return impl.call(this);\n    }\n    consume(idx, tokType, options) {\n        return this.consumeInternal(tokType, idx, options);\n    }\n    subrule(idx, ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, idx, options);\n    }\n    option(idx, actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, idx);\n    }\n    or(idx, altsOrOpts) {\n        return this.orInternal(altsOrOpts, idx);\n    }\n    many(idx, actionORMethodDef) {\n        return this.manyInternal(idx, actionORMethodDef);\n    }\n    atLeastOne(idx, actionORMethodDef) {\n        return this.atLeastOneInternal(idx, actionORMethodDef);\n    }\n    CONSUME(tokType, options) {\n        return this.consumeInternal(tokType, 0, options);\n    }\n    CONSUME1(tokType, options) {\n        return this.consumeInternal(tokType, 1, options);\n    }\n    CONSUME2(tokType, options) {\n        return this.consumeInternal(tokType, 2, options);\n    }\n    CONSUME3(tokType, options) {\n        return this.consumeInternal(tokType, 3, options);\n    }\n    CONSUME4(tokType, options) {\n        return this.consumeInternal(tokType, 4, options);\n    }\n    CONSUME5(tokType, options) {\n        return this.consumeInternal(tokType, 5, options);\n    }\n    CONSUME6(tokType, options) {\n        return this.consumeInternal(tokType, 6, options);\n    }\n    CONSUME7(tokType, options) {\n        return this.consumeInternal(tokType, 7, options);\n    }\n    CONSUME8(tokType, options) {\n        return this.consumeInternal(tokType, 8, options);\n    }\n    CONSUME9(tokType, options) {\n        return this.consumeInternal(tokType, 9, options);\n    }\n    SUBRULE(ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, 0, options);\n    }\n    SUBRULE1(ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, 1, options);\n    }\n    SUBRULE2(ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, 2, options);\n    }\n    SUBRULE3(ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, 3, options);\n    }\n    SUBRULE4(ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, 4, options);\n    }\n    SUBRULE5(ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, 5, options);\n    }\n    SUBRULE6(ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, 6, options);\n    }\n    SUBRULE7(ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, 7, options);\n    }\n    SUBRULE8(ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, 8, options);\n    }\n    SUBRULE9(ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, 9, options);\n    }\n    OPTION(actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, 0);\n    }\n    OPTION1(actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, 1);\n    }\n    OPTION2(actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, 2);\n    }\n    OPTION3(actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, 3);\n    }\n    OPTION4(actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, 4);\n    }\n    OPTION5(actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, 5);\n    }\n    OPTION6(actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, 6);\n    }\n    OPTION7(actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, 7);\n    }\n    OPTION8(actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, 8);\n    }\n    OPTION9(actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, 9);\n    }\n    OR(altsOrOpts) {\n        return this.orInternal(altsOrOpts, 0);\n    }\n    OR1(altsOrOpts) {\n        return this.orInternal(altsOrOpts, 1);\n    }\n    OR2(altsOrOpts) {\n        return this.orInternal(altsOrOpts, 2);\n    }\n    OR3(altsOrOpts) {\n        return this.orInternal(altsOrOpts, 3);\n    }\n    OR4(altsOrOpts) {\n        return this.orInternal(altsOrOpts, 4);\n    }\n    OR5(altsOrOpts) {\n        return this.orInternal(altsOrOpts, 5);\n    }\n    OR6(altsOrOpts) {\n        return this.orInternal(altsOrOpts, 6);\n    }\n    OR7(altsOrOpts) {\n        return this.orInternal(altsOrOpts, 7);\n    }\n    OR8(altsOrOpts) {\n        return this.orInternal(altsOrOpts, 8);\n    }\n    OR9(altsOrOpts) {\n        return this.orInternal(altsOrOpts, 9);\n    }\n    MANY(actionORMethodDef) {\n        this.manyInternal(0, actionORMethodDef);\n    }\n    MANY1(actionORMethodDef) {\n        this.manyInternal(1, actionORMethodDef);\n    }\n    MANY2(actionORMethodDef) {\n        this.manyInternal(2, actionORMethodDef);\n    }\n    MANY3(actionORMethodDef) {\n        this.manyInternal(3, actionORMethodDef);\n    }\n    MANY4(actionORMethodDef) {\n        this.manyInternal(4, actionORMethodDef);\n    }\n    MANY5(actionORMethodDef) {\n        this.manyInternal(5, actionORMethodDef);\n    }\n    MANY6(actionORMethodDef) {\n        this.manyInternal(6, actionORMethodDef);\n    }\n    MANY7(actionORMethodDef) {\n        this.manyInternal(7, actionORMethodDef);\n    }\n    MANY8(actionORMethodDef) {\n        this.manyInternal(8, actionORMethodDef);\n    }\n    MANY9(actionORMethodDef) {\n        this.manyInternal(9, actionORMethodDef);\n    }\n    MANY_SEP(options) {\n        this.manySepFirstInternal(0, options);\n    }\n    MANY_SEP1(options) {\n        this.manySepFirstInternal(1, options);\n    }\n    MANY_SEP2(options) {\n        this.manySepFirstInternal(2, options);\n    }\n    MANY_SEP3(options) {\n        this.manySepFirstInternal(3, options);\n    }\n    MANY_SEP4(options) {\n        this.manySepFirstInternal(4, options);\n    }\n    MANY_SEP5(options) {\n        this.manySepFirstInternal(5, options);\n    }\n    MANY_SEP6(options) {\n        this.manySepFirstInternal(6, options);\n    }\n    MANY_SEP7(options) {\n        this.manySepFirstInternal(7, options);\n    }\n    MANY_SEP8(options) {\n        this.manySepFirstInternal(8, options);\n    }\n    MANY_SEP9(options) {\n        this.manySepFirstInternal(9, options);\n    }\n    AT_LEAST_ONE(actionORMethodDef) {\n        this.atLeastOneInternal(0, actionORMethodDef);\n    }\n    AT_LEAST_ONE1(actionORMethodDef) {\n        return this.atLeastOneInternal(1, actionORMethodDef);\n    }\n    AT_LEAST_ONE2(actionORMethodDef) {\n        this.atLeastOneInternal(2, actionORMethodDef);\n    }\n    AT_LEAST_ONE3(actionORMethodDef) {\n        this.atLeastOneInternal(3, actionORMethodDef);\n    }\n    AT_LEAST_ONE4(actionORMethodDef) {\n        this.atLeastOneInternal(4, actionORMethodDef);\n    }\n    AT_LEAST_ONE5(actionORMethodDef) {\n        this.atLeastOneInternal(5, actionORMethodDef);\n    }\n    AT_LEAST_ONE6(actionORMethodDef) {\n        this.atLeastOneInternal(6, actionORMethodDef);\n    }\n    AT_LEAST_ONE7(actionORMethodDef) {\n        this.atLeastOneInternal(7, actionORMethodDef);\n    }\n    AT_LEAST_ONE8(actionORMethodDef) {\n        this.atLeastOneInternal(8, actionORMethodDef);\n    }\n    AT_LEAST_ONE9(actionORMethodDef) {\n        this.atLeastOneInternal(9, actionORMethodDef);\n    }\n    AT_LEAST_ONE_SEP(options) {\n        this.atLeastOneSepFirstInternal(0, options);\n    }\n    AT_LEAST_ONE_SEP1(options) {\n        this.atLeastOneSepFirstInternal(1, options);\n    }\n    AT_LEAST_ONE_SEP2(options) {\n        this.atLeastOneSepFirstInternal(2, options);\n    }\n    AT_LEAST_ONE_SEP3(options) {\n        this.atLeastOneSepFirstInternal(3, options);\n    }\n    AT_LEAST_ONE_SEP4(options) {\n        this.atLeastOneSepFirstInternal(4, options);\n    }\n    AT_LEAST_ONE_SEP5(options) {\n        this.atLeastOneSepFirstInternal(5, options);\n    }\n    AT_LEAST_ONE_SEP6(options) {\n        this.atLeastOneSepFirstInternal(6, options);\n    }\n    AT_LEAST_ONE_SEP7(options) {\n        this.atLeastOneSepFirstInternal(7, options);\n    }\n    AT_LEAST_ONE_SEP8(options) {\n        this.atLeastOneSepFirstInternal(8, options);\n    }\n    AT_LEAST_ONE_SEP9(options) {\n        this.atLeastOneSepFirstInternal(9, options);\n    }\n    RULE(name, implementation, config = DEFAULT_RULE_CONFIG) {\n        if (includes(this.definedRulesNames, name)) {\n            const errMsg = defaultGrammarValidatorErrorProvider.buildDuplicateRuleNameError({\n                topLevelRule: name,\n                grammarName: this.className,\n            });\n            const error = {\n                message: errMsg,\n                type: ParserDefinitionErrorType.DUPLICATE_RULE_NAME,\n                ruleName: name,\n            };\n            this.definitionErrors.push(error);\n        }\n        this.definedRulesNames.push(name);\n        const ruleImplementation = this.defineRule(name, implementation, config);\n        this[name] = ruleImplementation;\n        return ruleImplementation;\n    }\n    OVERRIDE_RULE(name, impl, config = DEFAULT_RULE_CONFIG) {\n        const ruleErrors = validateRuleIsOverridden(name, this.definedRulesNames, this.className);\n        this.definitionErrors = this.definitionErrors.concat(ruleErrors);\n        const ruleImplementation = this.defineRule(name, impl, config);\n        this[name] = ruleImplementation;\n        return ruleImplementation;\n    }\n    BACKTRACK(grammarRule, args) {\n        return function () {\n            // save org state\n            this.isBackTrackingStack.push(1);\n            const orgState = this.saveRecogState();\n            try {\n                grammarRule.apply(this, args);\n                // if no exception was thrown we have succeed parsing the rule.\n                return true;\n            }\n            catch (e) {\n                if (isRecognitionException(e)) {\n                    return false;\n                }\n                else {\n                    throw e;\n                }\n            }\n            finally {\n                this.reloadRecogState(orgState);\n                this.isBackTrackingStack.pop();\n            }\n        };\n    }\n    // GAST export APIs\n    getGAstProductions() {\n        return this.gastProductionsCache;\n    }\n    getSerializedGastProductions() {\n        return serializeGrammar(values(this.gastProductionsCache));\n    }\n}\n//# sourceMappingURL=recognizer_api.js.map","import { EarlyExitException, isRecognitionException, NoViableAltException, } from \"../../exceptions_public.js\";\nimport { clone, has } from \"lodash-es\";\nimport { getLookaheadPathsForOptionalProd, getLookaheadPathsForOr, } from \"../../grammar/lookahead.js\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser.js\";\n/**\n * Trait responsible for runtime parsing errors.\n */\nexport class ErrorHandler {\n    initErrorHandler(config) {\n        this._errors = [];\n        this.errorMessageProvider = has(config, \"errorMessageProvider\")\n            ? config.errorMessageProvider // assumes end user provides the correct config value/type\n            : DEFAULT_PARSER_CONFIG.errorMessageProvider;\n    }\n    SAVE_ERROR(error) {\n        if (isRecognitionException(error)) {\n            error.context = {\n                ruleStack: this.getHumanReadableRuleStack(),\n                ruleOccurrenceStack: clone(this.RULE_OCCURRENCE_STACK),\n            };\n            this._errors.push(error);\n            return error;\n        }\n        else {\n            throw Error(\"Trying to save an Error which is not a RecognitionException\");\n        }\n    }\n    get errors() {\n        return clone(this._errors);\n    }\n    set errors(newErrors) {\n        this._errors = newErrors;\n    }\n    // TODO: consider caching the error message computed information\n    raiseEarlyExitException(occurrence, prodType, userDefinedErrMsg) {\n        const ruleName = this.getCurrRuleFullName();\n        const ruleGrammar = this.getGAstProductions()[ruleName];\n        const lookAheadPathsPerAlternative = getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, this.maxLookahead);\n        const insideProdPaths = lookAheadPathsPerAlternative[0];\n        const actualTokens = [];\n        for (let i = 1; i <= this.maxLookahead; i++) {\n            actualTokens.push(this.LA(i));\n        }\n        const msg = this.errorMessageProvider.buildEarlyExitMessage({\n            expectedIterationPaths: insideProdPaths,\n            actual: actualTokens,\n            previous: this.LA(0),\n            customUserDescription: userDefinedErrMsg,\n            ruleName: ruleName,\n        });\n        throw this.SAVE_ERROR(new EarlyExitException(msg, this.LA(1), this.LA(0)));\n    }\n    // TODO: consider caching the error message computed information\n    raiseNoAltException(occurrence, errMsgTypes) {\n        const ruleName = this.getCurrRuleFullName();\n        const ruleGrammar = this.getGAstProductions()[ruleName];\n        // TODO: getLookaheadPathsForOr can be slow for large enough maxLookahead and certain grammars, consider caching ?\n        const lookAheadPathsPerAlternative = getLookaheadPathsForOr(occurrence, ruleGrammar, this.maxLookahead);\n        const actualTokens = [];\n        for (let i = 1; i <= this.maxLookahead; i++) {\n            actualTokens.push(this.LA(i));\n        }\n        const previousToken = this.LA(0);\n        const errMsg = this.errorMessageProvider.buildNoViableAltMessage({\n            expectedPathsPerAlt: lookAheadPathsPerAlternative,\n            actual: actualTokens,\n            previous: previousToken,\n            customUserDescription: errMsgTypes,\n            ruleName: this.getCurrRuleFullName(),\n        });\n        throw this.SAVE_ERROR(new NoViableAltException(errMsg, this.LA(1), previousToken));\n    }\n}\n//# sourceMappingURL=error_handler.js.map","import { NextAfterTokenWalker, nextPossibleTokensAfter, } from \"../../grammar/interpreter.js\";\nimport { first, isUndefined } from \"lodash-es\";\nexport class ContentAssist {\n    initContentAssist() { }\n    computeContentAssist(startRuleName, precedingInput) {\n        const startRuleGast = this.gastProductionsCache[startRuleName];\n        if (isUndefined(startRuleGast)) {\n            throw Error(`Rule ->${startRuleName}<- does not exist in this grammar.`);\n        }\n        return nextPossibleTokensAfter([startRuleGast], precedingInput, this.tokenMatcher, this.maxLookahead);\n    }\n    // TODO: should this be a member method or a utility? it does not have any state or usage of 'this'...\n    // TODO: should this be more explicitly part of the public API?\n    getNextPossibleTokenTypes(grammarPath) {\n        const topRuleName = first(grammarPath.ruleStack);\n        const gastProductions = this.getGAstProductions();\n        const topProduction = gastProductions[topRuleName];\n        const nextPossibleTokenTypes = new NextAfterTokenWalker(topProduction, grammarPath).startWalking();\n        return nextPossibleTokenTypes;\n    }\n}\n//# sourceMappingURL=context_assist.js.map","import { has } from \"lodash-es\";\nimport { timer } from \"@chevrotain/utils\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser.js\";\n/**\n * Trait responsible for runtime parsing errors.\n */\nexport class PerformanceTracer {\n    initPerformanceTracer(config) {\n        if (has(config, \"traceInitPerf\")) {\n            const userTraceInitPerf = config.traceInitPerf;\n            const traceIsNumber = typeof userTraceInitPerf === \"number\";\n            this.traceInitMaxIdent = traceIsNumber\n                ? userTraceInitPerf\n                : Infinity;\n            this.traceInitPerf = traceIsNumber\n                ? userTraceInitPerf > 0\n                : userTraceInitPerf; // assumes end user provides the correct config value/type\n        }\n        else {\n            this.traceInitMaxIdent = 0;\n            this.traceInitPerf = DEFAULT_PARSER_CONFIG.traceInitPerf;\n        }\n        this.traceInitIndent = -1;\n    }\n    TRACE_INIT(phaseDesc, phaseImpl) {\n        // No need to optimize this using NOOP pattern because\n        // It is not called in a hot spot...\n        if (this.traceInitPerf === true) {\n            this.traceInitIndent++;\n            const indent = new Array(this.traceInitIndent + 1).join(\"\\t\");\n            if (this.traceInitIndent < this.traceInitMaxIdent) {\n                console.log(`${indent}--> <${phaseDesc}>`);\n            }\n            const { time, value } = timer(phaseImpl);\n            /* istanbul ignore next - Difficult to reproduce specific performance behavior (>10ms) in tests */\n            const traceMethod = time > 10 ? console.warn : console.log;\n            if (this.traceInitIndent < this.traceInitMaxIdent) {\n                traceMethod(`${indent}<-- <${phaseDesc}> time: ${time}ms`);\n            }\n            this.traceInitIndent--;\n            return value;\n        }\n        else {\n            return phaseImpl();\n        }\n    }\n}\n//# sourceMappingURL=perf_tracer.js.map","/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport map from \"lodash-es/map.js\";\nimport filter from \"lodash-es/filter.js\";\nimport { Alternation, NonTerminal, Option, RepetitionMandatory, Repetition, Terminal, RepetitionWithSeparator, RepetitionMandatoryWithSeparator } from \"chevrotain\";\nexport function buildATNKey(rule, type, occurrence) {\n    return `${rule.name}_${type}_${occurrence}`;\n}\nexport const ATN_INVALID_TYPE = 0;\nexport const ATN_BASIC = 1;\nexport const ATN_RULE_START = 2;\nexport const ATN_PLUS_BLOCK_START = 4;\nexport const ATN_STAR_BLOCK_START = 5;\n// Currently unused as the ATN is not used for lexing\nexport const ATN_TOKEN_START = 6;\nexport const ATN_RULE_STOP = 7;\nexport const ATN_BLOCK_END = 8;\nexport const ATN_STAR_LOOP_BACK = 9;\nexport const ATN_STAR_LOOP_ENTRY = 10;\nexport const ATN_PLUS_LOOP_BACK = 11;\nexport const ATN_LOOP_END = 12;\nexport class AbstractTransition {\n    constructor(target) {\n        this.target = target;\n    }\n    isEpsilon() {\n        return false;\n    }\n}\nexport class AtomTransition extends AbstractTransition {\n    constructor(target, tokenType) {\n        super(target);\n        this.tokenType = tokenType;\n    }\n}\nexport class EpsilonTransition extends AbstractTransition {\n    constructor(target) {\n        super(target);\n    }\n    isEpsilon() {\n        return true;\n    }\n}\nexport class RuleTransition extends AbstractTransition {\n    constructor(ruleStart, rule, followState) {\n        super(ruleStart);\n        this.rule = rule;\n        this.followState = followState;\n    }\n    isEpsilon() {\n        return true;\n    }\n}\nexport function createATN(rules) {\n    const atn = {\n        decisionMap: {},\n        decisionStates: [],\n        ruleToStartState: new Map(),\n        ruleToStopState: new Map(),\n        states: []\n    };\n    createRuleStartAndStopATNStates(atn, rules);\n    const ruleLength = rules.length;\n    for (let i = 0; i < ruleLength; i++) {\n        const rule = rules[i];\n        const ruleBlock = block(atn, rule, rule);\n        if (ruleBlock === undefined) {\n            continue;\n        }\n        buildRuleHandle(atn, rule, ruleBlock);\n    }\n    return atn;\n}\nfunction createRuleStartAndStopATNStates(atn, rules) {\n    const ruleLength = rules.length;\n    for (let i = 0; i < ruleLength; i++) {\n        const rule = rules[i];\n        const start = newState(atn, rule, undefined, {\n            type: ATN_RULE_START\n        });\n        const stop = newState(atn, rule, undefined, {\n            type: ATN_RULE_STOP\n        });\n        start.stop = stop;\n        atn.ruleToStartState.set(rule, start);\n        atn.ruleToStopState.set(rule, stop);\n    }\n}\nfunction atom(atn, rule, production) {\n    if (production instanceof Terminal) {\n        return tokenRef(atn, rule, production.terminalType, production);\n    }\n    else if (production instanceof NonTerminal) {\n        return ruleRef(atn, rule, production);\n    }\n    else if (production instanceof Alternation) {\n        return alternation(atn, rule, production);\n    }\n    else if (production instanceof Option) {\n        return option(atn, rule, production);\n    }\n    else if (production instanceof Repetition) {\n        return repetition(atn, rule, production);\n    }\n    else if (production instanceof RepetitionWithSeparator) {\n        return repetitionSep(atn, rule, production);\n    }\n    else if (production instanceof RepetitionMandatory) {\n        return repetitionMandatory(atn, rule, production);\n    }\n    else if (production instanceof RepetitionMandatoryWithSeparator) {\n        return repetitionMandatorySep(atn, rule, production);\n    }\n    else {\n        return block(atn, rule, production);\n    }\n}\nfunction repetition(atn, rule, repetition) {\n    const starState = newState(atn, rule, repetition, {\n        type: ATN_STAR_BLOCK_START\n    });\n    defineDecisionState(atn, starState);\n    const handle = makeAlts(atn, rule, starState, repetition, block(atn, rule, repetition));\n    return star(atn, rule, repetition, handle);\n}\nfunction repetitionSep(atn, rule, repetition) {\n    const starState = newState(atn, rule, repetition, {\n        type: ATN_STAR_BLOCK_START\n    });\n    defineDecisionState(atn, starState);\n    const handle = makeAlts(atn, rule, starState, repetition, block(atn, rule, repetition));\n    const sep = tokenRef(atn, rule, repetition.separator, repetition);\n    return star(atn, rule, repetition, handle, sep);\n}\nfunction repetitionMandatory(atn, rule, repetition) {\n    const plusState = newState(atn, rule, repetition, {\n        type: ATN_PLUS_BLOCK_START\n    });\n    defineDecisionState(atn, plusState);\n    const handle = makeAlts(atn, rule, plusState, repetition, block(atn, rule, repetition));\n    return plus(atn, rule, repetition, handle);\n}\nfunction repetitionMandatorySep(atn, rule, repetition) {\n    const plusState = newState(atn, rule, repetition, {\n        type: ATN_PLUS_BLOCK_START\n    });\n    defineDecisionState(atn, plusState);\n    const handle = makeAlts(atn, rule, plusState, repetition, block(atn, rule, repetition));\n    const sep = tokenRef(atn, rule, repetition.separator, repetition);\n    return plus(atn, rule, repetition, handle, sep);\n}\nfunction alternation(atn, rule, alternation) {\n    const start = newState(atn, rule, alternation, {\n        type: ATN_BASIC\n    });\n    defineDecisionState(atn, start);\n    const alts = map(alternation.definition, (e) => atom(atn, rule, e));\n    const handle = makeAlts(atn, rule, start, alternation, ...alts);\n    return handle;\n}\nfunction option(atn, rule, option) {\n    const start = newState(atn, rule, option, {\n        type: ATN_BASIC\n    });\n    defineDecisionState(atn, start);\n    const handle = makeAlts(atn, rule, start, option, block(atn, rule, option));\n    return optional(atn, rule, option, handle);\n}\nfunction block(atn, rule, block) {\n    const handles = filter(map(block.definition, (e) => atom(atn, rule, e)), (e) => e !== undefined);\n    if (handles.length === 1) {\n        return handles[0];\n    }\n    else if (handles.length === 0) {\n        return undefined;\n    }\n    else {\n        return makeBlock(atn, handles);\n    }\n}\nfunction plus(atn, rule, plus, handle, sep) {\n    const blkStart = handle.left;\n    const blkEnd = handle.right;\n    const loop = newState(atn, rule, plus, {\n        type: ATN_PLUS_LOOP_BACK\n    });\n    defineDecisionState(atn, loop);\n    const end = newState(atn, rule, plus, {\n        type: ATN_LOOP_END\n    });\n    blkStart.loopback = loop;\n    end.loopback = loop;\n    atn.decisionMap[buildATNKey(rule, sep ? 'RepetitionMandatoryWithSeparator' : 'RepetitionMandatory', plus.idx)] = loop;\n    epsilon(blkEnd, loop); // block can see loop back\n    // Depending on whether we have a separator we put the exit transition at index 1 or 0\n    // This influences the chosen option in the lookahead DFA\n    if (sep === undefined) {\n        epsilon(loop, blkStart); // loop back to start\n        epsilon(loop, end); // exit\n    }\n    else {\n        epsilon(loop, end); // exit\n        // loop back to start with separator\n        epsilon(loop, sep.left);\n        epsilon(sep.right, blkStart);\n    }\n    return {\n        left: blkStart,\n        right: end\n    };\n}\nfunction star(atn, rule, star, handle, sep) {\n    const start = handle.left;\n    const end = handle.right;\n    const entry = newState(atn, rule, star, {\n        type: ATN_STAR_LOOP_ENTRY\n    });\n    defineDecisionState(atn, entry);\n    const loopEnd = newState(atn, rule, star, {\n        type: ATN_LOOP_END\n    });\n    const loop = newState(atn, rule, star, {\n        type: ATN_STAR_LOOP_BACK\n    });\n    entry.loopback = loop;\n    loopEnd.loopback = loop;\n    epsilon(entry, start); // loop enter edge (alt 2)\n    epsilon(entry, loopEnd); // bypass loop edge (alt 1)\n    epsilon(end, loop); // block end hits loop back\n    if (sep !== undefined) {\n        epsilon(loop, loopEnd); // end loop\n        // loop back to start of handle using separator\n        epsilon(loop, sep.left);\n        epsilon(sep.right, start);\n    }\n    else {\n        epsilon(loop, entry); // loop back to entry/exit decision\n    }\n    atn.decisionMap[buildATNKey(rule, sep ? 'RepetitionWithSeparator' : 'Repetition', star.idx)] = entry;\n    return {\n        left: entry,\n        right: loopEnd\n    };\n}\nfunction optional(atn, rule, optional, handle) {\n    const start = handle.left;\n    const end = handle.right;\n    epsilon(start, end);\n    atn.decisionMap[buildATNKey(rule, 'Option', optional.idx)] = start;\n    return handle;\n}\nfunction defineDecisionState(atn, state) {\n    atn.decisionStates.push(state);\n    state.decision = atn.decisionStates.length - 1;\n    return state.decision;\n}\nfunction makeAlts(atn, rule, start, production, ...alts) {\n    const end = newState(atn, rule, production, {\n        type: ATN_BLOCK_END,\n        start\n    });\n    start.end = end;\n    for (const alt of alts) {\n        if (alt !== undefined) {\n            // hook alts up to decision block\n            epsilon(start, alt.left);\n            epsilon(alt.right, end);\n        }\n        else {\n            epsilon(start, end);\n        }\n    }\n    const handle = {\n        left: start,\n        right: end\n    };\n    atn.decisionMap[buildATNKey(rule, getProdType(production), production.idx)] = start;\n    return handle;\n}\nfunction getProdType(production) {\n    if (production instanceof Alternation) {\n        return 'Alternation';\n    }\n    else if (production instanceof Option) {\n        return 'Option';\n    }\n    else if (production instanceof Repetition) {\n        return 'Repetition';\n    }\n    else if (production instanceof RepetitionWithSeparator) {\n        return 'RepetitionWithSeparator';\n    }\n    else if (production instanceof RepetitionMandatory) {\n        return 'RepetitionMandatory';\n    }\n    else if (production instanceof RepetitionMandatoryWithSeparator) {\n        return 'RepetitionMandatoryWithSeparator';\n    }\n    else {\n        throw new Error('Invalid production type encountered');\n    }\n}\nfunction makeBlock(atn, alts) {\n    const altsLength = alts.length;\n    for (let i = 0; i < altsLength - 1; i++) {\n        const handle = alts[i];\n        let transition;\n        if (handle.left.transitions.length === 1) {\n            transition = handle.left.transitions[0];\n        }\n        const isRuleTransition = transition instanceof RuleTransition;\n        const ruleTransition = transition;\n        const next = alts[i + 1].left;\n        if (handle.left.type === ATN_BASIC &&\n            handle.right.type === ATN_BASIC &&\n            transition !== undefined &&\n            ((isRuleTransition && ruleTransition.followState === handle.right) ||\n                transition.target === handle.right)) {\n            // we can avoid epsilon edge to next element\n            if (isRuleTransition) {\n                ruleTransition.followState = next;\n            }\n            else {\n                transition.target = next;\n            }\n            removeState(atn, handle.right); // we skipped over this state\n        }\n        else {\n            // need epsilon if previous block's right end node is complex\n            epsilon(handle.right, next);\n        }\n    }\n    const first = alts[0];\n    const last = alts[altsLength - 1];\n    return {\n        left: first.left,\n        right: last.right\n    };\n}\nfunction tokenRef(atn, rule, tokenType, production) {\n    const left = newState(atn, rule, production, {\n        type: ATN_BASIC\n    });\n    const right = newState(atn, rule, production, {\n        type: ATN_BASIC\n    });\n    addTransition(left, new AtomTransition(right, tokenType));\n    return {\n        left,\n        right\n    };\n}\nfunction ruleRef(atn, currentRule, nonTerminal) {\n    const rule = nonTerminal.referencedRule;\n    const start = atn.ruleToStartState.get(rule);\n    const left = newState(atn, currentRule, nonTerminal, {\n        type: ATN_BASIC\n    });\n    const right = newState(atn, currentRule, nonTerminal, {\n        type: ATN_BASIC\n    });\n    const call = new RuleTransition(start, rule, right);\n    addTransition(left, call);\n    return {\n        left,\n        right\n    };\n}\nfunction buildRuleHandle(atn, rule, block) {\n    const start = atn.ruleToStartState.get(rule);\n    epsilon(start, block.left);\n    const stop = atn.ruleToStopState.get(rule);\n    epsilon(block.right, stop);\n    const handle = {\n        left: start,\n        right: stop\n    };\n    return handle;\n}\nfunction epsilon(a, b) {\n    const transition = new EpsilonTransition(b);\n    addTransition(a, transition);\n}\nfunction newState(atn, rule, production, partial) {\n    const t = Object.assign({ atn,\n        production, epsilonOnlyTransitions: false, rule, transitions: [], nextTokenWithinRule: [], stateNumber: atn.states.length }, partial);\n    atn.states.push(t);\n    return t;\n}\nfunction addTransition(state, transition) {\n    // A single ATN state can only contain epsilon transitions or non-epsilon transitions\n    // Because they are never mixed, only setting the property for the first transition is fine\n    if (state.transitions.length === 0) {\n        state.epsilonOnlyTransitions = transition.isEpsilon();\n    }\n    state.transitions.push(transition);\n}\nfunction removeState(atn, state) {\n    atn.states.splice(atn.states.indexOf(state), 1);\n}\n//# sourceMappingURL=atn.js.map","/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport map from \"lodash-es/map.js\";\nexport const DFA_ERROR = {};\nexport class ATNConfigSet {\n    constructor() {\n        this.map = {};\n        this.configs = [];\n    }\n    get size() {\n        return this.configs.length;\n    }\n    finalize() {\n        // Empties the map to free up memory\n        this.map = {};\n    }\n    add(config) {\n        const key = getATNConfigKey(config);\n        // Only add configs which don't exist in our map already\n        // While this does not influence the actual algorithm, adding them anyway would massively increase memory consumption\n        if (!(key in this.map)) {\n            this.map[key] = this.configs.length;\n            this.configs.push(config);\n        }\n    }\n    get elements() {\n        return this.configs;\n    }\n    get alts() {\n        return map(this.configs, (e) => e.alt);\n    }\n    get key() {\n        let value = \"\";\n        for (const k in this.map) {\n            value += k + \":\";\n        }\n        return value;\n    }\n}\nexport function getATNConfigKey(config, alt = true) {\n    return `${alt ? `a${config.alt}` : \"\"}s${config.state.stateNumber}:${config.stack.map((e) => e.stateNumber.toString()).join(\"_\")}`;\n}\n//# sourceMappingURL=dfa.js.map","/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { tokenMatcher, tokenLabel, NonTerminal, Alternation, Option, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Repetition, Terminal, LLkLookaheadStrategy, getLookaheadPaths } from \"chevrotain\";\nimport { ATN_RULE_STOP, AtomTransition, buildATNKey, createATN, EpsilonTransition, RuleTransition } from \"./atn.js\";\nimport { ATNConfigSet, DFA_ERROR, getATNConfigKey } from \"./dfa.js\";\nimport min from \"lodash-es/min.js\";\nimport flatMap from \"lodash-es/flatMap.js\";\nimport uniqBy from \"lodash-es/uniqBy.js\";\nimport map from \"lodash-es/map.js\";\nimport flatten from \"lodash-es/flatten.js\";\nimport forEach from \"lodash-es/forEach.js\";\nimport isEmpty from \"lodash-es/isEmpty.js\";\nimport reduce from \"lodash-es/reduce.js\";\nfunction createDFACache(startState, decision) {\n    const map = {};\n    return (predicateSet) => {\n        const key = predicateSet.toString();\n        let existing = map[key];\n        if (existing !== undefined) {\n            return existing;\n        }\n        else {\n            existing = {\n                atnStartState: startState,\n                decision,\n                states: {}\n            };\n            map[key] = existing;\n            return existing;\n        }\n    };\n}\nclass PredicateSet {\n    constructor() {\n        this.predicates = [];\n    }\n    is(index) {\n        return index >= this.predicates.length || this.predicates[index];\n    }\n    set(index, value) {\n        this.predicates[index] = value;\n    }\n    toString() {\n        let value = \"\";\n        const size = this.predicates.length;\n        for (let i = 0; i < size; i++) {\n            value += this.predicates[i] === true ? \"1\" : \"0\";\n        }\n        return value;\n    }\n}\nconst EMPTY_PREDICATES = new PredicateSet();\nexport class LLStarLookaheadStrategy extends LLkLookaheadStrategy {\n    constructor(options) {\n        var _a;\n        super();\n        this.logging = (_a = options === null || options === void 0 ? void 0 : options.logging) !== null && _a !== void 0 ? _a : ((message) => console.log(message));\n    }\n    initialize(options) {\n        this.atn = createATN(options.rules);\n        this.dfas = initATNSimulator(this.atn);\n    }\n    validateAmbiguousAlternationAlternatives() {\n        return [];\n    }\n    validateEmptyOrAlternatives() {\n        return [];\n    }\n    buildLookaheadForAlternation(options) {\n        const { prodOccurrence, rule, hasPredicates, dynamicTokensEnabled } = options;\n        const dfas = this.dfas;\n        const logging = this.logging;\n        const key = buildATNKey(rule, 'Alternation', prodOccurrence);\n        const decisionState = this.atn.decisionMap[key];\n        const decisionIndex = decisionState.decision;\n        const partialAlts = map(getLookaheadPaths({\n            maxLookahead: 1,\n            occurrence: prodOccurrence,\n            prodType: \"Alternation\",\n            rule: rule\n        }), (currAlt) => map(currAlt, (path) => path[0]));\n        if (isLL1Sequence(partialAlts, false) && !dynamicTokensEnabled) {\n            const choiceToAlt = reduce(partialAlts, (result, currAlt, idx) => {\n                forEach(currAlt, (currTokType) => {\n                    if (currTokType) {\n                        result[currTokType.tokenTypeIdx] = idx;\n                        forEach(currTokType.categoryMatches, (currExtendingType) => {\n                            result[currExtendingType] = idx;\n                        });\n                    }\n                });\n                return result;\n            }, {});\n            if (hasPredicates) {\n                return function (orAlts) {\n                    var _a;\n                    const nextToken = this.LA(1);\n                    const prediction = choiceToAlt[nextToken.tokenTypeIdx];\n                    if (orAlts !== undefined && prediction !== undefined) {\n                        const gate = (_a = orAlts[prediction]) === null || _a === void 0 ? void 0 : _a.GATE;\n                        if (gate !== undefined && gate.call(this) === false) {\n                            return undefined;\n                        }\n                    }\n                    return prediction;\n                };\n            }\n            else {\n                return function () {\n                    const nextToken = this.LA(1);\n                    return choiceToAlt[nextToken.tokenTypeIdx];\n                };\n            }\n        }\n        else if (hasPredicates) {\n            return function (orAlts) {\n                const predicates = new PredicateSet();\n                const length = orAlts === undefined ? 0 : orAlts.length;\n                for (let i = 0; i < length; i++) {\n                    const gate = orAlts === null || orAlts === void 0 ? void 0 : orAlts[i].GATE;\n                    predicates.set(i, gate === undefined || gate.call(this));\n                }\n                const result = adaptivePredict.call(this, dfas, decisionIndex, predicates, logging);\n                return typeof result === 'number' ? result : undefined;\n            };\n        }\n        else {\n            return function () {\n                const result = adaptivePredict.call(this, dfas, decisionIndex, EMPTY_PREDICATES, logging);\n                return typeof result === 'number' ? result : undefined;\n            };\n        }\n    }\n    buildLookaheadForOptional(options) {\n        const { prodOccurrence, rule, prodType, dynamicTokensEnabled } = options;\n        const dfas = this.dfas;\n        const logging = this.logging;\n        const key = buildATNKey(rule, prodType, prodOccurrence);\n        const decisionState = this.atn.decisionMap[key];\n        const decisionIndex = decisionState.decision;\n        const alts = map(getLookaheadPaths({\n            maxLookahead: 1,\n            occurrence: prodOccurrence,\n            prodType,\n            rule\n        }), (e) => {\n            return map(e, (g) => g[0]);\n        });\n        if (isLL1Sequence(alts) && alts[0][0] && !dynamicTokensEnabled) {\n            const alt = alts[0];\n            const singleTokensTypes = flatten(alt);\n            if (singleTokensTypes.length === 1 &&\n                isEmpty(singleTokensTypes[0].categoryMatches)) {\n                const expectedTokenType = singleTokensTypes[0];\n                const expectedTokenUniqueKey = expectedTokenType.tokenTypeIdx;\n                return function () {\n                    return this.LA(1).tokenTypeIdx === expectedTokenUniqueKey;\n                };\n            }\n            else {\n                const choiceToAlt = reduce(singleTokensTypes, (result, currTokType) => {\n                    if (currTokType !== undefined) {\n                        result[currTokType.tokenTypeIdx] = true;\n                        forEach(currTokType.categoryMatches, (currExtendingType) => {\n                            result[currExtendingType] = true;\n                        });\n                    }\n                    return result;\n                }, {});\n                return function () {\n                    const nextToken = this.LA(1);\n                    return choiceToAlt[nextToken.tokenTypeIdx] === true;\n                };\n            }\n        }\n        return function () {\n            const result = adaptivePredict.call(this, dfas, decisionIndex, EMPTY_PREDICATES, logging);\n            return typeof result === \"object\" ? false : result === 0;\n        };\n    }\n}\nfunction isLL1Sequence(sequences, allowEmpty = true) {\n    const fullSet = new Set();\n    for (const alt of sequences) {\n        const altSet = new Set();\n        for (const tokType of alt) {\n            if (tokType === undefined) {\n                if (allowEmpty) {\n                    // Epsilon production encountered\n                    break;\n                }\n                else {\n                    return false;\n                }\n            }\n            const indices = [tokType.tokenTypeIdx].concat(tokType.categoryMatches);\n            for (const index of indices) {\n                if (fullSet.has(index)) {\n                    if (!altSet.has(index)) {\n                        return false;\n                    }\n                }\n                else {\n                    fullSet.add(index);\n                    altSet.add(index);\n                }\n            }\n        }\n    }\n    return true;\n}\nfunction initATNSimulator(atn) {\n    const decisionLength = atn.decisionStates.length;\n    const decisionToDFA = Array(decisionLength);\n    for (let i = 0; i < decisionLength; i++) {\n        decisionToDFA[i] = createDFACache(atn.decisionStates[i], i);\n    }\n    return decisionToDFA;\n}\nfunction adaptivePredict(dfaCaches, decision, predicateSet, logging) {\n    const dfa = dfaCaches[decision](predicateSet);\n    let start = dfa.start;\n    if (start === undefined) {\n        const closure = computeStartState(dfa.atnStartState);\n        start = addDFAState(dfa, newDFAState(closure));\n        dfa.start = start;\n    }\n    const alt = performLookahead.apply(this, [dfa, start, predicateSet, logging]);\n    return alt;\n}\nfunction performLookahead(dfa, s0, predicateSet, logging) {\n    let previousD = s0;\n    let i = 1;\n    const path = [];\n    let t = this.LA(i++);\n    while (true) {\n        let d = getExistingTargetState(previousD, t);\n        if (d === undefined) {\n            d = computeLookaheadTarget.apply(this, [dfa, previousD, t, i, predicateSet, logging]);\n        }\n        if (d === DFA_ERROR) {\n            return buildAdaptivePredictError(path, previousD, t);\n        }\n        if (d.isAcceptState === true) {\n            return d.prediction;\n        }\n        previousD = d;\n        path.push(t);\n        t = this.LA(i++);\n    }\n}\nfunction computeLookaheadTarget(dfa, previousD, token, lookahead, predicateSet, logging) {\n    const reach = computeReachSet(previousD.configs, token, predicateSet);\n    if (reach.size === 0) {\n        addDFAEdge(dfa, previousD, token, DFA_ERROR);\n        return DFA_ERROR;\n    }\n    let newState = newDFAState(reach);\n    const predictedAlt = getUniqueAlt(reach, predicateSet);\n    if (predictedAlt !== undefined) {\n        newState.isAcceptState = true;\n        newState.prediction = predictedAlt;\n        newState.configs.uniqueAlt = predictedAlt;\n    }\n    else if (hasConflictTerminatingPrediction(reach)) {\n        const prediction = min(reach.alts);\n        newState.isAcceptState = true;\n        newState.prediction = prediction;\n        newState.configs.uniqueAlt = prediction;\n        reportLookaheadAmbiguity.apply(this, [dfa, lookahead, reach.alts, logging]);\n    }\n    newState = addDFAEdge(dfa, previousD, token, newState);\n    return newState;\n}\nfunction reportLookaheadAmbiguity(dfa, lookahead, ambiguityIndices, logging) {\n    const prefixPath = [];\n    for (let i = 1; i <= lookahead; i++) {\n        prefixPath.push(this.LA(i).tokenType);\n    }\n    const atnState = dfa.atnStartState;\n    const topLevelRule = atnState.rule;\n    const production = atnState.production;\n    const message = buildAmbiguityError({\n        topLevelRule,\n        ambiguityIndices,\n        production,\n        prefixPath\n    });\n    logging(message);\n}\nfunction buildAmbiguityError(options) {\n    const pathMsg = map(options.prefixPath, (currtok) => tokenLabel(currtok)).join(\", \");\n    const occurrence = options.production.idx === 0 ? \"\" : options.production.idx;\n    let currMessage = `Ambiguous Alternatives Detected: <${options.ambiguityIndices.join(\", \")}> in <${getProductionDslName(options.production)}${occurrence}>` +\n        ` inside <${options.topLevelRule.name}> Rule,\\n` +\n        `<${pathMsg}> may appears as a prefix path in all these alternatives.\\n`;\n    currMessage =\n        currMessage +\n            `See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#AMBIGUOUS_ALTERNATIVES\\n` +\n            `For Further details.`;\n    return currMessage;\n}\nfunction getProductionDslName(prod) {\n    if (prod instanceof NonTerminal) {\n        return \"SUBRULE\";\n    }\n    else if (prod instanceof Option) {\n        return \"OPTION\";\n    }\n    else if (prod instanceof Alternation) {\n        return \"OR\";\n    }\n    else if (prod instanceof RepetitionMandatory) {\n        return \"AT_LEAST_ONE\";\n    }\n    else if (prod instanceof RepetitionMandatoryWithSeparator) {\n        return \"AT_LEAST_ONE_SEP\";\n    }\n    else if (prod instanceof RepetitionWithSeparator) {\n        return \"MANY_SEP\";\n    }\n    else if (prod instanceof Repetition) {\n        return \"MANY\";\n    }\n    else if (prod instanceof Terminal) {\n        return \"CONSUME\";\n    }\n    else {\n        throw Error(\"non exhaustive match\");\n    }\n}\nfunction buildAdaptivePredictError(path, previous, current) {\n    const nextTransitions = flatMap(previous.configs.elements, (e) => e.state.transitions);\n    const nextTokenTypes = uniqBy(nextTransitions\n        .filter((e) => e instanceof AtomTransition)\n        .map((e) => e.tokenType), (e) => e.tokenTypeIdx);\n    return {\n        actualToken: current,\n        possibleTokenTypes: nextTokenTypes,\n        tokenPath: path\n    };\n}\nfunction getExistingTargetState(state, token) {\n    return state.edges[token.tokenTypeIdx];\n}\nfunction computeReachSet(configs, token, predicateSet) {\n    const intermediate = new ATNConfigSet();\n    const skippedStopStates = [];\n    for (const c of configs.elements) {\n        if (predicateSet.is(c.alt) === false) {\n            continue;\n        }\n        if (c.state.type === ATN_RULE_STOP) {\n            skippedStopStates.push(c);\n            continue;\n        }\n        const transitionLength = c.state.transitions.length;\n        for (let i = 0; i < transitionLength; i++) {\n            const transition = c.state.transitions[i];\n            const target = getReachableTarget(transition, token);\n            if (target !== undefined) {\n                intermediate.add({\n                    state: target,\n                    alt: c.alt,\n                    stack: c.stack\n                });\n            }\n        }\n    }\n    let reach;\n    if (skippedStopStates.length === 0 && intermediate.size === 1) {\n        reach = intermediate;\n    }\n    if (reach === undefined) {\n        reach = new ATNConfigSet();\n        for (const c of intermediate.elements) {\n            closure(c, reach);\n        }\n    }\n    if (skippedStopStates.length > 0 && !hasConfigInRuleStopState(reach)) {\n        for (const c of skippedStopStates) {\n            reach.add(c);\n        }\n    }\n    return reach;\n}\nfunction getReachableTarget(transition, token) {\n    if (transition instanceof AtomTransition &&\n        tokenMatcher(token, transition.tokenType)) {\n        return transition.target;\n    }\n    return undefined;\n}\nfunction getUniqueAlt(configs, predicateSet) {\n    let alt;\n    for (const c of configs.elements) {\n        if (predicateSet.is(c.alt) === true) {\n            if (alt === undefined) {\n                alt = c.alt;\n            }\n            else if (alt !== c.alt) {\n                return undefined;\n            }\n        }\n    }\n    return alt;\n}\nfunction newDFAState(closure) {\n    return {\n        configs: closure,\n        edges: {},\n        isAcceptState: false,\n        prediction: -1\n    };\n}\nfunction addDFAEdge(dfa, from, token, to) {\n    to = addDFAState(dfa, to);\n    from.edges[token.tokenTypeIdx] = to;\n    return to;\n}\nfunction addDFAState(dfa, state) {\n    if (state === DFA_ERROR) {\n        return state;\n    }\n    // Repetitions have the same config set\n    // Therefore, storing the key of the config in a map allows us to create a loop in our DFA\n    const mapKey = state.configs.key;\n    const existing = dfa.states[mapKey];\n    if (existing !== undefined) {\n        return existing;\n    }\n    state.configs.finalize();\n    dfa.states[mapKey] = state;\n    return state;\n}\nfunction computeStartState(atnState) {\n    const configs = new ATNConfigSet();\n    const numberOfTransitions = atnState.transitions.length;\n    for (let i = 0; i < numberOfTransitions; i++) {\n        const target = atnState.transitions[i].target;\n        const config = {\n            state: target,\n            alt: i,\n            stack: []\n        };\n        closure(config, configs);\n    }\n    return configs;\n}\nfunction closure(config, configs) {\n    const p = config.state;\n    if (p.type === ATN_RULE_STOP) {\n        if (config.stack.length > 0) {\n            const atnStack = [...config.stack];\n            const followState = atnStack.pop();\n            const followConfig = {\n                state: followState,\n                alt: config.alt,\n                stack: atnStack\n            };\n            closure(followConfig, configs);\n        }\n        else {\n            // Dipping into outer context, simply add the config\n            // This will stop computation once every config is at the rule stop state\n            configs.add(config);\n        }\n        return;\n    }\n    if (!p.epsilonOnlyTransitions) {\n        configs.add(config);\n    }\n    const transitionLength = p.transitions.length;\n    for (let i = 0; i < transitionLength; i++) {\n        const transition = p.transitions[i];\n        const c = getEpsilonTarget(config, transition);\n        if (c !== undefined) {\n            closure(c, configs);\n        }\n    }\n}\nfunction getEpsilonTarget(config, transition) {\n    if (transition instanceof EpsilonTransition) {\n        return {\n            state: transition.target,\n            alt: config.alt,\n            stack: config.stack\n        };\n    }\n    else if (transition instanceof RuleTransition) {\n        const stack = [...config.stack, transition.followState];\n        return {\n            state: transition.target,\n            alt: config.alt,\n            stack\n        };\n    }\n    return undefined;\n}\nfunction hasConfigInRuleStopState(configs) {\n    for (const c of configs.elements) {\n        if (c.state.type === ATN_RULE_STOP) {\n            return true;\n        }\n    }\n    return false;\n}\nfunction allConfigsInRuleStopStates(configs) {\n    for (const c of configs.elements) {\n        if (c.state.type !== ATN_RULE_STOP) {\n            return false;\n        }\n    }\n    return true;\n}\nfunction hasConflictTerminatingPrediction(configs) {\n    if (allConfigsInRuleStopStates(configs)) {\n        return true;\n    }\n    const altSets = getConflictingAltSets(configs.elements);\n    const heuristic = hasConflictingAltSet(altSets) && !hasStateAssociatedWithOneAlt(altSets);\n    return heuristic;\n}\nfunction getConflictingAltSets(configs) {\n    const configToAlts = new Map();\n    for (const c of configs) {\n        const key = getATNConfigKey(c, false);\n        let alts = configToAlts.get(key);\n        if (alts === undefined) {\n            alts = {};\n            configToAlts.set(key, alts);\n        }\n        alts[c.alt] = true;\n    }\n    return configToAlts;\n}\nfunction hasConflictingAltSet(altSets) {\n    for (const value of Array.from(altSets.values())) {\n        if (Object.keys(value).length > 1) {\n            return true;\n        }\n    }\n    return false;\n}\nfunction hasStateAssociatedWithOneAlt(altSets) {\n    for (const value of Array.from(altSets.values())) {\n        if (Object.keys(value).length === 1) {\n            return true;\n        }\n    }\n    return false;\n}\n//# sourceMappingURL=all-star-lookahead.js.map","import baseIteratee from './_baseIteratee.js';\nimport baseUniq from './_baseUniq.js';\n\n/**\n * This method is like `_.uniq` except that it accepts `iteratee` which is\n * invoked for each element in `array` to generate the criterion by which\n * uniqueness is computed. The order of result values is determined by the\n * order they occur in the array. The iteratee is invoked with one argument:\n * (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {Array} Returns the new duplicate free array.\n * @example\n *\n * _.uniqBy([2.1, 1.2, 2.3], Math.floor);\n * // => [2.1, 1.2]\n *\n * // The `_.property` iteratee shorthand.\n * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');\n * // => [{ 'x': 1 }, { 'x': 2 }]\n */\nfunction uniqBy(array, iteratee) {\n  return (array && array.length) ? baseUniq(array, baseIteratee(iteratee, 2)) : [];\n}\n\nexport default uniqBy;\n","/* --------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n * ------------------------------------------------------------------------------------------ */\n'use strict';\nexport var DocumentUri;\n(function (DocumentUri) {\n    function is(value) {\n        return typeof value === 'string';\n    }\n    DocumentUri.is = is;\n})(DocumentUri || (DocumentUri = {}));\nexport var URI;\n(function (URI) {\n    function is(value) {\n        return typeof value === 'string';\n    }\n    URI.is = is;\n})(URI || (URI = {}));\nexport var integer;\n(function (integer) {\n    integer.MIN_VALUE = -2147483648;\n    integer.MAX_VALUE = 2147483647;\n    function is(value) {\n        return typeof value === 'number' && integer.MIN_VALUE <= value && value <= integer.MAX_VALUE;\n    }\n    integer.is = is;\n})(integer || (integer = {}));\nexport var uinteger;\n(function (uinteger) {\n    uinteger.MIN_VALUE = 0;\n    uinteger.MAX_VALUE = 2147483647;\n    function is(value) {\n        return typeof value === 'number' && uinteger.MIN_VALUE <= value && value <= uinteger.MAX_VALUE;\n    }\n    uinteger.is = is;\n})(uinteger || (uinteger = {}));\n/**\n * The Position namespace provides helper functions to work with\n * {@link Position} literals.\n */\nexport var Position;\n(function (Position) {\n    /**\n     * Creates a new Position literal from the given line and character.\n     * @param line The position's line.\n     * @param character The position's character.\n     */\n    function create(line, character) {\n        if (line === Number.MAX_VALUE) {\n            line = uinteger.MAX_VALUE;\n        }\n        if (character === Number.MAX_VALUE) {\n            character = uinteger.MAX_VALUE;\n        }\n        return { line, character };\n    }\n    Position.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link Position} interface.\n     */\n    function is(value) {\n        let candidate = value;\n        return Is.objectLiteral(candidate) && Is.uinteger(candidate.line) && Is.uinteger(candidate.character);\n    }\n    Position.is = is;\n})(Position || (Position = {}));\n/**\n * The Range namespace provides helper functions to work with\n * {@link Range} literals.\n */\nexport var Range;\n(function (Range) {\n    function create(one, two, three, four) {\n        if (Is.uinteger(one) && Is.uinteger(two) && Is.uinteger(three) && Is.uinteger(four)) {\n            return { start: Position.create(one, two), end: Position.create(three, four) };\n        }\n        else if (Position.is(one) && Position.is(two)) {\n            return { start: one, end: two };\n        }\n        else {\n            throw new Error(`Range#create called with invalid arguments[${one}, ${two}, ${three}, ${four}]`);\n        }\n    }\n    Range.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link Range} interface.\n     */\n    function is(value) {\n        let candidate = value;\n        return Is.objectLiteral(candidate) && Position.is(candidate.start) && Position.is(candidate.end);\n    }\n    Range.is = is;\n})(Range || (Range = {}));\n/**\n * The Location namespace provides helper functions to work with\n * {@link Location} literals.\n */\nexport var Location;\n(function (Location) {\n    /**\n     * Creates a Location literal.\n     * @param uri The location's uri.\n     * @param range The location's range.\n     */\n    function create(uri, range) {\n        return { uri, range };\n    }\n    Location.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link Location} interface.\n     */\n    function is(value) {\n        let candidate = value;\n        return Is.objectLiteral(candidate) && Range.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));\n    }\n    Location.is = is;\n})(Location || (Location = {}));\n/**\n * The LocationLink namespace provides helper functions to work with\n * {@link LocationLink} literals.\n */\nexport var LocationLink;\n(function (LocationLink) {\n    /**\n     * Creates a LocationLink literal.\n     * @param targetUri The definition's uri.\n     * @param targetRange The full range of the definition.\n     * @param targetSelectionRange The span of the symbol definition at the target.\n     * @param originSelectionRange The span of the symbol being defined in the originating source file.\n     */\n    function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {\n        return { targetUri, targetRange, targetSelectionRange, originSelectionRange };\n    }\n    LocationLink.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link LocationLink} interface.\n     */\n    function is(value) {\n        let candidate = value;\n        return Is.objectLiteral(candidate) && Range.is(candidate.targetRange) && Is.string(candidate.targetUri)\n            && Range.is(candidate.targetSelectionRange)\n            && (Range.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));\n    }\n    LocationLink.is = is;\n})(LocationLink || (LocationLink = {}));\n/**\n * The Color namespace provides helper functions to work with\n * {@link Color} literals.\n */\nexport var Color;\n(function (Color) {\n    /**\n     * Creates a new Color literal.\n     */\n    function create(red, green, blue, alpha) {\n        return {\n            red,\n            green,\n            blue,\n            alpha,\n        };\n    }\n    Color.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link Color} interface.\n     */\n    function is(value) {\n        const candidate = value;\n        return Is.objectLiteral(candidate) && Is.numberRange(candidate.red, 0, 1)\n            && Is.numberRange(candidate.green, 0, 1)\n            && Is.numberRange(candidate.blue, 0, 1)\n            && Is.numberRange(candidate.alpha, 0, 1);\n    }\n    Color.is = is;\n})(Color || (Color = {}));\n/**\n * The ColorInformation namespace provides helper functions to work with\n * {@link ColorInformation} literals.\n */\nexport var ColorInformation;\n(function (ColorInformation) {\n    /**\n     * Creates a new ColorInformation literal.\n     */\n    function create(range, color) {\n        return {\n            range,\n            color,\n        };\n    }\n    ColorInformation.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link ColorInformation} interface.\n     */\n    function is(value) {\n        const candidate = value;\n        return Is.objectLiteral(candidate) && Range.is(candidate.range) && Color.is(candidate.color);\n    }\n    ColorInformation.is = is;\n})(ColorInformation || (ColorInformation = {}));\n/**\n * The Color namespace provides helper functions to work with\n * {@link ColorPresentation} literals.\n */\nexport var ColorPresentation;\n(function (ColorPresentation) {\n    /**\n     * Creates a new ColorInformation literal.\n     */\n    function create(label, textEdit, additionalTextEdits) {\n        return {\n            label,\n            textEdit,\n            additionalTextEdits,\n        };\n    }\n    ColorPresentation.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link ColorInformation} interface.\n     */\n    function is(value) {\n        const candidate = value;\n        return Is.objectLiteral(candidate) && Is.string(candidate.label)\n            && (Is.undefined(candidate.textEdit) || TextEdit.is(candidate))\n            && (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit.is));\n    }\n    ColorPresentation.is = is;\n})(ColorPresentation || (ColorPresentation = {}));\n/**\n * A set of predefined range kinds.\n */\nexport var FoldingRangeKind;\n(function (FoldingRangeKind) {\n    /**\n     * Folding range for a comment\n     */\n    FoldingRangeKind.Comment = 'comment';\n    /**\n     * Folding range for an import or include\n     */\n    FoldingRangeKind.Imports = 'imports';\n    /**\n     * Folding range for a region (e.g. `#region`)\n     */\n    FoldingRangeKind.Region = 'region';\n})(FoldingRangeKind || (FoldingRangeKind = {}));\n/**\n * The folding range namespace provides helper functions to work with\n * {@link FoldingRange} literals.\n */\nexport var FoldingRange;\n(function (FoldingRange) {\n    /**\n     * Creates a new FoldingRange literal.\n     */\n    function create(startLine, endLine, startCharacter, endCharacter, kind, collapsedText) {\n        const result = {\n            startLine,\n            endLine\n        };\n        if (Is.defined(startCharacter)) {\n            result.startCharacter = startCharacter;\n        }\n        if (Is.defined(endCharacter)) {\n            result.endCharacter = endCharacter;\n        }\n        if (Is.defined(kind)) {\n            result.kind = kind;\n        }\n        if (Is.defined(collapsedText)) {\n            result.collapsedText = collapsedText;\n        }\n        return result;\n    }\n    FoldingRange.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link FoldingRange} interface.\n     */\n    function is(value) {\n        const candidate = value;\n        return Is.objectLiteral(candidate) && Is.uinteger(candidate.startLine) && Is.uinteger(candidate.startLine)\n            && (Is.undefined(candidate.startCharacter) || Is.uinteger(candidate.startCharacter))\n            && (Is.undefined(candidate.endCharacter) || Is.uinteger(candidate.endCharacter))\n            && (Is.undefined(candidate.kind) || Is.string(candidate.kind));\n    }\n    FoldingRange.is = is;\n})(FoldingRange || (FoldingRange = {}));\n/**\n * The DiagnosticRelatedInformation namespace provides helper functions to work with\n * {@link DiagnosticRelatedInformation} literals.\n */\nexport var DiagnosticRelatedInformation;\n(function (DiagnosticRelatedInformation) {\n    /**\n     * Creates a new DiagnosticRelatedInformation literal.\n     */\n    function create(location, message) {\n        return {\n            location,\n            message\n        };\n    }\n    DiagnosticRelatedInformation.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link DiagnosticRelatedInformation} interface.\n     */\n    function is(value) {\n        let candidate = value;\n        return Is.defined(candidate) && Location.is(candidate.location) && Is.string(candidate.message);\n    }\n    DiagnosticRelatedInformation.is = is;\n})(DiagnosticRelatedInformation || (DiagnosticRelatedInformation = {}));\n/**\n * The diagnostic's severity.\n */\nexport var DiagnosticSeverity;\n(function (DiagnosticSeverity) {\n    /**\n     * Reports an error.\n     */\n    DiagnosticSeverity.Error = 1;\n    /**\n     * Reports a warning.\n     */\n    DiagnosticSeverity.Warning = 2;\n    /**\n     * Reports an information.\n     */\n    DiagnosticSeverity.Information = 3;\n    /**\n     * Reports a hint.\n     */\n    DiagnosticSeverity.Hint = 4;\n})(DiagnosticSeverity || (DiagnosticSeverity = {}));\n/**\n * The diagnostic tags.\n *\n * @since 3.15.0\n */\nexport var DiagnosticTag;\n(function (DiagnosticTag) {\n    /**\n     * Unused or unnecessary code.\n     *\n     * Clients are allowed to render diagnostics with this tag faded out instead of having\n     * an error squiggle.\n     */\n    DiagnosticTag.Unnecessary = 1;\n    /**\n     * Deprecated or obsolete code.\n     *\n     * Clients are allowed to rendered diagnostics with this tag strike through.\n     */\n    DiagnosticTag.Deprecated = 2;\n})(DiagnosticTag || (DiagnosticTag = {}));\n/**\n * The CodeDescription namespace provides functions to deal with descriptions for diagnostic codes.\n *\n * @since 3.16.0\n */\nexport var CodeDescription;\n(function (CodeDescription) {\n    function is(value) {\n        const candidate = value;\n        return Is.objectLiteral(candidate) && Is.string(candidate.href);\n    }\n    CodeDescription.is = is;\n})(CodeDescription || (CodeDescription = {}));\n/**\n * The Diagnostic namespace provides helper functions to work with\n * {@link Diagnostic} literals.\n */\nexport var Diagnostic;\n(function (Diagnostic) {\n    /**\n     * Creates a new Diagnostic literal.\n     */\n    function create(range, message, severity, code, source, relatedInformation) {\n        let result = { range, message };\n        if (Is.defined(severity)) {\n            result.severity = severity;\n        }\n        if (Is.defined(code)) {\n            result.code = code;\n        }\n        if (Is.defined(source)) {\n            result.source = source;\n        }\n        if (Is.defined(relatedInformation)) {\n            result.relatedInformation = relatedInformation;\n        }\n        return result;\n    }\n    Diagnostic.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link Diagnostic} interface.\n     */\n    function is(value) {\n        var _a;\n        let candidate = value;\n        return Is.defined(candidate)\n            && Range.is(candidate.range)\n            && Is.string(candidate.message)\n            && (Is.number(candidate.severity) || Is.undefined(candidate.severity))\n            && (Is.integer(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code))\n            && (Is.undefined(candidate.codeDescription) || (Is.string((_a = candidate.codeDescription) === null || _a === void 0 ? void 0 : _a.href)))\n            && (Is.string(candidate.source) || Is.undefined(candidate.source))\n            && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation.is));\n    }\n    Diagnostic.is = is;\n})(Diagnostic || (Diagnostic = {}));\n/**\n * The Command namespace provides helper functions to work with\n * {@link Command} literals.\n */\nexport var Command;\n(function (Command) {\n    /**\n     * Creates a new Command literal.\n     */\n    function create(title, command, ...args) {\n        let result = { title, command };\n        if (Is.defined(args) && args.length > 0) {\n            result.arguments = args;\n        }\n        return result;\n    }\n    Command.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link Command} interface.\n     */\n    function is(value) {\n        let candidate = value;\n        return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.command);\n    }\n    Command.is = is;\n})(Command || (Command = {}));\n/**\n * The TextEdit namespace provides helper function to create replace,\n * insert and delete edits more easily.\n */\nexport var TextEdit;\n(function (TextEdit) {\n    /**\n     * Creates a replace text edit.\n     * @param range The range of text to be replaced.\n     * @param newText The new text.\n     */\n    function replace(range, newText) {\n        return { range, newText };\n    }\n    TextEdit.replace = replace;\n    /**\n     * Creates an insert text edit.\n     * @param position The position to insert the text at.\n     * @param newText The text to be inserted.\n     */\n    function insert(position, newText) {\n        return { range: { start: position, end: position }, newText };\n    }\n    TextEdit.insert = insert;\n    /**\n     * Creates a delete text edit.\n     * @param range The range of text to be deleted.\n     */\n    function del(range) {\n        return { range, newText: '' };\n    }\n    TextEdit.del = del;\n    function is(value) {\n        const candidate = value;\n        return Is.objectLiteral(candidate)\n            && Is.string(candidate.newText)\n            && Range.is(candidate.range);\n    }\n    TextEdit.is = is;\n})(TextEdit || (TextEdit = {}));\nexport var ChangeAnnotation;\n(function (ChangeAnnotation) {\n    function create(label, needsConfirmation, description) {\n        const result = { label };\n        if (needsConfirmation !== undefined) {\n            result.needsConfirmation = needsConfirmation;\n        }\n        if (description !== undefined) {\n            result.description = description;\n        }\n        return result;\n    }\n    ChangeAnnotation.create = create;\n    function is(value) {\n        const candidate = value;\n        return Is.objectLiteral(candidate) && Is.string(candidate.label) &&\n            (Is.boolean(candidate.needsConfirmation) || candidate.needsConfirmation === undefined) &&\n            (Is.string(candidate.description) || candidate.description === undefined);\n    }\n    ChangeAnnotation.is = is;\n})(ChangeAnnotation || (ChangeAnnotation = {}));\nexport var ChangeAnnotationIdentifier;\n(function (ChangeAnnotationIdentifier) {\n    function is(value) {\n        const candidate = value;\n        return Is.string(candidate);\n    }\n    ChangeAnnotationIdentifier.is = is;\n})(ChangeAnnotationIdentifier || (ChangeAnnotationIdentifier = {}));\nexport var AnnotatedTextEdit;\n(function (AnnotatedTextEdit) {\n    /**\n     * Creates an annotated replace text edit.\n     *\n     * @param range The range of text to be replaced.\n     * @param newText The new text.\n     * @param annotation The annotation.\n     */\n    function replace(range, newText, annotation) {\n        return { range, newText, annotationId: annotation };\n    }\n    AnnotatedTextEdit.replace = replace;\n    /**\n     * Creates an annotated insert text edit.\n     *\n     * @param position The position to insert the text at.\n     * @param newText The text to be inserted.\n     * @param annotation The annotation.\n     */\n    function insert(position, newText, annotation) {\n        return { range: { start: position, end: position }, newText, annotationId: annotation };\n    }\n    AnnotatedTextEdit.insert = insert;\n    /**\n     * Creates an annotated delete text edit.\n     *\n     * @param range The range of text to be deleted.\n     * @param annotation The annotation.\n     */\n    function del(range, annotation) {\n        return { range, newText: '', annotationId: annotation };\n    }\n    AnnotatedTextEdit.del = del;\n    function is(value) {\n        const candidate = value;\n        return TextEdit.is(candidate) && (ChangeAnnotation.is(candidate.annotationId) || ChangeAnnotationIdentifier.is(candidate.annotationId));\n    }\n    AnnotatedTextEdit.is = is;\n})(AnnotatedTextEdit || (AnnotatedTextEdit = {}));\n/**\n * The TextDocumentEdit namespace provides helper function to create\n * an edit that manipulates a text document.\n */\nexport var TextDocumentEdit;\n(function (TextDocumentEdit) {\n    /**\n     * Creates a new `TextDocumentEdit`\n     */\n    function create(textDocument, edits) {\n        return { textDocument, edits };\n    }\n    TextDocumentEdit.create = create;\n    function is(value) {\n        let candidate = value;\n        return Is.defined(candidate)\n            && OptionalVersionedTextDocumentIdentifier.is(candidate.textDocument)\n            && Array.isArray(candidate.edits);\n    }\n    TextDocumentEdit.is = is;\n})(TextDocumentEdit || (TextDocumentEdit = {}));\nexport var CreateFile;\n(function (CreateFile) {\n    function create(uri, options, annotation) {\n        let result = {\n            kind: 'create',\n            uri\n        };\n        if (options !== undefined && (options.overwrite !== undefined || options.ignoreIfExists !== undefined)) {\n            result.options = options;\n        }\n        if (annotation !== undefined) {\n            result.annotationId = annotation;\n        }\n        return result;\n    }\n    CreateFile.create = create;\n    function is(value) {\n        let candidate = value;\n        return candidate && candidate.kind === 'create' && Is.string(candidate.uri) && (candidate.options === undefined ||\n            ((candidate.options.overwrite === undefined || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === undefined || Is.boolean(candidate.options.ignoreIfExists)))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));\n    }\n    CreateFile.is = is;\n})(CreateFile || (CreateFile = {}));\nexport var RenameFile;\n(function (RenameFile) {\n    function create(oldUri, newUri, options, annotation) {\n        let result = {\n            kind: 'rename',\n            oldUri,\n            newUri\n        };\n        if (options !== undefined && (options.overwrite !== undefined || options.ignoreIfExists !== undefined)) {\n            result.options = options;\n        }\n        if (annotation !== undefined) {\n            result.annotationId = annotation;\n        }\n        return result;\n    }\n    RenameFile.create = create;\n    function is(value) {\n        let candidate = value;\n        return candidate && candidate.kind === 'rename' && Is.string(candidate.oldUri) && Is.string(candidate.newUri) && (candidate.options === undefined ||\n            ((candidate.options.overwrite === undefined || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === undefined || Is.boolean(candidate.options.ignoreIfExists)))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));\n    }\n    RenameFile.is = is;\n})(RenameFile || (RenameFile = {}));\nexport var DeleteFile;\n(function (DeleteFile) {\n    function create(uri, options, annotation) {\n        let result = {\n            kind: 'delete',\n            uri\n        };\n        if (options !== undefined && (options.recursive !== undefined || options.ignoreIfNotExists !== undefined)) {\n            result.options = options;\n        }\n        if (annotation !== undefined) {\n            result.annotationId = annotation;\n        }\n        return result;\n    }\n    DeleteFile.create = create;\n    function is(value) {\n        let candidate = value;\n        return candidate && candidate.kind === 'delete' && Is.string(candidate.uri) && (candidate.options === undefined ||\n            ((candidate.options.recursive === undefined || Is.boolean(candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === undefined || Is.boolean(candidate.options.ignoreIfNotExists)))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));\n    }\n    DeleteFile.is = is;\n})(DeleteFile || (DeleteFile = {}));\nexport var WorkspaceEdit;\n(function (WorkspaceEdit) {\n    function is(value) {\n        let candidate = value;\n        return candidate &&\n            (candidate.changes !== undefined || candidate.documentChanges !== undefined) &&\n            (candidate.documentChanges === undefined || candidate.documentChanges.every((change) => {\n                if (Is.string(change.kind)) {\n                    return CreateFile.is(change) || RenameFile.is(change) || DeleteFile.is(change);\n                }\n                else {\n                    return TextDocumentEdit.is(change);\n                }\n            }));\n    }\n    WorkspaceEdit.is = is;\n})(WorkspaceEdit || (WorkspaceEdit = {}));\nclass TextEditChangeImpl {\n    constructor(edits, changeAnnotations) {\n        this.edits = edits;\n        this.changeAnnotations = changeAnnotations;\n    }\n    insert(position, newText, annotation) {\n        let edit;\n        let id;\n        if (annotation === undefined) {\n            edit = TextEdit.insert(position, newText);\n        }\n        else if (ChangeAnnotationIdentifier.is(annotation)) {\n            id = annotation;\n            edit = AnnotatedTextEdit.insert(position, newText, annotation);\n        }\n        else {\n            this.assertChangeAnnotations(this.changeAnnotations);\n            id = this.changeAnnotations.manage(annotation);\n            edit = AnnotatedTextEdit.insert(position, newText, id);\n        }\n        this.edits.push(edit);\n        if (id !== undefined) {\n            return id;\n        }\n    }\n    replace(range, newText, annotation) {\n        let edit;\n        let id;\n        if (annotation === undefined) {\n            edit = TextEdit.replace(range, newText);\n        }\n        else if (ChangeAnnotationIdentifier.is(annotation)) {\n            id = annotation;\n            edit = AnnotatedTextEdit.replace(range, newText, annotation);\n        }\n        else {\n            this.assertChangeAnnotations(this.changeAnnotations);\n            id = this.changeAnnotations.manage(annotation);\n            edit = AnnotatedTextEdit.replace(range, newText, id);\n        }\n        this.edits.push(edit);\n        if (id !== undefined) {\n            return id;\n        }\n    }\n    delete(range, annotation) {\n        let edit;\n        let id;\n        if (annotation === undefined) {\n            edit = TextEdit.del(range);\n        }\n        else if (ChangeAnnotationIdentifier.is(annotation)) {\n            id = annotation;\n            edit = AnnotatedTextEdit.del(range, annotation);\n        }\n        else {\n            this.assertChangeAnnotations(this.changeAnnotations);\n            id = this.changeAnnotations.manage(annotation);\n            edit = AnnotatedTextEdit.del(range, id);\n        }\n        this.edits.push(edit);\n        if (id !== undefined) {\n            return id;\n        }\n    }\n    add(edit) {\n        this.edits.push(edit);\n    }\n    all() {\n        return this.edits;\n    }\n    clear() {\n        this.edits.splice(0, this.edits.length);\n    }\n    assertChangeAnnotations(value) {\n        if (value === undefined) {\n            throw new Error(`Text edit change is not configured to manage change annotations.`);\n        }\n    }\n}\n/**\n * A helper class\n */\nclass ChangeAnnotations {\n    constructor(annotations) {\n        this._annotations = annotations === undefined ? Object.create(null) : annotations;\n        this._counter = 0;\n        this._size = 0;\n    }\n    all() {\n        return this._annotations;\n    }\n    get size() {\n        return this._size;\n    }\n    manage(idOrAnnotation, annotation) {\n        let id;\n        if (ChangeAnnotationIdentifier.is(idOrAnnotation)) {\n            id = idOrAnnotation;\n        }\n        else {\n            id = this.nextId();\n            annotation = idOrAnnotation;\n        }\n        if (this._annotations[id] !== undefined) {\n            throw new Error(`Id ${id} is already in use.`);\n        }\n        if (annotation === undefined) {\n            throw new Error(`No annotation provided for id ${id}`);\n        }\n        this._annotations[id] = annotation;\n        this._size++;\n        return id;\n    }\n    nextId() {\n        this._counter++;\n        return this._counter.toString();\n    }\n}\n/**\n * A workspace change helps constructing changes to a workspace.\n */\nexport class WorkspaceChange {\n    constructor(workspaceEdit) {\n        this._textEditChanges = Object.create(null);\n        if (workspaceEdit !== undefined) {\n            this._workspaceEdit = workspaceEdit;\n            if (workspaceEdit.documentChanges) {\n                this._changeAnnotations = new ChangeAnnotations(workspaceEdit.changeAnnotations);\n                workspaceEdit.changeAnnotations = this._changeAnnotations.all();\n                workspaceEdit.documentChanges.forEach((change) => {\n                    if (TextDocumentEdit.is(change)) {\n                        const textEditChange = new TextEditChangeImpl(change.edits, this._changeAnnotations);\n                        this._textEditChanges[change.textDocument.uri] = textEditChange;\n                    }\n                });\n            }\n            else if (workspaceEdit.changes) {\n                Object.keys(workspaceEdit.changes).forEach((key) => {\n                    const textEditChange = new TextEditChangeImpl(workspaceEdit.changes[key]);\n                    this._textEditChanges[key] = textEditChange;\n                });\n            }\n        }\n        else {\n            this._workspaceEdit = {};\n        }\n    }\n    /**\n     * Returns the underlying {@link WorkspaceEdit} literal\n     * use to be returned from a workspace edit operation like rename.\n     */\n    get edit() {\n        this.initDocumentChanges();\n        if (this._changeAnnotations !== undefined) {\n            if (this._changeAnnotations.size === 0) {\n                this._workspaceEdit.changeAnnotations = undefined;\n            }\n            else {\n                this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();\n            }\n        }\n        return this._workspaceEdit;\n    }\n    getTextEditChange(key) {\n        if (OptionalVersionedTextDocumentIdentifier.is(key)) {\n            this.initDocumentChanges();\n            if (this._workspaceEdit.documentChanges === undefined) {\n                throw new Error('Workspace edit is not configured for document changes.');\n            }\n            const textDocument = { uri: key.uri, version: key.version };\n            let result = this._textEditChanges[textDocument.uri];\n            if (!result) {\n                const edits = [];\n                const textDocumentEdit = {\n                    textDocument,\n                    edits\n                };\n                this._workspaceEdit.documentChanges.push(textDocumentEdit);\n                result = new TextEditChangeImpl(edits, this._changeAnnotations);\n                this._textEditChanges[textDocument.uri] = result;\n            }\n            return result;\n        }\n        else {\n            this.initChanges();\n            if (this._workspaceEdit.changes === undefined) {\n                throw new Error('Workspace edit is not configured for normal text edit changes.');\n            }\n            let result = this._textEditChanges[key];\n            if (!result) {\n                let edits = [];\n                this._workspaceEdit.changes[key] = edits;\n                result = new TextEditChangeImpl(edits);\n                this._textEditChanges[key] = result;\n            }\n            return result;\n        }\n    }\n    initDocumentChanges() {\n        if (this._workspaceEdit.documentChanges === undefined && this._workspaceEdit.changes === undefined) {\n            this._changeAnnotations = new ChangeAnnotations();\n            this._workspaceEdit.documentChanges = [];\n            this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();\n        }\n    }\n    initChanges() {\n        if (this._workspaceEdit.documentChanges === undefined && this._workspaceEdit.changes === undefined) {\n            this._workspaceEdit.changes = Object.create(null);\n        }\n    }\n    createFile(uri, optionsOrAnnotation, options) {\n        this.initDocumentChanges();\n        if (this._workspaceEdit.documentChanges === undefined) {\n            throw new Error('Workspace edit is not configured for document changes.');\n        }\n        let annotation;\n        if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {\n            annotation = optionsOrAnnotation;\n        }\n        else {\n            options = optionsOrAnnotation;\n        }\n        let operation;\n        let id;\n        if (annotation === undefined) {\n            operation = CreateFile.create(uri, options);\n        }\n        else {\n            id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);\n            operation = CreateFile.create(uri, options, id);\n        }\n        this._workspaceEdit.documentChanges.push(operation);\n        if (id !== undefined) {\n            return id;\n        }\n    }\n    renameFile(oldUri, newUri, optionsOrAnnotation, options) {\n        this.initDocumentChanges();\n        if (this._workspaceEdit.documentChanges === undefined) {\n            throw new Error('Workspace edit is not configured for document changes.');\n        }\n        let annotation;\n        if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {\n            annotation = optionsOrAnnotation;\n        }\n        else {\n            options = optionsOrAnnotation;\n        }\n        let operation;\n        let id;\n        if (annotation === undefined) {\n            operation = RenameFile.create(oldUri, newUri, options);\n        }\n        else {\n            id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);\n            operation = RenameFile.create(oldUri, newUri, options, id);\n        }\n        this._workspaceEdit.documentChanges.push(operation);\n        if (id !== undefined) {\n            return id;\n        }\n    }\n    deleteFile(uri, optionsOrAnnotation, options) {\n        this.initDocumentChanges();\n        if (this._workspaceEdit.documentChanges === undefined) {\n            throw new Error('Workspace edit is not configured for document changes.');\n        }\n        let annotation;\n        if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {\n            annotation = optionsOrAnnotation;\n        }\n        else {\n            options = optionsOrAnnotation;\n        }\n        let operation;\n        let id;\n        if (annotation === undefined) {\n            operation = DeleteFile.create(uri, options);\n        }\n        else {\n            id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);\n            operation = DeleteFile.create(uri, options, id);\n        }\n        this._workspaceEdit.documentChanges.push(operation);\n        if (id !== undefined) {\n            return id;\n        }\n    }\n}\n/**\n * The TextDocumentIdentifier namespace provides helper functions to work with\n * {@link TextDocumentIdentifier} literals.\n */\nexport var TextDocumentIdentifier;\n(function (TextDocumentIdentifier) {\n    /**\n     * Creates a new TextDocumentIdentifier literal.\n     * @param uri The document's uri.\n     */\n    function create(uri) {\n        return { uri };\n    }\n    TextDocumentIdentifier.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link TextDocumentIdentifier} interface.\n     */\n    function is(value) {\n        let candidate = value;\n        return Is.defined(candidate) && Is.string(candidate.uri);\n    }\n    TextDocumentIdentifier.is = is;\n})(TextDocumentIdentifier || (TextDocumentIdentifier = {}));\n/**\n * The VersionedTextDocumentIdentifier namespace provides helper functions to work with\n * {@link VersionedTextDocumentIdentifier} literals.\n */\nexport var VersionedTextDocumentIdentifier;\n(function (VersionedTextDocumentIdentifier) {\n    /**\n     * Creates a new VersionedTextDocumentIdentifier literal.\n     * @param uri The document's uri.\n     * @param version The document's version.\n     */\n    function create(uri, version) {\n        return { uri, version };\n    }\n    VersionedTextDocumentIdentifier.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link VersionedTextDocumentIdentifier} interface.\n     */\n    function is(value) {\n        let candidate = value;\n        return Is.defined(candidate) && Is.string(candidate.uri) && Is.integer(candidate.version);\n    }\n    VersionedTextDocumentIdentifier.is = is;\n})(VersionedTextDocumentIdentifier || (VersionedTextDocumentIdentifier = {}));\n/**\n * The OptionalVersionedTextDocumentIdentifier namespace provides helper functions to work with\n * {@link OptionalVersionedTextDocumentIdentifier} literals.\n */\nexport var OptionalVersionedTextDocumentIdentifier;\n(function (OptionalVersionedTextDocumentIdentifier) {\n    /**\n     * Creates a new OptionalVersionedTextDocumentIdentifier literal.\n     * @param uri The document's uri.\n     * @param version The document's version.\n     */\n    function create(uri, version) {\n        return { uri, version };\n    }\n    OptionalVersionedTextDocumentIdentifier.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link OptionalVersionedTextDocumentIdentifier} interface.\n     */\n    function is(value) {\n        let candidate = value;\n        return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.integer(candidate.version));\n    }\n    OptionalVersionedTextDocumentIdentifier.is = is;\n})(OptionalVersionedTextDocumentIdentifier || (OptionalVersionedTextDocumentIdentifier = {}));\n/**\n * The TextDocumentItem namespace provides helper functions to work with\n * {@link TextDocumentItem} literals.\n */\nexport var TextDocumentItem;\n(function (TextDocumentItem) {\n    /**\n     * Creates a new TextDocumentItem literal.\n     * @param uri The document's uri.\n     * @param languageId The document's language identifier.\n     * @param version The document's version number.\n     * @param text The document's text.\n     */\n    function create(uri, languageId, version, text) {\n        return { uri, languageId, version, text };\n    }\n    TextDocumentItem.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link TextDocumentItem} interface.\n     */\n    function is(value) {\n        let candidate = value;\n        return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.integer(candidate.version) && Is.string(candidate.text);\n    }\n    TextDocumentItem.is = is;\n})(TextDocumentItem || (TextDocumentItem = {}));\n/**\n * Describes the content type that a client supports in various\n * result literals like `Hover`, `ParameterInfo` or `CompletionItem`.\n *\n * Please note that `MarkupKinds` must not start with a `$`. This kinds\n * are reserved for internal usage.\n */\nexport var MarkupKind;\n(function (MarkupKind) {\n    /**\n     * Plain text is supported as a content format\n     */\n    MarkupKind.PlainText = 'plaintext';\n    /**\n     * Markdown is supported as a content format\n     */\n    MarkupKind.Markdown = 'markdown';\n    /**\n     * Checks whether the given value is a value of the {@link MarkupKind} type.\n     */\n    function is(value) {\n        const candidate = value;\n        return candidate === MarkupKind.PlainText || candidate === MarkupKind.Markdown;\n    }\n    MarkupKind.is = is;\n})(MarkupKind || (MarkupKind = {}));\nexport var MarkupContent;\n(function (MarkupContent) {\n    /**\n     * Checks whether the given value conforms to the {@link MarkupContent} interface.\n     */\n    function is(value) {\n        const candidate = value;\n        return Is.objectLiteral(value) && MarkupKind.is(candidate.kind) && Is.string(candidate.value);\n    }\n    MarkupContent.is = is;\n})(MarkupContent || (MarkupContent = {}));\n/**\n * The kind of a completion entry.\n */\nexport var CompletionItemKind;\n(function (CompletionItemKind) {\n    CompletionItemKind.Text = 1;\n    CompletionItemKind.Method = 2;\n    CompletionItemKind.Function = 3;\n    CompletionItemKind.Constructor = 4;\n    CompletionItemKind.Field = 5;\n    CompletionItemKind.Variable = 6;\n    CompletionItemKind.Class = 7;\n    CompletionItemKind.Interface = 8;\n    CompletionItemKind.Module = 9;\n    CompletionItemKind.Property = 10;\n    CompletionItemKind.Unit = 11;\n    CompletionItemKind.Value = 12;\n    CompletionItemKind.Enum = 13;\n    CompletionItemKind.Keyword = 14;\n    CompletionItemKind.Snippet = 15;\n    CompletionItemKind.Color = 16;\n    CompletionItemKind.File = 17;\n    CompletionItemKind.Reference = 18;\n    CompletionItemKind.Folder = 19;\n    CompletionItemKind.EnumMember = 20;\n    CompletionItemKind.Constant = 21;\n    CompletionItemKind.Struct = 22;\n    CompletionItemKind.Event = 23;\n    CompletionItemKind.Operator = 24;\n    CompletionItemKind.TypeParameter = 25;\n})(CompletionItemKind || (CompletionItemKind = {}));\n/**\n * Defines whether the insert text in a completion item should be interpreted as\n * plain text or a snippet.\n */\nexport var InsertTextFormat;\n(function (InsertTextFormat) {\n    /**\n     * The primary text to be inserted is treated as a plain string.\n     */\n    InsertTextFormat.PlainText = 1;\n    /**\n     * The primary text to be inserted is treated as a snippet.\n     *\n     * A snippet can define tab stops and placeholders with `$1`, `$2`\n     * and `${3:foo}`. `$0` defines the final tab stop, it defaults to\n     * the end of the snippet. Placeholders with equal identifiers are linked,\n     * that is typing in one will update others too.\n     *\n     * See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#snippet_syntax\n     */\n    InsertTextFormat.Snippet = 2;\n})(InsertTextFormat || (InsertTextFormat = {}));\n/**\n * Completion item tags are extra annotations that tweak the rendering of a completion\n * item.\n *\n * @since 3.15.0\n */\nexport var CompletionItemTag;\n(function (CompletionItemTag) {\n    /**\n     * Render a completion as obsolete, usually using a strike-out.\n     */\n    CompletionItemTag.Deprecated = 1;\n})(CompletionItemTag || (CompletionItemTag = {}));\n/**\n * The InsertReplaceEdit namespace provides functions to deal with insert / replace edits.\n *\n * @since 3.16.0\n */\nexport var InsertReplaceEdit;\n(function (InsertReplaceEdit) {\n    /**\n     * Creates a new insert / replace edit\n     */\n    function create(newText, insert, replace) {\n        return { newText, insert, replace };\n    }\n    InsertReplaceEdit.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link InsertReplaceEdit} interface.\n     */\n    function is(value) {\n        const candidate = value;\n        return candidate && Is.string(candidate.newText) && Range.is(candidate.insert) && Range.is(candidate.replace);\n    }\n    InsertReplaceEdit.is = is;\n})(InsertReplaceEdit || (InsertReplaceEdit = {}));\n/**\n * How whitespace and indentation is handled during completion\n * item insertion.\n *\n * @since 3.16.0\n */\nexport var InsertTextMode;\n(function (InsertTextMode) {\n    /**\n     * The insertion or replace strings is taken as it is. If the\n     * value is multi line the lines below the cursor will be\n     * inserted using the indentation defined in the string value.\n     * The client will not apply any kind of adjustments to the\n     * string.\n     */\n    InsertTextMode.asIs = 1;\n    /**\n     * The editor adjusts leading whitespace of new lines so that\n     * they match the indentation up to the cursor of the line for\n     * which the item is accepted.\n     *\n     * Consider a line like this: <2tabs><cursor><3tabs>foo. Accepting a\n     * multi line completion item is indented using 2 tabs and all\n     * following lines inserted will be indented using 2 tabs as well.\n     */\n    InsertTextMode.adjustIndentation = 2;\n})(InsertTextMode || (InsertTextMode = {}));\nexport var CompletionItemLabelDetails;\n(function (CompletionItemLabelDetails) {\n    function is(value) {\n        const candidate = value;\n        return candidate && (Is.string(candidate.detail) || candidate.detail === undefined) &&\n            (Is.string(candidate.description) || candidate.description === undefined);\n    }\n    CompletionItemLabelDetails.is = is;\n})(CompletionItemLabelDetails || (CompletionItemLabelDetails = {}));\n/**\n * The CompletionItem namespace provides functions to deal with\n * completion items.\n */\nexport var CompletionItem;\n(function (CompletionItem) {\n    /**\n     * Create a completion item and seed it with a label.\n     * @param label The completion item's label\n     */\n    function create(label) {\n        return { label };\n    }\n    CompletionItem.create = create;\n})(CompletionItem || (CompletionItem = {}));\n/**\n * The CompletionList namespace provides functions to deal with\n * completion lists.\n */\nexport var CompletionList;\n(function (CompletionList) {\n    /**\n     * Creates a new completion list.\n     *\n     * @param items The completion items.\n     * @param isIncomplete The list is not complete.\n     */\n    function create(items, isIncomplete) {\n        return { items: items ? items : [], isIncomplete: !!isIncomplete };\n    }\n    CompletionList.create = create;\n})(CompletionList || (CompletionList = {}));\nexport var MarkedString;\n(function (MarkedString) {\n    /**\n     * Creates a marked string from plain text.\n     *\n     * @param plainText The plain text.\n     */\n    function fromPlainText(plainText) {\n        return plainText.replace(/[\\\\`*_{}[\\]()#+\\-.!]/g, '\\\\$&'); // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash\n    }\n    MarkedString.fromPlainText = fromPlainText;\n    /**\n     * Checks whether the given value conforms to the {@link MarkedString} type.\n     */\n    function is(value) {\n        const candidate = value;\n        return Is.string(candidate) || (Is.objectLiteral(candidate) && Is.string(candidate.language) && Is.string(candidate.value));\n    }\n    MarkedString.is = is;\n})(MarkedString || (MarkedString = {}));\nexport var Hover;\n(function (Hover) {\n    /**\n     * Checks whether the given value conforms to the {@link Hover} interface.\n     */\n    function is(value) {\n        let candidate = value;\n        return !!candidate && Is.objectLiteral(candidate) && (MarkupContent.is(candidate.contents) ||\n            MarkedString.is(candidate.contents) ||\n            Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === undefined || Range.is(value.range));\n    }\n    Hover.is = is;\n})(Hover || (Hover = {}));\n/**\n * The ParameterInformation namespace provides helper functions to work with\n * {@link ParameterInformation} literals.\n */\nexport var ParameterInformation;\n(function (ParameterInformation) {\n    /**\n     * Creates a new parameter information literal.\n     *\n     * @param label A label string.\n     * @param documentation A doc string.\n     */\n    function create(label, documentation) {\n        return documentation ? { label, documentation } : { label };\n    }\n    ParameterInformation.create = create;\n})(ParameterInformation || (ParameterInformation = {}));\n/**\n * The SignatureInformation namespace provides helper functions to work with\n * {@link SignatureInformation} literals.\n */\nexport var SignatureInformation;\n(function (SignatureInformation) {\n    function create(label, documentation, ...parameters) {\n        let result = { label };\n        if (Is.defined(documentation)) {\n            result.documentation = documentation;\n        }\n        if (Is.defined(parameters)) {\n            result.parameters = parameters;\n        }\n        else {\n            result.parameters = [];\n        }\n        return result;\n    }\n    SignatureInformation.create = create;\n})(SignatureInformation || (SignatureInformation = {}));\n/**\n * A document highlight kind.\n */\nexport var DocumentHighlightKind;\n(function (DocumentHighlightKind) {\n    /**\n     * A textual occurrence.\n     */\n    DocumentHighlightKind.Text = 1;\n    /**\n     * Read-access of a symbol, like reading a variable.\n     */\n    DocumentHighlightKind.Read = 2;\n    /**\n     * Write-access of a symbol, like writing to a variable.\n     */\n    DocumentHighlightKind.Write = 3;\n})(DocumentHighlightKind || (DocumentHighlightKind = {}));\n/**\n * DocumentHighlight namespace to provide helper functions to work with\n * {@link DocumentHighlight} literals.\n */\nexport var DocumentHighlight;\n(function (DocumentHighlight) {\n    /**\n     * Create a DocumentHighlight object.\n     * @param range The range the highlight applies to.\n     * @param kind The highlight kind\n     */\n    function create(range, kind) {\n        let result = { range };\n        if (Is.number(kind)) {\n            result.kind = kind;\n        }\n        return result;\n    }\n    DocumentHighlight.create = create;\n})(DocumentHighlight || (DocumentHighlight = {}));\n/**\n * A symbol kind.\n */\nexport var SymbolKind;\n(function (SymbolKind) {\n    SymbolKind.File = 1;\n    SymbolKind.Module = 2;\n    SymbolKind.Namespace = 3;\n    SymbolKind.Package = 4;\n    SymbolKind.Class = 5;\n    SymbolKind.Method = 6;\n    SymbolKind.Property = 7;\n    SymbolKind.Field = 8;\n    SymbolKind.Constructor = 9;\n    SymbolKind.Enum = 10;\n    SymbolKind.Interface = 11;\n    SymbolKind.Function = 12;\n    SymbolKind.Variable = 13;\n    SymbolKind.Constant = 14;\n    SymbolKind.String = 15;\n    SymbolKind.Number = 16;\n    SymbolKind.Boolean = 17;\n    SymbolKind.Array = 18;\n    SymbolKind.Object = 19;\n    SymbolKind.Key = 20;\n    SymbolKind.Null = 21;\n    SymbolKind.EnumMember = 22;\n    SymbolKind.Struct = 23;\n    SymbolKind.Event = 24;\n    SymbolKind.Operator = 25;\n    SymbolKind.TypeParameter = 26;\n})(SymbolKind || (SymbolKind = {}));\n/**\n * Symbol tags are extra annotations that tweak the rendering of a symbol.\n *\n * @since 3.16\n */\nexport var SymbolTag;\n(function (SymbolTag) {\n    /**\n     * Render a symbol as obsolete, usually using a strike-out.\n     */\n    SymbolTag.Deprecated = 1;\n})(SymbolTag || (SymbolTag = {}));\nexport var SymbolInformation;\n(function (SymbolInformation) {\n    /**\n     * Creates a new symbol information literal.\n     *\n     * @param name The name of the symbol.\n     * @param kind The kind of the symbol.\n     * @param range The range of the location of the symbol.\n     * @param uri The resource of the location of symbol.\n     * @param containerName The name of the symbol containing the symbol.\n     */\n    function create(name, kind, range, uri, containerName) {\n        let result = {\n            name,\n            kind,\n            location: { uri, range }\n        };\n        if (containerName) {\n            result.containerName = containerName;\n        }\n        return result;\n    }\n    SymbolInformation.create = create;\n})(SymbolInformation || (SymbolInformation = {}));\nexport var WorkspaceSymbol;\n(function (WorkspaceSymbol) {\n    /**\n     * Create a new workspace symbol.\n     *\n     * @param name The name of the symbol.\n     * @param kind The kind of the symbol.\n     * @param uri The resource of the location of the symbol.\n     * @param range An options range of the location.\n     * @returns A WorkspaceSymbol.\n     */\n    function create(name, kind, uri, range) {\n        return range !== undefined\n            ? { name, kind, location: { uri, range } }\n            : { name, kind, location: { uri } };\n    }\n    WorkspaceSymbol.create = create;\n})(WorkspaceSymbol || (WorkspaceSymbol = {}));\nexport var DocumentSymbol;\n(function (DocumentSymbol) {\n    /**\n     * Creates a new symbol information literal.\n     *\n     * @param name The name of the symbol.\n     * @param detail The detail of the symbol.\n     * @param kind The kind of the symbol.\n     * @param range The range of the symbol.\n     * @param selectionRange The selectionRange of the symbol.\n     * @param children Children of the symbol.\n     */\n    function create(name, detail, kind, range, selectionRange, children) {\n        let result = {\n            name,\n            detail,\n            kind,\n            range,\n            selectionRange\n        };\n        if (children !== undefined) {\n            result.children = children;\n        }\n        return result;\n    }\n    DocumentSymbol.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link DocumentSymbol} interface.\n     */\n    function is(value) {\n        let candidate = value;\n        return candidate &&\n            Is.string(candidate.name) && Is.number(candidate.kind) &&\n            Range.is(candidate.range) && Range.is(candidate.selectionRange) &&\n            (candidate.detail === undefined || Is.string(candidate.detail)) &&\n            (candidate.deprecated === undefined || Is.boolean(candidate.deprecated)) &&\n            (candidate.children === undefined || Array.isArray(candidate.children)) &&\n            (candidate.tags === undefined || Array.isArray(candidate.tags));\n    }\n    DocumentSymbol.is = is;\n})(DocumentSymbol || (DocumentSymbol = {}));\n/**\n * A set of predefined code action kinds\n */\nexport var CodeActionKind;\n(function (CodeActionKind) {\n    /**\n     * Empty kind.\n     */\n    CodeActionKind.Empty = '';\n    /**\n     * Base kind for quickfix actions: 'quickfix'\n     */\n    CodeActionKind.QuickFix = 'quickfix';\n    /**\n     * Base kind for refactoring actions: 'refactor'\n     */\n    CodeActionKind.Refactor = 'refactor';\n    /**\n     * Base kind for refactoring extraction actions: 'refactor.extract'\n     *\n     * Example extract actions:\n     *\n     * - Extract method\n     * - Extract function\n     * - Extract variable\n     * - Extract interface from class\n     * - ...\n     */\n    CodeActionKind.RefactorExtract = 'refactor.extract';\n    /**\n     * Base kind for refactoring inline actions: 'refactor.inline'\n     *\n     * Example inline actions:\n     *\n     * - Inline function\n     * - Inline variable\n     * - Inline constant\n     * - ...\n     */\n    CodeActionKind.RefactorInline = 'refactor.inline';\n    /**\n     * Base kind for refactoring rewrite actions: 'refactor.rewrite'\n     *\n     * Example rewrite actions:\n     *\n     * - Convert JavaScript function to class\n     * - Add or remove parameter\n     * - Encapsulate field\n     * - Make method static\n     * - Move method to base class\n     * - ...\n     */\n    CodeActionKind.RefactorRewrite = 'refactor.rewrite';\n    /**\n     * Base kind for source actions: `source`\n     *\n     * Source code actions apply to the entire file.\n     */\n    CodeActionKind.Source = 'source';\n    /**\n     * Base kind for an organize imports source action: `source.organizeImports`\n     */\n    CodeActionKind.SourceOrganizeImports = 'source.organizeImports';\n    /**\n     * Base kind for auto-fix source actions: `source.fixAll`.\n     *\n     * Fix all actions automatically fix errors that have a clear fix that do not require user input.\n     * They should not suppress errors or perform unsafe fixes such as generating new types or classes.\n     *\n     * @since 3.15.0\n     */\n    CodeActionKind.SourceFixAll = 'source.fixAll';\n})(CodeActionKind || (CodeActionKind = {}));\n/**\n * The reason why code actions were requested.\n *\n * @since 3.17.0\n */\nexport var CodeActionTriggerKind;\n(function (CodeActionTriggerKind) {\n    /**\n     * Code actions were explicitly requested by the user or by an extension.\n     */\n    CodeActionTriggerKind.Invoked = 1;\n    /**\n     * Code actions were requested automatically.\n     *\n     * This typically happens when current selection in a file changes, but can\n     * also be triggered when file content changes.\n     */\n    CodeActionTriggerKind.Automatic = 2;\n})(CodeActionTriggerKind || (CodeActionTriggerKind = {}));\n/**\n * The CodeActionContext namespace provides helper functions to work with\n * {@link CodeActionContext} literals.\n */\nexport var CodeActionContext;\n(function (CodeActionContext) {\n    /**\n     * Creates a new CodeActionContext literal.\n     */\n    function create(diagnostics, only, triggerKind) {\n        let result = { diagnostics };\n        if (only !== undefined && only !== null) {\n            result.only = only;\n        }\n        if (triggerKind !== undefined && triggerKind !== null) {\n            result.triggerKind = triggerKind;\n        }\n        return result;\n    }\n    CodeActionContext.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link CodeActionContext} interface.\n     */\n    function is(value) {\n        let candidate = value;\n        return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic.is)\n            && (candidate.only === undefined || Is.typedArray(candidate.only, Is.string))\n            && (candidate.triggerKind === undefined || candidate.triggerKind === CodeActionTriggerKind.Invoked || candidate.triggerKind === CodeActionTriggerKind.Automatic);\n    }\n    CodeActionContext.is = is;\n})(CodeActionContext || (CodeActionContext = {}));\nexport var CodeAction;\n(function (CodeAction) {\n    function create(title, kindOrCommandOrEdit, kind) {\n        let result = { title };\n        let checkKind = true;\n        if (typeof kindOrCommandOrEdit === 'string') {\n            checkKind = false;\n            result.kind = kindOrCommandOrEdit;\n        }\n        else if (Command.is(kindOrCommandOrEdit)) {\n            result.command = kindOrCommandOrEdit;\n        }\n        else {\n            result.edit = kindOrCommandOrEdit;\n        }\n        if (checkKind && kind !== undefined) {\n            result.kind = kind;\n        }\n        return result;\n    }\n    CodeAction.create = create;\n    function is(value) {\n        let candidate = value;\n        return candidate && Is.string(candidate.title) &&\n            (candidate.diagnostics === undefined || Is.typedArray(candidate.diagnostics, Diagnostic.is)) &&\n            (candidate.kind === undefined || Is.string(candidate.kind)) &&\n            (candidate.edit !== undefined || candidate.command !== undefined) &&\n            (candidate.command === undefined || Command.is(candidate.command)) &&\n            (candidate.isPreferred === undefined || Is.boolean(candidate.isPreferred)) &&\n            (candidate.edit === undefined || WorkspaceEdit.is(candidate.edit));\n    }\n    CodeAction.is = is;\n})(CodeAction || (CodeAction = {}));\n/**\n * The CodeLens namespace provides helper functions to work with\n * {@link CodeLens} literals.\n */\nexport var CodeLens;\n(function (CodeLens) {\n    /**\n     * Creates a new CodeLens literal.\n     */\n    function create(range, data) {\n        let result = { range };\n        if (Is.defined(data)) {\n            result.data = data;\n        }\n        return result;\n    }\n    CodeLens.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link CodeLens} interface.\n     */\n    function is(value) {\n        let candidate = value;\n        return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.command) || Command.is(candidate.command));\n    }\n    CodeLens.is = is;\n})(CodeLens || (CodeLens = {}));\n/**\n * The FormattingOptions namespace provides helper functions to work with\n * {@link FormattingOptions} literals.\n */\nexport var FormattingOptions;\n(function (FormattingOptions) {\n    /**\n     * Creates a new FormattingOptions literal.\n     */\n    function create(tabSize, insertSpaces) {\n        return { tabSize, insertSpaces };\n    }\n    FormattingOptions.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link FormattingOptions} interface.\n     */\n    function is(value) {\n        let candidate = value;\n        return Is.defined(candidate) && Is.uinteger(candidate.tabSize) && Is.boolean(candidate.insertSpaces);\n    }\n    FormattingOptions.is = is;\n})(FormattingOptions || (FormattingOptions = {}));\n/**\n * The DocumentLink namespace provides helper functions to work with\n * {@link DocumentLink} literals.\n */\nexport var DocumentLink;\n(function (DocumentLink) {\n    /**\n     * Creates a new DocumentLink literal.\n     */\n    function create(range, target, data) {\n        return { range, target, data };\n    }\n    DocumentLink.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link DocumentLink} interface.\n     */\n    function is(value) {\n        let candidate = value;\n        return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));\n    }\n    DocumentLink.is = is;\n})(DocumentLink || (DocumentLink = {}));\n/**\n * The SelectionRange namespace provides helper function to work with\n * SelectionRange literals.\n */\nexport var SelectionRange;\n(function (SelectionRange) {\n    /**\n     * Creates a new SelectionRange\n     * @param range the range.\n     * @param parent an optional parent.\n     */\n    function create(range, parent) {\n        return { range, parent };\n    }\n    SelectionRange.create = create;\n    function is(value) {\n        let candidate = value;\n        return Is.objectLiteral(candidate) && Range.is(candidate.range) && (candidate.parent === undefined || SelectionRange.is(candidate.parent));\n    }\n    SelectionRange.is = is;\n})(SelectionRange || (SelectionRange = {}));\n/**\n * A set of predefined token types. This set is not fixed\n * an clients can specify additional token types via the\n * corresponding client capabilities.\n *\n * @since 3.16.0\n */\nexport var SemanticTokenTypes;\n(function (SemanticTokenTypes) {\n    SemanticTokenTypes[\"namespace\"] = \"namespace\";\n    /**\n     * Represents a generic type. Acts as a fallback for types which can't be mapped to\n     * a specific type like class or enum.\n     */\n    SemanticTokenTypes[\"type\"] = \"type\";\n    SemanticTokenTypes[\"class\"] = \"class\";\n    SemanticTokenTypes[\"enum\"] = \"enum\";\n    SemanticTokenTypes[\"interface\"] = \"interface\";\n    SemanticTokenTypes[\"struct\"] = \"struct\";\n    SemanticTokenTypes[\"typeParameter\"] = \"typeParameter\";\n    SemanticTokenTypes[\"parameter\"] = \"parameter\";\n    SemanticTokenTypes[\"variable\"] = \"variable\";\n    SemanticTokenTypes[\"property\"] = \"property\";\n    SemanticTokenTypes[\"enumMember\"] = \"enumMember\";\n    SemanticTokenTypes[\"event\"] = \"event\";\n    SemanticTokenTypes[\"function\"] = \"function\";\n    SemanticTokenTypes[\"method\"] = \"method\";\n    SemanticTokenTypes[\"macro\"] = \"macro\";\n    SemanticTokenTypes[\"keyword\"] = \"keyword\";\n    SemanticTokenTypes[\"modifier\"] = \"modifier\";\n    SemanticTokenTypes[\"comment\"] = \"comment\";\n    SemanticTokenTypes[\"string\"] = \"string\";\n    SemanticTokenTypes[\"number\"] = \"number\";\n    SemanticTokenTypes[\"regexp\"] = \"regexp\";\n    SemanticTokenTypes[\"operator\"] = \"operator\";\n    /**\n     * @since 3.17.0\n     */\n    SemanticTokenTypes[\"decorator\"] = \"decorator\";\n})(SemanticTokenTypes || (SemanticTokenTypes = {}));\n/**\n * A set of predefined token modifiers. This set is not fixed\n * an clients can specify additional token types via the\n * corresponding client capabilities.\n *\n * @since 3.16.0\n */\nexport var SemanticTokenModifiers;\n(function (SemanticTokenModifiers) {\n    SemanticTokenModifiers[\"declaration\"] = \"declaration\";\n    SemanticTokenModifiers[\"definition\"] = \"definition\";\n    SemanticTokenModifiers[\"readonly\"] = \"readonly\";\n    SemanticTokenModifiers[\"static\"] = \"static\";\n    SemanticTokenModifiers[\"deprecated\"] = \"deprecated\";\n    SemanticTokenModifiers[\"abstract\"] = \"abstract\";\n    SemanticTokenModifiers[\"async\"] = \"async\";\n    SemanticTokenModifiers[\"modification\"] = \"modification\";\n    SemanticTokenModifiers[\"documentation\"] = \"documentation\";\n    SemanticTokenModifiers[\"defaultLibrary\"] = \"defaultLibrary\";\n})(SemanticTokenModifiers || (SemanticTokenModifiers = {}));\n/**\n * @since 3.16.0\n */\nexport var SemanticTokens;\n(function (SemanticTokens) {\n    function is(value) {\n        const candidate = value;\n        return Is.objectLiteral(candidate) && (candidate.resultId === undefined || typeof candidate.resultId === 'string') &&\n            Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === 'number');\n    }\n    SemanticTokens.is = is;\n})(SemanticTokens || (SemanticTokens = {}));\n/**\n * The InlineValueText namespace provides functions to deal with InlineValueTexts.\n *\n * @since 3.17.0\n */\nexport var InlineValueText;\n(function (InlineValueText) {\n    /**\n     * Creates a new InlineValueText literal.\n     */\n    function create(range, text) {\n        return { range, text };\n    }\n    InlineValueText.create = create;\n    function is(value) {\n        const candidate = value;\n        return candidate !== undefined && candidate !== null && Range.is(candidate.range) && Is.string(candidate.text);\n    }\n    InlineValueText.is = is;\n})(InlineValueText || (InlineValueText = {}));\n/**\n * The InlineValueVariableLookup namespace provides functions to deal with InlineValueVariableLookups.\n *\n * @since 3.17.0\n */\nexport var InlineValueVariableLookup;\n(function (InlineValueVariableLookup) {\n    /**\n     * Creates a new InlineValueText literal.\n     */\n    function create(range, variableName, caseSensitiveLookup) {\n        return { range, variableName, caseSensitiveLookup };\n    }\n    InlineValueVariableLookup.create = create;\n    function is(value) {\n        const candidate = value;\n        return candidate !== undefined && candidate !== null && Range.is(candidate.range) && Is.boolean(candidate.caseSensitiveLookup)\n            && (Is.string(candidate.variableName) || candidate.variableName === undefined);\n    }\n    InlineValueVariableLookup.is = is;\n})(InlineValueVariableLookup || (InlineValueVariableLookup = {}));\n/**\n * The InlineValueEvaluatableExpression namespace provides functions to deal with InlineValueEvaluatableExpression.\n *\n * @since 3.17.0\n */\nexport var InlineValueEvaluatableExpression;\n(function (InlineValueEvaluatableExpression) {\n    /**\n     * Creates a new InlineValueEvaluatableExpression literal.\n     */\n    function create(range, expression) {\n        return { range, expression };\n    }\n    InlineValueEvaluatableExpression.create = create;\n    function is(value) {\n        const candidate = value;\n        return candidate !== undefined && candidate !== null && Range.is(candidate.range)\n            && (Is.string(candidate.expression) || candidate.expression === undefined);\n    }\n    InlineValueEvaluatableExpression.is = is;\n})(InlineValueEvaluatableExpression || (InlineValueEvaluatableExpression = {}));\n/**\n * The InlineValueContext namespace provides helper functions to work with\n * {@link InlineValueContext} literals.\n *\n * @since 3.17.0\n */\nexport var InlineValueContext;\n(function (InlineValueContext) {\n    /**\n     * Creates a new InlineValueContext literal.\n     */\n    function create(frameId, stoppedLocation) {\n        return { frameId, stoppedLocation };\n    }\n    InlineValueContext.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link InlineValueContext} interface.\n     */\n    function is(value) {\n        const candidate = value;\n        return Is.defined(candidate) && Range.is(value.stoppedLocation);\n    }\n    InlineValueContext.is = is;\n})(InlineValueContext || (InlineValueContext = {}));\n/**\n * Inlay hint kinds.\n *\n * @since 3.17.0\n */\nexport var InlayHintKind;\n(function (InlayHintKind) {\n    /**\n     * An inlay hint that for a type annotation.\n     */\n    InlayHintKind.Type = 1;\n    /**\n     * An inlay hint that is for a parameter.\n     */\n    InlayHintKind.Parameter = 2;\n    function is(value) {\n        return value === 1 || value === 2;\n    }\n    InlayHintKind.is = is;\n})(InlayHintKind || (InlayHintKind = {}));\nexport var InlayHintLabelPart;\n(function (InlayHintLabelPart) {\n    function create(value) {\n        return { value };\n    }\n    InlayHintLabelPart.create = create;\n    function is(value) {\n        const candidate = value;\n        return Is.objectLiteral(candidate)\n            && (candidate.tooltip === undefined || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip))\n            && (candidate.location === undefined || Location.is(candidate.location))\n            && (candidate.command === undefined || Command.is(candidate.command));\n    }\n    InlayHintLabelPart.is = is;\n})(InlayHintLabelPart || (InlayHintLabelPart = {}));\nexport var InlayHint;\n(function (InlayHint) {\n    function create(position, label, kind) {\n        const result = { position, label };\n        if (kind !== undefined) {\n            result.kind = kind;\n        }\n        return result;\n    }\n    InlayHint.create = create;\n    function is(value) {\n        const candidate = value;\n        return Is.objectLiteral(candidate) && Position.is(candidate.position)\n            && (Is.string(candidate.label) || Is.typedArray(candidate.label, InlayHintLabelPart.is))\n            && (candidate.kind === undefined || InlayHintKind.is(candidate.kind))\n            && (candidate.textEdits === undefined) || Is.typedArray(candidate.textEdits, TextEdit.is)\n            && (candidate.tooltip === undefined || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip))\n            && (candidate.paddingLeft === undefined || Is.boolean(candidate.paddingLeft))\n            && (candidate.paddingRight === undefined || Is.boolean(candidate.paddingRight));\n    }\n    InlayHint.is = is;\n})(InlayHint || (InlayHint = {}));\nexport var StringValue;\n(function (StringValue) {\n    function createSnippet(value) {\n        return { kind: 'snippet', value };\n    }\n    StringValue.createSnippet = createSnippet;\n})(StringValue || (StringValue = {}));\nexport var InlineCompletionItem;\n(function (InlineCompletionItem) {\n    function create(insertText, filterText, range, command) {\n        return { insertText, filterText, range, command };\n    }\n    InlineCompletionItem.create = create;\n})(InlineCompletionItem || (InlineCompletionItem = {}));\nexport var InlineCompletionList;\n(function (InlineCompletionList) {\n    function create(items) {\n        return { items };\n    }\n    InlineCompletionList.create = create;\n})(InlineCompletionList || (InlineCompletionList = {}));\n/**\n * Describes how an {@link InlineCompletionItemProvider inline completion provider} was triggered.\n *\n * @since 3.18.0\n * @proposed\n */\nexport var InlineCompletionTriggerKind;\n(function (InlineCompletionTriggerKind) {\n    /**\n     * Completion was triggered explicitly by a user gesture.\n     */\n    InlineCompletionTriggerKind.Invoked = 0;\n    /**\n     * Completion was triggered automatically while editing.\n     */\n    InlineCompletionTriggerKind.Automatic = 1;\n})(InlineCompletionTriggerKind || (InlineCompletionTriggerKind = {}));\nexport var SelectedCompletionInfo;\n(function (SelectedCompletionInfo) {\n    function create(range, text) {\n        return { range, text };\n    }\n    SelectedCompletionInfo.create = create;\n})(SelectedCompletionInfo || (SelectedCompletionInfo = {}));\nexport var InlineCompletionContext;\n(function (InlineCompletionContext) {\n    function create(triggerKind, selectedCompletionInfo) {\n        return { triggerKind, selectedCompletionInfo };\n    }\n    InlineCompletionContext.create = create;\n})(InlineCompletionContext || (InlineCompletionContext = {}));\nexport var WorkspaceFolder;\n(function (WorkspaceFolder) {\n    function is(value) {\n        const candidate = value;\n        return Is.objectLiteral(candidate) && URI.is(candidate.uri) && Is.string(candidate.name);\n    }\n    WorkspaceFolder.is = is;\n})(WorkspaceFolder || (WorkspaceFolder = {}));\nexport const EOL = ['\\n', '\\r\\n', '\\r'];\n/**\n * @deprecated Use the text document from the new vscode-languageserver-textdocument package.\n */\nexport var TextDocument;\n(function (TextDocument) {\n    /**\n     * Creates a new ITextDocument literal from the given uri and content.\n     * @param uri The document's uri.\n     * @param languageId The document's language Id.\n     * @param version The document's version.\n     * @param content The document's content.\n     */\n    function create(uri, languageId, version, content) {\n        return new FullTextDocument(uri, languageId, version, content);\n    }\n    TextDocument.create = create;\n    /**\n     * Checks whether the given literal conforms to the {@link ITextDocument} interface.\n     */\n    function is(value) {\n        let candidate = value;\n        return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.uinteger(candidate.lineCount)\n            && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false;\n    }\n    TextDocument.is = is;\n    function applyEdits(document, edits) {\n        let text = document.getText();\n        let sortedEdits = mergeSort(edits, (a, b) => {\n            let diff = a.range.start.line - b.range.start.line;\n            if (diff === 0) {\n                return a.range.start.character - b.range.start.character;\n            }\n            return diff;\n        });\n        let lastModifiedOffset = text.length;\n        for (let i = sortedEdits.length - 1; i >= 0; i--) {\n            let e = sortedEdits[i];\n            let startOffset = document.offsetAt(e.range.start);\n            let endOffset = document.offsetAt(e.range.end);\n            if (endOffset <= lastModifiedOffset) {\n                text = text.substring(0, startOffset) + e.newText + text.substring(endOffset, text.length);\n            }\n            else {\n                throw new Error('Overlapping edit');\n            }\n            lastModifiedOffset = startOffset;\n        }\n        return text;\n    }\n    TextDocument.applyEdits = applyEdits;\n    function mergeSort(data, compare) {\n        if (data.length <= 1) {\n            // sorted\n            return data;\n        }\n        const p = (data.length / 2) | 0;\n        const left = data.slice(0, p);\n        const right = data.slice(p);\n        mergeSort(left, compare);\n        mergeSort(right, compare);\n        let leftIdx = 0;\n        let rightIdx = 0;\n        let i = 0;\n        while (leftIdx < left.length && rightIdx < right.length) {\n            let ret = compare(left[leftIdx], right[rightIdx]);\n            if (ret <= 0) {\n                // smaller_equal -> take left to preserve order\n                data[i++] = left[leftIdx++];\n            }\n            else {\n                // greater -> take right\n                data[i++] = right[rightIdx++];\n            }\n        }\n        while (leftIdx < left.length) {\n            data[i++] = left[leftIdx++];\n        }\n        while (rightIdx < right.length) {\n            data[i++] = right[rightIdx++];\n        }\n        return data;\n    }\n})(TextDocument || (TextDocument = {}));\n/**\n * @deprecated Use the text document from the new vscode-languageserver-textdocument package.\n */\nclass FullTextDocument {\n    constructor(uri, languageId, version, content) {\n        this._uri = uri;\n        this._languageId = languageId;\n        this._version = version;\n        this._content = content;\n        this._lineOffsets = undefined;\n    }\n    get uri() {\n        return this._uri;\n    }\n    get languageId() {\n        return this._languageId;\n    }\n    get version() {\n        return this._version;\n    }\n    getText(range) {\n        if (range) {\n            let start = this.offsetAt(range.start);\n            let end = this.offsetAt(range.end);\n            return this._content.substring(start, end);\n        }\n        return this._content;\n    }\n    update(event, version) {\n        this._content = event.text;\n        this._version = version;\n        this._lineOffsets = undefined;\n    }\n    getLineOffsets() {\n        if (this._lineOffsets === undefined) {\n            let lineOffsets = [];\n            let text = this._content;\n            let isLineStart = true;\n            for (let i = 0; i < text.length; i++) {\n                if (isLineStart) {\n                    lineOffsets.push(i);\n                    isLineStart = false;\n                }\n                let ch = text.charAt(i);\n                isLineStart = (ch === '\\r' || ch === '\\n');\n                if (ch === '\\r' && i + 1 < text.length && text.charAt(i + 1) === '\\n') {\n                    i++;\n                }\n            }\n            if (isLineStart && text.length > 0) {\n                lineOffsets.push(text.length);\n            }\n            this._lineOffsets = lineOffsets;\n        }\n        return this._lineOffsets;\n    }\n    positionAt(offset) {\n        offset = Math.max(Math.min(offset, this._content.length), 0);\n        let lineOffsets = this.getLineOffsets();\n        let low = 0, high = lineOffsets.length;\n        if (high === 0) {\n            return Position.create(0, offset);\n        }\n        while (low < high) {\n            let mid = Math.floor((low + high) / 2);\n            if (lineOffsets[mid] > offset) {\n                high = mid;\n            }\n            else {\n                low = mid + 1;\n            }\n        }\n        // low is the least x for which the line offset is larger than the current offset\n        // or array.length if no line offset is larger than the current offset\n        let line = low - 1;\n        return Position.create(line, offset - lineOffsets[line]);\n    }\n    offsetAt(position) {\n        let lineOffsets = this.getLineOffsets();\n        if (position.line >= lineOffsets.length) {\n            return this._content.length;\n        }\n        else if (position.line < 0) {\n            return 0;\n        }\n        let lineOffset = lineOffsets[position.line];\n        let nextLineOffset = (position.line + 1 < lineOffsets.length) ? lineOffsets[position.line + 1] : this._content.length;\n        return Math.max(Math.min(lineOffset + position.character, nextLineOffset), lineOffset);\n    }\n    get lineCount() {\n        return this.getLineOffsets().length;\n    }\n}\nvar Is;\n(function (Is) {\n    const toString = Object.prototype.toString;\n    function defined(value) {\n        return typeof value !== 'undefined';\n    }\n    Is.defined = defined;\n    function undefined(value) {\n        return typeof value === 'undefined';\n    }\n    Is.undefined = undefined;\n    function boolean(value) {\n        return value === true || value === false;\n    }\n    Is.boolean = boolean;\n    function string(value) {\n        return toString.call(value) === '[object String]';\n    }\n    Is.string = string;\n    function number(value) {\n        return toString.call(value) === '[object Number]';\n    }\n    Is.number = number;\n    function numberRange(value, min, max) {\n        return toString.call(value) === '[object Number]' && min <= value && value <= max;\n    }\n    Is.numberRange = numberRange;\n    function integer(value) {\n        return toString.call(value) === '[object Number]' && -2147483648 <= value && value <= 2147483647;\n    }\n    Is.integer = integer;\n    function uinteger(value) {\n        return toString.call(value) === '[object Number]' && 0 <= value && value <= 2147483647;\n    }\n    Is.uinteger = uinteger;\n    function func(value) {\n        return toString.call(value) === '[object Function]';\n    }\n    Is.func = func;\n    function objectLiteral(value) {\n        // Strictly speaking class instances pass this check as well. Since the LSP\n        // doesn't use classes we ignore this for now. If we do we need to add something\n        // like this: `Object.getPrototypeOf(Object.getPrototypeOf(x)) === null`\n        return value !== null && typeof value === 'object';\n    }\n    Is.objectLiteral = objectLiteral;\n    function typedArray(value, check) {\n        return Array.isArray(value) && value.every(check);\n    }\n    Is.typedArray = typedArray;\n})(Is || (Is = {}));\n","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { Position } from 'vscode-languageserver-types';\nimport { isCompositeCstNode } from '../syntax-tree.js';\nimport { tokenToRange } from '../utils/cst-utils.js';\nexport class CstNodeBuilder {\n    constructor() {\n        this.nodeStack = [];\n    }\n    get current() {\n        return this.nodeStack[this.nodeStack.length - 1];\n    }\n    buildRootNode(input) {\n        this.rootNode = new RootCstNodeImpl(input);\n        this.rootNode.root = this.rootNode;\n        this.nodeStack = [this.rootNode];\n        return this.rootNode;\n    }\n    buildCompositeNode(feature) {\n        const compositeNode = new CompositeCstNodeImpl();\n        compositeNode.grammarSource = feature;\n        compositeNode.root = this.rootNode;\n        this.current.content.push(compositeNode);\n        this.nodeStack.push(compositeNode);\n        return compositeNode;\n    }\n    buildLeafNode(token, feature) {\n        const leafNode = new LeafCstNodeImpl(token.startOffset, token.image.length, tokenToRange(token), token.tokenType, false);\n        leafNode.grammarSource = feature;\n        leafNode.root = this.rootNode;\n        this.current.content.push(leafNode);\n        return leafNode;\n    }\n    removeNode(node) {\n        const parent = node.container;\n        if (parent) {\n            const index = parent.content.indexOf(node);\n            if (index >= 0) {\n                parent.content.splice(index, 1);\n            }\n        }\n    }\n    construct(item) {\n        const current = this.current;\n        // The specified item could be a datatype ($type is symbol) or a fragment ($type is undefined)\n        // Only if the $type is a string, we actually assign the element\n        if (typeof item.$type === 'string') {\n            this.current.astNode = item;\n        }\n        item.$cstNode = current;\n        const node = this.nodeStack.pop();\n        // Empty composite nodes are not valid\n        // Simply remove the node from the tree\n        if ((node === null || node === void 0 ? void 0 : node.content.length) === 0) {\n            this.removeNode(node);\n        }\n    }\n    addHiddenTokens(hiddenTokens) {\n        for (const token of hiddenTokens) {\n            const hiddenNode = new LeafCstNodeImpl(token.startOffset, token.image.length, tokenToRange(token), token.tokenType, true);\n            hiddenNode.root = this.rootNode;\n            this.addHiddenToken(this.rootNode, hiddenNode);\n        }\n    }\n    addHiddenToken(node, token) {\n        const { offset: tokenStart, end: tokenEnd } = token;\n        for (let i = 0; i < node.content.length; i++) {\n            const child = node.content[i];\n            const { offset: childStart, end: childEnd } = child;\n            if (isCompositeCstNode(child) && tokenStart > childStart && tokenEnd < childEnd) {\n                this.addHiddenToken(child, token);\n                return;\n            }\n            else if (tokenEnd <= childStart) {\n                node.content.splice(i, 0, token);\n                return;\n            }\n        }\n        // We know that we haven't found a suited position for the token\n        // So we simply add it to the end of the current node\n        node.content.push(token);\n    }\n}\nexport class AbstractCstNode {\n    /** @deprecated use `container` instead. */\n    get parent() {\n        return this.container;\n    }\n    /** @deprecated use `grammarSource` instead. */\n    get feature() {\n        return this.grammarSource;\n    }\n    get hidden() {\n        return false;\n    }\n    get astNode() {\n        var _a, _b;\n        const node = typeof ((_a = this._astNode) === null || _a === void 0 ? void 0 : _a.$type) === 'string' ? this._astNode : (_b = this.container) === null || _b === void 0 ? void 0 : _b.astNode;\n        if (!node) {\n            throw new Error('This node has no associated AST element');\n        }\n        return node;\n    }\n    set astNode(value) {\n        this._astNode = value;\n    }\n    /** @deprecated use `astNode` instead. */\n    get element() {\n        return this.astNode;\n    }\n    get text() {\n        return this.root.fullText.substring(this.offset, this.end);\n    }\n}\nexport class LeafCstNodeImpl extends AbstractCstNode {\n    get offset() {\n        return this._offset;\n    }\n    get length() {\n        return this._length;\n    }\n    get end() {\n        return this._offset + this._length;\n    }\n    get hidden() {\n        return this._hidden;\n    }\n    get tokenType() {\n        return this._tokenType;\n    }\n    get range() {\n        return this._range;\n    }\n    constructor(offset, length, range, tokenType, hidden = false) {\n        super();\n        this._hidden = hidden;\n        this._offset = offset;\n        this._tokenType = tokenType;\n        this._length = length;\n        this._range = range;\n    }\n}\nexport class CompositeCstNodeImpl extends AbstractCstNode {\n    constructor() {\n        super(...arguments);\n        this.content = new CstNodeContainer(this);\n    }\n    /** @deprecated use `content` instead. */\n    get children() {\n        return this.content;\n    }\n    get offset() {\n        var _a, _b;\n        return (_b = (_a = this.firstNonHiddenNode) === null || _a === void 0 ? void 0 : _a.offset) !== null && _b !== void 0 ? _b : 0;\n    }\n    get length() {\n        return this.end - this.offset;\n    }\n    get end() {\n        var _a, _b;\n        return (_b = (_a = this.lastNonHiddenNode) === null || _a === void 0 ? void 0 : _a.end) !== null && _b !== void 0 ? _b : 0;\n    }\n    get range() {\n        const firstNode = this.firstNonHiddenNode;\n        const lastNode = this.lastNonHiddenNode;\n        if (firstNode && lastNode) {\n            if (this._rangeCache === undefined) {\n                const { range: firstRange } = firstNode;\n                const { range: lastRange } = lastNode;\n                this._rangeCache = { start: firstRange.start, end: lastRange.end.line < firstRange.start.line ? firstRange.start : lastRange.end };\n            }\n            return this._rangeCache;\n        }\n        else {\n            return { start: Position.create(0, 0), end: Position.create(0, 0) };\n        }\n    }\n    get firstNonHiddenNode() {\n        for (const child of this.content) {\n            if (!child.hidden) {\n                return child;\n            }\n        }\n        return this.content[0];\n    }\n    get lastNonHiddenNode() {\n        for (let i = this.content.length - 1; i >= 0; i--) {\n            const child = this.content[i];\n            if (!child.hidden) {\n                return child;\n            }\n        }\n        return this.content[this.content.length - 1];\n    }\n}\nclass CstNodeContainer extends Array {\n    constructor(parent) {\n        super();\n        this.parent = parent;\n        Object.setPrototypeOf(this, CstNodeContainer.prototype);\n    }\n    push(...items) {\n        this.addParents(items);\n        return super.push(...items);\n    }\n    unshift(...items) {\n        this.addParents(items);\n        return super.unshift(...items);\n    }\n    splice(start, count, ...items) {\n        this.addParents(items);\n        return super.splice(start, count, ...items);\n    }\n    addParents(items) {\n        for (const item of items) {\n            item.container = this.parent;\n        }\n    }\n}\nexport class RootCstNodeImpl extends CompositeCstNodeImpl {\n    get text() {\n        return this._text.substring(this.offset, this.end);\n    }\n    get fullText() {\n        return this._text;\n    }\n    constructor(input) {\n        super();\n        this._text = '';\n        this._text = input !== null && input !== void 0 ? input : '';\n    }\n}\n//# sourceMappingURL=cst-node-builder.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { defaultParserErrorProvider, EmbeddedActionsParser, LLkLookaheadStrategy } from 'chevrotain';\nimport { LLStarLookaheadStrategy } from 'chevrotain-allstar';\nimport { isAssignment, isCrossReference, isKeyword } from '../languages/generated/ast.js';\nimport { getTypeName, isDataTypeRule } from '../utils/grammar-utils.js';\nimport { assignMandatoryProperties, getContainerOfType, linkContentToContainer } from '../utils/ast-utils.js';\nimport { CstNodeBuilder } from './cst-node-builder.js';\nexport const DatatypeSymbol = Symbol('Datatype');\nfunction isDataTypeNode(node) {\n    return node.$type === DatatypeSymbol;\n}\nconst ruleSuffix = '\\u200B';\nconst withRuleSuffix = (name) => name.endsWith(ruleSuffix) ? name : name + ruleSuffix;\nexport class AbstractLangiumParser {\n    constructor(services) {\n        this._unorderedGroups = new Map();\n        this.lexer = services.parser.Lexer;\n        const tokens = this.lexer.definition;\n        this.wrapper = new ChevrotainWrapper(tokens, Object.assign(Object.assign({}, services.parser.ParserConfig), { errorMessageProvider: services.parser.ParserErrorMessageProvider }));\n    }\n    alternatives(idx, choices) {\n        this.wrapper.wrapOr(idx, choices);\n    }\n    optional(idx, callback) {\n        this.wrapper.wrapOption(idx, callback);\n    }\n    many(idx, callback) {\n        this.wrapper.wrapMany(idx, callback);\n    }\n    atLeastOne(idx, callback) {\n        this.wrapper.wrapAtLeastOne(idx, callback);\n    }\n    isRecording() {\n        return this.wrapper.IS_RECORDING;\n    }\n    get unorderedGroups() {\n        return this._unorderedGroups;\n    }\n    getRuleStack() {\n        return this.wrapper.RULE_STACK;\n    }\n    finalize() {\n        this.wrapper.wrapSelfAnalysis();\n    }\n}\nexport class LangiumParser extends AbstractLangiumParser {\n    get current() {\n        return this.stack[this.stack.length - 1];\n    }\n    constructor(services) {\n        super(services);\n        this.nodeBuilder = new CstNodeBuilder();\n        this.stack = [];\n        this.assignmentMap = new Map();\n        this.linker = services.references.Linker;\n        this.converter = services.parser.ValueConverter;\n        this.astReflection = services.shared.AstReflection;\n    }\n    rule(rule, impl) {\n        const type = rule.fragment ? undefined : isDataTypeRule(rule) ? DatatypeSymbol : getTypeName(rule);\n        const ruleMethod = this.wrapper.DEFINE_RULE(withRuleSuffix(rule.name), this.startImplementation(type, impl).bind(this));\n        if (rule.entry) {\n            this.mainRule = ruleMethod;\n        }\n        return ruleMethod;\n    }\n    parse(input) {\n        this.nodeBuilder.buildRootNode(input);\n        const lexerResult = this.lexer.tokenize(input);\n        this.wrapper.input = lexerResult.tokens;\n        const result = this.mainRule.call(this.wrapper, {});\n        this.nodeBuilder.addHiddenTokens(lexerResult.hidden);\n        this.unorderedGroups.clear();\n        return {\n            value: result,\n            lexerErrors: lexerResult.errors,\n            parserErrors: this.wrapper.errors\n        };\n    }\n    startImplementation($type, implementation) {\n        return (args) => {\n            if (!this.isRecording()) {\n                const node = { $type };\n                this.stack.push(node);\n                if ($type === DatatypeSymbol) {\n                    node.value = '';\n                }\n            }\n            let result;\n            try {\n                result = implementation(args);\n            }\n            catch (err) {\n                result = undefined;\n            }\n            if (!this.isRecording() && result === undefined) {\n                result = this.construct();\n            }\n            return result;\n        };\n    }\n    consume(idx, tokenType, feature) {\n        const token = this.wrapper.wrapConsume(idx, tokenType);\n        if (!this.isRecording() && this.isValidToken(token)) {\n            const leafNode = this.nodeBuilder.buildLeafNode(token, feature);\n            const { assignment, isCrossRef } = this.getAssignment(feature);\n            const current = this.current;\n            if (assignment) {\n                const convertedValue = isKeyword(feature) ? token.image : this.converter.convert(token.image, leafNode);\n                this.assign(assignment.operator, assignment.feature, convertedValue, leafNode, isCrossRef);\n            }\n            else if (isDataTypeNode(current)) {\n                let text = token.image;\n                if (!isKeyword(feature)) {\n                    text = this.converter.convert(text, leafNode).toString();\n                }\n                current.value += text;\n            }\n        }\n    }\n    /**\n     * Most consumed parser tokens are valid. However there are two cases in which they are not valid:\n     *\n     * 1. They were inserted during error recovery by the parser. These tokens don't really exist and should not be further processed\n     * 2. They contain invalid token ranges. This might include the special EOF token, or other tokens produced by invalid token builders.\n     */\n    isValidToken(token) {\n        return !token.isInsertedInRecovery && !isNaN(token.startOffset) && typeof token.endOffset === 'number' && !isNaN(token.endOffset);\n    }\n    subrule(idx, rule, feature, args) {\n        let cstNode;\n        if (!this.isRecording()) {\n            cstNode = this.nodeBuilder.buildCompositeNode(feature);\n        }\n        const subruleResult = this.wrapper.wrapSubrule(idx, rule, args);\n        if (!this.isRecording() && cstNode && cstNode.length > 0) {\n            this.performSubruleAssignment(subruleResult, feature, cstNode);\n        }\n    }\n    performSubruleAssignment(result, feature, cstNode) {\n        const { assignment, isCrossRef } = this.getAssignment(feature);\n        if (assignment) {\n            this.assign(assignment.operator, assignment.feature, result, cstNode, isCrossRef);\n        }\n        else if (!assignment) {\n            // If we call a subrule without an assignment we either:\n            // 1. append the result of the subrule (data type rule)\n            // 2. override the current object with the newly parsed object\n            // If the current element is an AST node and the result of the subrule\n            // is a data type rule, we can safely discard the results.\n            const current = this.current;\n            if (isDataTypeNode(current)) {\n                current.value += result.toString();\n            }\n            else if (typeof result === 'object' && result) {\n                const resultKind = result.$type;\n                const object = this.assignWithoutOverride(result, current);\n                if (resultKind) {\n                    object.$type = resultKind;\n                }\n                const newItem = object;\n                this.stack.pop();\n                this.stack.push(newItem);\n            }\n        }\n    }\n    action($type, action) {\n        if (!this.isRecording()) {\n            let last = this.current;\n            // This branch is used for left recursive grammar rules.\n            // Those don't call `construct` before another action.\n            // Therefore, we need to call it here.\n            if (!last.$cstNode && action.feature && action.operator) {\n                last = this.construct(false);\n                const feature = last.$cstNode.feature;\n                this.nodeBuilder.buildCompositeNode(feature);\n            }\n            const newItem = { $type };\n            this.stack.pop();\n            this.stack.push(newItem);\n            if (action.feature && action.operator) {\n                this.assign(action.operator, action.feature, last, last.$cstNode, false);\n            }\n        }\n    }\n    construct(pop = true) {\n        if (this.isRecording()) {\n            return undefined;\n        }\n        const obj = this.current;\n        linkContentToContainer(obj);\n        this.nodeBuilder.construct(obj);\n        if (pop) {\n            this.stack.pop();\n        }\n        if (isDataTypeNode(obj)) {\n            return this.converter.convert(obj.value, obj.$cstNode);\n        }\n        else {\n            assignMandatoryProperties(this.astReflection, obj);\n        }\n        return obj;\n    }\n    getAssignment(feature) {\n        if (!this.assignmentMap.has(feature)) {\n            const assignment = getContainerOfType(feature, isAssignment);\n            this.assignmentMap.set(feature, {\n                assignment: assignment,\n                isCrossRef: assignment ? isCrossReference(assignment.terminal) : false\n            });\n        }\n        return this.assignmentMap.get(feature);\n    }\n    assign(operator, feature, value, cstNode, isCrossRef) {\n        const obj = this.current;\n        let item;\n        if (isCrossRef && typeof value === 'string') {\n            item = this.linker.buildReference(obj, feature, cstNode, value);\n        }\n        else {\n            item = value;\n        }\n        switch (operator) {\n            case '=': {\n                obj[feature] = item;\n                break;\n            }\n            case '?=': {\n                obj[feature] = true;\n                break;\n            }\n            case '+=': {\n                if (!Array.isArray(obj[feature])) {\n                    obj[feature] = [];\n                }\n                obj[feature].push(item);\n            }\n        }\n    }\n    assignWithoutOverride(target, source) {\n        for (const [name, existingValue] of Object.entries(source)) {\n            const newValue = target[name];\n            if (newValue === undefined) {\n                target[name] = existingValue;\n            }\n            else if (Array.isArray(newValue) && Array.isArray(existingValue)) {\n                existingValue.push(...newValue);\n                target[name] = existingValue;\n            }\n        }\n        return target;\n    }\n    get definitionErrors() {\n        return this.wrapper.definitionErrors;\n    }\n}\nexport class AbstractParserErrorMessageProvider {\n    buildMismatchTokenMessage(options) {\n        return defaultParserErrorProvider.buildMismatchTokenMessage(options);\n    }\n    buildNotAllInputParsedMessage(options) {\n        return defaultParserErrorProvider.buildNotAllInputParsedMessage(options);\n    }\n    buildNoViableAltMessage(options) {\n        return defaultParserErrorProvider.buildNoViableAltMessage(options);\n    }\n    buildEarlyExitMessage(options) {\n        return defaultParserErrorProvider.buildEarlyExitMessage(options);\n    }\n}\nexport class LangiumParserErrorMessageProvider extends AbstractParserErrorMessageProvider {\n    buildMismatchTokenMessage({ expected, actual }) {\n        const expectedMsg = expected.LABEL\n            ? '`' + expected.LABEL + '`'\n            : expected.name.endsWith(':KW')\n                ? `keyword '${expected.name.substring(0, expected.name.length - 3)}'`\n                : `token of type '${expected.name}'`;\n        return `Expecting ${expectedMsg} but found \\`${actual.image}\\`.`;\n    }\n    buildNotAllInputParsedMessage({ firstRedundant }) {\n        return `Expecting end of file but found \\`${firstRedundant.image}\\`.`;\n    }\n}\nexport class LangiumCompletionParser extends AbstractLangiumParser {\n    constructor() {\n        super(...arguments);\n        this.tokens = [];\n        this.elementStack = [];\n        this.lastElementStack = [];\n        this.nextTokenIndex = 0;\n        this.stackSize = 0;\n    }\n    action() {\n        // NOOP\n    }\n    construct() {\n        // NOOP\n        return undefined;\n    }\n    parse(input) {\n        this.resetState();\n        const tokens = this.lexer.tokenize(input);\n        this.tokens = tokens.tokens;\n        this.wrapper.input = [...this.tokens];\n        this.mainRule.call(this.wrapper, {});\n        this.unorderedGroups.clear();\n        return {\n            tokens: this.tokens,\n            elementStack: [...this.lastElementStack],\n            tokenIndex: this.nextTokenIndex\n        };\n    }\n    rule(rule, impl) {\n        const ruleMethod = this.wrapper.DEFINE_RULE(withRuleSuffix(rule.name), this.startImplementation(impl).bind(this));\n        if (rule.entry) {\n            this.mainRule = ruleMethod;\n        }\n        return ruleMethod;\n    }\n    resetState() {\n        this.elementStack = [];\n        this.lastElementStack = [];\n        this.nextTokenIndex = 0;\n        this.stackSize = 0;\n    }\n    startImplementation(implementation) {\n        return (args) => {\n            const size = this.keepStackSize();\n            try {\n                implementation(args);\n            }\n            finally {\n                this.resetStackSize(size);\n            }\n        };\n    }\n    removeUnexpectedElements() {\n        this.elementStack.splice(this.stackSize);\n    }\n    keepStackSize() {\n        const size = this.elementStack.length;\n        this.stackSize = size;\n        return size;\n    }\n    resetStackSize(size) {\n        this.removeUnexpectedElements();\n        this.stackSize = size;\n    }\n    consume(idx, tokenType, feature) {\n        this.wrapper.wrapConsume(idx, tokenType);\n        if (!this.isRecording()) {\n            this.lastElementStack = [...this.elementStack, feature];\n            this.nextTokenIndex = this.currIdx + 1;\n        }\n    }\n    subrule(idx, rule, feature, args) {\n        this.before(feature);\n        this.wrapper.wrapSubrule(idx, rule, args);\n        this.after(feature);\n    }\n    before(element) {\n        if (!this.isRecording()) {\n            this.elementStack.push(element);\n        }\n    }\n    after(element) {\n        if (!this.isRecording()) {\n            const index = this.elementStack.lastIndexOf(element);\n            if (index >= 0) {\n                this.elementStack.splice(index);\n            }\n        }\n    }\n    get currIdx() {\n        return this.wrapper.currIdx;\n    }\n}\nconst defaultConfig = {\n    recoveryEnabled: true,\n    nodeLocationTracking: 'full',\n    skipValidations: true,\n    errorMessageProvider: new LangiumParserErrorMessageProvider()\n};\n/**\n * This class wraps the embedded actions parser of chevrotain and exposes protected methods.\n * This way, we can build the `LangiumParser` as a composition.\n */\nclass ChevrotainWrapper extends EmbeddedActionsParser {\n    constructor(tokens, config) {\n        const useDefaultLookahead = config && 'maxLookahead' in config;\n        super(tokens, Object.assign(Object.assign(Object.assign({}, defaultConfig), { lookaheadStrategy: useDefaultLookahead\n                ? new LLkLookaheadStrategy({ maxLookahead: config.maxLookahead })\n                : new LLStarLookaheadStrategy() }), config));\n    }\n    get IS_RECORDING() {\n        return this.RECORDING_PHASE;\n    }\n    DEFINE_RULE(name, impl) {\n        return this.RULE(name, impl);\n    }\n    wrapSelfAnalysis() {\n        this.performSelfAnalysis();\n    }\n    wrapConsume(idx, tokenType) {\n        return this.consume(idx, tokenType);\n    }\n    wrapSubrule(idx, rule, args) {\n        return this.subrule(idx, rule, {\n            ARGS: [args]\n        });\n    }\n    wrapOr(idx, choices) {\n        this.or(idx, choices);\n    }\n    wrapOption(idx, callback) {\n        this.option(idx, callback);\n    }\n    wrapMany(idx, callback) {\n        this.many(idx, callback);\n    }\n    wrapAtLeastOne(idx, callback) {\n        this.atLeastOne(idx, callback);\n    }\n}\n//# sourceMappingURL=langium-parser.js.map","/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { EMPTY_ALT, EOF } from 'chevrotain';\nimport { isAction, isAlternatives, isEndOfFile, isAssignment, isConjunction, isCrossReference, isDisjunction, isGroup, isKeyword, isNegation, isParameterReference, isParserRule, isRuleCall, isTerminalRule, isUnorderedGroup, isBooleanLiteral } from '../languages/generated/ast.js';\nimport { assertUnreachable, ErrorWithLocation } from '../utils/errors.js';\nimport { stream } from '../utils/stream.js';\nimport { findNameAssignment, getAllReachableRules, getTypeName } from '../utils/grammar-utils.js';\nexport function createParser(grammar, parser, tokens) {\n    const rules = new Map();\n    const parserContext = {\n        parser,\n        tokens,\n        rules,\n        ruleNames: new Map()\n    };\n    buildRules(parserContext, grammar);\n    return parser;\n}\nfunction buildRules(parserContext, grammar) {\n    const reachable = getAllReachableRules(grammar, false);\n    const parserRules = stream(grammar.rules).filter(isParserRule).filter(rule => reachable.has(rule));\n    for (const rule of parserRules) {\n        const ctx = Object.assign(Object.assign({}, parserContext), { consume: 1, optional: 1, subrule: 1, many: 1, or: 1 });\n        ctx.rules.set(rule.name, parserContext.parser.rule(rule, buildElement(ctx, rule.definition)));\n    }\n}\nfunction buildElement(ctx, element, ignoreGuard = false) {\n    let method;\n    if (isKeyword(element)) {\n        method = buildKeyword(ctx, element);\n    }\n    else if (isAction(element)) {\n        method = buildAction(ctx, element);\n    }\n    else if (isAssignment(element)) {\n        method = buildElement(ctx, element.terminal);\n    }\n    else if (isCrossReference(element)) {\n        method = buildCrossReference(ctx, element);\n    }\n    else if (isRuleCall(element)) {\n        method = buildRuleCall(ctx, element);\n    }\n    else if (isAlternatives(element)) {\n        method = buildAlternatives(ctx, element);\n    }\n    else if (isUnorderedGroup(element)) {\n        method = buildUnorderedGroup(ctx, element);\n    }\n    else if (isGroup(element)) {\n        method = buildGroup(ctx, element);\n    }\n    else if (isEndOfFile(element)) {\n        const idx = ctx.consume++;\n        method = () => ctx.parser.consume(idx, EOF, element);\n    }\n    else {\n        throw new ErrorWithLocation(element.$cstNode, `Unexpected element type: ${element.$type}`);\n    }\n    return wrap(ctx, ignoreGuard ? undefined : getGuardCondition(element), method, element.cardinality);\n}\nfunction buildAction(ctx, action) {\n    const actionType = getTypeName(action);\n    return () => ctx.parser.action(actionType, action);\n}\nfunction buildRuleCall(ctx, ruleCall) {\n    const rule = ruleCall.rule.ref;\n    if (isParserRule(rule)) {\n        const idx = ctx.subrule++;\n        const predicate = ruleCall.arguments.length > 0 ? buildRuleCallPredicate(rule, ruleCall.arguments) : () => ({});\n        return (args) => ctx.parser.subrule(idx, getRule(ctx, rule), ruleCall, predicate(args));\n    }\n    else if (isTerminalRule(rule)) {\n        const idx = ctx.consume++;\n        const method = getToken(ctx, rule.name);\n        return () => ctx.parser.consume(idx, method, ruleCall);\n    }\n    else if (!rule) {\n        throw new ErrorWithLocation(ruleCall.$cstNode, `Undefined rule type: ${ruleCall.$type}`);\n    }\n    else {\n        assertUnreachable(rule);\n    }\n}\nfunction buildRuleCallPredicate(rule, namedArgs) {\n    const predicates = namedArgs.map(e => buildPredicate(e.value));\n    return (args) => {\n        const ruleArgs = {};\n        for (let i = 0; i < predicates.length; i++) {\n            const ruleTarget = rule.parameters[i];\n            const predicate = predicates[i];\n            ruleArgs[ruleTarget.name] = predicate(args);\n        }\n        return ruleArgs;\n    };\n}\nfunction buildPredicate(condition) {\n    if (isDisjunction(condition)) {\n        const left = buildPredicate(condition.left);\n        const right = buildPredicate(condition.right);\n        return (args) => (left(args) || right(args));\n    }\n    else if (isConjunction(condition)) {\n        const left = buildPredicate(condition.left);\n        const right = buildPredicate(condition.right);\n        return (args) => (left(args) && right(args));\n    }\n    else if (isNegation(condition)) {\n        const value = buildPredicate(condition.value);\n        return (args) => !value(args);\n    }\n    else if (isParameterReference(condition)) {\n        const name = condition.parameter.ref.name;\n        return (args) => args !== undefined && args[name] === true;\n    }\n    else if (isBooleanLiteral(condition)) {\n        const value = Boolean(condition.true);\n        return () => value;\n    }\n    assertUnreachable(condition);\n}\nfunction buildAlternatives(ctx, alternatives) {\n    if (alternatives.elements.length === 1) {\n        return buildElement(ctx, alternatives.elements[0]);\n    }\n    else {\n        const methods = [];\n        for (const element of alternatives.elements) {\n            const predicatedMethod = {\n                // Since we handle the guard condition in the alternative already\n                // We can ignore the group guard condition inside\n                ALT: buildElement(ctx, element, true)\n            };\n            const guard = getGuardCondition(element);\n            if (guard) {\n                predicatedMethod.GATE = buildPredicate(guard);\n            }\n            methods.push(predicatedMethod);\n        }\n        const idx = ctx.or++;\n        return (args) => ctx.parser.alternatives(idx, methods.map(method => {\n            const alt = {\n                ALT: () => method.ALT(args)\n            };\n            const gate = method.GATE;\n            if (gate) {\n                alt.GATE = () => gate(args);\n            }\n            return alt;\n        }));\n    }\n}\nfunction buildUnorderedGroup(ctx, group) {\n    if (group.elements.length === 1) {\n        return buildElement(ctx, group.elements[0]);\n    }\n    const methods = [];\n    for (const element of group.elements) {\n        const predicatedMethod = {\n            // Since we handle the guard condition in the alternative already\n            // We can ignore the group guard condition inside\n            ALT: buildElement(ctx, element, true)\n        };\n        const guard = getGuardCondition(element);\n        if (guard) {\n            predicatedMethod.GATE = buildPredicate(guard);\n        }\n        methods.push(predicatedMethod);\n    }\n    const orIdx = ctx.or++;\n    const idFunc = (groupIdx, lParser) => {\n        const stackId = lParser.getRuleStack().join('-');\n        return `uGroup_${groupIdx}_${stackId}`;\n    };\n    const alternatives = (args) => ctx.parser.alternatives(orIdx, methods.map((method, idx) => {\n        const alt = { ALT: () => true };\n        const parser = ctx.parser;\n        alt.ALT = () => {\n            method.ALT(args);\n            if (!parser.isRecording()) {\n                const key = idFunc(orIdx, parser);\n                if (!parser.unorderedGroups.get(key)) {\n                    // init after clear state\n                    parser.unorderedGroups.set(key, []);\n                }\n                const groupState = parser.unorderedGroups.get(key);\n                if (typeof (groupState === null || groupState === void 0 ? void 0 : groupState[idx]) === 'undefined') {\n                    // Not accessed yet\n                    groupState[idx] = true;\n                }\n            }\n        };\n        const gate = method.GATE;\n        if (gate) {\n            alt.GATE = () => gate(args);\n        }\n        else {\n            alt.GATE = () => {\n                const trackedAlternatives = parser.unorderedGroups.get(idFunc(orIdx, parser));\n                const allow = !(trackedAlternatives === null || trackedAlternatives === void 0 ? void 0 : trackedAlternatives[idx]);\n                return allow;\n            };\n        }\n        return alt;\n    }));\n    const wrapped = wrap(ctx, getGuardCondition(group), alternatives, '*');\n    return (args) => {\n        wrapped(args);\n        if (!ctx.parser.isRecording()) {\n            ctx.parser.unorderedGroups.delete(idFunc(orIdx, ctx.parser));\n        }\n    };\n}\nfunction buildGroup(ctx, group) {\n    const methods = group.elements.map(e => buildElement(ctx, e));\n    return (args) => methods.forEach(method => method(args));\n}\nfunction getGuardCondition(element) {\n    if (isGroup(element)) {\n        return element.guardCondition;\n    }\n    return undefined;\n}\nfunction buildCrossReference(ctx, crossRef, terminal = crossRef.terminal) {\n    if (!terminal) {\n        if (!crossRef.type.ref) {\n            throw new Error('Could not resolve reference to type: ' + crossRef.type.$refText);\n        }\n        const assignment = findNameAssignment(crossRef.type.ref);\n        const assignTerminal = assignment === null || assignment === void 0 ? void 0 : assignment.terminal;\n        if (!assignTerminal) {\n            throw new Error('Could not find name assignment for type: ' + getTypeName(crossRef.type.ref));\n        }\n        return buildCrossReference(ctx, crossRef, assignTerminal);\n    }\n    else if (isRuleCall(terminal) && isParserRule(terminal.rule.ref)) {\n        const idx = ctx.subrule++;\n        return (args) => ctx.parser.subrule(idx, getRule(ctx, terminal.rule.ref), crossRef, args);\n    }\n    else if (isRuleCall(terminal) && isTerminalRule(terminal.rule.ref)) {\n        const idx = ctx.consume++;\n        const terminalRule = getToken(ctx, terminal.rule.ref.name);\n        return () => ctx.parser.consume(idx, terminalRule, crossRef);\n    }\n    else if (isKeyword(terminal)) {\n        const idx = ctx.consume++;\n        const keyword = getToken(ctx, terminal.value);\n        return () => ctx.parser.consume(idx, keyword, crossRef);\n    }\n    else {\n        throw new Error('Could not build cross reference parser');\n    }\n}\nfunction buildKeyword(ctx, keyword) {\n    const idx = ctx.consume++;\n    const token = ctx.tokens[keyword.value];\n    if (!token) {\n        throw new Error('Could not find token for keyword: ' + keyword.value);\n    }\n    return () => ctx.parser.consume(idx, token, keyword);\n}\nfunction wrap(ctx, guard, method, cardinality) {\n    const gate = guard && buildPredicate(guard);\n    if (!cardinality) {\n        if (gate) {\n            const idx = ctx.or++;\n            return (args) => ctx.parser.alternatives(idx, [\n                {\n                    ALT: () => method(args),\n                    GATE: () => gate(args)\n                },\n                {\n                    ALT: EMPTY_ALT(),\n                    GATE: () => !gate(args)\n                }\n            ]);\n        }\n        else {\n            return method;\n        }\n    }\n    if (cardinality === '*') {\n        const idx = ctx.many++;\n        return (args) => ctx.parser.many(idx, {\n            DEF: () => method(args),\n            GATE: gate ? () => gate(args) : undefined\n        });\n    }\n    else if (cardinality === '+') {\n        const idx = ctx.many++;\n        if (gate) {\n            const orIdx = ctx.or++;\n            // In the case of a guard condition for the `+` group\n            // We combine it with an empty alternative\n            // If the condition returns true, it needs to parse at least a single iteration\n            // If its false, it is not allowed to parse anything\n            return (args) => ctx.parser.alternatives(orIdx, [\n                {\n                    ALT: () => ctx.parser.atLeastOne(idx, {\n                        DEF: () => method(args)\n                    }),\n                    GATE: () => gate(args)\n                },\n                {\n                    ALT: EMPTY_ALT(),\n                    GATE: () => !gate(args)\n                }\n            ]);\n        }\n        else {\n            return (args) => ctx.parser.atLeastOne(idx, {\n                DEF: () => method(args),\n            });\n        }\n    }\n    else if (cardinality === '?') {\n        const idx = ctx.optional++;\n        return (args) => ctx.parser.optional(idx, {\n            DEF: () => method(args),\n            GATE: gate ? () => gate(args) : undefined\n        });\n    }\n    else {\n        assertUnreachable(cardinality);\n    }\n}\nfunction getRule(ctx, element) {\n    const name = getRuleName(ctx, element);\n    const rule = ctx.rules.get(name);\n    if (!rule)\n        throw new Error(`Rule \"${name}\" not found.\"`);\n    return rule;\n}\nfunction getRuleName(ctx, element) {\n    if (isParserRule(element)) {\n        return element.name;\n    }\n    else if (ctx.ruleNames.has(element)) {\n        return ctx.ruleNames.get(element);\n    }\n    else {\n        let item = element;\n        let parent = item.$container;\n        let ruleName = element.$type;\n        while (!isParserRule(parent)) {\n            if (isGroup(parent) || isAlternatives(parent) || isUnorderedGroup(parent)) {\n                const index = parent.elements.indexOf(item);\n                ruleName = index.toString() + ':' + ruleName;\n            }\n            item = parent;\n            parent = parent.$container;\n        }\n        const rule = parent;\n        ruleName = rule.name + ':' + ruleName;\n        ctx.ruleNames.set(element, ruleName);\n        return ruleName;\n    }\n}\nfunction getToken(ctx, name) {\n    const token = ctx.tokens[name];\n    if (!token)\n        throw new Error(`Token \"${name}\" not found.\"`);\n    return token;\n}\n//# sourceMappingURL=parser-builder-base.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { Lexer } from 'chevrotain';\nimport { isKeyword, isParserRule, isTerminalRule } from '../languages/generated/ast.js';\nimport { streamAllContents } from '../utils/ast-utils.js';\nimport { getAllReachableRules, terminalRegex } from '../utils/grammar-utils.js';\nimport { getCaseInsensitivePattern, isWhitespace, partialMatches } from '../utils/regexp-utils.js';\nimport { stream } from '../utils/stream.js';\nexport class DefaultTokenBuilder {\n    buildTokens(grammar, options) {\n        const reachableRules = stream(getAllReachableRules(grammar, false));\n        const terminalTokens = this.buildTerminalTokens(reachableRules);\n        const tokens = this.buildKeywordTokens(reachableRules, terminalTokens, options);\n        terminalTokens.forEach(terminalToken => {\n            const pattern = terminalToken.PATTERN;\n            if (typeof pattern === 'object' && pattern && 'test' in pattern && isWhitespace(pattern)) {\n                tokens.unshift(terminalToken);\n            }\n            else {\n                tokens.push(terminalToken);\n            }\n        });\n        // We don't need to add the EOF token explicitly.\n        // It is automatically available at the end of the token stream.\n        return tokens;\n    }\n    buildTerminalTokens(rules) {\n        return rules.filter(isTerminalRule).filter(e => !e.fragment)\n            .map(terminal => this.buildTerminalToken(terminal)).toArray();\n    }\n    buildTerminalToken(terminal) {\n        const regex = terminalRegex(terminal);\n        const pattern = this.requiresCustomPattern(regex) ? this.regexPatternFunction(regex) : regex;\n        const tokenType = {\n            name: terminal.name,\n            PATTERN: pattern,\n            LINE_BREAKS: true\n        };\n        if (terminal.hidden) {\n            // Only skip tokens that are able to accept whitespace\n            tokenType.GROUP = isWhitespace(regex) ? Lexer.SKIPPED : 'hidden';\n        }\n        return tokenType;\n    }\n    requiresCustomPattern(regex) {\n        if (regex.flags.includes('u')) {\n            // Unicode regexes are not supported by Chevrotain.\n            return true;\n        }\n        else if (regex.source.includes('?<=') || regex.source.includes('?<!')) {\n            // Negative and positive lookbehind are not supported by Chevrotain yet.\n            return true;\n        }\n        else {\n            return false;\n        }\n    }\n    regexPatternFunction(regex) {\n        const stickyRegex = new RegExp(regex, regex.flags + 'y');\n        return (text, offset) => {\n            stickyRegex.lastIndex = offset;\n            const execResult = stickyRegex.exec(text);\n            return execResult;\n        };\n    }\n    buildKeywordTokens(rules, terminalTokens, options) {\n        return rules\n            // We filter by parser rules, since keywords in terminal rules get transformed into regex and are not actual tokens\n            .filter(isParserRule)\n            .flatMap(rule => streamAllContents(rule).filter(isKeyword))\n            .distinct(e => e.value).toArray()\n            // Sort keywords by descending length\n            .sort((a, b) => b.value.length - a.value.length)\n            .map(keyword => this.buildKeywordToken(keyword, terminalTokens, Boolean(options === null || options === void 0 ? void 0 : options.caseInsensitive)));\n    }\n    buildKeywordToken(keyword, terminalTokens, caseInsensitive) {\n        return {\n            name: keyword.value,\n            PATTERN: this.buildKeywordPattern(keyword, caseInsensitive),\n            LONGER_ALT: this.findLongerAlt(keyword, terminalTokens)\n        };\n    }\n    buildKeywordPattern(keyword, caseInsensitive) {\n        return caseInsensitive ?\n            new RegExp(getCaseInsensitivePattern(keyword.value)) :\n            keyword.value;\n    }\n    findLongerAlt(keyword, terminalTokens) {\n        return terminalTokens.reduce((longerAlts, token) => {\n            const pattern = token === null || token === void 0 ? void 0 : token.PATTERN;\n            if ((pattern === null || pattern === void 0 ? void 0 : pattern.source) && partialMatches('^' + pattern.source + '$', keyword.value)) {\n                longerAlts.push(token);\n            }\n            return longerAlts;\n        }, []);\n    }\n}\n//# sourceMappingURL=token-builder.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { isCrossReference, isRuleCall } from '../languages/generated/ast.js';\nimport { getCrossReferenceTerminal, getRuleType } from '../utils/grammar-utils.js';\nexport class DefaultValueConverter {\n    convert(input, cstNode) {\n        let feature = cstNode.grammarSource;\n        if (isCrossReference(feature)) {\n            feature = getCrossReferenceTerminal(feature);\n        }\n        if (isRuleCall(feature)) {\n            const rule = feature.rule.ref;\n            if (!rule) {\n                throw new Error('This cst node was not parsed by a rule.');\n            }\n            return this.runConverter(rule, input, cstNode);\n        }\n        return input;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    runConverter(rule, input, cstNode) {\n        var _a;\n        switch (rule.name.toUpperCase()) {\n            case 'INT': return ValueConverter.convertInt(input);\n            case 'STRING': return ValueConverter.convertString(input);\n            case 'ID': return ValueConverter.convertID(input);\n        }\n        switch ((_a = getRuleType(rule)) === null || _a === void 0 ? void 0 : _a.toLowerCase()) {\n            case 'number': return ValueConverter.convertNumber(input);\n            case 'boolean': return ValueConverter.convertBoolean(input);\n            case 'bigint': return ValueConverter.convertBigint(input);\n            case 'date': return ValueConverter.convertDate(input);\n            default: return input;\n        }\n    }\n}\nexport var ValueConverter;\n(function (ValueConverter) {\n    function convertString(input) {\n        let result = '';\n        for (let i = 1; i < input.length - 1; i++) {\n            const c = input.charAt(i);\n            if (c === '\\\\') {\n                const c1 = input.charAt(++i);\n                result += convertEscapeCharacter(c1);\n            }\n            else {\n                result += c;\n            }\n        }\n        return result;\n    }\n    ValueConverter.convertString = convertString;\n    function convertEscapeCharacter(char) {\n        switch (char) {\n            case 'b': return '\\b';\n            case 'f': return '\\f';\n            case 'n': return '\\n';\n            case 'r': return '\\r';\n            case 't': return '\\t';\n            case 'v': return '\\v';\n            case '0': return '\\0';\n            default: return char;\n        }\n    }\n    function convertID(input) {\n        if (input.charAt(0) === '^') {\n            return input.substring(1);\n        }\n        else {\n            return input;\n        }\n    }\n    ValueConverter.convertID = convertID;\n    function convertInt(input) {\n        return parseInt(input);\n    }\n    ValueConverter.convertInt = convertInt;\n    function convertBigint(input) {\n        return BigInt(input);\n    }\n    ValueConverter.convertBigint = convertBigint;\n    function convertDate(input) {\n        return new Date(input);\n    }\n    ValueConverter.convertDate = convertDate;\n    function convertNumber(input) {\n        return Number(input);\n    }\n    ValueConverter.convertNumber = convertNumber;\n    function convertBoolean(input) {\n        return input.toLowerCase() === 'true';\n    }\n    ValueConverter.convertBoolean = convertBoolean;\n})(ValueConverter || (ValueConverter = {}));\n//# sourceMappingURL=value-converter.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken, CancellationTokenSource } from '../utils/cancellation.js';\n/**\n * Delays the execution of the current code to the next tick of the event loop.\n * Don't call this method directly in a tight loop to prevent too many promises from being created.\n */\nexport function delayNextTick() {\n    return new Promise(resolve => {\n        // In case we are running in a non-node environment, `setImmediate` isn't available.\n        // Using `setTimeout` of the browser API accomplishes the same result.\n        if (typeof setImmediate === 'undefined') {\n            setTimeout(resolve, 0);\n        }\n        else {\n            setImmediate(resolve);\n        }\n    });\n}\nlet lastTick = 0;\nlet globalInterruptionPeriod = 10;\n/**\n * Reset the global interruption period and create a cancellation token source.\n */\nexport function startCancelableOperation() {\n    lastTick = Date.now();\n    return new CancellationTokenSource();\n}\n/**\n * Change the period duration for `interruptAndCheck` to the given number of milliseconds.\n * The default value is 10ms.\n */\nexport function setInterruptionPeriod(period) {\n    globalInterruptionPeriod = period;\n}\n/**\n * This symbol may be thrown in an asynchronous context by any Langium service that receives\n * a `CancellationToken`. This means that the promise returned by such a service is rejected with\n * this symbol as rejection reason.\n */\nexport const OperationCancelled = Symbol('OperationCancelled');\n/**\n * Use this in a `catch` block to check whether the thrown object indicates that the operation\n * has been cancelled.\n */\nexport function isOperationCancelled(err) {\n    return err === OperationCancelled;\n}\n/**\n * This function does two things:\n *  1. Check the elapsed time since the last call to this function or to `startCancelableOperation`. If the predefined\n *     period (configured with `setInterruptionPeriod`) is exceeded, execution is delayed with `delayNextTick`.\n *  2. If the predefined period is not met yet or execution is resumed after an interruption, the given cancellation\n *     token is checked, and if cancellation is requested, `OperationCanceled` is thrown.\n *\n * All services in Langium that receive a `CancellationToken` may potentially call this function, so the\n * `CancellationToken` must be caught (with an `async` try-catch block or a `catch` callback attached to\n * the promise) to avoid that event being exposed as an error.\n */\nexport async function interruptAndCheck(token) {\n    if (token === CancellationToken.None) {\n        // Early exit in case cancellation was disabled by the caller\n        return;\n    }\n    const current = Date.now();\n    if (current - lastTick >= globalInterruptionPeriod) {\n        lastTick = current;\n        await delayNextTick();\n    }\n    if (token.isCancellationRequested) {\n        throw OperationCancelled;\n    }\n}\n/**\n * Simple implementation of the deferred pattern.\n * An object that exposes a promise and functions to resolve and reject it.\n */\nexport class Deferred {\n    constructor() {\n        this.promise = new Promise((resolve, reject) => {\n            this.resolve = (arg) => {\n                resolve(arg);\n                return this;\n            };\n            this.reject = (err) => {\n                reject(err);\n                return this;\n            };\n        });\n    }\n}\n//# sourceMappingURL=promise-utils.js.map","/* --------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n * ------------------------------------------------------------------------------------------ */\n'use strict';\nclass FullTextDocument {\n    constructor(uri, languageId, version, content) {\n        this._uri = uri;\n        this._languageId = languageId;\n        this._version = version;\n        this._content = content;\n        this._lineOffsets = undefined;\n    }\n    get uri() {\n        return this._uri;\n    }\n    get languageId() {\n        return this._languageId;\n    }\n    get version() {\n        return this._version;\n    }\n    getText(range) {\n        if (range) {\n            const start = this.offsetAt(range.start);\n            const end = this.offsetAt(range.end);\n            return this._content.substring(start, end);\n        }\n        return this._content;\n    }\n    update(changes, version) {\n        for (const change of changes) {\n            if (FullTextDocument.isIncremental(change)) {\n                // makes sure start is before end\n                const range = getWellformedRange(change.range);\n                // update content\n                const startOffset = this.offsetAt(range.start);\n                const endOffset = this.offsetAt(range.end);\n                this._content = this._content.substring(0, startOffset) + change.text + this._content.substring(endOffset, this._content.length);\n                // update the offsets\n                const startLine = Math.max(range.start.line, 0);\n                const endLine = Math.max(range.end.line, 0);\n                let lineOffsets = this._lineOffsets;\n                const addedLineOffsets = computeLineOffsets(change.text, false, startOffset);\n                if (endLine - startLine === addedLineOffsets.length) {\n                    for (let i = 0, len = addedLineOffsets.length; i < len; i++) {\n                        lineOffsets[i + startLine + 1] = addedLineOffsets[i];\n                    }\n                }\n                else {\n                    if (addedLineOffsets.length < 10000) {\n                        lineOffsets.splice(startLine + 1, endLine - startLine, ...addedLineOffsets);\n                    }\n                    else { // avoid too many arguments for splice\n                        this._lineOffsets = lineOffsets = lineOffsets.slice(0, startLine + 1).concat(addedLineOffsets, lineOffsets.slice(endLine + 1));\n                    }\n                }\n                const diff = change.text.length - (endOffset - startOffset);\n                if (diff !== 0) {\n                    for (let i = startLine + 1 + addedLineOffsets.length, len = lineOffsets.length; i < len; i++) {\n                        lineOffsets[i] = lineOffsets[i] + diff;\n                    }\n                }\n            }\n            else if (FullTextDocument.isFull(change)) {\n                this._content = change.text;\n                this._lineOffsets = undefined;\n            }\n            else {\n                throw new Error('Unknown change event received');\n            }\n        }\n        this._version = version;\n    }\n    getLineOffsets() {\n        if (this._lineOffsets === undefined) {\n            this._lineOffsets = computeLineOffsets(this._content, true);\n        }\n        return this._lineOffsets;\n    }\n    positionAt(offset) {\n        offset = Math.max(Math.min(offset, this._content.length), 0);\n        const lineOffsets = this.getLineOffsets();\n        let low = 0, high = lineOffsets.length;\n        if (high === 0) {\n            return { line: 0, character: offset };\n        }\n        while (low < high) {\n            const mid = Math.floor((low + high) / 2);\n            if (lineOffsets[mid] > offset) {\n                high = mid;\n            }\n            else {\n                low = mid + 1;\n            }\n        }\n        // low is the least x for which the line offset is larger than the current offset\n        // or array.length if no line offset is larger than the current offset\n        const line = low - 1;\n        offset = this.ensureBeforeEOL(offset, lineOffsets[line]);\n        return { line, character: offset - lineOffsets[line] };\n    }\n    offsetAt(position) {\n        const lineOffsets = this.getLineOffsets();\n        if (position.line >= lineOffsets.length) {\n            return this._content.length;\n        }\n        else if (position.line < 0) {\n            return 0;\n        }\n        const lineOffset = lineOffsets[position.line];\n        if (position.character <= 0) {\n            return lineOffset;\n        }\n        const nextLineOffset = (position.line + 1 < lineOffsets.length) ? lineOffsets[position.line + 1] : this._content.length;\n        const offset = Math.min(lineOffset + position.character, nextLineOffset);\n        return this.ensureBeforeEOL(offset, lineOffset);\n    }\n    ensureBeforeEOL(offset, lineOffset) {\n        while (offset > lineOffset && isEOL(this._content.charCodeAt(offset - 1))) {\n            offset--;\n        }\n        return offset;\n    }\n    get lineCount() {\n        return this.getLineOffsets().length;\n    }\n    static isIncremental(event) {\n        const candidate = event;\n        return candidate !== undefined && candidate !== null &&\n            typeof candidate.text === 'string' && candidate.range !== undefined &&\n            (candidate.rangeLength === undefined || typeof candidate.rangeLength === 'number');\n    }\n    static isFull(event) {\n        const candidate = event;\n        return candidate !== undefined && candidate !== null &&\n            typeof candidate.text === 'string' && candidate.range === undefined && candidate.rangeLength === undefined;\n    }\n}\nexport var TextDocument;\n(function (TextDocument) {\n    /**\n     * Creates a new text document.\n     *\n     * @param uri The document's uri.\n     * @param languageId  The document's language Id.\n     * @param version The document's initial version number.\n     * @param content The document's content.\n     */\n    function create(uri, languageId, version, content) {\n        return new FullTextDocument(uri, languageId, version, content);\n    }\n    TextDocument.create = create;\n    /**\n     * Updates a TextDocument by modifying its content.\n     *\n     * @param document the document to update. Only documents created by TextDocument.create are valid inputs.\n     * @param changes the changes to apply to the document.\n     * @param version the changes version for the document.\n     * @returns The updated TextDocument. Note: That's the same document instance passed in as first parameter.\n     *\n     */\n    function update(document, changes, version) {\n        if (document instanceof FullTextDocument) {\n            document.update(changes, version);\n            return document;\n        }\n        else {\n            throw new Error('TextDocument.update: document must be created by TextDocument.create');\n        }\n    }\n    TextDocument.update = update;\n    function applyEdits(document, edits) {\n        const text = document.getText();\n        const sortedEdits = mergeSort(edits.map(getWellformedEdit), (a, b) => {\n            const diff = a.range.start.line - b.range.start.line;\n            if (diff === 0) {\n                return a.range.start.character - b.range.start.character;\n            }\n            return diff;\n        });\n        let lastModifiedOffset = 0;\n        const spans = [];\n        for (const e of sortedEdits) {\n            const startOffset = document.offsetAt(e.range.start);\n            if (startOffset < lastModifiedOffset) {\n                throw new Error('Overlapping edit');\n            }\n            else if (startOffset > lastModifiedOffset) {\n                spans.push(text.substring(lastModifiedOffset, startOffset));\n            }\n            if (e.newText.length) {\n                spans.push(e.newText);\n            }\n            lastModifiedOffset = document.offsetAt(e.range.end);\n        }\n        spans.push(text.substr(lastModifiedOffset));\n        return spans.join('');\n    }\n    TextDocument.applyEdits = applyEdits;\n})(TextDocument || (TextDocument = {}));\nfunction mergeSort(data, compare) {\n    if (data.length <= 1) {\n        // sorted\n        return data;\n    }\n    const p = (data.length / 2) | 0;\n    const left = data.slice(0, p);\n    const right = data.slice(p);\n    mergeSort(left, compare);\n    mergeSort(right, compare);\n    let leftIdx = 0;\n    let rightIdx = 0;\n    let i = 0;\n    while (leftIdx < left.length && rightIdx < right.length) {\n        const ret = compare(left[leftIdx], right[rightIdx]);\n        if (ret <= 0) {\n            // smaller_equal -> take left to preserve order\n            data[i++] = left[leftIdx++];\n        }\n        else {\n            // greater -> take right\n            data[i++] = right[rightIdx++];\n        }\n    }\n    while (leftIdx < left.length) {\n        data[i++] = left[leftIdx++];\n    }\n    while (rightIdx < right.length) {\n        data[i++] = right[rightIdx++];\n    }\n    return data;\n}\nfunction computeLineOffsets(text, isAtLineStart, textOffset = 0) {\n    const result = isAtLineStart ? [textOffset] : [];\n    for (let i = 0; i < text.length; i++) {\n        const ch = text.charCodeAt(i);\n        if (isEOL(ch)) {\n            if (ch === 13 /* CharCode.CarriageReturn */ && i + 1 < text.length && text.charCodeAt(i + 1) === 10 /* CharCode.LineFeed */) {\n                i++;\n            }\n            result.push(textOffset + i + 1);\n        }\n    }\n    return result;\n}\nfunction isEOL(char) {\n    return char === 13 /* CharCode.CarriageReturn */ || char === 10 /* CharCode.LineFeed */;\n}\nfunction getWellformedRange(range) {\n    const start = range.start;\n    const end = range.end;\n    if (start.line > end.line || (start.line === end.line && start.character > end.character)) {\n        return { start: end, end: start };\n    }\n    return range;\n}\nfunction getWellformedEdit(textEdit) {\n    const range = getWellformedRange(textEdit.range);\n    if (range !== textEdit.range) {\n        return { newText: textEdit.newText, range };\n    }\n    return textEdit;\n}\n","var LIB;(()=>{\"use strict\";var t={470:t=>{function e(t){if(\"string\"!=typeof t)throw new TypeError(\"Path must be a string. Received \"+JSON.stringify(t))}function r(t,e){for(var r,n=\"\",i=0,o=-1,s=0,h=0;h<=t.length;++h){if(h<t.length)r=t.charCodeAt(h);else{if(47===r)break;r=47}if(47===r){if(o===h-1||1===s);else if(o!==h-1&&2===s){if(n.length<2||2!==i||46!==n.charCodeAt(n.length-1)||46!==n.charCodeAt(n.length-2))if(n.length>2){var a=n.lastIndexOf(\"/\");if(a!==n.length-1){-1===a?(n=\"\",i=0):i=(n=n.slice(0,a)).length-1-n.lastIndexOf(\"/\"),o=h,s=0;continue}}else if(2===n.length||1===n.length){n=\"\",i=0,o=h,s=0;continue}e&&(n.length>0?n+=\"/..\":n=\"..\",i=2)}else n.length>0?n+=\"/\"+t.slice(o+1,h):n=t.slice(o+1,h),i=h-o-1;o=h,s=0}else 46===r&&-1!==s?++s:s=-1}return n}var n={resolve:function(){for(var t,n=\"\",i=!1,o=arguments.length-1;o>=-1&&!i;o--){var s;o>=0?s=arguments[o]:(void 0===t&&(t=process.cwd()),s=t),e(s),0!==s.length&&(n=s+\"/\"+n,i=47===s.charCodeAt(0))}return n=r(n,!i),i?n.length>0?\"/\"+n:\"/\":n.length>0?n:\".\"},normalize:function(t){if(e(t),0===t.length)return\".\";var n=47===t.charCodeAt(0),i=47===t.charCodeAt(t.length-1);return 0!==(t=r(t,!n)).length||n||(t=\".\"),t.length>0&&i&&(t+=\"/\"),n?\"/\"+t:t},isAbsolute:function(t){return e(t),t.length>0&&47===t.charCodeAt(0)},join:function(){if(0===arguments.length)return\".\";for(var t,r=0;r<arguments.length;++r){var i=arguments[r];e(i),i.length>0&&(void 0===t?t=i:t+=\"/\"+i)}return void 0===t?\".\":n.normalize(t)},relative:function(t,r){if(e(t),e(r),t===r)return\"\";if((t=n.resolve(t))===(r=n.resolve(r)))return\"\";for(var i=1;i<t.length&&47===t.charCodeAt(i);++i);for(var o=t.length,s=o-i,h=1;h<r.length&&47===r.charCodeAt(h);++h);for(var a=r.length-h,c=s<a?s:a,f=-1,u=0;u<=c;++u){if(u===c){if(a>c){if(47===r.charCodeAt(h+u))return r.slice(h+u+1);if(0===u)return r.slice(h+u)}else s>c&&(47===t.charCodeAt(i+u)?f=u:0===u&&(f=0));break}var l=t.charCodeAt(i+u);if(l!==r.charCodeAt(h+u))break;47===l&&(f=u)}var g=\"\";for(u=i+f+1;u<=o;++u)u!==o&&47!==t.charCodeAt(u)||(0===g.length?g+=\"..\":g+=\"/..\");return g.length>0?g+r.slice(h+f):(h+=f,47===r.charCodeAt(h)&&++h,r.slice(h))},_makeLong:function(t){return t},dirname:function(t){if(e(t),0===t.length)return\".\";for(var r=t.charCodeAt(0),n=47===r,i=-1,o=!0,s=t.length-1;s>=1;--s)if(47===(r=t.charCodeAt(s))){if(!o){i=s;break}}else o=!1;return-1===i?n?\"/\":\".\":n&&1===i?\"//\":t.slice(0,i)},basename:function(t,r){if(void 0!==r&&\"string\"!=typeof r)throw new TypeError('\"ext\" argument must be a string');e(t);var n,i=0,o=-1,s=!0;if(void 0!==r&&r.length>0&&r.length<=t.length){if(r.length===t.length&&r===t)return\"\";var h=r.length-1,a=-1;for(n=t.length-1;n>=0;--n){var c=t.charCodeAt(n);if(47===c){if(!s){i=n+1;break}}else-1===a&&(s=!1,a=n+1),h>=0&&(c===r.charCodeAt(h)?-1==--h&&(o=n):(h=-1,o=a))}return i===o?o=a:-1===o&&(o=t.length),t.slice(i,o)}for(n=t.length-1;n>=0;--n)if(47===t.charCodeAt(n)){if(!s){i=n+1;break}}else-1===o&&(s=!1,o=n+1);return-1===o?\"\":t.slice(i,o)},extname:function(t){e(t);for(var r=-1,n=0,i=-1,o=!0,s=0,h=t.length-1;h>=0;--h){var a=t.charCodeAt(h);if(47!==a)-1===i&&(o=!1,i=h+1),46===a?-1===r?r=h:1!==s&&(s=1):-1!==r&&(s=-1);else if(!o){n=h+1;break}}return-1===r||-1===i||0===s||1===s&&r===i-1&&r===n+1?\"\":t.slice(r,i)},format:function(t){if(null===t||\"object\"!=typeof t)throw new TypeError('The \"pathObject\" argument must be of type Object. Received type '+typeof t);return function(t,e){var r=e.dir||e.root,n=e.base||(e.name||\"\")+(e.ext||\"\");return r?r===e.root?r+n:r+\"/\"+n:n}(0,t)},parse:function(t){e(t);var r={root:\"\",dir:\"\",base:\"\",ext:\"\",name:\"\"};if(0===t.length)return r;var n,i=t.charCodeAt(0),o=47===i;o?(r.root=\"/\",n=1):n=0;for(var s=-1,h=0,a=-1,c=!0,f=t.length-1,u=0;f>=n;--f)if(47!==(i=t.charCodeAt(f)))-1===a&&(c=!1,a=f+1),46===i?-1===s?s=f:1!==u&&(u=1):-1!==s&&(u=-1);else if(!c){h=f+1;break}return-1===s||-1===a||0===u||1===u&&s===a-1&&s===h+1?-1!==a&&(r.base=r.name=0===h&&o?t.slice(1,a):t.slice(h,a)):(0===h&&o?(r.name=t.slice(1,s),r.base=t.slice(1,a)):(r.name=t.slice(h,s),r.base=t.slice(h,a)),r.ext=t.slice(s,a)),h>0?r.dir=t.slice(0,h-1):o&&(r.dir=\"/\"),r},sep:\"/\",delimiter:\":\",win32:null,posix:null};n.posix=n,t.exports=n}},e={};function r(n){var i=e[n];if(void 0!==i)return i.exports;var o=e[n]={exports:{}};return t[n](o,o.exports,r),o.exports}r.d=(t,e)=>{for(var n in e)r.o(e,n)&&!r.o(t,n)&&Object.defineProperty(t,n,{enumerable:!0,get:e[n]})},r.o=(t,e)=>Object.prototype.hasOwnProperty.call(t,e),r.r=t=>{\"undefined\"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:\"Module\"}),Object.defineProperty(t,\"__esModule\",{value:!0})};var n={};(()=>{let t;if(r.r(n),r.d(n,{URI:()=>f,Utils:()=>P}),\"object\"==typeof process)t=\"win32\"===process.platform;else if(\"object\"==typeof navigator){let e=navigator.userAgent;t=e.indexOf(\"Windows\")>=0}const e=/^\\w[\\w\\d+.-]*$/,i=/^\\//,o=/^\\/\\//;function s(t,r){if(!t.scheme&&r)throw new Error(`[UriError]: Scheme is missing: {scheme: \"\", authority: \"${t.authority}\", path: \"${t.path}\", query: \"${t.query}\", fragment: \"${t.fragment}\"}`);if(t.scheme&&!e.test(t.scheme))throw new Error(\"[UriError]: Scheme contains illegal characters.\");if(t.path)if(t.authority){if(!i.test(t.path))throw new Error('[UriError]: If a URI contains an authority component, then the path component must either be empty or begin with a slash (\"/\") character')}else if(o.test(t.path))throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters (\"//\")')}const h=\"\",a=\"/\",c=/^(([^:/?#]+?):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?/;class f{static isUri(t){return t instanceof f||!!t&&\"string\"==typeof t.authority&&\"string\"==typeof t.fragment&&\"string\"==typeof t.path&&\"string\"==typeof t.query&&\"string\"==typeof t.scheme&&\"string\"==typeof t.fsPath&&\"function\"==typeof t.with&&\"function\"==typeof t.toString}scheme;authority;path;query;fragment;constructor(t,e,r,n,i,o=!1){\"object\"==typeof t?(this.scheme=t.scheme||h,this.authority=t.authority||h,this.path=t.path||h,this.query=t.query||h,this.fragment=t.fragment||h):(this.scheme=function(t,e){return t||e?t:\"file\"}(t,o),this.authority=e||h,this.path=function(t,e){switch(t){case\"https\":case\"http\":case\"file\":e?e[0]!==a&&(e=a+e):e=a}return e}(this.scheme,r||h),this.query=n||h,this.fragment=i||h,s(this,o))}get fsPath(){return m(this,!1)}with(t){if(!t)return this;let{scheme:e,authority:r,path:n,query:i,fragment:o}=t;return void 0===e?e=this.scheme:null===e&&(e=h),void 0===r?r=this.authority:null===r&&(r=h),void 0===n?n=this.path:null===n&&(n=h),void 0===i?i=this.query:null===i&&(i=h),void 0===o?o=this.fragment:null===o&&(o=h),e===this.scheme&&r===this.authority&&n===this.path&&i===this.query&&o===this.fragment?this:new l(e,r,n,i,o)}static parse(t,e=!1){const r=c.exec(t);return r?new l(r[2]||h,C(r[4]||h),C(r[5]||h),C(r[7]||h),C(r[9]||h),e):new l(h,h,h,h,h)}static file(e){let r=h;if(t&&(e=e.replace(/\\\\/g,a)),e[0]===a&&e[1]===a){const t=e.indexOf(a,2);-1===t?(r=e.substring(2),e=a):(r=e.substring(2,t),e=e.substring(t)||a)}return new l(\"file\",r,e,h,h)}static from(t){const e=new l(t.scheme,t.authority,t.path,t.query,t.fragment);return s(e,!0),e}toString(t=!1){return y(this,t)}toJSON(){return this}static revive(t){if(t){if(t instanceof f)return t;{const e=new l(t);return e._formatted=t.external,e._fsPath=t._sep===u?t.fsPath:null,e}}return t}}const u=t?1:void 0;class l extends f{_formatted=null;_fsPath=null;get fsPath(){return this._fsPath||(this._fsPath=m(this,!1)),this._fsPath}toString(t=!1){return t?y(this,!0):(this._formatted||(this._formatted=y(this,!1)),this._formatted)}toJSON(){const t={$mid:1};return this._fsPath&&(t.fsPath=this._fsPath,t._sep=u),this._formatted&&(t.external=this._formatted),this.path&&(t.path=this.path),this.scheme&&(t.scheme=this.scheme),this.authority&&(t.authority=this.authority),this.query&&(t.query=this.query),this.fragment&&(t.fragment=this.fragment),t}}const g={58:\"%3A\",47:\"%2F\",63:\"%3F\",35:\"%23\",91:\"%5B\",93:\"%5D\",64:\"%40\",33:\"%21\",36:\"%24\",38:\"%26\",39:\"%27\",40:\"%28\",41:\"%29\",42:\"%2A\",43:\"%2B\",44:\"%2C\",59:\"%3B\",61:\"%3D\",32:\"%20\"};function d(t,e,r){let n,i=-1;for(let o=0;o<t.length;o++){const s=t.charCodeAt(o);if(s>=97&&s<=122||s>=65&&s<=90||s>=48&&s<=57||45===s||46===s||95===s||126===s||e&&47===s||r&&91===s||r&&93===s||r&&58===s)-1!==i&&(n+=encodeURIComponent(t.substring(i,o)),i=-1),void 0!==n&&(n+=t.charAt(o));else{void 0===n&&(n=t.substr(0,o));const e=g[s];void 0!==e?(-1!==i&&(n+=encodeURIComponent(t.substring(i,o)),i=-1),n+=e):-1===i&&(i=o)}}return-1!==i&&(n+=encodeURIComponent(t.substring(i))),void 0!==n?n:t}function p(t){let e;for(let r=0;r<t.length;r++){const n=t.charCodeAt(r);35===n||63===n?(void 0===e&&(e=t.substr(0,r)),e+=g[n]):void 0!==e&&(e+=t[r])}return void 0!==e?e:t}function m(e,r){let n;return n=e.authority&&e.path.length>1&&\"file\"===e.scheme?`//${e.authority}${e.path}`:47===e.path.charCodeAt(0)&&(e.path.charCodeAt(1)>=65&&e.path.charCodeAt(1)<=90||e.path.charCodeAt(1)>=97&&e.path.charCodeAt(1)<=122)&&58===e.path.charCodeAt(2)?r?e.path.substr(1):e.path[1].toLowerCase()+e.path.substr(2):e.path,t&&(n=n.replace(/\\//g,\"\\\\\")),n}function y(t,e){const r=e?p:d;let n=\"\",{scheme:i,authority:o,path:s,query:h,fragment:c}=t;if(i&&(n+=i,n+=\":\"),(o||\"file\"===i)&&(n+=a,n+=a),o){let t=o.indexOf(\"@\");if(-1!==t){const e=o.substr(0,t);o=o.substr(t+1),t=e.lastIndexOf(\":\"),-1===t?n+=r(e,!1,!1):(n+=r(e.substr(0,t),!1,!1),n+=\":\",n+=r(e.substr(t+1),!1,!0)),n+=\"@\"}o=o.toLowerCase(),t=o.lastIndexOf(\":\"),-1===t?n+=r(o,!1,!0):(n+=r(o.substr(0,t),!1,!0),n+=o.substr(t))}if(s){if(s.length>=3&&47===s.charCodeAt(0)&&58===s.charCodeAt(2)){const t=s.charCodeAt(1);t>=65&&t<=90&&(s=`/${String.fromCharCode(t+32)}:${s.substr(3)}`)}else if(s.length>=2&&58===s.charCodeAt(1)){const t=s.charCodeAt(0);t>=65&&t<=90&&(s=`${String.fromCharCode(t+32)}:${s.substr(2)}`)}n+=r(s,!0,!1)}return h&&(n+=\"?\",n+=r(h,!1,!1)),c&&(n+=\"#\",n+=e?c:d(c,!1,!1)),n}function v(t){try{return decodeURIComponent(t)}catch{return t.length>3?t.substr(0,3)+v(t.substr(3)):t}}const b=/(%[0-9A-Za-z][0-9A-Za-z])+/g;function C(t){return t.match(b)?t.replace(b,(t=>v(t))):t}var A=r(470);const w=A.posix||A,x=\"/\";var P;!function(t){t.joinPath=function(t,...e){return t.with({path:w.join(t.path,...e)})},t.resolvePath=function(t,...e){let r=t.path,n=!1;r[0]!==x&&(r=x+r,n=!0);let i=w.resolve(r,...e);return n&&i[0]===x&&!t.authority&&(i=i.substring(1)),t.with({path:i})},t.dirname=function(t){if(0===t.path.length||t.path===x)return t;let e=w.dirname(t.path);return 1===e.length&&46===e.charCodeAt(0)&&(e=\"\"),t.with({path:e})},t.basename=function(t){return w.basename(t.path)},t.extname=function(t){return w.extname(t.path)}}(P||(P={}))})(),LIB=n})();export const{URI,Utils}=LIB;\n//# sourceMappingURL=index.mjs.map","/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { URI, Utils } from 'vscode-uri';\nexport { URI };\nexport var UriUtils;\n(function (UriUtils) {\n    UriUtils.basename = Utils.basename;\n    UriUtils.dirname = Utils.dirname;\n    UriUtils.extname = Utils.extname;\n    UriUtils.joinPath = Utils.joinPath;\n    UriUtils.resolvePath = Utils.resolvePath;\n    function equals(a, b) {\n        return (a === null || a === void 0 ? void 0 : a.toString()) === (b === null || b === void 0 ? void 0 : b.toString());\n    }\n    UriUtils.equals = equals;\n    function relative(from, to) {\n        const fromPath = typeof from === 'string' ? from : from.path;\n        const toPath = typeof to === 'string' ? to : to.path;\n        const fromParts = fromPath.split('/').filter(e => e.length > 0);\n        const toParts = toPath.split('/').filter(e => e.length > 0);\n        let i = 0;\n        for (; i < fromParts.length; i++) {\n            if (fromParts[i] !== toParts[i]) {\n                break;\n            }\n        }\n        const backPart = '../'.repeat(fromParts.length - i);\n        const toPart = toParts.slice(i).join('/');\n        return backPart + toPart;\n    }\n    UriUtils.relative = relative;\n})(UriUtils || (UriUtils = {}));\n//# sourceMappingURL=uri-utils.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\n/**\n * Re-export 'TextDocument' from 'vscode-languageserver-textdocument' for convenience,\n *  including both type _and_ symbol (namespace), as we here and there also refer to the symbol,\n *  the overhead is very small, just a few kilobytes.\n * Everything else of that package (at the time contributing) is also defined\n *  in 'vscode-languageserver-protocol' or 'vscode-languageserver-types'.\n */\nexport { TextDocument } from 'vscode-languageserver-textdocument';\nimport { TextDocument } from './documents.js';\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { stream } from '../utils/stream.js';\nimport { URI } from '../utils/uri-utils.js';\n/**\n * A document is subject to several phases that are run in predefined order. Any state value implies that\n * smaller state values are finished as well.\n */\nexport var DocumentState;\n(function (DocumentState) {\n    /**\n     * The text content has changed and needs to be parsed again. The AST held by this outdated\n     * document instance is no longer valid.\n     */\n    DocumentState[DocumentState[\"Changed\"] = 0] = \"Changed\";\n    /**\n     * An AST has been created from the text content. The document structure can be traversed,\n     * but cross-references cannot be resolved yet. If necessary, the structure can be manipulated\n     * at this stage as a preprocessing step.\n     */\n    DocumentState[DocumentState[\"Parsed\"] = 1] = \"Parsed\";\n    /**\n     * The `IndexManager` service has processed AST nodes of this document. This means the\n     * exported symbols are available in the global scope and can be resolved from other documents.\n     */\n    DocumentState[DocumentState[\"IndexedContent\"] = 2] = \"IndexedContent\";\n    /**\n     * The `ScopeComputation` service has processed this document. This means the local symbols\n     * are stored in a MultiMap so they can be looked up by the `ScopeProvider` service.\n     * Once a document has reached this state, you may follow every reference - it will lazily\n     * resolve its `ref` property and yield either the target AST node or `undefined` in case\n     * the target is not in scope.\n     */\n    DocumentState[DocumentState[\"ComputedScopes\"] = 3] = \"ComputedScopes\";\n    /**\n     * The `Linker` service has processed this document. All outgoing references have been\n     * resolved or marked as erroneous.\n     */\n    DocumentState[DocumentState[\"Linked\"] = 4] = \"Linked\";\n    /**\n     * The `IndexManager` service has processed AST node references of this document. This is\n     * necessary to determine which documents are affected by a change in one of the workspace\n     * documents.\n     */\n    DocumentState[DocumentState[\"IndexedReferences\"] = 5] = \"IndexedReferences\";\n    /**\n     * The `DocumentValidator` service has processed this document. The language server listens\n     * to the results of this phase and sends diagnostics to the client.\n     */\n    DocumentState[DocumentState[\"Validated\"] = 6] = \"Validated\";\n})(DocumentState || (DocumentState = {}));\nexport class DefaultLangiumDocumentFactory {\n    constructor(services) {\n        this.serviceRegistry = services.ServiceRegistry;\n        this.textDocuments = services.workspace.TextDocuments;\n        this.fileSystemProvider = services.workspace.FileSystemProvider;\n    }\n    async fromUri(uri, cancellationToken = CancellationToken.None) {\n        const content = await this.fileSystemProvider.readFile(uri);\n        return this.createAsync(uri, content, cancellationToken);\n    }\n    fromTextDocument(textDocument, uri, cancellationToken) {\n        uri = uri !== null && uri !== void 0 ? uri : URI.parse(textDocument.uri);\n        if (cancellationToken) {\n            return this.createAsync(uri, textDocument, cancellationToken);\n        }\n        else {\n            return this.create(uri, textDocument);\n        }\n    }\n    fromString(text, uri, cancellationToken) {\n        if (cancellationToken) {\n            return this.createAsync(uri, text, cancellationToken);\n        }\n        else {\n            return this.create(uri, text);\n        }\n    }\n    fromModel(model, uri) {\n        return this.create(uri, { $model: model });\n    }\n    create(uri, content) {\n        if (typeof content === 'string') {\n            const parseResult = this.parse(uri, content);\n            return this.createLangiumDocument(parseResult, uri, undefined, content);\n        }\n        else if ('$model' in content) {\n            const parseResult = { value: content.$model, parserErrors: [], lexerErrors: [] };\n            return this.createLangiumDocument(parseResult, uri);\n        }\n        else {\n            const parseResult = this.parse(uri, content.getText());\n            return this.createLangiumDocument(parseResult, uri, content);\n        }\n    }\n    async createAsync(uri, content, cancelToken) {\n        if (typeof content === 'string') {\n            const parseResult = await this.parseAsync(uri, content, cancelToken);\n            return this.createLangiumDocument(parseResult, uri, undefined, content);\n        }\n        else {\n            const parseResult = await this.parseAsync(uri, content.getText(), cancelToken);\n            return this.createLangiumDocument(parseResult, uri, content);\n        }\n    }\n    /**\n     * Create a LangiumDocument from a given parse result.\n     *\n     * A TextDocument is created on demand if it is not provided as argument here. Usually this\n     * should not be necessary because the main purpose of the TextDocument is to convert between\n     * text ranges and offsets, which is done solely in LSP request handling.\n     *\n     * With the introduction of {@link update} below this method is supposed to be mainly called\n     * during workspace initialization and on addition/recognition of new files, while changes in\n     * existing documents are processed via {@link update}.\n     */\n    createLangiumDocument(parseResult, uri, textDocument, text) {\n        let document;\n        if (textDocument) {\n            document = {\n                parseResult,\n                uri,\n                state: DocumentState.Parsed,\n                references: [],\n                textDocument\n            };\n        }\n        else {\n            const textDocumentGetter = this.createTextDocumentGetter(uri, text);\n            document = {\n                parseResult,\n                uri,\n                state: DocumentState.Parsed,\n                references: [],\n                get textDocument() {\n                    return textDocumentGetter();\n                }\n            };\n        }\n        parseResult.value.$document = document;\n        return document;\n    }\n    async update(document, cancellationToken) {\n        var _a, _b;\n        // The CST full text property contains the original text that was used to create the AST.\n        const oldText = (_a = document.parseResult.value.$cstNode) === null || _a === void 0 ? void 0 : _a.root.fullText;\n        const textDocument = (_b = this.textDocuments) === null || _b === void 0 ? void 0 : _b.get(document.uri.toString());\n        const text = textDocument ? textDocument.getText() : await this.fileSystemProvider.readFile(document.uri);\n        if (textDocument) {\n            Object.defineProperty(document, 'textDocument', {\n                value: textDocument\n            });\n        }\n        else {\n            const textDocumentGetter = this.createTextDocumentGetter(document.uri, text);\n            Object.defineProperty(document, 'textDocument', {\n                get: textDocumentGetter\n            });\n        }\n        // Some of these documents can be pretty large, so parsing them again can be quite expensive.\n        // Therefore, we only parse if the text has actually changed.\n        if (oldText !== text) {\n            document.parseResult = await this.parseAsync(document.uri, text, cancellationToken);\n            document.parseResult.value.$document = document;\n        }\n        document.state = DocumentState.Parsed;\n        return document;\n    }\n    parse(uri, text) {\n        const services = this.serviceRegistry.getServices(uri);\n        return services.parser.LangiumParser.parse(text);\n    }\n    parseAsync(uri, text, cancellationToken) {\n        const services = this.serviceRegistry.getServices(uri);\n        return services.parser.AsyncParser.parse(text, cancellationToken);\n    }\n    createTextDocumentGetter(uri, text) {\n        const serviceRegistry = this.serviceRegistry;\n        let textDoc = undefined;\n        return () => {\n            return textDoc !== null && textDoc !== void 0 ? textDoc : (textDoc = TextDocument.create(uri.toString(), serviceRegistry.getServices(uri).LanguageMetaData.languageId, 0, text !== null && text !== void 0 ? text : ''));\n        };\n    }\n}\nexport class DefaultLangiumDocuments {\n    constructor(services) {\n        this.documentMap = new Map();\n        this.langiumDocumentFactory = services.workspace.LangiumDocumentFactory;\n    }\n    get all() {\n        return stream(this.documentMap.values());\n    }\n    addDocument(document) {\n        const uriString = document.uri.toString();\n        if (this.documentMap.has(uriString)) {\n            throw new Error(`A document with the URI '${uriString}' is already present.`);\n        }\n        this.documentMap.set(uriString, document);\n    }\n    getDocument(uri) {\n        const uriString = uri.toString();\n        return this.documentMap.get(uriString);\n    }\n    async getOrCreateDocument(uri, cancellationToken) {\n        let document = this.getDocument(uri);\n        if (document) {\n            return document;\n        }\n        document = await this.langiumDocumentFactory.fromUri(uri, cancellationToken);\n        this.addDocument(document);\n        return document;\n    }\n    createDocument(uri, text, cancellationToken) {\n        if (cancellationToken) {\n            return this.langiumDocumentFactory.fromString(text, uri, cancellationToken).then(document => {\n                this.addDocument(document);\n                return document;\n            });\n        }\n        else {\n            const document = this.langiumDocumentFactory.fromString(text, uri);\n            this.addDocument(document);\n            return document;\n        }\n    }\n    hasDocument(uri) {\n        return this.documentMap.has(uri.toString());\n    }\n    invalidateDocument(uri) {\n        const uriString = uri.toString();\n        const langiumDoc = this.documentMap.get(uriString);\n        if (langiumDoc) {\n            langiumDoc.state = DocumentState.Changed;\n            langiumDoc.precomputedScopes = undefined;\n            langiumDoc.references = [];\n            langiumDoc.diagnostics = undefined;\n        }\n        return langiumDoc;\n    }\n    deleteDocument(uri) {\n        const uriString = uri.toString();\n        const langiumDoc = this.documentMap.get(uriString);\n        if (langiumDoc) {\n            langiumDoc.state = DocumentState.Changed;\n            this.documentMap.delete(uriString);\n        }\n        return langiumDoc;\n    }\n}\n//# sourceMappingURL=documents.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { MultiMap } from '../utils/collections.js';\nimport { isOperationCancelled } from '../utils/promise-utils.js';\nimport { stream } from '../utils/stream.js';\n/**\n * Create DiagnosticData for a given diagnostic code. The result can be put into the `data` field of a DiagnosticInfo.\n */\nexport function diagnosticData(code) {\n    return { code };\n}\nexport var ValidationCategory;\n(function (ValidationCategory) {\n    ValidationCategory.all = ['fast', 'slow', 'built-in'];\n})(ValidationCategory || (ValidationCategory = {}));\n/**\n * Manages a set of `ValidationCheck`s to be applied when documents are validated.\n */\nexport class ValidationRegistry {\n    constructor(services) {\n        this.entries = new MultiMap();\n        this.reflection = services.shared.AstReflection;\n    }\n    /**\n     * Register a set of validation checks. Each value in the record can be either a single validation check (i.e. a function)\n     * or an array of validation checks.\n     *\n     * @param checksRecord Set of validation checks to register.\n     * @param category Optional category for the validation checks (defaults to `'fast'`).\n     * @param thisObj Optional object to be used as `this` when calling the validation check functions.\n     */\n    register(checksRecord, thisObj = this, category = 'fast') {\n        if (category === 'built-in') {\n            throw new Error(\"The 'built-in' category is reserved for lexer, parser, and linker errors.\");\n        }\n        for (const [type, ch] of Object.entries(checksRecord)) {\n            const callbacks = ch;\n            if (Array.isArray(callbacks)) {\n                for (const check of callbacks) {\n                    const entry = {\n                        check: this.wrapValidationException(check, thisObj),\n                        category\n                    };\n                    this.addEntry(type, entry);\n                }\n            }\n            else if (typeof callbacks === 'function') {\n                const entry = {\n                    check: this.wrapValidationException(callbacks, thisObj),\n                    category\n                };\n                this.addEntry(type, entry);\n            }\n        }\n    }\n    wrapValidationException(check, thisObj) {\n        return async (node, accept, cancelToken) => {\n            try {\n                await check.call(thisObj, node, accept, cancelToken);\n            }\n            catch (err) {\n                if (isOperationCancelled(err)) {\n                    throw err;\n                }\n                console.error('An error occurred during validation:', err);\n                const message = err instanceof Error ? err.message : String(err);\n                if (err instanceof Error && err.stack) {\n                    console.error(err.stack);\n                }\n                accept('error', 'An error occurred during validation: ' + message, { node });\n            }\n        };\n    }\n    addEntry(type, entry) {\n        if (type === 'AstNode') {\n            this.entries.add('AstNode', entry);\n            return;\n        }\n        for (const subtype of this.reflection.getAllSubTypes(type)) {\n            this.entries.add(subtype, entry);\n        }\n    }\n    getChecks(type, categories) {\n        let checks = stream(this.entries.get(type))\n            .concat(this.entries.get('AstNode'));\n        if (categories) {\n            checks = checks.filter(entry => categories.includes(entry.category));\n        }\n        return checks.map(entry => entry.check);\n    }\n}\n//# sourceMappingURL=validation-registry.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { findNodeForKeyword, findNodeForProperty } from '../utils/grammar-utils.js';\nimport { streamAst } from '../utils/ast-utils.js';\nimport { tokenToRange } from '../utils/cst-utils.js';\nimport { interruptAndCheck, isOperationCancelled } from '../utils/promise-utils.js';\nimport { diagnosticData } from './validation-registry.js';\nexport class DefaultDocumentValidator {\n    constructor(services) {\n        this.validationRegistry = services.validation.ValidationRegistry;\n        this.metadata = services.LanguageMetaData;\n    }\n    async validateDocument(document, options = {}, cancelToken = CancellationToken.None) {\n        const parseResult = document.parseResult;\n        const diagnostics = [];\n        await interruptAndCheck(cancelToken);\n        if (!options.categories || options.categories.includes('built-in')) {\n            this.processLexingErrors(parseResult, diagnostics, options);\n            if (options.stopAfterLexingErrors && diagnostics.some(d => { var _a; return ((_a = d.data) === null || _a === void 0 ? void 0 : _a.code) === DocumentValidator.LexingError; })) {\n                return diagnostics;\n            }\n            this.processParsingErrors(parseResult, diagnostics, options);\n            if (options.stopAfterParsingErrors && diagnostics.some(d => { var _a; return ((_a = d.data) === null || _a === void 0 ? void 0 : _a.code) === DocumentValidator.ParsingError; })) {\n                return diagnostics;\n            }\n            this.processLinkingErrors(document, diagnostics, options);\n            if (options.stopAfterLinkingErrors && diagnostics.some(d => { var _a; return ((_a = d.data) === null || _a === void 0 ? void 0 : _a.code) === DocumentValidator.LinkingError; })) {\n                return diagnostics;\n            }\n        }\n        // Process custom validations\n        try {\n            diagnostics.push(...await this.validateAst(parseResult.value, options, cancelToken));\n        }\n        catch (err) {\n            if (isOperationCancelled(err)) {\n                throw err;\n            }\n            console.error('An error occurred during validation:', err);\n        }\n        await interruptAndCheck(cancelToken);\n        return diagnostics;\n    }\n    processLexingErrors(parseResult, diagnostics, _options) {\n        for (const lexerError of parseResult.lexerErrors) {\n            const diagnostic = {\n                severity: toDiagnosticSeverity('error'),\n                range: {\n                    start: {\n                        line: lexerError.line - 1,\n                        character: lexerError.column - 1\n                    },\n                    end: {\n                        line: lexerError.line - 1,\n                        character: lexerError.column + lexerError.length - 1\n                    }\n                },\n                message: lexerError.message,\n                data: diagnosticData(DocumentValidator.LexingError),\n                source: this.getSource()\n            };\n            diagnostics.push(diagnostic);\n        }\n    }\n    processParsingErrors(parseResult, diagnostics, _options) {\n        for (const parserError of parseResult.parserErrors) {\n            let range = undefined;\n            // We can run into the chevrotain error recovery here\n            // The token contained in the parser error might be automatically inserted\n            // In this case every position value will be `NaN`\n            if (isNaN(parserError.token.startOffset)) {\n                // Some special parser error types contain a `previousToken`\n                // We can simply append our diagnostic to that token\n                if ('previousToken' in parserError) {\n                    const token = parserError.previousToken;\n                    if (!isNaN(token.startOffset)) {\n                        const position = { line: token.endLine - 1, character: token.endColumn };\n                        range = { start: position, end: position };\n                    }\n                    else {\n                        // No valid prev token. Might be empty document or containing only hidden tokens.\n                        // Point to document start\n                        const position = { line: 0, character: 0 };\n                        range = { start: position, end: position };\n                    }\n                }\n            }\n            else {\n                range = tokenToRange(parserError.token);\n            }\n            if (range) {\n                const diagnostic = {\n                    severity: toDiagnosticSeverity('error'),\n                    range,\n                    message: parserError.message,\n                    data: diagnosticData(DocumentValidator.ParsingError),\n                    source: this.getSource()\n                };\n                diagnostics.push(diagnostic);\n            }\n        }\n    }\n    processLinkingErrors(document, diagnostics, _options) {\n        for (const reference of document.references) {\n            const linkingError = reference.error;\n            if (linkingError) {\n                const info = {\n                    node: linkingError.container,\n                    property: linkingError.property,\n                    index: linkingError.index,\n                    data: {\n                        code: DocumentValidator.LinkingError,\n                        containerType: linkingError.container.$type,\n                        property: linkingError.property,\n                        refText: linkingError.reference.$refText\n                    }\n                };\n                diagnostics.push(this.toDiagnostic('error', linkingError.message, info));\n            }\n        }\n    }\n    async validateAst(rootNode, options, cancelToken = CancellationToken.None) {\n        const validationItems = [];\n        const acceptor = (severity, message, info) => {\n            validationItems.push(this.toDiagnostic(severity, message, info));\n        };\n        await Promise.all(streamAst(rootNode).map(async (node) => {\n            await interruptAndCheck(cancelToken);\n            const checks = this.validationRegistry.getChecks(node.$type, options.categories);\n            for (const check of checks) {\n                await check(node, acceptor, cancelToken);\n            }\n        }));\n        return validationItems;\n    }\n    toDiagnostic(severity, message, info) {\n        return {\n            message,\n            range: getDiagnosticRange(info),\n            severity: toDiagnosticSeverity(severity),\n            code: info.code,\n            codeDescription: info.codeDescription,\n            tags: info.tags,\n            relatedInformation: info.relatedInformation,\n            data: info.data,\n            source: this.getSource()\n        };\n    }\n    getSource() {\n        return this.metadata.languageId;\n    }\n}\nexport function getDiagnosticRange(info) {\n    if (info.range) {\n        return info.range;\n    }\n    let cstNode;\n    if (typeof info.property === 'string') {\n        cstNode = findNodeForProperty(info.node.$cstNode, info.property, info.index);\n    }\n    else if (typeof info.keyword === 'string') {\n        cstNode = findNodeForKeyword(info.node.$cstNode, info.keyword, info.index);\n    }\n    cstNode !== null && cstNode !== void 0 ? cstNode : (cstNode = info.node.$cstNode);\n    if (!cstNode) {\n        return {\n            start: { line: 0, character: 0 },\n            end: { line: 0, character: 0 }\n        };\n    }\n    return cstNode.range;\n}\nexport function toDiagnosticSeverity(severity) {\n    switch (severity) {\n        case 'error':\n            return 1; // according to vscode-languageserver-types/lib/esm/main.js#DiagnosticSeverity.Error\n        case 'warning':\n            return 2; // according to vscode-languageserver-types/lib/esm/main.js#DiagnosticSeverity.Warning\n        case 'info':\n            return 3; // according to vscode-languageserver-types/lib/esm/main.js#DiagnosticSeverity.Information\n        case 'hint':\n            return 4; // according to vscode-languageserver-types/lib/esm/main.js#DiagnosticSeverity.Hint\n        default:\n            throw new Error('Invalid diagnostic severity: ' + severity);\n    }\n}\nexport var DocumentValidator;\n(function (DocumentValidator) {\n    DocumentValidator.LexingError = 'lexing-error';\n    DocumentValidator.ParsingError = 'parsing-error';\n    DocumentValidator.LinkingError = 'linking-error';\n})(DocumentValidator || (DocumentValidator = {}));\n//# sourceMappingURL=document-validator.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nexport var Disposable;\n(function (Disposable) {\n    function create(callback) {\n        return {\n            dispose: async () => await callback()\n        };\n    }\n    Disposable.create = create;\n})(Disposable || (Disposable = {}));\n//# sourceMappingURL=disposable.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { isAstNode, isAstNodeDescription, isLinkingError } from '../syntax-tree.js';\nimport { getDocument, streamAst, streamReferences } from '../utils/ast-utils.js';\nimport { interruptAndCheck } from '../utils/promise-utils.js';\nimport { DocumentState } from '../workspace/documents.js';\nexport class DefaultLinker {\n    constructor(services) {\n        this.reflection = services.shared.AstReflection;\n        this.langiumDocuments = () => services.shared.workspace.LangiumDocuments;\n        this.scopeProvider = services.references.ScopeProvider;\n        this.astNodeLocator = services.workspace.AstNodeLocator;\n    }\n    async link(document, cancelToken = CancellationToken.None) {\n        for (const node of streamAst(document.parseResult.value)) {\n            await interruptAndCheck(cancelToken);\n            streamReferences(node).forEach(ref => this.doLink(ref, document));\n        }\n    }\n    doLink(refInfo, document) {\n        const ref = refInfo.reference;\n        // The reference may already have been resolved lazily by accessing its `ref` property.\n        if (ref._ref === undefined) {\n            try {\n                const description = this.getCandidate(refInfo);\n                if (isLinkingError(description)) {\n                    ref._ref = description;\n                }\n                else {\n                    ref._nodeDescription = description;\n                    if (this.langiumDocuments().hasDocument(description.documentUri)) {\n                        // The target document is already loaded\n                        const linkedNode = this.loadAstNode(description);\n                        ref._ref = linkedNode !== null && linkedNode !== void 0 ? linkedNode : this.createLinkingError(refInfo, description);\n                    }\n                }\n            }\n            catch (err) {\n                ref._ref = Object.assign(Object.assign({}, refInfo), { message: `An error occurred while resolving reference to '${ref.$refText}': ${err}` });\n            }\n        }\n        // Add the reference to the document's array of references\n        document.references.push(ref);\n    }\n    unlink(document) {\n        for (const ref of document.references) {\n            delete ref._ref;\n            delete ref._nodeDescription;\n        }\n        document.references = [];\n    }\n    getCandidate(refInfo) {\n        const scope = this.scopeProvider.getScope(refInfo);\n        const description = scope.getElement(refInfo.reference.$refText);\n        return description !== null && description !== void 0 ? description : this.createLinkingError(refInfo);\n    }\n    buildReference(node, property, refNode, refText) {\n        // See behavior description in doc of Linker, update that on changes in here.\n        // eslint-disable-next-line @typescript-eslint/no-this-alias\n        const linker = this;\n        const reference = {\n            $refNode: refNode,\n            $refText: refText,\n            get ref() {\n                var _a;\n                if (isAstNode(this._ref)) {\n                    // Most frequent case: the target is already resolved.\n                    return this._ref;\n                }\n                else if (isAstNodeDescription(this._nodeDescription)) {\n                    // A candidate has been found before, but it is not loaded yet.\n                    const linkedNode = linker.loadAstNode(this._nodeDescription);\n                    this._ref = linkedNode !== null && linkedNode !== void 0 ? linkedNode : linker.createLinkingError({ reference, container: node, property }, this._nodeDescription);\n                }\n                else if (this._ref === undefined) {\n                    // The reference has not been linked yet, so do that now.\n                    const refData = linker.getLinkedNode({ reference, container: node, property });\n                    if (refData.error && getDocument(node).state < DocumentState.ComputedScopes) {\n                        // Document scope is not ready, don't set `this._ref` so linker can retry later.\n                        return undefined;\n                    }\n                    this._ref = (_a = refData.node) !== null && _a !== void 0 ? _a : refData.error;\n                    this._nodeDescription = refData.descr;\n                }\n                return isAstNode(this._ref) ? this._ref : undefined;\n            },\n            get $nodeDescription() {\n                return this._nodeDescription;\n            },\n            get error() {\n                return isLinkingError(this._ref) ? this._ref : undefined;\n            }\n        };\n        return reference;\n    }\n    getLinkedNode(refInfo) {\n        try {\n            const description = this.getCandidate(refInfo);\n            if (isLinkingError(description)) {\n                return { error: description };\n            }\n            const linkedNode = this.loadAstNode(description);\n            if (linkedNode) {\n                return { node: linkedNode, descr: description };\n            }\n            else {\n                return {\n                    descr: description,\n                    error: this.createLinkingError(refInfo, description)\n                };\n            }\n        }\n        catch (err) {\n            return {\n                error: Object.assign(Object.assign({}, refInfo), { message: `An error occurred while resolving reference to '${refInfo.reference.$refText}': ${err}` })\n            };\n        }\n    }\n    loadAstNode(nodeDescription) {\n        if (nodeDescription.node) {\n            return nodeDescription.node;\n        }\n        const doc = this.langiumDocuments().getDocument(nodeDescription.documentUri);\n        if (!doc) {\n            return undefined;\n        }\n        return this.astNodeLocator.getAstNode(doc.parseResult.value, nodeDescription.path);\n    }\n    createLinkingError(refInfo, targetDescription) {\n        // Check whether the document is sufficiently processed by the DocumentBuilder. If not, this is a hint for a bug\n        // in the language implementation.\n        const document = getDocument(refInfo.container);\n        if (document.state < DocumentState.ComputedScopes) {\n            console.warn(`Attempted reference resolution before document reached ComputedScopes state (${document.uri}).`);\n        }\n        const referenceType = this.reflection.getReferenceType(refInfo);\n        return Object.assign(Object.assign({}, refInfo), { message: `Could not resolve reference to ${referenceType} named '${refInfo.reference.$refText}'.`, targetDescription });\n    }\n}\n//# sourceMappingURL=linker.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { findNodeForProperty } from '../utils/grammar-utils.js';\nexport function isNamed(node) {\n    return typeof node.name === 'string';\n}\nexport class DefaultNameProvider {\n    getName(node) {\n        if (isNamed(node)) {\n            return node.name;\n        }\n        return undefined;\n    }\n    getNameNode(node) {\n        return findNodeForProperty(node.$cstNode, 'name');\n    }\n}\n//# sourceMappingURL=name-provider.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { findAssignment } from '../utils/grammar-utils.js';\nimport { isReference } from '../syntax-tree.js';\nimport { getDocument } from '../utils/ast-utils.js';\nimport { isChildNode, toDocumentSegment } from '../utils/cst-utils.js';\nimport { stream } from '../utils/stream.js';\nimport { UriUtils } from '../utils/uri-utils.js';\nexport class DefaultReferences {\n    constructor(services) {\n        this.nameProvider = services.references.NameProvider;\n        this.index = services.shared.workspace.IndexManager;\n        this.nodeLocator = services.workspace.AstNodeLocator;\n    }\n    findDeclaration(sourceCstNode) {\n        if (sourceCstNode) {\n            const assignment = findAssignment(sourceCstNode);\n            const nodeElem = sourceCstNode.astNode;\n            if (assignment && nodeElem) {\n                const reference = nodeElem[assignment.feature];\n                if (isReference(reference)) {\n                    return reference.ref;\n                }\n                else if (Array.isArray(reference)) {\n                    for (const ref of reference) {\n                        if (isReference(ref) && ref.$refNode\n                            && ref.$refNode.offset <= sourceCstNode.offset\n                            && ref.$refNode.end >= sourceCstNode.end) {\n                            return ref.ref;\n                        }\n                    }\n                }\n            }\n            if (nodeElem) {\n                const nameNode = this.nameProvider.getNameNode(nodeElem);\n                // Only return the targeted node in case the targeted cst node is the name node or part of it\n                if (nameNode && (nameNode === sourceCstNode || isChildNode(sourceCstNode, nameNode))) {\n                    return nodeElem;\n                }\n            }\n        }\n        return undefined;\n    }\n    findDeclarationNode(sourceCstNode) {\n        const astNode = this.findDeclaration(sourceCstNode);\n        if (astNode === null || astNode === void 0 ? void 0 : astNode.$cstNode) {\n            const targetNode = this.nameProvider.getNameNode(astNode);\n            return targetNode !== null && targetNode !== void 0 ? targetNode : astNode.$cstNode;\n        }\n        return undefined;\n    }\n    findReferences(targetNode, options) {\n        const refs = [];\n        if (options.includeDeclaration) {\n            const ref = this.getReferenceToSelf(targetNode);\n            if (ref) {\n                refs.push(ref);\n            }\n        }\n        let indexReferences = this.index.findAllReferences(targetNode, this.nodeLocator.getAstNodePath(targetNode));\n        if (options.documentUri) {\n            indexReferences = indexReferences.filter(ref => UriUtils.equals(ref.sourceUri, options.documentUri));\n        }\n        refs.push(...indexReferences);\n        return stream(refs);\n    }\n    getReferenceToSelf(targetNode) {\n        const nameNode = this.nameProvider.getNameNode(targetNode);\n        if (nameNode) {\n            const doc = getDocument(targetNode);\n            const path = this.nodeLocator.getAstNodePath(targetNode);\n            return {\n                sourceUri: doc.uri,\n                sourcePath: path,\n                targetUri: doc.uri,\n                targetPath: path,\n                segment: toDocumentSegment(nameNode),\n                local: true\n            };\n        }\n        return undefined;\n    }\n}\n//# sourceMappingURL=references.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { Reduction, stream } from './stream.js';\n/**\n * A multimap is a variation of a Map that has potentially multiple values for every key.\n */\nexport class MultiMap {\n    constructor(elements) {\n        this.map = new Map();\n        if (elements) {\n            for (const [key, value] of elements) {\n                this.add(key, value);\n            }\n        }\n    }\n    /**\n     * The total number of values in the multimap.\n     */\n    get size() {\n        return Reduction.sum(stream(this.map.values()).map(a => a.length));\n    }\n    /**\n     * Clear all entries in the multimap.\n     */\n    clear() {\n        this.map.clear();\n    }\n    /**\n     * Operates differently depending on whether a `value` is given:\n     *  * With a value, this method deletes the specific key / value pair from the multimap.\n     *  * Without a value, all values associated with the given key are deleted.\n     *\n     * @returns `true` if a value existed and has been removed, or `false` if the specified\n     *     key / value does not exist.\n     */\n    delete(key, value) {\n        if (value === undefined) {\n            return this.map.delete(key);\n        }\n        else {\n            const values = this.map.get(key);\n            if (values) {\n                const index = values.indexOf(value);\n                if (index >= 0) {\n                    if (values.length === 1) {\n                        this.map.delete(key);\n                    }\n                    else {\n                        values.splice(index, 1);\n                    }\n                    return true;\n                }\n            }\n            return false;\n        }\n    }\n    /**\n     * Returns an array of all values associated with the given key. If no value exists,\n     * an empty array is returned.\n     *\n     * _Note:_ The returned array is assumed not to be modified. Use the `set` method to add a\n     * value and `delete` to remove a value from the multimap.\n     */\n    get(key) {\n        var _a;\n        return (_a = this.map.get(key)) !== null && _a !== void 0 ? _a : [];\n    }\n    /**\n     * Operates differently depending on whether a `value` is given:\n     *  * With a value, this method returns `true` if the specific key / value pair is present in the multimap.\n     *  * Without a value, this method returns `true` if the given key is present in the multimap.\n     */\n    has(key, value) {\n        if (value === undefined) {\n            return this.map.has(key);\n        }\n        else {\n            const values = this.map.get(key);\n            if (values) {\n                return values.indexOf(value) >= 0;\n            }\n            return false;\n        }\n    }\n    /**\n     * Add the given key / value pair to the multimap.\n     */\n    add(key, value) {\n        if (this.map.has(key)) {\n            this.map.get(key).push(value);\n        }\n        else {\n            this.map.set(key, [value]);\n        }\n        return this;\n    }\n    /**\n     * Add the given set of key / value pairs to the multimap.\n     */\n    addAll(key, values) {\n        if (this.map.has(key)) {\n            this.map.get(key).push(...values);\n        }\n        else {\n            this.map.set(key, Array.from(values));\n        }\n        return this;\n    }\n    /**\n     * Invokes the given callback function for every key / value pair in the multimap.\n     */\n    forEach(callbackfn) {\n        this.map.forEach((array, key) => array.forEach(value => callbackfn(value, key, this)));\n    }\n    /**\n     * Returns an iterator of key, value pairs for every entry in the map.\n     */\n    [Symbol.iterator]() {\n        return this.entries().iterator();\n    }\n    /**\n     * Returns a stream of key, value pairs for every entry in the map.\n     */\n    entries() {\n        return stream(this.map.entries())\n            .flatMap(([key, array]) => array.map(value => [key, value]));\n    }\n    /**\n     * Returns a stream of keys in the map.\n     */\n    keys() {\n        return stream(this.map.keys());\n    }\n    /**\n     * Returns a stream of values in the map.\n     */\n    values() {\n        return stream(this.map.values()).flat();\n    }\n    /**\n     * Returns a stream of key, value set pairs for every key in the map.\n     */\n    entriesGroupedByKey() {\n        return stream(this.map.entries());\n    }\n}\nexport class BiMap {\n    get size() {\n        return this.map.size;\n    }\n    constructor(elements) {\n        this.map = new Map();\n        this.inverse = new Map();\n        if (elements) {\n            for (const [key, value] of elements) {\n                this.set(key, value);\n            }\n        }\n    }\n    clear() {\n        this.map.clear();\n        this.inverse.clear();\n    }\n    set(key, value) {\n        this.map.set(key, value);\n        this.inverse.set(value, key);\n        return this;\n    }\n    get(key) {\n        return this.map.get(key);\n    }\n    getKey(value) {\n        return this.inverse.get(value);\n    }\n    delete(key) {\n        const value = this.map.get(key);\n        if (value !== undefined) {\n            this.map.delete(key);\n            this.inverse.delete(value);\n            return true;\n        }\n        return false;\n    }\n}\n//# sourceMappingURL=collections.js.map","/******************************************************************************\n * Copyright 2021-2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { streamAllContents, streamContents } from '../utils/ast-utils.js';\nimport { MultiMap } from '../utils/collections.js';\nimport { interruptAndCheck } from '../utils/promise-utils.js';\n/**\n * The default scope computation creates and collectes descriptions of the AST nodes to be exported into the\n * _global_ scope from the given document. By default those are the document's root AST node and its directly\n * contained child nodes.\n *\n * Besides, it gathers all AST nodes that have a name (according to the `NameProvider` service) and includes them\n * in the local scope of their particular container nodes. As a result, for every cross-reference in the AST,\n * target elements from the same level (siblings) and further up towards the root (parents and siblings of parents)\n * are visible. Elements being nested inside lower levels (children, children of siblings and parents' siblings)\n * are _invisible_ by default, but that can be changed by customizing this service.\n */\nexport class DefaultScopeComputation {\n    constructor(services) {\n        this.nameProvider = services.references.NameProvider;\n        this.descriptions = services.workspace.AstNodeDescriptionProvider;\n    }\n    async computeExports(document, cancelToken = CancellationToken.None) {\n        return this.computeExportsForNode(document.parseResult.value, document, undefined, cancelToken);\n    }\n    /**\n     * Creates {@link AstNodeDescription AstNodeDescriptions} for the given {@link AstNode parentNode} and its children.\n     * The list of children to be considered is determined by the function parameter {@link children}.\n     * By default only the direct children of {@link parentNode} are visited, nested nodes are not exported.\n     *\n     * @param parentNode AST node to be exported, i.e., of which an {@link AstNodeDescription} shall be added to the returned list.\n     * @param document The document containing the AST node to be exported.\n     * @param children A function called with {@link parentNode} as single argument and returning an {@link Iterable} supplying the children to be visited, which must be directly or transitively contained in {@link parentNode}.\n     * @param cancelToken Indicates when to cancel the current operation.\n     * @throws `OperationCanceled` if a user action occurs during execution.\n     * @returns A list of {@link AstNodeDescription AstNodeDescriptions} to be published to index.\n     */\n    async computeExportsForNode(parentNode, document, children = streamContents, cancelToken = CancellationToken.None) {\n        const exports = [];\n        this.exportNode(parentNode, exports, document);\n        for (const node of children(parentNode)) {\n            await interruptAndCheck(cancelToken);\n            this.exportNode(node, exports, document);\n        }\n        return exports;\n    }\n    /**\n     * Add a single node to the list of exports if it has a name. Override this method to change how\n     * symbols are exported, e.g. by modifying their exported name.\n     */\n    exportNode(node, exports, document) {\n        const name = this.nameProvider.getName(node);\n        if (name) {\n            exports.push(this.descriptions.createDescription(node, name, document));\n        }\n    }\n    async computeLocalScopes(document, cancelToken = CancellationToken.None) {\n        const rootNode = document.parseResult.value;\n        const scopes = new MultiMap();\n        // Here we navigate the full AST - local scopes shall be available in the whole document\n        for (const node of streamAllContents(rootNode)) {\n            await interruptAndCheck(cancelToken);\n            this.processNode(node, document, scopes);\n        }\n        return scopes;\n    }\n    /**\n     * Process a single node during scopes computation. The default implementation makes the node visible\n     * in the subtree of its container (if the node has a name). Override this method to change this,\n     * e.g. by increasing the visibility to a higher level in the AST.\n     */\n    processNode(node, document, scopes) {\n        const container = node.$container;\n        if (container) {\n            const name = this.nameProvider.getName(node);\n            if (name) {\n                scopes.add(container, this.descriptions.createDescription(node, name, document));\n            }\n        }\n    }\n}\n//# sourceMappingURL=scope-computation.js.map","/******************************************************************************\n * Copyright 2023 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { EMPTY_STREAM, stream } from '../utils/stream.js';\n/**\n * The default scope implementation is based on a `Stream`. It has an optional _outer scope_ describing\n * the next level of elements, which are queried when a target element is not found in the stream provided\n * to this scope.\n */\nexport class StreamScope {\n    constructor(elements, outerScope, options) {\n        var _a;\n        this.elements = elements;\n        this.outerScope = outerScope;\n        this.caseInsensitive = (_a = options === null || options === void 0 ? void 0 : options.caseInsensitive) !== null && _a !== void 0 ? _a : false;\n    }\n    getAllElements() {\n        if (this.outerScope) {\n            return this.elements.concat(this.outerScope.getAllElements());\n        }\n        else {\n            return this.elements;\n        }\n    }\n    getElement(name) {\n        const local = this.caseInsensitive\n            ? this.elements.find(e => e.name.toLowerCase() === name.toLowerCase())\n            : this.elements.find(e => e.name === name);\n        if (local) {\n            return local;\n        }\n        if (this.outerScope) {\n            return this.outerScope.getElement(name);\n        }\n        return undefined;\n    }\n}\nexport class MapScope {\n    constructor(elements, outerScope, options) {\n        var _a;\n        this.elements = new Map();\n        this.caseInsensitive = (_a = options === null || options === void 0 ? void 0 : options.caseInsensitive) !== null && _a !== void 0 ? _a : false;\n        for (const element of elements) {\n            const name = this.caseInsensitive\n                ? element.name.toLowerCase()\n                : element.name;\n            this.elements.set(name, element);\n        }\n        this.outerScope = outerScope;\n    }\n    getElement(name) {\n        const localName = this.caseInsensitive ? name.toLowerCase() : name;\n        const local = this.elements.get(localName);\n        if (local) {\n            return local;\n        }\n        if (this.outerScope) {\n            return this.outerScope.getElement(name);\n        }\n        return undefined;\n    }\n    getAllElements() {\n        let elementStream = stream(this.elements.values());\n        if (this.outerScope) {\n            elementStream = elementStream.concat(this.outerScope.getAllElements());\n        }\n        return elementStream;\n    }\n}\nexport const EMPTY_SCOPE = {\n    getElement() {\n        return undefined;\n    },\n    getAllElements() {\n        return EMPTY_STREAM;\n    }\n};\n//# sourceMappingURL=scope.js.map","/******************************************************************************\n * Copyright 2023 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nexport class DisposableCache {\n    constructor() {\n        this.toDispose = [];\n        this.isDisposed = false;\n    }\n    onDispose(disposable) {\n        this.toDispose.push(disposable);\n    }\n    dispose() {\n        this.throwIfDisposed();\n        this.clear();\n        this.isDisposed = true;\n        this.toDispose.forEach(disposable => disposable.dispose());\n    }\n    throwIfDisposed() {\n        if (this.isDisposed) {\n            throw new Error('This cache has already been disposed');\n        }\n    }\n}\nexport class SimpleCache extends DisposableCache {\n    constructor() {\n        super(...arguments);\n        this.cache = new Map();\n    }\n    has(key) {\n        this.throwIfDisposed();\n        return this.cache.has(key);\n    }\n    set(key, value) {\n        this.throwIfDisposed();\n        this.cache.set(key, value);\n    }\n    get(key, provider) {\n        this.throwIfDisposed();\n        if (this.cache.has(key)) {\n            return this.cache.get(key);\n        }\n        else if (provider) {\n            const value = provider();\n            this.cache.set(key, value);\n            return value;\n        }\n        else {\n            return undefined;\n        }\n    }\n    delete(key) {\n        this.throwIfDisposed();\n        return this.cache.delete(key);\n    }\n    clear() {\n        this.throwIfDisposed();\n        this.cache.clear();\n    }\n}\nexport class ContextCache extends DisposableCache {\n    constructor(converter) {\n        super();\n        this.cache = new Map();\n        this.converter = converter !== null && converter !== void 0 ? converter : (value => value);\n    }\n    has(contextKey, key) {\n        this.throwIfDisposed();\n        return this.cacheForContext(contextKey).has(key);\n    }\n    set(contextKey, key, value) {\n        this.throwIfDisposed();\n        this.cacheForContext(contextKey).set(key, value);\n    }\n    get(contextKey, key, provider) {\n        this.throwIfDisposed();\n        const contextCache = this.cacheForContext(contextKey);\n        if (contextCache.has(key)) {\n            return contextCache.get(key);\n        }\n        else if (provider) {\n            const value = provider();\n            contextCache.set(key, value);\n            return value;\n        }\n        else {\n            return undefined;\n        }\n    }\n    delete(contextKey, key) {\n        this.throwIfDisposed();\n        return this.cacheForContext(contextKey).delete(key);\n    }\n    clear(contextKey) {\n        this.throwIfDisposed();\n        if (contextKey) {\n            const mapKey = this.converter(contextKey);\n            this.cache.delete(mapKey);\n        }\n        else {\n            this.cache.clear();\n        }\n    }\n    cacheForContext(contextKey) {\n        const mapKey = this.converter(contextKey);\n        let documentCache = this.cache.get(mapKey);\n        if (!documentCache) {\n            documentCache = new Map();\n            this.cache.set(mapKey, documentCache);\n        }\n        return documentCache;\n    }\n}\n/**\n * Every key/value pair in this cache is scoped to a document.\n * If this document is changed or deleted, all associated key/value pairs are deleted.\n */\nexport class DocumentCache extends ContextCache {\n    constructor(sharedServices) {\n        super(uri => uri.toString());\n        this.onDispose(sharedServices.workspace.DocumentBuilder.onUpdate((changed, deleted) => {\n            const allUris = changed.concat(deleted);\n            for (const uri of allUris) {\n                this.clear(uri);\n            }\n        }));\n    }\n}\n/**\n * Every key/value pair in this cache is scoped to the whole workspace.\n * If any document in the workspace changes, the whole cache is evicted.\n */\nexport class WorkspaceCache extends SimpleCache {\n    constructor(sharedServices) {\n        super();\n        this.onDispose(sharedServices.workspace.DocumentBuilder.onUpdate(() => {\n            this.clear();\n        }));\n    }\n}\n//# sourceMappingURL=caching.js.map","/******************************************************************************\n * Copyright 2021-2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { MapScope, StreamScope } from './scope.js';\nimport { getDocument } from '../utils/ast-utils.js';\nimport { stream } from '../utils/stream.js';\nimport { WorkspaceCache } from '../utils/caching.js';\nexport class DefaultScopeProvider {\n    constructor(services) {\n        this.reflection = services.shared.AstReflection;\n        this.nameProvider = services.references.NameProvider;\n        this.descriptions = services.workspace.AstNodeDescriptionProvider;\n        this.indexManager = services.shared.workspace.IndexManager;\n        this.globalScopeCache = new WorkspaceCache(services.shared);\n    }\n    getScope(context) {\n        const scopes = [];\n        const referenceType = this.reflection.getReferenceType(context);\n        const precomputed = getDocument(context.container).precomputedScopes;\n        if (precomputed) {\n            let currentNode = context.container;\n            do {\n                const allDescriptions = precomputed.get(currentNode);\n                if (allDescriptions.length > 0) {\n                    scopes.push(stream(allDescriptions).filter(desc => this.reflection.isSubtype(desc.type, referenceType)));\n                }\n                currentNode = currentNode.$container;\n            } while (currentNode);\n        }\n        let result = this.getGlobalScope(referenceType, context);\n        for (let i = scopes.length - 1; i >= 0; i--) {\n            result = this.createScope(scopes[i], result);\n        }\n        return result;\n    }\n    /**\n     * Create a scope for the given collection of AST node descriptions.\n     */\n    createScope(elements, outerScope, options) {\n        return new StreamScope(stream(elements), outerScope, options);\n    }\n    /**\n     * Create a scope for the given collection of AST nodes, which need to be transformed into respective\n     * descriptions first. This is done using the `NameProvider` and `AstNodeDescriptionProvider` services.\n     */\n    createScopeForNodes(elements, outerScope, options) {\n        const s = stream(elements).map(e => {\n            const name = this.nameProvider.getName(e);\n            if (name) {\n                return this.descriptions.createDescription(e, name);\n            }\n            return undefined;\n        }).nonNullable();\n        return new StreamScope(s, outerScope, options);\n    }\n    /**\n     * Create a global scope filtered for the given reference type.\n     */\n    getGlobalScope(referenceType, _context) {\n        return this.globalScopeCache.get(referenceType, () => new MapScope(this.indexManager.allElements(referenceType)));\n    }\n}\n//# sourceMappingURL=scope-provider.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { URI } from 'vscode-uri';\nimport { isAstNode, isReference } from '../syntax-tree.js';\nimport { getDocument } from '../utils/ast-utils.js';\nimport { findNodesForProperty } from '../utils/grammar-utils.js';\nexport function isAstNodeWithComment(node) {\n    return typeof node.$comment === 'string';\n}\nfunction isIntermediateReference(obj) {\n    return typeof obj === 'object' && !!obj && ('$ref' in obj || '$error' in obj);\n}\nexport class DefaultJsonSerializer {\n    constructor(services) {\n        /** The set of AstNode properties to be ignored by the serializer. */\n        this.ignoreProperties = new Set(['$container', '$containerProperty', '$containerIndex', '$document', '$cstNode']);\n        this.langiumDocuments = services.shared.workspace.LangiumDocuments;\n        this.astNodeLocator = services.workspace.AstNodeLocator;\n        this.nameProvider = services.references.NameProvider;\n        this.commentProvider = services.documentation.CommentProvider;\n    }\n    serialize(node, options = {}) {\n        const specificReplacer = options === null || options === void 0 ? void 0 : options.replacer;\n        const defaultReplacer = (key, value) => this.replacer(key, value, options);\n        const replacer = specificReplacer ? (key, value) => specificReplacer(key, value, defaultReplacer) : defaultReplacer;\n        try {\n            this.currentDocument = getDocument(node);\n            return JSON.stringify(node, replacer, options === null || options === void 0 ? void 0 : options.space);\n        }\n        finally {\n            this.currentDocument = undefined;\n        }\n    }\n    deserialize(content, options = {}) {\n        const root = JSON.parse(content);\n        this.linkNode(root, root, options);\n        return root;\n    }\n    replacer(key, value, { refText, sourceText, textRegions, comments, uriConverter }) {\n        var _a, _b, _c, _d;\n        if (this.ignoreProperties.has(key)) {\n            return undefined;\n        }\n        else if (isReference(value)) {\n            const refValue = value.ref;\n            const $refText = refText ? value.$refText : undefined;\n            if (refValue) {\n                const targetDocument = getDocument(refValue);\n                let targetUri = '';\n                if (this.currentDocument && this.currentDocument !== targetDocument) {\n                    if (uriConverter) {\n                        targetUri = uriConverter(targetDocument.uri, value);\n                    }\n                    else {\n                        targetUri = targetDocument.uri.toString();\n                    }\n                }\n                const targetPath = this.astNodeLocator.getAstNodePath(refValue);\n                return {\n                    $ref: `${targetUri}#${targetPath}`,\n                    $refText\n                };\n            }\n            else {\n                return {\n                    $error: (_b = (_a = value.error) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : 'Could not resolve reference',\n                    $refText\n                };\n            }\n        }\n        else if (isAstNode(value)) {\n            let astNode = undefined;\n            if (textRegions) {\n                astNode = this.addAstNodeRegionWithAssignmentsTo(Object.assign({}, value));\n                if ((!key || value.$document) && (astNode === null || astNode === void 0 ? void 0 : astNode.$textRegion)) {\n                    // The document URI is added to the root node of the resulting JSON tree\n                    astNode.$textRegion.documentURI = (_c = this.currentDocument) === null || _c === void 0 ? void 0 : _c.uri.toString();\n                }\n            }\n            if (sourceText && !key) {\n                astNode !== null && astNode !== void 0 ? astNode : (astNode = Object.assign({}, value));\n                astNode.$sourceText = (_d = value.$cstNode) === null || _d === void 0 ? void 0 : _d.text;\n            }\n            if (comments) {\n                astNode !== null && astNode !== void 0 ? astNode : (astNode = Object.assign({}, value));\n                const comment = this.commentProvider.getComment(value);\n                if (comment) {\n                    astNode.$comment = comment.replace(/\\r/g, '');\n                }\n            }\n            return astNode !== null && astNode !== void 0 ? astNode : value;\n        }\n        else {\n            return value;\n        }\n    }\n    addAstNodeRegionWithAssignmentsTo(node) {\n        const createDocumentSegment = cstNode => ({\n            offset: cstNode.offset,\n            end: cstNode.end,\n            length: cstNode.length,\n            range: cstNode.range,\n        });\n        if (node.$cstNode) {\n            const textRegion = node.$textRegion = createDocumentSegment(node.$cstNode);\n            const assignments = textRegion.assignments = {};\n            Object.keys(node).filter(key => !key.startsWith('$')).forEach(key => {\n                const propertyAssignments = findNodesForProperty(node.$cstNode, key).map(createDocumentSegment);\n                if (propertyAssignments.length !== 0) {\n                    assignments[key] = propertyAssignments;\n                }\n            });\n            return node;\n        }\n        return undefined;\n    }\n    linkNode(node, root, options, container, containerProperty, containerIndex) {\n        for (const [propertyName, item] of Object.entries(node)) {\n            if (Array.isArray(item)) {\n                for (let index = 0; index < item.length; index++) {\n                    const element = item[index];\n                    if (isIntermediateReference(element)) {\n                        item[index] = this.reviveReference(node, propertyName, root, element, options);\n                    }\n                    else if (isAstNode(element)) {\n                        this.linkNode(element, root, options, node, propertyName, index);\n                    }\n                }\n            }\n            else if (isIntermediateReference(item)) {\n                node[propertyName] = this.reviveReference(node, propertyName, root, item, options);\n            }\n            else if (isAstNode(item)) {\n                this.linkNode(item, root, options, node, propertyName);\n            }\n        }\n        const mutable = node;\n        mutable.$container = container;\n        mutable.$containerProperty = containerProperty;\n        mutable.$containerIndex = containerIndex;\n    }\n    reviveReference(container, property, root, reference, options) {\n        let refText = reference.$refText;\n        let error = reference.$error;\n        if (reference.$ref) {\n            const ref = this.getRefNode(root, reference.$ref, options.uriConverter);\n            if (isAstNode(ref)) {\n                if (!refText) {\n                    refText = this.nameProvider.getName(ref);\n                }\n                return {\n                    $refText: refText !== null && refText !== void 0 ? refText : '',\n                    ref\n                };\n            }\n            else {\n                error = ref;\n            }\n        }\n        if (error) {\n            const ref = {\n                $refText: refText !== null && refText !== void 0 ? refText : ''\n            };\n            ref.error = {\n                container,\n                property,\n                message: error,\n                reference: ref\n            };\n            return ref;\n        }\n        else {\n            return undefined;\n        }\n    }\n    getRefNode(root, uri, uriConverter) {\n        try {\n            const fragmentIndex = uri.indexOf('#');\n            if (fragmentIndex === 0) {\n                const node = this.astNodeLocator.getAstNode(root, uri.substring(1));\n                if (!node) {\n                    return 'Could not resolve path: ' + uri;\n                }\n                return node;\n            }\n            if (fragmentIndex < 0) {\n                const documentUri = uriConverter ? uriConverter(uri) : URI.parse(uri);\n                const document = this.langiumDocuments.getDocument(documentUri);\n                if (!document) {\n                    return 'Could not find document for URI: ' + uri;\n                }\n                return document.parseResult.value;\n            }\n            const documentUri = uriConverter ? uriConverter(uri.substring(0, fragmentIndex)) : URI.parse(uri.substring(0, fragmentIndex));\n            const document = this.langiumDocuments.getDocument(documentUri);\n            if (!document) {\n                return 'Could not find document for URI: ' + uri;\n            }\n            if (fragmentIndex === uri.length - 1) {\n                return document.parseResult.value;\n            }\n            const node = this.astNodeLocator.getAstNode(document.parseResult.value, uri.substring(fragmentIndex + 1));\n            if (!node) {\n                return 'Could not resolve URI: ' + uri;\n            }\n            return node;\n        }\n        catch (err) {\n            return String(err);\n        }\n    }\n}\n//# sourceMappingURL=json-serializer.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { UriUtils } from './utils/uri-utils.js';\n/**\n * Generic registry for Langium services, but capable of being used with extending service sets as well (such as the lsp-complete LangiumCoreServices set)\n */\nexport class DefaultServiceRegistry {\n    register(language) {\n        if (!this.singleton && !this.map) {\n            // This is the first language to be registered; store it as singleton.\n            this.singleton = language;\n            return;\n        }\n        if (!this.map) {\n            this.map = {};\n            if (this.singleton) {\n                // Move the previous singleton instance to the new map.\n                for (const ext of this.singleton.LanguageMetaData.fileExtensions) {\n                    this.map[ext] = this.singleton;\n                }\n                this.singleton = undefined;\n            }\n        }\n        // Store the language services in the map.\n        for (const ext of language.LanguageMetaData.fileExtensions) {\n            if (this.map[ext] !== undefined && this.map[ext] !== language) {\n                console.warn(`The file extension ${ext} is used by multiple languages. It is now assigned to '${language.LanguageMetaData.languageId}'.`);\n            }\n            this.map[ext] = language;\n        }\n    }\n    getServices(uri) {\n        if (this.singleton !== undefined) {\n            return this.singleton;\n        }\n        if (this.map === undefined) {\n            throw new Error('The service registry is empty. Use `register` to register the services of a language.');\n        }\n        const ext = UriUtils.extname(uri);\n        const services = this.map[ext];\n        if (!services) {\n            throw new Error(`The service registry contains no services for the extension '${ext}'.`);\n        }\n        return services;\n    }\n    get all() {\n        if (this.singleton !== undefined) {\n            return [this.singleton];\n        }\n        if (this.map !== undefined) {\n            return Object.values(this.map);\n        }\n        return [];\n    }\n}\n//# sourceMappingURL=service-registry.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { isLinkingError } from '../syntax-tree.js';\nimport { getDocument, streamAst, streamReferences } from '../utils/ast-utils.js';\nimport { toDocumentSegment } from '../utils/cst-utils.js';\nimport { interruptAndCheck } from '../utils/promise-utils.js';\nimport { UriUtils } from '../utils/uri-utils.js';\nexport class DefaultAstNodeDescriptionProvider {\n    constructor(services) {\n        this.astNodeLocator = services.workspace.AstNodeLocator;\n        this.nameProvider = services.references.NameProvider;\n    }\n    createDescription(node, name, document = getDocument(node)) {\n        name !== null && name !== void 0 ? name : (name = this.nameProvider.getName(node));\n        const path = this.astNodeLocator.getAstNodePath(node);\n        if (!name) {\n            throw new Error(`Node at path ${path} has no name.`);\n        }\n        let nameNodeSegment;\n        const nameSegmentGetter = () => { var _a; return nameNodeSegment !== null && nameNodeSegment !== void 0 ? nameNodeSegment : (nameNodeSegment = toDocumentSegment((_a = this.nameProvider.getNameNode(node)) !== null && _a !== void 0 ? _a : node.$cstNode)); };\n        return {\n            node,\n            name,\n            get nameSegment() {\n                return nameSegmentGetter();\n            },\n            selectionSegment: toDocumentSegment(node.$cstNode),\n            type: node.$type,\n            documentUri: document.uri,\n            path\n        };\n    }\n}\nexport class DefaultReferenceDescriptionProvider {\n    constructor(services) {\n        this.nodeLocator = services.workspace.AstNodeLocator;\n    }\n    async createDescriptions(document, cancelToken = CancellationToken.None) {\n        const descr = [];\n        const rootNode = document.parseResult.value;\n        for (const astNode of streamAst(rootNode)) {\n            await interruptAndCheck(cancelToken);\n            streamReferences(astNode).filter(refInfo => !isLinkingError(refInfo)).forEach(refInfo => {\n                // TODO: Consider logging a warning or throw an exception when DocumentState is < than Linked\n                const description = this.createDescription(refInfo);\n                if (description) {\n                    descr.push(description);\n                }\n            });\n        }\n        return descr;\n    }\n    createDescription(refInfo) {\n        const targetNodeDescr = refInfo.reference.$nodeDescription;\n        const refCstNode = refInfo.reference.$refNode;\n        if (!targetNodeDescr || !refCstNode) {\n            return undefined;\n        }\n        const docUri = getDocument(refInfo.container).uri;\n        return {\n            sourceUri: docUri,\n            sourcePath: this.nodeLocator.getAstNodePath(refInfo.container),\n            targetUri: targetNodeDescr.documentUri,\n            targetPath: targetNodeDescr.path,\n            segment: toDocumentSegment(refCstNode),\n            local: UriUtils.equals(targetNodeDescr.documentUri, docUri)\n        };\n    }\n}\n//# sourceMappingURL=ast-descriptions.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nexport class DefaultAstNodeLocator {\n    constructor() {\n        this.segmentSeparator = '/';\n        this.indexSeparator = '@';\n    }\n    getAstNodePath(node) {\n        if (node.$container) {\n            const containerPath = this.getAstNodePath(node.$container);\n            const newSegment = this.getPathSegment(node);\n            const nodePath = containerPath + this.segmentSeparator + newSegment;\n            return nodePath;\n        }\n        return '';\n    }\n    getPathSegment({ $containerProperty, $containerIndex }) {\n        if (!$containerProperty) {\n            throw new Error(\"Missing '$containerProperty' in AST node.\");\n        }\n        if ($containerIndex !== undefined) {\n            return $containerProperty + this.indexSeparator + $containerIndex;\n        }\n        return $containerProperty;\n    }\n    getAstNode(node, path) {\n        const segments = path.split(this.segmentSeparator);\n        return segments.reduce((previousValue, currentValue) => {\n            if (!previousValue || currentValue.length === 0) {\n                return previousValue;\n            }\n            const propertyIndex = currentValue.indexOf(this.indexSeparator);\n            if (propertyIndex > 0) {\n                const property = currentValue.substring(0, propertyIndex);\n                const arrayIndex = parseInt(currentValue.substring(propertyIndex + 1));\n                const array = previousValue[property];\n                return array === null || array === void 0 ? void 0 : array[arrayIndex];\n            }\n            return previousValue[currentValue];\n        }, node);\n    }\n}\n//# sourceMappingURL=ast-node-locator.js.map","/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { Deferred } from '../utils/promise-utils.js';\n/**\n * Base configuration provider for building up other configuration providers\n */\nexport class DefaultConfigurationProvider {\n    constructor(services) {\n        this._ready = new Deferred();\n        this.settings = {};\n        this.workspaceConfig = false;\n        this.serviceRegistry = services.ServiceRegistry;\n    }\n    get ready() {\n        return this._ready.promise;\n    }\n    initialize(params) {\n        var _a, _b;\n        this.workspaceConfig = (_b = (_a = params.capabilities.workspace) === null || _a === void 0 ? void 0 : _a.configuration) !== null && _b !== void 0 ? _b : false;\n    }\n    async initialized(params) {\n        if (this.workspaceConfig) {\n            if (params.register) {\n                // params.register(...) is a function to be provided by the calling language server for the sake of\n                //  decoupling this implementation from the concrete LSP implementations, specifically the LSP Connection\n                const languages = this.serviceRegistry.all;\n                params.register({\n                    // Listen to configuration changes for all languages\n                    section: languages.map(lang => this.toSectionName(lang.LanguageMetaData.languageId))\n                });\n            }\n            if (params.fetchConfiguration) {\n                // params.fetchConfiguration(...) is a function to be provided by the calling language server for the sake of\n                //  decoupling this implementation from the concrete LSP implementations, specifically the LSP Connection\n                const configToUpdate = this.serviceRegistry.all.map(lang => ({\n                    // Fetch the configuration changes for all languages\n                    section: this.toSectionName(lang.LanguageMetaData.languageId)\n                }));\n                // get workspace configurations (default scope URI)\n                const configs = await params.fetchConfiguration(configToUpdate);\n                configToUpdate.forEach((conf, idx) => {\n                    this.updateSectionConfiguration(conf.section, configs[idx]);\n                });\n            }\n        }\n        this._ready.resolve();\n    }\n    /**\n     *  Updates the cached configurations using the `change` notification parameters.\n     *\n     * @param change The parameters of a change configuration notification.\n     * `settings` property of the change object could be expressed as `Record<string, Record<string, any>>`\n     */\n    updateConfiguration(change) {\n        if (!change.settings) {\n            return;\n        }\n        Object.keys(change.settings).forEach(section => {\n            this.updateSectionConfiguration(section, change.settings[section]);\n        });\n    }\n    updateSectionConfiguration(section, configuration) {\n        this.settings[section] = configuration;\n    }\n    /**\n    * Returns a configuration value stored for the given language.\n    *\n    * @param language The language id\n    * @param configuration Configuration name\n    */\n    async getConfiguration(language, configuration) {\n        await this.ready;\n        const sectionName = this.toSectionName(language);\n        if (this.settings[sectionName]) {\n            return this.settings[sectionName][configuration];\n        }\n    }\n    toSectionName(languageId) {\n        return `${languageId}`;\n    }\n}\n//# sourceMappingURL=configuration.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { Disposable } from '../utils/disposable.js';\nimport { MultiMap } from '../utils/collections.js';\nimport { OperationCancelled, interruptAndCheck } from '../utils/promise-utils.js';\nimport { stream } from '../utils/stream.js';\nimport { ValidationCategory } from '../validation/validation-registry.js';\nimport { DocumentState } from './documents.js';\nexport class DefaultDocumentBuilder {\n    constructor(services) {\n        this.updateBuildOptions = {\n            // Default: run only the built-in validation checks and those in the _fast_ category (includes those without category)\n            validation: {\n                categories: ['built-in', 'fast']\n            }\n        };\n        this.updateListeners = [];\n        this.buildPhaseListeners = new MultiMap();\n        this.buildState = new Map();\n        this.documentBuildWaiters = new Map();\n        this.currentState = DocumentState.Changed;\n        this.langiumDocuments = services.workspace.LangiumDocuments;\n        this.langiumDocumentFactory = services.workspace.LangiumDocumentFactory;\n        this.indexManager = services.workspace.IndexManager;\n        this.serviceRegistry = services.ServiceRegistry;\n    }\n    async build(documents, options = {}, cancelToken = CancellationToken.None) {\n        var _a, _b;\n        for (const document of documents) {\n            const key = document.uri.toString();\n            if (document.state === DocumentState.Validated) {\n                if (typeof options.validation === 'boolean' && options.validation) {\n                    // Force re-running all validation checks\n                    document.state = DocumentState.IndexedReferences;\n                    document.diagnostics = undefined;\n                    this.buildState.delete(key);\n                }\n                else if (typeof options.validation === 'object') {\n                    const buildState = this.buildState.get(key);\n                    const previousCategories = (_a = buildState === null || buildState === void 0 ? void 0 : buildState.result) === null || _a === void 0 ? void 0 : _a.validationChecks;\n                    if (previousCategories) {\n                        // Validation with explicit options was requested for a document that has already been partly validated.\n                        // In this case, we need to merge the previous validation categories with the new ones.\n                        const newCategories = (_b = options.validation.categories) !== null && _b !== void 0 ? _b : ValidationCategory.all;\n                        const categories = newCategories.filter(c => !previousCategories.includes(c));\n                        if (categories.length > 0) {\n                            this.buildState.set(key, {\n                                completed: false,\n                                options: {\n                                    validation: Object.assign(Object.assign({}, options.validation), { categories })\n                                },\n                                result: buildState.result\n                            });\n                            document.state = DocumentState.IndexedReferences;\n                        }\n                    }\n                }\n            }\n            else {\n                // Default: forget any previous build options\n                this.buildState.delete(key);\n            }\n        }\n        this.currentState = DocumentState.Changed;\n        await this.emitUpdate(documents.map(e => e.uri), []);\n        await this.buildDocuments(documents, options, cancelToken);\n    }\n    async update(changed, deleted, cancelToken = CancellationToken.None) {\n        this.currentState = DocumentState.Changed;\n        // Remove all metadata of documents that are reported as deleted\n        for (const deletedUri of deleted) {\n            this.langiumDocuments.deleteDocument(deletedUri);\n            this.buildState.delete(deletedUri.toString());\n            this.indexManager.remove(deletedUri);\n        }\n        // Set the state of all changed documents to `Changed` so they are completely rebuilt\n        for (const changedUri of changed) {\n            const invalidated = this.langiumDocuments.invalidateDocument(changedUri);\n            if (!invalidated) {\n                // We create an unparsed, invalid document.\n                // This will be parsed as soon as we reach the first document builder phase.\n                // This allows to cancel the parsing process later in case we need it.\n                const newDocument = this.langiumDocumentFactory.fromModel({ $type: 'INVALID' }, changedUri);\n                newDocument.state = DocumentState.Changed;\n                this.langiumDocuments.addDocument(newDocument);\n            }\n            this.buildState.delete(changedUri.toString());\n        }\n        // Set the state of all documents that should be relinked to `ComputedScopes` (if not already lower)\n        const allChangedUris = stream(changed).concat(deleted).map(uri => uri.toString()).toSet();\n        this.langiumDocuments.all\n            .filter(doc => !allChangedUris.has(doc.uri.toString()) && this.shouldRelink(doc, allChangedUris))\n            .forEach(doc => {\n            const linker = this.serviceRegistry.getServices(doc.uri).references.Linker;\n            linker.unlink(doc);\n            doc.state = Math.min(doc.state, DocumentState.ComputedScopes);\n            doc.diagnostics = undefined;\n        });\n        // Notify listeners of the update\n        await this.emitUpdate(changed, deleted);\n        // Only allow interrupting the execution after all state changes are done\n        await interruptAndCheck(cancelToken);\n        // Collect all documents that we should rebuild\n        const rebuildDocuments = this.langiumDocuments.all\n            .filter(doc => {\n            var _a;\n            // This includes those that were reported as changed and those that we selected for relinking\n            return doc.state < DocumentState.Linked\n                // This includes those for which a previous build has been cancelled\n                || !((_a = this.buildState.get(doc.uri.toString())) === null || _a === void 0 ? void 0 : _a.completed);\n        })\n            .toArray();\n        await this.buildDocuments(rebuildDocuments, this.updateBuildOptions, cancelToken);\n    }\n    async emitUpdate(changed, deleted) {\n        await Promise.all(this.updateListeners.map(listener => listener(changed, deleted)));\n    }\n    /**\n     * Check whether the given document should be relinked after changes were found in the given URIs.\n     */\n    shouldRelink(document, changedUris) {\n        // Relink documents with linking errors -- maybe those references can be resolved now\n        if (document.references.some(ref => ref.error !== undefined)) {\n            return true;\n        }\n        // Check whether the document is affected by any of the changed URIs\n        return this.indexManager.isAffected(document, changedUris);\n    }\n    onUpdate(callback) {\n        this.updateListeners.push(callback);\n        return Disposable.create(() => {\n            const index = this.updateListeners.indexOf(callback);\n            if (index >= 0) {\n                this.updateListeners.splice(index, 1);\n            }\n        });\n    }\n    /**\n     * Build the given documents by stepping through all build phases. If a document's state indicates\n     * that a certain build phase is already done, the phase is skipped for that document.\n     */\n    async buildDocuments(documents, options, cancelToken) {\n        this.prepareBuild(documents, options);\n        // 0. Parse content\n        await this.runCancelable(documents, DocumentState.Parsed, cancelToken, doc => this.langiumDocumentFactory.update(doc, cancelToken));\n        // 1. Index content\n        await this.runCancelable(documents, DocumentState.IndexedContent, cancelToken, doc => this.indexManager.updateContent(doc, cancelToken));\n        // 2. Compute scopes\n        await this.runCancelable(documents, DocumentState.ComputedScopes, cancelToken, async (doc) => {\n            const scopeComputation = this.serviceRegistry.getServices(doc.uri).references.ScopeComputation;\n            doc.precomputedScopes = await scopeComputation.computeLocalScopes(doc, cancelToken);\n        });\n        // 3. Linking\n        await this.runCancelable(documents, DocumentState.Linked, cancelToken, doc => {\n            const linker = this.serviceRegistry.getServices(doc.uri).references.Linker;\n            return linker.link(doc, cancelToken);\n        });\n        // 4. Index references\n        await this.runCancelable(documents, DocumentState.IndexedReferences, cancelToken, doc => this.indexManager.updateReferences(doc, cancelToken));\n        // 5. Validation\n        const toBeValidated = documents.filter(doc => this.shouldValidate(doc));\n        await this.runCancelable(toBeValidated, DocumentState.Validated, cancelToken, doc => this.validate(doc, cancelToken));\n        // If we've made it to this point without being cancelled, we can mark the build state as completed.\n        for (const doc of documents) {\n            const state = this.buildState.get(doc.uri.toString());\n            if (state) {\n                state.completed = true;\n            }\n        }\n    }\n    prepareBuild(documents, options) {\n        for (const doc of documents) {\n            const key = doc.uri.toString();\n            const state = this.buildState.get(key);\n            // If the document has no previous build state, we set it. If it has one, but it's already marked\n            // as completed, we overwrite it. If the previous build was not completed, we keep its state\n            // and continue where it was cancelled.\n            if (!state || state.completed) {\n                this.buildState.set(key, {\n                    completed: false,\n                    options,\n                    result: state === null || state === void 0 ? void 0 : state.result\n                });\n            }\n        }\n    }\n    async runCancelable(documents, targetState, cancelToken, callback) {\n        const filtered = documents.filter(e => e.state < targetState);\n        for (const document of filtered) {\n            await interruptAndCheck(cancelToken);\n            await callback(document);\n            document.state = targetState;\n        }\n        await this.notifyBuildPhase(filtered, targetState, cancelToken);\n        this.currentState = targetState;\n    }\n    onBuildPhase(targetState, callback) {\n        this.buildPhaseListeners.add(targetState, callback);\n        return Disposable.create(() => {\n            this.buildPhaseListeners.delete(targetState, callback);\n        });\n    }\n    waitUntil(state, uriOrToken, cancelToken) {\n        let uri = undefined;\n        if (uriOrToken && 'path' in uriOrToken) {\n            uri = uriOrToken;\n        }\n        else {\n            cancelToken = uriOrToken;\n        }\n        cancelToken !== null && cancelToken !== void 0 ? cancelToken : (cancelToken = CancellationToken.None);\n        if (uri) {\n            const document = this.langiumDocuments.getDocument(uri);\n            if (document && document.state > state) {\n                return Promise.resolve(uri);\n            }\n        }\n        if (this.currentState >= state) {\n            return Promise.resolve(undefined);\n        }\n        else if (cancelToken.isCancellationRequested) {\n            return Promise.reject(OperationCancelled);\n        }\n        return new Promise((resolve, reject) => {\n            const buildDisposable = this.onBuildPhase(state, () => {\n                buildDisposable.dispose();\n                cancelDisposable.dispose();\n                if (uri) {\n                    const document = this.langiumDocuments.getDocument(uri);\n                    resolve(document === null || document === void 0 ? void 0 : document.uri);\n                }\n                else {\n                    resolve(undefined);\n                }\n            });\n            const cancelDisposable = cancelToken.onCancellationRequested(() => {\n                buildDisposable.dispose();\n                cancelDisposable.dispose();\n                reject(OperationCancelled);\n            });\n        });\n    }\n    async notifyBuildPhase(documents, state, cancelToken) {\n        if (documents.length === 0) {\n            // Don't notify when no document has been processed\n            return;\n        }\n        const listeners = this.buildPhaseListeners.get(state);\n        for (const listener of listeners) {\n            await interruptAndCheck(cancelToken);\n            await listener(documents, cancelToken);\n        }\n    }\n    /**\n     * Determine whether the given document should be validated during a build. The default\n     * implementation checks the `validation` property of the build options. If it's set to `true`\n     * or a `ValidationOptions` object, the document is included in the validation phase.\n     */\n    shouldValidate(document) {\n        return Boolean(this.getBuildOptions(document).validation);\n    }\n    /**\n     * Run validation checks on the given document and store the resulting diagnostics in the document.\n     * If the document already contains diagnostics, the new ones are added to the list.\n     */\n    async validate(document, cancelToken) {\n        var _a, _b;\n        const validator = this.serviceRegistry.getServices(document.uri).validation.DocumentValidator;\n        const validationSetting = this.getBuildOptions(document).validation;\n        const options = typeof validationSetting === 'object' ? validationSetting : undefined;\n        const diagnostics = await validator.validateDocument(document, options, cancelToken);\n        if (document.diagnostics) {\n            document.diagnostics.push(...diagnostics);\n        }\n        else {\n            document.diagnostics = diagnostics;\n        }\n        // Store information about the executed validation in the build state\n        const state = this.buildState.get(document.uri.toString());\n        if (state) {\n            (_a = state.result) !== null && _a !== void 0 ? _a : (state.result = {});\n            const newCategories = (_b = options === null || options === void 0 ? void 0 : options.categories) !== null && _b !== void 0 ? _b : ValidationCategory.all;\n            if (state.result.validationChecks) {\n                state.result.validationChecks.push(...newCategories);\n            }\n            else {\n                state.result.validationChecks = [...newCategories];\n            }\n        }\n    }\n    getBuildOptions(document) {\n        var _a, _b;\n        return (_b = (_a = this.buildState.get(document.uri.toString())) === null || _a === void 0 ? void 0 : _a.options) !== null && _b !== void 0 ? _b : {};\n    }\n}\n//# sourceMappingURL=document-builder.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { getDocument } from '../utils/ast-utils.js';\nimport { ContextCache } from '../utils/caching.js';\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { stream } from '../utils/stream.js';\nimport { UriUtils } from '../utils/uri-utils.js';\nexport class DefaultIndexManager {\n    constructor(services) {\n        /**\n         * The symbol index stores all `AstNodeDescription` items exported by a document.\n         * The key used in this map is the string representation of the specific document URI.\n         */\n        this.symbolIndex = new Map();\n        /**\n         * This is a cache for the `allElements()` method.\n         * It caches the descriptions from `symbolIndex` grouped by types.\n         */\n        this.symbolByTypeIndex = new ContextCache();\n        /**\n         * This index keeps track of all `ReferenceDescription` items exported by a document.\n         * This is used to compute which elements are affected by a document change\n         * and for finding references to an AST node.\n         */\n        this.referenceIndex = new Map();\n        this.documents = services.workspace.LangiumDocuments;\n        this.serviceRegistry = services.ServiceRegistry;\n        this.astReflection = services.AstReflection;\n    }\n    findAllReferences(targetNode, astNodePath) {\n        const targetDocUri = getDocument(targetNode).uri;\n        const result = [];\n        this.referenceIndex.forEach(docRefs => {\n            docRefs.forEach(refDescr => {\n                if (UriUtils.equals(refDescr.targetUri, targetDocUri) && refDescr.targetPath === astNodePath) {\n                    result.push(refDescr);\n                }\n            });\n        });\n        return stream(result);\n    }\n    allElements(nodeType, uris) {\n        let documentUris = stream(this.symbolIndex.keys());\n        if (uris) {\n            documentUris = documentUris.filter(uri => !uris || uris.has(uri));\n        }\n        return documentUris\n            .map(uri => this.getFileDescriptions(uri, nodeType))\n            .flat();\n    }\n    getFileDescriptions(uri, nodeType) {\n        var _a;\n        if (!nodeType) {\n            return (_a = this.symbolIndex.get(uri)) !== null && _a !== void 0 ? _a : [];\n        }\n        const descriptions = this.symbolByTypeIndex.get(uri, nodeType, () => {\n            var _a;\n            const allFileDescriptions = (_a = this.symbolIndex.get(uri)) !== null && _a !== void 0 ? _a : [];\n            return allFileDescriptions.filter(e => this.astReflection.isSubtype(e.type, nodeType));\n        });\n        return descriptions;\n    }\n    remove(uri) {\n        const uriString = uri.toString();\n        this.symbolIndex.delete(uriString);\n        this.symbolByTypeIndex.clear(uriString);\n        this.referenceIndex.delete(uriString);\n    }\n    async updateContent(document, cancelToken = CancellationToken.None) {\n        const services = this.serviceRegistry.getServices(document.uri);\n        const exports = await services.references.ScopeComputation.computeExports(document, cancelToken);\n        const uri = document.uri.toString();\n        this.symbolIndex.set(uri, exports);\n        this.symbolByTypeIndex.clear(uri);\n    }\n    async updateReferences(document, cancelToken = CancellationToken.None) {\n        const services = this.serviceRegistry.getServices(document.uri);\n        const indexData = await services.workspace.ReferenceDescriptionProvider.createDescriptions(document, cancelToken);\n        this.referenceIndex.set(document.uri.toString(), indexData);\n    }\n    isAffected(document, changedUris) {\n        const references = this.referenceIndex.get(document.uri.toString());\n        if (!references) {\n            return false;\n        }\n        return references.some(ref => !ref.local && changedUris.has(ref.targetUri.toString()));\n    }\n}\n//# sourceMappingURL=index-manager.js.map","/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { Deferred, interruptAndCheck } from '../utils/promise-utils.js';\nimport { URI, UriUtils } from '../utils/uri-utils.js';\nexport class DefaultWorkspaceManager {\n    constructor(services) {\n        this.initialBuildOptions = {};\n        this._ready = new Deferred();\n        this.serviceRegistry = services.ServiceRegistry;\n        this.langiumDocuments = services.workspace.LangiumDocuments;\n        this.documentBuilder = services.workspace.DocumentBuilder;\n        this.fileSystemProvider = services.workspace.FileSystemProvider;\n        this.mutex = services.workspace.WorkspaceLock;\n    }\n    get ready() {\n        return this._ready.promise;\n    }\n    initialize(params) {\n        var _a;\n        this.folders = (_a = params.workspaceFolders) !== null && _a !== void 0 ? _a : undefined;\n    }\n    initialized(_params) {\n        // Initialize the workspace even if there are no workspace folders\n        // We still want to load additional documents (language library or similar) during initialization\n        return this.mutex.write(token => { var _a; return this.initializeWorkspace((_a = this.folders) !== null && _a !== void 0 ? _a : [], token); });\n    }\n    async initializeWorkspace(folders, cancelToken = CancellationToken.None) {\n        const documents = await this.performStartup(folders);\n        // Only after creating all documents do we check whether we need to cancel the initialization\n        // The document builder will later pick up on all unprocessed documents\n        await interruptAndCheck(cancelToken);\n        await this.documentBuilder.build(documents, this.initialBuildOptions, cancelToken);\n    }\n    /**\n     * Performs the uninterruptable startup sequence of the workspace manager.\n     * This methods loads all documents in the workspace and other documents and returns them.\n     */\n    async performStartup(folders) {\n        const fileExtensions = this.serviceRegistry.all.flatMap(e => e.LanguageMetaData.fileExtensions);\n        const documents = [];\n        const collector = (document) => {\n            documents.push(document);\n            if (!this.langiumDocuments.hasDocument(document.uri)) {\n                this.langiumDocuments.addDocument(document);\n            }\n        };\n        // Even though we don't await the initialization of the workspace manager,\n        // we can still assume that all library documents and file documents are loaded by the time we start building documents.\n        // The mutex prevents anything from performing a workspace build until we check the cancellation token\n        await this.loadAdditionalDocuments(folders, collector);\n        await Promise.all(folders.map(wf => [wf, this.getRootFolder(wf)])\n            .map(async (entry) => this.traverseFolder(...entry, fileExtensions, collector)));\n        this._ready.resolve();\n        return documents;\n    }\n    /**\n     * Load all additional documents that shall be visible in the context of the given workspace\n     * folders and add them to the collector. This can be used to include built-in libraries of\n     * your language, which can be either loaded from provided files or constructed in memory.\n     */\n    loadAdditionalDocuments(_folders, _collector) {\n        return Promise.resolve();\n    }\n    /**\n     * Determine the root folder of the source documents in the given workspace folder.\n     * The default implementation returns the URI of the workspace folder, but you can override\n     * this to return a subfolder like `src` instead.\n     */\n    getRootFolder(workspaceFolder) {\n        return URI.parse(workspaceFolder.uri);\n    }\n    /**\n     * Traverse the file system folder identified by the given URI and its subfolders. All\n     * contained files that match the file extensions are added to the collector.\n     */\n    async traverseFolder(workspaceFolder, folderPath, fileExtensions, collector) {\n        const content = await this.fileSystemProvider.readDirectory(folderPath);\n        await Promise.all(content.map(async (entry) => {\n            if (this.includeEntry(workspaceFolder, entry, fileExtensions)) {\n                if (entry.isDirectory) {\n                    await this.traverseFolder(workspaceFolder, entry.uri, fileExtensions, collector);\n                }\n                else if (entry.isFile) {\n                    const document = await this.langiumDocuments.getOrCreateDocument(entry.uri);\n                    collector(document);\n                }\n            }\n        }));\n    }\n    /**\n     * Determine whether the given folder entry shall be included while indexing the workspace.\n     */\n    includeEntry(_workspaceFolder, entry, fileExtensions) {\n        const name = UriUtils.basename(entry.uri);\n        if (name.startsWith('.')) {\n            return false;\n        }\n        if (entry.isDirectory) {\n            return name !== 'node_modules' && name !== 'out';\n        }\n        else if (entry.isFile) {\n            const extname = UriUtils.extname(entry.uri);\n            return fileExtensions.includes(extname);\n        }\n        return false;\n    }\n}\n//# sourceMappingURL=workspace-manager.js.map","/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { Lexer as ChevrotainLexer } from 'chevrotain';\nexport class DefaultLexer {\n    constructor(services) {\n        const tokens = services.parser.TokenBuilder.buildTokens(services.Grammar, {\n            caseInsensitive: services.LanguageMetaData.caseInsensitive\n        });\n        this.tokenTypes = this.toTokenTypeDictionary(tokens);\n        const lexerTokens = isTokenTypeDictionary(tokens) ? Object.values(tokens) : tokens;\n        this.chevrotainLexer = new ChevrotainLexer(lexerTokens, {\n            positionTracking: 'full'\n        });\n    }\n    get definition() {\n        return this.tokenTypes;\n    }\n    tokenize(text) {\n        var _a;\n        const chevrotainResult = this.chevrotainLexer.tokenize(text);\n        return {\n            tokens: chevrotainResult.tokens,\n            errors: chevrotainResult.errors,\n            hidden: (_a = chevrotainResult.groups.hidden) !== null && _a !== void 0 ? _a : []\n        };\n    }\n    toTokenTypeDictionary(buildTokens) {\n        if (isTokenTypeDictionary(buildTokens))\n            return buildTokens;\n        const tokens = isIMultiModeLexerDefinition(buildTokens) ? Object.values(buildTokens.modes).flat() : buildTokens;\n        const res = {};\n        tokens.forEach(token => res[token.name] = token);\n        return res;\n    }\n}\n/**\n * Returns a check whether the given TokenVocabulary is TokenType array\n */\nexport function isTokenTypeArray(tokenVocabulary) {\n    return Array.isArray(tokenVocabulary) && (tokenVocabulary.length === 0 || 'name' in tokenVocabulary[0]);\n}\n/**\n * Returns a check whether the given TokenVocabulary is IMultiModeLexerDefinition\n */\nexport function isIMultiModeLexerDefinition(tokenVocabulary) {\n    return tokenVocabulary && 'modes' in tokenVocabulary && 'defaultMode' in tokenVocabulary;\n}\n/**\n * Returns a check whether the given TokenVocabulary is TokenTypeDictionary\n */\nexport function isTokenTypeDictionary(tokenVocabulary) {\n    return !isTokenTypeArray(tokenVocabulary) && !isIMultiModeLexerDefinition(tokenVocabulary);\n}\n//# sourceMappingURL=lexer.js.map","/******************************************************************************\n * Copyright 2023 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { Position, Range } from 'vscode-languageserver-types';\nimport { NEWLINE_REGEXP, escapeRegExp } from '../utils/regexp-utils.js';\nimport { URI } from '../utils/uri-utils.js';\nexport function parseJSDoc(node, start, options) {\n    let opts;\n    let position;\n    if (typeof node === 'string') {\n        position = start;\n        opts = options;\n    }\n    else {\n        position = node.range.start;\n        opts = start;\n    }\n    if (!position) {\n        position = Position.create(0, 0);\n    }\n    const lines = getLines(node);\n    const normalizedOptions = normalizeOptions(opts);\n    const tokens = tokenize({\n        lines,\n        position,\n        options: normalizedOptions\n    });\n    return parseJSDocComment({\n        index: 0,\n        tokens,\n        position\n    });\n}\nexport function isJSDoc(node, options) {\n    const normalizedOptions = normalizeOptions(options);\n    const lines = getLines(node);\n    if (lines.length === 0) {\n        return false;\n    }\n    const first = lines[0];\n    const last = lines[lines.length - 1];\n    const firstRegex = normalizedOptions.start;\n    const lastRegex = normalizedOptions.end;\n    return Boolean(firstRegex === null || firstRegex === void 0 ? void 0 : firstRegex.exec(first)) && Boolean(lastRegex === null || lastRegex === void 0 ? void 0 : lastRegex.exec(last));\n}\nfunction getLines(node) {\n    let content = '';\n    if (typeof node === 'string') {\n        content = node;\n    }\n    else {\n        content = node.text;\n    }\n    const lines = content.split(NEWLINE_REGEXP);\n    return lines;\n}\nconst tagRegex = /\\s*(@([\\p{L}][\\p{L}\\p{N}]*)?)/uy;\nconst inlineTagRegex = /\\{(@[\\p{L}][\\p{L}\\p{N}]*)(\\s*)([^\\r\\n}]+)?\\}/gu;\nfunction tokenize(context) {\n    var _a, _b, _c;\n    const tokens = [];\n    let currentLine = context.position.line;\n    let currentCharacter = context.position.character;\n    for (let i = 0; i < context.lines.length; i++) {\n        const first = i === 0;\n        const last = i === context.lines.length - 1;\n        let line = context.lines[i];\n        let index = 0;\n        if (first && context.options.start) {\n            const match = (_a = context.options.start) === null || _a === void 0 ? void 0 : _a.exec(line);\n            if (match) {\n                index = match.index + match[0].length;\n            }\n        }\n        else {\n            const match = (_b = context.options.line) === null || _b === void 0 ? void 0 : _b.exec(line);\n            if (match) {\n                index = match.index + match[0].length;\n            }\n        }\n        if (last) {\n            const match = (_c = context.options.end) === null || _c === void 0 ? void 0 : _c.exec(line);\n            if (match) {\n                line = line.substring(0, match.index);\n            }\n        }\n        line = line.substring(0, lastCharacter(line));\n        const whitespaceEnd = skipWhitespace(line, index);\n        if (whitespaceEnd >= line.length) {\n            // Only create a break token when we already have previous tokens\n            if (tokens.length > 0) {\n                const position = Position.create(currentLine, currentCharacter);\n                tokens.push({\n                    type: 'break',\n                    content: '',\n                    range: Range.create(position, position)\n                });\n            }\n        }\n        else {\n            tagRegex.lastIndex = index;\n            const tagMatch = tagRegex.exec(line);\n            if (tagMatch) {\n                const fullMatch = tagMatch[0];\n                const value = tagMatch[1];\n                const start = Position.create(currentLine, currentCharacter + index);\n                const end = Position.create(currentLine, currentCharacter + index + fullMatch.length);\n                tokens.push({\n                    type: 'tag',\n                    content: value,\n                    range: Range.create(start, end)\n                });\n                index += fullMatch.length;\n                index = skipWhitespace(line, index);\n            }\n            if (index < line.length) {\n                const rest = line.substring(index);\n                const inlineTagMatches = Array.from(rest.matchAll(inlineTagRegex));\n                tokens.push(...buildInlineTokens(inlineTagMatches, rest, currentLine, currentCharacter + index));\n            }\n        }\n        currentLine++;\n        currentCharacter = 0;\n    }\n    // Remove last break token if there is one\n    if (tokens.length > 0 && tokens[tokens.length - 1].type === 'break') {\n        return tokens.slice(0, -1);\n    }\n    return tokens;\n}\nfunction buildInlineTokens(tags, line, lineIndex, characterIndex) {\n    const tokens = [];\n    if (tags.length === 0) {\n        const start = Position.create(lineIndex, characterIndex);\n        const end = Position.create(lineIndex, characterIndex + line.length);\n        tokens.push({\n            type: 'text',\n            content: line,\n            range: Range.create(start, end)\n        });\n    }\n    else {\n        let lastIndex = 0;\n        for (const match of tags) {\n            const matchIndex = match.index;\n            const startContent = line.substring(lastIndex, matchIndex);\n            if (startContent.length > 0) {\n                tokens.push({\n                    type: 'text',\n                    content: line.substring(lastIndex, matchIndex),\n                    range: Range.create(Position.create(lineIndex, lastIndex + characterIndex), Position.create(lineIndex, matchIndex + characterIndex))\n                });\n            }\n            let offset = startContent.length + 1;\n            const tagName = match[1];\n            tokens.push({\n                type: 'inline-tag',\n                content: tagName,\n                range: Range.create(Position.create(lineIndex, lastIndex + offset + characterIndex), Position.create(lineIndex, lastIndex + offset + tagName.length + characterIndex))\n            });\n            offset += tagName.length;\n            if (match.length === 4) {\n                offset += match[2].length;\n                const value = match[3];\n                tokens.push({\n                    type: 'text',\n                    content: value,\n                    range: Range.create(Position.create(lineIndex, lastIndex + offset + characterIndex), Position.create(lineIndex, lastIndex + offset + value.length + characterIndex))\n                });\n            }\n            else {\n                tokens.push({\n                    type: 'text',\n                    content: '',\n                    range: Range.create(Position.create(lineIndex, lastIndex + offset + characterIndex), Position.create(lineIndex, lastIndex + offset + characterIndex))\n                });\n            }\n            lastIndex = matchIndex + match[0].length;\n        }\n        const endContent = line.substring(lastIndex);\n        if (endContent.length > 0) {\n            tokens.push({\n                type: 'text',\n                content: endContent,\n                range: Range.create(Position.create(lineIndex, lastIndex + characterIndex), Position.create(lineIndex, lastIndex + characterIndex + endContent.length))\n            });\n        }\n    }\n    return tokens;\n}\nconst nonWhitespaceRegex = /\\S/;\nconst whitespaceEndRegex = /\\s*$/;\nfunction skipWhitespace(line, index) {\n    const match = line.substring(index).match(nonWhitespaceRegex);\n    if (match) {\n        return index + match.index;\n    }\n    else {\n        return line.length;\n    }\n}\nfunction lastCharacter(line) {\n    const match = line.match(whitespaceEndRegex);\n    if (match && typeof match.index === 'number') {\n        return match.index;\n    }\n    return undefined;\n}\n// Parsing\nfunction parseJSDocComment(context) {\n    var _a, _b, _c, _d;\n    const startPosition = Position.create(context.position.line, context.position.character);\n    if (context.tokens.length === 0) {\n        return new JSDocCommentImpl([], Range.create(startPosition, startPosition));\n    }\n    const elements = [];\n    while (context.index < context.tokens.length) {\n        const element = parseJSDocElement(context, elements[elements.length - 1]);\n        if (element) {\n            elements.push(element);\n        }\n    }\n    const start = (_b = (_a = elements[0]) === null || _a === void 0 ? void 0 : _a.range.start) !== null && _b !== void 0 ? _b : startPosition;\n    const end = (_d = (_c = elements[elements.length - 1]) === null || _c === void 0 ? void 0 : _c.range.end) !== null && _d !== void 0 ? _d : startPosition;\n    return new JSDocCommentImpl(elements, Range.create(start, end));\n}\nfunction parseJSDocElement(context, last) {\n    const next = context.tokens[context.index];\n    if (next.type === 'tag') {\n        return parseJSDocTag(context, false);\n    }\n    else if (next.type === 'text' || next.type === 'inline-tag') {\n        return parseJSDocText(context);\n    }\n    else {\n        appendEmptyLine(next, last);\n        context.index++;\n        return undefined;\n    }\n}\nfunction appendEmptyLine(token, element) {\n    if (element) {\n        const line = new JSDocLineImpl('', token.range);\n        if ('inlines' in element) {\n            element.inlines.push(line);\n        }\n        else {\n            element.content.inlines.push(line);\n        }\n    }\n}\nfunction parseJSDocText(context) {\n    let token = context.tokens[context.index];\n    const firstToken = token;\n    let lastToken = token;\n    const lines = [];\n    while (token && token.type !== 'break' && token.type !== 'tag') {\n        lines.push(parseJSDocInline(context));\n        lastToken = token;\n        token = context.tokens[context.index];\n    }\n    return new JSDocTextImpl(lines, Range.create(firstToken.range.start, lastToken.range.end));\n}\nfunction parseJSDocInline(context) {\n    const token = context.tokens[context.index];\n    if (token.type === 'inline-tag') {\n        return parseJSDocTag(context, true);\n    }\n    else {\n        return parseJSDocLine(context);\n    }\n}\nfunction parseJSDocTag(context, inline) {\n    const tagToken = context.tokens[context.index++];\n    const name = tagToken.content.substring(1);\n    const nextToken = context.tokens[context.index];\n    if ((nextToken === null || nextToken === void 0 ? void 0 : nextToken.type) === 'text') {\n        if (inline) {\n            const docLine = parseJSDocLine(context);\n            return new JSDocTagImpl(name, new JSDocTextImpl([docLine], docLine.range), inline, Range.create(tagToken.range.start, docLine.range.end));\n        }\n        else {\n            const textDoc = parseJSDocText(context);\n            return new JSDocTagImpl(name, textDoc, inline, Range.create(tagToken.range.start, textDoc.range.end));\n        }\n    }\n    else {\n        const range = tagToken.range;\n        return new JSDocTagImpl(name, new JSDocTextImpl([], range), inline, range);\n    }\n}\nfunction parseJSDocLine(context) {\n    const token = context.tokens[context.index++];\n    return new JSDocLineImpl(token.content, token.range);\n}\nfunction normalizeOptions(options) {\n    if (!options) {\n        return normalizeOptions({\n            start: '/**',\n            end: '*/',\n            line: '*'\n        });\n    }\n    const { start, end, line } = options;\n    return {\n        start: normalizeOption(start, true),\n        end: normalizeOption(end, false),\n        line: normalizeOption(line, true)\n    };\n}\nfunction normalizeOption(option, start) {\n    if (typeof option === 'string' || typeof option === 'object') {\n        const escaped = typeof option === 'string' ? escapeRegExp(option) : option.source;\n        if (start) {\n            return new RegExp(`^\\\\s*${escaped}`);\n        }\n        else {\n            return new RegExp(`\\\\s*${escaped}\\\\s*$`);\n        }\n    }\n    else {\n        return option;\n    }\n}\nclass JSDocCommentImpl {\n    constructor(elements, range) {\n        this.elements = elements;\n        this.range = range;\n    }\n    getTag(name) {\n        return this.getAllTags().find(e => e.name === name);\n    }\n    getTags(name) {\n        return this.getAllTags().filter(e => e.name === name);\n    }\n    getAllTags() {\n        return this.elements.filter((e) => 'name' in e);\n    }\n    toString() {\n        let value = '';\n        for (const element of this.elements) {\n            if (value.length === 0) {\n                value = element.toString();\n            }\n            else {\n                const text = element.toString();\n                value += fillNewlines(value) + text;\n            }\n        }\n        return value.trim();\n    }\n    toMarkdown(options) {\n        let value = '';\n        for (const element of this.elements) {\n            if (value.length === 0) {\n                value = element.toMarkdown(options);\n            }\n            else {\n                const text = element.toMarkdown(options);\n                value += fillNewlines(value) + text;\n            }\n        }\n        return value.trim();\n    }\n}\nclass JSDocTagImpl {\n    constructor(name, content, inline, range) {\n        this.name = name;\n        this.content = content;\n        this.inline = inline;\n        this.range = range;\n    }\n    toString() {\n        let text = `@${this.name}`;\n        const content = this.content.toString();\n        if (this.content.inlines.length === 1) {\n            text = `${text} ${content}`;\n        }\n        else if (this.content.inlines.length > 1) {\n            text = `${text}\\n${content}`;\n        }\n        if (this.inline) {\n            // Inline tags are surrounded by curly braces\n            return `{${text}}`;\n        }\n        else {\n            return text;\n        }\n    }\n    toMarkdown(options) {\n        var _a, _b;\n        return (_b = (_a = options === null || options === void 0 ? void 0 : options.renderTag) === null || _a === void 0 ? void 0 : _a.call(options, this)) !== null && _b !== void 0 ? _b : this.toMarkdownDefault(options);\n    }\n    toMarkdownDefault(options) {\n        const content = this.content.toMarkdown(options);\n        if (this.inline) {\n            const rendered = renderInlineTag(this.name, content, options !== null && options !== void 0 ? options : {});\n            if (typeof rendered === 'string') {\n                return rendered;\n            }\n        }\n        let marker = '';\n        if ((options === null || options === void 0 ? void 0 : options.tag) === 'italic' || (options === null || options === void 0 ? void 0 : options.tag) === undefined) {\n            marker = '*';\n        }\n        else if ((options === null || options === void 0 ? void 0 : options.tag) === 'bold') {\n            marker = '**';\n        }\n        else if ((options === null || options === void 0 ? void 0 : options.tag) === 'bold-italic') {\n            marker = '***';\n        }\n        let text = `${marker}@${this.name}${marker}`;\n        if (this.content.inlines.length === 1) {\n            text = `${text} — ${content}`;\n        }\n        else if (this.content.inlines.length > 1) {\n            text = `${text}\\n${content}`;\n        }\n        if (this.inline) {\n            // Inline tags are surrounded by curly braces\n            return `{${text}}`;\n        }\n        else {\n            return text;\n        }\n    }\n}\nfunction renderInlineTag(tag, content, options) {\n    var _a, _b;\n    if (tag === 'linkplain' || tag === 'linkcode' || tag === 'link') {\n        const index = content.indexOf(' ');\n        let display = content;\n        if (index > 0) {\n            const displayStart = skipWhitespace(content, index);\n            display = content.substring(displayStart);\n            content = content.substring(0, index);\n        }\n        if (tag === 'linkcode' || (tag === 'link' && options.link === 'code')) {\n            // Surround the display value in a markdown inline code block\n            display = `\\`${display}\\``;\n        }\n        const renderedLink = (_b = (_a = options.renderLink) === null || _a === void 0 ? void 0 : _a.call(options, content, display)) !== null && _b !== void 0 ? _b : renderLinkDefault(content, display);\n        return renderedLink;\n    }\n    return undefined;\n}\nfunction renderLinkDefault(content, display) {\n    try {\n        URI.parse(content, true);\n        return `[${display}](${content})`;\n    }\n    catch (_a) {\n        return content;\n    }\n}\nclass JSDocTextImpl {\n    constructor(lines, range) {\n        this.inlines = lines;\n        this.range = range;\n    }\n    toString() {\n        let text = '';\n        for (let i = 0; i < this.inlines.length; i++) {\n            const inline = this.inlines[i];\n            const next = this.inlines[i + 1];\n            text += inline.toString();\n            if (next && next.range.start.line > inline.range.start.line) {\n                text += '\\n';\n            }\n        }\n        return text;\n    }\n    toMarkdown(options) {\n        let text = '';\n        for (let i = 0; i < this.inlines.length; i++) {\n            const inline = this.inlines[i];\n            const next = this.inlines[i + 1];\n            text += inline.toMarkdown(options);\n            if (next && next.range.start.line > inline.range.start.line) {\n                text += '\\n';\n            }\n        }\n        return text;\n    }\n}\nclass JSDocLineImpl {\n    constructor(text, range) {\n        this.text = text;\n        this.range = range;\n    }\n    toString() {\n        return this.text;\n    }\n    toMarkdown() {\n        return this.text;\n    }\n}\nfunction fillNewlines(text) {\n    if (text.endsWith('\\n')) {\n        return '\\n';\n    }\n    else {\n        return '\\n\\n';\n    }\n}\n//# sourceMappingURL=jsdoc.js.map","/******************************************************************************\n * Copyright 2023 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { getDocument } from '../utils/ast-utils.js';\nimport { isJSDoc, parseJSDoc } from './jsdoc.js';\nexport class JSDocDocumentationProvider {\n    constructor(services) {\n        this.indexManager = services.shared.workspace.IndexManager;\n        this.commentProvider = services.documentation.CommentProvider;\n    }\n    getDocumentation(node) {\n        const comment = this.commentProvider.getComment(node);\n        if (comment && isJSDoc(comment)) {\n            const parsedJSDoc = parseJSDoc(comment);\n            return parsedJSDoc.toMarkdown({\n                renderLink: (link, display) => {\n                    return this.documentationLinkRenderer(node, link, display);\n                },\n                renderTag: (tag) => {\n                    return this.documentationTagRenderer(node, tag);\n                }\n            });\n        }\n        return undefined;\n    }\n    documentationLinkRenderer(node, name, display) {\n        var _a;\n        const description = (_a = this.findNameInPrecomputedScopes(node, name)) !== null && _a !== void 0 ? _a : this.findNameInGlobalScope(node, name);\n        if (description && description.nameSegment) {\n            const line = description.nameSegment.range.start.line + 1;\n            const character = description.nameSegment.range.start.character + 1;\n            const uri = description.documentUri.with({ fragment: `L${line},${character}` });\n            return `[${display}](${uri.toString()})`;\n        }\n        else {\n            return undefined;\n        }\n    }\n    documentationTagRenderer(_node, _tag) {\n        // Fall back to the default tag rendering\n        return undefined;\n    }\n    findNameInPrecomputedScopes(node, name) {\n        const document = getDocument(node);\n        const precomputed = document.precomputedScopes;\n        if (!precomputed) {\n            return undefined;\n        }\n        let currentNode = node;\n        do {\n            const allDescriptions = precomputed.get(currentNode);\n            const description = allDescriptions.find(e => e.name === name);\n            if (description) {\n                return description;\n            }\n            currentNode = currentNode.$container;\n        } while (currentNode);\n        return undefined;\n    }\n    findNameInGlobalScope(node, name) {\n        const description = this.indexManager.allElements().find(e => e.name === name);\n        return description;\n    }\n}\n//# sourceMappingURL=documentation-provider.js.map","/******************************************************************************\n * Copyright 2023 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { isAstNodeWithComment } from '../serializer/json-serializer.js';\nimport { findCommentNode } from '../utils/cst-utils.js';\nexport class DefaultCommentProvider {\n    constructor(services) {\n        this.grammarConfig = () => services.parser.GrammarConfig;\n    }\n    getComment(node) {\n        var _a;\n        if (isAstNodeWithComment(node)) {\n            return node.$comment;\n        }\n        return (_a = findCommentNode(node.$cstNode, this.grammarConfig().multilineCommentRules)) === null || _a === void 0 ? void 0 : _a.text;\n    }\n}\n//# sourceMappingURL=comment-provider.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nexport var Module;\n(function (Module) {\n    Module.merge = (m1, m2) => _merge(_merge({}, m1), m2);\n})(Module || (Module = {}));\n/**\n * Given a set of modules, the inject function returns a lazily evaluated injector\n * that injects dependencies into the requested service when it is requested the\n * first time. Subsequent requests will return the same service.\n *\n * In the case of cyclic dependencies, an Error will be thrown. This can be fixed\n * by injecting a provider `() => T` instead of a `T`.\n *\n * Please note that the arguments may be objects or arrays. However, the result will\n * be an object. Using it with for..of will have no effect.\n *\n * @param module1 first Module\n * @param module2 (optional) second Module\n * @param module3 (optional) third Module\n * @param module4 (optional) fourth Module\n * @param module5 (optional) fifth Module\n * @param module6 (optional) sixth Module\n * @param module7 (optional) seventh Module\n * @param module8 (optional) eighth Module\n * @param module9 (optional) ninth Module\n * @returns a new object of type I\n */\nexport function inject(module1, module2, module3, module4, module5, module6, module7, module8, module9) {\n    const module = [module1, module2, module3, module4, module5, module6, module7, module8, module9].reduce(_merge, {});\n    return _inject(module);\n}\nconst isProxy = Symbol('isProxy');\n/**\n * Eagerly load all services in the given dependency injection container. This is sometimes\n * necessary because services can register event listeners in their constructors.\n */\nexport function eagerLoad(item) {\n    if (item && item[isProxy]) {\n        for (const value of Object.values(item)) {\n            eagerLoad(value);\n        }\n    }\n    return item;\n}\n/**\n * Helper function that returns an injector by creating a proxy.\n * Invariant: injector is of type I. If injector is undefined, then T = I.\n */\nfunction _inject(module, injector) {\n    const proxy = new Proxy({}, {\n        deleteProperty: () => false,\n        get: (obj, prop) => _resolve(obj, prop, module, injector || proxy),\n        getOwnPropertyDescriptor: (obj, prop) => (_resolve(obj, prop, module, injector || proxy), Object.getOwnPropertyDescriptor(obj, prop)),\n        has: (_, prop) => prop in module,\n        ownKeys: () => [...Reflect.ownKeys(module), isProxy] // used by for..in\n    });\n    proxy[isProxy] = true;\n    return proxy;\n}\n/**\n * Internally used to tag a requested dependency, directly before calling the factory.\n * This allows us to find cycles during instance creation.\n */\nconst __requested__ = Symbol();\n/**\n * Returns the value `obj[prop]`. If the value does not exist, yet, it is resolved from\n * the module description. The result of service factories is cached. Groups are\n * recursively proxied.\n *\n * @param obj an object holding all group proxies and services\n * @param prop the key of a value within obj\n * @param module an object containing groups and service factories\n * @param injector the first level proxy that provides access to all values\n * @returns the requested value `obj[prop]`\n * @throws Error if a dependency cycle is detected\n */\nfunction _resolve(obj, prop, module, injector) {\n    if (prop in obj) {\n        if (obj[prop] instanceof Error) {\n            throw new Error('Construction failure. Please make sure that your dependencies are constructable.', { cause: obj[prop] });\n        }\n        if (obj[prop] === __requested__) {\n            throw new Error('Cycle detected. Please make \"' + String(prop) + '\" lazy. See https://langium.org/docs/configuration-services/#resolving-cyclic-dependencies');\n        }\n        return obj[prop];\n    }\n    else if (prop in module) {\n        const value = module[prop];\n        obj[prop] = __requested__;\n        try {\n            obj[prop] = (typeof value === 'function') ? value(injector) : _inject(value, injector);\n        }\n        catch (error) {\n            obj[prop] = error instanceof Error ? error : undefined;\n            throw error;\n        }\n        return obj[prop];\n    }\n    else {\n        return undefined;\n    }\n}\n/**\n * Performs a deep-merge of two modules by writing source entries into the target module.\n *\n * @param target the module which is written\n * @param source the module which is read\n * @returns the target module\n */\nfunction _merge(target, source) {\n    if (source) {\n        for (const [key, value2] of Object.entries(source)) {\n            if (value2 !== undefined) {\n                const value1 = target[key];\n                if (value1 !== null && value2 !== null && typeof value1 === 'object' && typeof value2 === 'object') {\n                    target[key] = _merge(value1, value2);\n                }\n                else {\n                    target[key] = value2;\n                }\n            }\n        }\n    }\n    return target;\n}\n//# sourceMappingURL=dependency-injection.js.map","/******************************************************************************\n * Copyright 2023 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { Deferred, OperationCancelled } from '../utils/promise-utils.js';\nimport { Emitter } from '../utils/event.js';\n/**\n * Default implementation of the async parser. This implementation only wraps the sync parser in a promise.\n *\n * A real implementation would create worker threads or web workers to offload the parsing work.\n */\nexport class DefaultAsyncParser {\n    constructor(services) {\n        this.syncParser = services.parser.LangiumParser;\n    }\n    parse(text) {\n        return Promise.resolve(this.syncParser.parse(text));\n    }\n}\nexport class AbstractThreadedAsyncParser {\n    constructor(services) {\n        /**\n         * The thread count determines how many threads are used to parse files in parallel.\n         * The default value is 8. Decreasing this value increases startup performance, but decreases parallel parsing performance.\n         */\n        this.threadCount = 8;\n        /**\n         * The termination delay determines how long the parser waits for a thread to finish after a cancellation request.\n         * The default value is 200(ms).\n         */\n        this.terminationDelay = 200;\n        this.workerPool = [];\n        this.queue = [];\n        this.hydrator = services.serializer.Hydrator;\n    }\n    initializeWorkers() {\n        while (this.workerPool.length < this.threadCount) {\n            const worker = this.createWorker();\n            worker.onReady(() => {\n                if (this.queue.length > 0) {\n                    const deferred = this.queue.shift();\n                    if (deferred) {\n                        worker.lock();\n                        deferred.resolve(worker);\n                    }\n                }\n            });\n            this.workerPool.push(worker);\n        }\n    }\n    async parse(text, cancelToken) {\n        const worker = await this.acquireParserWorker(cancelToken);\n        const deferred = new Deferred();\n        let timeout;\n        // If the cancellation token is requested, we wait for a certain time before terminating the worker.\n        // Since the cancellation token lives longer than the parsing process, we need to dispose the event listener.\n        // Otherwise, we might accidentally terminate the worker after the parsing process has finished.\n        const cancellation = cancelToken.onCancellationRequested(() => {\n            timeout = setTimeout(() => {\n                this.terminateWorker(worker);\n            }, this.terminationDelay);\n        });\n        worker.parse(text).then(result => {\n            const hydrated = this.hydrator.hydrate(result);\n            deferred.resolve(hydrated);\n        }).catch(err => {\n            deferred.reject(err);\n        }).finally(() => {\n            cancellation.dispose();\n            clearTimeout(timeout);\n        });\n        return deferred.promise;\n    }\n    terminateWorker(worker) {\n        worker.terminate();\n        const index = this.workerPool.indexOf(worker);\n        if (index >= 0) {\n            this.workerPool.splice(index, 1);\n        }\n    }\n    async acquireParserWorker(cancelToken) {\n        this.initializeWorkers();\n        for (const worker of this.workerPool) {\n            if (worker.ready) {\n                worker.lock();\n                return worker;\n            }\n        }\n        const deferred = new Deferred();\n        cancelToken.onCancellationRequested(() => {\n            const index = this.queue.indexOf(deferred);\n            if (index >= 0) {\n                this.queue.splice(index, 1);\n            }\n            deferred.reject(OperationCancelled);\n        });\n        this.queue.push(deferred);\n        return deferred.promise;\n    }\n}\nexport class ParserWorker {\n    get ready() {\n        return this._ready;\n    }\n    get onReady() {\n        return this.onReadyEmitter.event;\n    }\n    constructor(sendMessage, onMessage, onError, terminate) {\n        this.onReadyEmitter = new Emitter();\n        this.deferred = new Deferred();\n        this._ready = true;\n        this._parsing = false;\n        this.sendMessage = sendMessage;\n        this._terminate = terminate;\n        onMessage(result => {\n            const parseResult = result;\n            this.deferred.resolve(parseResult);\n            this.unlock();\n        });\n        onError(error => {\n            this.deferred.reject(error);\n            this.unlock();\n        });\n    }\n    terminate() {\n        this.deferred.reject(OperationCancelled);\n        this._terminate();\n    }\n    lock() {\n        this._ready = false;\n    }\n    unlock() {\n        this._parsing = false;\n        this._ready = true;\n        this.onReadyEmitter.fire();\n    }\n    parse(text) {\n        if (this._parsing) {\n            throw new Error('Parser worker is busy');\n        }\n        this._parsing = true;\n        this.deferred = new Deferred();\n        this.sendMessage(text);\n        return this.deferred.promise;\n    }\n}\n//# sourceMappingURL=async-parser.js.map","/******************************************************************************\n * Copyright 2023 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken, CancellationTokenSource } from '../utils/cancellation.js';\nimport { Deferred, isOperationCancelled } from '../utils/promise-utils.js';\nexport class DefaultWorkspaceLock {\n    constructor() {\n        this.previousTokenSource = new CancellationTokenSource();\n        this.writeQueue = [];\n        this.readQueue = [];\n        this.done = true;\n    }\n    write(action) {\n        this.cancelWrite();\n        const tokenSource = new CancellationTokenSource();\n        this.previousTokenSource = tokenSource;\n        return this.enqueue(this.writeQueue, action, tokenSource.token);\n    }\n    read(action) {\n        return this.enqueue(this.readQueue, action);\n    }\n    enqueue(queue, action, cancellationToken) {\n        const deferred = new Deferred();\n        const entry = {\n            action,\n            deferred,\n            cancellationToken: cancellationToken !== null && cancellationToken !== void 0 ? cancellationToken : CancellationToken.None\n        };\n        queue.push(entry);\n        this.performNextOperation();\n        return deferred.promise;\n    }\n    async performNextOperation() {\n        if (!this.done) {\n            return;\n        }\n        const entries = [];\n        if (this.writeQueue.length > 0) {\n            // Just perform the next write action\n            entries.push(this.writeQueue.shift());\n        }\n        else if (this.readQueue.length > 0) {\n            // Empty the read queue and perform all actions in parallel\n            entries.push(...this.readQueue.splice(0, this.readQueue.length));\n        }\n        else {\n            return;\n        }\n        this.done = false;\n        await Promise.all(entries.map(async ({ action, deferred, cancellationToken }) => {\n            try {\n                // Move the execution of the action to the next event loop tick via `Promise.resolve()`\n                const result = await Promise.resolve().then(() => action(cancellationToken));\n                deferred.resolve(result);\n            }\n            catch (err) {\n                if (isOperationCancelled(err)) {\n                    // If the operation was cancelled, we don't want to reject the promise\n                    deferred.resolve(undefined);\n                }\n                else {\n                    deferred.reject(err);\n                }\n            }\n        }));\n        this.done = true;\n        this.performNextOperation();\n    }\n    cancelWrite() {\n        this.previousTokenSource.cancel();\n    }\n}\n//# sourceMappingURL=workspace-lock.js.map","/******************************************************************************\n * Copyright 2024 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CompositeCstNodeImpl, LeafCstNodeImpl, RootCstNodeImpl } from '../parser/cst-node-builder.js';\nimport { isAbstractElement } from '../languages/generated/ast.js';\nimport { isRootCstNode, isCompositeCstNode, isLeafCstNode, isAstNode, isReference } from '../syntax-tree.js';\nimport { streamAst } from '../utils/ast-utils.js';\nimport { BiMap } from '../utils/collections.js';\nimport { streamCst } from '../utils/cst-utils.js';\nexport class DefaultHydrator {\n    constructor(services) {\n        this.grammarElementIdMap = new BiMap();\n        this.tokenTypeIdMap = new BiMap();\n        this.grammar = services.Grammar;\n        this.lexer = services.parser.Lexer;\n        this.linker = services.references.Linker;\n    }\n    dehydrate(result) {\n        return {\n            // We need to create shallow copies of the errors\n            // The original errors inherit from the `Error` class, which is not transferable across worker threads\n            lexerErrors: result.lexerErrors.map(e => (Object.assign({}, e))),\n            parserErrors: result.parserErrors.map(e => (Object.assign({}, e))),\n            value: this.dehydrateAstNode(result.value, this.createDehyrationContext(result.value))\n        };\n    }\n    createDehyrationContext(node) {\n        const astNodes = new Map();\n        const cstNodes = new Map();\n        for (const astNode of streamAst(node)) {\n            astNodes.set(astNode, {});\n        }\n        if (node.$cstNode) {\n            for (const cstNode of streamCst(node.$cstNode)) {\n                cstNodes.set(cstNode, {});\n            }\n        }\n        return {\n            astNodes,\n            cstNodes\n        };\n    }\n    dehydrateAstNode(node, context) {\n        const obj = context.astNodes.get(node);\n        obj.$type = node.$type;\n        obj.$containerIndex = node.$containerIndex;\n        obj.$containerProperty = node.$containerProperty;\n        if (node.$cstNode !== undefined) {\n            obj.$cstNode = this.dehydrateCstNode(node.$cstNode, context);\n        }\n        for (const [name, value] of Object.entries(node)) {\n            if (name.startsWith('$')) {\n                continue;\n            }\n            if (Array.isArray(value)) {\n                const arr = [];\n                obj[name] = arr;\n                for (const item of value) {\n                    if (isAstNode(item)) {\n                        arr.push(this.dehydrateAstNode(item, context));\n                    }\n                    else if (isReference(item)) {\n                        arr.push(this.dehydrateReference(item, context));\n                    }\n                    else {\n                        arr.push(item);\n                    }\n                }\n            }\n            else if (isAstNode(value)) {\n                obj[name] = this.dehydrateAstNode(value, context);\n            }\n            else if (isReference(value)) {\n                obj[name] = this.dehydrateReference(value, context);\n            }\n            else if (value !== undefined) {\n                obj[name] = value;\n            }\n        }\n        return obj;\n    }\n    dehydrateReference(reference, context) {\n        const obj = {};\n        obj.$refText = reference.$refText;\n        if (reference.$refNode) {\n            obj.$refNode = context.cstNodes.get(reference.$refNode);\n        }\n        return obj;\n    }\n    dehydrateCstNode(node, context) {\n        const cstNode = context.cstNodes.get(node);\n        if (isRootCstNode(node)) {\n            cstNode.fullText = node.fullText;\n        }\n        else {\n            // Note: This returns undefined for hidden nodes (i.e. comments)\n            cstNode.grammarSource = this.getGrammarElementId(node.grammarSource);\n        }\n        cstNode.hidden = node.hidden;\n        cstNode.astNode = context.astNodes.get(node.astNode);\n        if (isCompositeCstNode(node)) {\n            cstNode.content = node.content.map(child => this.dehydrateCstNode(child, context));\n        }\n        else if (isLeafCstNode(node)) {\n            cstNode.tokenType = node.tokenType.name;\n            cstNode.offset = node.offset;\n            cstNode.length = node.length;\n            cstNode.startLine = node.range.start.line;\n            cstNode.startColumn = node.range.start.character;\n            cstNode.endLine = node.range.end.line;\n            cstNode.endColumn = node.range.end.character;\n        }\n        return cstNode;\n    }\n    hydrate(result) {\n        const node = result.value;\n        const context = this.createHydrationContext(node);\n        if ('$cstNode' in node) {\n            this.hydrateCstNode(node.$cstNode, context);\n        }\n        return {\n            lexerErrors: result.lexerErrors,\n            parserErrors: result.parserErrors,\n            value: this.hydrateAstNode(node, context)\n        };\n    }\n    createHydrationContext(node) {\n        const astNodes = new Map();\n        const cstNodes = new Map();\n        for (const astNode of streamAst(node)) {\n            astNodes.set(astNode, {});\n        }\n        let root;\n        if (node.$cstNode) {\n            for (const cstNode of streamCst(node.$cstNode)) {\n                let cst;\n                if ('fullText' in cstNode) {\n                    cst = new RootCstNodeImpl(cstNode.fullText);\n                    root = cst;\n                }\n                else if ('content' in cstNode) {\n                    cst = new CompositeCstNodeImpl();\n                }\n                else if ('tokenType' in cstNode) {\n                    cst = this.hydrateCstLeafNode(cstNode);\n                }\n                if (cst) {\n                    cstNodes.set(cstNode, cst);\n                    cst.root = root;\n                }\n            }\n        }\n        return {\n            astNodes,\n            cstNodes\n        };\n    }\n    hydrateAstNode(node, context) {\n        const astNode = context.astNodes.get(node);\n        astNode.$type = node.$type;\n        astNode.$containerIndex = node.$containerIndex;\n        astNode.$containerProperty = node.$containerProperty;\n        if (node.$cstNode) {\n            astNode.$cstNode = context.cstNodes.get(node.$cstNode);\n        }\n        for (const [name, value] of Object.entries(node)) {\n            if (name.startsWith('$')) {\n                continue;\n            }\n            if (Array.isArray(value)) {\n                const arr = [];\n                astNode[name] = arr;\n                for (const item of value) {\n                    if (isAstNode(item)) {\n                        arr.push(this.setParent(this.hydrateAstNode(item, context), astNode));\n                    }\n                    else if (isReference(item)) {\n                        arr.push(this.hydrateReference(item, astNode, name, context));\n                    }\n                    else {\n                        arr.push(item);\n                    }\n                }\n            }\n            else if (isAstNode(value)) {\n                astNode[name] = this.setParent(this.hydrateAstNode(value, context), astNode);\n            }\n            else if (isReference(value)) {\n                astNode[name] = this.hydrateReference(value, astNode, name, context);\n            }\n            else if (value !== undefined) {\n                astNode[name] = value;\n            }\n        }\n        return astNode;\n    }\n    setParent(node, parent) {\n        node.$container = parent;\n        return node;\n    }\n    hydrateReference(reference, node, name, context) {\n        return this.linker.buildReference(node, name, context.cstNodes.get(reference.$refNode), reference.$refText);\n    }\n    hydrateCstNode(cstNode, context, num = 0) {\n        const cstNodeObj = context.cstNodes.get(cstNode);\n        if (typeof cstNode.grammarSource === 'number') {\n            cstNodeObj.grammarSource = this.getGrammarElement(cstNode.grammarSource);\n        }\n        cstNodeObj.astNode = context.astNodes.get(cstNode.astNode);\n        if (isCompositeCstNode(cstNodeObj)) {\n            for (const child of cstNode.content) {\n                const hydrated = this.hydrateCstNode(child, context, num++);\n                cstNodeObj.content.push(hydrated);\n            }\n        }\n        return cstNodeObj;\n    }\n    hydrateCstLeafNode(cstNode) {\n        const tokenType = this.getTokenType(cstNode.tokenType);\n        const offset = cstNode.offset;\n        const length = cstNode.length;\n        const startLine = cstNode.startLine;\n        const startColumn = cstNode.startColumn;\n        const endLine = cstNode.endLine;\n        const endColumn = cstNode.endColumn;\n        const hidden = cstNode.hidden;\n        const node = new LeafCstNodeImpl(offset, length, {\n            start: {\n                line: startLine,\n                character: startColumn\n            },\n            end: {\n                line: endLine,\n                character: endColumn\n            }\n        }, tokenType, hidden);\n        return node;\n    }\n    getTokenType(name) {\n        return this.lexer.definition[name];\n    }\n    getGrammarElementId(node) {\n        if (this.grammarElementIdMap.size === 0) {\n            this.createGrammarElementIdMap();\n        }\n        return this.grammarElementIdMap.get(node);\n    }\n    getGrammarElement(id) {\n        if (this.grammarElementIdMap.size === 0) {\n            this.createGrammarElementIdMap();\n        }\n        const element = this.grammarElementIdMap.getKey(id);\n        if (element) {\n            return element;\n        }\n        else {\n            throw new Error('Invalid grammar element id: ' + id);\n        }\n    }\n    createGrammarElementIdMap() {\n        let id = 0;\n        for (const element of streamAst(this.grammar)) {\n            if (isAbstractElement(element)) {\n                this.grammarElementIdMap.set(element, id++);\n            }\n        }\n    }\n}\n//# sourceMappingURL=hydrator.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n******************************************************************************/\nimport { createGrammarConfig } from './languages/grammar-config.js';\nimport { createCompletionParser } from './parser/completion-parser-builder.js';\nimport { createLangiumParser } from './parser/langium-parser-builder.js';\nimport { DefaultTokenBuilder } from './parser/token-builder.js';\nimport { DefaultValueConverter } from './parser/value-converter.js';\nimport { DefaultLinker } from './references/linker.js';\nimport { DefaultNameProvider } from './references/name-provider.js';\nimport { DefaultReferences } from './references/references.js';\nimport { DefaultScopeComputation } from './references/scope-computation.js';\nimport { DefaultScopeProvider } from './references/scope-provider.js';\nimport { DefaultJsonSerializer } from './serializer/json-serializer.js';\nimport { DefaultServiceRegistry } from './service-registry.js';\nimport { DefaultDocumentValidator } from './validation/document-validator.js';\nimport { ValidationRegistry } from './validation/validation-registry.js';\nimport { DefaultAstNodeDescriptionProvider, DefaultReferenceDescriptionProvider } from './workspace/ast-descriptions.js';\nimport { DefaultAstNodeLocator } from './workspace/ast-node-locator.js';\nimport { DefaultConfigurationProvider } from './workspace/configuration.js';\nimport { DefaultDocumentBuilder } from './workspace/document-builder.js';\nimport { DefaultLangiumDocumentFactory, DefaultLangiumDocuments } from './workspace/documents.js';\nimport { DefaultIndexManager } from './workspace/index-manager.js';\nimport { DefaultWorkspaceManager } from './workspace/workspace-manager.js';\nimport { DefaultLexer } from './parser/lexer.js';\nimport { JSDocDocumentationProvider } from './documentation/documentation-provider.js';\nimport { DefaultCommentProvider } from './documentation/comment-provider.js';\nimport { LangiumParserErrorMessageProvider } from './parser/langium-parser.js';\nimport { DefaultAsyncParser } from './parser/async-parser.js';\nimport { DefaultWorkspaceLock } from './workspace/workspace-lock.js';\nimport { DefaultHydrator } from './serializer/hydrator.js';\n/**\n * Creates a dependency injection module configuring the default core services.\n * This is a set of services that are dedicated to a specific language.\n */\nexport function createDefaultCoreModule(context) {\n    return {\n        documentation: {\n            CommentProvider: (services) => new DefaultCommentProvider(services),\n            DocumentationProvider: (services) => new JSDocDocumentationProvider(services)\n        },\n        parser: {\n            AsyncParser: (services) => new DefaultAsyncParser(services),\n            GrammarConfig: (services) => createGrammarConfig(services),\n            LangiumParser: (services) => createLangiumParser(services),\n            CompletionParser: (services) => createCompletionParser(services),\n            ValueConverter: () => new DefaultValueConverter(),\n            TokenBuilder: () => new DefaultTokenBuilder(),\n            Lexer: (services) => new DefaultLexer(services),\n            ParserErrorMessageProvider: () => new LangiumParserErrorMessageProvider()\n        },\n        workspace: {\n            AstNodeLocator: () => new DefaultAstNodeLocator(),\n            AstNodeDescriptionProvider: (services) => new DefaultAstNodeDescriptionProvider(services),\n            ReferenceDescriptionProvider: (services) => new DefaultReferenceDescriptionProvider(services)\n        },\n        references: {\n            Linker: (services) => new DefaultLinker(services),\n            NameProvider: () => new DefaultNameProvider(),\n            ScopeProvider: (services) => new DefaultScopeProvider(services),\n            ScopeComputation: (services) => new DefaultScopeComputation(services),\n            References: (services) => new DefaultReferences(services)\n        },\n        serializer: {\n            Hydrator: (services) => new DefaultHydrator(services),\n            JsonSerializer: (services) => new DefaultJsonSerializer(services)\n        },\n        validation: {\n            DocumentValidator: (services) => new DefaultDocumentValidator(services),\n            ValidationRegistry: (services) => new ValidationRegistry(services)\n        },\n        shared: () => context.shared\n    };\n}\n/**\n * Creates a dependency injection module configuring the default shared core services.\n * This is the set of services that are shared between multiple languages.\n */\nexport function createDefaultSharedCoreModule(context) {\n    return {\n        ServiceRegistry: () => new DefaultServiceRegistry(),\n        workspace: {\n            LangiumDocuments: (services) => new DefaultLangiumDocuments(services),\n            LangiumDocumentFactory: (services) => new DefaultLangiumDocumentFactory(services),\n            DocumentBuilder: (services) => new DefaultDocumentBuilder(services),\n            IndexManager: (services) => new DefaultIndexManager(services),\n            WorkspaceManager: (services) => new DefaultWorkspaceManager(services),\n            FileSystemProvider: (services) => context.fileSystemProvider(services),\n            WorkspaceLock: () => new DefaultWorkspaceLock(),\n            ConfigurationProvider: (services) => new DefaultConfigurationProvider(services)\n        }\n    };\n}\n//# sourceMappingURL=default-module.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { DefaultNameRegexp } from '../utils/cst-utils.js';\nimport { isCommentTerminal, terminalRegex } from '../utils/grammar-utils.js';\nimport { isMultilineComment } from '../utils/regexp-utils.js';\nimport { isTerminalRule } from './generated/ast.js';\n/**\n * Create the default grammar configuration (used by `createDefaultModule`). This can be overridden in a\n * language-specific module.\n */\nexport function createGrammarConfig(services) {\n    const rules = [];\n    const grammar = services.Grammar;\n    for (const rule of grammar.rules) {\n        if (isTerminalRule(rule) && isCommentTerminal(rule) && isMultilineComment(terminalRegex(rule))) {\n            rules.push(rule.name);\n        }\n    }\n    return {\n        multilineCommentRules: rules,\n        nameRegexp: DefaultNameRegexp\n    };\n}\n//# sourceMappingURL=grammar-config.js.map","/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { LangiumParser } from './langium-parser.js';\nimport { createParser } from './parser-builder-base.js';\n/**\n * Create and finalize a Langium parser. The parser rules are derived from the grammar, which is\n * available at `services.Grammar`.\n */\nexport function createLangiumParser(services) {\n    const parser = prepareLangiumParser(services);\n    parser.finalize();\n    return parser;\n}\n/**\n * Create a Langium parser without finalizing it. This is used to extract more detailed error\n * information when the parser is initially validated.\n */\nexport function prepareLangiumParser(services) {\n    const grammar = services.Grammar;\n    const lexer = services.parser.Lexer;\n    const parser = new LangiumParser(services);\n    return createParser(grammar, parser, lexer.definition);\n}\n//# sourceMappingURL=langium-parser-builder.js.map","/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { LangiumCompletionParser } from './langium-parser.js';\nimport { createParser } from './parser-builder-base.js';\nexport function createCompletionParser(services) {\n    const grammar = services.Grammar;\n    const lexer = services.parser.Lexer;\n    const parser = new LangiumCompletionParser(services);\n    createParser(grammar, parser, lexer.definition);\n    parser.finalize();\n    return parser;\n}\n//# sourceMappingURL=completion-parser-builder.js.map","/******************************************************************************\n * Copyright 2022 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nexport class EmptyFileSystemProvider {\n    readFile() {\n        throw new Error('No file system is available.');\n    }\n    async readDirectory() {\n        return [];\n    }\n}\nexport const EmptyFileSystem = {\n    fileSystemProvider: () => new EmptyFileSystemProvider()\n};\n//# sourceMappingURL=file-system-provider.js.map","/******************************************************************************\n * Copyright 2023 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { createDefaultCoreModule, createDefaultSharedCoreModule } from '../default-module.js';\nimport { inject } from '../dependency-injection.js';\nimport * as ast from '../languages/generated/ast.js';\nimport { EmptyFileSystem } from '../workspace/file-system-provider.js';\nimport { URI } from './uri-utils.js';\nconst minimalGrammarModule = {\n    Grammar: () => undefined,\n    LanguageMetaData: () => ({\n        caseInsensitive: false,\n        fileExtensions: ['.langium'],\n        languageId: 'langium'\n    })\n};\nconst minimalSharedGrammarModule = {\n    AstReflection: () => new ast.LangiumGrammarAstReflection()\n};\nfunction createMinimalGrammarServices() {\n    const shared = inject(createDefaultSharedCoreModule(EmptyFileSystem), minimalSharedGrammarModule);\n    const grammar = inject(createDefaultCoreModule({ shared }), minimalGrammarModule);\n    shared.ServiceRegistry.register(grammar);\n    return grammar;\n}\n/**\n * Load a Langium grammar for your language from a JSON string. This is used by several services,\n * most notably the parser builder which interprets the grammar to create a parser.\n */\nexport function loadGrammarFromJson(json) {\n    var _a;\n    const services = createMinimalGrammarServices();\n    const astNode = services.serializer.JsonSerializer.deserialize(json);\n    services.shared.workspace.LangiumDocumentFactory.fromModel(astNode, URI.parse(`memory://${(_a = astNode.name) !== null && _a !== void 0 ? _a : 'grammar'}.langium`));\n    return astNode;\n}\n//# sourceMappingURL=grammar-loader.js.map","import baseFlatten from './_baseFlatten.js';\n\n/**\n * Flattens `array` a single level deep.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to flatten.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * _.flatten([1, [2, [3, [4]], 5]]);\n * // => [1, 2, [3, [4]], 5]\n */\nfunction flatten(array) {\n  var length = array == null ? 0 : array.length;\n  return length ? baseFlatten(array, 1) : [];\n}\n\nexport default flatten;\n","import arrayMap from './_arrayMap.js';\nimport baseIteratee from './_baseIteratee.js';\nimport baseMap from './_baseMap.js';\nimport isArray from './isArray.js';\n\n/**\n * Creates an array of values by running each element in `collection` thru\n * `iteratee`. The iteratee is invoked with three arguments:\n * (value, index|key, collection).\n *\n * Many lodash methods are guarded to work as iteratees for methods like\n * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.\n *\n * The guarded methods are:\n * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,\n * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,\n * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,\n * `template`, `trim`, `trimEnd`, `trimStart`, and `words`\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n * @example\n *\n * function square(n) {\n *   return n * n;\n * }\n *\n * _.map([4, 8], square);\n * // => [16, 64]\n *\n * _.map({ 'a': 4, 'b': 8 }, square);\n * // => [16, 64] (iteration order is not guaranteed)\n *\n * var users = [\n *   { 'user': 'barney' },\n *   { 'user': 'fred' }\n * ];\n *\n * // The `_.property` iteratee shorthand.\n * _.map(users, 'user');\n * // => ['barney', 'fred']\n */\nfunction map(collection, iteratee) {\n  var func = isArray(collection) ? arrayMap : baseMap;\n  return func(collection, baseIteratee(iteratee, 3));\n}\n\nexport default map;\n","import assignValue from './_assignValue.js';\nimport castPath from './_castPath.js';\nimport isIndex from './_isIndex.js';\nimport isObject from './isObject.js';\nimport toKey from './_toKey.js';\n\n/**\n * The base implementation of `_.set`.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {*} value The value to set.\n * @param {Function} [customizer] The function to customize path creation.\n * @returns {Object} Returns `object`.\n */\nfunction baseSet(object, path, value, customizer) {\n  if (!isObject(object)) {\n    return object;\n  }\n  path = castPath(path, object);\n\n  var index = -1,\n      length = path.length,\n      lastIndex = length - 1,\n      nested = object;\n\n  while (nested != null && ++index < length) {\n    var key = toKey(path[index]),\n        newValue = value;\n\n    if (key === '__proto__' || key === 'constructor' || key === 'prototype') {\n      return object;\n    }\n\n    if (index != lastIndex) {\n      var objValue = nested[key];\n      newValue = customizer ? customizer(objValue, key, nested) : undefined;\n      if (newValue === undefined) {\n        newValue = isObject(objValue)\n          ? objValue\n          : (isIndex(path[index + 1]) ? [] : {});\n      }\n    }\n    assignValue(nested, key, newValue);\n    nested = nested[key];\n  }\n  return object;\n}\n\nexport default baseSet;\n","import baseGet from './_baseGet.js';\nimport baseSet from './_baseSet.js';\nimport castPath from './_castPath.js';\n\n/**\n * The base implementation of  `_.pickBy` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} paths The property paths to pick.\n * @param {Function} predicate The function invoked per property.\n * @returns {Object} Returns the new object.\n */\nfunction basePickBy(object, paths, predicate) {\n  var index = -1,\n      length = paths.length,\n      result = {};\n\n  while (++index < length) {\n    var path = paths[index],\n        value = baseGet(object, path);\n\n    if (predicate(value, path)) {\n      baseSet(result, castPath(path, object), value);\n    }\n  }\n  return result;\n}\n\nexport default basePickBy;\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","/**\n * The base implementation of `_.lt` which doesn't coerce arguments.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if `value` is less than `other`,\n *  else `false`.\n */\nfunction baseLt(value, other) {\n  return value < other;\n}\n\nexport default baseLt;\n","import baseExtremum from './_baseExtremum.js';\nimport baseLt from './_baseLt.js';\nimport identity from './identity.js';\n\n/**\n * Computes the minimum value of `array`. If `array` is empty or falsey,\n * `undefined` is returned.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Math\n * @param {Array} array The array to iterate over.\n * @returns {*} Returns the minimum value.\n * @example\n *\n * _.min([4, 2, 8, 6]);\n * // => 2\n *\n * _.min([]);\n * // => undefined\n */\nfunction min(array) {\n  return (array && array.length)\n    ? baseExtremum(array, identity, baseLt)\n    : undefined;\n}\n\nexport default min;\n","/**\n * Gets the last element of `array`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to query.\n * @returns {*} Returns the last element of `array`.\n * @example\n *\n * _.last([1, 2, 3]);\n * // => 3\n */\nfunction last(array) {\n  var length = array == null ? 0 : array.length;\n  return length ? array[length - 1] : undefined;\n}\n\nexport default last;\n","import {\n  AbstractMermaidTokenBuilder,\n  CommonValueConverter,\n  InfoGeneratedModule,\n  MermaidGeneratedSharedModule,\n  __name\n} from \"./chunk-Y27MQZ3U.mjs\";\n\n// src/language/info/module.ts\nimport {\n  EmptyFileSystem,\n  createDefaultCoreModule,\n  createDefaultSharedCoreModule,\n  inject\n} from \"langium\";\n\n// src/language/info/tokenBuilder.ts\nvar InfoTokenBuilder = class extends AbstractMermaidTokenBuilder {\n  static {\n    __name(this, \"InfoTokenBuilder\");\n  }\n  constructor() {\n    super([\"info\", \"showInfo\"]);\n  }\n};\n\n// src/language/info/module.ts\nvar InfoModule = {\n  parser: {\n    TokenBuilder: /* @__PURE__ */ __name(() => new InfoTokenBuilder(), \"TokenBuilder\"),\n    ValueConverter: /* @__PURE__ */ __name(() => new CommonValueConverter(), \"ValueConverter\")\n  }\n};\nfunction createInfoServices(context = EmptyFileSystem) {\n  const shared = inject(\n    createDefaultSharedCoreModule(context),\n    MermaidGeneratedSharedModule\n  );\n  const Info = inject(\n    createDefaultCoreModule({ shared }),\n    InfoGeneratedModule,\n    InfoModule\n  );\n  shared.ServiceRegistry.register(Info);\n  return { shared, Info };\n}\n__name(createInfoServices, \"createInfoServices\");\n\nexport {\n  InfoModule,\n  createInfoServices\n};\n","\"use strict\";\n/* --------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n * ------------------------------------------------------------------------------------------ */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0;\nfunction boolean(value) {\n    return value === true || value === false;\n}\nexports.boolean = boolean;\nfunction string(value) {\n    return typeof value === 'string' || value instanceof String;\n}\nexports.string = string;\nfunction number(value) {\n    return typeof value === 'number' || value instanceof Number;\n}\nexports.number = number;\nfunction error(value) {\n    return value instanceof Error;\n}\nexports.error = error;\nfunction func(value) {\n    return typeof value === 'function';\n}\nexports.func = func;\nfunction array(value) {\n    return Array.isArray(value);\n}\nexports.array = array;\nfunction stringArray(value) {\n    return array(value) && value.every(elem => string(elem));\n}\nexports.stringArray = stringArray;\n","import toFinite from './toFinite.js';\n\n/**\n * Converts `value` to an integer.\n *\n * **Note:** This method is loosely based on\n * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toInteger(3.2);\n * // => 3\n *\n * _.toInteger(Number.MIN_VALUE);\n * // => 0\n *\n * _.toInteger(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toInteger('3.2');\n * // => 3\n */\nfunction toInteger(value) {\n  var result = toFinite(value),\n      remainder = result % 1;\n\n  return result === result ? (remainder ? result - remainder : result) : 0;\n}\n\nexport default toInteger;\n","import {\n  AbstractMermaidTokenBuilder,\n  AbstractMermaidValueConverter,\n  MermaidGeneratedSharedModule,\n  PieGeneratedModule,\n  __name\n} from \"./chunk-Y27MQZ3U.mjs\";\n\n// src/language/pie/module.ts\nimport {\n  EmptyFileSystem,\n  createDefaultCoreModule,\n  createDefaultSharedCoreModule,\n  inject\n} from \"langium\";\n\n// src/language/pie/tokenBuilder.ts\nvar PieTokenBuilder = class extends AbstractMermaidTokenBuilder {\n  static {\n    __name(this, \"PieTokenBuilder\");\n  }\n  constructor() {\n    super([\"pie\", \"showData\"]);\n  }\n};\n\n// src/language/pie/valueConverter.ts\nvar PieValueConverter = class extends AbstractMermaidValueConverter {\n  static {\n    __name(this, \"PieValueConverter\");\n  }\n  runCustomConverter(rule, input, _cstNode) {\n    if (rule.name !== \"PIE_SECTION_LABEL\") {\n      return void 0;\n    }\n    return input.replace(/\"/g, \"\").trim();\n  }\n};\n\n// src/language/pie/module.ts\nvar PieModule = {\n  parser: {\n    TokenBuilder: /* @__PURE__ */ __name(() => new PieTokenBuilder(), \"TokenBuilder\"),\n    ValueConverter: /* @__PURE__ */ __name(() => new PieValueConverter(), \"ValueConverter\")\n  }\n};\nfunction createPieServices(context = EmptyFileSystem) {\n  const shared = inject(\n    createDefaultSharedCoreModule(context),\n    MermaidGeneratedSharedModule\n  );\n  const Pie = inject(\n    createDefaultCoreModule({ shared }),\n    PieGeneratedModule,\n    PieModule\n  );\n  shared.ServiceRegistry.register(Pie);\n  return { shared, Pie };\n}\n__name(createPieServices, \"createPieServices\");\n\nexport {\n  PieModule,\n  createPieServices\n};\n","import {\n  GitGraphModule,\n  createGitGraphServices\n} from \"./chunks/mermaid-parser.core/chunk-NCMFTTUW.mjs\";\nimport {\n  InfoModule,\n  createInfoServices\n} from \"./chunks/mermaid-parser.core/chunk-4YFB5VUC.mjs\";\nimport {\n  PacketModule,\n  createPacketServices\n} from \"./chunks/mermaid-parser.core/chunk-EQFLFMNE.mjs\";\nimport {\n  PieModule,\n  createPieServices\n} from \"./chunks/mermaid-parser.core/chunk-BI6EQKOQ.mjs\";\nimport {\n  ArchitectureModule,\n  createArchitectureServices\n} from \"./chunks/mermaid-parser.core/chunk-FF7BQXOH.mjs\";\nimport {\n  AbstractMermaidTokenBuilder,\n  AbstractMermaidValueConverter,\n  Architecture,\n  ArchitectureGeneratedModule,\n  Branch,\n  Commit,\n  CommonTokenBuilder,\n  CommonValueConverter,\n  GitGraph,\n  GitGraphGeneratedModule,\n  Info,\n  InfoGeneratedModule,\n  Merge,\n  MermaidGeneratedSharedModule,\n  Packet,\n  PacketBlock,\n  PacketGeneratedModule,\n  Pie,\n  PieGeneratedModule,\n  PieSection,\n  Statement,\n  __name,\n  isArchitecture,\n  isBranch,\n  isCommit,\n  isCommon,\n  isGitGraph,\n  isInfo,\n  isMerge,\n  isPacket,\n  isPacketBlock,\n  isPie,\n  isPieSection\n} from \"./chunks/mermaid-parser.core/chunk-Y27MQZ3U.mjs\";\n\n// src/parse.ts\nvar parsers = {};\nvar initializers = {\n  info: /* @__PURE__ */ __name(async () => {\n    const { createInfoServices: createInfoServices2 } = await import(\"./chunks/mermaid-parser.core/info-46DW6VJ7.mjs\");\n    const parser = createInfoServices2().Info.parser.LangiumParser;\n    parsers.info = parser;\n  }, \"info\"),\n  packet: /* @__PURE__ */ __name(async () => {\n    const { createPacketServices: createPacketServices2 } = await import(\"./chunks/mermaid-parser.core/packet-W2GHVCYJ.mjs\");\n    const parser = createPacketServices2().Packet.parser.LangiumParser;\n    parsers.packet = parser;\n  }, \"packet\"),\n  pie: /* @__PURE__ */ __name(async () => {\n    const { createPieServices: createPieServices2 } = await import(\"./chunks/mermaid-parser.core/pie-BEWT4RHE.mjs\");\n    const parser = createPieServices2().Pie.parser.LangiumParser;\n    parsers.pie = parser;\n  }, \"pie\"),\n  architecture: /* @__PURE__ */ __name(async () => {\n    const { createArchitectureServices: createArchitectureServices2 } = await import(\"./chunks/mermaid-parser.core/architecture-I3QFYML2.mjs\");\n    const parser = createArchitectureServices2().Architecture.parser.LangiumParser;\n    parsers.architecture = parser;\n  }, \"architecture\"),\n  gitGraph: /* @__PURE__ */ __name(async () => {\n    const { createGitGraphServices: createGitGraphServices2 } = await import(\"./chunks/mermaid-parser.core/gitGraph-YCYPL57B.mjs\");\n    const parser = createGitGraphServices2().GitGraph.parser.LangiumParser;\n    parsers.gitGraph = parser;\n  }, \"gitGraph\")\n};\nasync function parse(diagramType, text) {\n  const initializer = initializers[diagramType];\n  if (!initializer) {\n    throw new Error(`Unknown diagram type: ${diagramType}`);\n  }\n  if (!parsers[diagramType]) {\n    await initializer();\n  }\n  const parser = parsers[diagramType];\n  const result = parser.parse(text);\n  if (result.lexerErrors.length > 0 || result.parserErrors.length > 0) {\n    throw new MermaidParseError(result);\n  }\n  return result.value;\n}\n__name(parse, \"parse\");\nvar MermaidParseError = class extends Error {\n  constructor(result) {\n    const lexerErrors = result.lexerErrors.map((err) => err.message).join(\"\\n\");\n    const parserErrors = result.parserErrors.map((err) => err.message).join(\"\\n\");\n    super(`Parsing failed: ${lexerErrors} ${parserErrors}`);\n    this.result = result;\n  }\n  static {\n    __name(this, \"MermaidParseError\");\n  }\n};\nexport {\n  AbstractMermaidTokenBuilder,\n  AbstractMermaidValueConverter,\n  Architecture,\n  ArchitectureGeneratedModule,\n  ArchitectureModule,\n  Branch,\n  Commit,\n  CommonTokenBuilder,\n  CommonValueConverter,\n  GitGraph,\n  GitGraphGeneratedModule,\n  GitGraphModule,\n  Info,\n  InfoGeneratedModule,\n  InfoModule,\n  Merge,\n  MermaidGeneratedSharedModule,\n  MermaidParseError,\n  Packet,\n  PacketBlock,\n  PacketGeneratedModule,\n  PacketModule,\n  Pie,\n  PieGeneratedModule,\n  PieModule,\n  PieSection,\n  Statement,\n  createArchitectureServices,\n  createGitGraphServices,\n  createInfoServices,\n  createPacketServices,\n  createPieServices,\n  isArchitecture,\n  isBranch,\n  isCommit,\n  isCommon,\n  isGitGraph,\n  isInfo,\n  isMerge,\n  isPacket,\n  isPacketBlock,\n  isPie,\n  isPieSection,\n  parse\n};\n","var __defProp = Object.defineProperty;\nvar __name = (target, value) => __defProp(target, \"name\", { value, configurable: true });\n\n// src/language/generated/ast.ts\nimport { AbstractAstReflection } from \"langium\";\nvar Statement = \"Statement\";\nvar Architecture = \"Architecture\";\nfunction isArchitecture(item) {\n  return reflection.isInstance(item, Architecture);\n}\n__name(isArchitecture, \"isArchitecture\");\nvar Branch = \"Branch\";\nfunction isBranch(item) {\n  return reflection.isInstance(item, Branch);\n}\n__name(isBranch, \"isBranch\");\nvar Checkout = \"Checkout\";\nvar CherryPicking = \"CherryPicking\";\nvar Commit = \"Commit\";\nfunction isCommit(item) {\n  return reflection.isInstance(item, Commit);\n}\n__name(isCommit, \"isCommit\");\nvar Common = \"Common\";\nfunction isCommon(item) {\n  return reflection.isInstance(item, Common);\n}\n__name(isCommon, \"isCommon\");\nvar GitGraph = \"GitGraph\";\nfunction isGitGraph(item) {\n  return reflection.isInstance(item, GitGraph);\n}\n__name(isGitGraph, \"isGitGraph\");\nvar Info = \"Info\";\nfunction isInfo(item) {\n  return reflection.isInstance(item, Info);\n}\n__name(isInfo, \"isInfo\");\nvar Merge = \"Merge\";\nfunction isMerge(item) {\n  return reflection.isInstance(item, Merge);\n}\n__name(isMerge, \"isMerge\");\nvar Packet = \"Packet\";\nfunction isPacket(item) {\n  return reflection.isInstance(item, Packet);\n}\n__name(isPacket, \"isPacket\");\nvar PacketBlock = \"PacketBlock\";\nfunction isPacketBlock(item) {\n  return reflection.isInstance(item, PacketBlock);\n}\n__name(isPacketBlock, \"isPacketBlock\");\nvar Pie = \"Pie\";\nfunction isPie(item) {\n  return reflection.isInstance(item, Pie);\n}\n__name(isPie, \"isPie\");\nvar PieSection = \"PieSection\";\nfunction isPieSection(item) {\n  return reflection.isInstance(item, PieSection);\n}\n__name(isPieSection, \"isPieSection\");\nvar Direction = \"Direction\";\nvar MermaidAstReflection = class extends AbstractAstReflection {\n  static {\n    __name(this, \"MermaidAstReflection\");\n  }\n  getAllTypes() {\n    return [\"Architecture\", \"Branch\", \"Checkout\", \"CherryPicking\", \"Commit\", \"Common\", \"Direction\", \"Edge\", \"GitGraph\", \"Group\", \"Info\", \"Junction\", \"Merge\", \"Packet\", \"PacketBlock\", \"Pie\", \"PieSection\", \"Service\", \"Statement\"];\n  }\n  computeIsSubtype(subtype, supertype) {\n    switch (subtype) {\n      case Branch:\n      case Checkout:\n      case CherryPicking:\n      case Commit:\n      case Merge: {\n        return this.isSubtype(Statement, supertype);\n      }\n      case Direction: {\n        return this.isSubtype(GitGraph, supertype);\n      }\n      default: {\n        return false;\n      }\n    }\n  }\n  getReferenceType(refInfo) {\n    const referenceId = `${refInfo.container.$type}:${refInfo.property}`;\n    switch (referenceId) {\n      default: {\n        throw new Error(`${referenceId} is not a valid reference id.`);\n      }\n    }\n  }\n  getTypeMetaData(type) {\n    switch (type) {\n      case \"Architecture\": {\n        return {\n          name: \"Architecture\",\n          properties: [\n            { name: \"accDescr\" },\n            { name: \"accTitle\" },\n            { name: \"edges\", defaultValue: [] },\n            { name: \"groups\", defaultValue: [] },\n            { name: \"junctions\", defaultValue: [] },\n            { name: \"services\", defaultValue: [] },\n            { name: \"title\" }\n          ]\n        };\n      }\n      case \"Branch\": {\n        return {\n          name: \"Branch\",\n          properties: [\n            { name: \"name\" },\n            { name: \"order\" }\n          ]\n        };\n      }\n      case \"Checkout\": {\n        return {\n          name: \"Checkout\",\n          properties: [\n            { name: \"branch\" }\n          ]\n        };\n      }\n      case \"CherryPicking\": {\n        return {\n          name: \"CherryPicking\",\n          properties: [\n            { name: \"id\" },\n            { name: \"parent\" },\n            { name: \"tags\", defaultValue: [] }\n          ]\n        };\n      }\n      case \"Commit\": {\n        return {\n          name: \"Commit\",\n          properties: [\n            { name: \"id\" },\n            { name: \"message\" },\n            { name: \"tags\", defaultValue: [] },\n            { name: \"type\" }\n          ]\n        };\n      }\n      case \"Common\": {\n        return {\n          name: \"Common\",\n          properties: [\n            { name: \"accDescr\" },\n            { name: \"accTitle\" },\n            { name: \"title\" }\n          ]\n        };\n      }\n      case \"Edge\": {\n        return {\n          name: \"Edge\",\n          properties: [\n            { name: \"lhsDir\" },\n            { name: \"lhsGroup\", defaultValue: false },\n            { name: \"lhsId\" },\n            { name: \"lhsInto\", defaultValue: false },\n            { name: \"rhsDir\" },\n            { name: \"rhsGroup\", defaultValue: false },\n            { name: \"rhsId\" },\n            { name: \"rhsInto\", defaultValue: false },\n            { name: \"title\" }\n          ]\n        };\n      }\n      case \"GitGraph\": {\n        return {\n          name: \"GitGraph\",\n          properties: [\n            { name: \"accDescr\" },\n            { name: \"accTitle\" },\n            { name: \"statements\", defaultValue: [] },\n            { name: \"title\" }\n          ]\n        };\n      }\n      case \"Group\": {\n        return {\n          name: \"Group\",\n          properties: [\n            { name: \"icon\" },\n            { name: \"id\" },\n            { name: \"in\" },\n            { name: \"title\" }\n          ]\n        };\n      }\n      case \"Info\": {\n        return {\n          name: \"Info\",\n          properties: [\n            { name: \"accDescr\" },\n            { name: \"accTitle\" },\n            { name: \"title\" }\n          ]\n        };\n      }\n      case \"Junction\": {\n        return {\n          name: \"Junction\",\n          properties: [\n            { name: \"id\" },\n            { name: \"in\" }\n          ]\n        };\n      }\n      case \"Merge\": {\n        return {\n          name: \"Merge\",\n          properties: [\n            { name: \"branch\" },\n            { name: \"id\" },\n            { name: \"tags\", defaultValue: [] },\n            { name: \"type\" }\n          ]\n        };\n      }\n      case \"Packet\": {\n        return {\n          name: \"Packet\",\n          properties: [\n            { name: \"accDescr\" },\n            { name: \"accTitle\" },\n            { name: \"blocks\", defaultValue: [] },\n            { name: \"title\" }\n          ]\n        };\n      }\n      case \"PacketBlock\": {\n        return {\n          name: \"PacketBlock\",\n          properties: [\n            { name: \"end\" },\n            { name: \"label\" },\n            { name: \"start\" }\n          ]\n        };\n      }\n      case \"Pie\": {\n        return {\n          name: \"Pie\",\n          properties: [\n            { name: \"accDescr\" },\n            { name: \"accTitle\" },\n            { name: \"sections\", defaultValue: [] },\n            { name: \"showData\", defaultValue: false },\n            { name: \"title\" }\n          ]\n        };\n      }\n      case \"PieSection\": {\n        return {\n          name: \"PieSection\",\n          properties: [\n            { name: \"label\" },\n            { name: \"value\" }\n          ]\n        };\n      }\n      case \"Service\": {\n        return {\n          name: \"Service\",\n          properties: [\n            { name: \"icon\" },\n            { name: \"iconText\" },\n            { name: \"id\" },\n            { name: \"in\" },\n            { name: \"title\" }\n          ]\n        };\n      }\n      case \"Direction\": {\n        return {\n          name: \"Direction\",\n          properties: [\n            { name: \"accDescr\" },\n            { name: \"accTitle\" },\n            { name: \"dir\" },\n            { name: \"statements\", defaultValue: [] },\n            { name: \"title\" }\n          ]\n        };\n      }\n      default: {\n        return {\n          name: type,\n          properties: []\n        };\n      }\n    }\n  }\n};\nvar reflection = new MermaidAstReflection();\n\n// src/language/generated/grammar.ts\nimport { loadGrammarFromJson } from \"langium\";\nvar loadedInfoGrammar;\nvar InfoGrammar = /* @__PURE__ */ __name(() => loadedInfoGrammar ?? (loadedInfoGrammar = loadGrammarFromJson('{\"$type\":\"Grammar\",\"isDeclared\":true,\"name\":\"Info\",\"imports\":[],\"rules\":[{\"$type\":\"ParserRule\",\"name\":\"Info\",\"entry\":true,\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@3\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"Keyword\",\"value\":\"info\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@3\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"showInfo\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@3\"},\"arguments\":[],\"cardinality\":\"*\"}],\"cardinality\":\"?\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@1\"},\"arguments\":[],\"cardinality\":\"?\"}]},\"definesHiddenTokens\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"TitleAndAccessibilities\",\"fragment\":true,\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"accDescr\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@4\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"accTitle\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@5\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"title\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@6\"},\"arguments\":[]}}]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@2\"},\"arguments\":[]}],\"cardinality\":\"+\"},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"EOL\",\"fragment\":true,\"dataType\":\"string\",\"definition\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@3\"},\"arguments\":[],\"cardinality\":\"+\"},{\"$type\":\"EndOfFile\"}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"NEWLINE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\r?\\\\\\\\n/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_DESCR\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accDescr(?:[\\\\\\\\t ]*:([^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)|\\\\\\\\s*{([^}]*)})/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accTitle[\\\\\\\\t ]*:(?:[^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*title(?:[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*|)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"WHITESPACE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]+/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"YAML\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/---[\\\\\\\\t ]*\\\\\\\\r?\\\\\\\\n(?:[\\\\\\\\S\\\\\\\\s]*?\\\\\\\\r?\\\\\\\\n)?---(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"DIRECTIVE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%{[\\\\\\\\S\\\\\\\\s]*?}%%(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"SINGLE_LINE_COMMENT\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%[^\\\\\\\\n\\\\\\\\r]*/\"},\"fragment\":false}],\"definesHiddenTokens\":false,\"hiddenTokens\":[],\"interfaces\":[{\"$type\":\"Interface\",\"name\":\"Common\",\"attributes\":[{\"$type\":\"TypeAttribute\",\"name\":\"accDescr\",\"isOptional\":true,\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"}},{\"$type\":\"TypeAttribute\",\"name\":\"accTitle\",\"isOptional\":true,\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"}},{\"$type\":\"TypeAttribute\",\"name\":\"title\",\"isOptional\":true,\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"}}],\"superTypes\":[]}],\"types\":[],\"usedGrammars\":[]}')), \"InfoGrammar\");\nvar loadedPacketGrammar;\nvar PacketGrammar = /* @__PURE__ */ __name(() => loadedPacketGrammar ?? (loadedPacketGrammar = loadGrammarFromJson(`{\"$type\":\"Grammar\",\"isDeclared\":true,\"name\":\"Packet\",\"imports\":[],\"rules\":[{\"$type\":\"ParserRule\",\"name\":\"Packet\",\"entry\":true,\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@6\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"Keyword\",\"value\":\"packet-beta\"},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@6\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@4\"},\"arguments\":[]},{\"$type\":\"Assignment\",\"feature\":\"blocks\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@1\"},\"arguments\":[]},\"cardinality\":\"*\"}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@6\"},\"arguments\":[],\"cardinality\":\"+\"},{\"$type\":\"Assignment\",\"feature\":\"blocks\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@1\"},\"arguments\":[]},\"cardinality\":\"+\"}]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@6\"},\"arguments\":[],\"cardinality\":\"*\"}]}]},\"definesHiddenTokens\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"PacketBlock\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"start\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@2\"},\"arguments\":[]}},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"-\"},{\"$type\":\"Assignment\",\"feature\":\"end\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@2\"},\"arguments\":[]}}],\"cardinality\":\"?\"},{\"$type\":\"Keyword\",\"value\":\":\"},{\"$type\":\"Assignment\",\"feature\":\"label\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@3\"},\"arguments\":[]}},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@5\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"INT\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/0|[1-9][0-9]*/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"STRING\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\"[^\\\\\"]*\\\\\"|'[^']*'/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"ParserRule\",\"name\":\"TitleAndAccessibilities\",\"fragment\":true,\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"accDescr\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@7\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"accTitle\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@8\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"title\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@9\"},\"arguments\":[]}}]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@5\"},\"arguments\":[]}],\"cardinality\":\"+\"},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"EOL\",\"fragment\":true,\"dataType\":\"string\",\"definition\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@6\"},\"arguments\":[],\"cardinality\":\"+\"},{\"$type\":\"EndOfFile\"}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"NEWLINE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\r?\\\\\\\\n/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_DESCR\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accDescr(?:[\\\\\\\\t ]*:([^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)|\\\\\\\\s*{([^}]*)})/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accTitle[\\\\\\\\t ]*:(?:[^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*title(?:[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*|)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"WHITESPACE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]+/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"YAML\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/---[\\\\\\\\t ]*\\\\\\\\r?\\\\\\\\n(?:[\\\\\\\\S\\\\\\\\s]*?\\\\\\\\r?\\\\\\\\n)?---(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"DIRECTIVE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%{[\\\\\\\\S\\\\\\\\s]*?}%%(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"SINGLE_LINE_COMMENT\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%[^\\\\\\\\n\\\\\\\\r]*/\"},\"fragment\":false}],\"definesHiddenTokens\":false,\"hiddenTokens\":[],\"interfaces\":[{\"$type\":\"Interface\",\"name\":\"Common\",\"attributes\":[{\"$type\":\"TypeAttribute\",\"name\":\"accDescr\",\"isOptional\":true,\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"}},{\"$type\":\"TypeAttribute\",\"name\":\"accTitle\",\"isOptional\":true,\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"}},{\"$type\":\"TypeAttribute\",\"name\":\"title\",\"isOptional\":true,\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"}}],\"superTypes\":[]}],\"types\":[],\"usedGrammars\":[]}`)), \"PacketGrammar\");\nvar loadedPieGrammar;\nvar PieGrammar = /* @__PURE__ */ __name(() => loadedPieGrammar ?? (loadedPieGrammar = loadGrammarFromJson('{\"$type\":\"Grammar\",\"isDeclared\":true,\"name\":\"Pie\",\"imports\":[],\"rules\":[{\"$type\":\"ParserRule\",\"name\":\"Pie\",\"entry\":true,\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@6\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"Keyword\",\"value\":\"pie\"},{\"$type\":\"Assignment\",\"feature\":\"showData\",\"operator\":\"?=\",\"terminal\":{\"$type\":\"Keyword\",\"value\":\"showData\"},\"cardinality\":\"?\"},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@6\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@4\"},\"arguments\":[]},{\"$type\":\"Assignment\",\"feature\":\"sections\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@1\"},\"arguments\":[]},\"cardinality\":\"*\"}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@6\"},\"arguments\":[],\"cardinality\":\"+\"},{\"$type\":\"Assignment\",\"feature\":\"sections\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@1\"},\"arguments\":[]},\"cardinality\":\"+\"}]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@6\"},\"arguments\":[],\"cardinality\":\"*\"}]}]},\"definesHiddenTokens\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"PieSection\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"label\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@2\"},\"arguments\":[]}},{\"$type\":\"Keyword\",\"value\":\":\"},{\"$type\":\"Assignment\",\"feature\":\"value\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@3\"},\"arguments\":[]}},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@5\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"PIE_SECTION_LABEL\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\"[^\\\\\"]+\\\\\"/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"PIE_SECTION_VALUE\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/(0|[1-9][0-9]*)(\\\\\\\\.[0-9]+)?/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"ParserRule\",\"name\":\"TitleAndAccessibilities\",\"fragment\":true,\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"accDescr\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@7\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"accTitle\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@8\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"title\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@9\"},\"arguments\":[]}}]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@5\"},\"arguments\":[]}],\"cardinality\":\"+\"},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"EOL\",\"fragment\":true,\"dataType\":\"string\",\"definition\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@6\"},\"arguments\":[],\"cardinality\":\"+\"},{\"$type\":\"EndOfFile\"}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"NEWLINE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\r?\\\\\\\\n/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_DESCR\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accDescr(?:[\\\\\\\\t ]*:([^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)|\\\\\\\\s*{([^}]*)})/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accTitle[\\\\\\\\t ]*:(?:[^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*title(?:[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*|)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"WHITESPACE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]+/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"YAML\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/---[\\\\\\\\t ]*\\\\\\\\r?\\\\\\\\n(?:[\\\\\\\\S\\\\\\\\s]*?\\\\\\\\r?\\\\\\\\n)?---(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"DIRECTIVE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%{[\\\\\\\\S\\\\\\\\s]*?}%%(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"SINGLE_LINE_COMMENT\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%[^\\\\\\\\n\\\\\\\\r]*/\"},\"fragment\":false}],\"definesHiddenTokens\":false,\"hiddenTokens\":[],\"interfaces\":[{\"$type\":\"Interface\",\"name\":\"Common\",\"attributes\":[{\"$type\":\"TypeAttribute\",\"name\":\"accDescr\",\"isOptional\":true,\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"}},{\"$type\":\"TypeAttribute\",\"name\":\"accTitle\",\"isOptional\":true,\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"}},{\"$type\":\"TypeAttribute\",\"name\":\"title\",\"isOptional\":true,\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"}}],\"superTypes\":[]}],\"types\":[],\"usedGrammars\":[]}')), \"PieGrammar\");\nvar loadedArchitectureGrammar;\nvar ArchitectureGrammar = /* @__PURE__ */ __name(() => loadedArchitectureGrammar ?? (loadedArchitectureGrammar = loadGrammarFromJson('{\"$type\":\"Grammar\",\"isDeclared\":true,\"name\":\"Architecture\",\"imports\":[],\"rules\":[{\"$type\":\"ParserRule\",\"name\":\"Architecture\",\"entry\":true,\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@18\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"Keyword\",\"value\":\"architecture-beta\"},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@18\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@16\"},\"arguments\":[]}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@18\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@1\"},\"arguments\":[],\"cardinality\":\"*\"}]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@18\"},\"arguments\":[],\"cardinality\":\"*\"}]}]},\"definesHiddenTokens\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Statement\",\"fragment\":true,\"definition\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"groups\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@5\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"services\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@6\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"junctions\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@7\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"edges\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@8\"},\"arguments\":[]}}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"LeftPort\",\"fragment\":true,\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\":\"},{\"$type\":\"Assignment\",\"feature\":\"lhsDir\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@9\"},\"arguments\":[]}}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"RightPort\",\"fragment\":true,\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"rhsDir\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@9\"},\"arguments\":[]}},{\"$type\":\"Keyword\",\"value\":\":\"}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Arrow\",\"fragment\":true,\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@2\"},\"arguments\":[]},{\"$type\":\"Assignment\",\"feature\":\"lhsInto\",\"operator\":\"?=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@15\"},\"arguments\":[]},\"cardinality\":\"?\"},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"--\"},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"-\"},{\"$type\":\"Assignment\",\"feature\":\"title\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@13\"},\"arguments\":[]}},{\"$type\":\"Keyword\",\"value\":\"-\"}]}]},{\"$type\":\"Assignment\",\"feature\":\"rhsInto\",\"operator\":\"?=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@15\"},\"arguments\":[]},\"cardinality\":\"?\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@3\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Group\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"group\"},{\"$type\":\"Assignment\",\"feature\":\"id\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@10\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"icon\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@12\"},\"arguments\":[]},\"cardinality\":\"?\"},{\"$type\":\"Assignment\",\"feature\":\"title\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@13\"},\"arguments\":[]},\"cardinality\":\"?\"},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"in\"},{\"$type\":\"Assignment\",\"feature\":\"in\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@10\"},\"arguments\":[]}}],\"cardinality\":\"?\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Service\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"service\"},{\"$type\":\"Assignment\",\"feature\":\"id\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@10\"},\"arguments\":[]}},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"iconText\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@11\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"icon\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@12\"},\"arguments\":[]}}],\"cardinality\":\"?\"},{\"$type\":\"Assignment\",\"feature\":\"title\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@13\"},\"arguments\":[]},\"cardinality\":\"?\"},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"in\"},{\"$type\":\"Assignment\",\"feature\":\"in\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@10\"},\"arguments\":[]}}],\"cardinality\":\"?\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Junction\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"junction\"},{\"$type\":\"Assignment\",\"feature\":\"id\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@10\"},\"arguments\":[]}},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"in\"},{\"$type\":\"Assignment\",\"feature\":\"in\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@10\"},\"arguments\":[]}}],\"cardinality\":\"?\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Edge\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"lhsId\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@10\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"lhsGroup\",\"operator\":\"?=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@14\"},\"arguments\":[]},\"cardinality\":\"?\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@4\"},\"arguments\":[]},{\"$type\":\"Assignment\",\"feature\":\"rhsId\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@10\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"rhsGroup\",\"operator\":\"?=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@14\"},\"arguments\":[]},\"cardinality\":\"?\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"ARROW_DIRECTION\",\"definition\":{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"TerminalAlternatives\",\"elements\":[{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"L\"}},{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"R\"}}]},{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"T\"}}]},{\"$type\":\"CharacterRange\",\"left\":{\"$type\":\"Keyword\",\"value\":\"B\"}}]},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ARCH_ID\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\w]+/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ARCH_TEXT_ICON\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\(\\\\\"[^\\\\\"]+\\\\\"\\\\\\\\)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ARCH_ICON\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\([\\\\\\\\w-:]+\\\\\\\\)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ARCH_TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\[[\\\\\\\\w ]+\\\\\\\\]/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ARROW_GROUP\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\{group\\\\\\\\}/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ARROW_INTO\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/<|>/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"ParserRule\",\"name\":\"TitleAndAccessibilities\",\"fragment\":true,\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"accDescr\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@19\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"accTitle\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"title\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@21\"},\"arguments\":[]}}]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}],\"cardinality\":\"+\"},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"EOL\",\"fragment\":true,\"dataType\":\"string\",\"definition\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@18\"},\"arguments\":[],\"cardinality\":\"+\"},{\"$type\":\"EndOfFile\"}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"NEWLINE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\r?\\\\\\\\n/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_DESCR\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accDescr(?:[\\\\\\\\t ]*:([^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)|\\\\\\\\s*{([^}]*)})/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accTitle[\\\\\\\\t ]*:(?:[^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*title(?:[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*|)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"WHITESPACE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]+/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"YAML\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/---[\\\\\\\\t ]*\\\\\\\\r?\\\\\\\\n(?:[\\\\\\\\S\\\\\\\\s]*?\\\\\\\\r?\\\\\\\\n)?---(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"DIRECTIVE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%{[\\\\\\\\S\\\\\\\\s]*?}%%(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"SINGLE_LINE_COMMENT\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%[^\\\\\\\\n\\\\\\\\r]*/\"},\"fragment\":false}],\"definesHiddenTokens\":false,\"hiddenTokens\":[],\"interfaces\":[{\"$type\":\"Interface\",\"name\":\"Common\",\"attributes\":[{\"$type\":\"TypeAttribute\",\"name\":\"accDescr\",\"isOptional\":true,\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"}},{\"$type\":\"TypeAttribute\",\"name\":\"accTitle\",\"isOptional\":true,\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"}},{\"$type\":\"TypeAttribute\",\"name\":\"title\",\"isOptional\":true,\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"}}],\"superTypes\":[]}],\"types\":[],\"usedGrammars\":[]}')), \"ArchitectureGrammar\");\nvar loadedGitGraphGrammar;\nvar GitGraphGrammar = /* @__PURE__ */ __name(() => loadedGitGraphGrammar ?? (loadedGitGraphGrammar = loadGrammarFromJson(`{\"$type\":\"Grammar\",\"isDeclared\":true,\"name\":\"GitGraph\",\"interfaces\":[{\"$type\":\"Interface\",\"name\":\"Common\",\"attributes\":[{\"$type\":\"TypeAttribute\",\"name\":\"accDescr\",\"isOptional\":true,\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"}},{\"$type\":\"TypeAttribute\",\"name\":\"accTitle\",\"isOptional\":true,\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"}},{\"$type\":\"TypeAttribute\",\"name\":\"title\",\"isOptional\":true,\"type\":{\"$type\":\"SimpleType\",\"primitiveType\":\"string\"}}],\"superTypes\":[]}],\"rules\":[{\"$type\":\"ParserRule\",\"name\":\"TitleAndAccessibilities\",\"fragment\":true,\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Assignment\",\"feature\":\"accDescr\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@3\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"accTitle\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@4\"},\"arguments\":[]}},{\"$type\":\"Assignment\",\"feature\":\"title\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@5\"},\"arguments\":[]}}]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@1\"},\"arguments\":[]}],\"cardinality\":\"+\"},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"EOL\",\"fragment\":true,\"dataType\":\"string\",\"definition\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@2\"},\"arguments\":[],\"cardinality\":\"+\"},{\"$type\":\"EndOfFile\"}]},\"definesHiddenTokens\":false,\"entry\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"NEWLINE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\r?\\\\\\\\n/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_DESCR\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accDescr(?:[\\\\\\\\t ]*:([^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)|\\\\\\\\s*{([^}]*)})/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ACC_TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*accTitle[\\\\\\\\t ]*:(?:[^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[^\\\\\\\\n\\\\\\\\r]*)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"TITLE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*title(?:[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*?(?=%%)|[\\\\\\\\t ][^\\\\\\\\n\\\\\\\\r]*|)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"WHITESPACE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]+/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"YAML\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/---[\\\\\\\\t ]*\\\\\\\\r?\\\\\\\\n(?:[\\\\\\\\S\\\\\\\\s]*?\\\\\\\\r?\\\\\\\\n)?---(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"DIRECTIVE\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%{[\\\\\\\\S\\\\\\\\s]*?}%%(?:\\\\\\\\r?\\\\\\\\n|(?!\\\\\\\\S))/\"},\"fragment\":false},{\"$type\":\"TerminalRule\",\"hidden\":true,\"name\":\"SINGLE_LINE_COMMENT\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[\\\\\\\\t ]*%%[^\\\\\\\\n\\\\\\\\r]*/\"},\"fragment\":false},{\"$type\":\"ParserRule\",\"name\":\"GitGraph\",\"entry\":true,\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@2\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"gitGraph\"},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"gitGraph\"},{\"$type\":\"Keyword\",\"value\":\":\"}]},{\"$type\":\"Keyword\",\"value\":\"gitGraph:\"},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"gitGraph\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@12\"},\"arguments\":[]},{\"$type\":\"Keyword\",\"value\":\":\"}]}]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@2\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@2\"},\"arguments\":[],\"cardinality\":\"*\"},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@0\"},\"arguments\":[]},{\"$type\":\"Assignment\",\"feature\":\"statements\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@11\"},\"arguments\":[]}},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@2\"},\"arguments\":[]}],\"cardinality\":\"*\"}]}]},\"definesHiddenTokens\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Statement\",\"definition\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@13\"},\"arguments\":[]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@14\"},\"arguments\":[]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@15\"},\"arguments\":[]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@16\"},\"arguments\":[]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@17\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Direction\",\"definition\":{\"$type\":\"Assignment\",\"feature\":\"dir\",\"operator\":\"=\",\"terminal\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"LR\"},{\"$type\":\"Keyword\",\"value\":\"TB\"},{\"$type\":\"Keyword\",\"value\":\"BT\"}]}},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Commit\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"commit\"},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"id:\"},{\"$type\":\"Assignment\",\"feature\":\"id\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[]}}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"msg:\",\"cardinality\":\"?\"},{\"$type\":\"Assignment\",\"feature\":\"message\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[]}}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"tag:\"},{\"$type\":\"Assignment\",\"feature\":\"tags\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[]}}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"type:\"},{\"$type\":\"Assignment\",\"feature\":\"type\",\"operator\":\"=\",\"terminal\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"NORMAL\"},{\"$type\":\"Keyword\",\"value\":\"REVERSE\"},{\"$type\":\"Keyword\",\"value\":\"HIGHLIGHT\"}]}}]}],\"cardinality\":\"*\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@1\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Branch\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"branch\"},{\"$type\":\"Assignment\",\"feature\":\"name\",\"operator\":\"=\",\"terminal\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@19\"},\"arguments\":[]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[]}]}},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"order:\"},{\"$type\":\"Assignment\",\"feature\":\"order\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@18\"},\"arguments\":[]}}],\"cardinality\":\"?\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@1\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Merge\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"merge\"},{\"$type\":\"Assignment\",\"feature\":\"branch\",\"operator\":\"=\",\"terminal\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@19\"},\"arguments\":[]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[]}]}},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"id:\"},{\"$type\":\"Assignment\",\"feature\":\"id\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[]}}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"tag:\"},{\"$type\":\"Assignment\",\"feature\":\"tags\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[]}}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"type:\"},{\"$type\":\"Assignment\",\"feature\":\"type\",\"operator\":\"=\",\"terminal\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"NORMAL\"},{\"$type\":\"Keyword\",\"value\":\"REVERSE\"},{\"$type\":\"Keyword\",\"value\":\"HIGHLIGHT\"}]}}]}],\"cardinality\":\"*\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@1\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"Checkout\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"checkout\"},{\"$type\":\"Keyword\",\"value\":\"switch\"}]},{\"$type\":\"Assignment\",\"feature\":\"branch\",\"operator\":\"=\",\"terminal\":{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@19\"},\"arguments\":[]},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[]}]}},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@1\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"ParserRule\",\"name\":\"CherryPicking\",\"definition\":{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"cherry-pick\"},{\"$type\":\"Alternatives\",\"elements\":[{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"id:\"},{\"$type\":\"Assignment\",\"feature\":\"id\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[]}}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"tag:\"},{\"$type\":\"Assignment\",\"feature\":\"tags\",\"operator\":\"+=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[]}}]},{\"$type\":\"Group\",\"elements\":[{\"$type\":\"Keyword\",\"value\":\"parent:\"},{\"$type\":\"Assignment\",\"feature\":\"parent\",\"operator\":\"=\",\"terminal\":{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@20\"},\"arguments\":[]}}]}],\"cardinality\":\"*\"},{\"$type\":\"RuleCall\",\"rule\":{\"$ref\":\"#/rules@1\"},\"arguments\":[]}]},\"definesHiddenTokens\":false,\"entry\":false,\"fragment\":false,\"hiddenTokens\":[],\"parameters\":[],\"wildcard\":false},{\"$type\":\"TerminalRule\",\"name\":\"INT\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"number\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/[0-9]+(?=\\\\\\\\s)/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"ID\",\"type\":{\"$type\":\"ReturnType\",\"name\":\"string\"},\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\\\\w([-\\\\\\\\./\\\\\\\\w]*[-\\\\\\\\w])?/\"},\"fragment\":false,\"hidden\":false},{\"$type\":\"TerminalRule\",\"name\":\"STRING\",\"definition\":{\"$type\":\"RegexToken\",\"regex\":\"/\\\\\"[^\\\\\"]*\\\\\"|'[^']*'/\"},\"fragment\":false,\"hidden\":false}],\"definesHiddenTokens\":false,\"hiddenTokens\":[],\"imports\":[],\"types\":[],\"usedGrammars\":[]}`)), \"GitGraphGrammar\");\n\n// src/language/generated/module.ts\nvar InfoLanguageMetaData = {\n  languageId: \"info\",\n  fileExtensions: [\".mmd\", \".mermaid\"],\n  caseInsensitive: false\n};\nvar PacketLanguageMetaData = {\n  languageId: \"packet\",\n  fileExtensions: [\".mmd\", \".mermaid\"],\n  caseInsensitive: false\n};\nvar PieLanguageMetaData = {\n  languageId: \"pie\",\n  fileExtensions: [\".mmd\", \".mermaid\"],\n  caseInsensitive: false\n};\nvar ArchitectureLanguageMetaData = {\n  languageId: \"architecture\",\n  fileExtensions: [\".mmd\", \".mermaid\"],\n  caseInsensitive: false\n};\nvar GitGraphLanguageMetaData = {\n  languageId: \"gitGraph\",\n  fileExtensions: [\".mmd\", \".mermaid\"],\n  caseInsensitive: false\n};\nvar MermaidGeneratedSharedModule = {\n  AstReflection: /* @__PURE__ */ __name(() => new MermaidAstReflection(), \"AstReflection\")\n};\nvar InfoGeneratedModule = {\n  Grammar: /* @__PURE__ */ __name(() => InfoGrammar(), \"Grammar\"),\n  LanguageMetaData: /* @__PURE__ */ __name(() => InfoLanguageMetaData, \"LanguageMetaData\"),\n  parser: {}\n};\nvar PacketGeneratedModule = {\n  Grammar: /* @__PURE__ */ __name(() => PacketGrammar(), \"Grammar\"),\n  LanguageMetaData: /* @__PURE__ */ __name(() => PacketLanguageMetaData, \"LanguageMetaData\"),\n  parser: {}\n};\nvar PieGeneratedModule = {\n  Grammar: /* @__PURE__ */ __name(() => PieGrammar(), \"Grammar\"),\n  LanguageMetaData: /* @__PURE__ */ __name(() => PieLanguageMetaData, \"LanguageMetaData\"),\n  parser: {}\n};\nvar ArchitectureGeneratedModule = {\n  Grammar: /* @__PURE__ */ __name(() => ArchitectureGrammar(), \"Grammar\"),\n  LanguageMetaData: /* @__PURE__ */ __name(() => ArchitectureLanguageMetaData, \"LanguageMetaData\"),\n  parser: {}\n};\nvar GitGraphGeneratedModule = {\n  Grammar: /* @__PURE__ */ __name(() => GitGraphGrammar(), \"Grammar\"),\n  LanguageMetaData: /* @__PURE__ */ __name(() => GitGraphLanguageMetaData, \"LanguageMetaData\"),\n  parser: {}\n};\n\n// src/language/common/valueConverter.ts\nimport { DefaultValueConverter } from \"langium\";\n\n// src/language/common/matcher.ts\nvar accessibilityDescrRegex = /accDescr(?:[\\t ]*:([^\\n\\r]*)|\\s*{([^}]*)})/;\nvar accessibilityTitleRegex = /accTitle[\\t ]*:([^\\n\\r]*)/;\nvar titleRegex = /title([\\t ][^\\n\\r]*|)/;\n\n// src/language/common/valueConverter.ts\nvar rulesRegexes = {\n  ACC_DESCR: accessibilityDescrRegex,\n  ACC_TITLE: accessibilityTitleRegex,\n  TITLE: titleRegex\n};\nvar AbstractMermaidValueConverter = class extends DefaultValueConverter {\n  static {\n    __name(this, \"AbstractMermaidValueConverter\");\n  }\n  runConverter(rule, input, cstNode) {\n    let value = this.runCommonConverter(rule, input, cstNode);\n    if (value === void 0) {\n      value = this.runCustomConverter(rule, input, cstNode);\n    }\n    if (value === void 0) {\n      return super.runConverter(rule, input, cstNode);\n    }\n    return value;\n  }\n  runCommonConverter(rule, input, _cstNode) {\n    const regex = rulesRegexes[rule.name];\n    if (regex === void 0) {\n      return void 0;\n    }\n    const match = regex.exec(input);\n    if (match === null) {\n      return void 0;\n    }\n    if (match[1] !== void 0) {\n      return match[1].trim().replace(/[\\t ]{2,}/gm, \" \");\n    }\n    if (match[2] !== void 0) {\n      return match[2].replace(/^\\s*/gm, \"\").replace(/\\s+$/gm, \"\").replace(/[\\t ]{2,}/gm, \" \").replace(/[\\n\\r]{2,}/gm, \"\\n\");\n    }\n    return void 0;\n  }\n};\nvar CommonValueConverter = class extends AbstractMermaidValueConverter {\n  static {\n    __name(this, \"CommonValueConverter\");\n  }\n  runCustomConverter(_rule, _input, _cstNode) {\n    return void 0;\n  }\n};\n\n// src/language/common/tokenBuilder.ts\nimport { DefaultTokenBuilder } from \"langium\";\nvar AbstractMermaidTokenBuilder = class extends DefaultTokenBuilder {\n  static {\n    __name(this, \"AbstractMermaidTokenBuilder\");\n  }\n  constructor(keywords) {\n    super();\n    this.keywords = new Set(keywords);\n  }\n  buildKeywordTokens(rules, terminalTokens, options) {\n    const tokenTypes = super.buildKeywordTokens(rules, terminalTokens, options);\n    tokenTypes.forEach((tokenType) => {\n      if (this.keywords.has(tokenType.name) && tokenType.PATTERN !== void 0) {\n        tokenType.PATTERN = new RegExp(tokenType.PATTERN.toString() + \"(?:(?=%%)|(?!\\\\S))\");\n      }\n    });\n    return tokenTypes;\n  }\n};\nvar CommonTokenBuilder = class extends AbstractMermaidTokenBuilder {\n  static {\n    __name(this, \"CommonTokenBuilder\");\n  }\n};\n\nexport {\n  __name,\n  Statement,\n  Architecture,\n  isArchitecture,\n  Branch,\n  isBranch,\n  Commit,\n  isCommit,\n  isCommon,\n  GitGraph,\n  isGitGraph,\n  Info,\n  isInfo,\n  Merge,\n  isMerge,\n  Packet,\n  isPacket,\n  PacketBlock,\n  isPacketBlock,\n  Pie,\n  isPie,\n  PieSection,\n  isPieSection,\n  MermaidGeneratedSharedModule,\n  InfoGeneratedModule,\n  PacketGeneratedModule,\n  PieGeneratedModule,\n  ArchitectureGeneratedModule,\n  GitGraphGeneratedModule,\n  AbstractMermaidValueConverter,\n  CommonValueConverter,\n  AbstractMermaidTokenBuilder,\n  CommonTokenBuilder\n};\n","\"use strict\";\n/* --------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n * ------------------------------------------------------------------------------------------ */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nlet _ral;\nfunction RAL() {\n    if (_ral === undefined) {\n        throw new Error(`No runtime abstraction layer installed`);\n    }\n    return _ral;\n}\n(function (RAL) {\n    function install(ral) {\n        if (ral === undefined) {\n            throw new Error(`No runtime abstraction layer provided`);\n        }\n        _ral = ral;\n    }\n    RAL.install = install;\n})(RAL || (RAL = {}));\nexports.default = RAL;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.has` without support for deep paths.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {Array|string} key The key to check.\n * @returns {boolean} Returns `true` if `key` exists, else `false`.\n */\nfunction baseHas(object, key) {\n  return object != null && hasOwnProperty.call(object, key);\n}\n\nexport default baseHas;\n","import baseHas from './_baseHas.js';\nimport hasPath from './_hasPath.js';\n\n/**\n * Checks if `path` is a direct property of `object`.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n * @example\n *\n * var object = { 'a': { 'b': 2 } };\n * var other = _.create({ 'a': _.create({ 'b': 2 }) });\n *\n * _.has(object, 'a');\n * // => true\n *\n * _.has(object, 'a.b');\n * // => true\n *\n * _.has(object, ['a', 'b']);\n * // => true\n *\n * _.has(other, 'a');\n * // => false\n */\nfunction has(object, path) {\n  return object != null && hasPath(object, path, baseHas);\n}\n\nexport default has;\n","import baseGetTag from './_baseGetTag.js';\nimport isArray from './isArray.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar stringTag = '[object String]';\n\n/**\n * Checks if `value` is classified as a `String` primitive or object.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a string, else `false`.\n * @example\n *\n * _.isString('abc');\n * // => true\n *\n * _.isString(1);\n * // => false\n */\nfunction isString(value) {\n  return typeof value == 'string' ||\n    (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);\n}\n\nexport default isString;\n","\"use strict\";\n/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.CancellationTokenSource = exports.CancellationToken = void 0;\nconst ral_1 = require(\"./ral\");\nconst Is = require(\"./is\");\nconst events_1 = require(\"./events\");\nvar CancellationToken;\n(function (CancellationToken) {\n    CancellationToken.None = Object.freeze({\n        isCancellationRequested: false,\n        onCancellationRequested: events_1.Event.None\n    });\n    CancellationToken.Cancelled = Object.freeze({\n        isCancellationRequested: true,\n        onCancellationRequested: events_1.Event.None\n    });\n    function is(value) {\n        const candidate = value;\n        return candidate && (candidate === CancellationToken.None\n            || candidate === CancellationToken.Cancelled\n            || (Is.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested));\n    }\n    CancellationToken.is = is;\n})(CancellationToken || (exports.CancellationToken = CancellationToken = {}));\nconst shortcutEvent = Object.freeze(function (callback, context) {\n    const handle = (0, ral_1.default)().timer.setTimeout(callback.bind(context), 0);\n    return { dispose() { handle.dispose(); } };\n});\nclass MutableToken {\n    constructor() {\n        this._isCancelled = false;\n    }\n    cancel() {\n        if (!this._isCancelled) {\n            this._isCancelled = true;\n            if (this._emitter) {\n                this._emitter.fire(undefined);\n                this.dispose();\n            }\n        }\n    }\n    get isCancellationRequested() {\n        return this._isCancelled;\n    }\n    get onCancellationRequested() {\n        if (this._isCancelled) {\n            return shortcutEvent;\n        }\n        if (!this._emitter) {\n            this._emitter = new events_1.Emitter();\n        }\n        return this._emitter.event;\n    }\n    dispose() {\n        if (this._emitter) {\n            this._emitter.dispose();\n            this._emitter = undefined;\n        }\n    }\n}\nclass CancellationTokenSource {\n    get token() {\n        if (!this._token) {\n            // be lazy and create the token only when\n            // actually needed\n            this._token = new MutableToken();\n        }\n        return this._token;\n    }\n    cancel() {\n        if (!this._token) {\n            // save an object by returning the default\n            // cancelled token when cancellation happens\n            // before someone asks for the token\n            this._token = CancellationToken.Cancelled;\n        }\n        else {\n            this._token.cancel();\n        }\n    }\n    dispose() {\n        if (!this._token) {\n            // ensure to initialize with an empty token if we had none\n            this._token = CancellationToken.None;\n        }\n        else if (this._token instanceof MutableToken) {\n            // actually dispose\n            this._token.dispose();\n        }\n    }\n}\nexports.CancellationTokenSource = CancellationTokenSource;\n","import {\n  AbstractMermaidTokenBuilder,\n  AbstractMermaidValueConverter,\n  ArchitectureGeneratedModule,\n  MermaidGeneratedSharedModule,\n  __name\n} from \"./chunk-Y27MQZ3U.mjs\";\n\n// src/language/architecture/module.ts\nimport {\n  EmptyFileSystem,\n  createDefaultCoreModule,\n  createDefaultSharedCoreModule,\n  inject\n} from \"langium\";\n\n// src/language/architecture/tokenBuilder.ts\nvar ArchitectureTokenBuilder = class extends AbstractMermaidTokenBuilder {\n  static {\n    __name(this, \"ArchitectureTokenBuilder\");\n  }\n  constructor() {\n    super([\"architecture\"]);\n  }\n};\n\n// src/language/architecture/valueConverter.ts\nvar ArchitectureValueConverter = class extends AbstractMermaidValueConverter {\n  static {\n    __name(this, \"ArchitectureValueConverter\");\n  }\n  runCustomConverter(rule, input, _cstNode) {\n    if (rule.name === \"ARCH_ICON\") {\n      return input.replace(/[()]/g, \"\").trim();\n    } else if (rule.name === \"ARCH_TEXT_ICON\") {\n      return input.replace(/[\"()]/g, \"\");\n    } else if (rule.name === \"ARCH_TITLE\") {\n      return input.replace(/[[\\]]/g, \"\").trim();\n    }\n    return void 0;\n  }\n};\n\n// src/language/architecture/module.ts\nvar ArchitectureModule = {\n  parser: {\n    TokenBuilder: /* @__PURE__ */ __name(() => new ArchitectureTokenBuilder(), \"TokenBuilder\"),\n    ValueConverter: /* @__PURE__ */ __name(() => new ArchitectureValueConverter(), \"ValueConverter\")\n  }\n};\nfunction createArchitectureServices(context = EmptyFileSystem) {\n  const shared = inject(\n    createDefaultSharedCoreModule(context),\n    MermaidGeneratedSharedModule\n  );\n  const Architecture = inject(\n    createDefaultCoreModule({ shared }),\n    ArchitectureGeneratedModule,\n    ArchitectureModule\n  );\n  shared.ServiceRegistry.register(Architecture);\n  return { shared, Architecture };\n}\n__name(createArchitectureServices, \"createArchitectureServices\");\n\nexport {\n  ArchitectureModule,\n  createArchitectureServices\n};\n"],"names":["value","nativeMax","Math","max","findIndexFunc","array","predicate","fromIndex","length","index","toInteger","collection","iterable","Object","isArrayLike","iteratee","keys","key","undefined","PacketTokenBuilder","this","constructor","super","PacketModule","parser","TokenBuilder","ValueConverter","createPacketServices","context","shared","Packet","ServiceRegistry","register","comparator","current","computed","result","Array","defineProperty","exports","Emitter","Event","ral_1","_disposable","dispose","None","CallbackList","add","callback","bucket","_callbacks","_contexts","push","isArray","remove","foundCallbackWithDifferentContext","i","len","splice","Error","invoke","args","ret","callbacks","slice","contexts","apply","e","default","console","error","isEmpty","_options","event","_event","listener","thisArgs","disposables","onFirstListenerAdd","_noop","onLastListenerRemove","fire","call","GitGraphTokenBuilder","GitGraphModule","createGitGraphServices","GitGraph","objectProto","prototype","hasOwnProperty","object","sources","guard","source","props","propsIndex","propsLength","reWhitespace","reTrimStart","string","test","charAt","replace","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","INFINITY","isSymbol","isObject","other","valueOf","isBinary","obj","$type","$refText","isLinkingError","container","reference","message","AbstractAstReflection","subtypes","allSubtypes","isInstance","node","type","isSubtype","subtype","supertype","nested","existing","computeIsSubtype","getAllSubTypes","allTypes","getAllTypes","types","possibleSubType","content","tokenType","isRootCstNode","fullText","StreamImpl","startFn","nextFn","iterator","state","next","Symbol","Boolean","done","count","toArray","toSet","Set","toMap","keyFn","valueFn","entryStream","map","element","Map","toString","join","concat","first","firstDone","DONE_RESULT","separator","addSeparator","item","indexOf","searchElement","every","some","forEach","callbackfn","filter","nonNullable","reduce","initialValue","previousValue","reduceRight","recursiveReduce","find","findIndex","includes","flatMap","mapped","isIterable","flat","depth","stream","head","tail","skipCount","limit","maxSize","size","distinct","by","set","has","exclude","otherKeySet","ownKey","EMPTY_STREAM","freeze","collections","collIndex","arrIndex","TreeStreamImpl","root","children","options","iterators","includeRoot","pruned","pop","prune","Reduction","RangeComparison","streamCst","tokenToRange","token","start","character","startColumn","line","startLine","end","endColumn","endLine","toDocumentSegment","offset","range","sum","a","b","product","min","DefaultNameRegexp","isCommentNode","cstNode","commentNames","name","ErrorWithLocation","assertUnreachable","_","AbstractRule","AbstractType","Condition","ValueLiteral","AbstractElement","BooleanLiteral","Conjunction","Disjunction","InferredType","isInferredType","reflection","Interface","isInterface","Negation","ParameterReference","ParserRule","isParserRule","ReturnType","SimpleType","TerminalRule","isTerminalRule","Type","isType","Action","isAction","Alternatives","isAlternatives","Assignment","isAssignment","CharacterRange","CrossReference","isCrossReference","EndOfFile","Group","isGroup","Keyword","isKeyword","NegatedToken","RegexToken","RuleCall","isRuleCall","TerminalAlternatives","TerminalGroup","TerminalRuleCall","isTerminalRuleCall","UnorderedGroup","isUnorderedGroup","UntilToken","Wildcard","LangiumGrammarAstReflection","getReferenceType","refInfo","referenceId","property","getTypeMetaData","properties","defaultValue","getContainerOfType","typePredicate","$container","getDocument","rootNode","findRootNode","$document","streamContents","keyIndex","arrayIndex","startsWith","isAstNodeInRange","streamAst","astNode","_a","nodeRange","$cstNode","to","comparison","Before","After","startInside","endInside","Inside","OverlapBack","OverlapFront","compareRange","inRange","streamReferences","copyDefaultValue","propertyType","cc","char","charCodeAt","insertToSet","subItem","addFlag","flagObj","flagKey","ASSERT_EXISTS","ASSERT_NEVER_REACH_HERE","isCharacter","digitsCharCodes","wordCharCodes","whitespaceCodes","hexDigitPattern","decimalPattern","decimalPatternNoZero","RegExpParser","idx","input","groupIdx","saveState","restoreState","newState","pattern","consumeChar","disjunction","flags","loc","begin","global","ignoreCase","multiLine","unicode","sticky","isRegExpFlag","popChar","substring","alts","alternative","peekChar","terms","isTerm","term","isAssertion","assertion","atom","quantifier","isBacktracking","atLeast","atMost","Infinity","integerIncludingZero","isDigit","greedy","dotAll","atomEscape","characterClass","group","isPatternCharacter","patternCharacter","isQuantifier","complement","decimalEscapeAtom","characterClassEscape","controlEscapeAtom","controlLetterEscapeAtom","nulCharacterAtom","hexEscapeSequenceAtom","regExpUnicodeEscapeSequenceAtom","identityEscapeAtom","positiveInteger","escapeCode","letter","toUpperCase","parseHexDigits","classPatternCharacterAtom","isClassAtom","from","classAtom","isRangeDash","classEscape","capturing","groupAst","number","nextChar","howMuch","isAtom","prevState","howMany","hexString","hexChar","BaseRegExpVisitor","visitChildren","child","visit","subChild","visitPattern","visitFlags","visitDisjunction","visitAlternative","visitStartAnchor","visitEndAnchor","visitWordBoundary","visitNonWordBoundary","visitLookahead","visitNegativeLookahead","visitCharacter","visitSet","visitGroup","visitGroupBackReference","visitQuantifier","NEWLINE_REGEXP","regexpParser","visitor","arguments","isStarting","endRegexpStack","multiline","endRegex","reset","regex","startRegexp","String","fromCharCode","escapedChar","escapeRegExp","RegExp","match","isMultilineComment","regexp","isWhitespace","getAllReachableRules","grammar","allTerminals","ruleNames","entryRule","rules","entry","getEntryRule","topMostRules","hidden","getHiddenRules","rule","ruleDfs","visitedSet","refRule","ref","findNodeForProperty","nodes","findNodesForPropertyInternal","nodeFeature","grammarSource","feature","findNameAssignment","startNode","findNameAssignmentInternal","cache","go","refType","childAssignment","get","toLowerCase","typeRef","isDataTypeRule","isDataTypeRuleInternal","visited","definition","getExplicitRuleType","inferredType","dataType","returnType","getTypeName","actionType","action","getActionType","terminalRegex","terminalRule","s","u","abstractElementToRegex","flagText","entries","WILDCARD","withCardinality","alternatives","elements","cardinality","lookahead","right","keywordToRegex","left","wrap","negate","until","terminal","lastSlash","lastIndexOf","regexFlags","keyword","toFastProperties","toBecomeFast","FakeConstructor","fakeInstance","fakeAccess","bar","n","prop","path","nodeIsRegExp","isRegExp","isObjectLike","AbstractProduction","_definition","accept","prod","v","referencedRule","Rule","orgText","Alternative","ignoreAmbiguities","Option","RepetitionMandatory","RepetitionMandatoryWithSeparator","Repetition","RepetitionWithSeparator","Alternation","hasPredicates","Terminal","serializeProduction","convertDefinition","serializedNonTerminal","nonTerminalName","isString","label","terminalType","serializedTerminal","tokType","LABEL","terminalLabel","PATTERN","nodeAny","visitNonTerminal","visitOption","visitRepetitionMandatory","visitRepetitionMandatoryWithSeparator","visitRepetitionWithSeparator","visitRepetition","visitAlternation","visitTerminal","visitRule","func","isOptionalProd","alreadyVisited","subProd","getProductionDslName","RestWalker","walk","prevRest","currRest","walkProdRef","walkTerminal","walkFlat","walkOption","walkAtLeastOne","walkAtLeastOneSep","walkManySep","walkMany","walkOr","refProd","flatProd","fullOrRest","optionProd","atLeastOneProd","fullAtLeastOneRest","atLeastOneSepProd","fullAtLeastOneSepRest","restForRepetitionWithSeparator","manyProd","fullManyRest","manySepProd","fullManySepRest","orProd","alt","prodWrapper","repSepProd","isSequenceProd","firstSet","seq","currSubProd","nextSubProdIdx","hasInnerProdsRemaining","isLastInnerProdOptional","firstForSequence","isBranchingProd","allAlternativesFirsts","innerProd","firstForBranching","ResyncFollowsWalker","topProd","follows","startWalking","followName","inner","occurenceInParent","fullRest","t_in_topProd_follows","TypeError","values","isArrayLikeObject","isCommon","valuesLength","outer","valuesIndex","resIndex","PRINT_ERROR","msg","PRINT_WARNING","warn","regExpAstCache","regExpParser","getRegExpAst","regExp","regExpStr","regExpAst","complementErrorMessage","failedOptimizationPrefixMsg","getOptimizedStartCodesIndices","ensureOptimizations","ast","firstCharOptimizedIndices","msgSuffix","addOptimizedIdxToResult","code","rangeCode","minOptimizationVal","minUnOptVal","maxUnOptVal","minOptIdx","charCodeToOptimizedIndex","maxOptIdx","currOptIdx","isOptionalQuantifier","isWholeOptional","optimizedCharIdx","upperChar","lowerChar","handleIgnoreCase","findCode","setNode","targetCharCodes","codeOrRange","targetCode","CharCodeFinder","found","canMatchCharCode","charCodes","charCodeFinder","DEFAULT_MODE","MODES","SUPPORT_STICKY","end_of_input","start_of_input","addStartOfInput","addStickyFlag","isCustomPattern","isFunction","isShortPattern","LineTerminatorOptimizedTester","text","lastIndex","c","checkLineBreaksIssues","lineTerminatorCharCodes","issue","LexerDefinitionErrorType","IDENTIFY_TERMINATOR","errMsg","CUSTOM_LINE_BREAK","getCharCodes","charsOrCodes","numOrString","addToMapOfArrays","charCodeToOptimizedIdxMap","charCode","timer","Date","getTime","val","time","tokenStructuredMatcher","tokInstance","tokConstructor","instanceType","tokenTypeIdx","isParent","categoryMatchesMap","tokenStructuredMatcherNoCategories","tokenShortNameIdx","tokenIdxToClass","augmentTokenTypes","tokenTypes","tokenTypesAndParents","clone","categories","searching","currTokType","CATEGORIES","newCategories","expandCategories","hasShortKeyProperty","hasCategoriesProperty","categoryMatches","hasExtendingTokensTypesMapProperty","assignTokenDefaultProps","singleAssignCategoriesToksMap","assignCategoriesMapProp","assignCategoriesTokensProp","nextNode","pathNode","nextCategory","newPath","isTokenType","DEFAULT_LEXER_CONFIG","deferDefinitionErrorsHandling","positionTracking","lineTerminatorsPattern","lineTerminatorCharacters","safeMode","errorMessageProvider","buildUnableToPopLexerModeMessage","image","buildUnexpectedCharactersMessage","startOffset","column","traceInitPerf","skipValidations","recoveryEnabled","Lexer","lexerDefinition","config","lexerDefinitionErrors","lexerDefinitionWarning","patternIdxToConfig","charCodeToPatternIdxToConfig","modes","emptyGroups","trackStartLines","trackEndLines","hasCustom","canModeBeOptimized","TRACE_INIT","phaseDesc","phaseImpl","traceInitIndent","indent","traceInitMaxIdent","log","traceMethod","traceInitVal","actualDefinition","hasOnlySingleMode","defaultMode","errors","MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE","MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY","MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST","currModeValue","currModeName","currIdx","isUndefined","LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED","longerAlt","LONGER_ALT","currLongerAlt","MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE","performRuntimeChecks","trackLines","warnings","hasAnyLineBreak","allTokenTypes","concreteTokenTypes","currType","NA","terminatorCharCodes","currIssue","details","buildLineBreakIssueMessage","warningDescriptor","LINE_BREAKS","NO_LINE_BREAKS_FLAGS","performWarningRuntimeChecks","allModeNames","currModDef","currModName","validModesNames","missingResult","tokenTypesWithMissingPattern","MISSING_PATTERN","valid","findMissingPatterns","invalidResult","tokenTypesWithInvalidPattern","INVALID_PATTERN","findInvalidPatterns","validTokenTypes","withRegExpPatterns","EndAnchorFinder","invalidRegex","regexpAst","endAnchorVisitor","EOI_ANCHOR_FOUND","findEndOfInputAnchor","StartAnchorFinder","startAnchorVisitor","SOI_ANCHOR_FOUND","findStartOfInputAnchor","invalidFlags","UNSUPPORTED_FLAGS_FOUND","findUnsupportedFlags","identicalPatterns","outerType","innerType","duplicatePatterns","currIdenticalSet","setOfIdentical","tokenTypeNames","DUPLICATE_PATTERNS_FOUND","findDuplicatePatterns","matchesEmptyString","EMPTY_MATCH_PATTERN","findEmptyMatchRegExps","validateRegExpPattern","invalidTypes","clazz","GROUP","SKIPPED","INVALID_GROUP_TYPE_FOUND","findInvalidGroupType","validModes","invalidModes","PUSH_MODE","PUSH_MODE_DOES_NOT_EXIST","findModesThatDoNotExist","canBeTested","str","testIdx","regExpArray","exec","testTokenType","UNREACHABLE_PATTERN","findUnreachablePatterns","validatePatterns","currAnalyzeResult","tracer","defaults","useSticky","debug","onlyRelevantTypes","initCharCodeToOptimizedIndexMap","allTransformedPatterns","patternIdxToType","patternIdxToGroup","patternIdxToLongerAltIdxArr","patternIdxToPushMode","patternIdxToPopMode","patternIdxToCanLineTerminator","patternIdxToIsCustom","patternIdxToShort","currPattern","regExpSource","escapedRegExpString","wrappedRegExp","groupName","longerAltType","acc","x","canLineTerminator","isCustom","short","canBeOptimized","optimizedIdx","START_CHARS_HINT","lastOptimizedIdx","charOrInt","currOptimizedIdx","optimizedCodes","analyzeTokenTypes","allErrMessagesString","chopInput","identity","matchWithTest","updateLastIndex","noop","matchWithExec","handleModes","computeNewColumn","updateTokenEndLineColumnLocation","createTokenInstance","createFullToken","createStartOnlyToken","createOffsetOnlyToken","addToken","addTokenUsingPush","handlePayload","handlePayloadWithCustom","addTokenUsingMemberAccess","handlePayloadNoCustom","unOptimizedModes","cannotBeOptimized","modeName","tokenize","initialMode","tokenizeInternal","j","k","matchAltImage","matchedImage","payload","altPayload","imageLength","newToken","errLength","orgLength","matchedTokensIndex","guessedNumberOfTokens","floor","matchedTokens","groups","clonedResult","groupKeys","currKey","currGroupValue","cloneEmptyGroups","lineTerminatorPattern","currModePatternsLength","currCharCodeToPatternIdxToConfig","modeStack","emptyArray","getPossiblePatterns","getPossiblePatternsSlow","getPossiblePatternsOptimized","possiblePatterns","pop_mode","popToken","newMode","last","modeCanBeOptimized","push_mode","currConfig","nextCharCode","chosenPatternIdxToConfig","chosenPatternsLength","singleCharCode","longerAltLength","longerAltConfig","longerAltPattern","foundTerminator","lastLTEndOffset","numOfLTsInMatch","errorStartOffset","errorLine","errorColumn","foundResyncPoint","tokens","pushMode","newLastIndex","lastLTIdx","lastCharIsLT","fixForEndingInLT","oldColumn","endOffset","tokenVector","tokenToAdd","POP_MODE","createToken","createTokenInternal","EOF","tokenMatcher","defaultParserErrorProvider","buildMismatchTokenMessage","expected","actual","previous","ruleName","buildNotAllInputParsedMessage","firstRedundant","buildNoViableAltMessage","expectedPathsPerAlt","customUserDescription","errPrefix","errSuffix","allLookAheadPaths","currAltPaths","nextValidTokenSequences","currPath","currTokenType","itemMsg","buildEarlyExitMessage","expectedIterationPaths","defaultGrammarResolverErrorProvider","buildRuleNotFoundError","topLevelRule","undefinedRule","defaultGrammarValidatorErrorProvider","buildDuplicateFoundError","duplicateProds","topLevelName","duplicateProd","dslName","extraArgument","buildNamespaceConflictError","buildAlternationPrefixAmbiguityError","pathMsg","prefixPath","currTok","occurrence","alternation","ambiguityIndices","buildAlternationAmbiguityError","currtok","currMessage","buildEmptyRepetitionError","repetition","buildTokenNameError","buildEmptyAlternationError","emptyChoiceIdx","buildTooManyAlternativesError","buildLeftRecursionError","leftRecursionPath","currRule","buildInvalidRuleNameError","buildDuplicateRuleNameError","grammarName","GastRefResolverVisitor","nameToTopRule","errMsgProvider","resolveRefs","currTopLevel","ParserDefinitionErrorType","UNRESOLVED_SUBRULE_REF","unresolvedRefName","setter","accumulator","initializer","AbstractNextPossibleTokensWalker","possibleTokTypes","nextProductionName","nextProductionOccurrence","isAtEndOfPath","ruleStack","reverse","occurrenceStack","updateExpectedNext","NextAfterTokenWalker","nextTerminalName","nextTerminalOccurrence","lastTok","lastTokOccurrence","restProd","AbstractNextTerminalAfterProductionWalker","topRule","isEndOfRule","NextTerminalAfterManyWalker","firstAfterMany","NextTerminalAfterManySepWalker","firstAfterManySep","NextTerminalAfterAtLeastOneWalker","firstAfterAtLeastOne","NextTerminalAfterAtLeastOneSepWalker","atleastOneSepProd","firstAfterfirstAfterAtLeastOneSep","possiblePathsFrom","targetDef","maxLength","getAlternativesForProd","newDef","currAlt","partialPath","suffixDef","nextPossibleTokensAfter","initialDef","tokMatcher","maxLookAhead","EXIT_NON_TERMINAL","EXIT_NON_TERMINAL_ARR","EXIT_ALTERNATIVE","foundCompletePath","tokenVectorLength","minimalAlternativesIndex","possiblePaths","def","currDef","currRuleStack","currOccurrenceStack","nextPath","nextIdx","nextTokenType","nextTokenOccurrence","newRuleStack","newOccurrenceStack","nextPathWithout","nextPathWith","secondIteration","separatorGast","nthRepetition","currAltPath","expandTopLevelRule","newCurrOccurrenceStack","PROD_TYPE","getProdType","OPTION","REPETITION","REPETITION_MANDATORY","REPETITION_MANDATORY_WITH_SEPARATOR","REPETITION_WITH_SEPARATOR","ALTERNATION","getLookaheadPaths","prodType","maxLookahead","getLookaheadPathsForOr","getLookaheadPathsForOptionalProd","buildAlternativesLookAheadFunc","dynamicTokensEnabled","numOfAlts","areAllOneTokenLookahead","orAlts","predicates","GATE","t","currNumOfPaths","currPredicate","currPathLength","nextToken","LA","singleTokenAlts","choiceToAlt","currExtendingType","buildSingleAlternativeLookaheadFunction","numOfPaths","singleTokensTypes","expectedTokenUniqueKey","RestDefinitionFinderWalker","targetOccurrence","targetProdType","restDef","checkIsTarget","expectedProdType","InsideDefinitionFinderVisitor","targetRef","expectedProdName","initializeArrayOfArrays","pathToHashKeys","longerKeys","currShorterKey","categoriesKeySuffix","isUniquePrefixHash","altKnownPathsKeys","searchPathKeys","currAltIdx","otherAltKnownPathsKeys","searchIdx","lookAheadSequenceFromAlternatives","altsDefs","partialAlts","finalResult","altsHashes","dict","newData","pathLength","currDataset","altIdx","currAltPathsAndSuffixes","currPathIdx","currPathPrefix","prefixKeys","currAltResult","containsPath","newPartialPathsAndSuffixes","ruleGrammar","insideDefVisitor","insideDef","afterDef","searchPath","compareOtherPath","otherPath","searchTok","otherTok","areTokenCategoriesNotUsed","lookAheadPaths","singleAltPaths","singlePath","identifyProductionForDuplicates","getExtraProductionArgument","OccurrenceValidationCollector","allProductions","subrule","option","manySep","atLeastOne","atLeastOneSep","many","or","validateNoLeftRecursion","nextNonTerminals","getFirstNoneTerminal","LEFT_RECURSION","validNextSteps","errorsFromNextSteps","currRefRule","firstProd","currSubDef","isFirstOptional","hasMore","rest","OrCollector","alternations","RepetitionCollector","MISMATCHED_TOKEN_EXCEPTION","NO_VIABLE_ALT_EXCEPTION","EARLY_EXIT_EXCEPTION","NOT_ALL_INPUT_PARSED_EXCEPTION","RECOGNITION_EXCEPTION_NAMES","isRecognitionException","RecognitionException","resyncedTokens","setPrototypeOf","captureStackTrace","MismatchedTokenException","previousToken","NoViableAltException","NotAllInputParsedException","EarlyExitException","EOF_FOLLOW_KEY","IN_RULE_RECOVERY_EXCEPTION","InRuleRecoveryException","attemptInRepetitionRecovery","prodFunc","lookaheadFunc","dslMethodIdx","prodOccurrence","nextToksWalker","notStuck","getKeyForAutomaticLookahead","firstAfterRepInfo","firstAfterRepMap","currRuleName","getCurrRuleFullName","getGAstProductions","expectTokAfterLastMatch","nextTokIdx","RULE_STACK","shouldInRepetitionRecoveryBeTried","tryInRepetitionRecovery","AT_LEAST_ONE_IDX","MANY_SEP_IDX","AT_LEAST_ONE_SEP_IDX","ruleIdx","LLkLookaheadStrategy","DEFAULT_PARSER_CONFIG","validate","leftRecursionErrors","emptyAltErrors","validateEmptyOrAlternatives","ambiguousAltsErrors","validateAmbiguousAlternationAlternatives","emptyRepetitionErrors","validateSomeNonEmptyLookaheadPath","currTopRule","orCollector","ors","currOr","exceptLast","currAlternative","possibleFirstInAlt","NONE_LAST_EMPTY_ALT","validateEmptyOrAlternative","globalMaxLookahead","currOccurrence","actualMaxLookahead","altsAmbiguityErrors","foundAmbiguousPaths","identicalAmbiguities","altsCurrPathAppearsIn","currOtherAlt","currOtherAltIdx","currAmbDescriptor","ambgIndices","AMBIGUOUS_ALTS","checkAlternativesAmbiguities","altsPrefixAmbiguityErrors","pathsAndIndices","currPathsAndIdx","currPathAndIdx","targetIdx","targetPath","prefixAmbiguitiesPathsAndIndices","searchPathAndIdx","prefix","otherTokType","currAmbPathAndIdx","AMBIGUOUS_PREFIX_ALTS","checkPrefixAlternativesAmbiguities","topLevelRules","collectorVisitor","allRuleProductions","currProd","pathsInsideProduction","NO_NON_EMPTY_LOOKAHEAD","buildLookaheadForAlternation","laFuncBuilder","buildLookaheadFuncForOr","buildLookaheadForOptional","lookaheadBuilder","buildLookaheadFuncForOptionalProd","dslMethods","repetitionWithSeparator","repetitionMandatory","repetitionMandatoryWithSeparator","setNodeLocationOnlyOffset","currNodeLocation","newLocationInfo","isNaN","setNodeLocationFull","defineNameProp","nameValue","enumerable","configurable","writable","defaultVisit","ctx","param","childrenNames","childrenNamesLength","currChildArray","currChildArrayLength","currChild","CstVisitorDefinitionError","RECORDING_NULL_OBJECT","description","HANDLE_SEPARATOR","MAX_METHOD_IDX","pow","RFT","RECORDING_PHASE_TOKEN","RECORDING_PHASE_CSTNODE","recordProd","prodConstructor","mainProdArg","handleSep","assertMethodIdxIsValid","prevProd","recordingProdStack","grammarAction","DEF","newProd","SEP","MAX_LOOKAHEAD","recordOrProd","hasOptions","newOrProd","IGNORE_AMBIGUITIES","currAltFlat","ALT","getIdxSuffix","KNOWN_RECORDER_ERROR","END_OF_FILE","NaN","outputCst","nodeLocationTracking","DEFAULT_RULE_CONFIG","recoveryValueFunc","resyncEnabled","derivedCtor","baseCtors","EMPTY_ALT","Parser","performSelfAnalysis","parserInstance","defErrorsMsgs","selfAnalysisDone","className","enableRecording","definedRulesNames","originalGrammarAction","recordedRuleGast","topLevelRuleRecord","gastProductionsCache","disableRecording","resolverErrors","actualOptions","topRulesTable","topLevels","refResolver","definitionErrors","validationErrors","tokensMap","duplicateErrors","productionGroups","duplicates","currGroup","currDuplicates","defError","DUPLICATE_PRODUCTIONS","parameter","validateDuplicateProductions","termsNamespaceConflictErrors","tokenNames","currToken","CONFLICT_TOKENS_RULES_NAMESPACE","checkTerminalAndNoneTerminalsNameSpace","tooManyAltsErrors","curRule","TOO_MANY_ALTS","validateTooManyAlts","duplicateRulesError","allRules","occurrences","DUPLICATE_RULE_NAME","validateRuleDoesNotAlreadyExist","lookaheadValidationErrors","lookaheadValidationErrorMessages","lookaheadStrategy","errorMessage","assign","CUSTOM_LOOKAHEAD_VALIDATION","validateLookahead","allFollows","topProductions","reSyncFollows","currRefsFollow","computeAllProdsFollows","resyncFollows","_b","initialize","preComputeLookaheadFunctions","DEFER_DEFINITION_ERRORS_HANDLING","tokenVocabulary","that","initErrorHandler","initLexerAdapter","initLooksAhead","initRecognizerEngine","initRecoverable","initTreeBuilder","initContentAssist","initGastRecorder","initPerformanceTracer","getTokenToInsert","tokToInsert","isInsertedInRecovery","canTokenTypeBeInsertedInRecovery","canTokenTypeBeDeletedInRecovery","grammarRule","grammarRuleArgs","lookAheadFunc","expectedTokType","reSyncTokType","findReSyncTokenType","savedLexerState","exportLexerState","passedResyncPoint","nextTokenWithoutResync","generateErrorMessage","SAVE_ERROR","SKIP_TOKEN","addToResyncTokens","importLexerState","isBackTracking","canPerformInRuleRecovery","getFollowsForInRuleRecovery","tokIdxInRule","grammarPath","getCurrentGrammarPath","getNextPossibleTokenTypes","tryInRuleRecovery","canRecoverWithSingleTokenInsertion","canRecoverWithSingleTokenDeletion","nextTok","consumeToken","expectedToken","mismatchedTok","possibleFollowsTokType","isInCurrentRuleReSyncSet","followKey","getCurrFollowKey","currentRuleReSyncSet","getFollowSetFromFollowKey","allPossibleReSyncTokTypes","flattenFollowSet","foundMatch","resyncTokType","currRuleShortName","getLastExplicitRuleShortName","currRuleIdx","getLastExplicitRuleOccurrenceIndex","prevRuleShortName","getPreviousExplicitRuleShortName","shortRuleNameToFullName","idxInCallingRule","inRule","buildFullFollowKeyStack","explicitRuleStack","explicitOccurrenceStack","RULE_OCCURRENCE_STACK","followStack","resyncTokens","reSyncTo","getHumanReadableRuleStack","currShortName","lookAheadFuncsCache","collectMethods","prodIdx","laFunc","fullRuleNameToShort","setLaFuncCache","computeLookaheadFunc","prodKey","prodMaxLookahead","dslMethodName","getLaFuncFromCache","CST_STACK","setNodeLocationFromToken","setNodeLocationFromNode","cstPostRule","setInitialNodeLocation","setInitialNodeLocationFullRecovery","cstPostRuleFull","setInitialNodeLocationFullRegular","setInitialNodeLocationOnlyOffsetRecovery","cstPostRuleOnlyOffset","setInitialNodeLocationOnlyOffsetRegular","cstInvocationStateUpdate","cstFinallyStateUpdate","cstPostTerminal","cstPostNonTerminal","location","fullRuleName","create","ruleCstNode","prevToken","consumedToken","rootCst","tokenTypeName","ruleCstResult","preCstNode","ruleResult","addNoneTerminalToCst","getBaseCstVisitorConstructor","baseCstVisitorConstructor","newBaseCstVisitorConstructor","derivedConstructor","semanticProto","validateVisitor","semanticDefinitionErrors","visitorInstance","missingErrors","missingRuleNames","MISSING_METHOD","methodName","validateMissingCstMethods","errorMessages","currDefError","_RULE_NAMES","createBaseSemanticVisitorConstructor","getBaseCstVisitorConstructorWithDefaults","baseCstVisitorWithDefaultsConstructor","newConstructor","baseConstructor","withDefaultsProto","createBaseVisitorConstructorWithDefaults","tokVector","tokVectorLength","newInput","soughtIdx","resetLexerState","moveToTerminatedState","getLexerPosition","shortRuleNameToFull","ruleShortNameIdx","subruleIdx","isBackTrackingStack","uniqueTokens","noTokenCategoriesUsed","tokenConstructor","defineRule","impl","shortName","invokeRuleWithTry","ruleInvocationStateUpdate","cst","invokeRuleCatch","ruleFinallyStateUpdate","resyncEnabledConfig","isFirstInvokedRule","reSyncEnabled","recogError","partialCstResult","recoveredNode","optionInternal","actionORMethodDef","optionInternalLogic","orgLookaheadFunction","atLeastOneInternal","laKey","atLeastOneInternalLogic","raiseEarlyExitException","ERR_MSG","doSingleRepetition","atLeastOneSepFirstInternal","atLeastOneSepFirstInternalLogic","separatorLookAheadFunc","CONSUME","repetitionSepSecondInternal","manyInternal","manyInternalLogic","lookaheadFunction","manySepFirstInternal","manySepFirstInternalLogic","nextTerminalAfterWalker","beforeIteration","orInternal","altsOrOpts","altIdxToTake","raiseNoAltException","isAtEndOfInput","firstRedundantTok","subruleInternal","ruleToCall","ARGS","subruleInternalError","consumeInternal","consumeInternalError","eFromConsumption","consumeInternalRecovery","eFromInRuleRecovery","saveRecogState","savedErrors","savedRuleStack","lexerState","reloadRecogState","fullName","ACTION","consume","CONSUME1","CONSUME2","CONSUME3","CONSUME4","CONSUME5","CONSUME6","CONSUME7","CONSUME8","CONSUME9","SUBRULE","SUBRULE1","SUBRULE2","SUBRULE3","SUBRULE4","SUBRULE5","SUBRULE6","SUBRULE7","SUBRULE8","SUBRULE9","OPTION1","OPTION2","OPTION3","OPTION4","OPTION5","OPTION6","OPTION7","OPTION8","OPTION9","OR","OR1","OR2","OR3","OR4","OR5","OR6","OR7","OR8","OR9","MANY","MANY1","MANY2","MANY3","MANY4","MANY5","MANY6","MANY7","MANY8","MANY9","MANY_SEP","MANY_SEP1","MANY_SEP2","MANY_SEP3","MANY_SEP4","MANY_SEP5","MANY_SEP6","MANY_SEP7","MANY_SEP8","MANY_SEP9","AT_LEAST_ONE","AT_LEAST_ONE1","AT_LEAST_ONE2","AT_LEAST_ONE3","AT_LEAST_ONE4","AT_LEAST_ONE5","AT_LEAST_ONE6","AT_LEAST_ONE7","AT_LEAST_ONE8","AT_LEAST_ONE9","AT_LEAST_ONE_SEP","AT_LEAST_ONE_SEP1","AT_LEAST_ONE_SEP2","AT_LEAST_ONE_SEP3","AT_LEAST_ONE_SEP4","AT_LEAST_ONE_SEP5","AT_LEAST_ONE_SEP6","AT_LEAST_ONE_SEP7","AT_LEAST_ONE_SEP8","AT_LEAST_ONE_SEP9","RULE","implementation","ruleImplementation","OVERRIDE_RULE","ruleErrors","INVALID_RULE_OVERRIDE","validateRuleIsOverridden","BACKTRACK","orgState","getSerializedGastProductions","topRules","_errors","ruleOccurrenceStack","newErrors","userDefinedErrMsg","insideProdPaths","actualTokens","errMsgTypes","lookAheadPathsPerAlternative","computeContentAssist","startRuleName","precedingInput","startRuleGast","topRuleName","topProduction","RECORDING_PHASE","arg1","arg2","consumeInternalRecord","subruleInternalRecord","optionInternalRecord","orInternalRecord","manyInternalRecord","manySepFirstInternalRecord","atLeastOneInternalRecord","atLeastOneSepFirstInternalRecord","ACTION_RECORD","BACKTRACK_RECORD","LA_RECORD","newTopLevelRule","originalError","mutabilityError","JSON","stringify","newNoneTerminal","userTraceInitPerf","traceIsNumber","baseCtor","baseProto","getOwnPropertyNames","propName","basePropDescriptor","getOwnPropertyDescriptor","EmbeddedActionsParser","configClone","buildATNKey","AbstractTransition","target","isEpsilon","AtomTransition","EpsilonTransition","RuleTransition","ruleStart","followState","atn","production","tokenRef","currentRule","nonTerminal","ruleToStartState","addTransition","ruleRef","defineDecisionState","makeAlts","optional","handle","epsilon","decisionMap","block","starState","star","repetitionSep","plusState","plus","repetitionMandatorySep","handles","altsLength","transition","transitions","isRuleTransition","ruleTransition","removeState","makeBlock","sep","blkStart","blkEnd","loop","loopback","loopEnd","decisionStates","decision","buildRuleHandle","stop","ruleToStopState","partial","epsilonOnlyTransitions","nextTokenWithinRule","stateNumber","states","DFA_ERROR","ATNConfigSet","configs","finalize","getATNConfigKey","stack","createDFACache","startState","predicateSet","atnStartState","PredicateSet","is","EMPTY_PREDICATES","LLStarLookaheadStrategy","logging","ruleLength","createRuleStartAndStopATNStates","ruleBlock","createATN","dfas","decisionLength","decisionToDFA","initATNSimulator","decisionIndex","isLL1Sequence","prediction","gate","adaptivePredict","g","sequences","allowEmpty","fullSet","altSet","indices","dfaCaches","dfa","addDFAState","newDFAState","atnState","numberOfTransitions","closure","computeStartState","performLookahead","s0","previousD","d","edges","computeLookaheadTarget","buildAdaptivePredictError","isAcceptState","reach","intermediate","skippedStopStates","transitionLength","getReachableTarget","hasConfigInRuleStopState","computeReachSet","addDFAEdge","predictedAlt","getUniqueAlt","uniqueAlt","allConfigsInRuleStopStates","altSets","configToAlts","getConflictingAltSets","hasConflictingAltSet","hasStateAssociatedWithOneAlt","hasConflictTerminatingPrediction","reportLookaheadAmbiguity","buildAmbiguityError","nextTransitions","actualToken","possibleTokenTypes","tokenPath","mapKey","p","atnStack","getEpsilonTarget","DocumentUri","URI","integer","uinteger","Position","Range","Location","LocationLink","Color","ColorInformation","ColorPresentation","FoldingRangeKind","FoldingRange","DiagnosticRelatedInformation","DiagnosticSeverity","DiagnosticTag","CodeDescription","Diagnostic","Command","TextEdit","ChangeAnnotation","ChangeAnnotationIdentifier","AnnotatedTextEdit","TextDocumentEdit","CreateFile","RenameFile","DeleteFile","WorkspaceEdit","TextDocumentIdentifier","VersionedTextDocumentIdentifier","OptionalVersionedTextDocumentIdentifier","TextDocumentItem","MarkupKind","MarkupContent","CompletionItemKind","InsertTextFormat","CompletionItemTag","InsertReplaceEdit","InsertTextMode","CompletionItemLabelDetails","CompletionItem","CompletionList","MarkedString","Hover","ParameterInformation","SignatureInformation","DocumentHighlightKind","DocumentHighlight","SymbolKind","SymbolTag","SymbolInformation","WorkspaceSymbol","DocumentSymbol","CodeActionKind","CodeActionTriggerKind","CodeActionContext","CodeAction","CodeLens","FormattingOptions","DocumentLink","SelectionRange","SemanticTokenTypes","SemanticTokenModifiers","SemanticTokens","InlineValueText","InlineValueVariableLookup","InlineValueEvaluatableExpression","InlineValueContext","InlayHintKind","InlayHintLabelPart","InlayHint","StringValue","InlineCompletionItem","InlineCompletionList","InlineCompletionTriggerKind","SelectedCompletionInfo","InlineCompletionContext","WorkspaceFolder","TextDocument","Is","MIN_VALUE","MAX_VALUE","Number","candidate","objectLiteral","one","two","three","four","uri","targetUri","targetRange","targetSelectionRange","originSelectionRange","red","green","blue","alpha","numberRange","color","textEdit","additionalTextEdits","typedArray","Comment","Imports","Region","startCharacter","endCharacter","kind","collapsedText","defined","Warning","Information","Hint","Unnecessary","Deprecated","href","severity","relatedInformation","codeDescription","title","command","newText","insert","position","del","needsConfirmation","boolean","annotation","annotationId","textDocument","edits","overwrite","ignoreIfExists","oldUri","newUri","recursive","ignoreIfNotExists","changes","documentChanges","change","version","languageId","PlainText","Markdown","Text","Method","Function","Constructor","Field","Variable","Class","Module","Property","Unit","Value","Enum","Snippet","File","Reference","Folder","EnumMember","Constant","Struct","Operator","TypeParameter","asIs","adjustIndentation","detail","items","isIncomplete","fromPlainText","plainText","language","contents","documentation","parameters","Read","Write","Namespace","Package","Key","Null","containerName","selectionRange","deprecated","tags","Empty","QuickFix","Refactor","RefactorExtract","RefactorInline","RefactorRewrite","Source","SourceOrganizeImports","SourceFixAll","Invoked","Automatic","diagnostics","only","triggerKind","kindOrCommandOrEdit","checkKind","edit","isPreferred","data","tabSize","insertSpaces","parent","resultId","variableName","caseSensitiveLookup","expression","frameId","stoppedLocation","Parameter","tooltip","textEdits","paddingLeft","paddingRight","createSnippet","insertText","filterText","selectedCompletionInfo","mergeSort","compare","leftIdx","rightIdx","FullTextDocument","lineCount","getText","positionAt","offsetAt","applyEdits","document","sortedEdits","diff","lastModifiedOffset","_uri","_languageId","_version","_content","_lineOffsets","update","getLineOffsets","lineOffsets","isLineStart","ch","low","high","mid","lineOffset","nextLineOffset","check","CstNodeBuilder","nodeStack","buildRootNode","RootCstNodeImpl","buildCompositeNode","compositeNode","CompositeCstNodeImpl","buildLeafNode","leafNode","LeafCstNodeImpl","removeNode","construct","addHiddenTokens","hiddenTokens","hiddenNode","addHiddenToken","tokenStart","tokenEnd","childStart","childEnd","AbstractCstNode","_astNode","_offset","_length","_hidden","_tokenType","_range","CstNodeContainer","firstNonHiddenNode","lastNonHiddenNode","firstNode","lastNode","_rangeCache","firstRange","lastRange","addParents","unshift","_text","DatatypeSymbol","isDataTypeNode","withRuleSuffix","endsWith","AbstractLangiumParser","services","_unorderedGroups","lexer","wrapper","ChevrotainWrapper","ParserConfig","ParserErrorMessageProvider","choices","wrapOr","wrapOption","wrapMany","wrapAtLeastOne","isRecording","IS_RECORDING","unorderedGroups","getRuleStack","wrapSelfAnalysis","LangiumParser","nodeBuilder","assignmentMap","linker","references","Linker","converter","astReflection","AstReflection","fragment","ruleMethod","DEFINE_RULE","startImplementation","bind","mainRule","parse","lexerResult","clear","lexerErrors","parserErrors","err","wrapConsume","isValidToken","assignment","isCrossRef","getAssignment","convertedValue","convert","operator","subruleResult","wrapSubrule","performSubruleAssignment","resultKind","assignWithoutOverride","newItem","$containerProperty","$containerIndex","linkContentToContainer","typeMetaData","genericNode","assignMandatoryProperties","buildReference","existingValue","newValue","AbstractParserErrorMessageProvider","LangiumParserErrorMessageProvider","LangiumCompletionParser","elementStack","lastElementStack","nextTokenIndex","stackSize","resetState","tokenIndex","keepStackSize","resetStackSize","removeUnexpectedElements","before","after","defaultConfig","useDefaultLookahead","createParser","parserContext","reachable","parserRules","buildElement","buildRules","ignoreGuard","method","buildKeyword","buildAction","buildCrossReference","ruleCall","namedArgs","buildPredicate","ruleArgs","ruleTarget","buildRuleCallPredicate","getRule","getToken","buildRuleCall","methods","predicatedMethod","getGuardCondition","buildAlternatives","orIdx","idFunc","lParser","wrapped","groupState","trackedAlternatives","delete","buildUnorderedGroup","buildGroup","condition","isConjunction","isNegation","isParameterReference","isBooleanLiteral","true","guardCondition","crossRef","assignTerminal","getRuleName","DefaultTokenBuilder","buildTokens","reachableRules","terminalTokens","buildTerminalTokens","buildKeywordTokens","terminalToken","buildTerminalToken","requiresCustomPattern","regexPatternFunction","stickyRegex","sort","buildKeywordToken","caseInsensitive","buildKeywordPattern","findLongerAlt","getCaseInsensitivePattern","longerAlts","re","process","tmp","appendRaw","nbChars","substr","appendOptional","partialRegExp","partialMatches","DefaultValueConverter","nameAssigment","getCrossReferenceTerminal","runConverter","convertInt","convertString","convertID","_c","getRuleType","convertNumber","convertBoolean","convertBigint","convertDate","convertEscapeCharacter","BigInt","lastTick","isOperationCancelled","async","interruptAndCheck","now","Promise","resolve","setImmediate","setTimeout","isCancellationRequested","promise","reject","arg","isIncremental","getWellformedRange","addedLineOffsets","computeLineOffsets","isFull","ensureBeforeEOL","isEOL","rangeLength","isAtLineStart","textOffset","getWellformedEdit","spans","LIB","r","o","h","cwd","normalize","isAbsolute","relative","f","l","_makeLong","dirname","basename","extname","format","dir","base","ext","delimiter","win32","posix","toStringTag","Utils","P","platform","navigator","userAgent","scheme","authority","query","isUri","fsPath","with","m","C","file","y","toJSON","revive","_formatted","external","_fsPath","_sep","$mid","encodeURIComponent","decodeURIComponent","A","w","joinPath","resolvePath","UriUtils","DocumentState","ValidationCategory","DocumentValidator","Disposable","equals","fromPath","toPath","fromParts","split","toParts","repeat","DefaultLangiumDocumentFactory","serviceRegistry","textDocuments","workspace","TextDocuments","fileSystemProvider","FileSystemProvider","fromUri","cancellationToken","readFile","createAsync","fromTextDocument","fromString","fromModel","model","$model","parseResult","createLangiumDocument","cancelToken","parseAsync","Parsed","textDocumentGetter","createTextDocumentGetter","oldText","getServices","AsyncParser","textDoc","LanguageMetaData","DefaultLangiumDocuments","documentMap","langiumDocumentFactory","LangiumDocumentFactory","all","addDocument","uriString","getOrCreateDocument","createDocument","then","hasDocument","invalidateDocument","langiumDoc","Changed","precomputedScopes","deleteDocument","DefaultLinker","langiumDocuments","LangiumDocuments","scopeProvider","ScopeProvider","astNodeLocator","AstNodeLocator","link","doLink","_ref","getCandidate","_nodeDescription","documentUri","linkedNode","loadAstNode","createLinkingError","unlink","getScope","getElement","refNode","refText","$refNode","refData","getLinkedNode","ComputedScopes","descr","$nodeDescription","nodeDescription","doc","getAstNode","targetDescription","referenceType","DefaultNameProvider","getName","isNamed","getNameNode","DefaultReferences","nameProvider","NameProvider","IndexManager","nodeLocator","findDeclaration","sourceCstNode","findAssignment","nodeElem","nameNode","isChildNode","findDeclarationNode","targetNode","findReferences","refs","includeDeclaration","getReferenceToSelf","indexReferences","findAllReferences","getAstNodePath","sourceUri","sourcePath","segment","local","MultiMap","addAll","entriesGroupedByKey","BiMap","inverse","getKey","DefaultScopeComputation","descriptions","AstNodeDescriptionProvider","computeExports","computeExportsForNode","parentNode","exportNode","createDescription","computeLocalScopes","scopes","processNode","StreamScope","outerScope","getAllElements","MapScope","localName","elementStream","DisposableCache","toDispose","isDisposed","onDispose","disposable","throwIfDisposed","SimpleCache","provider","ContextCache","contextKey","cacheForContext","contextCache","documentCache","WorkspaceCache","sharedServices","DocumentBuilder","onUpdate","DefaultScopeProvider","indexManager","globalScopeCache","precomputed","currentNode","allDescriptions","desc","getGlobalScope","createScope","createScopeForNodes","_context","allElements","isIntermediateReference","DefaultJsonSerializer","ignoreProperties","commentProvider","CommentProvider","serialize","specificReplacer","replacer","defaultReplacer","currentDocument","space","deserialize","linkNode","sourceText","textRegions","comments","uriConverter","_d","refValue","targetDocument","$ref","$error","addAstNodeRegionWithAssignmentsTo","$textRegion","documentURI","$sourceText","comment","getComment","$comment","createDocumentSegment","assignments","propertyAssignments","findNodesForProperty","containerProperty","containerIndex","propertyName","reviveReference","mutable","getRefNode","fragmentIndex","DefaultServiceRegistry","singleton","fileExtensions","diagnosticData","ValidationRegistry","checksRecord","thisObj","category","wrapValidationException","addEntry","getChecks","checks","DefaultDocumentValidator","validationRegistry","validation","metadata","validateDocument","processLexingErrors","stopAfterLexingErrors","LexingError","processParsingErrors","stopAfterParsingErrors","ParsingError","processLinkingErrors","stopAfterLinkingErrors","LinkingError","validateAst","lexerError","diagnostic","toDiagnosticSeverity","getSource","parserError","linkingError","info","containerType","toDiagnostic","validationItems","acceptor","getDiagnosticRange","treeIterator","keywordNodes","childNode","findNodesForKeywordInternal","findNodeForKeyword","DefaultAstNodeDescriptionProvider","nameNodeSegment","nameSegmentGetter","nameSegment","selectionSegment","DefaultReferenceDescriptionProvider","createDescriptions","targetNodeDescr","refCstNode","docUri","DefaultAstNodeLocator","segmentSeparator","indexSeparator","containerPath","newSegment","getPathSegment","currentValue","propertyIndex","DefaultConfigurationProvider","_ready","settings","workspaceConfig","ready","params","capabilities","configuration","initialized","languages","section","lang","toSectionName","fetchConfiguration","configToUpdate","conf","updateSectionConfiguration","updateConfiguration","getConfiguration","sectionName","DefaultDocumentBuilder","updateBuildOptions","updateListeners","buildPhaseListeners","buildState","documentBuildWaiters","currentState","build","documents","Validated","IndexedReferences","previousCategories","validationChecks","completed","emitUpdate","buildDocuments","changed","deleted","deletedUri","changedUri","newDocument","allChangedUris","shouldRelink","rebuildDocuments","Linked","changedUris","isAffected","prepareBuild","runCancelable","IndexedContent","updateContent","scopeComputation","ScopeComputation","updateReferences","toBeValidated","shouldValidate","targetState","filtered","notifyBuildPhase","onBuildPhase","waitUntil","uriOrToken","buildDisposable","cancelDisposable","onCancellationRequested","listeners","getBuildOptions","validator","validationSetting","DefaultIndexManager","symbolIndex","symbolByTypeIndex","referenceIndex","astNodePath","targetDocUri","docRefs","refDescr","nodeType","uris","documentUris","getFileDescriptions","indexData","ReferenceDescriptionProvider","DefaultWorkspaceManager","initialBuildOptions","documentBuilder","mutex","WorkspaceLock","folders","workspaceFolders","_params","write","initializeWorkspace","performStartup","collector","loadAdditionalDocuments","wf","getRootFolder","traverseFolder","_folders","_collector","workspaceFolder","folderPath","readDirectory","includeEntry","isDirectory","isFile","_workspaceFolder","DefaultLexer","Grammar","toTokenTypeDictionary","lexerTokens","isTokenTypeDictionary","chevrotainLexer","chevrotainResult","isIMultiModeLexerDefinition","res","isTokenTypeArray","getLines","tagRegex","inlineTagRegex","buildInlineTokens","lineIndex","characterIndex","matchIndex","startContent","tagName","endContent","nonWhitespaceRegex","whitespaceEndRegex","skipWhitespace","lastCharacter","parseJSDocElement","parseJSDocTag","parseJSDocText","JSDocLineImpl","inlines","appendEmptyLine","firstToken","lastToken","lines","parseJSDocInline","JSDocTextImpl","parseJSDocLine","inline","tagToken","docLine","JSDocTagImpl","normalizeOptions","normalizeOption","escaped","JSDocCommentImpl","getTag","getAllTags","getTags","fillNewlines","trim","toMarkdown","renderTag","toMarkdownDefault","rendered","tag","display","displayStart","renderedLink","renderLink","renderLinkDefault","renderInlineTag","marker","JSDocDocumentationProvider","getDocumentation","normalizedOptions","isJSDoc","firstRegex","lastRegex","opts","currentLine","currentCharacter","tagMatch","fullMatch","inlineTagMatches","matchAll","startPosition","parseJSDocComment","parseJSDoc","documentationLinkRenderer","documentationTagRenderer","findNameInPrecomputedScopes","findNameInGlobalScope","_node","_tag","DefaultCommentProvider","grammarConfig","GrammarConfig","isAstNodeWithComment","getPreviousNode","findCommentNode","multilineCommentRules","DefaultAsyncParser","syncParser","DefaultWorkspaceLock","previousTokenSource","writeQueue","readQueue","cancelWrite","tokenSource","enqueue","read","queue","deferred","performNextOperation","shift","cancel","DefaultHydrator","grammarElementIdMap","tokenTypeIdMap","dehydrate","dehydrateAstNode","createDehyrationContext","astNodes","cstNodes","dehydrateCstNode","arr","dehydrateReference","getGrammarElementId","hydrate","createHydrationContext","hydrateCstNode","hydrateAstNode","hydrateCstLeafNode","setParent","hydrateReference","num","cstNodeObj","getGrammarElement","hydrated","getTokenType","createGrammarElementIdMap","id","createDefaultCoreModule","DocumentationProvider","nameRegexp","createGrammarConfig","prepareLangiumParser","createLangiumParser","CompletionParser","createCompletionParser","References","serializer","Hydrator","JsonSerializer","createDefaultSharedCoreModule","WorkspaceManager","ConfigurationProvider","inject","module1","module2","module3","module4","module5","module6","module7","module8","module9","_inject","_merge","merge","m1","m2","isProxy","module","injector","proxy","Proxy","deleteProperty","_resolve","ownKeys","Reflect","__requested__","cause","value2","value1","EmptyFileSystemProvider","EmptyFileSystem","minimalGrammarModule","minimalSharedGrammarModule","loadGrammarFromJson","json","createMinimalGrammarServices","customizer","objValue","paths","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","clearTimeout","currentQueue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","run","runClearTimeout","Item","nextTick","browser","env","argv","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","binding","chdir","umask","InfoTokenBuilder","InfoModule","createInfoServices","Info","stringArray","elem","remainder","PieTokenBuilder","PieValueConverter","runCustomConverter","_cstNode","PieModule","createPieServices","Pie","parsers","initializers","createInfoServices2","packet","createPacketServices2","pie","createPieServices2","architecture","createArchitectureServices","createArchitectureServices2","Architecture","gitGraph","createGitGraphServices2","diagramType","MermaidParseError","__defProp","__name","Branch","Commit","Merge","loadedInfoGrammar","loadedPacketGrammar","loadedPieGrammar","loadedArchitectureGrammar","loadedGitGraphGrammar","MermaidAstReflection","InfoGrammar","PacketGrammar","PieGrammar","ArchitectureGrammar","GitGraphGrammar","InfoLanguageMetaData","PacketLanguageMetaData","PieLanguageMetaData","ArchitectureLanguageMetaData","GitGraphLanguageMetaData","MermaidGeneratedSharedModule","InfoGeneratedModule","PacketGeneratedModule","PieGeneratedModule","ArchitectureGeneratedModule","GitGraphGeneratedModule","rulesRegexes","ACC_DESCR","ACC_TITLE","TITLE","AbstractMermaidValueConverter","runCommonConverter","CommonValueConverter","_rule","_input","AbstractMermaidTokenBuilder","keywords","_ral","RAL","install","ral","events_1","CancellationToken","Cancelled","shortcutEvent","MutableToken","_isCancelled","_emitter","_token","ArchitectureTokenBuilder","ArchitectureValueConverter","ArchitectureModule"],"sourceRoot":""}