@verbb/plugin-kit-react 1.0.0

package/dist/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unsupportedIterableToArray.js","names":[],"sources":["../../../../../../node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js"],"sourcesContent":["var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\nfunction _unsupportedIterableToArray(r, a) {\n  if (r) {\n    if (\"string\" == typeof r) return arrayLikeToArray(r, a);\n    var t = {}.toString.call(r).slice(8, -1);\n    return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, a) : void 0;\n  }\n}\nmodule.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;"],"x_google_ignoreList":[0],"mappings":";;;;CAAA,IAAI,mBAAA,0BAAA;CACJ,SAAS,4BAA4B,GAAG,GAAG;AACzC,MAAI,GAAG;AACL,OAAI,YAAY,OAAO,EAAG,QAAO,iBAAiB,GAAG,EAAE;GACvD,IAAI,IAAI,EAAE,CAAC,SAAS,KAAK,EAAE,CAAC,MAAM,GAAG,GAAG;AACxC,UAAO,aAAa,KAAK,EAAE,gBAAgB,IAAI,EAAE,YAAY,OAAO,UAAU,KAAK,UAAU,IAAI,MAAM,KAAK,EAAE,GAAG,gBAAgB,KAAK,2CAA2C,KAAK,EAAE,GAAG,iBAAiB,GAAG,EAAE,GAAG,KAAK;;;AAG7N,QAAO,UAAU,6BAA6B,OAAO,QAAQ,aAAa,MAAM,OAAO,QAAQ,aAAa,OAAO"}

package/dist/node_modules/jexl/dist/Expression.js

@@ -0,0 +1,84 @@
+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_Evaluator } from "./evaluator/Evaluator.js";
+import { require_Lexer } from "./Lexer.js";
+import { require_Parser } from "./parser/Parser.js";
+import { require_PromiseSync } from "./PromiseSync.js";
+//#region ../node_modules/jexl/dist/Expression.js
+var require_Expression = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var _interopRequireDefault = require_interopRequireDefault();
+	var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
+	var _createClass2 = _interopRequireDefault(require_createClass());
+	var Evaluator = require_Evaluator();
+	var Lexer = require_Lexer();
+	var Parser = require_Parser();
+	var PromiseSync = require_PromiseSync();
+	module.exports = /* @__PURE__ */ function() {
+		function Expression(grammar, exprStr) {
+			(0, _classCallCheck2.default)(this, Expression);
+			this._grammar = grammar;
+			this._exprStr = exprStr;
+			this._ast = null;
+		}
+		/**
+		* Forces a compilation of the expression string that this Expression object
+		* was constructed with. This function can be called multiple times; useful
+		* if the language elements of the associated Jexl instance change.
+		* @returns {Expression} this Expression instance, for convenience
+		*/
+		(0, _createClass2.default)(Expression, [
+			{
+				key: "compile",
+				value: function compile() {
+					var lexer = new Lexer(this._grammar);
+					var parser = new Parser(this._grammar);
+					var tokens = lexer.tokenize(this._exprStr);
+					parser.addTokens(tokens);
+					this._ast = parser.complete();
+					return this;
+				}
+			},
+			{
+				key: "eval",
+				value: function _eval() {
+					var context = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+					return this._eval(context, Promise);
+				}
+			},
+			{
+				key: "evalSync",
+				value: function evalSync() {
+					var context = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+					var res = this._eval(context, PromiseSync);
+					if (res.error) throw res.error;
+					return res.value;
+				}
+			},
+			{
+				key: "_eval",
+				value: function _eval(context, promise) {
+					var _this = this;
+					return promise.resolve().then(function() {
+						var ast = _this._getAst();
+						return new Evaluator(_this._grammar, context, void 0, promise).eval(ast);
+					});
+				}
+			},
+			{
+				key: "_getAst",
+				value: function _getAst() {
+					if (!this._ast) this.compile();
+					return this._ast;
+				}
+			}
+		]);
+		return Expression;
+	}();
+}));
+//#endregion
+export default require_Expression();
+export { require_Expression };
+
+//# sourceMappingURL=Expression.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Expression.js","names":[],"sources":["../../../../../node_modules/jexl/dist/Expression.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 Evaluator = require('./evaluator/Evaluator');\n\nvar Lexer = require('./Lexer');\n\nvar Parser = require('./parser/Parser');\n\nvar PromiseSync = require('./PromiseSync');\n\nvar Expression = /*#__PURE__*/function () {\n  function Expression(grammar, exprStr) {\n    (0, _classCallCheck2.default)(this, Expression);\n    this._grammar = grammar;\n    this._exprStr = exprStr;\n    this._ast = null;\n  }\n  /**\n   * Forces a compilation of the expression string that this Expression object\n   * was constructed with. This function can be called multiple times; useful\n   * if the language elements of the associated Jexl instance change.\n   * @returns {Expression} this Expression instance, for convenience\n   */\n\n\n  (0, _createClass2.default)(Expression, [{\n    key: \"compile\",\n    value: function compile() {\n      var lexer = new Lexer(this._grammar);\n      var parser = new Parser(this._grammar);\n      var tokens = lexer.tokenize(this._exprStr);\n      parser.addTokens(tokens);\n      this._ast = parser.complete();\n      return this;\n    }\n    /**\n     * Asynchronously evaluates the expression within an optional context.\n     * @param {Object} [context] A mapping of variables to values, which will be\n     *      made accessible to the Jexl expression when evaluating it\n     * @returns {Promise<*>} resolves with the result of the evaluation.\n     */\n\n  }, {\n    key: \"eval\",\n    value: function _eval() {\n      var context = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n      return this._eval(context, Promise);\n    }\n    /**\n     * Synchronously evaluates the expression within an optional context.\n     * @param {Object} [context] A mapping of variables to values, which will be\n     *      made accessible to the Jexl expression when evaluating it\n     * @returns {*} the result of the evaluation.\n     * @throws {*} on error\n     */\n\n  }, {\n    key: \"evalSync\",\n    value: function evalSync() {\n      var context = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n      var res = this._eval(context, PromiseSync);\n\n      if (res.error) throw res.error;\n      return res.value;\n    }\n  }, {\n    key: \"_eval\",\n    value: function _eval(context, promise) {\n      var _this = this;\n\n      return promise.resolve().then(function () {\n        var ast = _this._getAst();\n\n        var evaluator = new Evaluator(_this._grammar, context, undefined, promise);\n        return evaluator.eval(ast);\n      });\n    }\n  }, {\n    key: \"_getAst\",\n    value: function _getAst() {\n      if (!this._ast) this.compile();\n      return this._ast;\n    }\n  }]);\n  return Expression;\n}();\n\nmodule.exports = Expression;"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;CAEA,IAAI,yBAAA,+BAAA;CAEJ,IAAI,mBAAmB,uBAAA,wBAAA,CAAwE;CAE/F,IAAI,gBAAgB,uBAAA,qBAAA,CAAqE;CAMzF,IAAI,YAAA,mBAAA;CAEJ,IAAI,QAAA,eAAA;CAEJ,IAAI,SAAA,gBAAA;CAEJ,IAAI,cAAA,qBAAA;AAgFJ,QAAO,UAAU,gBA9Ea,WAAY;EACxC,SAAS,WAAW,SAAS,SAAS;AACpC,IAAC,GAAG,iBAAiB,SAAS,MAAM,WAAW;AAC/C,QAAK,WAAW;AAChB,QAAK,WAAW;AAChB,QAAK,OAAO;;;;;;;;AAUd,GAAC,GAAG,cAAc,SAAS,YAAY;GAAC;IACtC,KAAK;IACL,OAAO,SAAS,UAAU;KACxB,IAAI,QAAQ,IAAI,MAAM,KAAK,SAAS;KACpC,IAAI,SAAS,IAAI,OAAO,KAAK,SAAS;KACtC,IAAI,SAAS,MAAM,SAAS,KAAK,SAAS;AAC1C,YAAO,UAAU,OAAO;AACxB,UAAK,OAAO,OAAO,UAAU;AAC7B,YAAO;;IASV;GAAE;IACD,KAAK;IACL,OAAO,SAAS,QAAQ;KACtB,IAAI,UAAU,UAAU,SAAS,KAAK,UAAU,OAAO,KAAA,IAAY,UAAU,KAAK,EAAE;AACpF,YAAO,KAAK,MAAM,SAAS,QAAQ;;IAUtC;GAAE;IACD,KAAK;IACL,OAAO,SAAS,WAAW;KACzB,IAAI,UAAU,UAAU,SAAS,KAAK,UAAU,OAAO,KAAA,IAAY,UAAU,KAAK,EAAE;KAEpF,IAAI,MAAM,KAAK,MAAM,SAAS,YAAY;AAE1C,SAAI,IAAI,MAAO,OAAM,IAAI;AACzB,YAAO,IAAI;;IAEd;GAAE;IACD,KAAK;IACL,OAAO,SAAS,MAAM,SAAS,SAAS;KACtC,IAAI,QAAQ;AAEZ,YAAO,QAAQ,SAAS,CAAC,KAAK,WAAY;MACxC,IAAI,MAAM,MAAM,SAAS;AAGzB,aAAO,IADa,UAAU,MAAM,UAAU,SAAS,KAAA,GAAW,QAClD,CAAC,KAAK,IAAI;OAC1B;;IAEL;GAAE;IACD,KAAK;IACL,OAAO,SAAS,UAAU;AACxB,SAAI,CAAC,KAAK,KAAM,MAAK,SAAS;AAC9B,YAAO,KAAK;;IAEf;GAAC,CAAC;AACH,SAAO;IAGQ"}

