@contember/binding-common 2.1.0-alpha.3 → 2.1.0-alpha.35

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

@@ -1,722 +0,0 @@
-import { Lexer, EmbeddedActionsParser } 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(() => {
-        if (variableName === "rootWhereAsFilter") {
-          console.warn("$rootWhereAsFilter is deprecated, use $rootFilter");
-        }
-        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