Erster Docker-Stand

_node_modules/@chevrotain/gast/LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

_node_modules/@chevrotain/gast/lib/src/api.d.ts

@@ -0,0 +1,3 @@
+export { Rule, Terminal, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Alternation, Alternative, serializeGrammar, serializeProduction } from "./model";
+export { GAstVisitor } from "./visitor";
+export { getProductionDslName, isOptionalProd, isBranchingProd, isSequenceProd } from "./helpers";

_node_modules/@chevrotain/gast/lib/src/api.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSequenceProd = exports.isBranchingProd = exports.isOptionalProd = exports.getProductionDslName = exports.GAstVisitor = exports.serializeProduction = exports.serializeGrammar = exports.Alternative = exports.Alternation = exports.RepetitionWithSeparator = exports.RepetitionMandatoryWithSeparator = exports.RepetitionMandatory = exports.Repetition = exports.Option = exports.NonTerminal = exports.Terminal = exports.Rule = void 0;
+var model_1 = require("./model");
+Object.defineProperty(exports, "Rule", { enumerable: true, get: function () { return model_1.Rule; } });
+Object.defineProperty(exports, "Terminal", { enumerable: true, get: function () { return model_1.Terminal; } });
+Object.defineProperty(exports, "NonTerminal", { enumerable: true, get: function () { return model_1.NonTerminal; } });
+Object.defineProperty(exports, "Option", { enumerable: true, get: function () { return model_1.Option; } });
+Object.defineProperty(exports, "Repetition", { enumerable: true, get: function () { return model_1.Repetition; } });
+Object.defineProperty(exports, "RepetitionMandatory", { enumerable: true, get: function () { return model_1.RepetitionMandatory; } });
+Object.defineProperty(exports, "RepetitionMandatoryWithSeparator", { enumerable: true, get: function () { return model_1.RepetitionMandatoryWithSeparator; } });
+Object.defineProperty(exports, "RepetitionWithSeparator", { enumerable: true, get: function () { return model_1.RepetitionWithSeparator; } });
+Object.defineProperty(exports, "Alternation", { enumerable: true, get: function () { return model_1.Alternation; } });
+Object.defineProperty(exports, "Alternative", { enumerable: true, get: function () { return model_1.Alternative; } });
+Object.defineProperty(exports, "serializeGrammar", { enumerable: true, get: function () { return model_1.serializeGrammar; } });
+Object.defineProperty(exports, "serializeProduction", { enumerable: true, get: function () { return model_1.serializeProduction; } });
+var visitor_1 = require("./visitor");
+Object.defineProperty(exports, "GAstVisitor", { enumerable: true, get: function () { return visitor_1.GAstVisitor; } });
+var helpers_1 = require("./helpers");
+Object.defineProperty(exports, "getProductionDslName", { enumerable: true, get: function () { return helpers_1.getProductionDslName; } });
+Object.defineProperty(exports, "isOptionalProd", { enumerable: true, get: function () { return helpers_1.isOptionalProd; } });
+Object.defineProperty(exports, "isBranchingProd", { enumerable: true, get: function () { return helpers_1.isBranchingProd; } });
+Object.defineProperty(exports, "isSequenceProd", { enumerable: true, get: function () { return helpers_1.isSequenceProd; } });
+//# sourceMappingURL=api.js.map

_node_modules/@chevrotain/gast/lib/src/api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.js","sourceRoot":"","sources":["../../src/api.ts"],"names":[],"mappings":";;;AAAA,iCAagB;AAZd,6FAAA,IAAI,OAAA;AACJ,iGAAA,QAAQ,OAAA;AACR,oGAAA,WAAW,OAAA;AACX,+FAAA,MAAM,OAAA;AACN,mGAAA,UAAU,OAAA;AACV,4GAAA,mBAAmB,OAAA;AACnB,yHAAA,gCAAgC,OAAA;AAChC,gHAAA,uBAAuB,OAAA;AACvB,oGAAA,WAAW,OAAA;AACX,oGAAA,WAAW,OAAA;AACX,yGAAA,gBAAgB,OAAA;AAChB,4GAAA,mBAAmB,OAAA;AAGrB,qCAAuC;AAA9B,sGAAA,WAAW,OAAA;AAEpB,qCAKkB;AAJhB,+GAAA,oBAAoB,OAAA;AACpB,yGAAA,cAAc,OAAA;AACd,0GAAA,eAAe,OAAA;AACf,yGAAA,cAAc,OAAA"}

_node_modules/@chevrotain/gast/lib/src/helpers.d.ts

@@ -0,0 +1,10 @@
+import { NonTerminal } from "./model";
+import { IProduction, IProductionWithOccurrence } from "@chevrotain/types";
+export declare function isSequenceProd(prod: IProduction): prod is {
+    definition: IProduction[];
+} & IProduction;
+export declare function isOptionalProd(prod: IProduction, alreadyVisited?: NonTerminal[]): boolean;
+export declare function isBranchingProd(prod: IProduction): prod is {
+    definition: IProduction[];
+} & IProduction;
+export declare function getProductionDslName(prod: IProductionWithOccurrence): string;

_node_modules/@chevrotain/gast/lib/src/helpers.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProductionDslName = exports.isBranchingProd = exports.isOptionalProd = exports.isSequenceProd = void 0;
+var some_1 = __importDefault(require("lodash/some"));
+var every_1 = __importDefault(require("lodash/every"));
+var includes_1 = __importDefault(require("lodash/includes"));
+var model_1 = require("./model");
+function isSequenceProd(prod) {
+    return (prod instanceof model_1.Alternative ||
+        prod instanceof model_1.Option ||
+        prod instanceof model_1.Repetition ||
+        prod instanceof model_1.RepetitionMandatory ||
+        prod instanceof model_1.RepetitionMandatoryWithSeparator ||
+        prod instanceof model_1.RepetitionWithSeparator ||
+        prod instanceof model_1.Terminal ||
+        prod instanceof model_1.Rule);
+}
+exports.isSequenceProd = isSequenceProd;
+function isOptionalProd(prod, alreadyVisited) {
+    if (alreadyVisited === void 0) { alreadyVisited = []; }
+    var isDirectlyOptional = prod instanceof model_1.Option ||
+        prod instanceof model_1.Repetition ||
+        prod instanceof model_1.RepetitionWithSeparator;
+    if (isDirectlyOptional) {
+        return true;
+    }
+    // note that this can cause infinite loop if one optional empty TOP production has a cyclic dependency with another
+    // empty optional top rule
+    // may be indirectly optional ((A?B?C?) | (D?E?F?))
+    if (prod instanceof model_1.Alternation) {
+        // for OR its enough for just one of the alternatives to be optional
+        return (0, some_1.default)(prod.definition, function (subProd) {
+            return isOptionalProd(subProd, alreadyVisited);
+        });
+    }
+    else if (prod instanceof model_1.NonTerminal && (0, includes_1.default)(alreadyVisited, prod)) {
+        // avoiding stack overflow due to infinite recursion
+        return false;
+    }
+    else if (prod instanceof model_1.AbstractProduction) {
+        if (prod instanceof model_1.NonTerminal) {
+            alreadyVisited.push(prod);
+        }
+        return (0, every_1.default)(prod.definition, function (subProd) {
+            return isOptionalProd(subProd, alreadyVisited);
+        });
+    }
+    else {
+        return false;
+    }
+}
+exports.isOptionalProd = isOptionalProd;
+function isBranchingProd(prod) {
+    return prod instanceof model_1.Alternation;
+}
+exports.isBranchingProd = isBranchingProd;
+function getProductionDslName(prod) {
+    /* istanbul ignore else */
+    if (prod instanceof model_1.NonTerminal) {
+        return "SUBRULE";
+    }
+    else if (prod instanceof model_1.Option) {
+        return "OPTION";
+    }
+    else if (prod instanceof model_1.Alternation) {
+        return "OR";
+    }
+    else if (prod instanceof model_1.RepetitionMandatory) {
+        return "AT_LEAST_ONE";
+    }
+    else if (prod instanceof model_1.RepetitionMandatoryWithSeparator) {
+        return "AT_LEAST_ONE_SEP";
+    }
+    else if (prod instanceof model_1.RepetitionWithSeparator) {
+        return "MANY_SEP";
+    }
+    else if (prod instanceof model_1.Repetition) {
+        return "MANY";
+    }
+    else if (prod instanceof model_1.Terminal) {
+        return "CONSUME";
+    }
+    else {
+        throw Error("non exhaustive match");
+    }
+}
+exports.getProductionDslName = getProductionDslName;
+//# sourceMappingURL=helpers.js.map