package/dist/node_modules/jexl/dist/Jexl.js

@@ -0,0 +1,165 @@
+import { __commonJSMin } from "../../../_virtual/_rolldown/runtime.js";
+import { require_interopRequireDefault } from "../../@babel/runtime/helpers/interopRequireDefault.js";
+import { require_defineProperty } from "../../@babel/runtime/helpers/defineProperty.js";
+import { require_classCallCheck } from "../../@babel/runtime/helpers/classCallCheck.js";
+import { require_createClass } from "../../@babel/runtime/helpers/createClass.js";
+import { require_Expression } from "./Expression.js";
+import { require_grammar } from "./grammar.js";
+//#region ../node_modules/jexl/dist/Jexl.js
+var require_Jexl = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var _interopRequireDefault = require_interopRequireDefault();
+	var _defineProperty2 = _interopRequireDefault(require_defineProperty());
+	var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
+	var _createClass2 = _interopRequireDefault(require_createClass());
+	var Expression = require_Expression();
+	var getGrammar = require_grammar().getGrammar;
+	/**
+	* Jexl is the Javascript Expression Language, capable of parsing and
+	* evaluating basic to complex expression strings, combined with advanced
+	* xpath-like drilldown into native Javascript objects.
+	* @constructor
+	*/
+	var Jexl = /* @__PURE__ */ function() {
+		function Jexl() {
+			(0, _classCallCheck2.default)(this, Jexl);
+			this.expr = this.expr.bind(this);
+			this._grammar = getGrammar();
+		}
+		/**
+		* Adds a binary operator to Jexl at the specified precedence. The higher the
+		* precedence, the earlier the operator is applied in the order of operations.
+		* For example, * has a higher precedence than +, because multiplication comes
+		* before division.
+		*
+		* Please see grammar.js for a listing of all default operators and their
+		* precedence values in order to choose the appropriate precedence for the
+		* new operator.
+		* @param {string} operator The operator string to be added
+		* @param {number} precedence The operator's precedence
+		* @param {function} fn A function to run to calculate the result. The function
+		*      will be called with two arguments: left and right, denoting the values
+		*      on either side of the operator. It should return either the resulting
+		*      value, or a Promise that resolves with the resulting value.
+		* @param {boolean} [manualEval] If true, the `left` and `right` arguments
+		*      will be wrapped in objects with an `eval` function. Calling
+		*      left.eval() or right.eval() will return a promise that resolves to
+		*      that operand's actual value. This is useful to conditionally evaluate
+		*      operands.
+		*/
+		(0, _createClass2.default)(Jexl, [
+			{
+				key: "addBinaryOp",
+				value: function addBinaryOp(operator, precedence, fn, manualEval) {
+					this._addGrammarElement(operator, (0, _defineProperty2.default)({
+						type: "binaryOp",
+						precedence
+					}, manualEval ? "evalOnDemand" : "eval", fn));
+				}
+			},
+			{
+				key: "addFunction",
+				value: function addFunction(name, fn) {
+					this._grammar.functions[name] = fn;
+				}
+			},
+			{
+				key: "addFunctions",
+				value: function addFunctions(map) {
+					for (var key in map) this._grammar.functions[key] = map[key];
+				}
+			},
+			{
+				key: "addUnaryOp",
+				value: function addUnaryOp(operator, fn) {
+					this._addGrammarElement(operator, {
+						type: "unaryOp",
+						weight: Infinity,
+						eval: fn
+					});
+				}
+			},
+			{
+				key: "addTransform",
+				value: function addTransform(name, fn) {
+					this._grammar.transforms[name] = fn;
+				}
+			},
+			{
+				key: "addTransforms",
+				value: function addTransforms(map) {
+					for (var key in map) this._grammar.transforms[key] = map[key];
+				}
+			},
+			{
+				key: "compile",
+				value: function compile(expression) {
+					return this.createExpression(expression).compile();
+				}
+			},
+			{
+				key: "createExpression",
+				value: function createExpression(expression) {
+					return new Expression(this._grammar, expression);
+				}
+			},
+			{
+				key: "getFunction",
+				value: function getFunction(name) {
+					return this._grammar.functions[name];
+				}
+			},
+			{
+				key: "getTransform",
+				value: function getTransform(name) {
+					return this._grammar.transforms[name];
+				}
+			},
+			{
+				key: "eval",
+				value: function _eval(expression) {
+					var context = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+					return this.createExpression(expression).eval(context);
+				}
+			},
+			{
+				key: "evalSync",
+				value: function evalSync(expression) {
+					var context = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+					return this.createExpression(expression).evalSync(context);
+				}
+			},
+			{
+				key: "expr",
+				value: function expr(strs) {
+					for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) args[_key - 1] = arguments[_key];
+					var exprStr = strs.reduce(function(acc, str, idx) {
+						var arg = idx < args.length ? args[idx] : "";
+						acc += str + arg;
+						return acc;
+					}, "");
+					return this.createExpression(exprStr);
+				}
+			},
+			{
+				key: "removeOp",
+				value: function removeOp(operator) {
+					if (this._grammar.elements[operator] && (this._grammar.elements[operator].type === "binaryOp" || this._grammar.elements[operator].type === "unaryOp")) delete this._grammar.elements[operator];
+				}
+			},
+			{
+				key: "_addGrammarElement",
+				value: function _addGrammarElement(str, obj) {
+					this._grammar.elements[str] = obj;
+				}
+			}
+		]);
+		return Jexl;
+	}();
+	module.exports = new Jexl();
+	module.exports.Jexl = Jexl;
+}));
+//#endregion
+export default require_Jexl();
+export { require_Jexl };
+
+//# sourceMappingURL=Jexl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Jexl.js","names":[],"sources":["../../../../../node_modules/jexl/dist/Jexl.js"],"sourcesContent":["\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _defineProperty2 = _interopRequireDefault(require(\"@babel/runtime/helpers/defineProperty\"));\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 Expression = require('./Expression');\n\nvar _require = require('./grammar'),\n    getGrammar = _require.getGrammar;\n/**\n * Jexl is the Javascript Expression Language, capable of parsing and\n * evaluating basic to complex expression strings, combined with advanced\n * xpath-like drilldown into native Javascript objects.\n * @constructor\n */\n\n\nvar Jexl = /*#__PURE__*/function () {\n  function Jexl() {\n    (0, _classCallCheck2.default)(this, Jexl);\n    // Allow expr to be called outside of the jexl context\n    this.expr = this.expr.bind(this);\n    this._grammar = getGrammar();\n  }\n  /**\n   * Adds a binary operator to Jexl at the specified precedence. The higher the\n   * precedence, the earlier the operator is applied in the order of operations.\n   * For example, * has a higher precedence than +, because multiplication comes\n   * before division.\n   *\n   * Please see grammar.js for a listing of all default operators and their\n   * precedence values in order to choose the appropriate precedence for the\n   * new operator.\n   * @param {string} operator The operator string to be added\n   * @param {number} precedence The operator's precedence\n   * @param {function} fn A function to run to calculate the result. The function\n   *      will be called with two arguments: left and right, denoting the values\n   *      on either side of the operator. It should return either the resulting\n   *      value, or a Promise that resolves with the resulting value.\n   * @param {boolean} [manualEval] If true, the `left` and `right` arguments\n   *      will be wrapped in objects with an `eval` function. Calling\n   *      left.eval() or right.eval() will return a promise that resolves to\n   *      that operand's actual value. This is useful to conditionally evaluate\n   *      operands.\n   */\n\n\n  (0, _createClass2.default)(Jexl, [{\n    key: \"addBinaryOp\",\n    value: function addBinaryOp(operator, precedence, fn, manualEval) {\n      this._addGrammarElement(operator, (0, _defineProperty2.default)({\n        type: 'binaryOp',\n        precedence: precedence\n      }, manualEval ? 'evalOnDemand' : 'eval', fn));\n    }\n    /**\n     * Adds or replaces an expression function in this Jexl instance.\n     * @param {string} name The name of the expression function, as it will be\n     *      used within Jexl expressions\n     * @param {function} fn The javascript function to be executed when this\n     *      expression function is invoked. It will be provided with each argument\n     *      supplied in the expression, in the same order.\n     */\n\n  }, {\n    key: \"addFunction\",\n    value: function addFunction(name, fn) {\n      this._grammar.functions[name] = fn;\n    }\n    /**\n     * Syntactic sugar for calling {@link #addFunction} repeatedly. This function\n     * accepts a map of one or more expression function names to their javascript\n     * function counterpart.\n     * @param {{}} map A map of expression function names to javascript functions\n     */\n\n  }, {\n    key: \"addFunctions\",\n    value: function addFunctions(map) {\n      for (var key in map) {\n        this._grammar.functions[key] = map[key];\n      }\n    }\n    /**\n     * Adds a unary operator to Jexl. Unary operators are currently only supported\n     * on the left side of the value on which it will operate.\n     * @param {string} operator The operator string to be added\n     * @param {function} fn A function to run to calculate the result. The function\n     *      will be called with one argument: the literal value to the right of the\n     *      operator. It should return either the resulting value, or a Promise\n     *      that resolves with the resulting value.\n     */\n\n  }, {\n    key: \"addUnaryOp\",\n    value: function addUnaryOp(operator, fn) {\n      this._addGrammarElement(operator, {\n        type: 'unaryOp',\n        weight: Infinity,\n        eval: fn\n      });\n    }\n    /**\n     * Adds or replaces a transform function in this Jexl instance.\n     * @param {string} name The name of the transform function, as it will be used\n     *      within Jexl expressions\n     * @param {function} fn The function to be executed when this transform is\n     *      invoked. It will be provided with at least one argument:\n     *          - {*} value: The value to be transformed\n     *          - {...*} args: The arguments for this transform\n     */\n\n  }, {\n    key: \"addTransform\",\n    value: function addTransform(name, fn) {\n      this._grammar.transforms[name] = fn;\n    }\n    /**\n     * Syntactic sugar for calling {@link #addTransform} repeatedly.  This function\n     * accepts a map of one or more transform names to their transform function.\n     * @param {{}} map A map of transform names to transform functions\n     */\n\n  }, {\n    key: \"addTransforms\",\n    value: function addTransforms(map) {\n      for (var key in map) {\n        this._grammar.transforms[key] = map[key];\n      }\n    }\n    /**\n     * Creates an Expression object from the given Jexl expression string, and\n     * immediately compiles it. The returned Expression object can then be\n     * evaluated multiple times with new contexts, without generating any\n     * additional string processing overhead.\n     * @param {string} expression The Jexl expression to be compiled\n     * @returns {Expression} The compiled Expression object\n     */\n\n  }, {\n    key: \"compile\",\n    value: function compile(expression) {\n      var exprObj = this.createExpression(expression);\n      return exprObj.compile();\n    }\n    /**\n     * Constructs an Expression object from a Jexl expression string.\n     * @param {string} expression The Jexl expression to be wrapped in an\n     *    Expression object\n     * @returns {Expression} The Expression object representing the given string\n     */\n\n  }, {\n    key: \"createExpression\",\n    value: function createExpression(expression) {\n      return new Expression(this._grammar, expression);\n    }\n    /**\n     * Retrieves a previously set expression function.\n     * @param {string} name The name of the expression function\n     * @returns {function} The expression function\n     */\n\n  }, {\n    key: \"getFunction\",\n    value: function getFunction(name) {\n      return this._grammar.functions[name];\n    }\n    /**\n     * Retrieves a previously set transform function.\n     * @param {string} name The name of the transform function\n     * @returns {function} The transform function\n     */\n\n  }, {\n    key: \"getTransform\",\n    value: function getTransform(name) {\n      return this._grammar.transforms[name];\n    }\n    /**\n     * Asynchronously evaluates a Jexl string within an optional context.\n     * @param {string} expression The Jexl expression to be evaluated\n     * @param {Object} [context] A mapping of variables to values, which will be\n     *      made accessible to the Jexl expression when evaluating it\n     * @returns {Promise<*>} resolves with the result of the evaluation.\n     */\n\n  }, {\n    key: \"eval\",\n    value: function _eval(expression) {\n      var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n      var exprObj = this.createExpression(expression);\n      return exprObj.eval(context);\n    }\n    /**\n     * Synchronously evaluates a Jexl string within an optional context.\n     * @param {string} expression The Jexl expression to be evaluated\n     * @param {Object} [context] A mapping of variables to values, which will be\n     *      made accessible to the Jexl expression when evaluating it\n     * @returns {*} the result of the evaluation.\n     * @throws {*} on error\n     */\n\n  }, {\n    key: \"evalSync\",\n    value: function evalSync(expression) {\n      var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n      var exprObj = this.createExpression(expression);\n      return exprObj.evalSync(context);\n    }\n    /**\n     * A JavaScript template literal to allow expressions to be defined by the\n     * syntax: expr`40 + 2`\n     * @param {Array<string>} strs\n     * @param  {...any} args\n     */\n\n  }, {\n    key: \"expr\",\n    value: function expr(strs) {\n      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n        args[_key - 1] = arguments[_key];\n      }\n\n      var exprStr = strs.reduce(function (acc, str, idx) {\n        var arg = idx < args.length ? args[idx] : '';\n        acc += str + arg;\n        return acc;\n      }, '');\n      return this.createExpression(exprStr);\n    }\n    /**\n     * Removes a binary or unary operator from the Jexl grammar.\n     * @param {string} operator The operator string to be removed\n     */\n\n  }, {\n    key: \"removeOp\",\n    value: function removeOp(operator) {\n      if (this._grammar.elements[operator] && (this._grammar.elements[operator].type === 'binaryOp' || this._grammar.elements[operator].type === 'unaryOp')) {\n        delete this._grammar.elements[operator];\n      }\n    }\n    /**\n     * Adds an element to the grammar map used by this Jexl instance.\n     * @param {string} str The key string to be added\n     * @param {{type: <string>}} obj A map of configuration options for this\n     *      grammar element\n     * @private\n     */\n\n  }, {\n    key: \"_addGrammarElement\",\n    value: function _addGrammarElement(str, obj) {\n      this._grammar.elements[str] = obj;\n    }\n  }]);\n  return Jexl;\n}();\n\nmodule.exports = new Jexl();\nmodule.exports.Jexl = Jexl;"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;CAEA,IAAI,yBAAA,+BAAA;CAEJ,IAAI,mBAAmB,uBAAA,wBAAA,CAAwE;CAE/F,IAAI,mBAAmB,uBAAA,wBAAA,CAAwE;CAE/F,IAAI,gBAAgB,uBAAA,qBAAA,CAAqE;CAMzF,IAAI,aAAA,oBAAA;CAEJ,IACI,aAAA,iBAAA,CAAsB;;;;;;;CAS1B,IAAI,OAAoB,2BAAY;EAClC,SAAS,OAAO;AACd,IAAC,GAAG,iBAAiB,SAAS,MAAM,KAAK;AAEzC,QAAK,OAAO,KAAK,KAAK,KAAK,KAAK;AAChC,QAAK,WAAW,YAAY;;;;;;;;;;;;;;;;;;;;;;;AAyB9B,GAAC,GAAG,cAAc,SAAS,MAAM;GAAC;IAChC,KAAK;IACL,OAAO,SAAS,YAAY,UAAU,YAAY,IAAI,YAAY;AAChE,UAAK,mBAAmB,WAAW,GAAG,iBAAiB,SAAS;MAC9D,MAAM;MACM;MACb,EAAE,aAAa,iBAAiB,QAAQ,GAAG,CAAC;;IAWhD;GAAE;IACD,KAAK;IACL,OAAO,SAAS,YAAY,MAAM,IAAI;AACpC,UAAK,SAAS,UAAU,QAAQ;;IASnC;GAAE;IACD,KAAK;IACL,OAAO,SAAS,aAAa,KAAK;AAChC,UAAK,IAAI,OAAO,IACd,MAAK,SAAS,UAAU,OAAO,IAAI;;IAaxC;GAAE;IACD,KAAK;IACL,OAAO,SAAS,WAAW,UAAU,IAAI;AACvC,UAAK,mBAAmB,UAAU;MAChC,MAAM;MACN,QAAQ;MACR,MAAM;MACP,CAAC;;IAYL;GAAE;IACD,KAAK;IACL,OAAO,SAAS,aAAa,MAAM,IAAI;AACrC,UAAK,SAAS,WAAW,QAAQ;;IAQpC;GAAE;IACD,KAAK;IACL,OAAO,SAAS,cAAc,KAAK;AACjC,UAAK,IAAI,OAAO,IACd,MAAK,SAAS,WAAW,OAAO,IAAI;;IAYzC;GAAE;IACD,KAAK;IACL,OAAO,SAAS,QAAQ,YAAY;AAElC,YADc,KAAK,iBAAiB,WACtB,CAAC,SAAS;;IAS3B;GAAE;IACD,KAAK;IACL,OAAO,SAAS,iBAAiB,YAAY;AAC3C,YAAO,IAAI,WAAW,KAAK,UAAU,WAAW;;IAQnD;GAAE;IACD,KAAK;IACL,OAAO,SAAS,YAAY,MAAM;AAChC,YAAO,KAAK,SAAS,UAAU;;IAQlC;GAAE;IACD,KAAK;IACL,OAAO,SAAS,aAAa,MAAM;AACjC,YAAO,KAAK,SAAS,WAAW;;IAUnC;GAAE;IACD,KAAK;IACL,OAAO,SAAS,MAAM,YAAY;KAChC,IAAI,UAAU,UAAU,SAAS,KAAK,UAAU,OAAO,KAAA,IAAY,UAAU,KAAK,EAAE;AAEpF,YADc,KAAK,iBAAiB,WACtB,CAAC,KAAK,QAAQ;;IAW/B;GAAE;IACD,KAAK;IACL,OAAO,SAAS,SAAS,YAAY;KACnC,IAAI,UAAU,UAAU,SAAS,KAAK,UAAU,OAAO,KAAA,IAAY,UAAU,KAAK,EAAE;AAEpF,YADc,KAAK,iBAAiB,WACtB,CAAC,SAAS,QAAQ;;IASnC;GAAE;IACD,KAAK;IACL,OAAO,SAAS,KAAK,MAAM;AACzB,UAAK,IAAI,OAAO,UAAU,QAAQ,OAAO,IAAI,MAAM,OAAO,IAAI,OAAO,IAAI,EAAE,EAAE,OAAO,GAAG,OAAO,MAAM,OAClG,MAAK,OAAO,KAAK,UAAU;KAG7B,IAAI,UAAU,KAAK,OAAO,SAAU,KAAK,KAAK,KAAK;MACjD,IAAI,MAAM,MAAM,KAAK,SAAS,KAAK,OAAO;AAC1C,aAAO,MAAM;AACb,aAAO;QACN,GAAG;AACN,YAAO,KAAK,iBAAiB,QAAQ;;IAOxC;GAAE;IACD,KAAK;IACL,OAAO,SAAS,SAAS,UAAU;AACjC,SAAI,KAAK,SAAS,SAAS,cAAc,KAAK,SAAS,SAAS,UAAU,SAAS,cAAc,KAAK,SAAS,SAAS,UAAU,SAAS,WACzI,QAAO,KAAK,SAAS,SAAS;;IAWnC;GAAE;IACD,KAAK;IACL,OAAO,SAAS,mBAAmB,KAAK,KAAK;AAC3C,UAAK,SAAS,SAAS,OAAO;;IAEjC;GAAC,CAAC;AACH,SAAO;IACN;AAEH,QAAO,UAAU,IAAI,MAAM;AAC3B,QAAO,QAAQ,OAAO"}

