@verbb/plugin-kit-react 1.0.0

package/dist/node_modules/jexl/dist/evaluator/Evaluator.js

@@ -0,0 +1,98 @@
+import { __commonJSMin } from "../../../../_virtual/_rolldown/runtime.js";
+import { require_interopRequireDefault } from "../../../@babel/runtime/helpers/interopRequireDefault.js";
+import { require_classCallCheck } from "../../../@babel/runtime/helpers/classCallCheck.js";
+import { require_createClass } from "../../../@babel/runtime/helpers/createClass.js";
+import { require_handlers } from "./handlers.js";
+//#region ../node_modules/jexl/dist/evaluator/Evaluator.js
+var require_Evaluator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var _interopRequireDefault = require_interopRequireDefault();
+	var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
+	var _createClass2 = _interopRequireDefault(require_createClass());
+	var handlers = require_handlers();
+	module.exports = /* @__PURE__ */ function() {
+		function Evaluator(grammar, context, relativeContext) {
+			var promise = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : Promise;
+			(0, _classCallCheck2.default)(this, Evaluator);
+			this._grammar = grammar;
+			this._context = context || {};
+			this._relContext = relativeContext || this._context;
+			this.Promise = promise;
+		}
+		/**
+		* Evaluates an expression tree within the configured context.
+		* @param {{}} ast An expression tree object
+		* @returns {Promise<*>} resolves with the resulting value of the expression.
+		*/
+		(0, _createClass2.default)(Evaluator, [
+			{
+				key: "eval",
+				value: function _eval(ast) {
+					var _this = this;
+					return this.Promise.resolve().then(function() {
+						return handlers[ast.type].call(_this, ast);
+					});
+				}
+			},
+			{
+				key: "evalArray",
+				value: function evalArray(arr) {
+					var _this2 = this;
+					return this.Promise.all(arr.map(function(elem) {
+						return _this2.eval(elem);
+					}));
+				}
+			},
+			{
+				key: "evalMap",
+				value: function evalMap(map) {
+					var _this3 = this;
+					var keys = Object.keys(map);
+					var result = {};
+					var asts = keys.map(function(key) {
+						return _this3.eval(map[key]);
+					});
+					return this.Promise.all(asts).then(function(vals) {
+						vals.forEach(function(val, idx) {
+							result[keys[idx]] = val;
+						});
+						return result;
+					});
+				}
+			},
+			{
+				key: "_filterRelative",
+				value: function _filterRelative(subject, expr) {
+					var _this4 = this;
+					var promises = [];
+					if (!Array.isArray(subject)) subject = subject === void 0 ? [] : [subject];
+					subject.forEach(function(elem) {
+						var evalInst = new Evaluator(_this4._grammar, _this4._context, elem, _this4.Promise);
+						promises.push(evalInst.eval(expr));
+					});
+					return this.Promise.all(promises).then(function(values) {
+						var results = [];
+						values.forEach(function(value, idx) {
+							if (value) results.push(subject[idx]);
+						});
+						return results;
+					});
+				}
+			},
+			{
+				key: "_filterStatic",
+				value: function _filterStatic(subject, expr) {
+					return this.eval(expr).then(function(res) {
+						if (typeof res === "boolean") return res ? subject : void 0;
+						return subject[res];
+					});
+				}
+			}
+		]);
+		return Evaluator;
+	}();
+}));
+//#endregion
+export default require_Evaluator();
+export { require_Evaluator };
+
+//# sourceMappingURL=Evaluator.js.map