_node_modules/@chevrotain/gast/lib/src/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/helpers.ts"],"names":[],"mappings":";;;;;;AAAA,qDAA8B;AAC9B,uDAAgC;AAEhC,6DAAsC;AACtC,iCAYgB;AAIhB,SAAgB,cAAc,CAC5B,IAAiB;IAEjB,OAAO,CACL,IAAI,YAAY,mBAAW;QAC3B,IAAI,YAAY,cAAM;QACtB,IAAI,YAAY,kBAAU;QAC1B,IAAI,YAAY,2BAAmB;QACnC,IAAI,YAAY,wCAAgC;QAChD,IAAI,YAAY,+BAAuB;QACvC,IAAI,YAAY,gBAAQ;QACxB,IAAI,YAAY,YAAI,CACrB,CAAA;AACH,CAAC;AAbD,wCAaC;AAED,SAAgB,cAAc,CAC5B,IAAiB,EACjB,cAAkC;IAAlC,+BAAA,EAAA,mBAAkC;IAElC,IAAM,kBAAkB,GACtB,IAAI,YAAY,cAAM;QACtB,IAAI,YAAY,kBAAU;QAC1B,IAAI,YAAY,+BAAuB,CAAA;IACzC,IAAI,kBAAkB,EAAE;QACtB,OAAO,IAAI,CAAA;KACZ;IAED,mHAAmH;IACnH,0BAA0B;IAC1B,mDAAmD;IACnD,IAAI,IAAI,YAAY,mBAAW,EAAE;QAC/B,oEAAoE;QACpE,OAAO,IAAA,cAAI,EAAe,IAAK,CAAC,UAAU,EAAE,UAAC,OAAoB;YAC/D,OAAO,cAAc,CAAC,OAAO,EAAE,cAAc,CAAC,CAAA;QAChD,CAAC,CAAC,CAAA;KACH;SAAM,IAAI,IAAI,YAAY,mBAAW,IAAI,IAAA,kBAAQ,EAAC,cAAc,EAAE,IAAI,CAAC,EAAE;QACxE,oDAAoD;QACpD,OAAO,KAAK,CAAA;KACb;SAAM,IAAI,IAAI,YAAY,0BAAkB,EAAE;QAC7C,IAAI,IAAI,YAAY,mBAAW,EAAE;YAC/B,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;SAC1B;QACD,OAAO,IAAA,eAAK,EACW,IAAK,CAAC,UAAU,EACrC,UAAC,OAAoB;YACnB,OAAO,cAAc,CAAC,OAAO,EAAE,cAAc,CAAC,CAAA;QAChD,CAAC,CACF,CAAA;KACF;SAAM;QACL,OAAO,KAAK,CAAA;KACb;AACH,CAAC;AApCD,wCAoCC;AAED,SAAgB,eAAe,CAC7B,IAAiB;IAEjB,OAAO,IAAI,YAAY,mBAAW,CAAA;AACpC,CAAC;AAJD,0CAIC;AAED,SAAgB,oBAAoB,CAAC,IAA+B;IAClE,0BAA0B;IAC1B,IAAI,IAAI,YAAY,mBAAW,EAAE;QAC/B,OAAO,SAAS,CAAA;KACjB;SAAM,IAAI,IAAI,YAAY,cAAM,EAAE;QACjC,OAAO,QAAQ,CAAA;KAChB;SAAM,IAAI,IAAI,YAAY,mBAAW,EAAE;QACtC,OAAO,IAAI,CAAA;KACZ;SAAM,IAAI,IAAI,YAAY,2BAAmB,EAAE;QAC9C,OAAO,cAAc,CAAA;KACtB;SAAM,IAAI,IAAI,YAAY,wCAAgC,EAAE;QAC3D,OAAO,kBAAkB,CAAA;KAC1B;SAAM,IAAI,IAAI,YAAY,+BAAuB,EAAE;QAClD,OAAO,UAAU,CAAA;KAClB;SAAM,IAAI,IAAI,YAAY,kBAAU,EAAE;QACrC,OAAO,MAAM,CAAA;KACd;SAAM,IAAI,IAAI,YAAY,gBAAQ,EAAE;QACnC,OAAO,SAAS,CAAA;KACjB;SAAM;QACL,MAAM,KAAK,CAAC,sBAAsB,CAAC,CAAA;KACpC;AACH,CAAC;AArBD,oDAqBC"}

_node_modules/@chevrotain/gast/lib/src/model.d.ts