package/dist/node_modules/jexl/dist/Lexer.js

@@ -0,0 +1,152 @@
+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";
+//#region ../node_modules/jexl/dist/Lexer.js
+var require_Lexer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var _interopRequireDefault = require_interopRequireDefault();
+	var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
+	var _createClass2 = _interopRequireDefault(require_createClass());
+	var numericRegex = /^-?(?:(?:[0-9]*\.[0-9]+)|[0-9]+)$/;
+	var identRegex = /^[a-zA-Zа-яА-Я_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$][a-zA-Zа-яА-Я0-9_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$]*$/;
+	var escEscRegex = /\\\\/;
+	var whitespaceRegex = /^\s*$/;
+	var preOpRegexElems = [
+		"'(?:(?:\\\\')|[^'])*'",
+		"\"(?:(?:\\\\\")|[^\"])*\"",
+		"\\s+",
+		"\\btrue\\b",
+		"\\bfalse\\b"
+	];
+	var postOpRegexElems = ["[a-zA-Zа-яА-Я_À-ÖØ-öø-ÿ\\$][a-zA-Z0-9а-яА-Я_À-ÖØ-öø-ÿ\\$]*", "(?:(?:[0-9]*\\.[0-9]+)|[0-9]+)"];
+	var minusNegatesAfter = [
+		"binaryOp",
+		"unaryOp",
+		"openParen",
+		"openBracket",
+		"question",
+		"colon"
+	];
+	module.exports = /* @__PURE__ */ function() {
+		function Lexer(grammar) {
+			(0, _classCallCheck2.default)(this, Lexer);
+			this._grammar = grammar;
+		}
+		/**
+		* Splits a Jexl expression string into an array of expression elements.
+		* @param {string} str A Jexl expression string
+		* @returns {Array<string>} An array of substrings defining the functional
+		*      elements of the expression.
+		*/
+		(0, _createClass2.default)(Lexer, [
+			{
+				key: "getElements",
+				value: function getElements(str) {
+					var regex = this._getSplitRegex();
+					return str.split(regex).filter(function(elem) {
+						return elem;
+					});
+				}
+			},
+			{
+				key: "getTokens",
+				value: function getTokens(elements) {
+					var tokens = [];
+					var negate = false;
+					for (var i = 0; i < elements.length; i++) if (this._isWhitespace(elements[i])) {
+						if (tokens.length) tokens[tokens.length - 1].raw += elements[i];
+					} else if (elements[i] === "-" && this._isNegative(tokens)) negate = true;
+					else {
+						if (negate) {
+							elements[i] = "-" + elements[i];
+							negate = false;
+						}
+						tokens.push(this._createToken(elements[i]));
+					}
+					if (negate) tokens.push(this._createToken("-"));
+					return tokens;
+				}
+			},
+			{
+				key: "tokenize",
+				value: function tokenize(str) {
+					var elements = this.getElements(str);
+					return this.getTokens(elements);
+				}
+			},
+			{
+				key: "_createToken",
+				value: function _createToken(element) {
+					var token = {
+						type: "literal",
+						value: element,
+						raw: element
+					};
+					if (element[0] === "\"" || element[0] === "'") token.value = this._unquote(element);
+					else if (element.match(numericRegex)) token.value = parseFloat(element);
+					else if (element === "true" || element === "false") token.value = element === "true";
+					else if (this._grammar.elements[element]) token.type = this._grammar.elements[element].type;
+					else if (element.match(identRegex)) token.type = "identifier";
+					else throw new Error("Invalid expression token: ".concat(element));
+					return token;
+				}
+			},
+			{
+				key: "_escapeRegExp",
+				value: function _escapeRegExp(str) {
+					str = str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+					if (str.match(identRegex)) str = "\\b" + str + "\\b";
+					return str;
+				}
+			},
+			{
+				key: "_getSplitRegex",
+				value: function _getSplitRegex() {
+					var _this = this;
+					if (!this._splitRegex) {
+						var elemArray = Object.keys(this._grammar.elements).sort(function(a, b) {
+							return b.length - a.length;
+						}).map(function(elem) {
+							return _this._escapeRegExp(elem);
+						}, this);
+						this._splitRegex = new RegExp("(" + [
+							preOpRegexElems.join("|"),
+							elemArray.join("|"),
+							postOpRegexElems.join("|")
+						].join("|") + ")");
+					}
+					return this._splitRegex;
+				}
+			},
+			{
+				key: "_isNegative",
+				value: function _isNegative(tokens) {
+					if (!tokens.length) return true;
+					return minusNegatesAfter.some(function(type) {
+						return type === tokens[tokens.length - 1].type;
+					});
+				}
+			},
+			{
+				key: "_isWhitespace",
+				value: function _isWhitespace(str) {
+					return !!str.match(whitespaceRegex);
+				}
+			},
+			{
+				key: "_unquote",
+				value: function _unquote(str) {
+					var quote = str[0];
+					var escQuoteRegex = new RegExp("\\\\" + quote, "g");
+					return str.substr(1, str.length - 2).replace(escQuoteRegex, quote).replace(escEscRegex, "\\");
+				}
+			}
+		]);
+		return Lexer;
+	}();
+}));
+//#endregion
+export default require_Lexer();
+export { require_Lexer };
+
+//# sourceMappingURL=Lexer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Lexer.js","names":[],"sources":["../../../../../node_modules/jexl/dist/Lexer.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 numericRegex = /^-?(?:(?:[0-9]*\\.[0-9]+)|[0-9]+)$/;\nvar identRegex = /^[a-zA-Zа-яА-Я_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u00FF$][a-zA-Zа-яА-Я0-9_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u00FF$]*$/;\nvar escEscRegex = /\\\\\\\\/;\nvar whitespaceRegex = /^\\s*$/;\nvar preOpRegexElems = [// Strings\n\"'(?:(?:\\\\\\\\')|[^'])*'\", '\"(?:(?:\\\\\\\\\")|[^\"])*\"', // Whitespace\n'\\\\s+', // Booleans\n'\\\\btrue\\\\b', '\\\\bfalse\\\\b'];\nvar postOpRegexElems = [// Identifiers\n\"[a-zA-Z\\u0430-\\u044F\\u0410-\\u042F_\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\xFF\\\\$][a-zA-Z0-9\\u0430-\\u044F\\u0410-\\u042F_\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\xFF\\\\$]*\", // Numerics (without negative symbol)\n'(?:(?:[0-9]*\\\\.[0-9]+)|[0-9]+)'];\nvar minusNegatesAfter = ['binaryOp', 'unaryOp', 'openParen', 'openBracket', 'question', 'colon'];\n/**\n * Lexer is a collection of stateless, statically-accessed functions for the\n * lexical parsing of a Jexl string.  Its responsibility is to identify the\n * \"parts of speech\" of a Jexl expression, and tokenize and label each, but\n * to do only the most minimal syntax checking; the only errors the Lexer\n * should be concerned with are if it's unable to identify the utility of\n * any of its tokens.  Errors stemming from these tokens not being in a\n * sensible configuration should be left for the Parser to handle.\n * @type {{}}\n */\n\nvar Lexer = /*#__PURE__*/function () {\n  function Lexer(grammar) {\n    (0, _classCallCheck2.default)(this, Lexer);\n    this._grammar = grammar;\n  }\n  /**\n   * Splits a Jexl expression string into an array of expression elements.\n   * @param {string} str A Jexl expression string\n   * @returns {Array<string>} An array of substrings defining the functional\n   *      elements of the expression.\n   */\n\n\n  (0, _createClass2.default)(Lexer, [{\n    key: \"getElements\",\n    value: function getElements(str) {\n      var regex = this._getSplitRegex();\n\n      return str.split(regex).filter(function (elem) {\n        // Remove empty strings\n        return elem;\n      });\n    }\n    /**\n     * Converts an array of expression elements into an array of tokens.  Note that\n     * the resulting array may not equal the element array in length, as any\n     * elements that consist only of whitespace get appended to the previous\n     * token's \"raw\" property.  For the structure of a token object, please see\n     * {@link Lexer#tokenize}.\n     * @param {Array<string>} elements An array of Jexl expression elements to be\n     *      converted to tokens\n     * @returns {Array<{type, value, raw}>} an array of token objects.\n     */\n\n  }, {\n    key: \"getTokens\",\n    value: function getTokens(elements) {\n      var tokens = [];\n      var negate = false;\n\n      for (var i = 0; i < elements.length; i++) {\n        if (this._isWhitespace(elements[i])) {\n          if (tokens.length) {\n            tokens[tokens.length - 1].raw += elements[i];\n          }\n        } else if (elements[i] === '-' && this._isNegative(tokens)) {\n          negate = true;\n        } else {\n          if (negate) {\n            elements[i] = '-' + elements[i];\n            negate = false;\n          }\n\n          tokens.push(this._createToken(elements[i]));\n        }\n      } // Catch a - at the end of the string. Let the parser handle that issue.\n\n\n      if (negate) {\n        tokens.push(this._createToken('-'));\n      }\n\n      return tokens;\n    }\n    /**\n     * Converts a Jexl string into an array of tokens.  Each token is an object\n     * in the following format:\n     *\n     *     {\n     *         type: <string>,\n     *         [name]: <string>,\n     *         value: <boolean|number|string>,\n     *         raw: <string>\n     *     }\n     *\n     * Type is one of the following:\n     *\n     *      literal, identifier, binaryOp, unaryOp\n     *\n     * OR, if the token is a control character its type is the name of the element\n     * defined in the Grammar.\n     *\n     * Name appears only if the token is a control string found in\n     * {@link grammar#elements}, and is set to the name of the element.\n     *\n     * Value is the value of the token in the correct type (boolean or numeric as\n     * appropriate). Raw is the string representation of this value taken directly\n     * from the expression string, including any trailing spaces.\n     * @param {string} str The Jexl string to be tokenized\n     * @returns {Array<{type, value, raw}>} an array of token objects.\n     * @throws {Error} if the provided string contains an invalid token.\n     */\n\n  }, {\n    key: \"tokenize\",\n    value: function tokenize(str) {\n      var elements = this.getElements(str);\n      return this.getTokens(elements);\n    }\n    /**\n     * Creates a new token object from an element of a Jexl string. See\n     * {@link Lexer#tokenize} for a description of the token object.\n     * @param {string} element The element from which a token should be made\n     * @returns {{value: number|boolean|string, [name]: string, type: string,\n     *      raw: string}} a token object describing the provided element.\n     * @throws {Error} if the provided string is not a valid expression element.\n     * @private\n     */\n\n  }, {\n    key: \"_createToken\",\n    value: function _createToken(element) {\n      var token = {\n        type: 'literal',\n        value: element,\n        raw: element\n      };\n\n      if (element[0] === '\"' || element[0] === \"'\") {\n        token.value = this._unquote(element);\n      } else if (element.match(numericRegex)) {\n        token.value = parseFloat(element);\n      } else if (element === 'true' || element === 'false') {\n        token.value = element === 'true';\n      } else if (this._grammar.elements[element]) {\n        token.type = this._grammar.elements[element].type;\n      } else if (element.match(identRegex)) {\n        token.type = 'identifier';\n      } else {\n        throw new Error(\"Invalid expression token: \".concat(element));\n      }\n\n      return token;\n    }\n    /**\n     * Escapes a string so that it can be treated as a string literal within a\n     * regular expression.\n     * @param {string} str The string to be escaped\n     * @returns {string} the RegExp-escaped string.\n     * @see https://developer.mozilla.org/en/docs/Web/JavaScript/Guide/Regular_Expressions\n     * @private\n     */\n\n  }, {\n    key: \"_escapeRegExp\",\n    value: function _escapeRegExp(str) {\n      str = str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n\n      if (str.match(identRegex)) {\n        str = '\\\\b' + str + '\\\\b';\n      }\n\n      return str;\n    }\n    /**\n     * Gets a RegEx object appropriate for splitting a Jexl string into its core\n     * elements.\n     * @returns {RegExp} An element-splitting RegExp object\n     * @private\n     */\n\n  }, {\n    key: \"_getSplitRegex\",\n    value: function _getSplitRegex() {\n      var _this = this;\n\n      if (!this._splitRegex) {\n        // Sort by most characters to least, then regex escape each\n        var elemArray = Object.keys(this._grammar.elements).sort(function (a, b) {\n          return b.length - a.length;\n        }).map(function (elem) {\n          return _this._escapeRegExp(elem);\n        }, this);\n        this._splitRegex = new RegExp('(' + [preOpRegexElems.join('|'), elemArray.join('|'), postOpRegexElems.join('|')].join('|') + ')');\n      }\n\n      return this._splitRegex;\n    }\n    /**\n     * Determines whether the addition of a '-' token should be interpreted as a\n     * negative symbol for an upcoming number, given an array of tokens already\n     * processed.\n     * @param {Array<Object>} tokens An array of tokens already processed\n     * @returns {boolean} true if adding a '-' should be considered a negative\n     *      symbol; false otherwise\n     * @private\n     */\n\n  }, {\n    key: \"_isNegative\",\n    value: function _isNegative(tokens) {\n      if (!tokens.length) return true;\n      return minusNegatesAfter.some(function (type) {\n        return type === tokens[tokens.length - 1].type;\n      });\n    }\n    /**\n     * A utility function to determine if a string consists of only space\n     * characters.\n     * @param {string} str A string to be tested\n     * @returns {boolean} true if the string is empty or consists of only spaces;\n     *      false otherwise.\n     * @private\n     */\n\n  }, {\n    key: \"_isWhitespace\",\n    value: function _isWhitespace(str) {\n      return !!str.match(whitespaceRegex);\n    }\n    /**\n     * Removes the beginning and trailing quotes from a string, unescapes any\n     * escaped quotes on its interior, and unescapes any escaped escape\n     * characters. Note that this function is not defensive; it assumes that the\n     * provided string is not empty, and that its first and last characters are\n     * actually quotes.\n     * @param {string} str A string whose first and last characters are quotes\n     * @returns {string} a string with the surrounding quotes stripped and escapes\n     *      properly processed.\n     * @private\n     */\n\n  }, {\n    key: \"_unquote\",\n    value: function _unquote(str) {\n      var quote = str[0];\n      var escQuoteRegex = new RegExp('\\\\\\\\' + quote, 'g');\n      return str.substr(1, str.length - 2).replace(escQuoteRegex, quote).replace(escEscRegex, '\\\\');\n    }\n  }]);\n  return Lexer;\n}();\n\nmodule.exports = Lexer;"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/jexl/dist/PromiseSync.js

