@dyrected/core 2.13.0 → 2.13.3

package/dist/chunk-27YRIGK5.js

@@ -1,1758 +0,0 @@
-import {
-  __commonJS
-} from "./chunk-JSBRDJBE.js";
-
-// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/interopRequireDefault.js
-var require_interopRequireDefault = __commonJS({
-  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/interopRequireDefault.js"(exports, module) {
-    "use strict";
-    function _interopRequireDefault(e) {
-      return e && e.__esModule ? e : {
-        "default": e
-      };
-    }
-    module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;
-  }
-});
-
-// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/typeof.js
-var require_typeof = __commonJS({
-  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/typeof.js"(exports, module) {
-    "use strict";
-    function _typeof(o) {
-      "@babel/helpers - typeof";
-      return module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
-        return typeof o2;
-      } : function(o2) {
-        return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
-      }, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof(o);
-    }
-    module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
-  }
-});
-
-// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/toPrimitive.js
-var require_toPrimitive = __commonJS({
-  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/toPrimitive.js"(exports, module) {
-    "use strict";
-    var _typeof = require_typeof()["default"];
-    function toPrimitive(t, r) {
-      if ("object" != _typeof(t) || !t) return t;
-      var e = t[Symbol.toPrimitive];
-      if (void 0 !== e) {
-        var i = e.call(t, r || "default");
-        if ("object" != _typeof(i)) return i;
-        throw new TypeError("@@toPrimitive must return a primitive value.");
-      }
-      return ("string" === r ? String : Number)(t);
-    }
-    module.exports = toPrimitive, module.exports.__esModule = true, module.exports["default"] = module.exports;
-  }
-});
-
-// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/toPropertyKey.js
-var require_toPropertyKey = __commonJS({
-  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/toPropertyKey.js"(exports, module) {
-    "use strict";
-    var _typeof = require_typeof()["default"];
-    var toPrimitive = require_toPrimitive();
-    function toPropertyKey(t) {
-      var i = toPrimitive(t, "string");
-      return "symbol" == _typeof(i) ? i : i + "";
-    }
-    module.exports = toPropertyKey, module.exports.__esModule = true, module.exports["default"] = module.exports;
-  }
-});
-
-// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/defineProperty.js
-var require_defineProperty = __commonJS({
-  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/defineProperty.js"(exports, module) {
-    "use strict";
-    var toPropertyKey = require_toPropertyKey();
-    function _defineProperty(e, r, t) {
-      return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
-        value: t,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      }) : e[r] = t, e;
-    }
-    module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
-  }
-});
-
-// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/classCallCheck.js
-var require_classCallCheck = __commonJS({
-  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/classCallCheck.js"(exports, module) {
-    "use strict";
-    function _classCallCheck(a, n) {
-      if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
-    }
-    module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;
-  }
-});
-
-// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/createClass.js
-var require_createClass = __commonJS({
-  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/createClass.js"(exports, module) {
-    "use strict";
-    var toPropertyKey = require_toPropertyKey();
-    function _defineProperties(e, r) {
-      for (var t = 0; t < r.length; t++) {
-        var o = r[t];
-        o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, toPropertyKey(o.key), o);
-      }
-    }
-    function _createClass(e, r, t) {
-      return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
-        writable: false
-      }), e;
-    }
-    module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;
-  }
-});
-
-// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/arrayLikeToArray.js
-var require_arrayLikeToArray = __commonJS({
-  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/arrayLikeToArray.js"(exports, module) {
-    "use strict";
-    function _arrayLikeToArray(r, a) {
-      (null == a || a > r.length) && (a = r.length);
-      for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
-      return n;
-    }
-    module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
-  }
-});
-
-// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js
-var require_arrayWithoutHoles = __commonJS({
-  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js"(exports, module) {
-    "use strict";
-    var arrayLikeToArray = require_arrayLikeToArray();
-    function _arrayWithoutHoles(r) {
-      if (Array.isArray(r)) return arrayLikeToArray(r);
-    }
-    module.exports = _arrayWithoutHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;
-  }
-});
-
-// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/iterableToArray.js
-var require_iterableToArray = __commonJS({
-  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/iterableToArray.js"(exports, module) {
-    "use strict";
-    function _iterableToArray(r) {
-      if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
-    }
-    module.exports = _iterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
-  }
-});
-
-// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js
-var require_unsupportedIterableToArray = __commonJS({
-  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js"(exports, module) {
-    "use strict";
-    var arrayLikeToArray = require_arrayLikeToArray();
-    function _unsupportedIterableToArray(r, a) {
-      if (r) {
-        if ("string" == typeof r) return arrayLikeToArray(r, a);
-        var t = {}.toString.call(r).slice(8, -1);
-        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;
-      }
-    }
-    module.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
-  }
-});
-
-// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/nonIterableSpread.js
-var require_nonIterableSpread = __commonJS({
-  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/nonIterableSpread.js"(exports, module) {
-    "use strict";
-    function _nonIterableSpread() {
-      throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-    }
-    module.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports["default"] = module.exports;
-  }
-});
-
-// ../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/toConsumableArray.js
-var require_toConsumableArray = __commonJS({
-  "../../node_modules/.pnpm/@babel+runtime@7.29.7/node_modules/@babel/runtime/helpers/toConsumableArray.js"(exports, module) {
-    "use strict";
-    var arrayWithoutHoles = require_arrayWithoutHoles();
-    var iterableToArray = require_iterableToArray();
-    var unsupportedIterableToArray = require_unsupportedIterableToArray();
-    var nonIterableSpread = require_nonIterableSpread();
-    function _toConsumableArray(r) {
-      return arrayWithoutHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableSpread();
-    }
-    module.exports = _toConsumableArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
-  }
-});
-
-// ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/evaluator/handlers.js
-var require_handlers = __commonJS({
-  "../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/evaluator/handlers.js"(exports) {
-    "use strict";
-    var _interopRequireDefault = require_interopRequireDefault();
-    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
-    var poolNames = {
-      functions: "Jexl Function",
-      transforms: "Transform"
-    };
-    exports.ArrayLiteral = function(ast) {
-      return this.evalArray(ast.value);
-    };
-    exports.BinaryExpression = function(ast) {
-      var _this = this;
-      var grammarOp = this._grammar.elements[ast.operator];
-      if (grammarOp.evalOnDemand) {
-        var wrap = function wrap2(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]);
-      });
-    };
-    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);
-      });
-    };
-    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);
-      });
-    };
-    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 void 0;
-        }
-        if (Array.isArray(context)) {
-          context = context[0];
-        }
-        return context[ast.value];
-      });
-    };
-    exports.Literal = function(ast) {
-      return ast.value;
-    };
-    exports.ObjectLiteral = function(ast) {
-      return this.evalMap(ast.value);
-    };
-    exports.FunctionCall = function(ast) {
-      var poolName = poolNames[ast.pool];
-      if (!poolName) {
-        throw new Error("Corrupt AST: Pool '".concat(ast.pool, "' not found"));
-      }
-      var pool = this._grammar[ast.pool];
-      var func = 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));
-      });
-    };
-    exports.UnaryExpression = function(ast) {
-      var _this4 = this;
-      return this.eval(ast.right).then(function(right) {
-        return _this4._grammar.elements[ast.operator].eval(right);
-      });
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/evaluator/Evaluator.js
-var require_Evaluator = __commonJS({
-  "../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/evaluator/Evaluator.js"(exports, module) {
-    "use strict";
-    var _interopRequireDefault = require_interopRequireDefault();
-    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
-    var _createClass2 = _interopRequireDefault(require_createClass());
-    var handlers = require_handlers();
-    var Evaluator = /* @__PURE__ */ (function() {
-      function Evaluator2(grammar, context, relativeContext) {
-        var promise = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : Promise;
-        (0, _classCallCheck2.default)(this, Evaluator2);
-        this._grammar = grammar;
-        this._context = context || {};
-        this._relContext = relativeContext || this._context;
-        this.Promise = promise;
-      }
-      (0, _createClass2.default)(Evaluator2, [{
-        key: "eval",
-        value: function _eval(ast) {
-          var _this = this;
-          return this.Promise.resolve().then(function() {
-            return handlers[ast.type].call(_this, ast);
-          });
-        }
-        /**
-         * Simultaneously evaluates each expression within an array, and delivers the
-         * response as an array with the resulting values at the same indexes as their
-         * originating expressions.
-         * @param {Array<string>} arr An array of expression strings to be evaluated
-         * @returns {Promise<Array<{}>>} resolves with the result array
-         */
-      }, {
-        key: "evalArray",
-        value: function evalArray(arr) {
-          var _this2 = this;
-          return this.Promise.all(arr.map(function(elem) {
-            return _this2.eval(elem);
-          }));
-        }
-        /**
-         * Simultaneously evaluates each expression within a map, and delivers the
-         * response as a map with the same keys, but with the evaluated result for each
-         * as their value.
-         * @param {{}} map A map of expression names to expression trees to be
-         *      evaluated
-         * @returns {Promise<{}>} resolves with the result map.
-         */
-      }, {
-        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;
-          });
-        }
-        /**
-         * Applies a filter expression with relative identifier elements to a subject.
-         * The intent is for the subject to be an array of subjects that will be
-         * individually used as the relative context against the provided expression
-         * tree. Only the elements whose expressions result in a truthy value will be
-         * included in the resulting array.
-         *
-         * If the subject is not an array of values, it will be converted to a single-
-         * element array before running the filter.
-         * @param {*} subject The value to be filtered usually an array. If this value is
-         *      not an array, it will be converted to an array with this value as the
-         *      only element.
-         * @param {{}} expr The expression tree to run against each subject. If the
-         *      tree evaluates to a truthy result, then the value will be included in
-         *      the returned array otherwise, it will be eliminated.
-         * @returns {Promise<Array>} resolves with an array of values that passed the
-         *      expression filter.
-         * @private
-         */
-      }, {
-        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 Evaluator2(_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;
-          });
-        }
-        /**
-         * Applies a static filter expression to a subject value.  If the filter
-         * expression evaluates to boolean true, the subject is returned if false,
-         * undefined.
-         *
-         * For any other resulting value of the expression, this function will attempt
-         * to respond with the property at that name or index of the subject.
-         * @param {*} subject The value to be filtered.  Usually an Array (for which
-         *      the expression would generally resolve to a numeric index) or an
-         *      Object (for which the expression would generally resolve to a string
-         *      indicating a property name)
-         * @param {{}} expr The expression tree to run against the subject
-         * @returns {Promise<*>} resolves with the value of the drill-down.
-         * @private
-         */
-      }, {
-        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 Evaluator2;
-    })();
-    module.exports = Evaluator;
-  }
-});
-
-// ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/Lexer.js
-var require_Lexer = __commonJS({
-  "../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/Lexer.js"(exports, module) {
-    "use strict";
-    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 = [
-      // Strings
-      "'(?:(?:\\\\')|[^'])*'",
-      '"(?:(?:\\\\")|[^"])*"',
-      // Whitespace
-      "\\s+",
-      // Booleans
-      "\\btrue\\b",
-      "\\bfalse\\b"
-    ];
-    var postOpRegexElems = [
-      // Identifiers
-      "[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)
-      "(?:(?:[0-9]*\\.[0-9]+)|[0-9]+)"
-    ];
-    var minusNegatesAfter = ["binaryOp", "unaryOp", "openParen", "openBracket", "question", "colon"];
-    var Lexer = /* @__PURE__ */ (function() {
-      function Lexer2(grammar) {
-        (0, _classCallCheck2.default)(this, Lexer2);
-        this._grammar = grammar;
-      }
-      (0, _createClass2.default)(Lexer2, [{
-        key: "getElements",
-        value: function getElements(str) {
-          var regex = this._getSplitRegex();
-          return str.split(regex).filter(function(elem) {
-            return elem;
-          });
-        }
-        /**
-         * Converts an array of expression elements into an array of tokens.  Note that
-         * the resulting array may not equal the element array in length, as any
-         * elements that consist only of whitespace get appended to the previous
-         * token's "raw" property.  For the structure of a token object, please see
-         * {@link Lexer#tokenize}.
-         * @param {Array<string>} elements An array of Jexl expression elements to be
-         *      converted to tokens
-         * @returns {Array<{type, value, raw}>} an array of token objects.
-         */
-      }, {
-        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;
-        }
-        /**
-         * Converts a Jexl string into an array of tokens.  Each token is an object
-         * in the following format:
-         *
-         *     {
-         *         type: <string>,
-         *         [name]: <string>,
-         *         value: <boolean|number|string>,
-         *         raw: <string>
-         *     }
-         *
-         * Type is one of the following:
-         *
-         *      literal, identifier, binaryOp, unaryOp
-         *
-         * OR, if the token is a control character its type is the name of the element
-         * defined in the Grammar.
-         *
-         * Name appears only if the token is a control string found in
-         * {@link grammar#elements}, and is set to the name of the element.
-         *
-         * Value is the value of the token in the correct type (boolean or numeric as
-         * appropriate). Raw is the string representation of this value taken directly
-         * from the expression string, including any trailing spaces.
-         * @param {string} str The Jexl string to be tokenized
-         * @returns {Array<{type, value, raw}>} an array of token objects.
-         * @throws {Error} if the provided string contains an invalid token.
-         */
-      }, {
-        key: "tokenize",
-        value: function tokenize(str) {
-          var elements = this.getElements(str);
-          return this.getTokens(elements);
-        }
-        /**
-         * Creates a new token object from an element of a Jexl string. See
-         * {@link Lexer#tokenize} for a description of the token object.
-         * @param {string} element The element from which a token should be made
-         * @returns {{value: number|boolean|string, [name]: string, type: string,
-         *      raw: string}} a token object describing the provided element.
-         * @throws {Error} if the provided string is not a valid expression element.
-         * @private
-         */
-      }, {
-        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;
-        }
-        /**
-         * Escapes a string so that it can be treated as a string literal within a
-         * regular expression.
-         * @param {string} str The string to be escaped
-         * @returns {string} the RegExp-escaped string.
-         * @see https://developer.mozilla.org/en/docs/Web/JavaScript/Guide/Regular_Expressions
-         * @private
-         */
-      }, {
-        key: "_escapeRegExp",
-        value: function _escapeRegExp(str) {
-          str = str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-          if (str.match(identRegex)) {
-            str = "\\b" + str + "\\b";
-          }
-          return str;
-        }
-        /**
-         * Gets a RegEx object appropriate for splitting a Jexl string into its core
-         * elements.
-         * @returns {RegExp} An element-splitting RegExp object
-         * @private
-         */
-      }, {
-        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;
-        }
-        /**
-         * Determines whether the addition of a '-' token should be interpreted as a
-         * negative symbol for an upcoming number, given an array of tokens already
-         * processed.
-         * @param {Array<Object>} tokens An array of tokens already processed
-         * @returns {boolean} true if adding a '-' should be considered a negative
-         *      symbol; false otherwise
-         * @private
-         */
-      }, {
-        key: "_isNegative",
-        value: function _isNegative(tokens) {
-          if (!tokens.length) return true;
-          return minusNegatesAfter.some(function(type) {
-            return type === tokens[tokens.length - 1].type;
-          });
-        }
-        /**
-         * A utility function to determine if a string consists of only space
-         * characters.
-         * @param {string} str A string to be tested
-         * @returns {boolean} true if the string is empty or consists of only spaces;
-         *      false otherwise.
-         * @private
-         */
-      }, {
-        key: "_isWhitespace",
-        value: function _isWhitespace(str) {
-          return !!str.match(whitespaceRegex);
-        }
-        /**
-         * Removes the beginning and trailing quotes from a string, unescapes any
-         * escaped quotes on its interior, and unescapes any escaped escape
-         * characters. Note that this function is not defensive; it assumes that the
-         * provided string is not empty, and that its first and last characters are
-         * actually quotes.
-         * @param {string} str A string whose first and last characters are quotes
-         * @returns {string} a string with the surrounding quotes stripped and escapes
-         *      properly processed.
-         * @private
-         */
-      }, {
-        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 Lexer2;
-    })();
-    module.exports = Lexer;
-  }
-});
-
-// ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/parser/handlers.js
-var require_handlers2 = __commonJS({
-  "../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/parser/handlers.js"(exports) {
-    "use strict";
-    exports.argVal = function(ast) {
-      if (ast) this._cursor.args.push(ast);
-    };
-    exports.arrayStart = function() {
-      this._placeAtCursor({
-        type: "ArrayLiteral",
-        value: []
-      });
-    };
-    exports.arrayVal = function(ast) {
-      if (ast) {
-        this._cursor.value.push(ast);
-      }
-    };
-    exports.binaryOp = function(token) {
-      var precedence = this._grammar.elements[token.value].precedence || 0;
-      var parent = this._cursor._parent;
-      while (parent && parent.operator && this._grammar.elements[parent.operator].precedence >= precedence) {
-        this._cursor = parent;
-        parent = parent._parent;
-      }
-      var node = {
-        type: "BinaryExpression",
-        operator: token.value,
-        left: this._cursor
-      };
-      this._setParent(this._cursor, node);
-      this._cursor = parent;
-      this._placeAtCursor(node);
-    };
-    exports.dot = function() {
-      this._nextIdentEncapsulate = this._cursor && this._cursor.type !== "UnaryExpression" && (this._cursor.type !== "BinaryExpression" || this._cursor.type === "BinaryExpression" && this._cursor.right);
-      this._nextIdentRelative = !this._cursor || this._cursor && !this._nextIdentEncapsulate;
-      if (this._nextIdentRelative) {
-        this._relative = true;
-      }
-    };
-    exports.filter = function(ast) {
-      this._placeBeforeCursor({
-        type: "FilterExpression",
-        expr: ast,
-        relative: this._subParser.isRelative(),
-        subject: this._cursor
-      });
-    };
-    exports.functionCall = function() {
-      this._placeBeforeCursor({
-        type: "FunctionCall",
-        name: this._cursor.value,
-        args: [],
-        pool: "functions"
-      });
-    };
-    exports.identifier = function(token) {
-      var node = {
-        type: "Identifier",
-        value: token.value
-      };
-      if (this._nextIdentEncapsulate) {
-        node.from = this._cursor;
-        this._placeBeforeCursor(node);
-        this._nextIdentEncapsulate = false;
-      } else {
-        if (this._nextIdentRelative) {
-          node.relative = true;
-          this._nextIdentRelative = false;
-        }
-        this._placeAtCursor(node);
-      }
-    };
-    exports.literal = function(token) {
-      this._placeAtCursor({
-        type: "Literal",
-        value: token.value
-      });
-    };
-    exports.objKey = function(token) {
-      this._curObjKey = token.value;
-    };
-    exports.objStart = function() {
-      this._placeAtCursor({
-        type: "ObjectLiteral",
-        value: {}
-      });
-    };
-    exports.objVal = function(ast) {
-      this._cursor.value[this._curObjKey] = ast;
-    };
-    exports.subExpression = function(ast) {
-      this._placeAtCursor(ast);
-    };
-    exports.ternaryEnd = function(ast) {
-      this._cursor.alternate = ast;
-    };
-    exports.ternaryMid = function(ast) {
-      this._cursor.consequent = ast;
-    };
-    exports.ternaryStart = function() {
-      this._tree = {
-        type: "ConditionalExpression",
-        test: this._tree
-      };
-      this._cursor = this._tree;
-    };
-    exports.transform = function(token) {
-      this._placeBeforeCursor({
-        type: "FunctionCall",
-        name: token.value,
-        args: [this._cursor],
-        pool: "transforms"
-      });
-    };
-    exports.unaryOp = function(token) {
-      this._placeAtCursor({
-        type: "UnaryExpression",
-        operator: token.value
-      });
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/parser/states.js
-var require_states = __commonJS({
-  "../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/parser/states.js"(exports) {
-    "use strict";
-    var h = require_handlers2();
-    exports.states = {
-      expectOperand: {
-        tokenTypes: {
-          literal: {
-            toState: "expectBinOp"
-          },
-          identifier: {
-            toState: "identifier"
-          },
-          unaryOp: {},
-          openParen: {
-            toState: "subExpression"
-          },
-          openCurl: {
-            toState: "expectObjKey",
-            handler: h.objStart
-          },
-          dot: {
-            toState: "traverse"
-          },
-          openBracket: {
-            toState: "arrayVal",
-            handler: h.arrayStart
-          }
-        }
-      },
-      expectBinOp: {
-        tokenTypes: {
-          binaryOp: {
-            toState: "expectOperand"
-          },
-          pipe: {
-            toState: "expectTransform"
-          },
-          dot: {
-            toState: "traverse"
-          },
-          question: {
-            toState: "ternaryMid",
-            handler: h.ternaryStart
-          }
-        },
-        completable: true
-      },
-      expectTransform: {
-        tokenTypes: {
-          identifier: {
-            toState: "postTransform",
-            handler: h.transform
-          }
-        }
-      },
-      expectObjKey: {
-        tokenTypes: {
-          identifier: {
-            toState: "expectKeyValSep",
-            handler: h.objKey
-          },
-          closeCurl: {
-            toState: "expectBinOp"
-          }
-        }
-      },
-      expectKeyValSep: {
-        tokenTypes: {
-          colon: {
-            toState: "objVal"
-          }
-        }
-      },
-      postTransform: {
-        tokenTypes: {
-          openParen: {
-            toState: "argVal"
-          },
-          binaryOp: {
-            toState: "expectOperand"
-          },
-          dot: {
-            toState: "traverse"
-          },
-          openBracket: {
-            toState: "filter"
-          },
-          pipe: {
-            toState: "expectTransform"
-          }
-        },
-        completable: true
-      },
-      postArgs: {
-        tokenTypes: {
-          binaryOp: {
-            toState: "expectOperand"
-          },
-          dot: {
-            toState: "traverse"
-          },
-          openBracket: {
-            toState: "filter"
-          },
-          pipe: {
-            toState: "expectTransform"
-          }
-        },
-        completable: true
-      },
-      identifier: {
-        tokenTypes: {
-          binaryOp: {
-            toState: "expectOperand"
-          },
-          dot: {
-            toState: "traverse"
-          },
-          openBracket: {
-            toState: "filter"
-          },
-          openParen: {
-            toState: "argVal",
-            handler: h.functionCall
-          },
-          pipe: {
-            toState: "expectTransform"
-          },
-          question: {
-            toState: "ternaryMid",
-            handler: h.ternaryStart
-          }
-        },
-        completable: true
-      },
-      traverse: {
-        tokenTypes: {
-          identifier: {
-            toState: "identifier"
-          }
-        }
-      },
-      filter: {
-        subHandler: h.filter,
-        endStates: {
-          closeBracket: "identifier"
-        }
-      },
-      subExpression: {
-        subHandler: h.subExpression,
-        endStates: {
-          closeParen: "expectBinOp"
-        }
-      },
-      argVal: {
-        subHandler: h.argVal,
-        endStates: {
-          comma: "argVal",
-          closeParen: "postArgs"
-        }
-      },
-      objVal: {
-        subHandler: h.objVal,
-        endStates: {
-          comma: "expectObjKey",
-          closeCurl: "expectBinOp"
-        }
-      },
-      arrayVal: {
-        subHandler: h.arrayVal,
-        endStates: {
-          comma: "arrayVal",
-          closeBracket: "expectBinOp"
-        }
-      },
-      ternaryMid: {
-        subHandler: h.ternaryMid,
-        endStates: {
-          colon: "ternaryEnd"
-        }
-      },
-      ternaryEnd: {
-        subHandler: h.ternaryEnd,
-        completable: true
-      }
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/parser/Parser.js
-var require_Parser = __commonJS({
-  "../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/parser/Parser.js"(exports, module) {
-    "use strict";
-    var _interopRequireDefault = require_interopRequireDefault();
-    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
-    var _createClass2 = _interopRequireDefault(require_createClass());
-    var handlers = require_handlers2();
-    var states = require_states().states;
-    var Parser = /* @__PURE__ */ (function() {
-      function Parser2(grammar, prefix, stopMap) {
-        (0, _classCallCheck2.default)(this, Parser2);
-        this._grammar = grammar;
-        this._state = "expectOperand";
-        this._tree = null;
-        this._exprStr = prefix || "";
-        this._relative = false;
-        this._stopMap = stopMap || {};
-      }
-      (0, _createClass2.default)(Parser2, [{
-        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;
-        }
-        /**
-         * Processes an array of tokens iteratively through the {@link #addToken}
-         * function.
-         * @param {Array<{type: <string>}>} tokens An array of tokens, as provided by
-         *      the {@link Lexer#tokenize} function.
-         */
-      }, {
-        key: "addTokens",
-        value: function addTokens(tokens) {
-          tokens.forEach(this.addToken, this);
-        }
-        /**
-         * Marks this Parser instance as completed and retrieves the full AST.
-         * @returns {{}|null} a full expression tree, ready for evaluation by the
-         *      {@link Evaluator#eval} function, or null if no tokens were passed to
-         *      the parser before complete was called
-         * @throws {Error} if the parser is not in a state where it's legal to end
-         *      the expression, indicating that the expression is incomplete
-         */
-      }, {
-        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;
-        }
-        /**
-         * Indicates whether the expression tree contains a relative path identifier.
-         * @returns {boolean} true if a relative identifier exists false otherwise.
-         */
-      }, {
-        key: "isRelative",
-        value: function isRelative() {
-          return this._relative;
-        }
-        /**
-         * Ends a subexpression by completing the subParser and passing its result
-         * to the subHandler configured in the current state.
-         * @private
-         */
-      }, {
-        key: "_endSubExpression",
-        value: function _endSubExpression() {
-          states[this._state].subHandler.call(this, this._subParser.complete());
-          this._subParser = null;
-        }
-        /**
-         * Places a new tree node at the current position of the cursor (to the 'right'
-         * property) and then advances the cursor to the new node. This function also
-         * handles setting the parent of the new node.
-         * @param {{type: <string>}} node A node to be added to the AST
-         * @private
-         */
-      }, {
-        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;
-        }
-        /**
-         * Places a tree node before the current position of the cursor, replacing
-         * the node that the cursor currently points to. This should only be called in
-         * cases where the cursor is known to exist, and the provided node already
-         * contains a pointer to what's at the cursor currently.
-         * @param {{type: <string>}} node A node to be added to the AST
-         * @private
-         */
-      }, {
-        key: "_placeBeforeCursor",
-        value: function _placeBeforeCursor(node) {
-          this._cursor = this._cursor._parent;
-          this._placeAtCursor(node);
-        }
-        /**
-         * Sets the parent of a node by creating a non-enumerable _parent property
-         * that points to the supplied parent argument.
-         * @param {{type: <string>}} node A node of the AST on which to set a new
-         *      parent
-         * @param {{type: <string>}} parent An existing node of the AST to serve as the
-         *      parent of the new node
-         * @private
-         */
-      }, {
-        key: "_setParent",
-        value: function _setParent(node, parent) {
-          Object.defineProperty(node, "_parent", {
-            value: parent,
-            writable: true
-          });
-        }
-        /**
-         * Prepares the Parser to accept a subexpression by (re)instantiating the
-         * subParser.
-         * @param {string} [exprStr] The expression string to prefix to the new Parser
-         * @private
-         */
-      }, {
-        key: "_startSubExpression",
-        value: function _startSubExpression(exprStr) {
-          var endStates = states[this._state].endStates;
-          if (!endStates) {
-            this._parentStop = true;
-            endStates = this._stopMap;
-          }
-          this._subParser = new Parser2(this._grammar, exprStr, endStates);
-        }
-      }]);
-      return Parser2;
-    })();
-    module.exports = Parser;
-  }
-});
-
-// ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/PromiseSync.js
-var require_PromiseSync = __commonJS({
-  "../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/PromiseSync.js"(exports, module) {
-    "use strict";
-    var _interopRequireDefault = require_interopRequireDefault();
-    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
-    var _createClass2 = _interopRequireDefault(require_createClass());
-    var PromiseSync = /* @__PURE__ */ (function() {
-      function PromiseSync2(fn) {
-        (0, _classCallCheck2.default)(this, PromiseSync2);
-        fn(this._resolve.bind(this), this._reject.bind(this));
-      }
-      (0, _createClass2.default)(PromiseSync2, [{
-        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 PromiseSync2) {
-            if (val.error) {
-              this._reject(val.error);
-            } else {
-              this._resolve(val.value);
-            }
-          } else {
-            this.value = val;
-            this.error = void 0;
-          }
-        }
-      }]);
-      return PromiseSync2;
-    })();
-    PromiseSync.all = function(vals) {
-      return new PromiseSync(function(resolve) {
-        var resolved = vals.map(function(val) {
-          while (val instanceof PromiseSync) {
-            if (val.error) throw Error(val.error);
-            val = val.value;
-          }
-          return val;
-        });
-        resolve(resolved);
-      });
-    };
-    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;
-  }
-});
-
-// ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/Expression.js
-var require_Expression = __commonJS({
-  "../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/Expression.js"(exports, module) {
-    "use strict";
-    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();
-    var Expression = /* @__PURE__ */ (function() {
-      function Expression2(grammar, exprStr) {
-        (0, _classCallCheck2.default)(this, Expression2);
-        this._grammar = grammar;
-        this._exprStr = exprStr;
-        this._ast = null;
-      }
-      (0, _createClass2.default)(Expression2, [{
-        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;
-        }
-        /**
-         * Asynchronously evaluates the expression within an optional context.
-         * @param {Object} [context] A mapping of variables to values, which will be
-         *      made accessible to the Jexl expression when evaluating it
-         * @returns {Promise<*>} resolves with the result of the evaluation.
-         */
-      }, {
-        key: "eval",
-        value: function _eval() {
-          var context = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-          return this._eval(context, Promise);
-        }
-        /**
-         * Synchronously evaluates the expression within an optional context.
-         * @param {Object} [context] A mapping of variables to values, which will be
-         *      made accessible to the Jexl expression when evaluating it
-         * @returns {*} the result of the evaluation.
-         * @throws {*} on error
-         */
-      }, {
-        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();
-            var evaluator = new Evaluator(_this._grammar, context, void 0, promise);
-            return evaluator.eval(ast);
-          });
-        }
-      }, {
-        key: "_getAst",
-        value: function _getAst() {
-          if (!this._ast) this.compile();
-          return this._ast;
-        }
-      }]);
-      return Expression2;
-    })();
-    module.exports = Expression;
-  }
-});
-
-// ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/grammar.js
-var require_grammar = __commonJS({
-  "../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/grammar.js"(exports) {
-    "use strict";
-    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: {}
-      };
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/Jexl.js
-var require_Jexl = __commonJS({
-  "../../node_modules/.pnpm/jexl@2.3.0/node_modules/jexl/dist/Jexl.js"(exports, module) {
-    "use strict";
-    var _interopRequireDefault = require_interopRequireDefault();
-    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
-    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
-    var _createClass2 = _interopRequireDefault(require_createClass());
-    var Expression = require_Expression();
-    var _require = require_grammar();
-    var getGrammar = _require.getGrammar;
-    var Jexl = /* @__PURE__ */ (function() {
-      function Jexl2() {
-        (0, _classCallCheck2.default)(this, Jexl2);
-        this.expr = this.expr.bind(this);
-        this._grammar = getGrammar();
-      }
-      (0, _createClass2.default)(Jexl2, [{
-        key: "addBinaryOp",
-        value: function addBinaryOp(operator, precedence, fn, manualEval) {
-          this._addGrammarElement(operator, (0, _defineProperty2.default)({
-            type: "binaryOp",
-            precedence
-          }, manualEval ? "evalOnDemand" : "eval", fn));
-        }
-        /**
-         * Adds or replaces an expression function in this Jexl instance.
-         * @param {string} name The name of the expression function, as it will be
-         *      used within Jexl expressions
-         * @param {function} fn The javascript function to be executed when this
-         *      expression function is invoked. It will be provided with each argument
-         *      supplied in the expression, in the same order.
-         */
-      }, {
-        key: "addFunction",
-        value: function addFunction(name, fn) {
-          this._grammar.functions[name] = fn;
-        }
-        /**
-         * Syntactic sugar for calling {@link #addFunction} repeatedly. This function
-         * accepts a map of one or more expression function names to their javascript
-         * function counterpart.
-         * @param {{}} map A map of expression function names to javascript functions
-         */
-      }, {
-        key: "addFunctions",
-        value: function addFunctions(map) {
-          for (var key in map) {
-            this._grammar.functions[key] = map[key];
-          }
-        }
-        /**
-         * Adds a unary operator to Jexl. Unary operators are currently only supported
-         * on the left side of the value on which it will operate.
-         * @param {string} operator The operator string to be added
-         * @param {function} fn A function to run to calculate the result. The function
-         *      will be called with one argument: the literal value to the right of the
-         *      operator. It should return either the resulting value, or a Promise
-         *      that resolves with the resulting value.
-         */
-      }, {
-        key: "addUnaryOp",
-        value: function addUnaryOp(operator, fn) {
-          this._addGrammarElement(operator, {
-            type: "unaryOp",
-            weight: Infinity,
-            eval: fn
-          });
-        }
-        /**
-         * Adds or replaces a transform function in this Jexl instance.
-         * @param {string} name The name of the transform function, as it will be used
-         *      within Jexl expressions
-         * @param {function} fn The function to be executed when this transform is
-         *      invoked. It will be provided with at least one argument:
-         *          - {*} value: The value to be transformed
-         *          - {...*} args: The arguments for this transform
-         */
-      }, {
-        key: "addTransform",
-        value: function addTransform(name, fn) {
-          this._grammar.transforms[name] = fn;
-        }
-        /**
-         * Syntactic sugar for calling {@link #addTransform} repeatedly.  This function
-         * accepts a map of one or more transform names to their transform function.
-         * @param {{}} map A map of transform names to transform functions
-         */
-      }, {
-        key: "addTransforms",
-        value: function addTransforms(map) {
-          for (var key in map) {
-            this._grammar.transforms[key] = map[key];
-          }
-        }
-        /**
-         * Creates an Expression object from the given Jexl expression string, and
-         * immediately compiles it. The returned Expression object can then be
-         * evaluated multiple times with new contexts, without generating any
-         * additional string processing overhead.
-         * @param {string} expression The Jexl expression to be compiled
-         * @returns {Expression} The compiled Expression object
-         */
-      }, {
-        key: "compile",
-        value: function compile(expression) {
-          var exprObj = this.createExpression(expression);
-          return exprObj.compile();
-        }
-        /**
-         * Constructs an Expression object from a Jexl expression string.
-         * @param {string} expression The Jexl expression to be wrapped in an
-         *    Expression object
-         * @returns {Expression} The Expression object representing the given string
-         */
-      }, {
-        key: "createExpression",
-        value: function createExpression(expression) {
-          return new Expression(this._grammar, expression);
-        }
-        /**
-         * Retrieves a previously set expression function.
-         * @param {string} name The name of the expression function
-         * @returns {function} The expression function
-         */
-      }, {
-        key: "getFunction",
-        value: function getFunction(name) {
-          return this._grammar.functions[name];
-        }
-        /**
-         * Retrieves a previously set transform function.
-         * @param {string} name The name of the transform function
-         * @returns {function} The transform function
-         */
-      }, {
-        key: "getTransform",
-        value: function getTransform(name) {
-          return this._grammar.transforms[name];
-        }
-        /**
-         * Asynchronously evaluates a Jexl string within an optional context.
-         * @param {string} expression The Jexl expression to be evaluated
-         * @param {Object} [context] A mapping of variables to values, which will be
-         *      made accessible to the Jexl expression when evaluating it
-         * @returns {Promise<*>} resolves with the result of the evaluation.
-         */
-      }, {
-        key: "eval",
-        value: function _eval(expression) {
-          var context = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-          var exprObj = this.createExpression(expression);
-          return exprObj.eval(context);
-        }
-        /**
-         * Synchronously evaluates a Jexl string within an optional context.
-         * @param {string} expression The Jexl expression to be evaluated
-         * @param {Object} [context] A mapping of variables to values, which will be
-         *      made accessible to the Jexl expression when evaluating it
-         * @returns {*} the result of the evaluation.
-         * @throws {*} on error
-         */
-      }, {
-        key: "evalSync",
-        value: function evalSync(expression) {
-          var context = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-          var exprObj = this.createExpression(expression);
-          return exprObj.evalSync(context);
-        }
-        /**
-         * A JavaScript template literal to allow expressions to be defined by the
-         * syntax: expr`40 + 2`
-         * @param {Array<string>} strs
-         * @param  {...any} args
-         */
-      }, {
-        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);
-        }
-        /**
-         * Removes a binary or unary operator from the Jexl grammar.
-         * @param {string} operator The operator string to be removed
-         */
-      }, {
-        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];
-          }
-        }
-        /**
-         * Adds an element to the grammar map used by this Jexl instance.
-         * @param {string} str The key string to be added
-         * @param {{type: <string>}} obj A map of configuration options for this
-         *      grammar element
-         * @private
-         */
-      }, {
-        key: "_addGrammarElement",
-        value: function _addGrammarElement(str, obj) {
-          this._grammar.elements[str] = obj;
-        }
-      }]);
-      return Jexl2;
-    })();
-    module.exports = new Jexl();
-    module.exports.Jexl = Jexl;
-  }
-});
-
-export {
-  require_Jexl
-};