package/dist/node_modules/jexl/dist/evaluator/Evaluator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Evaluator.js","names":[],"sources":["../../../../../../node_modules/jexl/dist/evaluator/Evaluator.js"],"sourcesContent":["\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _classCallCheck2 = _interopRequireDefault(require(\"@babel/runtime/helpers/classCallCheck\"));\n\nvar _createClass2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createClass\"));\n\n/*\n * Jexl\n * Copyright 2020 Tom Shawver\n */\nvar handlers = require('./handlers');\n/**\n * The Evaluator takes a Jexl expression tree as generated by the\n * {@link Parser} and calculates its value within a given context. The\n * collection of transforms, context, and a relative context to be used as the\n * root for relative identifiers, are all specific to an Evaluator instance.\n * When any of these things change, a new instance is required.  However, a\n * single instance can be used to simultaneously evaluate many different\n * expressions, and does not have to be reinstantiated for each.\n * @param {{}} grammar A grammar object against which to evaluate the expression\n *      tree\n * @param {{}} [context] A map of variable keys to their values. This will be\n *      accessed to resolve the value of each non-relative identifier. Any\n *      Promise values will be passed to the expression as their resolved\n *      value.\n * @param {{}|Array<{}|Array>} [relativeContext] A map or array to be accessed\n *      to resolve the value of a relative identifier.\n * @param {function} promise A constructor for the Promise class to be used;\n *      probably either Promise or PromiseSync.\n */\n\n\nvar Evaluator = /*#__PURE__*/function () {\n  function Evaluator(grammar, context, relativeContext) {\n    var promise = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : Promise;\n    (0, _classCallCheck2.default)(this, Evaluator);\n    this._grammar = grammar;\n    this._context = context || {};\n    this._relContext = relativeContext || this._context;\n    this.Promise = promise;\n  }\n  /**\n   * Evaluates an expression tree within the configured context.\n   * @param {{}} ast An expression tree object\n   * @returns {Promise<*>} resolves with the resulting value of the expression.\n   */\n\n\n  (0, _createClass2.default)(Evaluator, [{\n    key: \"eval\",\n    value: function _eval(ast) {\n      var _this = this;\n\n      return this.Promise.resolve().then(function () {\n        return handlers[ast.type].call(_this, ast);\n      });\n    }\n    /**\n     * Simultaneously evaluates each expression within an array, and delivers the\n     * response as an array with the resulting values at the same indexes as their\n     * originating expressions.\n     * @param {Array<string>} arr An array of expression strings to be evaluated\n     * @returns {Promise<Array<{}>>} resolves with the result array\n     */\n\n  }, {\n    key: \"evalArray\",\n    value: function evalArray(arr) {\n      var _this2 = this;\n\n      return this.Promise.all(arr.map(function (elem) {\n        return _this2.eval(elem);\n      }));\n    }\n    /**\n     * Simultaneously evaluates each expression within a map, and delivers the\n     * response as a map with the same keys, but with the evaluated result for each\n     * as their value.\n     * @param {{}} map A map of expression names to expression trees to be\n     *      evaluated\n     * @returns {Promise<{}>} resolves with the result map.\n     */\n\n  }, {\n    key: \"evalMap\",\n    value: function evalMap(map) {\n      var _this3 = this;\n\n      var keys = Object.keys(map);\n      var result = {};\n      var asts = keys.map(function (key) {\n        return _this3.eval(map[key]);\n      });\n      return this.Promise.all(asts).then(function (vals) {\n        vals.forEach(function (val, idx) {\n          result[keys[idx]] = val;\n        });\n        return result;\n      });\n    }\n    /**\n     * Applies a filter expression with relative identifier elements to a subject.\n     * The intent is for the subject to be an array of subjects that will be\n     * individually used as the relative context against the provided expression\n     * tree. Only the elements whose expressions result in a truthy value will be\n     * included in the resulting array.\n     *\n     * If the subject is not an array of values, it will be converted to a single-\n     * element array before running the filter.\n     * @param {*} subject The value to be filtered usually an array. If this value is\n     *      not an array, it will be converted to an array with this value as the\n     *      only element.\n     * @param {{}} expr The expression tree to run against each subject. If the\n     *      tree evaluates to a truthy result, then the value will be included in\n     *      the returned array otherwise, it will be eliminated.\n     * @returns {Promise<Array>} resolves with an array of values that passed the\n     *      expression filter.\n     * @private\n     */\n\n  }, {\n    key: \"_filterRelative\",\n    value: function _filterRelative(subject, expr) {\n      var _this4 = this;\n\n      var promises = [];\n\n      if (!Array.isArray(subject)) {\n        subject = subject === undefined ? [] : [subject];\n      }\n\n      subject.forEach(function (elem) {\n        var evalInst = new Evaluator(_this4._grammar, _this4._context, elem, _this4.Promise);\n        promises.push(evalInst.eval(expr));\n      });\n      return this.Promise.all(promises).then(function (values) {\n        var results = [];\n        values.forEach(function (value, idx) {\n          if (value) {\n            results.push(subject[idx]);\n          }\n        });\n        return results;\n      });\n    }\n    /**\n     * Applies a static filter expression to a subject value.  If the filter\n     * expression evaluates to boolean true, the subject is returned if false,\n     * undefined.\n     *\n     * For any other resulting value of the expression, this function will attempt\n     * to respond with the property at that name or index of the subject.\n     * @param {*} subject The value to be filtered.  Usually an Array (for which\n     *      the expression would generally resolve to a numeric index) or an\n     *      Object (for which the expression would generally resolve to a string\n     *      indicating a property name)\n     * @param {{}} expr The expression tree to run against the subject\n     * @returns {Promise<*>} resolves with the value of the drill-down.\n     * @private\n     */\n\n  }, {\n    key: \"_filterStatic\",\n    value: function _filterStatic(subject, expr) {\n      return this.eval(expr).then(function (res) {\n        if (typeof res === 'boolean') {\n          return res ? subject : undefined;\n        }\n\n        return subject[res];\n      });\n    }\n  }]);\n  return Evaluator;\n}();\n\nmodule.exports = Evaluator;"],"x_google_ignoreList":[0],"mappings":";;;;;;;CAEA,IAAI,yBAAA,+BAAA;CAEJ,IAAI,mBAAmB,uBAAA,wBAAA,CAAwE;CAE/F,IAAI,gBAAgB,uBAAA,qBAAA,CAAqE;CAMzF,IAAI,WAAA,kBAAA;AAsKJ,QAAO,UAAU,gBAhJY,WAAY;EACvC,SAAS,UAAU,SAAS,SAAS,iBAAiB;GACpD,IAAI,UAAU,UAAU,SAAS,KAAK,UAAU,OAAO,KAAA,IAAY,UAAU,KAAK;AAClF,IAAC,GAAG,iBAAiB,SAAS,MAAM,UAAU;AAC9C,QAAK,WAAW;AAChB,QAAK,WAAW,WAAW,EAAE;AAC7B,QAAK,cAAc,mBAAmB,KAAK;AAC3C,QAAK,UAAU;;;;;;;AASjB,GAAC,GAAG,cAAc,SAAS,WAAW;GAAC;IACrC,KAAK;IACL,OAAO,SAAS,MAAM,KAAK;KACzB,IAAI,QAAQ;AAEZ,YAAO,KAAK,QAAQ,SAAS,CAAC,KAAK,WAAY;AAC7C,aAAO,SAAS,IAAI,MAAM,KAAK,OAAO,IAAI;OAC1C;;IAUL;GAAE;IACD,KAAK;IACL,OAAO,SAAS,UAAU,KAAK;KAC7B,IAAI,SAAS;AAEb,YAAO,KAAK,QAAQ,IAAI,IAAI,IAAI,SAAU,MAAM;AAC9C,aAAO,OAAO,KAAK,KAAK;OACxB,CAAC;;IAWN;GAAE;IACD,KAAK;IACL,OAAO,SAAS,QAAQ,KAAK;KAC3B,IAAI,SAAS;KAEb,IAAI,OAAO,OAAO,KAAK,IAAI;KAC3B,IAAI,SAAS,EAAE;KACf,IAAI,OAAO,KAAK,IAAI,SAAU,KAAK;AACjC,aAAO,OAAO,KAAK,IAAI,KAAK;OAC5B;AACF,YAAO,KAAK,QAAQ,IAAI,KAAK,CAAC,KAAK,SAAU,MAAM;AACjD,WAAK,QAAQ,SAAU,KAAK,KAAK;AAC/B,cAAO,KAAK,QAAQ;QACpB;AACF,aAAO;OACP;;IAsBL;GAAE;IACD,KAAK;IACL,OAAO,SAAS,gBAAgB,SAAS,MAAM;KAC7C,IAAI,SAAS;KAEb,IAAI,WAAW,EAAE;AAEjB,SAAI,CAAC,MAAM,QAAQ,QAAQ,CACzB,WAAU,YAAY,KAAA,IAAY,EAAE,GAAG,CAAC,QAAQ;AAGlD,aAAQ,QAAQ,SAAU,MAAM;MAC9B,IAAI,WAAW,IAAI,UAAU,OAAO,UAAU,OAAO,UAAU,MAAM,OAAO,QAAQ;AACpF,eAAS,KAAK,SAAS,KAAK,KAAK,CAAC;OAClC;AACF,YAAO,KAAK,QAAQ,IAAI,SAAS,CAAC,KAAK,SAAU,QAAQ;MACvD,IAAI,UAAU,EAAE;AAChB,aAAO,QAAQ,SAAU,OAAO,KAAK;AACnC,WAAI,MACF,SAAQ,KAAK,QAAQ,KAAK;QAE5B;AACF,aAAO;OACP;;IAkBL;GAAE;IACD,KAAK;IACL,OAAO,SAAS,cAAc,SAAS,MAAM;AAC3C,YAAO,KAAK,KAAK,KAAK,CAAC,KAAK,SAAU,KAAK;AACzC,UAAI,OAAO,QAAQ,UACjB,QAAO,MAAM,UAAU,KAAA;AAGzB,aAAO,QAAQ;OACf;;IAEL;GAAC,CAAC;AACH,SAAO;IAGQ"}

