@contember/binding-common 2.1.0-alpha.37 → 2.1.0-alpha.39

package/dist/production/src/queryLanguage/Parser.js

@@ -0,0 +1,711 @@
+import { EmbeddedActionsParser, Lexer } from "chevrotain";
+import { CacheStore } from "./CacheStore.js";
+import { QueryLanguageError } from "./QueryLanguageError.js";
+import { tokenList, tokens, TokenRegExps } from "./tokenList.js";
+import { BindingError } from "../BindingError.js";
+import { Environment } from "../environment/Environment.js";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const _Parser = class _Parser2 extends EmbeddedActionsParser {
+  constructor() {
+    super(tokenList, { outputCst: false, maxLookahead: 1 });
+    __publicField(this, "qualifiedEntityList", this.RULE("qualifiedEntityList", () => {
+      const entityName = this.SUBRULE(this.entityIdentifier);
+      const filter = this.OPTION(() => this.SUBRULE(this.nonUniqueWhere));
+      const relativeSingleEntity = this.OPTION1(() => {
+        this.CONSUME(tokens.Dot);
+        return this.SUBRULE(this.relativeSingleEntity);
+      });
+      const hasOneRelationPath = this.ACTION(() => relativeSingleEntity === void 0 ? [] : relativeSingleEntity.hasOneRelationPath);
+      return {
+        entityName,
+        filter,
+        hasOneRelationPath
+      };
+    }));
+    __publicField(this, "qualifiedFieldList", this.RULE("qualifiedFieldList", () => {
+      const entityName = this.SUBRULE(this.entityIdentifier);
+      const filter = this.OPTION(() => this.SUBRULE(this.nonUniqueWhere));
+      this.CONSUME(tokens.Dot);
+      const { hasOneRelationPath, field } = this.SUBRULE(this.relativeSingleField);
+      return {
+        entityName,
+        field,
+        filter,
+        hasOneRelationPath
+      };
+    }));
+    __publicField(this, "qualifiedSingleEntity", this.RULE("qualifiedSingleEntity", () => {
+      const entityName = this.SUBRULE(this.entityIdentifier);
+      const where = this.SUBRULE(this.uniqueWhere);
+      const filter = this.OPTION(() => this.SUBRULE(this.nonUniqueWhere));
+      const relativeSingleEntity = this.OPTION1(() => {
+        this.CONSUME(tokens.Dot);
+        return this.SUBRULE(this.relativeSingleEntity);
+      });
+      const hasOneRelationPath = this.ACTION(() => relativeSingleEntity === void 0 ? [] : relativeSingleEntity.hasOneRelationPath);
+      return {
+        entityName,
+        where,
+        hasOneRelationPath,
+        filter
+      };
+    }));
+    __publicField(this, "unconstrainedQualifiedEntityList", this.RULE(
+      "unconstrainedQualifiedEntityList",
+      () => {
+        const entityName = this.SUBRULE(this.entityIdentifier);
+        const relativeSingleEntity = this.OPTION(() => {
+          this.CONSUME(tokens.Dot);
+          return this.SUBRULE(this.relativeSingleEntity);
+        });
+        const hasOneRelationPath = this.ACTION(() => relativeSingleEntity === void 0 ? [] : relativeSingleEntity.hasOneRelationPath);
+        return {
+          entityName,
+          hasOneRelationPath
+        };
+      }
+    ));
+    __publicField(this, "unconstrainedQualifiedSingleEntity", this.RULE(
+      "unconstrainedQualifiedSingleEntity",
+      () => {
+        const entityName = this.SUBRULE(this.entityIdentifier);
+        const relativeSingleEntity = this.OPTION1(() => {
+          this.CONSUME(tokens.Dot);
+          return this.SUBRULE(this.relativeSingleEntity);
+        });
+        const hasOneRelationPath = this.ACTION(() => relativeSingleEntity === void 0 ? [] : relativeSingleEntity.hasOneRelationPath);
+        return {
+          entityName,
+          hasOneRelationPath
+        };
+      }
+    ));
+    __publicField(this, "relativeSingleField", this.RULE("relativeSingleField", () => {
+      let { hasOneRelationPath } = this.SUBRULE(this.relativeSingleEntity);
+      const last = this.ACTION(() => hasOneRelationPath.pop());
+      this.ACTION(() => {
+        if (last.reducedBy !== void 0 || last.filter !== void 0) {
+          throw new QueryLanguageError(
+            `Cannot parse '${_Parser2.rawInput}': the last field '${last.field}' is being reduced or filtered, which, grammatically, makes it a relation but a single field is expected.`
+          );
+        }
+      });
+      const field = this.ACTION(() => last.field);
+      return {
+        hasOneRelationPath,
+        field
+      };
+    }));
+    __publicField(this, "relativeSingleEntity", this.RULE("relativeSingleEntity", () => {
+      const hasOneRelationPath = [];
+      this.AT_LEAST_ONE_SEP({
+        SEP: tokens.Dot,
+        DEF: () => {
+          hasOneRelationPath.push(this.SUBRULE(this.hasOneRelation));
+        }
+      });
+      return {
+        hasOneRelationPath
+      };
+    }));
+    __publicField(this, "relativeEntityList", this.RULE("relativeEntityList", () => {
+      let { hasOneRelationPath } = this.SUBRULE(this.relativeSingleEntity);
+      const last = this.ACTION(() => hasOneRelationPath.pop());
+      this.ACTION(() => {
+        if (last.reducedBy !== void 0) {
+          throw new QueryLanguageError(
+            `Cannot parse '${_Parser2.rawInput}': the last field '${last.field}' is being reduced, which, grammatically, makes it a has-one relation but a has-many relation is expected.`
+          );
+        }
+      });
+      const hasManyRelation = this.ACTION(
+        () => ({
+          field: last.field,
+          filter: last.filter
+        })
+      );
+      return {
+        hasOneRelationPath,
+        hasManyRelation
+      };
+    }));
+    __publicField(this, "hasOneRelation", this.RULE("hasOneRelation", () => {
+      const fieldName = this.SUBRULE(this.fieldName);
+      const reducedBy = this.OPTION(() => this.SUBRULE(this.uniqueWhere));
+      const filter = this.OPTION1(() => this.SUBRULE(this.nonUniqueWhere));
+      const hasOneRelation = {
+        field: fieldName,
+        filter,
+        reducedBy
+      };
+      return hasOneRelation;
+    }));
+    __publicField(this, "nonUniqueWhere", this.RULE("nonUniqueWhere", () => {
+      const cnfWhere = [];
+      this.AT_LEAST_ONE(() => {
+        this.CONSUME(tokens.LeftBracket);
+        cnfWhere.push(this.SUBRULE(this.disjunction));
+        this.CONSUME(tokens.RightBracket);
+      });
+      if (cnfWhere.length === 1) {
+        return cnfWhere[0];
+      }
+      return {
+        and: cnfWhere
+      };
+    }));
+    __publicField(this, "disjunction", this.RULE("disjunction", () => {
+      const conjunctions = [];
+      this.AT_LEAST_ONE_SEP({
+        SEP: tokens.Or,
+        DEF: () => {
+          conjunctions.push(this.SUBRULE(this.conjunction));
+        }
+      });
+      if (conjunctions.length === 1) {
+        return conjunctions[0];
+      }
+      return {
+        or: conjunctions
+      };
+    }));
+    __publicField(this, "conjunction", this.RULE("conjunction", () => {
+      const negations = [];
+      this.AT_LEAST_ONE_SEP({
+        SEP: tokens.And,
+        DEF: () => {
+          negations.push(this.SUBRULE(this.negation));
+        }
+      });
+      if (negations.length === 1) {
+        return negations[0];
+      }
+      return {
+        and: negations
+      };
+    }));
+    __publicField(this, "negation", this.RULE("negation", () => {
+      return this.OR([
+        {
+          ALT: () => {
+            this.CONSUME(tokens.Not);
+            return {
+              not: this.SUBRULE(this.filterGroup)
+            };
+          }
+        },
+        {
+          ALT: () => {
+            return this.SUBRULE1(this.filterGroup);
+          }
+        }
+      ]);
+    }));
+    __publicField(this, "filterGroup", this.RULE("filterGroup", () => {
+      return this.OR([
+        {
+          ALT: () => {
+            this.CONSUME(tokens.LeftParenthesis);
+            const subFilter = this.SUBRULE(this.disjunction);
+            this.CONSUME1(tokens.RightParenthesis);
+            return subFilter;
+          }
+        },
+        {
+          ALT: () => this.SUBRULE1(this.filterAtom)
+        }
+      ]);
+    }));
+    __publicField(this, "filterAtom", this.RULE("filterAtom", () => {
+      return this.OR([
+        {
+          ALT: () => {
+            const variable = this.SUBRULE(this.variable);
+            return this.ACTION(() => {
+              if (typeof variable !== "object") {
+                throw new QueryLanguageError(`Invalid filter value '${JSON.stringify(variable)}'`);
+              }
+              return variable;
+            });
+          }
+        },
+        {
+          ALT: () => this.SUBRULE1(this.fieldWhere)
+        }
+      ]);
+    }));
+    __publicField(this, "fieldWhere", this.RULE("fieldWhere", () => {
+      const fields = [];
+      this.AT_LEAST_ONE_SEP({
+        SEP: tokens.Dot,
+        DEF: () => {
+          fields.push(this.SUBRULE(this.fieldIdentifierWithOptionalModifier));
+        }
+      });
+      const createFieldWhere = (value) => {
+        return this.ACTION(() => {
+          let val = value;
+          for (let i = fields.length - 1; i >= 0; i--) {
+            const field = fields[i];
+            if (field.modifier === "none") {
+              val = {
+                not: {
+                  [field.name]: val
+                }
+              };
+            } else if (field.modifier === "all") {
+              val = {
+                not: {
+                  [field.name]: { not: val }
+                }
+              };
+            } else if (!field.modifier || field.modifier === "some") {
+              val = {
+                [field.name]: val
+              };
+            } else {
+              throw new QueryLanguageError(`Unknown modifier '${field.modifier}', expected 'none', 'some' or 'all'`);
+            }
+          }
+          return val;
+        });
+      };
+      return this.OR([
+        {
+          ALT: () => {
+            const condition = this.SUBRULE(this.condition);
+            return createFieldWhere(condition);
+          }
+        },
+        {
+          ALT: () => {
+            const subWhere = this.SUBRULE(this.nonUniqueWhere);
+            return createFieldWhere(subWhere);
+          }
+        }
+      ]);
+    }));
+    __publicField(this, "condition", this.RULE("condition", () => {
+      const operator = this.SUBRULE(this.conditionOperator);
+      const columnValue = this.SUBRULE(this.columnValue);
+      const condition = {};
+      return this.ACTION(() => {
+        if (columnValue === null) {
+          if (operator === "eq") {
+            condition.null = true;
+          } else if (operator === "notEq") {
+            condition.null = false;
+          } else {
+            throw new QueryLanguageError(`The null keyword as a right hand operand can only be tested for (in)equality.`);
+          }
+          return condition;
+        }
+        condition[operator] = columnValue;
+        return condition;
+      });
+    }));
+    __publicField(this, "conditionOperator", this.RULE(
+      "conditionOperator",
+      () => {
+        return this.OR([
+          {
+            ALT: () => {
+              this.CONSUME(tokens.Equals);
+              return "eq";
+            }
+          },
+          {
+            ALT: () => {
+              this.CONSUME(tokens.NotEquals);
+              return "notEq";
+            }
+          },
+          {
+            ALT: () => {
+              this.CONSUME(tokens.LowerThan);
+              return "lt";
+            }
+          },
+          {
+            ALT: () => {
+              this.CONSUME(tokens.LowerEqual);
+              return "lte";
+            }
+          },
+          {
+            ALT: () => {
+              this.CONSUME(tokens.GreaterThan);
+              return "gt";
+            }
+          },
+          {
+            ALT: () => {
+              this.CONSUME(tokens.GreaterEqual);
+              return "gte";
+            }
+          }
+        ]);
+      }
+    ));
+    __publicField(this, "columnValue", this.RULE("columnValue", () => {
+      return this.OR([
+        {
+          ALT: () => {
+            this.CONSUME(tokens.Null);
+            return null;
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(tokens.True);
+            return true;
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(tokens.False);
+            return false;
+          }
+        },
+        {
+          ALT: () => this.SUBRULE(this.primaryValue)
+        }
+      ]);
+    }));
+    __publicField(this, "uniqueWhere", this.RULE("uniqueWhere", () => {
+      const where = {};
+      this.CONSUME(tokens.LeftParenthesis);
+      this.AT_LEAST_ONE_SEP({
+        SEP: tokens.Comma,
+        DEF: () => {
+          const nestedFields = [];
+          this.AT_LEAST_ONE_SEP1({
+            SEP: tokens.Dot,
+            DEF: () => {
+              nestedFields.push(this.SUBRULE(this.fieldIdentifier));
+            }
+          });
+          this.CONSUME(tokens.Equals);
+          const primaryValue = this.SUBRULE(this.primaryValue);
+          this.ACTION(() => {
+            let nestedWhere = where;
+            for (let i = 0, len = nestedFields.length; i < len; i++) {
+              const nestedField = nestedFields[i];
+              const isLast = len - 1 === i;
+              if (isLast) {
+                if (nestedField in nestedWhere) {
+                  throw new QueryLanguageError(`Duplicate '${nestedFields.slice(0, i + 1).join(".")}' field`);
+                }
+                nestedWhere[nestedField] = primaryValue;
+              } else {
+                if (nestedField in nestedWhere) {
+                  const existingWhere = nestedWhere[nestedField];
+                  if (typeof existingWhere === "object") {
+                    nestedWhere = existingWhere;
+                  } else {
+                    throw new QueryLanguageError(
+                      `Malformed expression: cannot simultaneously treat the '${nestedFields.slice(0, i + 1).join(".")}' field as a scalar as well as a relation.`
+                    );
+                  }
+                } else {
+                  const newWhere = {};
+                  nestedWhere[nestedField] = newWhere;
+                  nestedWhere = newWhere;
+                }
+              }
+            }
+          });
+        }
+      });
+      this.CONSUME(tokens.RightParenthesis);
+      return where;
+    }));
+    __publicField(this, "orderBy", this.RULE("orderBy", () => {
+      const order = [];
+      this.AT_LEAST_ONE_SEP({
+        SEP: tokens.Comma,
+        DEF: () => {
+          const fieldNames = [];
+          this.AT_LEAST_ONE_SEP1({
+            SEP: tokens.Dot,
+            DEF: () => {
+              fieldNames.push(this.SUBRULE(this.fieldIdentifier));
+            }
+          });
+          const literal = this.OPTION(() => this.SUBRULE1(this.identifier));
+          this.ACTION(() => {
+            let orderDirection;
+            if (literal) {
+              if (literal !== "asc" && literal !== "desc" && literal !== "ascNullsFirst" && literal !== "descNullsLast") {
+                throw new QueryLanguageError(`The only valid order directions are 'asc', 'desc', 'ascNullsFirst' and 'descNullsLast'.`);
+              }
+              orderDirection = literal;
+            } else {
+              orderDirection = "asc";
+            }
+            let orderBy = orderDirection;
+            for (let i = fieldNames.length - 1; i >= 0; i--) {
+              orderBy = { [fieldNames[i]]: orderBy };
+            }
+            order.push(orderBy);
+          });
+        }
+      });
+      return order;
+    }));
+    __publicField(this, "taggedMap", this.RULE("taggedMap", () => {
+      const name = this.SUBRULE(this.pageName);
+      return {
+        name,
+        entries: this.OPTION(() => this.SUBRULE(this.taggedMapEntries)) ?? []
+      };
+    }));
+    __publicField(this, "taggedMapEntries", this.RULE("taggedMapEntries", () => {
+      this.CONSUME(tokens.LeftParenthesis);
+      const entries = [];
+      this.AT_LEAST_ONE_SEP({
+        SEP: tokens.Comma,
+        DEF: () => entries.push(this.SUBRULE(this.taggedMapEntry))
+      });
+      this.CONSUME(tokens.RightParenthesis);
+      return entries;
+    }));
+    __publicField(this, "taggedMapEntry", this.RULE("taggedMapEntry", () => {
+      const variableName = this.CONSUME(tokens.Identifier).image;
+      this.CONSUME1(tokens.Colon);
+      const value = this.OR([
+        {
+          ALT: () => this.SUBRULE(this.taggedMapLiteralValue)
+        },
+        {
+          ALT: () => this.SUBRULE(this.taggedMapVariableValue)
+        }
+      ]);
+      return {
+        key: variableName,
+        value
+      };
+    }));
+    __publicField(this, "taggedMapLiteralValue", this.RULE("taggedMapLiteralValue", () => {
+      const value = this.OR([
+        {
+          ALT: () => this.SUBRULE(this.string)
+        },
+        {
+          ALT: () => this.SUBRULE(this.number)
+        }
+      ]);
+      return {
+        type: "literal",
+        value
+      };
+    }));
+    __publicField(this, "taggedMapVariableValue", this.RULE("taggedMapVariableValue", () => {
+      const start = this.CONSUME(tokens.DollarSign);
+      this.SUBRULE(this.relativeSingleField);
+      const end = this.LA(0);
+      const field = this.input.slice(this.input.indexOf(start) + 1, this.input.indexOf(end) + 1).map((it) => it.image).join("");
+      return {
+        type: "variable",
+        value: field
+      };
+    }));
+    __publicField(this, "fieldName", this.RULE("fieldName", () => {
+      return this.OR([
+        {
+          ALT: () => this.SUBRULE(this.fieldIdentifier)
+        }
+      ]);
+    }));
+    __publicField(this, "primaryValue", this.RULE("primaryValue", () => {
+      return this.OR([
+        {
+          ALT: () => this.SUBRULE(this.string)
+        },
+        {
+          ALT: () => this.SUBRULE(this.number)
+        },
+        {
+          ALT: () => this.SUBRULE(this.identifier)
+        },
+        {
+          ALT: () => {
+            const variableValue = this.SUBRULE(this.variable);
+            return this.ACTION(() => {
+              if (typeof variableValue === "string" || typeof variableValue === "number") {
+                return variableValue;
+              }
+              throw new QueryLanguageError(
+                `A variable can resolve to a literal, string or a number, not ${typeof variableValue}`
+              );
+            });
+          }
+        }
+      ]);
+    }));
+    __publicField(this, "fieldIdentifierWithOptionalModifier", this.RULE("fieldIdentifierWithOptionalModifier", () => {
+      const fieldIdentifier = this.SUBRULE1(this.fieldIdentifier);
+      const modifier = this.OPTION(() => {
+        this.CONSUME(tokens.Colon);
+        return this.SUBRULE(this.identifier);
+      });
+      return { name: fieldIdentifier, modifier };
+    }));
+    __publicField(this, "fieldIdentifier", this.RULE("fieldIdentifier", () => {
+      return this.SUBRULE(this.identifier);
+    }));
+    __publicField(this, "identifier", this.RULE("identifier", () => {
+      return this.OR([
+        {
+          ALT: () => this.CONSUME(tokens.Identifier).image
+        },
+        {
+          // TODO this is a temporary hack to allow for literals that start with an uppercase letter… 🙈
+          ALT: () => this.CONSUME(tokens.EntityIdentifier).image
+        }
+      ]);
+    }));
+    __publicField(this, "pageName", this.RULE("pageName", () => {
+      const parts = [];
+      this.AT_LEAST_ONE_SEP({
+        SEP: tokens.Slash,
+        DEF: () => parts.push(this.CONSUME(tokens.Identifier).image)
+      });
+      return parts.join("/");
+    }));
+    __publicField(this, "entityIdentifier", this.RULE("entityIdentifier", () => {
+      return this.OR([
+        {
+          ALT: () => this.CONSUME(tokens.EntityIdentifier).image
+        },
+        {
+          ALT: () => {
+            const variable = this.SUBRULE(this.variable);
+            return this.ACTION(() => {
+              if (!(typeof variable === "string") || !TokenRegExps.entityIdentifier.test(variable)) {
+                throw new QueryLanguageError(`The value of the variable $${variable} is not a valid entity identifier.`);
+              }
+              return variable;
+            });
+          }
+        }
+      ]);
+    }));
+    __publicField(this, "string", this.RULE("string", () => {
+      const image = this.CONSUME(tokens.StringLiteral).image;
+      return image.substring(1, image.length - 1).replace("\\'", "'").replace(`\\"`, `"`).replace("\\b", "\b").replace("\\f", "\f").replace("\\n", "\n").replace("\\r", "\r").replace("\\t", "	").replace("\\v", "\v");
+    }));
+    __publicField(this, "number", this.RULE("number", () => {
+      return parseFloat(this.CONSUME(tokens.NumberLiteral).image);
+    }));
+    __publicField(this, "variable", this.RULE("variable", () => {
+      this.CONSUME(tokens.DollarSign);
+      const variableName = this.CONSUME(tokens.Identifier).image;
+      return this.ACTION(() => {
+        switch (variableName) {
+          case "rootWhereAsFilter":
+          case "rootFilter":
+            return _Parser2.environment.getSubTree().filter;
+        }
+        if (_Parser2.environment.hasVariable(variableName)) {
+          return _Parser2.environment.getVariable(variableName);
+        }
+        if (_Parser2.environment.hasParameter(variableName)) {
+          return _Parser2.environment.getParameter(variableName);
+        }
+        if (_Parser2.environment.hasDimension(variableName)) {
+          const dimensionValue = _Parser2.environment.getDimension(variableName);
+          if (dimensionValue.length > 1) {
+            throw new BindingError(
+              `The variable $${variableName} resolved to a dimension which exists but contains ${dimensionValue.length} values. It has to contain exactly one. Perhaps you forgot to set the 'maxItems' prop of your DimensionsSwitcher?`
+            );
+          }
+          return dimensionValue[0];
+        }
+        throw new QueryLanguageError(`Undefined variable $${variableName}.`);
+      });
+    }));
+    this.performSelfAnalysis();
+  }
+  static parseQueryLanguageExpression(input, entry, environment) {
+    const cached = this.cacheStore.get(environment, entry, input);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const lexingResult = _Parser2.lexer.tokenize(_Parser2.rawInput = input);
+    if (lexingResult.errors.length !== 0) {
+      throw new QueryLanguageError(
+        `Failed to tokenize '${input}'.
+
+${lexingResult.errors.map((i) => i.message).join("\n")}`
+      );
+    }
+    _Parser2.environment = environment;
+    _Parser2.parser.input = lexingResult.tokens;
+    let expression;
+    switch (entry) {
+      case "relativeSingleField":
+        expression = _Parser2.parser.relativeSingleField();
+        break;
+      case "relativeSingleEntity":
+        expression = _Parser2.parser.relativeSingleEntity();
+        break;
+      case "relativeEntityList":
+        expression = _Parser2.parser.relativeEntityList();
+        break;
+      case "qualifiedEntityList":
+        expression = _Parser2.parser.qualifiedEntityList();
+        break;
+      case "qualifiedFieldList":
+        expression = _Parser2.parser.qualifiedFieldList();
+        break;
+      case "qualifiedSingleEntity":
+        expression = _Parser2.parser.qualifiedSingleEntity();
+        break;
+      case "unconstrainedQualifiedEntityList":
+        expression = _Parser2.parser.unconstrainedQualifiedEntityList();
+        break;
+      case "unconstrainedQualifiedSingleEntity":
+        expression = _Parser2.parser.unconstrainedQualifiedSingleEntity();
+        break;
+      case "uniqueWhere":
+        expression = _Parser2.parser.uniqueWhere();
+        break;
+      case "filter":
+        expression = _Parser2.parser.nonUniqueWhere();
+        break;
+      case "orderBy":
+        expression = _Parser2.parser.orderBy();
+        break;
+      case "taggedMap":
+        expression = _Parser2.parser.taggedMap();
+        break;
+      case "columnValue":
+        expression = _Parser2.parser.columnValue();
+        break;
+      default:
+        throw new QueryLanguageError(`Not implemented entry point '${entry}'`);
+    }
+    if (_Parser2.parser.errors.length !== 0) {
+      throw new QueryLanguageError(
+        `Failed to parse '${input}'.
+
+${_Parser2.parser.errors.map((i) => i.message).join("\n")}`
+      );
+    }
+    this.cacheStore.set(environment, entry, input, expression);
+    return expression;
+  }
+};
+__publicField(_Parser, "rawInput", "");
+__publicField(_Parser, "lexer", new Lexer(tokenList));
+__publicField(_Parser, "parser", new _Parser());
+__publicField(_Parser, "environment", Environment.create());
+__publicField(_Parser, "cacheStore", new CacheStore());
+let Parser = _Parser;
+export {
+  Parser
+};
+//# sourceMappingURL=Parser.js.map