@@ -0,0 +1,87 @@
+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";
+//#region ../node_modules/jexl/dist/PromiseSync.js
+var require_PromiseSync = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var _interopRequireDefault = require_interopRequireDefault();
+	var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
+	var _createClass2 = _interopRequireDefault(require_createClass());
+	var PromiseSync = /* @__PURE__ */ function() {
+		function PromiseSync(fn) {
+			(0, _classCallCheck2.default)(this, PromiseSync);
+			fn(this._resolve.bind(this), this._reject.bind(this));
+		}
+		(0, _createClass2.default)(PromiseSync, [
+			{
+				key: "catch",
+				value: function _catch(rejected) {
+					if (this.error) try {
+						this._resolve(rejected(this.error));
+					} catch (e) {
+						this._reject(e);
+					}
+					return this;
+				}
+			},
+			{
+				key: "then",
+				value: function then(resolved, rejected) {
+					if (!this.error) try {
+						this._resolve(resolved(this.value));
+					} catch (e) {
+						this._reject(e);
+					}
+					if (rejected) this.catch(rejected);
+					return this;
+				}
+			},
+			{
+				key: "_reject",
+				value: function _reject(error) {
+					this.value = void 0;
+					this.error = error;
+				}
+			},
+			{
+				key: "_resolve",
+				value: function _resolve(val) {
+					if (val instanceof PromiseSync) if (val.error) this._reject(val.error);
+					else this._resolve(val.value);
+					else {
+						this.value = val;
+						this.error = void 0;
+					}
+				}
+			}
+		]);
+		return PromiseSync;
+	}();
+	PromiseSync.all = function(vals) {
+		return new PromiseSync(function(resolve) {
+			resolve(vals.map(function(val) {
+				while (val instanceof PromiseSync) {
+					if (val.error) throw Error(val.error);
+					val = val.value;
+				}
+				return val;
+			}));
+		});
+	};
+	PromiseSync.resolve = function(val) {
+		return new PromiseSync(function(resolve) {
+			return resolve(val);
+		});
+	};
+	PromiseSync.reject = function(error) {
+		return new PromiseSync(function(resolve, reject) {
+			return reject(error);
+		});
+	};
+	module.exports = PromiseSync;
+}));
+//#endregion
+export default require_PromiseSync();
+export { require_PromiseSync };
+
+//# sourceMappingURL=PromiseSync.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PromiseSync.js","names":[],"sources":["../../../../../node_modules/jexl/dist/PromiseSync.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 PromiseSync = /*#__PURE__*/function () {\n  function PromiseSync(fn) {\n    (0, _classCallCheck2.default)(this, PromiseSync);\n    fn(this._resolve.bind(this), this._reject.bind(this));\n  }\n\n  (0, _createClass2.default)(PromiseSync, [{\n    key: \"catch\",\n    value: function _catch(rejected) {\n      if (this.error) {\n        try {\n          this._resolve(rejected(this.error));\n        } catch (e) {\n          this._reject(e);\n        }\n      }\n\n      return this;\n    }\n  }, {\n    key: \"then\",\n    value: function then(resolved, rejected) {\n      if (!this.error) {\n        try {\n          this._resolve(resolved(this.value));\n        } catch (e) {\n          this._reject(e);\n        }\n      }\n\n      if (rejected) this.catch(rejected);\n      return this;\n    }\n  }, {\n    key: \"_reject\",\n    value: function _reject(error) {\n      this.value = undefined;\n      this.error = error;\n    }\n  }, {\n    key: \"_resolve\",\n    value: function _resolve(val) {\n      if (val instanceof PromiseSync) {\n        if (val.error) {\n          this._reject(val.error);\n        } else {\n          this._resolve(val.value);\n        }\n      } else {\n        this.value = val;\n        this.error = undefined;\n      }\n    }\n  }]);\n  return PromiseSync;\n}();\n\nPromiseSync.all = function (vals) {\n  return new PromiseSync(function (resolve) {\n    var resolved = vals.map(function (val) {\n      while (val instanceof PromiseSync) {\n        if (val.error) throw Error(val.error);\n        val = val.value;\n      }\n\n      return val;\n    });\n    resolve(resolved);\n  });\n};\n\nPromiseSync.resolve = function (val) {\n  return new PromiseSync(function (resolve) {\n    return resolve(val);\n  });\n};\n\nPromiseSync.reject = function (error) {\n  return new PromiseSync(function (resolve, reject) {\n    return reject(error);\n  });\n};\n\nmodule.exports = PromiseSync;"],"x_google_ignoreList":[0],"mappings":";;;;;;CAEA,IAAI,yBAAA,+BAAA;CAEJ,IAAI,mBAAmB,uBAAA,wBAAA,CAAwE;CAE/F,IAAI,gBAAgB,uBAAA,qBAAA,CAAqE;CAMzF,IAAI,cAA2B,2BAAY;EACzC,SAAS,YAAY,IAAI;AACvB,IAAC,GAAG,iBAAiB,SAAS,MAAM,YAAY;AAChD,MAAG,KAAK,SAAS,KAAK,KAAK,EAAE,KAAK,QAAQ,KAAK,KAAK,CAAC;;AAGvD,GAAC,GAAG,cAAc,SAAS,aAAa;GAAC;IACvC,KAAK;IACL,OAAO,SAAS,OAAO,UAAU;AAC/B,SAAI,KAAK,MACP,KAAI;AACF,WAAK,SAAS,SAAS,KAAK,MAAM,CAAC;cAC5B,GAAG;AACV,WAAK,QAAQ,EAAE;;AAInB,YAAO;;IAEV;GAAE;IACD,KAAK;IACL,OAAO,SAAS,KAAK,UAAU,UAAU;AACvC,SAAI,CAAC,KAAK,MACR,KAAI;AACF,WAAK,SAAS,SAAS,KAAK,MAAM,CAAC;cAC5B,GAAG;AACV,WAAK,QAAQ,EAAE;;AAInB,SAAI,SAAU,MAAK,MAAM,SAAS;AAClC,YAAO;;IAEV;GAAE;IACD,KAAK;IACL,OAAO,SAAS,QAAQ,OAAO;AAC7B,UAAK,QAAQ,KAAA;AACb,UAAK,QAAQ;;IAEhB;GAAE;IACD,KAAK;IACL,OAAO,SAAS,SAAS,KAAK;AAC5B,SAAI,eAAe,YACjB,KAAI,IAAI,MACN,MAAK,QAAQ,IAAI,MAAM;SAEvB,MAAK,SAAS,IAAI,MAAM;UAErB;AACL,WAAK,QAAQ;AACb,WAAK,QAAQ,KAAA;;;IAGlB;GAAC,CAAC;AACH,SAAO;IACN;AAEH,aAAY,MAAM,SAAU,MAAM;AAChC,SAAO,IAAI,YAAY,SAAU,SAAS;AASxC,WARe,KAAK,IAAI,SAAU,KAAK;AACrC,WAAO,eAAe,aAAa;AACjC,SAAI,IAAI,MAAO,OAAM,MAAM,IAAI,MAAM;AACrC,WAAM,IAAI;;AAGZ,WAAO;KAEO,CAAC;IACjB;;AAGJ,aAAY,UAAU,SAAU,KAAK;AACnC,SAAO,IAAI,YAAY,SAAU,SAAS;AACxC,UAAO,QAAQ,IAAI;IACnB;;AAGJ,aAAY,SAAS,SAAU,OAAO;AACpC,SAAO,IAAI,YAAY,SAAU,SAAS,QAAQ;AAChD,UAAO,OAAO,MAAM;IACpB;;AAGJ,QAAO,UAAU"}