package/dist/node_modules/jexl/dist/evaluator/handlers.js

@@ -0,0 +1,162 @@
+import { __commonJSMin } from "../../../../_virtual/_rolldown/runtime.js";
+import { require_interopRequireDefault } from "../../../@babel/runtime/helpers/interopRequireDefault.js";
+import { require_toConsumableArray } from "../../../@babel/runtime/helpers/toConsumableArray.js";
+//#region ../node_modules/jexl/dist/evaluator/handlers.js
+var require_handlers = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var _toConsumableArray2 = require_interopRequireDefault()(require_toConsumableArray());
+	var poolNames = {
+		functions: "Jexl Function",
+		transforms: "Transform"
+	};
+	/**
+	* Evaluates an ArrayLiteral by returning its value, with each element
+	* independently run through the evaluator.
+	* @param {{type: 'ObjectLiteral', value: <{}>}} ast An expression tree with an
+	*      ObjectLiteral as the top node
+	* @returns {Promise.<[]>} resolves to a map contained evaluated values.
+	* @private
+	*/
+	exports.ArrayLiteral = function(ast) {
+		return this.evalArray(ast.value);
+	};
+	/**
+	* Evaluates a BinaryExpression node by running the Grammar's evaluator for
+	* the given operator. Note that binary expressions support two types of
+	* evaluators: `eval` is called with the left and right operands pre-evaluated.
+	* `evalOnDemand`, if it exists, will be called with the left and right operands
+	* each individually wrapped in an object with an "eval" function that returns
+	* a promise with the resulting value. This allows the binary expression to
+	* evaluate the operands conditionally.
+	* @param {{type: 'BinaryExpression', operator: <string>, left: {},
+	*      right: {}}} ast An expression tree with a BinaryExpression as the top
+	*      node
+	* @returns {Promise<*>} resolves with the value of the BinaryExpression.
+	* @private
+	*/
+	exports.BinaryExpression = function(ast) {
+		var _this = this;
+		var grammarOp = this._grammar.elements[ast.operator];
+		if (grammarOp.evalOnDemand) {
+			var wrap = function wrap(subAst) {
+				return { eval: function _eval() {
+					return _this.eval(subAst);
+				} };
+			};
+			return grammarOp.evalOnDemand(wrap(ast.left), wrap(ast.right));
+		}
+		return this.Promise.all([this.eval(ast.left), this.eval(ast.right)]).then(function(arr) {
+			return grammarOp.eval(arr[0], arr[1]);
+		});
+	};
+	/**
+	* Evaluates a ConditionalExpression node by first evaluating its test branch,
+	* and resolving with the consequent branch if the test is truthy, or the
+	* alternate branch if it is not. If there is no consequent branch, the test
+	* result will be used instead.
+	* @param {{type: 'ConditionalExpression', test: {}, consequent: {},
+	*      alternate: {}}} ast An expression tree with a ConditionalExpression as
+	*      the top node
+	* @private
+	*/
+	exports.ConditionalExpression = function(ast) {
+		var _this2 = this;
+		return this.eval(ast.test).then(function(res) {
+			if (res) {
+				if (ast.consequent) return _this2.eval(ast.consequent);
+				return res;
+			}
+			return _this2.eval(ast.alternate);
+		});
+	};
+	/**
+	* Evaluates a FilterExpression by applying it to the subject value.
+	* @param {{type: 'FilterExpression', relative: <boolean>, expr: {},
+	*      subject: {}}} ast An expression tree with a FilterExpression as the top
+	*      node
+	* @returns {Promise<*>} resolves with the value of the FilterExpression.
+	* @private
+	*/
+	exports.FilterExpression = function(ast) {
+		var _this3 = this;
+		return this.eval(ast.subject).then(function(subject) {
+			if (ast.relative) return _this3._filterRelative(subject, ast.expr);
+			return _this3._filterStatic(subject, ast.expr);
+		});
+	};
+	/**
+	* Evaluates an Identifier by either stemming from the evaluated 'from'
+	* expression tree or accessing the context provided when this Evaluator was
+	* constructed.
+	* @param {{type: 'Identifier', value: <string>, [from]: {}}} ast An expression
+	*      tree with an Identifier as the top node
+	* @returns {Promise<*>|*} either the identifier's value, or a Promise that
+	*      will resolve with the identifier's value.
+	* @private
+	*/
+	exports.Identifier = function(ast) {
+		if (!ast.from) return ast.relative ? this._relContext[ast.value] : this._context[ast.value];
+		return this.eval(ast.from).then(function(context) {
+			if (context === void 0 || context === null) return;
+			if (Array.isArray(context)) context = context[0];
+			return context[ast.value];
+		});
+	};
+	/**
+	* Evaluates a Literal by returning its value property.
+	* @param {{type: 'Literal', value: <string|number|boolean>}} ast An expression
+	*      tree with a Literal as its only node
+	* @returns {string|number|boolean} The value of the Literal node
+	* @private
+	*/
+	exports.Literal = function(ast) {
+		return ast.value;
+	};
+	/**
+	* Evaluates an ObjectLiteral by returning its value, with each key
+	* independently run through the evaluator.
+	* @param {{type: 'ObjectLiteral', value: <{}>}} ast An expression tree with an
+	*      ObjectLiteral as the top node
+	* @returns {Promise<{}>} resolves to a map contained evaluated values.
+	* @private
+	*/
+	exports.ObjectLiteral = function(ast) {
+		return this.evalMap(ast.value);
+	};
+	/**
+	* Evaluates a FunctionCall node by applying the supplied arguments to a
+	* function defined in one of the grammar's function pools.
+	* @param {{type: 'FunctionCall', name: <string>}} ast An
+	*      expression tree with a FunctionCall as the top node
+	* @returns {Promise<*>|*} the value of the function call, or a Promise that
+	*      will resolve with the resulting value.
+	* @private
+	*/
+	exports.FunctionCall = function(ast) {
+		var poolName = poolNames[ast.pool];
+		if (!poolName) throw new Error("Corrupt AST: Pool '".concat(ast.pool, "' not found"));
+		var func = this._grammar[ast.pool][ast.name];
+		if (!func) throw new Error("".concat(poolName, " ").concat(ast.name, " is not defined."));
+		return this.evalArray(ast.args || []).then(function(args) {
+			return func.apply(void 0, (0, _toConsumableArray2.default)(args));
+		});
+	};
+	/**
+	* Evaluates a Unary expression by passing the right side through the
+	* operator's eval function.
+	* @param {{type: 'UnaryExpression', operator: <string>, right: {}}} ast An
+	*      expression tree with a UnaryExpression as the top node
+	* @returns {Promise<*>} resolves with the value of the UnaryExpression.
+	* @constructor
+	*/
+	exports.UnaryExpression = function(ast) {
+		var _this4 = this;
+		return this.eval(ast.right).then(function(right) {
+			return _this4._grammar.elements[ast.operator].eval(right);
+		});
+	};
+}));
+//#endregion
+export default require_handlers();
+export { require_handlers };
+
+//# sourceMappingURL=handlers.js.map