@@ -0,0 +1,144 @@
+import { IGASTVisitor, IProduction, IProductionWithOccurrence, ISerializedGast, TokenType } from "@chevrotain/types";
+export declare abstract class AbstractProduction<T extends IProduction = IProduction> implements IProduction {
+    protected _definition: T[];
+    get definition(): T[];
+    set definition(value: T[]);
+    constructor(_definition: T[]);
+    accept(visitor: IGASTVisitor): void;
+}
+export declare class NonTerminal extends AbstractProduction implements IProductionWithOccurrence {
+    nonTerminalName: string;
+    label?: string;
+    referencedRule: Rule;
+    idx: number;
+    constructor(options: {
+        nonTerminalName: string;
+        label?: string;
+        referencedRule?: Rule;
+        idx?: number;
+    });
+    set definition(definition: IProduction[]);
+    get definition(): IProduction[];
+    accept(visitor: IGASTVisitor): void;
+}
+export declare class Rule extends AbstractProduction {
+    name: string;
+    orgText: string;
+    constructor(options: {
+        name: string;
+        definition: IProduction[];
+        orgText?: string;
+    });
+}
+export declare class Alternative extends AbstractProduction {
+    ignoreAmbiguities: boolean;
+    constructor(options: {
+        definition: IProduction[];
+        ignoreAmbiguities?: boolean;
+    });
+}
+export declare class Option extends AbstractProduction implements IProductionWithOccurrence {
+    idx: number;
+    maxLookahead?: number;
+    constructor(options: {
+        definition: IProduction[];
+        idx?: number;
+        maxLookahead?: number;
+    });
+}
+export declare class RepetitionMandatory extends AbstractProduction implements IProductionWithOccurrence {
+    idx: number;
+    maxLookahead?: number;
+    constructor(options: {
+        definition: IProduction[];
+        idx?: number;
+        maxLookahead?: number;
+    });
+}
+export declare class RepetitionMandatoryWithSeparator extends AbstractProduction implements IProductionWithOccurrence {
+    separator: TokenType;
+    idx: number;
+    maxLookahead?: number;
+    constructor(options: {
+        definition: IProduction[];
+        separator: TokenType;
+        idx?: number;
+    });
+}
+export declare class Repetition extends AbstractProduction implements IProductionWithOccurrence {
+    separator: TokenType;
+    idx: number;
+    maxLookahead?: number;
+    constructor(options: {
+        definition: IProduction[];
+        idx?: number;
+        maxLookahead?: number;
+    });
+}
+export declare class RepetitionWithSeparator extends AbstractProduction implements IProductionWithOccurrence {
+    separator: TokenType;
+    idx: number;
+    maxLookahead?: number;
+    constructor(options: {
+        definition: IProduction[];
+        separator: TokenType;
+        idx?: number;
+    });
+}
+export declare class Alternation extends AbstractProduction<Alternative> implements IProductionWithOccurrence {
+    idx: number;
+    ignoreAmbiguities: boolean;
+    hasPredicates: boolean;
+    maxLookahead?: number;
+    get definition(): Alternative[];
+    set definition(value: Alternative[]);
+    constructor(options: {
+        definition: Alternative[];
+        idx?: number;
+        ignoreAmbiguities?: boolean;
+        hasPredicates?: boolean;
+        maxLookahead?: number;
+    });
+}
+export declare class Terminal implements IProductionWithOccurrence {
+    terminalType: TokenType;
+    label?: string;
+    idx: number;
+    constructor(options: {
+        terminalType: TokenType;
+        label?: string;
+        idx?: number;
+    });
+    accept(visitor: IGASTVisitor): void;
+}
+export interface ISerializedBasic extends ISerializedGast {
+    type: "Alternative" | "Option" | "RepetitionMandatory" | "Repetition" | "Alternation";
+    idx?: number;
+}
+export interface ISerializedGastRule extends ISerializedGast {
+    type: "Rule";
+    name: string;
+    orgText: string;
+}
+export interface ISerializedNonTerminal extends ISerializedGast {
+    type: "NonTerminal";
+    name: string;
+    label?: string;
+    idx: number;
+}
+export interface ISerializedTerminal extends ISerializedGast {
+    type: "Terminal";
+    name: string;
+    terminalLabel?: string;
+    label?: string;
+    pattern?: string;
+    idx: number;
+}
+export interface ISerializedTerminalWithSeparator extends ISerializedGast {
+    type: "RepetitionMandatoryWithSeparator" | "RepetitionWithSeparator";
+    idx: number;
+    separator: ISerializedTerminal;
+}
+export type ISerializedGastAny = ISerializedBasic | ISerializedGastRule | ISerializedNonTerminal | ISerializedTerminal | ISerializedTerminalWithSeparator;
+export declare function serializeGrammar(topRules: Rule[]): ISerializedGast[];
+export declare function serializeProduction(node: IProduction): ISerializedGast;

_node_modules/@chevrotain/gast/lib/src/model.js

