@dyrected/core 2.8.3 → 2.9.0

package/dist/{chunk-GFFGDHST.js → chunk-XRIONGRY.js}

@@ -1,3 +1,1759 @@
+import {
+  __commonJS,
+  __toESM
+} 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;
+  }
+});
+
 // src/workflows.ts
 var WORKFLOW_HISTORY_COLLECTION = "__workflow_history";
 var LIFECYCLE_EVENTS_COLLECTION = "__lifecycle_events";
@@ -394,7 +2150,7 @@ async function transitionWorkflow(args) {
       await hook({ ...hookContext, doc: updated, event: events[0] });
     } catch (error) {
       try {
-        const { getConfigLogger, getObservabilityRuntime } = await import("./observability-KCMTV7GO.js");
+        const { getConfigLogger, getObservabilityRuntime } = await import("./observability-HQF4EUSV.js");
         getObservabilityRuntime(config)?.recordWorkflowHookFailure({
           collection: collection.slug,
           transition: transition.name
@@ -450,7 +2206,7 @@ function humanizeProviderName(id, type) {
 }
 
 // src/utils/jexl-helpers.ts
-import jexl from "jexl";
+var import_jexl = __toESM(require_Jexl(), 1);
 function slugify(val) {
   if (val === void 0 || val === null) return "";
   return String(val).normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/[^a-z0-9\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -657,7 +2413,7 @@ function get(obj, path, fallback = null) {
   }
   return curr === void 0 || curr === null ? fallback : curr;
 }
-function registerJexlHelpers(jexlInstance = jexl) {
+function registerJexlHelpers(jexlInstance = import_jexl.default) {
   const helpers = {
     // Strings
     slugify,
@@ -721,7 +2477,7 @@ function registerJexlHelpers(jexlInstance = jexl) {
   } catch {
   }
 }
-registerJexlHelpers(jexl);
+registerJexlHelpers(import_jexl.default);
 async function evaluateJexl(expression, context = {}) {
   if (!expression || typeof expression !== "string") return void 0;
   try {
@@ -732,7 +2488,7 @@ async function evaluateJexl(expression, context = {}) {
       math: Math,
       Math
     };
-    return await jexl.eval(expression, evalContext);
+    return await import_jexl.default.eval(expression, evalContext);
   } catch (_err) {
     return void 0;
   }
@@ -747,7 +2503,7 @@ function evaluateJexlSync(expression, context = {}) {
       math: Math,
       Math
     };
-    return jexl.evalSync(expression, evalContext);
+    return import_jexl.default.evalSync(expression, evalContext);
   } catch (_err) {
     return void 0;
   }
@@ -792,8 +2548,8 @@ var BUILTIN_JEXL_HELPERS = [
 ];
 
 // src/utils/declarative-hooks.ts
-import jexl2 from "jexl";
-registerJexlHelpers(jexl2);
+var import_jexl2 = __toESM(require_Jexl(), 1);
+registerJexlHelpers(import_jexl2.default);
 var SURFACE_ROOTS = {
   "collection.beforeRead": ["req", "user", "query", ...BUILTIN_JEXL_HELPERS],
   "collection.afterRead": ["req", "user", "doc", ...BUILTIN_JEXL_HELPERS],
@@ -811,7 +2567,7 @@ var COMPILE_CACHE = /* @__PURE__ */ new Map();
 function compileExpression(expression) {
   const cached = COMPILE_CACHE.get(expression);
   if (cached) return cached;
-  const compiled = jexl2.compile(expression);
+  const compiled = import_jexl2.default.compile(expression);
   const next = { ast: compiled._ast };
   COMPILE_CACHE.set(expression, next);
   return next;
@@ -1967,7 +3723,7 @@ function normalizeConfig(config) {
 }
 
 // src/utils/hooks.ts
-import jexl3 from "jexl";
+var import_jexl3 = __toESM(require_Jexl(), 1);
 async function runCollectionHooks(hooks, args, options = {}) {
   if (!hooks || hooks.length === 0) {
     return args.data ?? args.doc ?? args.query ?? void 0;
@@ -1988,7 +3744,7 @@ async function runCollectionHooks(hooks, args, options = {}) {
             options.path ?? options.surface
           );
         }
-        return jexl3.eval(hook, hookArgs);
+        return import_jexl3.default.eval(hook, hookArgs);
       })() : await hook(hookArgs);
       if (result !== void 0) {
         if (typeof hook === "string" && options.surface) {
@@ -2037,7 +3793,7 @@ async function executeFieldBeforeChange(fields, data, originalDoc, user, db, pat
             "field.beforeChange",
             fieldPath
           );
-          return jexl3.eval(hook, hookArgs);
+          return import_jexl3.default.eval(hook, hookArgs);
         })() : await hook(hookArgs);
       }
       result[field.name] = updatedValue;
@@ -3458,6 +5214,7 @@ export {
   resolveAdminAuthCollection,
   getPublicAdminAuthConfig,
   mergeDynamicConfig,
+  require_Jexl,
   slugify,
   lower,
   upper,