package/dist/node_modules/jexl/dist/evaluator/handlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.js","names":[],"sources":["../../../../../../node_modules/jexl/dist/evaluator/handlers.js"],"sourcesContent":["\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _toConsumableArray2 = _interopRequireDefault(require(\"@babel/runtime/helpers/toConsumableArray\"));\n\n/*\n * Jexl\n * Copyright 2020 Tom Shawver\n */\nvar poolNames = {\n  functions: 'Jexl Function',\n  transforms: 'Transform'\n};\n/**\n * Evaluates an ArrayLiteral by returning its value, with each element\n * independently run through the evaluator.\n * @param {{type: 'ObjectLiteral', value: <{}>}} ast An expression tree with an\n *      ObjectLiteral as the top node\n * @returns {Promise.<[]>} resolves to a map contained evaluated values.\n * @private\n */\n\nexports.ArrayLiteral = function (ast) {\n  return this.evalArray(ast.value);\n};\n/**\n * Evaluates a BinaryExpression node by running the Grammar's evaluator for\n * the given operator. Note that binary expressions support two types of\n * evaluators: `eval` is called with the left and right operands pre-evaluated.\n * `evalOnDemand`, if it exists, will be called with the left and right operands\n * each individually wrapped in an object with an \"eval\" function that returns\n * a promise with the resulting value. This allows the binary expression to\n * evaluate the operands conditionally.\n * @param {{type: 'BinaryExpression', operator: <string>, left: {},\n *      right: {}}} ast An expression tree with a BinaryExpression as the top\n *      node\n * @returns {Promise<*>} resolves with the value of the BinaryExpression.\n * @private\n */\n\n\nexports.BinaryExpression = function (ast) {\n  var _this = this;\n\n  var grammarOp = this._grammar.elements[ast.operator];\n\n  if (grammarOp.evalOnDemand) {\n    var wrap = function wrap(subAst) {\n      return {\n        eval: function _eval() {\n          return _this.eval(subAst);\n        }\n      };\n    };\n\n    return grammarOp.evalOnDemand(wrap(ast.left), wrap(ast.right));\n  }\n\n  return this.Promise.all([this.eval(ast.left), this.eval(ast.right)]).then(function (arr) {\n    return grammarOp.eval(arr[0], arr[1]);\n  });\n};\n/**\n * Evaluates a ConditionalExpression node by first evaluating its test branch,\n * and resolving with the consequent branch if the test is truthy, or the\n * alternate branch if it is not. If there is no consequent branch, the test\n * result will be used instead.\n * @param {{type: 'ConditionalExpression', test: {}, consequent: {},\n *      alternate: {}}} ast An expression tree with a ConditionalExpression as\n *      the top node\n * @private\n */\n\n\nexports.ConditionalExpression = function (ast) {\n  var _this2 = this;\n\n  return this.eval(ast.test).then(function (res) {\n    if (res) {\n      if (ast.consequent) {\n        return _this2.eval(ast.consequent);\n      }\n\n      return res;\n    }\n\n    return _this2.eval(ast.alternate);\n  });\n};\n/**\n * Evaluates a FilterExpression by applying it to the subject value.\n * @param {{type: 'FilterExpression', relative: <boolean>, expr: {},\n *      subject: {}}} ast An expression tree with a FilterExpression as the top\n *      node\n * @returns {Promise<*>} resolves with the value of the FilterExpression.\n * @private\n */\n\n\nexports.FilterExpression = function (ast) {\n  var _this3 = this;\n\n  return this.eval(ast.subject).then(function (subject) {\n    if (ast.relative) {\n      return _this3._filterRelative(subject, ast.expr);\n    }\n\n    return _this3._filterStatic(subject, ast.expr);\n  });\n};\n/**\n * Evaluates an Identifier by either stemming from the evaluated 'from'\n * expression tree or accessing the context provided when this Evaluator was\n * constructed.\n * @param {{type: 'Identifier', value: <string>, [from]: {}}} ast An expression\n *      tree with an Identifier as the top node\n * @returns {Promise<*>|*} either the identifier's value, or a Promise that\n *      will resolve with the identifier's value.\n * @private\n */\n\n\nexports.Identifier = function (ast) {\n  if (!ast.from) {\n    return ast.relative ? this._relContext[ast.value] : this._context[ast.value];\n  }\n\n  return this.eval(ast.from).then(function (context) {\n    if (context === undefined || context === null) {\n      return undefined;\n    }\n\n    if (Array.isArray(context)) {\n      context = context[0];\n    }\n\n    return context[ast.value];\n  });\n};\n/**\n * Evaluates a Literal by returning its value property.\n * @param {{type: 'Literal', value: <string|number|boolean>}} ast An expression\n *      tree with a Literal as its only node\n * @returns {string|number|boolean} The value of the Literal node\n * @private\n */\n\n\nexports.Literal = function (ast) {\n  return ast.value;\n};\n/**\n * Evaluates an ObjectLiteral by returning its value, with each key\n * independently run through the evaluator.\n * @param {{type: 'ObjectLiteral', value: <{}>}} ast An expression tree with an\n *      ObjectLiteral as the top node\n * @returns {Promise<{}>} resolves to a map contained evaluated values.\n * @private\n */\n\n\nexports.ObjectLiteral = function (ast) {\n  return this.evalMap(ast.value);\n};\n/**\n * Evaluates a FunctionCall node by applying the supplied arguments to a\n * function defined in one of the grammar's function pools.\n * @param {{type: 'FunctionCall', name: <string>}} ast An\n *      expression tree with a FunctionCall as the top node\n * @returns {Promise<*>|*} the value of the function call, or a Promise that\n *      will resolve with the resulting value.\n * @private\n */\n\n\nexports.FunctionCall = function (ast) {\n  var poolName = poolNames[ast.pool];\n\n  if (!poolName) {\n    throw new Error(\"Corrupt AST: Pool '\".concat(ast.pool, \"' not found\"));\n  }\n\n  var pool = this._grammar[ast.pool];\n  var func = pool[ast.name];\n\n  if (!func) {\n    throw new Error(\"\".concat(poolName, \" \").concat(ast.name, \" is not defined.\"));\n  }\n\n  return this.evalArray(ast.args || []).then(function (args) {\n    return func.apply(void 0, (0, _toConsumableArray2.default)(args));\n  });\n};\n/**\n * Evaluates a Unary expression by passing the right side through the\n * operator's eval function.\n * @param {{type: 'UnaryExpression', operator: <string>, right: {}}} ast An\n *      expression tree with a UnaryExpression as the top node\n * @returns {Promise<*>} resolves with the value of the UnaryExpression.\n * @constructor\n */\n\n\nexports.UnaryExpression = function (ast) {\n  var _this4 = this;\n\n  return this.eval(ast.right).then(function (right) {\n    return _this4._grammar.elements[ast.operator].eval(right);\n  });\n};"],"x_google_ignoreList":[0],"mappings":";;;;;CAIA,IAAI,sBAAA,+BAAA,CAAA,2BAAA,CAAiG;CAMrG,IAAI,YAAY;EACd,WAAW;EACX,YAAY;EACb;;;;;;;;;AAUD,SAAQ,eAAe,SAAU,KAAK;AACpC,SAAO,KAAK,UAAU,IAAI,MAAM;;;;;;;;;;;;;;;;AAkBlC,SAAQ,mBAAmB,SAAU,KAAK;EACxC,IAAI,QAAQ;EAEZ,IAAI,YAAY,KAAK,SAAS,SAAS,IAAI;AAE3C,MAAI,UAAU,cAAc;GAC1B,IAAI,OAAO,SAAS,KAAK,QAAQ;AAC/B,WAAO,EACL,MAAM,SAAS,QAAQ;AACrB,YAAO,MAAM,KAAK,OAAO;OAE5B;;AAGH,UAAO,UAAU,aAAa,KAAK,IAAI,KAAK,EAAE,KAAK,IAAI,MAAM,CAAC;;AAGhE,SAAO,KAAK,QAAQ,IAAI,CAAC,KAAK,KAAK,IAAI,KAAK,EAAE,KAAK,KAAK,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,SAAU,KAAK;AACvF,UAAO,UAAU,KAAK,IAAI,IAAI,IAAI,GAAG;IACrC;;;;;;;;;;;;AAcJ,SAAQ,wBAAwB,SAAU,KAAK;EAC7C,IAAI,SAAS;AAEb,SAAO,KAAK,KAAK,IAAI,KAAK,CAAC,KAAK,SAAU,KAAK;AAC7C,OAAI,KAAK;AACP,QAAI,IAAI,WACN,QAAO,OAAO,KAAK,IAAI,WAAW;AAGpC,WAAO;;AAGT,UAAO,OAAO,KAAK,IAAI,UAAU;IACjC;;;;;;;;;;AAYJ,SAAQ,mBAAmB,SAAU,KAAK;EACxC,IAAI,SAAS;AAEb,SAAO,KAAK,KAAK,IAAI,QAAQ,CAAC,KAAK,SAAU,SAAS;AACpD,OAAI,IAAI,SACN,QAAO,OAAO,gBAAgB,SAAS,IAAI,KAAK;AAGlD,UAAO,OAAO,cAAc,SAAS,IAAI,KAAK;IAC9C;;;;;;;;;;;;AAcJ,SAAQ,aAAa,SAAU,KAAK;AAClC,MAAI,CAAC,IAAI,KACP,QAAO,IAAI,WAAW,KAAK,YAAY,IAAI,SAAS,KAAK,SAAS,IAAI;AAGxE,SAAO,KAAK,KAAK,IAAI,KAAK,CAAC,KAAK,SAAU,SAAS;AACjD,OAAI,YAAY,KAAA,KAAa,YAAY,KACvC;AAGF,OAAI,MAAM,QAAQ,QAAQ,CACxB,WAAU,QAAQ;AAGpB,UAAO,QAAQ,IAAI;IACnB;;;;;;;;;AAWJ,SAAQ,UAAU,SAAU,KAAK;AAC/B,SAAO,IAAI;;;;;;;;;;AAYb,SAAQ,gBAAgB,SAAU,KAAK;AACrC,SAAO,KAAK,QAAQ,IAAI,MAAM;;;;;;;;;;;AAahC,SAAQ,eAAe,SAAU,KAAK;EACpC,IAAI,WAAW,UAAU,IAAI;AAE7B,MAAI,CAAC,SACH,OAAM,IAAI,MAAM,sBAAsB,OAAO,IAAI,MAAM,cAAc,CAAC;EAIxE,IAAI,OADO,KAAK,SAAS,IAAI,MACb,IAAI;AAEpB,MAAI,CAAC,KACH,OAAM,IAAI,MAAM,GAAG,OAAO,UAAU,IAAI,CAAC,OAAO,IAAI,MAAM,mBAAmB,CAAC;AAGhF,SAAO,KAAK,UAAU,IAAI,QAAQ,EAAE,CAAC,CAAC,KAAK,SAAU,MAAM;AACzD,UAAO,KAAK,MAAM,KAAK,IAAI,GAAG,oBAAoB,SAAS,KAAK,CAAC;IACjE;;;;;;;;;;AAYJ,SAAQ,kBAAkB,SAAU,KAAK;EACvC,IAAI,SAAS;AAEb,SAAO,KAAK,KAAK,IAAI,MAAM,CAAC,KAAK,SAAU,OAAO;AAChD,UAAO,OAAO,SAAS,SAAS,IAAI,UAAU,KAAK,MAAM;IACzD"}