@@ -0,0 +1,304 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeProduction = exports.serializeGrammar = exports.Terminal = exports.Alternation = exports.RepetitionWithSeparator = exports.Repetition = exports.RepetitionMandatoryWithSeparator = exports.RepetitionMandatory = exports.Option = exports.Alternative = exports.Rule = exports.NonTerminal = exports.AbstractProduction = void 0;
+var map_1 = __importDefault(require("lodash/map"));
+var forEach_1 = __importDefault(require("lodash/forEach"));
+var isString_1 = __importDefault(require("lodash/isString"));
+var isRegExp_1 = __importDefault(require("lodash/isRegExp"));
+var pickBy_1 = __importDefault(require("lodash/pickBy"));
+var assign_1 = __importDefault(require("lodash/assign"));
+// TODO: duplicated code to avoid extracting another sub-package -- how to avoid?
+function tokenLabel(tokType) {
+    if (hasTokenLabel(tokType)) {
+        return tokType.LABEL;
+    }
+    else {
+        return tokType.name;
+    }
+}
+// TODO: duplicated code to avoid extracting another sub-package -- how to avoid?
+function hasTokenLabel(obj) {
+    return (0, isString_1.default)(obj.LABEL) && obj.LABEL !== "";
+}
+var AbstractProduction = /** @class */ (function () {
+    function AbstractProduction(_definition) {
+        this._definition = _definition;
+    }
+    Object.defineProperty(AbstractProduction.prototype, "definition", {
+        get: function () {
+            return this._definition;
+        },
+        set: function (value) {
+            this._definition = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AbstractProduction.prototype.accept = function (visitor) {
+        visitor.visit(this);
+        (0, forEach_1.default)(this.definition, function (prod) {
+            prod.accept(visitor);
+        });
+    };
+    return AbstractProduction;
+}());
+exports.AbstractProduction = AbstractProduction;
+var NonTerminal = /** @class */ (function (_super) {
+    __extends(NonTerminal, _super);
+    function NonTerminal(options) {
+        var _this = _super.call(this, []) || this;
+        _this.idx = 1;
+        (0, assign_1.default)(_this, (0, pickBy_1.default)(options, function (v) { return v !== undefined; }));
+        return _this;
+    }
+    Object.defineProperty(NonTerminal.prototype, "definition", {
+        get: function () {
+            if (this.referencedRule !== undefined) {
+                return this.referencedRule.definition;
+            }
+            return [];
+        },
+        set: function (definition) {
+            // immutable
+        },
+        enumerable: false,
+        configurable: true
+    });
+    NonTerminal.prototype.accept = function (visitor) {
+        visitor.visit(this);
+        // don't visit children of a reference, we will get cyclic infinite loops if we do so
+    };
+    return NonTerminal;
+}(AbstractProduction));
+exports.NonTerminal = NonTerminal;
+var Rule = /** @class */ (function (_super) {
+    __extends(Rule, _super);
+    function Rule(options) {
+        var _this = _super.call(this, options.definition) || this;
+        _this.orgText = "";
+        (0, assign_1.default)(_this, (0, pickBy_1.default)(options, function (v) { return v !== undefined; }));
+        return _this;
+    }
+    return Rule;
+}(AbstractProduction));
+exports.Rule = Rule;
+var Alternative = /** @class */ (function (_super) {
+    __extends(Alternative, _super);
+    function Alternative(options) {
+        var _this = _super.call(this, options.definition) || this;
+        _this.ignoreAmbiguities = false;
+        (0, assign_1.default)(_this, (0, pickBy_1.default)(options, function (v) { return v !== undefined; }));
+        return _this;
+    }
+    return Alternative;
+}(AbstractProduction));
+exports.Alternative = Alternative;
+var Option = /** @class */ (function (_super) {
+    __extends(Option, _super);
+    function Option(options) {
+        var _this = _super.call(this, options.definition) || this;
+        _this.idx = 1;
+        (0, assign_1.default)(_this, (0, pickBy_1.default)(options, function (v) { return v !== undefined; }));
+        return _this;
+    }
+    return Option;
+}(AbstractProduction));
+exports.Option = Option;
+var RepetitionMandatory = /** @class */ (function (_super) {
+    __extends(RepetitionMandatory, _super);
+    function RepetitionMandatory(options) {
+        var _this = _super.call(this, options.definition) || this;
+        _this.idx = 1;
+        (0, assign_1.default)(_this, (0, pickBy_1.default)(options, function (v) { return v !== undefined; }));
+        return _this;
+    }
+    return RepetitionMandatory;
+}(AbstractProduction));
+exports.RepetitionMandatory = RepetitionMandatory;
+var RepetitionMandatoryWithSeparator = /** @class */ (function (_super) {
+    __extends(RepetitionMandatoryWithSeparator, _super);
+    function RepetitionMandatoryWithSeparator(options) {
+        var _this = _super.call(this, options.definition) || this;
+        _this.idx = 1;
+        (0, assign_1.default)(_this, (0, pickBy_1.default)(options, function (v) { return v !== undefined; }));
+        return _this;
+    }
+    return RepetitionMandatoryWithSeparator;
+}(AbstractProduction));
+exports.RepetitionMandatoryWithSeparator = RepetitionMandatoryWithSeparator;
+var Repetition = /** @class */ (function (_super) {
+    __extends(Repetition, _super);
+    function Repetition(options) {
+        var _this = _super.call(this, options.definition) || this;
+        _this.idx = 1;
+        (0, assign_1.default)(_this, (0, pickBy_1.default)(options, function (v) { return v !== undefined; }));
+        return _this;
+    }
+    return Repetition;
+}(AbstractProduction));
+exports.Repetition = Repetition;
+var RepetitionWithSeparator = /** @class */ (function (_super) {
+    __extends(RepetitionWithSeparator, _super);
+    function RepetitionWithSeparator(options) {
+        var _this = _super.call(this, options.definition) || this;
+        _this.idx = 1;
+        (0, assign_1.default)(_this, (0, pickBy_1.default)(options, function (v) { return v !== undefined; }));
+        return _this;
+    }
+    return RepetitionWithSeparator;
+}(AbstractProduction));
+exports.RepetitionWithSeparator = RepetitionWithSeparator;
+var Alternation = /** @class */ (function (_super) {
+    __extends(Alternation, _super);
+    function Alternation(options) {
+        var _this = _super.call(this, options.definition) || this;
+        _this.idx = 1;
+        _this.ignoreAmbiguities = false;
+        _this.hasPredicates = false;
+        (0, assign_1.default)(_this, (0, pickBy_1.default)(options, function (v) { return v !== undefined; }));
+        return _this;
+    }
+    Object.defineProperty(Alternation.prototype, "definition", {
+        get: function () {
+            return this._definition;
+        },
+        set: function (value) {
+            this._definition = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Alternation;
+}(AbstractProduction));
+exports.Alternation = Alternation;
+var Terminal = /** @class */ (function () {
+    function Terminal(options) {
+        this.idx = 1;
+        (0, assign_1.default)(this, (0, pickBy_1.default)(options, function (v) { return v !== undefined; }));
+    }
+    Terminal.prototype.accept = function (visitor) {
+        visitor.visit(this);
+    };
+    return Terminal;
+}());
+exports.Terminal = Terminal;
+function serializeGrammar(topRules) {
+    return (0, map_1.default)(topRules, serializeProduction);
+}
+exports.serializeGrammar = serializeGrammar;
+function serializeProduction(node) {
+    function convertDefinition(definition) {
+        return (0, map_1.default)(definition, serializeProduction);
+    }
+    /* istanbul ignore else */
+    if (node instanceof NonTerminal) {
+        var serializedNonTerminal = {
+            type: "NonTerminal",
+            name: node.nonTerminalName,
+            idx: node.idx
+        };
+        if ((0, isString_1.default)(node.label)) {
+            serializedNonTerminal.label = node.label;
+        }
+        return serializedNonTerminal;
+    }
+    else if (node instanceof Alternative) {
+        return {
+            type: "Alternative",
+            definition: convertDefinition(node.definition)
+        };
+    }
+    else if (node instanceof Option) {
+        return {
+            type: "Option",
+            idx: node.idx,
+            definition: convertDefinition(node.definition)
+        };
+    }
+    else if (node instanceof RepetitionMandatory) {
+        return {
+            type: "RepetitionMandatory",
+            idx: node.idx,
+            definition: convertDefinition(node.definition)
+        };
+    }
+    else if (node instanceof RepetitionMandatoryWithSeparator) {
+        return {
+            type: "RepetitionMandatoryWithSeparator",
+            idx: node.idx,
+            separator: (serializeProduction(new Terminal({ terminalType: node.separator }))),
+            definition: convertDefinition(node.definition)
+        };
+    }
+    else if (node instanceof RepetitionWithSeparator) {
+        return {
+            type: "RepetitionWithSeparator",
+            idx: node.idx,
+            separator: (serializeProduction(new Terminal({ terminalType: node.separator }))),
+            definition: convertDefinition(node.definition)
+        };
+    }
+    else if (node instanceof Repetition) {
+        return {
+            type: "Repetition",
+            idx: node.idx,
+            definition: convertDefinition(node.definition)
+        };
+    }
+    else if (node instanceof Alternation) {
+        return {
+            type: "Alternation",
+            idx: node.idx,
+            definition: convertDefinition(node.definition)
+        };
+    }
+    else if (node instanceof Terminal) {
+        var serializedTerminal = {
+            type: "Terminal",
+            name: node.terminalType.name,
+            label: tokenLabel(node.terminalType),
+            idx: node.idx
+        };
+        if ((0, isString_1.default)(node.label)) {
+            serializedTerminal.terminalLabel = node.label;
+        }
+        var pattern = node.terminalType.PATTERN;
+        if (node.terminalType.PATTERN) {
+            serializedTerminal.pattern = (0, isRegExp_1.default)(pattern)
+                ? pattern.source
+                : pattern;
+        }
+        return serializedTerminal;
+    }
+    else if (node instanceof Rule) {
+        return {
+            type: "Rule",
+            name: node.name,
+            orgText: node.orgText,
+            definition: convertDefinition(node.definition)
+        };
+    }
+    else {
+        throw Error("non exhaustive match");
+    }
+}
+exports.serializeProduction = serializeProduction;
+//# sourceMappingURL=model.js.map

_node_modules/@chevrotain/gast/lib/src/visitor.d.ts

@@ -0,0 +1,15 @@
+import { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Rule, Terminal } from "./model";
+import { IProduction } from "@chevrotain/types";
+export declare abstract class GAstVisitor {
+    visit(node: IProduction): any;
+    visitNonTerminal(node: NonTerminal): any;
+    visitAlternative(node: Alternative): any;
+    visitOption(node: Option): any;
+    visitRepetition(node: Repetition): any;
+    visitRepetitionMandatory(node: RepetitionMandatory): any;
+    visitRepetitionMandatoryWithSeparator(node: RepetitionMandatoryWithSeparator): any;
+    visitRepetitionWithSeparator(node: RepetitionWithSeparator): any;
+    visitAlternation(node: Alternation): any;
+    visitTerminal(node: Terminal): any;
+    visitRule(node: Rule): any;
+}

_node_modules/@chevrotain/gast/lib/src/visitor.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GAstVisitor = void 0;
+var model_1 = require("./model");
+var GAstVisitor = /** @class */ (function () {
+    function GAstVisitor() {
+    }
+    GAstVisitor.prototype.visit = function (node) {
+        var nodeAny = node;
+        switch (nodeAny.constructor) {
+            case model_1.NonTerminal:
+                return this.visitNonTerminal(nodeAny);
+            case model_1.Alternative:
+                return this.visitAlternative(nodeAny);
+            case model_1.Option:
+                return this.visitOption(nodeAny);
+            case model_1.RepetitionMandatory:
+                return this.visitRepetitionMandatory(nodeAny);
+            case model_1.RepetitionMandatoryWithSeparator:
+                return this.visitRepetitionMandatoryWithSeparator(nodeAny);
+            case model_1.RepetitionWithSeparator:
+                return this.visitRepetitionWithSeparator(nodeAny);
+            case model_1.Repetition:
+                return this.visitRepetition(nodeAny);
+            case model_1.Alternation:
+                return this.visitAlternation(nodeAny);
+            case model_1.Terminal:
+                return this.visitTerminal(nodeAny);
+            case model_1.Rule:
+                return this.visitRule(nodeAny);
+            /* istanbul ignore next */
+            default:
+                throw Error("non exhaustive match");
+        }
+    };
+    /* istanbul ignore next - testing the fact a NOOP function exists is non-trivial  */
+    GAstVisitor.prototype.visitNonTerminal = function (node) { };
+    /* istanbul ignore next - testing the fact a NOOP function exists is non-trivial  */
+    GAstVisitor.prototype.visitAlternative = function (node) { };
+    /* istanbul ignore next - testing the fact a NOOP function exists is non-trivial  */
+    GAstVisitor.prototype.visitOption = function (node) { };
+    /* istanbul ignore next - testing the fact a NOOP function exists is non-trivial  */
+    GAstVisitor.prototype.visitRepetition = function (node) { };
+    /* istanbul ignore next - testing the fact a NOOP function exists is non-trivial  */
+    GAstVisitor.prototype.visitRepetitionMandatory = function (node) { };
+    /* istanbul ignore next - testing the fact a NOOP function exists is non-trivial  */
+    GAstVisitor.prototype.visitRepetitionMandatoryWithSeparator = function (node) { };
+    /* istanbul ignore next - testing the fact a NOOP function exists is non-trivial  */
+    GAstVisitor.prototype.visitRepetitionWithSeparator = function (node) { };
+    /* istanbul ignore next - testing the fact a NOOP function exists is non-trivial  */
+    GAstVisitor.prototype.visitAlternation = function (node) { };
+    /* istanbul ignore next - testing the fact a NOOP function exists is non-trivial  */
+    GAstVisitor.prototype.visitTerminal = function (node) { };
+    /* istanbul ignore next - testing the fact a NOOP function exists is non-trivial  */
+    GAstVisitor.prototype.visitRule = function (node) { };
+    return GAstVisitor;
+}());
+exports.GAstVisitor = GAstVisitor;
+//# sourceMappingURL=visitor.js.map

_node_modules/@chevrotain/gast/lib/src/visitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visitor.js","sourceRoot":"","sources":["../../src/visitor.ts"],"names":[],"mappings":";;;AAAA,iCAWgB;AAGhB;IAAA;IA6DA,CAAC;IA5DQ,2BAAK,GAAZ,UAAa,IAAiB;QAC5B,IAAM,OAAO,GAAQ,IAAI,CAAA;QACzB,QAAQ,OAAO,CAAC,WAAW,EAAE;YAC3B,KAAK,mBAAW;gBACd,OAAO,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAA;YACvC,KAAK,mBAAW;gBACd,OAAO,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAA;YACvC,KAAK,cAAM;gBACT,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAA;YAClC,KAAK,2BAAmB;gBACtB,OAAO,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC,CAAA;YAC/C,KAAK,wCAAgC;gBACnC,OAAO,IAAI,CAAC,qCAAqC,CAAC,OAAO,CAAC,CAAA;YAC5D,KAAK,+BAAuB;gBAC1B,OAAO,IAAI,CAAC,4BAA4B,CAAC,OAAO,CAAC,CAAA;YACnD,KAAK,kBAAU;gBACb,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAA;YACtC,KAAK,mBAAW;gBACd,OAAO,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAA;YACvC,KAAK,gBAAQ;gBACX,OAAO,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAA;YACpC,KAAK,YAAI;gBACP,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAA;YAChC,0BAA0B;YAC1B;gBACE,MAAM,KAAK,CAAC,sBAAsB,CAAC,CAAA;SACtC;IACH,CAAC;IAED,oFAAoF;IAC7E,sCAAgB,GAAvB,UAAwB,IAAiB,IAAQ,CAAC;IAElD,oFAAoF;IAC7E,sCAAgB,GAAvB,UAAwB,IAAiB,IAAQ,CAAC;IAElD,oFAAoF;IAC7E,iCAAW,GAAlB,UAAmB,IAAY,IAAQ,CAAC;IAExC,oFAAoF;IAC7E,qCAAe,GAAtB,UAAuB,IAAgB,IAAQ,CAAC;IAEhD,oFAAoF;IAC7E,8CAAwB,GAA/B,UAAgC,IAAyB,IAAQ,CAAC;IAElE,oFAAoF;IAC7E,2DAAqC,GAA5C,UACE,IAAsC,IAChC,CAAC;IAET,oFAAoF;IAC7E,kDAA4B,GAAnC,UAAoC,IAA6B,IAAQ,CAAC;IAE1E,oFAAoF;IAC7E,sCAAgB,GAAvB,UAAwB,IAAiB,IAAQ,CAAC;IAElD,oFAAoF;IAC7E,mCAAa,GAApB,UAAqB,IAAc,IAAQ,CAAC;IAE5C,oFAAoF;IAC7E,+BAAS,GAAhB,UAAiB,IAAU,IAAQ,CAAC;IACtC,kBAAC;AAAD,CAAC,AA7DD,IA6DC;AA7DqB,kCAAW"}

_node_modules/@chevrotain/gast/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@chevrotain/gast",
+  "version": "10.5.0",
+  "description": "Grammar AST structure for Chevrotain Parsers",
+  "keywords": [],
+  "bugs": {
+    "url": "https://github.com/Chevrotain/chevrotain/issues"
+  },
+  "license": "Apache-2.0",
+  "typings": "lib/src/api.d.ts",
+  "main": "lib/src/api.js",
+  "files": [
+    "src/**/*.ts",
+    "lib/src/**/*.js",
+    "lib/src/**/*.d.ts",
+    "lib/src/**/*.js.map",
+    "api.d.ts"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/Chevrotain/chevrotain.git"
+  },
+  "scripts": {
+    "---------- CI FLOWS --------": "",
+    "ci": "pnpm run build test",
+    "build": "npm-run-all clean compile",
+    "test": "npm-run-all coverage",
+    "---------- DEV FLOWS --------": "",
+    "update-snapshots": "node ./scripts/update-snapshots.js",
+    "---------- BUILD STEPS --------": "",
+    "clean": "shx rm -rf lib coverage",
+    "compile:watch": "tsc -w",
+    "compile": "tsc",
+    "coverage": "nyc mocha"
+  },
+  "dependencies": {
+    "@chevrotain/types": "10.5.0",
+    "lodash": "4.17.21"
+  },
+  "devDependencies": {
+    "@types/lodash": "4.14.191"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "f5fdf95b8da570c702753252b0a3f7aa34d64f3b"
+}

_node_modules/@chevrotain/gast/src/api.ts

@@ -0,0 +1,23 @@
+export {
+  Rule,
+  Terminal,
+  NonTerminal,
+  Option,
+  Repetition,
+  RepetitionMandatory,
+  RepetitionMandatoryWithSeparator,
+  RepetitionWithSeparator,
+  Alternation,
+  Alternative,
+  serializeGrammar,
+  serializeProduction
+} from "./model"
+
+export { GAstVisitor } from "./visitor"
+
+export {
+  getProductionDslName,
+  isOptionalProd,
+  isBranchingProd,
+  isSequenceProd
+} from "./helpers"

_node_modules/@chevrotain/gast/src/helpers.ts

@@ -0,0 +1,101 @@
+import some from "lodash/some"
+import every from "lodash/every"
+import has from "lodash/has"
+import includes from "lodash/includes"
+import {
+  AbstractProduction,
+  Alternation,
+  Alternative,
+  NonTerminal,
+  Option,
+  Repetition,
+  RepetitionMandatory,
+  RepetitionMandatoryWithSeparator,
+  RepetitionWithSeparator,
+  Rule,
+  Terminal
+} from "./model"
+import { GAstVisitor } from "./visitor"
+import { IProduction, IProductionWithOccurrence } from "@chevrotain/types"
+
+export function isSequenceProd(
+  prod: IProduction
+): prod is { definition: IProduction[] } & IProduction {
+  return (
+    prod instanceof Alternative ||
+    prod instanceof Option ||
+    prod instanceof Repetition ||
+    prod instanceof RepetitionMandatory ||
+    prod instanceof RepetitionMandatoryWithSeparator ||
+    prod instanceof RepetitionWithSeparator ||
+    prod instanceof Terminal ||
+    prod instanceof Rule
+  )
+}
+
+export function isOptionalProd(
+  prod: IProduction,
+  alreadyVisited: NonTerminal[] = []
+): boolean {
+  const isDirectlyOptional =
+    prod instanceof Option ||
+    prod instanceof Repetition ||
+    prod instanceof RepetitionWithSeparator
+  if (isDirectlyOptional) {
+    return true
+  }
+
+  // note that this can cause infinite loop if one optional empty TOP production has a cyclic dependency with another
+  // empty optional top rule
+  // may be indirectly optional ((A?B?C?) | (D?E?F?))
+  if (prod instanceof Alternation) {
+    // for OR its enough for just one of the alternatives to be optional
+    return some((<Alternation>prod).definition, (subProd: IProduction) => {
+      return isOptionalProd(subProd, alreadyVisited)
+    })
+  } else if (prod instanceof NonTerminal && includes(alreadyVisited, prod)) {
+    // avoiding stack overflow due to infinite recursion
+    return false
+  } else if (prod instanceof AbstractProduction) {
+    if (prod instanceof NonTerminal) {
+      alreadyVisited.push(prod)
+    }
+    return every(
+      (<AbstractProduction>prod).definition,
+      (subProd: IProduction) => {
+        return isOptionalProd(subProd, alreadyVisited)
+      }
+    )
+  } else {
+    return false
+  }
+}
+
+export function isBranchingProd(
+  prod: IProduction
+): prod is { definition: IProduction[] } & IProduction {
+  return prod instanceof Alternation
+}
+
+export function getProductionDslName(prod: IProductionWithOccurrence): string {
+  /* istanbul ignore else */
+  if (prod instanceof NonTerminal) {
+    return "SUBRULE"
+  } else if (prod instanceof Option) {
+    return "OPTION"
+  } else if (prod instanceof Alternation) {
+    return "OR"
+  } else if (prod instanceof RepetitionMandatory) {
+    return "AT_LEAST_ONE"
+  } else if (prod instanceof RepetitionMandatoryWithSeparator) {
+    return "AT_LEAST_ONE_SEP"
+  } else if (prod instanceof RepetitionWithSeparator) {
+    return "MANY_SEP"
+  } else if (prod instanceof Repetition) {
+    return "MANY"
+  } else if (prod instanceof Terminal) {
+    return "CONSUME"
+  } else {
+    throw Error("non exhaustive match")
+  }
+}

_node_modules/@chevrotain/gast/src/model.ts

@@ -0,0 +1,420 @@
+import map from "lodash/map"
+import forEach from "lodash/forEach"
+import isString from "lodash/isString"
+import isRegExp from "lodash/isRegExp"
+import pickBy from "lodash/pickBy"
+import assign from "lodash/assign"
+import {
+  IGASTVisitor,
+  IProduction,
+  IProductionWithOccurrence,
+  ISerializedGast,
+  TokenType
+} from "@chevrotain/types"
+
+// TODO: duplicated code to avoid extracting another sub-package -- how to avoid?
+function tokenLabel(tokType: TokenType): string {
+  if (hasTokenLabel(tokType)) {
+    return tokType.LABEL
+  } else {
+    return tokType.name
+  }
+}
+
+// TODO: duplicated code to avoid extracting another sub-package -- how to avoid?
+function hasTokenLabel(
+  obj: TokenType
+): obj is TokenType & Pick<Required<TokenType>, "LABEL"> {
+  return isString(obj.LABEL) && obj.LABEL !== ""
+}
+
+export abstract class AbstractProduction<T extends IProduction = IProduction>
+  implements IProduction
+{
+  public get definition(): T[] {
+    return this._definition
+  }
+  public set definition(value: T[]) {
+    this._definition = value
+  }
+
+  constructor(protected _definition: T[]) {}
+
+  accept(visitor: IGASTVisitor): void {
+    visitor.visit(this)
+    forEach(this.definition, (prod) => {
+      prod.accept(visitor)
+    })
+  }
+}
+
+export class NonTerminal
+  extends AbstractProduction
+  implements IProductionWithOccurrence
+{
+  public nonTerminalName!: string
+  public label?: string
+  public referencedRule!: Rule
+  public idx: number = 1
+
+  constructor(options: {
+    nonTerminalName: string
+    label?: string
+    referencedRule?: Rule
+    idx?: number
+  }) {
+    super([])
+    assign(
+      this,
+      pickBy(options, (v) => v !== undefined)
+    )
+  }
+
+  set definition(definition: IProduction[]) {
+    // immutable
+  }
+
+  get definition(): IProduction[] {
+    if (this.referencedRule !== undefined) {
+      return this.referencedRule.definition
+    }
+    return []
+  }
+
+  accept(visitor: IGASTVisitor): void {
+    visitor.visit(this)
+    // don't visit children of a reference, we will get cyclic infinite loops if we do so
+  }
+}
+
+export class Rule extends AbstractProduction {
+  public name!: string
+  public orgText: string = ""
+
+  constructor(options: {
+    name: string
+    definition: IProduction[]
+    orgText?: string
+  }) {
+    super(options.definition)
+    assign(
+      this,
+      pickBy(options, (v) => v !== undefined)
+    )
+  }
+}
+
+export class Alternative extends AbstractProduction {
+  public ignoreAmbiguities: boolean = false
+
+  constructor(options: {
+    definition: IProduction[]
+    ignoreAmbiguities?: boolean
+  }) {
+    super(options.definition)
+    assign(
+      this,
+      pickBy(options, (v) => v !== undefined)
+    )
+  }
+}
+
+export class Option
+  extends AbstractProduction
+  implements IProductionWithOccurrence
+{
+  public idx: number = 1
+  public maxLookahead?: number
+
+  constructor(options: {
+    definition: IProduction[]
+    idx?: number
+    maxLookahead?: number
+  }) {
+    super(options.definition)
+    assign(
+      this,
+      pickBy(options, (v) => v !== undefined)
+    )
+  }
+}
+
+export class RepetitionMandatory
+  extends AbstractProduction
+  implements IProductionWithOccurrence
+{
+  public idx: number = 1
+  public maxLookahead?: number
+
+  constructor(options: {
+    definition: IProduction[]
+    idx?: number
+    maxLookahead?: number
+  }) {
+    super(options.definition)
+    assign(
+      this,
+      pickBy(options, (v) => v !== undefined)
+    )
+  }
+}
+
+export class RepetitionMandatoryWithSeparator
+  extends AbstractProduction
+  implements IProductionWithOccurrence
+{
+  public separator!: TokenType
+  public idx: number = 1
+  public maxLookahead?: number
+
+  constructor(options: {
+    definition: IProduction[]
+    separator: TokenType
+    idx?: number
+  }) {
+    super(options.definition)
+    assign(
+      this,
+      pickBy(options, (v) => v !== undefined)
+    )
+  }
+}
+
+export class Repetition
+  extends AbstractProduction
+  implements IProductionWithOccurrence
+{
+  public separator!: TokenType
+  public idx: number = 1
+  public maxLookahead?: number
+
+  constructor(options: {
+    definition: IProduction[]
+    idx?: number
+    maxLookahead?: number
+  }) {
+    super(options.definition)
+    assign(
+      this,
+      pickBy(options, (v) => v !== undefined)
+    )
+  }
+}
+
+export class RepetitionWithSeparator
+  extends AbstractProduction
+  implements IProductionWithOccurrence
+{
+  public separator!: TokenType
+  public idx: number = 1
+  public maxLookahead?: number
+
+  constructor(options: {
+    definition: IProduction[]
+    separator: TokenType
+    idx?: number
+  }) {
+    super(options.definition)
+    assign(
+      this,
+      pickBy(options, (v) => v !== undefined)
+    )
+  }
+}
+
+export class Alternation
+  extends AbstractProduction<Alternative>
+  implements IProductionWithOccurrence
+{
+  public idx: number = 1
+  public ignoreAmbiguities: boolean = false
+  public hasPredicates: boolean = false
+  public maxLookahead?: number
+
+  public get definition(): Alternative[] {
+    return this._definition
+  }
+  public set definition(value: Alternative[]) {
+    this._definition = value
+  }
+
+  constructor(options: {
+    definition: Alternative[]
+    idx?: number
+    ignoreAmbiguities?: boolean
+    hasPredicates?: boolean
+    maxLookahead?: number
+  }) {
+    super(options.definition)
+    assign(
+      this,
+      pickBy(options, (v) => v !== undefined)
+    )
+  }
+}
+
+export class Terminal implements IProductionWithOccurrence {
+  public terminalType!: TokenType
+  public label?: string
+  public idx: number = 1
+
+  constructor(options: {
+    terminalType: TokenType
+    label?: string
+    idx?: number
+  }) {
+    assign(
+      this,
+      pickBy(options, (v) => v !== undefined)
+    )
+  }
+
+  accept(visitor: IGASTVisitor): void {
+    visitor.visit(this)
+  }
+}
+
+export interface ISerializedBasic extends ISerializedGast {
+  type:
+    | "Alternative"
+    | "Option"
+    | "RepetitionMandatory"
+    | "Repetition"
+    | "Alternation"
+  idx?: number
+}
+
+export interface ISerializedGastRule extends ISerializedGast {
+  type: "Rule"
+  name: string
+  orgText: string
+}
+
+export interface ISerializedNonTerminal extends ISerializedGast {
+  type: "NonTerminal"
+  name: string
+  label?: string
+  idx: number
+}
+
+export interface ISerializedTerminal extends ISerializedGast {
+  type: "Terminal"
+  name: string
+  terminalLabel?: string
+  label?: string
+  pattern?: string
+  idx: number
+}
+
+export interface ISerializedTerminalWithSeparator extends ISerializedGast {
+  type: "RepetitionMandatoryWithSeparator" | "RepetitionWithSeparator"
+  idx: number
+  separator: ISerializedTerminal
+}
+
+export type ISerializedGastAny =
+  | ISerializedBasic
+  | ISerializedGastRule
+  | ISerializedNonTerminal
+  | ISerializedTerminal
+  | ISerializedTerminalWithSeparator
+
+export function serializeGrammar(topRules: Rule[]): ISerializedGast[] {
+  return map(topRules, serializeProduction)
+}
+
+export function serializeProduction(node: IProduction): ISerializedGast {
+  function convertDefinition(definition: IProduction[]): ISerializedGast[] {
+    return map(definition, serializeProduction)
+  }
+  /* istanbul ignore else */
+  if (node instanceof NonTerminal) {
+    const serializedNonTerminal: ISerializedNonTerminal = {
+      type: "NonTerminal",
+      name: node.nonTerminalName,
+      idx: node.idx
+    }
+
+    if (isString(node.label)) {
+      serializedNonTerminal.label = node.label
+    }
+
+    return serializedNonTerminal
+  } else if (node instanceof Alternative) {
+    return <ISerializedBasic>{
+      type: "Alternative",
+      definition: convertDefinition(node.definition)
+    }
+  } else if (node instanceof Option) {
+    return <ISerializedBasic>{
+      type: "Option",
+      idx: node.idx,
+      definition: convertDefinition(node.definition)
+    }
+  } else if (node instanceof RepetitionMandatory) {
+    return <ISerializedBasic>{
+      type: "RepetitionMandatory",
+      idx: node.idx,
+      definition: convertDefinition(node.definition)
+    }
+  } else if (node instanceof RepetitionMandatoryWithSeparator) {
+    return <ISerializedTerminalWithSeparator>{
+      type: "RepetitionMandatoryWithSeparator",
+      idx: node.idx,
+      separator: <ISerializedTerminal>(
+        serializeProduction(new Terminal({ terminalType: node.separator }))
+      ),
+      definition: convertDefinition(node.definition)
+    }
+  } else if (node instanceof RepetitionWithSeparator) {
+    return <ISerializedTerminalWithSeparator>{
+      type: "RepetitionWithSeparator",
+      idx: node.idx,
+      separator: <ISerializedTerminal>(
+        serializeProduction(new Terminal({ terminalType: node.separator }))
+      ),
+      definition: convertDefinition(node.definition)
+    }
+  } else if (node instanceof Repetition) {
+    return <ISerializedBasic>{
+      type: "Repetition",
+      idx: node.idx,
+      definition: convertDefinition(node.definition)
+    }
+  } else if (node instanceof Alternation) {
+    return <ISerializedBasic>{
+      type: "Alternation",
+      idx: node.idx,
+      definition: convertDefinition(node.definition)
+    }
+  } else if (node instanceof Terminal) {
+    const serializedTerminal = <ISerializedTerminal>{
+      type: "Terminal",
+      name: node.terminalType.name,
+      label: tokenLabel(node.terminalType),
+      idx: node.idx
+    }
+
+    if (isString(node.label)) {
+      serializedTerminal.terminalLabel = node.label
+    }
+
+    const pattern = node.terminalType.PATTERN
+    if (node.terminalType.PATTERN) {
+      serializedTerminal.pattern = isRegExp(pattern)
+        ? (<any>pattern).source
+        : pattern
+    }
+
+    return serializedTerminal
+  } else if (node instanceof Rule) {
+    return <ISerializedGastRule>{
+      type: "Rule",
+      name: node.name,
+      orgText: node.orgText,
+      definition: convertDefinition(node.definition)
+    }
+  } else {
+    throw Error("non exhaustive match")
+  }
+}

_node_modules/@chevrotain/gast/src/visitor.ts

@@ -0,0 +1,76 @@
+import {
+  Alternation,
+  Alternative,
+  NonTerminal,
+  Option,
+  Repetition,
+  RepetitionMandatory,
+  RepetitionMandatoryWithSeparator,
+  RepetitionWithSeparator,
+  Rule,
+  Terminal
+} from "./model"
+import { IProduction } from "@chevrotain/types"
+
+export abstract class GAstVisitor {
+  public visit(node: IProduction): any {
+    const nodeAny: any = node
+    switch (nodeAny.constructor) {
+      case NonTerminal:
+        return this.visitNonTerminal(nodeAny)
+      case Alternative:
+        return this.visitAlternative(nodeAny)
+      case Option:
+        return this.visitOption(nodeAny)
+      case RepetitionMandatory:
+        return this.visitRepetitionMandatory(nodeAny)
+      case RepetitionMandatoryWithSeparator:
+        return this.visitRepetitionMandatoryWithSeparator(nodeAny)
+      case RepetitionWithSeparator:
+        return this.visitRepetitionWithSeparator(nodeAny)
+      case Repetition:
+        return this.visitRepetition(nodeAny)
+      case Alternation:
+        return this.visitAlternation(nodeAny)
+      case Terminal:
+        return this.visitTerminal(nodeAny)
+      case Rule:
+        return this.visitRule(nodeAny)
+      /* istanbul ignore next */
+      default:
+        throw Error("non exhaustive match")
+    }
+  }
+
+  /* istanbul ignore next - testing the fact a NOOP function exists is non-trivial  */
+  public visitNonTerminal(node: NonTerminal): any {}
+
+  /* istanbul ignore next - testing the fact a NOOP function exists is non-trivial  */
+  public visitAlternative(node: Alternative): any {}
+
+  /* istanbul ignore next - testing the fact a NOOP function exists is non-trivial  */
+  public visitOption(node: Option): any {}
+
+  /* istanbul ignore next - testing the fact a NOOP function exists is non-trivial  */
+  public visitRepetition(node: Repetition): any {}
+
+  /* istanbul ignore next - testing the fact a NOOP function exists is non-trivial  */
+  public visitRepetitionMandatory(node: RepetitionMandatory): any {}
+
+  /* istanbul ignore next - testing the fact a NOOP function exists is non-trivial  */
+  public visitRepetitionMandatoryWithSeparator(
+    node: RepetitionMandatoryWithSeparator
+  ): any {}
+
+  /* istanbul ignore next - testing the fact a NOOP function exists is non-trivial  */
+  public visitRepetitionWithSeparator(node: RepetitionWithSeparator): any {}
+
+  /* istanbul ignore next - testing the fact a NOOP function exists is non-trivial  */
+  public visitAlternation(node: Alternation): any {}
+
+  /* istanbul ignore next - testing the fact a NOOP function exists is non-trivial  */
+  public visitTerminal(node: Terminal): any {}
+
+  /* istanbul ignore next - testing the fact a NOOP function exists is non-trivial  */
+  public visitRule(node: Rule): any {}
+}