package/dist/node_modules/jexl/dist/grammar.js

@@ -0,0 +1,195 @@
+import { __commonJSMin } from "../../../_virtual/_rolldown/runtime.js";
+//#region ../node_modules/jexl/dist/grammar.js
+var require_grammar = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.getGrammar = function() {
+		return {
+			/**
+			* A map of all expression elements to their properties. Note that changes
+			* here may require changes in the Lexer or Parser.
+			* @type {{}}
+			*/
+			elements: {
+				".": { type: "dot" },
+				"[": { type: "openBracket" },
+				"]": { type: "closeBracket" },
+				"|": { type: "pipe" },
+				"{": { type: "openCurl" },
+				"}": { type: "closeCurl" },
+				":": { type: "colon" },
+				",": { type: "comma" },
+				"(": { type: "openParen" },
+				")": { type: "closeParen" },
+				"?": { type: "question" },
+				"+": {
+					type: "binaryOp",
+					precedence: 30,
+					eval: function _eval(left, right) {
+						return left + right;
+					}
+				},
+				"-": {
+					type: "binaryOp",
+					precedence: 30,
+					eval: function _eval(left, right) {
+						return left - right;
+					}
+				},
+				"*": {
+					type: "binaryOp",
+					precedence: 40,
+					eval: function _eval(left, right) {
+						return left * right;
+					}
+				},
+				"/": {
+					type: "binaryOp",
+					precedence: 40,
+					eval: function _eval(left, right) {
+						return left / right;
+					}
+				},
+				"//": {
+					type: "binaryOp",
+					precedence: 40,
+					eval: function _eval(left, right) {
+						return Math.floor(left / right);
+					}
+				},
+				"%": {
+					type: "binaryOp",
+					precedence: 50,
+					eval: function _eval(left, right) {
+						return left % right;
+					}
+				},
+				"^": {
+					type: "binaryOp",
+					precedence: 50,
+					eval: function _eval(left, right) {
+						return Math.pow(left, right);
+					}
+				},
+				"==": {
+					type: "binaryOp",
+					precedence: 20,
+					eval: function _eval(left, right) {
+						return left == right;
+					}
+				},
+				"!=": {
+					type: "binaryOp",
+					precedence: 20,
+					eval: function _eval(left, right) {
+						return left != right;
+					}
+				},
+				">": {
+					type: "binaryOp",
+					precedence: 20,
+					eval: function _eval(left, right) {
+						return left > right;
+					}
+				},
+				">=": {
+					type: "binaryOp",
+					precedence: 20,
+					eval: function _eval(left, right) {
+						return left >= right;
+					}
+				},
+				"<": {
+					type: "binaryOp",
+					precedence: 20,
+					eval: function _eval(left, right) {
+						return left < right;
+					}
+				},
+				"<=": {
+					type: "binaryOp",
+					precedence: 20,
+					eval: function _eval(left, right) {
+						return left <= right;
+					}
+				},
+				"&&": {
+					type: "binaryOp",
+					precedence: 10,
+					evalOnDemand: function evalOnDemand(left, right) {
+						return left.eval().then(function(leftVal) {
+							if (!leftVal) return leftVal;
+							return right.eval();
+						});
+					}
+				},
+				"||": {
+					type: "binaryOp",
+					precedence: 10,
+					evalOnDemand: function evalOnDemand(left, right) {
+						return left.eval().then(function(leftVal) {
+							if (leftVal) return leftVal;
+							return right.eval();
+						});
+					}
+				},
+				in: {
+					type: "binaryOp",
+					precedence: 20,
+					eval: function _eval(left, right) {
+						if (typeof right === "string") return right.indexOf(left) !== -1;
+						if (Array.isArray(right)) return right.some(function(elem) {
+							return elem === left;
+						});
+						return false;
+					}
+				},
+				"!": {
+					type: "unaryOp",
+					precedence: Infinity,
+					eval: function _eval(right) {
+						return !right;
+					}
+				}
+			},
+			/**
+			* A map of function names to javascript functions. A Jexl function
+			* takes zero ore more arguemnts:
+			*
+			*     - {*} ...args: A variable number of arguments passed to this function.
+			*       All of these are pre-evaluated to their actual values before calling
+			*       the function.
+			*
+			* The Jexl function should return either the transformed value, or
+			* a Promises/A+ Promise object that resolves with the value and rejects
+			* or throws only when an unrecoverable error occurs. Functions should
+			* generally return undefined when they don't make sense to be used on the
+			* given value type, rather than throw/reject. An error is only
+			* appropriate when the function would normally return a value, but
+			* cannot due to some other failure.
+			*/
+			functions: {},
+			/**
+			* A map of transform names to transform functions. A transform function
+			* takes one ore more arguemnts:
+			*
+			*     - {*} val: A value to be transformed
+			*     - {*} ...args: A variable number of arguments passed to this transform.
+			*       All of these are pre-evaluated to their actual values before calling
+			*       the function.
+			*
+			* The transform function should return either the transformed value, or
+			* a Promises/A+ Promise object that resolves with the value and rejects
+			* or throws only when an unrecoverable error occurs. Transforms should
+			* generally return undefined when they don't make sense to be used on the
+			* given value type, rather than throw/reject. An error is only
+			* appropriate when the transform would normally return a value, but
+			* cannot due to some other failure.
+			*/
+			transforms: {}
+		};
+	};
+}));
+//#endregion
+export default require_grammar();
+export { require_grammar };
+
+//# sourceMappingURL=grammar.js.map

package/dist/node_modules/jexl/dist/grammar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammar.js","names":[],"sources":["../../../../../node_modules/jexl/dist/grammar.js"],"sourcesContent":["\"use strict\";\n\n/*\n * Jexl\n * Copyright 2020 Tom Shawver\n */\n\n/* eslint eqeqeq:0 */\nexports.getGrammar = function () {\n  return {\n    /**\n     * A map of all expression elements to their properties. Note that changes\n     * here may require changes in the Lexer or Parser.\n     * @type {{}}\n     */\n    elements: {\n      '.': {\n        type: 'dot'\n      },\n      '[': {\n        type: 'openBracket'\n      },\n      ']': {\n        type: 'closeBracket'\n      },\n      '|': {\n        type: 'pipe'\n      },\n      '{': {\n        type: 'openCurl'\n      },\n      '}': {\n        type: 'closeCurl'\n      },\n      ':': {\n        type: 'colon'\n      },\n      ',': {\n        type: 'comma'\n      },\n      '(': {\n        type: 'openParen'\n      },\n      ')': {\n        type: 'closeParen'\n      },\n      '?': {\n        type: 'question'\n      },\n      '+': {\n        type: 'binaryOp',\n        precedence: 30,\n        eval: function _eval(left, right) {\n          return left + right;\n        }\n      },\n      '-': {\n        type: 'binaryOp',\n        precedence: 30,\n        eval: function _eval(left, right) {\n          return left - right;\n        }\n      },\n      '*': {\n        type: 'binaryOp',\n        precedence: 40,\n        eval: function _eval(left, right) {\n          return left * right;\n        }\n      },\n      '/': {\n        type: 'binaryOp',\n        precedence: 40,\n        eval: function _eval(left, right) {\n          return left / right;\n        }\n      },\n      '//': {\n        type: 'binaryOp',\n        precedence: 40,\n        eval: function _eval(left, right) {\n          return Math.floor(left / right);\n        }\n      },\n      '%': {\n        type: 'binaryOp',\n        precedence: 50,\n        eval: function _eval(left, right) {\n          return left % right;\n        }\n      },\n      '^': {\n        type: 'binaryOp',\n        precedence: 50,\n        eval: function _eval(left, right) {\n          return Math.pow(left, right);\n        }\n      },\n      '==': {\n        type: 'binaryOp',\n        precedence: 20,\n        eval: function _eval(left, right) {\n          return left == right;\n        }\n      },\n      '!=': {\n        type: 'binaryOp',\n        precedence: 20,\n        eval: function _eval(left, right) {\n          return left != right;\n        }\n      },\n      '>': {\n        type: 'binaryOp',\n        precedence: 20,\n        eval: function _eval(left, right) {\n          return left > right;\n        }\n      },\n      '>=': {\n        type: 'binaryOp',\n        precedence: 20,\n        eval: function _eval(left, right) {\n          return left >= right;\n        }\n      },\n      '<': {\n        type: 'binaryOp',\n        precedence: 20,\n        eval: function _eval(left, right) {\n          return left < right;\n        }\n      },\n      '<=': {\n        type: 'binaryOp',\n        precedence: 20,\n        eval: function _eval(left, right) {\n          return left <= right;\n        }\n      },\n      '&&': {\n        type: 'binaryOp',\n        precedence: 10,\n        evalOnDemand: function evalOnDemand(left, right) {\n          return left.eval().then(function (leftVal) {\n            if (!leftVal) return leftVal;\n            return right.eval();\n          });\n        }\n      },\n      '||': {\n        type: 'binaryOp',\n        precedence: 10,\n        evalOnDemand: function evalOnDemand(left, right) {\n          return left.eval().then(function (leftVal) {\n            if (leftVal) return leftVal;\n            return right.eval();\n          });\n        }\n      },\n      in: {\n        type: 'binaryOp',\n        precedence: 20,\n        eval: function _eval(left, right) {\n          if (typeof right === 'string') {\n            return right.indexOf(left) !== -1;\n          }\n\n          if (Array.isArray(right)) {\n            return right.some(function (elem) {\n              return elem === left;\n            });\n          }\n\n          return false;\n        }\n      },\n      '!': {\n        type: 'unaryOp',\n        precedence: Infinity,\n        eval: function _eval(right) {\n          return !right;\n        }\n      }\n    },\n\n    /**\n     * A map of function names to javascript functions. A Jexl function\n     * takes zero ore more arguemnts:\n     *\n     *     - {*} ...args: A variable number of arguments passed to this function.\n     *       All of these are pre-evaluated to their actual values before calling\n     *       the function.\n     *\n     * The Jexl function should return either the transformed value, or\n     * a Promises/A+ Promise object that resolves with the value and rejects\n     * or throws only when an unrecoverable error occurs. Functions should\n     * generally return undefined when they don't make sense to be used on the\n     * given value type, rather than throw/reject. An error is only\n     * appropriate when the function would normally return a value, but\n     * cannot due to some other failure.\n     */\n    functions: {},\n\n    /**\n     * A map of transform names to transform functions. A transform function\n     * takes one ore more arguemnts:\n     *\n     *     - {*} val: A value to be transformed\n     *     - {*} ...args: A variable number of arguments passed to this transform.\n     *       All of these are pre-evaluated to their actual values before calling\n     *       the function.\n     *\n     * The transform function should return either the transformed value, or\n     * a Promises/A+ Promise object that resolves with the value and rejects\n     * or throws only when an unrecoverable error occurs. Transforms should\n     * generally return undefined when they don't make sense to be used on the\n     * given value type, rather than throw/reject. An error is only\n     * appropriate when the transform would normally return a value, but\n     * cannot due to some other failure.\n     */\n    transforms: {}\n  };\n};"],"x_google_ignoreList":[0],"mappings":";;;AAQA,SAAQ,aAAa,WAAY;AAC/B,SAAO;;;;;;GAML,UAAU;IACR,KAAK,EACH,MAAM,OACP;IACD,KAAK,EACH,MAAM,eACP;IACD,KAAK,EACH,MAAM,gBACP;IACD,KAAK,EACH,MAAM,QACP;IACD,KAAK,EACH,MAAM,YACP;IACD,KAAK,EACH,MAAM,aACP;IACD,KAAK,EACH,MAAM,SACP;IACD,KAAK,EACH,MAAM,SACP;IACD,KAAK,EACH,MAAM,aACP;IACD,KAAK,EACH,MAAM,cACP;IACD,KAAK,EACH,MAAM,YACP;IACD,KAAK;KACH,MAAM;KACN,YAAY;KACZ,MAAM,SAAS,MAAM,MAAM,OAAO;AAChC,aAAO,OAAO;;KAEjB;IACD,KAAK;KACH,MAAM;KACN,YAAY;KACZ,MAAM,SAAS,MAAM,MAAM,OAAO;AAChC,aAAO,OAAO;;KAEjB;IACD,KAAK;KACH,MAAM;KACN,YAAY;KACZ,MAAM,SAAS,MAAM,MAAM,OAAO;AAChC,aAAO,OAAO;;KAEjB;IACD,KAAK;KACH,MAAM;KACN,YAAY;KACZ,MAAM,SAAS,MAAM,MAAM,OAAO;AAChC,aAAO,OAAO;;KAEjB;IACD,MAAM;KACJ,MAAM;KACN,YAAY;KACZ,MAAM,SAAS,MAAM,MAAM,OAAO;AAChC,aAAO,KAAK,MAAM,OAAO,MAAM;;KAElC;IACD,KAAK;KACH,MAAM;KACN,YAAY;KACZ,MAAM,SAAS,MAAM,MAAM,OAAO;AAChC,aAAO,OAAO;;KAEjB;IACD,KAAK;KACH,MAAM;KACN,YAAY;KACZ,MAAM,SAAS,MAAM,MAAM,OAAO;AAChC,aAAO,KAAK,IAAI,MAAM,MAAM;;KAE/B;IACD,MAAM;KACJ,MAAM;KACN,YAAY;KACZ,MAAM,SAAS,MAAM,MAAM,OAAO;AAChC,aAAO,QAAQ;;KAElB;IACD,MAAM;KACJ,MAAM;KACN,YAAY;KACZ,MAAM,SAAS,MAAM,MAAM,OAAO;AAChC,aAAO,QAAQ;;KAElB;IACD,KAAK;KACH,MAAM;KACN,YAAY;KACZ,MAAM,SAAS,MAAM,MAAM,OAAO;AAChC,aAAO,OAAO;;KAEjB;IACD,MAAM;KACJ,MAAM;KACN,YAAY;KACZ,MAAM,SAAS,MAAM,MAAM,OAAO;AAChC,aAAO,QAAQ;;KAElB;IACD,KAAK;KACH,MAAM;KACN,YAAY;KACZ,MAAM,SAAS,MAAM,MAAM,OAAO;AAChC,aAAO,OAAO;;KAEjB;IACD,MAAM;KACJ,MAAM;KACN,YAAY;KACZ,MAAM,SAAS,MAAM,MAAM,OAAO;AAChC,aAAO,QAAQ;;KAElB;IACD,MAAM;KACJ,MAAM;KACN,YAAY;KACZ,cAAc,SAAS,aAAa,MAAM,OAAO;AAC/C,aAAO,KAAK,MAAM,CAAC,KAAK,SAAU,SAAS;AACzC,WAAI,CAAC,QAAS,QAAO;AACrB,cAAO,MAAM,MAAM;QACnB;;KAEL;IACD,MAAM;KACJ,MAAM;KACN,YAAY;KACZ,cAAc,SAAS,aAAa,MAAM,OAAO;AAC/C,aAAO,KAAK,MAAM,CAAC,KAAK,SAAU,SAAS;AACzC,WAAI,QAAS,QAAO;AACpB,cAAO,MAAM,MAAM;QACnB;;KAEL;IACD,IAAI;KACF,MAAM;KACN,YAAY;KACZ,MAAM,SAAS,MAAM,MAAM,OAAO;AAChC,UAAI,OAAO,UAAU,SACnB,QAAO,MAAM,QAAQ,KAAK,KAAK;AAGjC,UAAI,MAAM,QAAQ,MAAM,CACtB,QAAO,MAAM,KAAK,SAAU,MAAM;AAChC,cAAO,SAAS;QAChB;AAGJ,aAAO;;KAEV;IACD,KAAK;KACH,MAAM;KACN,YAAY;KACZ,MAAM,SAAS,MAAM,OAAO;AAC1B,aAAO,CAAC;;KAEX;IACF;;;;;;;;;;;;;;;;;GAkBD,WAAW,EAAE;;;;;;;;;;;;;;;;;;GAmBb,YAAY,EAAE;GACf"}

package/dist/node_modules/jexl/dist/parser/Parser.js

@@ -0,0 +1,135 @@
+import { __commonJSMin } from "../../../../_virtual/_rolldown/runtime.js";
+import { require_interopRequireDefault } from "../../../@babel/runtime/helpers/interopRequireDefault.js";
+import { require_classCallCheck } from "../../../@babel/runtime/helpers/classCallCheck.js";
+import { require_createClass } from "../../../@babel/runtime/helpers/createClass.js";
+import { require_handlers } from "./handlers.js";
+import { require_states } from "./states.js";
+//#region ../node_modules/jexl/dist/parser/Parser.js
+var require_Parser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var _interopRequireDefault = require_interopRequireDefault();
+	var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
+	var _createClass2 = _interopRequireDefault(require_createClass());
+	var handlers = require_handlers();
+	var states = require_states().states;
+	module.exports = /* @__PURE__ */ function() {
+		function Parser(grammar, prefix, stopMap) {
+			(0, _classCallCheck2.default)(this, Parser);
+			this._grammar = grammar;
+			this._state = "expectOperand";
+			this._tree = null;
+			this._exprStr = prefix || "";
+			this._relative = false;
+			this._stopMap = stopMap || {};
+		}
+		/**
+		* Processes a new token into the AST and manages the transitions of the state
+		* machine.
+		* @param {{type: <string>}} token A token object, as provided by the
+		*      {@link Lexer#tokenize} function.
+		* @throws {Error} if a token is added when the Parser has been marked as
+		*      complete by {@link #complete}, or if an unexpected token type is added.
+		* @returns {boolean|*} the stopState value if this parser encountered a token
+		*      in the stopState mapb false if tokens can continue.
+		*/
+		(0, _createClass2.default)(Parser, [
+			{
+				key: "addToken",
+				value: function addToken(token) {
+					if (this._state === "complete") throw new Error("Cannot add a new token to a completed Parser");
+					var state = states[this._state];
+					var startExpr = this._exprStr;
+					this._exprStr += token.raw;
+					if (state.subHandler) {
+						if (!this._subParser) this._startSubExpression(startExpr);
+						var stopState = this._subParser.addToken(token);
+						if (stopState) {
+							this._endSubExpression();
+							if (this._parentStop) return stopState;
+							this._state = stopState;
+						}
+					} else if (state.tokenTypes[token.type]) {
+						var typeOpts = state.tokenTypes[token.type];
+						var handleFunc = handlers[token.type];
+						if (typeOpts.handler) handleFunc = typeOpts.handler;
+						if (handleFunc) handleFunc.call(this, token);
+						if (typeOpts.toState) this._state = typeOpts.toState;
+					} else if (this._stopMap[token.type]) return this._stopMap[token.type];
+					else throw new Error("Token ".concat(token.raw, " (").concat(token.type, ") unexpected in expression: ").concat(this._exprStr));
+					return false;
+				}
+			},
+			{
+				key: "addTokens",
+				value: function addTokens(tokens) {
+					tokens.forEach(this.addToken, this);
+				}
+			},
+			{
+				key: "complete",
+				value: function complete() {
+					if (this._cursor && !states[this._state].completable) throw new Error("Unexpected end of expression: ".concat(this._exprStr));
+					if (this._subParser) this._endSubExpression();
+					this._state = "complete";
+					return this._cursor ? this._tree : null;
+				}
+			},
+			{
+				key: "isRelative",
+				value: function isRelative() {
+					return this._relative;
+				}
+			},
+			{
+				key: "_endSubExpression",
+				value: function _endSubExpression() {
+					states[this._state].subHandler.call(this, this._subParser.complete());
+					this._subParser = null;
+				}
+			},
+			{
+				key: "_placeAtCursor",
+				value: function _placeAtCursor(node) {
+					if (!this._cursor) this._tree = node;
+					else {
+						this._cursor.right = node;
+						this._setParent(node, this._cursor);
+					}
+					this._cursor = node;
+				}
+			},
+			{
+				key: "_placeBeforeCursor",
+				value: function _placeBeforeCursor(node) {
+					this._cursor = this._cursor._parent;
+					this._placeAtCursor(node);
+				}
+			},
+			{
+				key: "_setParent",
+				value: function _setParent(node, parent) {
+					Object.defineProperty(node, "_parent", {
+						value: parent,
+						writable: true
+					});
+				}
+			},
+			{
+				key: "_startSubExpression",
+				value: function _startSubExpression(exprStr) {
+					var endStates = states[this._state].endStates;
+					if (!endStates) {
+						this._parentStop = true;
+						endStates = this._stopMap;
+					}
+					this._subParser = new Parser(this._grammar, exprStr, endStates);
+				}
+			}
+		]);
+		return Parser;
+	}();
+}));
+//#endregion
+export default require_Parser();
+export { require_Parser };
+
+//# sourceMappingURL=Parser.js.map