@routier/core 0.2.0 → 0.3.0

package/dist/expressions/index.cjs

@@ -0,0 +1,2087 @@
+(() => {
+"use strict";
+var __webpack_modules__ = ({
+126(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  assertString: () => (assertString),
+  isComparatorExpression: () => (isComparatorExpression),
+  isOperatorExpression: () => (isOperatorExpression),
+  isPropertyExpression: () => (isPropertyExpression),
+  isValueExpression: () => (isValueExpression)
+});
+
+
+function assertDate(data) {
+    if (isDate(data) === false) {
+        throw new TypeError('Value is not a Date');
+    }
+}
+function assertIsNotNull(data, message) {
+    if (data == null) {
+        if (message == null) {
+            throw new TypeError('Assertion failed, data is null');
+        }
+        if (typeof message === "string") {
+            throw new TypeError(message);
+        }
+        throw new TypeError(message());
+    }
+}
+function assertIsArray(data, message) {
+    if (!Array.isArray(data)) {
+        throw new TypeError(message ?? 'Assertion failed, data is not of type Array');
+    }
+}
+function assertString(data, message) {
+    if (typeof data !== "string") {
+        throw new TypeError(message ?? 'Assertion failed, data is not of type String');
+    }
+}
+function assertInstanceOf(value, Instance) {
+    if (value instanceof Instance) {
+        return;
+    }
+    if (value != null && typeof value === "object" && "constructor" in value) {
+        throw new TypeError(`value is not instance of type.  Type: ${value.constructor.name}`);
+    }
+    throw new TypeError(`value is not instance of type`);
+}
+function assertIsNumber(value) {
+    if (typeof value !== "number") {
+        throw new TypeError("value is not of type `number`");
+    }
+}
+function isObjectWithType(value) {
+    return typeof value === "object" && value !== null && "type" in value;
+}
+/**
+ * Type guard: narrows `value` to `Expression` when it is an object with a valid `type` property.
+ */ function isExpression(value) {
+    return isObjectWithType(value) && EXPRESSION_TYPES.includes(value.type);
+}
+/**
+ * Type guard: narrows `value` to `OperatorExpression` when it is an object with `type === "operator"`.
+ */ function isOperatorExpression(value) {
+    return isObjectWithType(value) && value.type === "operator";
+}
+/**
+ * Type guard: narrows `value` to `ComparatorExpression` when it is an object with `type === "comparator"`.
+ */ function isComparatorExpression(value) {
+    return isObjectWithType(value) && value.type === "comparator";
+}
+/**
+ * Type guard: narrows `value` to `PropertyExpression` when it is an object with `type === "property"`.
+ */ function isPropertyExpression(value) {
+    return isObjectWithType(value) && value.type === "property";
+}
+/**
+ * Type guard: narrows `value` to `ValueExpression` when it is an object with `type === "value"`.
+ */ function isValueExpression(value) {
+    return isObjectWithType(value) && value.type === "value";
+}
+/**
+ * Type guard: narrows `value` to `EmptyExpression` when it is an object with `type === "empty"`.
+ */ function isEmptyExpression(value) {
+    return isObjectWithType(value) && value.type === "empty";
+}
+/**
+ * Type guard: narrows `value` to `NotParsableExpression` when it is an object with `type === "not-parsable"`.
+ */ function isNotParsableExpression(value) {
+    return isObjectWithType(value) && value.type === "not-parsable";
+}
+
+
+},
+835(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  t: () => (EXPRESSION_TYPES)
+});
+const EXPRESSION_TYPES = [
+    "operator",
+    "comparator",
+    "property",
+    "value",
+    "empty",
+    "not-parsable"
+];
+
+
+},
+379(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  Vu: () => (toPredicate),
+  _3: () => (evaluate),
+  wS: () => (toStrictPredicate)
+});
+/* import */ var _assertions__rspack_import_0 = __webpack_require__(126);
+
+/** Reads a property or literal operand, or `UNRESOLVED` when the node is not one. */ const UNRESOLVED = Symbol("unresolved");
+const applyTransformer = (value, transformer)=>{
+    if (transformer == null) {
+        return value;
+    }
+    // A transformer applied to an absent value has no answer, and inventing one ("" for a missing
+    // string) is how a filter starts matching rows it should not.
+    if (value == null) {
+        return UNRESOLVED;
+    }
+    if (transformer === "to-lower-case") {
+        return typeof value === "string" ? value.toLowerCase() : UNRESOLVED;
+    }
+    if (transformer === "to-upper-case") {
+        return typeof value === "string" ? value.toUpperCase() : UNRESOLVED;
+    }
+    if (transformer === "length") {
+        return typeof value === "string" || Array.isArray(value) ? value.length : UNRESOLVED;
+    }
+    return UNRESOLVED;
+};
+const operand = (expression, row)=>{
+    if (expression == null) {
+        return UNRESOLVED;
+    }
+    if ((0,_assertions__rspack_import_0.isValueExpression)(expression)) {
+        return applyTransformer(expression.value, expression.transformer);
+    }
+    if ((0,_assertions__rspack_import_0.isPropertyExpression)(expression)) {
+        // Through the PropertyInfo, so a nested path and a `from`-renamed segment resolve the same
+        // way every other consumer of the tree resolves them.
+        return applyTransformer(expression.property.getValue(row), expression.transformer);
+    }
+    return UNRESOLVED;
+};
+/**
+ * `a === b` for the comparators, with Dates compared by VALUE.
+ *
+ * A Date compares by reference under `===`, so two Dates holding the same instant would be
+ * unequal — which is not what a filter on a date means, and not what any backend does.
+ */ const equals = (left, right, strict)=>{
+    if (left instanceof Date && right instanceof Date) {
+        return left.getTime() === right.getTime();
+    }
+    // oxlint-disable-next-line eqeqeq
+    return strict ? left === right : left == right;
+};
+/** Ordered comparison, only for shapes that have an order. */ const compare = (left, right, comparator)=>{
+    const asComparable = (value)=>value instanceof Date ? value.getTime() : value;
+    const a = asComparable(left);
+    const b = asComparable(right);
+    const comparable = typeof a === "number" && typeof b === "number" || typeof a === "string" && typeof b === "string";
+    if (comparable === false) {
+        return undefined;
+    }
+    if (comparator === "greater-than") {
+        return a > b;
+    }
+    if (comparator === "greater-than-equals") {
+        return a >= b;
+    }
+    if (comparator === "less-than") {
+        return a < b;
+    }
+    return a <= b;
+};
+const evaluateComparator = (comparator, left, right, strict)=>{
+    if (comparator === "equals") {
+        return equals(left, right, strict);
+    }
+    if (comparator === "includes") {
+        // Two shapes, and the tree does not distinguish them: `array.includes(value)` and
+        // `string.includes(substring)`. Whichever side is the container decides.
+        if (Array.isArray(left)) {
+            return left.some((item)=>equals(item, right, strict));
+        }
+        if (Array.isArray(right)) {
+            return right.some((item)=>equals(item, left, strict));
+        }
+        return typeof left === "string" && typeof right === "string" ? left.includes(right) : undefined;
+    }
+    if (comparator === "starts-with") {
+        return typeof left === "string" && typeof right === "string" ? left.startsWith(right) : undefined;
+    }
+    if (comparator === "ends-with") {
+        return typeof left === "string" && typeof right === "string" ? left.endsWith(right) : undefined;
+    }
+    return compare(left, right, comparator);
+};
+/**
+ * Evaluates `expression` against `row`, or returns `undefined` when it cannot.
+ *
+ * See the note at the top of this file: `undefined` means KEEP the row.
+ */ const evaluate = (expression, row)=>{
+    if ((0,_assertions__rspack_import_0.isOperatorExpression)(expression)) {
+        const left = expression.left == null ? undefined : evaluate(expression.left, row);
+        const right = expression.right == null ? undefined : evaluate(expression.right, row);
+        /**
+         * One unevaluable side does not have to sink the whole tree.
+         *
+         * `a && b` where `a` is definitely false is false whatever `b` is, and `a || b` where `a`
+         * is definitely true is true. That short-circuiting is what lets a mostly-understood
+         * predicate still narrow anything at all — without it, one unfamiliar sub-expression makes
+         * the entire filter a no-op.
+         */ if (expression.operator === "&&") {
+            if (left === false || right === false) {
+                return false;
+            }
+            return left === true && right === true ? true : undefined;
+        }
+        if (left === true || right === true) {
+            return true;
+        }
+        return left === false && right === false ? false : undefined;
+    }
+    if ((0,_assertions__rspack_import_0.isComparatorExpression)(expression)) {
+        const left = operand(expression.left, row);
+        const right = operand(expression.right, row);
+        if (left === UNRESOLVED || right === UNRESOLVED) {
+            return undefined;
+        }
+        const result = evaluateComparator(expression.comparator, left, right, expression.strict);
+        if (result === undefined) {
+            return undefined;
+        }
+        return expression.negated ? result === false : result;
+    }
+    // A tautology excludes nothing, which is exactly `true`. Anything else — a bare property, a
+    // literal, `not-parsable` — is not a predicate this can judge.
+    return expression.type === "empty" ? true : undefined;
+};
+/**
+ * `evaluate`, as a predicate that keeps whatever it cannot judge.
+ *
+ * The form every narrowing caller wants, with the fail-open rule applied once here rather than
+ * remembered at each call site.
+ */ const toPredicate = (expression)=>(row)=>evaluate(expression, row) !== false;
+/**
+ * `evaluate`, as a predicate that THROWS on anything it cannot judge.
+ *
+ * The opposite default to `toPredicate`, and the right one when the predicate is the only thing
+ * standing between a caller and rows they asked to exclude — a filter that arrived over a wire and
+ * is being applied by the receiver. Failing open there does not cost a wasted comparison; it returns
+ * data the requester filtered out, and reports nothing.
+ *
+ * Use `toPredicate` when something authoritative re-checks the result, and this when nothing does.
+ */ const toStrictPredicate = (expression)=>(row)=>{
+        const result = evaluate(expression, row);
+        if (result === undefined) {
+            throw new Error("Cannot apply this filter: its expression cannot be evaluated in memory, and applying it partially would " + "return rows the filter excludes.  This happens when a filter arrives without a runnable predicate — over a " + "wire, or rebuilt from a serialized query — and names something the evaluator does not understand.");
+        }
+        return result;
+    };
+
+
+},
+91(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  MY: () => (toExpression),
+  oH: () => (parseFragment),
+  pg: () => (combineExpressions)
+});
+/* import */ var _utilities__rspack_import_3 = __webpack_require__(581);
+/* import */ var _assertions__rspack_import_0 = __webpack_require__(126);
+/* import */ var _schema__rspack_import_2 = __webpack_require__(537);
+/* import */ var _types__rspack_import_1 = __webpack_require__(27);
+
+
+
+
+// Error message constants
+const ERROR_MESSAGES = {
+    PROPERTY_NOT_FOUND: (path)=>`Error parsing query, could not find PropertyInfo for path: ${path}`,
+    PARAM_PATH_NOT_FOUND: (value, params)=>`Cannot find path in params for .where(). Make sure parameters are not used inline.\r\nPath: ${value}, Params: ${JSON.stringify(params)}`,
+    VARIABLE_VALUE: (value)=>`Cannot derive value from variable, please pass parameters into the expression.
+
+Example: .where(([x, params]) => x.id === params.id, { id: someVar.id })
+Issue At: ${value}`,
+    UNSUPPORTED: (value)=>`Unsupported expression format: ${value}`
+};
+const parseUnknown = (value)=>{
+    (0,_assertions__rspack_import_0.assertString)(value);
+    return JSON.parse(value);
+};
+/**
+ * A parse failure caused by the params VALUES rather than the filter source.
+ * These must never poison the template cache — the same source can succeed
+ * with different params.
+ */ class ParamDependentParseError extends Error {
+}
+const converters = {
+    Array: (v)=>v,
+    Boolean: (v)=>v == null ? v : Boolean(v),
+    // Stryker disable next-line ArrowFunction: filters on computed properties route to
+    // in-memory execution, so this entry cannot be reached through a parsable filter.
+    Computed: (v)=>v,
+    Date: (v)=>v,
+    // A file is a reference, and a filter can legitimately compare its fields — content type
+    // and size are ordinary columns. The value passes through unconverted like an object.
+    File: (v)=>v,
+    // Stryker disable next-line ArrowFunction: SchemaTypes.Definition is handled as a
+    // generic primitive everywhere (specs/known-defects.md) and never pairs in a filter.
+    Definition: (v)=>v,
+    // Stryker disable next-line ArrowFunction: filters on function properties route to
+    // in-memory execution, so this entry cannot be reached through a parsable filter.
+    Function: (v)=>v,
+    Number: (v)=>v == null ? v : Number(v),
+    Object: (v)=>v,
+    String: (v)=>v == null ? v : String(v),
+    // A vector is a list of numbers and passes through like any other array. Nothing
+    // converts it because nothing compares it: similarity is `.nearest()`, not a filter.
+    Vector: (v)=>v
+};
+// Longest first so multi-character punctuation wins over its prefixes
+const MULTI_CHARACTER_PUNCTUATION = [
+    "===",
+    "!==",
+    "?.",
+    "&&",
+    "||",
+    "==",
+    "!=",
+    ">=",
+    "<=",
+    "=>"
+];
+// Stryker disable next-line all: documented equivalent cluster (see
+// docs/mutation-backlog.md) — dropping an entry only affects source the parser rejects
+// either way, and the rejection message names the character from the source rather than
+// from this set, so no observable boundary distinguishes the mutant. Established
+// experimentally: 30 message-asserting tests killed 1 of 12.
+const SINGLE_CHARACTER_PUNCTUATION = new Set([
+    "(",
+    ")",
+    "[",
+    "]",
+    "{",
+    "}",
+    ".",
+    ",",
+    ";",
+    "!",
+    ">",
+    "<",
+    "-",
+    "+",
+    "*",
+    "/",
+    "%",
+    "=",
+    "?",
+    ":",
+    "&",
+    "|"
+]);
+const STRING_ESCAPES = {
+    "n": "\n",
+    "r": "\r",
+    "t": "\t",
+    "b": "\b",
+    "f": "\f",
+    "v": "\v",
+    "0": "\0"
+};
+const isIdentifierStart = (char)=>/[a-zA-Z_$]/.test(char);
+const isIdentifierPart = (char)=>/[a-zA-Z0-9_$]/.test(char);
+const isDigit = (char)=>char >= "0" && char <= "9";
+const isHexDigit = (char)=>isDigit(char) || char >= "a" && char <= "f" || char >= "A" && char <= "F";
+/**
+ * Decodes a `\uXXXX`, `\u{...}` or `\xXX` escape starting at the backslash.
+ * Returns the decoded character and the index just past the escape.  These
+ * escapes carry a computed character, so mapping them through STRING_ESCAPES
+ * (which would yield the literal "u"/"x") silently corrupts the value.
+ */ const decodeCodeEscape = (source, backslashIndex)=>{
+    const kind = source[backslashIndex + 1];
+    let start = backslashIndex + 2;
+    if (kind === "u" && source[start] === "{") {
+        const end = source.indexOf("}", start + 1);
+        if (end === -1) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("unterminated unicode escape"));
+        }
+        return {
+            value: String.fromCodePoint(parseInt(source.slice(start + 1, end), 16)),
+            nextIndex: end + 1
+        };
+    }
+    const length = kind === "u" ? 4 : 2;
+    const digits = source.slice(start, start + length);
+    if (digits.length < length || [
+        ...digits
+    ].some((d)=>!isHexDigit(d))) {
+        throw new Error(ERROR_MESSAGES.UNSUPPORTED(`'\\${kind}' escape`));
+    }
+    return {
+        value: String.fromCharCode(parseInt(digits, 16)),
+        nextIndex: start + length
+    };
+};
+/**
+ * Converts filter source text into a flat token stream.  Strings and comments are
+ * consumed here so operator characters inside literals can never be mistaken for
+ * real operators.
+ */ const tokenize = (source)=>{
+    const tokens = [];
+    let i = 0;
+    while(i < source.length){
+        const char = source[i];
+        // Whitespace
+        if (char === " " || char === "\t" || char === "\r" || char === "\n") {
+            i++;
+            continue;
+        }
+        // Comments
+        if (char === "/" && source[i + 1] === "/") {
+            while(i < source.length && source[i] !== "\n"){
+                i++;
+            }
+            continue;
+        }
+        if (char === "/" && source[i + 1] === "*") {
+            i += 2;
+            while(i < source.length && !(source[i] === "*" && source[i + 1] === "/")){
+                i++;
+            }
+            i += 2;
+            continue;
+        }
+        // String literals
+        if (char === "'" || char === "\"" || char === "`") {
+            const quote = char;
+            let value = "";
+            i++;
+            while(i < source.length && source[i] !== quote){
+                if (source[i] === "\\") {
+                    const escaped = source[i + 1];
+                    if (escaped === "u" || escaped === "x") {
+                        const decoded = decodeCodeEscape(source, i);
+                        value += decoded.value;
+                        i = decoded.nextIndex;
+                        continue;
+                    }
+                    value += STRING_ESCAPES[escaped] ?? escaped;
+                    i += 2;
+                    continue;
+                }
+                if (quote === "`" && source[i] === "$" && source[i + 1] === "{") {
+                    throw new Error(ERROR_MESSAGES.UNSUPPORTED("template literal interpolation"));
+                }
+                value += source[i];
+                i++;
+            }
+            if (i >= source.length) {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("unterminated string literal"));
+            }
+            i++; // consume closing quote
+            tokens.push({
+                kind: "string",
+                value
+            });
+            continue;
+        }
+        // Numbers — covers decimals, exponents (1e6), hex/octal/binary (0xFF),
+        // and numeric separators (1_000_000).  Values are normalized here (the
+        // separator stripped) so the parser can hand them straight to Number()
+        if (isDigit(char)) {
+            let value = "";
+            const nextChar = source[i + 1];
+            const radixPrefix = char === "0" && nextChar != null && "xXoObB".includes(nextChar);
+            if (radixPrefix) {
+                value = source[i] + source[i + 1];
+                i += 2;
+                while(i < source.length && (isHexDigit(source[i]) || source[i] === "_")){
+                    value += source[i];
+                    i++;
+                }
+            } else {
+                while(i < source.length && (isDigit(source[i]) || source[i] === "." || source[i] === "_")){
+                    value += source[i];
+                    i++;
+                }
+                // Exponent part: e/E, optional sign, then digits.  Only consumed when
+                // digits follow, so a stray identifier after a number still errors
+                if (source[i] === "e" || source[i] === "E") {
+                    const signLength = source[i + 1] === "+" || source[i + 1] === "-" ? 1 : 0;
+                    if (isDigit(source[i + 1 + signLength])) {
+                        value += source[i];
+                        i++;
+                        if (signLength === 1) {
+                            value += source[i];
+                            i++;
+                        }
+                        while(i < source.length && isDigit(source[i])){
+                            value += source[i];
+                            i++;
+                        }
+                    }
+                }
+            }
+            tokens.push({
+                kind: "number",
+                value: value.replace(/_/g, "")
+            });
+            continue;
+        }
+        // Identifiers / keywords
+        if (isIdentifierStart(char)) {
+            let value = "";
+            while(i < source.length && isIdentifierPart(source[i])){
+                value += source[i];
+                i++;
+            }
+            tokens.push({
+                kind: "identifier",
+                value
+            });
+            continue;
+        }
+        // Multi-character punctuation (longest match first)
+        const multi = MULTI_CHARACTER_PUNCTUATION.find((w)=>source.startsWith(w, i));
+        if (multi != null) {
+            tokens.push({
+                kind: "punctuation",
+                value: multi
+            });
+            i += multi.length;
+            continue;
+        }
+        if (SINGLE_CHARACTER_PUNCTUATION.has(char)) {
+            tokens.push({
+                kind: "punctuation",
+                value: char
+            });
+            i++;
+            continue;
+        }
+        throw new Error(ERROR_MESSAGES.UNSUPPORTED(`unexpected character '${char}'`));
+    }
+    return tokens;
+};
+/**
+ * Cursor over the token stream with the small set of lookahead operations the
+ * parser needs.
+ */ class TokenStream {
+    tokens;
+    index = 0;
+    constructor(tokens){
+        this.tokens = tokens;
+    }
+    get isAtEnd() {
+        return this.index >= this.tokens.length;
+    }
+    peek(offset = 0) {
+        return this.tokens[this.index + offset] ?? null;
+    }
+    next() {
+        const token = this.tokens[this.index];
+        if (token == null) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("unexpected end of expression"));
+        }
+        this.index++;
+        return token;
+    }
+    isPunctuation(value, offset = 0) {
+        const token = this.peek(offset);
+        return token != null && token.kind === "punctuation" && token.value === value;
+    }
+    matchPunctuation(value) {
+        if (this.isPunctuation(value)) {
+            this.index++;
+            return true;
+        }
+        return false;
+    }
+    expectPunctuation(value) {
+        if (!this.matchPunctuation(value)) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`expected '${value}'`));
+        }
+    }
+}
+const COMPARATOR_METHODS = {
+    startsWith: "starts-with",
+    endsWith: "ends-with",
+    includes: "includes"
+};
+const TRANSFORM_METHODS = {
+    toLowerCase: {
+        transformer: "to-lower-case",
+        locale: null
+    },
+    toUpperCase: {
+        transformer: "to-upper-case",
+        locale: null
+    },
+    toLocaleLowerCase: {
+        transformer: "to-lower-case",
+        locale: "en-US"
+    },
+    toLocaleUpperCase: {
+        transformer: "to-upper-case",
+        locale: "en-US"
+    }
+};
+const COMPARISON_OPERATORS = {
+    "==": {
+        comparator: "equals",
+        negated: false,
+        strict: false
+    },
+    "===": {
+        comparator: "equals",
+        negated: false,
+        strict: true
+    },
+    "!=": {
+        comparator: "equals",
+        negated: true,
+        strict: false
+    },
+    "!==": {
+        comparator: "equals",
+        negated: true,
+        strict: true
+    },
+    ">": {
+        comparator: "greater-than",
+        negated: false,
+        strict: false
+    },
+    ">=": {
+        comparator: "greater-than-equals",
+        negated: false,
+        strict: false
+    },
+    "<": {
+        comparator: "less-than",
+        negated: false,
+        strict: false
+    },
+    "<=": {
+        comparator: "less-than-equals",
+        negated: false,
+        strict: false
+    }
+};
+const SWAPPED_COMPARATORS = {
+    "equals": "equals",
+    "greater-than": "less-than",
+    "greater-than-equals": "less-than-equals",
+    "less-than": "greater-than",
+    "less-than-equals": "greater-than-equals",
+    "starts-with": "starts-with",
+    "ends-with": "ends-with",
+    "includes": "includes"
+};
+// #endregion
+// #region Param references
+/**
+ * Placeholder for a parameter value inside a cached expression template.  Never
+ * escapes this module — binding replaces it with a plain ValueExpression that
+ * holds the resolved value.
+ */ class ParamReferenceExpression extends _types__rspack_import_1/* .ValueExpression */.Ko {
+    /** Path into the params object, excluding the params root name. */ paramPath;
+    /** The property this value is compared against; drives serialization/conversion at bind time. */ pairedProperty;
+    /** Whether the paired property's type converter applies (equality/relational comparisons only). */ applyConverter;
+    constructor(options){
+        super({
+            value: undefined
+        });
+        this.paramPath = options.paramPath;
+        this.pairedProperty = options.pairedProperty;
+        this.applyConverter = options.applyConverter;
+    }
+}
+const resolveParamPath = (paramsName, path, data)=>{
+    let result = data;
+    for(let i = 0; i < path.length; i++){
+        const name = path[i];
+        if (result != null && typeof result === "object" && name in result) {
+            result = result[name];
+            continue;
+        }
+        throw new ParamDependentParseError(ERROR_MESSAGES.PARAM_PATH_NOT_FOUND([
+            paramsName,
+            ...path
+        ].join("."), data));
+    }
+    return result;
+};
+/**
+ * Applies the paired property's value serializer and (optionally) its schema
+ * type converter, matching how literal values are treated at parse time.
+ */ const resolvePairedValue = (value, pairedProperty, applyConverter)=>{
+    if (pairedProperty == null) {
+        return value;
+    }
+    let result = value;
+    if (pairedProperty.valueSerializer != null) {
+        result = String(pairedProperty.valueSerializer(parseUnknown(result)));
+    }
+    if (applyConverter) {
+        result = converters[pairedProperty.type](result);
+    }
+    return result;
+};
+// #endregion
+// #region Parser
+/**
+ * Recursive descent parser over the token stream.  Produces an expression
+ * template: literal values are fully resolved, parameter values are represented
+ * as ParamReferenceExpression placeholders so the template can be cached and
+ * re-bound with different params.
+ */ class ExpressionParser {
+    schema;
+    stream;
+    entityName;
+    paramsName;
+    params;
+    /** Set when a param value shaped the tree itself (e.g. x[p.name]) — such templates cannot be cached. */ structurallyDependsOnParams = false;
+    constructor(schema, stream, entityName, paramsName, params){
+        this.schema = schema;
+        this.stream = stream;
+        this.entityName = entityName;
+        this.paramsName = paramsName;
+        this.params = params;
+    }
+    parse() {
+        const expression = this.parseOr();
+        if (!this.stream.isAtEnd) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`unexpected token '${this.stream.peek()?.value}'`));
+        }
+        return expression;
+    }
+    // || binds loosest, so it sits at the root of the parse
+    parseOr() {
+        let left = this.parseAnd();
+        while(this.stream.matchPunctuation("||")){
+            const right = this.parseAnd();
+            // A tautology (`true`) absorbs the whole disjunction
+            if (_types__rspack_import_1/* .Expression.isEmpty */.r4.isEmpty(left) || _types__rspack_import_1/* .Expression.isEmpty */.r4.isEmpty(right)) {
+                left = _types__rspack_import_1/* .Expression.EMPTY */.r4.EMPTY;
+                continue;
+            }
+            left = new _types__rspack_import_1/* .OperatorExpression */.fw({
+                operator: "||",
+                left,
+                right
+            });
+        }
+        return left;
+    }
+    parseAnd() {
+        let left = this.parseUnary();
+        while(this.stream.matchPunctuation("&&")){
+            const right = this.parseUnary();
+            // A tautology (`true`) is the identity of a conjunction
+            if (_types__rspack_import_1/* .Expression.isEmpty */.r4.isEmpty(left)) {
+                left = right;
+                continue;
+            }
+            if (_types__rspack_import_1/* .Expression.isEmpty */.r4.isEmpty(right)) {
+                continue;
+            }
+            left = new _types__rspack_import_1/* .OperatorExpression */.fw({
+                operator: "&&",
+                left,
+                right
+            });
+        }
+        return left;
+    }
+    parseUnary() {
+        if (this.stream.matchPunctuation("!")) {
+            return this.negateExpression(this.parseUnary());
+        }
+        return this.parseComparison();
+    }
+    /**
+     * Applies `!` to an already-parsed expression: comparators flip their
+     * negated flag, compound expressions distribute via De Morgan's laws.
+     */ negateExpression(expression) {
+        if (expression instanceof _types__rspack_import_1/* .ComparatorExpression */.bQ) {
+            expression.negated = !expression.negated;
+            return expression;
+        }
+        if (expression instanceof _types__rspack_import_1/* .OperatorExpression */.fw && expression.left != null && expression.right != null) {
+            return new _types__rspack_import_1/* .OperatorExpression */.fw({
+                operator: expression.operator === "&&" ? "||" : "&&",
+                left: this.negateExpression(expression.left),
+                right: this.negateExpression(expression.right)
+            });
+        }
+        throw new Error(ERROR_MESSAGES.UNSUPPORTED("'!' on this expression"));
+    }
+    parseComparison() {
+        // Parenthesized group
+        if (this.stream.matchPunctuation("(")) {
+            const expression = this.parseOr();
+            this.stream.expectPunctuation(")");
+            const trailing = this.stream.peek();
+            if (trailing != null && trailing.kind === "punctuation" && COMPARISON_OPERATORS[trailing.value] != null) {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("comparison against a parenthesized expression"));
+            }
+            return expression;
+        }
+        const left = this.parseOperand();
+        const operatorToken = this.stream.peek();
+        if (operatorToken != null && operatorToken.kind === "punctuation" && COMPARISON_OPERATORS[operatorToken.value] != null) {
+            this.stream.next();
+            const right = this.parseOperand();
+            return this.buildComparison(left, COMPARISON_OPERATORS[operatorToken.value], right);
+        }
+        return this.buildStandalone(left);
+    }
+    parseOperand() {
+        const token = this.stream.peek();
+        if (token == null) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("unexpected end of expression"));
+        }
+        if (token.kind === "string") {
+            this.stream.next();
+            return this.withValueTransformer({
+                kind: "value",
+                value: token.value,
+                transformer: null,
+                locale: null
+            });
+        }
+        if (token.kind === "number") {
+            this.stream.next();
+            return {
+                kind: "value",
+                value: Number(token.value),
+                transformer: null,
+                locale: null
+            };
+        }
+        if (token.kind === "punctuation" && token.value === "-") {
+            this.stream.next();
+            const numberToken = this.stream.next();
+            if (numberToken.kind !== "number") {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("unary '-' on a non-number"));
+            }
+            return {
+                kind: "value",
+                value: -Number(numberToken.value),
+                transformer: null,
+                locale: null
+            };
+        }
+        if (token.kind === "punctuation" && token.value === "[") {
+            return this.parseArrayLiteralOperand();
+        }
+        if (token.kind === "identifier") {
+            return this.parseIdentifierOperand();
+        }
+        throw new Error(ERROR_MESSAGES.UNSUPPORTED(String(token.value)));
+    }
+    /**
+     * Parses an inline array of literals, e.g. `["active", "pending"]`, and the
+     * membership test that follows it: `[...].includes(entity.property)`.
+     */ parseArrayLiteralOperand() {
+        this.stream.expectPunctuation("[");
+        const elements = [];
+        while(!this.stream.isPunctuation("]")){
+            const element = this.parseOperand();
+            if (element.kind !== "value" || element.transformer != null) {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("a non-literal element in an array literal"));
+            }
+            elements.push(element.value);
+            if (!this.stream.matchPunctuation(",")) {
+                break;
+            }
+        }
+        this.stream.expectPunctuation("]");
+        const array = {
+            kind: "value",
+            value: elements,
+            transformer: null,
+            locale: null
+        };
+        // The only supported use is a membership test on a schema property
+        if (this.stream.isPunctuation(".") || this.stream.isPunctuation("?.")) {
+            this.stream.next();
+            const method = this.stream.next();
+            if (method.kind !== "identifier" || method.value !== "includes") {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED(`'.${method.value}' on an array literal`));
+            }
+            this.stream.expectPunctuation("(");
+            const argument = this.parseOperand();
+            this.stream.expectPunctuation(")");
+            if (argument.kind === "method-call") {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("nested method call inside .includes()"));
+            }
+            return {
+                kind: "method-call",
+                target: array,
+                method: "includes",
+                argument
+            };
+        }
+        return array;
+    }
+    parseIdentifierOperand() {
+        const root = this.stream.next().value;
+        // Keyword literals
+        if (root === "true" || root === "false") {
+            return {
+                kind: "value",
+                value: root === "true",
+                transformer: null,
+                locale: null
+            };
+        }
+        if (root === "null") {
+            return {
+                kind: "value",
+                value: null,
+                transformer: null,
+                locale: null
+            };
+        }
+        if (root === "undefined") {
+            return {
+                kind: "value",
+                value: undefined,
+                transformer: null,
+                locale: null
+            };
+        }
+        if (root === "void") {
+            this.stream.next(); // the '0'
+            return {
+                kind: "value",
+                value: undefined,
+                transformer: null,
+                locale: null
+            };
+        }
+        if (root === this.entityName) {
+            return this.parseChain({
+                kind: "property",
+                root
+            });
+        }
+        if (this.paramsName != null && root === this.paramsName) {
+            return this.parseChain({
+                kind: "param",
+                root
+            });
+        }
+        // A bare variable from the outer scope — its value cannot be derived from source text
+        throw new Error(ERROR_MESSAGES.VARIABLE_VALUE(root));
+    }
+    /**
+     * Parses the segments after an entity/params root: dot access, bracket
+     * access, transform methods and comparator methods.
+     */ parseChain(options) {
+        const path = [];
+        let transformer = null;
+        let locale = null;
+        while(true){
+            if (this.stream.matchPunctuation(".") || this.stream.matchPunctuation("?.")) {
+                const segment = this.stream.next();
+                if (segment.kind !== "identifier") {
+                    throw new Error(ERROR_MESSAGES.UNSUPPORTED(`'.${segment.value}'`));
+                }
+                // Method call
+                if (this.stream.isPunctuation("(")) {
+                    const method = segment.value;
+                    if (TRANSFORM_METHODS[method] != null) {
+                        this.stream.expectPunctuation("(");
+                        this.stream.expectPunctuation(")");
+                        transformer = TRANSFORM_METHODS[method].transformer;
+                        locale = TRANSFORM_METHODS[method].locale;
+                        continue;
+                    }
+                    if (COMPARATOR_METHODS[method] != null) {
+                        this.stream.expectPunctuation("(");
+                        const argument = this.parseOperand();
+                        this.stream.expectPunctuation(")");
+                        if (argument.kind === "method-call") {
+                            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`nested method call inside .${method}()`));
+                        }
+                        return {
+                            kind: "method-call",
+                            target: this.resolveChain(options.kind, path, transformer, locale),
+                            method: method,
+                            argument
+                        };
+                    }
+                    throw new Error(ERROR_MESSAGES.UNSUPPORTED(`method '.${method}()'`));
+                }
+                if (transformer != null) {
+                    throw new Error(ERROR_MESSAGES.UNSUPPORTED("property access after a transform method"));
+                }
+                path.push(segment.value);
+                continue;
+            }
+            if (this.stream.matchPunctuation("[")) {
+                path.push(this.parseBracketSegment(options.kind));
+                this.stream.expectPunctuation("]");
+                continue;
+            }
+            break;
+        }
+        return this.resolveChain(options.kind, path, transformer, locale);
+    }
+    parseBracketSegment(kind) {
+        const token = this.stream.next();
+        // Literal segment: entity["name"]
+        if (token.kind === "string") {
+            return token.value;
+        }
+        // Param-driven segment: entity[p.name] — the property depends on the
+        // param VALUE, so the resulting template is tied to these params.
+        // Stryker disable next-line all: documented equivalent cluster (see
+        // docs/mutation-backlog.md) — every mutation of this four-conjunct guard reroutes
+        // bracket access between two paths that both collapse to NOT_PARSABLE; the
+        // experiment recorded there aimed 30 tests at this line and killed none.
+        if (kind === "property" && token.kind === "identifier" && this.paramsName != null && token.value === this.paramsName) {
+            const paramPath = [];
+            while(this.stream.matchPunctuation(".") || this.stream.matchPunctuation("?.")){
+                paramPath.push(this.stream.next().value);
+            }
+            const resolved = resolveParamPath(this.paramsName, paramPath, this.params);
+            if (typeof resolved !== "string") {
+                throw new ParamDependentParseError(ERROR_MESSAGES.PROPERTY_NOT_FOUND(paramPath.join(".")));
+            }
+            this.structurallyDependsOnParams = true;
+            return resolved;
+        }
+        throw new Error(ERROR_MESSAGES.UNSUPPORTED(`bracket access '[${token.value}]'`));
+    }
+    resolveChain(kind, path, transformer, locale) {
+        if (kind === "param") {
+            if (path.length === 0) {
+                // `params` alone is a variable, not a value we can resolve
+                throw new Error(ERROR_MESSAGES.PARAM_PATH_NOT_FOUND(this.paramsName ?? "params", this.params));
+            }
+            return {
+                kind: "param",
+                path,
+                transformer,
+                locale
+            };
+        }
+        const pathString = path.join(".");
+        const property = this.schema.properties.find((w)=>w.getAssignmentPath() == pathString);
+        if (property == null) {
+            // `.length` on a string/array property — a real schema property named
+            // `length` wins (checked above); otherwise treat it as a transformer
+            if (path.length > 1 && path[path.length - 1] === "length" && transformer == null) {
+                const parentPath = path.slice(0, -1).join(".");
+                const parent = this.schema.properties.find((w)=>w.getAssignmentPath() == parentPath);
+                // Vector is deliberately absent. Its length is the dimension count declared
+                // in the schema — a constant, not data — so a filter on it answers a question
+                // nobody asks, and pushing it down would need `json_array_length` on a
+                // backend storing JSON and something else entirely on one with a native
+                // vector column. Not parsing it leaves a clear error instead of a dialect gap.
+                if (parent != null && (parent.type === _schema__rspack_import_2/* .SchemaTypes.String */.L.String || parent.type === _schema__rspack_import_2/* .SchemaTypes.Array */.L.Array)) {
+                    return {
+                        kind: "property",
+                        property: parent,
+                        transformer: "length",
+                        locale: null
+                    };
+                }
+            }
+            throw new Error(ERROR_MESSAGES.PROPERTY_NOT_FOUND(pathString));
+        }
+        return {
+            kind: "property",
+            property,
+            transformer,
+            locale
+        };
+    }
+    withValueTransformer(operand) {
+        if (this.stream.isPunctuation(".")) {
+            const method = this.stream.peek(1);
+            // Stryker disable next-line all: documented equivalent cluster (see
+            // docs/mutation-backlog.md) — the guard's conjuncts each route to a rejection that
+            // collapses to NOT_PARSABLE with an indistinguishable message; 18 targeted tests
+            // killed none of these.
+            if (method != null && method.kind === "identifier" && TRANSFORM_METHODS[method.value] != null) {
+                this.stream.next(); // .
+                this.stream.next(); // method name
+                this.stream.expectPunctuation("(");
+                this.stream.expectPunctuation(")");
+                operand.transformer = TRANSFORM_METHODS[method.value].transformer;
+                operand.locale = TRANSFORM_METHODS[method.value].locale;
+            }
+        }
+        return operand;
+    }
+    // #region Condition building
+    buildComparison(left, operator, right) {
+        // methodCall == true/false — fold the boolean into negation
+        if (left.kind === "method-call") {
+            if (operator.comparator === "equals" && right.kind === "value" && typeof right.value === "boolean") {
+                const comparator = this.buildMethodComparator(left);
+                const comparedToFalse = right.value === false;
+                comparator.negated = comparator.negated !== (operator.negated !== comparedToFalse);
+                return comparator;
+            }
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("comparing a method call to a non-boolean"));
+        }
+        if (right.kind === "method-call") {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("method call on the right side of a comparison"));
+        }
+        if (left.kind === "property" && right.kind === "property") {
+            // Casing transformers are only valid with string-matching comparators,
+            // which cannot produce a property-to-property comparison
+            if (left.transformer === "to-lower-case" || left.transformer === "to-upper-case" || right.transformer === "to-lower-case" || right.transformer === "to-upper-case") {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("transform method outside of startsWith/endsWith/includes"));
+            }
+            return new _types__rspack_import_1/* .ComparatorExpression */.bQ({
+                comparator: operator.comparator,
+                negated: operator.negated,
+                strict: operator.strict,
+                left: this.createPropertyExpression(left),
+                right: this.createPropertyExpression(right)
+            });
+        }
+        if (left.kind === "property" && right.kind !== "property") {
+            return this.buildPropertyComparator(left, operator, right, /* applyConverter */ true);
+        }
+        if (right.kind === "property" && left.kind !== "property") {
+            const swapped = {
+                ...operator,
+                comparator: SWAPPED_COMPARATORS[operator.comparator]
+            };
+            return this.buildPropertyComparator(right, swapped, left, /* applyConverter */ true);
+        }
+        throw new Error(ERROR_MESSAGES.UNSUPPORTED("comparison requires a schema property on at least one side"));
+    }
+    buildStandalone(operand) {
+        if (operand.kind === "method-call") {
+            return this.buildMethodComparator(operand);
+        }
+        if (operand.kind === "property") {
+            // Truthy shorthand on `.length`: a length is truthy exactly when > 0
+            if (operand.transformer === "length") {
+                return this.buildPropertyComparator(operand, COMPARISON_OPERATORS[">"], {
+                    kind: "value",
+                    value: 0,
+                    transformer: null,
+                    locale: null
+                }, /* applyConverter */ true);
+            }
+            // Truthy shorthand: `w.isActive` → isActive === true
+            return this.buildPropertyComparator(operand, COMPARISON_OPERATORS["==="], {
+                kind: "value",
+                value: true,
+                transformer: null,
+                locale: null
+            }, /* applyConverter */ true);
+        }
+        // Constant `true` — a tautology, which parseAnd/parseOr simplify away
+        if (operand.kind === "value" && operand.value === true && operand.transformer == null) {
+            return _types__rspack_import_1/* .Expression.EMPTY */.r4.EMPTY;
+        }
+        throw new Error(ERROR_MESSAGES.UNSUPPORTED("a filter condition must reference a schema property"));
+    }
+    buildMethodComparator(operand) {
+        const { target, method, argument } = operand;
+        if (target.kind === "property") {
+            if (argument.kind === "property") {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED(`.${method}() comparing two schema properties`));
+            }
+            // Method arguments skip type conversion — only the value serializer applies
+            return this.buildPropertyComparator(target, {
+                comparator: COMPARATOR_METHODS[method],
+                negated: false,
+                strict: false
+            }, argument, /* applyConverter */ false);
+        }
+        // ["a", "b"].includes(x.prop) / params.list.includes(x.prop) —
+        // membership test with the collection on the left
+        if (method === "includes" && argument.kind === "property") {
+            if (target.transformer != null) {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("transform method on a collection used with .includes()"));
+            }
+            return new _types__rspack_import_1/* .ComparatorExpression */.bQ({
+                comparator: "includes",
+                negated: false,
+                strict: false,
+                left: this.createValueExpression(target, argument.property, /* applyConverter */ false),
+                right: this.createPropertyExpression(argument)
+            });
+        }
+        throw new Error(ERROR_MESSAGES.UNSUPPORTED(`.${method}() on a non-property target`));
+    }
+    buildPropertyComparator(property, operator, value, applyConverter) {
+        const isStringMatch = operator.comparator === "starts-with" || operator.comparator === "ends-with" || operator.comparator === "includes";
+        // `.length` compares a NUMBER, so the paired property's serializer and
+        // type converter must not touch the value; and a length has no meaning
+        // inside a string-matching comparator
+        if (property.transformer === "length") {
+            if (isStringMatch) {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("'.length' with startsWith/endsWith/includes"));
+            }
+            return new _types__rspack_import_1/* .ComparatorExpression */.bQ({
+                comparator: operator.comparator,
+                negated: operator.negated,
+                strict: operator.strict,
+                left: this.createPropertyExpression(property),
+                right: this.createValueExpression(value, null, /* applyConverter */ false)
+            });
+        }
+        // Casing transformers on a property are only meaningful with string-matching
+        // comparators; on relational comparators the plugins would silently
+        // ignore them and return wrong data
+        if (property.transformer != null && !isStringMatch) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("transform method outside of startsWith/endsWith/includes"));
+        }
+        return new _types__rspack_import_1/* .ComparatorExpression */.bQ({
+            comparator: operator.comparator,
+            negated: operator.negated,
+            strict: operator.strict,
+            left: this.createPropertyExpression(property),
+            right: this.createValueExpression(value, property.property, applyConverter)
+        });
+    }
+    createPropertyExpression(operand) {
+        const expression = new _types__rspack_import_1/* .PropertyExpression */.ep({
+            property: operand.property
+        });
+        expression.transformer = operand.transformer;
+        expression.locale = operand.locale;
+        return expression;
+    }
+    createValueExpression(operand, pairedProperty, applyConverter) {
+        if (operand.kind === "param") {
+            const expression = new ParamReferenceExpression({
+                paramPath: operand.path,
+                pairedProperty,
+                applyConverter
+            });
+            expression.transformer = operand.transformer;
+            expression.locale = operand.locale;
+            return expression;
+        }
+        const expression = new _types__rspack_import_1/* .ValueExpression */.Ko({
+            value: resolvePairedValue(operand.value, pairedProperty, applyConverter)
+        });
+        expression.transformer = operand.transformer;
+        expression.locale = operand.locale;
+        return expression;
+    }
+}
+// #endregion
+// #region Template binding
+/**
+ * Deep-clones a template into a consumer-facing tree, resolving parameter
+ * placeholders against the supplied params.  Always clones so cached templates
+ * can never be mutated by consumers.
+ */ const bindExpression = (expression, paramsName, params)=>{
+    if (expression instanceof ParamReferenceExpression) {
+        const raw = resolveParamPath(paramsName ?? "params", expression.paramPath, params);
+        const bound = new _types__rspack_import_1/* .ValueExpression */.Ko({
+            value: resolvePairedValue(raw, expression.pairedProperty, expression.applyConverter)
+        });
+        bound.transformer = expression.transformer;
+        bound.locale = expression.locale;
+        return bound;
+    }
+    if (expression instanceof _types__rspack_import_1/* .ValueExpression */.Ko) {
+        const clone = new _types__rspack_import_1/* .ValueExpression */.Ko({
+            value: expression.value
+        });
+        clone.transformer = expression.transformer;
+        clone.locale = expression.locale;
+        return clone;
+    }
+    if (expression instanceof _types__rspack_import_1/* .PropertyExpression */.ep) {
+        const clone = new _types__rspack_import_1/* .PropertyExpression */.ep({
+            property: expression.property
+        });
+        clone.transformer = expression.transformer;
+        clone.locale = expression.locale;
+        return clone;
+    }
+    if (expression instanceof _types__rspack_import_1/* .ComparatorExpression */.bQ) {
+        return new _types__rspack_import_1/* .ComparatorExpression */.bQ({
+            comparator: expression.comparator,
+            negated: expression.negated,
+            strict: expression.strict,
+            left: expression.left ? bindExpression(expression.left, paramsName, params) : undefined,
+            right: expression.right ? bindExpression(expression.right, paramsName, params) : undefined
+        });
+    }
+    if (expression instanceof _types__rspack_import_1/* .OperatorExpression */.fw) {
+        return new _types__rspack_import_1/* .OperatorExpression */.fw({
+            operator: expression.operator,
+            left: expression.left ? bindExpression(expression.left, paramsName, params) : undefined,
+            right: expression.right ? bindExpression(expression.right, paramsName, params) : undefined
+        });
+    }
+    return expression;
+};
+/**
+ * Splits stringified filter source into parameter names and the expression
+ * body, unwrapping single-return block bodies.
+ */ const resolveFunctionShape = (stringifiedFunction, hasParams)=>{
+    const source = stringifiedFunction.trim();
+    let parameterNames;
+    let body;
+    // `function (x) { ... }` / `function name(x) { ... }` — what ES5-targeting
+    // transpilers rewrite every arrow filter into
+    const functionHead = /^function\b[^(]*\(/.exec(source);
+    if (functionHead != null) {
+        const parametersEnd = source.indexOf(")", functionHead[0].length);
+        if (parametersEnd === -1) {
+            throw new Error("Invalid Function");
+        }
+        parameterNames = source.slice(functionHead[0].length, parametersEnd).trim();
+        body = source.slice(parametersEnd + 1).trim();
+    } else {
+        const arrowIndex = source.indexOf("=>");
+        if (arrowIndex === -1) {
+            throw new Error("Invalid Function");
+        }
+        parameterNames = source.substring(0, arrowIndex).trim();
+        body = source.substring(arrowIndex + 2).trim();
+        // Strip wrapping parens: (entity) or ([x, p])
+        if (parameterNames.startsWith("(") && parameterNames.endsWith(")")) {
+            parameterNames = parameterNames.slice(1, -1).trim();
+        }
+    }
+    let entityName;
+    let paramsName = null;
+    if (parameterNames.startsWith("[") && parameterNames.endsWith("]")) {
+        const destructured = parameterNames.slice(1, -1).split(",").map((w)=>w.trim());
+        entityName = destructured[0];
+        if (hasParams) {
+            paramsName = destructured[1] ?? null;
+        }
+    } else {
+        entityName = parameterNames;
+    }
+    if (entityName == null || entityName.length === 0) {
+        throw new Error("Invalid Function");
+    }
+    // Unwrap a single-return block body: { return <expression>; }
+    if (body.startsWith("{")) {
+        const inner = body.slice(1, body.lastIndexOf("}")).trim();
+        if (!inner.startsWith("return")) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("block body without a single return statement"));
+        }
+        body = inner.slice("return".length).trim();
+        if (body.endsWith(";")) {
+            body = body.slice(0, -1).trim();
+        }
+    }
+    return {
+        entityName,
+        paramsName,
+        body
+    };
+};
+// Keyed by schema instance so identical filter source on different schemas can
+// never collide; entries live only as long as the schema does
+const templateCache = new WeakMap();
+const MAX_CACHED_TEMPLATES_PER_SCHEMA = 1024;
+const getCachedTemplate = (schema, source)=>{
+    return templateCache.get(schema)?.get(source) ?? null;
+};
+const setCachedTemplate = (schema, source, entry)=>{
+    let bySource = templateCache.get(schema);
+    if (bySource == null) {
+        bySource = new Map();
+        templateCache.set(schema, bySource);
+    }
+    // Filter source strings come from static code, so this cap should never be
+    // hit in practice — it only guards against unbounded dynamic generation.
+    // Stryker disable next-line all: the cap is a pure resource bound — every mutation of
+    // it (never clear, always clear, off-by-one) parses identically and differs only in
+    // memory growth, which no observable boundary can assert.
+    if (bySource.size >= MAX_CACHED_TEMPLATES_PER_SCHEMA) {
+        bySource.clear();
+    }
+    bySource.set(source, entry);
+};
+// #endregion
+const combineExpressions = (...expressions)=>{
+    if (expressions.length === 0) {
+        throw new Error("combineExpressions requires at least 1 expression");
+    }
+    if (expressions.length === 1) {
+        return expressions[0];
+    }
+    // Start with the first expression
+    let result = expressions[0];
+    // Loop through remaining expressions and combine them
+    for(let i = 1; i < expressions.length; i++){
+        result = new _types__rspack_import_1/* .OperatorExpression */.fw({
+            operator: "&&",
+            left: result,
+            right: expressions[i]
+        });
+    }
+    return result;
+};
+/**
+ * Parses an expression SOURCE FRAGMENT against one schema and one root name.
+ *
+ * `toExpression` starts from a function and works out its own roots. This starts from text, which
+ * is what a caller has when it has split a larger predicate apart — `p.rank > 10` lifted out of
+ * `([p, m]) => p.rank > 10 && m.won === true`.
+ *
+ * **A fragment naming anything other than `rootName` returns `NOT_PARSABLE`, and that is the
+ * point.** It is how a caller discovers which side of a join a conjunct belongs to: parse it
+ * against each side in turn, and exactly one succeeds for a single-side condition. A condition
+ * spanning both fails against both, which is the correct answer — it cannot be pushed to either.
+ *
+ * No params: a fragment carrying a params reference has no bag to resolve it against here, so it
+ * fails rather than binding to nothing.
+ *
+ * Deliberately NOT cached. The cache is keyed by function source, and a fragment is not a function
+ * — two different lambdas can contain the same fragment text against different schemas.
+ */ const parseFragment = (schema, body, rootName)=>{
+    try {
+        const stream = new TokenStream(tokenize(body));
+        const parser = new ExpressionParser(schema, stream, rootName, null, undefined);
+        return parser.parse();
+    } catch  {
+        // The failure is expected and informative — see above — so it is not logged. A caller that
+        // parses one conjunct against two schemas would otherwise warn on every successful split.
+        return _types__rspack_import_1/* .Expression.NOT_PARSABLE */.r4.NOT_PARSABLE;
+    }
+};
+const toExpression = (schema, fn, params)=>{
+    const stringifiedFunction = fn.toString();
+    const warn = (error)=>_utilities__rspack_import_3/* .logger.warn */.vF.warn("Error parsing expression", {
+            error,
+            collectionName: schema.collectionName,
+            params,
+            selector: stringifiedFunction
+        });
+    const cached = getCachedTemplate(schema, stringifiedFunction);
+    if (cached != null) {
+        // A cached failure — the warning was already logged when it was discovered
+        if (_types__rspack_import_1/* .Expression.isNotParsable */.r4.isNotParsable(cached.template)) {
+            return _types__rspack_import_1/* .Expression.NOT_PARSABLE */.r4.NOT_PARSABLE;
+        }
+        try {
+            return bindExpression(cached.template, cached.paramsName, params);
+        } catch (error) {
+            // Binding failures are param-dependent by nature — never cached
+            warn(error);
+            return _types__rspack_import_1/* .Expression.NOT_PARSABLE */.r4.NOT_PARSABLE;
+        }
+    }
+    let paramsName = null;
+    let template;
+    let structurallyDependsOnParams;
+    try {
+        const shape = resolveFunctionShape(stringifiedFunction, params != null);
+        const stream = new TokenStream(tokenize(shape.body));
+        const parser = new ExpressionParser(schema, stream, shape.entityName, shape.paramsName, params);
+        paramsName = shape.paramsName;
+        template = parser.parse();
+        structurallyDependsOnParams = parser.structurallyDependsOnParams;
+    } catch (error) {
+        // Cache the failure so a hot query on an unsupported filter doesn't
+        // re-parse and re-warn on every execution.  Param-dependent failures are
+        // exempt: the same source can succeed with different params.
+        if (!(error instanceof ParamDependentParseError)) {
+            setCachedTemplate(schema, stringifiedFunction, {
+                template: _types__rspack_import_1/* .Expression.NOT_PARSABLE */.r4.NOT_PARSABLE,
+                paramsName: null
+            });
+        }
+        warn(error);
+        return _types__rspack_import_1/* .Expression.NOT_PARSABLE */.r4.NOT_PARSABLE;
+    }
+    // Templates whose structure was resolved from param values are only
+    // valid for this exact params object — parse those fresh every time
+    if (!structurallyDependsOnParams) {
+        setCachedTemplate(schema, stringifiedFunction, {
+            template,
+            paramsName
+        });
+    }
+    try {
+        return bindExpression(template, paramsName, params);
+    } catch (error) {
+        warn(error);
+        return _types__rspack_import_1/* .Expression.NOT_PARSABLE */.r4.NOT_PARSABLE;
+    }
+};
+
+
+},
+27(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  Ko: () => (ValueExpression),
+  SC: () => (NotParsableExpression),
+  Sm: () => (EmptyExpression),
+  bQ: () => (ComparatorExpression),
+  ep: () => (PropertyExpression),
+  fw: () => (OperatorExpression),
+  r4: () => (Expression)
+});
+const valueToJson = (value)=>{
+    if (value === undefined) {
+        return {
+            k: "undefined"
+        };
+    }
+    if (value === null) {
+        return {
+            k: "raw",
+            v: null
+        };
+    }
+    if (value instanceof Date) {
+        // ISO rather than epoch millis: it survives a human reading the payload, and an invalid
+        // Date has no ISO form — so it is caught here rather than becoming a silent `null`.
+        return {
+            k: "date",
+            v: value.toISOString()
+        };
+    }
+    if (Array.isArray(value)) {
+        return {
+            k: "array",
+            v: value.map(valueToJson)
+        };
+    }
+    if (typeof value === "number" && Number.isFinite(value) === false) {
+        // `JSON.stringify` turns all three of these into `null`, which would compare as a different
+        // value entirely rather than failing.
+        return {
+            k: "number",
+            v: Number.isNaN(value) ? "NaN" : value > 0 ? "Infinity" : "-Infinity"
+        };
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return {
+            k: "raw",
+            v: value
+        };
+    }
+    throw new Error(`Cannot serialize this filter value: only strings, numbers, booleans, null, undefined, Dates and arrays of those can cross a wire.  ` + `Received: ${Object.prototype.toString.call(value)}`);
+};
+const valueFromJson = (value)=>{
+    if (value.k === "undefined") {
+        return undefined;
+    }
+    if (value.k === "date") {
+        return new Date(value.v);
+    }
+    if (value.k === "array") {
+        return value.v.map(valueFromJson);
+    }
+    if (value.k === "number") {
+        return value.v === "NaN" ? Number.NaN : value.v === "Infinity" ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+    }
+    return value.v;
+};
+/**
+ * The base class for all expression types.
+ */ class Expression {
+    /** The left-hand side of the expression (if applicable). */ left;
+    /** The right-hand side of the expression (if applicable). */ right;
+    constructor(left, right){
+        this.left = left;
+        this.right = right;
+    }
+    static get EMPTY() {
+        return new EmptyExpression();
+    }
+    static get NOT_PARSABLE() {
+        return new NotParsableExpression();
+    }
+    static isEmpty(expression) {
+        return expression.type === "empty" || expression instanceof EmptyExpression;
+    }
+    static isNotParsable(expression) {
+        return expression.type === "not-parsable" || expression instanceof NotParsableExpression;
+    }
+    /**
+     * Turns a tree into plain JSON, so a whole query can cross a wire.
+     *
+     * On the class rather than beside it, because this is the type's own REPRESENTATION — there is one
+     * right answer and it belongs with the thing being represented, next to `EMPTY` and `isEmpty`.
+     * Rendering a tree into some other language (`toSql`, `toMql`, `evaluate`) is a different kind of
+     * thing: there are many, each belongs to its consumer, and none of them is canonical.
+     *
+     * ## Why it is this small
+     *
+     * Of the six node types a bound tree can contain, exactly one holds anything JSON cannot carry:
+     * `PropertyExpression`, whose live `PropertyInfo` has functions, a parent chain and caches. It
+     * reduces to a property PATH — `PropertyInfo.id` IS the dotted path, and `getProperty` is keyed by
+     * exactly that — so rebinding is one lookup.
+     *
+     * `ParamReferenceExpression` never appears: it is a parse-time placeholder that binding replaces
+     * with a plain `ValueExpression` holding the resolved value. A serialized tree is always already
+     * bound, so there is no params object to send alongside it.
+     *
+     * Switches on `type` rather than using the `isXExpression` guards, which live in `../assertions`
+     * and import this module — the guards test the same discriminant, so nothing is lost.
+     */ static toJson(expression) {
+        if (expression.type === "operator") {
+            const operator = expression;
+            return {
+                t: "operator",
+                operator: operator.operator,
+                ...operator.left != null && {
+                    left: Expression.toJson(operator.left)
+                },
+                ...operator.right != null && {
+                    right: Expression.toJson(operator.right)
+                }
+            };
+        }
+        if (expression.type === "comparator") {
+            const comparator = expression;
+            return {
+                t: "comparator",
+                comparator: comparator.comparator,
+                negated: comparator.negated,
+                strict: comparator.strict,
+                ...comparator.left != null && {
+                    left: Expression.toJson(comparator.left)
+                },
+                ...comparator.right != null && {
+                    right: Expression.toJson(comparator.right)
+                }
+            };
+        }
+        if (expression.type === "property") {
+            const property = expression;
+            return {
+                t: "property",
+                // The dotted path, which is exactly the key `getProperty` is looking up
+                path: property.property.id,
+                transformer: property.transformer,
+                locale: property.locale
+            };
+        }
+        if (expression.type === "value") {
+            const value = expression;
+            return {
+                t: "value",
+                value: valueToJson(value.value),
+                transformer: value.transformer,
+                locale: value.locale
+            };
+        }
+        return expression.type === "empty" ? {
+            t: "empty"
+        } : {
+            t: "not-parsable"
+        };
+    }
+    /**
+     * Rebuilds a tree from JSON, rebinding every property against `schema`.
+     *
+     * The schema is SUPPLIED rather than read out of the payload. A filter always belongs to a known
+     * collection, and the RECEIVER's schema is the authority on what its properties are — taking an
+     * id from the payload would mean rebinding against a schema the sender chose, which is backwards
+     * for anything crossing a trust boundary.
+     *
+     * @throws when a property path is not declared by `schema`. Not `NOT_PARSABLE`: on a receiver, a
+     * filter that silently stops filtering returns rows the requester excluded, which is the one
+     * failure here worse than an error.
+     */ static fromJson(json, schema) {
+        const child = (node)=>node == null ? undefined : Expression.fromJson(node, schema);
+        if (json.t === "operator") {
+            return new OperatorExpression({
+                operator: json.operator,
+                left: child(json.left),
+                right: child(json.right)
+            });
+        }
+        if (json.t === "comparator") {
+            return new ComparatorExpression({
+                comparator: json.comparator,
+                negated: json.negated,
+                strict: json.strict,
+                left: child(json.left),
+                right: child(json.right)
+            });
+        }
+        if (json.t === "property") {
+            const property = schema.getProperty(json.path);
+            if (property == null) {
+                throw new Error(`Cannot deserialize a filter: this schema does not declare the property it names.  ` + `Property: ${json.path}, Collection: ${schema.collectionName}.  ` + `The two sides disagree about the shape of the data, so the filter cannot be applied.`);
+            }
+            const rebuilt = new PropertyExpression({
+                property
+            });
+            rebuilt.transformer = json.transformer;
+            rebuilt.locale = json.locale;
+            return rebuilt;
+        }
+        if (json.t === "value") {
+            const rebuilt = new ValueExpression({
+                value: valueFromJson(json.value)
+            });
+            rebuilt.transformer = json.transformer;
+            rebuilt.locale = json.locale;
+            return rebuilt;
+        }
+        return json.t === "empty" ? Expression.EMPTY : Expression.NOT_PARSABLE;
+    }
+}
+class EmptyExpression extends Expression {
+    type = "empty";
+}
+class NotParsableExpression extends Expression {
+    type = "not-parsable";
+}
+/**
+ * A class representing a comparison operation (e.g., equals, greater-than).
+ */ class ComparatorExpression extends Expression {
+    /** The type of the expression (always 'comparator'). */ type = "comparator";
+    /** The comparator operation (e.g., equals, greater-than). */ comparator;
+    /** Whether the comparison is negated (e.g., not equals). */ negated;
+    /** Whether the comparison is strict (type-sensitive). */ strict;
+    constructor(options){
+        super(options.left, options.right);
+        this.comparator = options.comparator;
+        this.negated = options.negated;
+        this.strict = options.strict;
+    }
+}
+/**
+ * A class representing a logical operator (e.g., &&, ||).
+ */ class OperatorExpression extends Expression {
+    /** The type of the expression (always 'operator'). */ type = "operator";
+    /** The logical operator. */ operator;
+    constructor(options){
+        super(options.left, options.right);
+        this.operator = options.operator;
+    }
+}
+/**
+ * A class representing a property path.
+ */ class PropertyExpression extends Expression {
+    /** The type of the expression (always 'property'). */ type = "property";
+    /** The property info for the path. */ property;
+    transformer = null;
+    locale = null;
+    constructor(options){
+        super();
+        this.property = options.property;
+    }
+}
+/**
+ * A class representing a literal value.
+ */ class ValueExpression extends Expression {
+    /** The type of the expression (always 'value'). */ type = "value";
+    /** The literal value. */ value;
+    transformer = null;
+    locale = null;
+    constructor(options){
+        super();
+        this.value = options.value;
+    }
+}
+
+
+},
+63(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  j: () => (forEach),
+  o: () => (getProperties)
+});
+/**
+ * Extracts all properties referenced in an expression
+ * @param expression The expression to analyze
+ * @returns Array of PropertyInfo objects referenced in the expression
+ */ function getProperties(expression) {
+    const properties = [];
+    function traverse(expr) {
+        // If this is a property expression, add it to our collection
+        if (expr.type === "property") {
+            properties.push(expr.property);
+        }
+        // Traverse left and right expressions if they exist
+        if (expr.left) {
+            traverse(expr.left);
+        }
+        if (expr.right) {
+            traverse(expr.right);
+        }
+    }
+    traverse(expression);
+    return properties;
+}
+function forEach(expression, callback) {
+    function traverse(expr) {
+        // Call the callback for this expression
+        // If callback returns false, stop traversing
+        if (!callback(expr)) {
+            return false;
+        }
+        // Traverse left and right expressions if they exist
+        if (expr.left) {
+            if (!traverse(expr.left)) {
+                return false;
+            }
+        }
+        if (expr.right) {
+            if (!traverse(expr.right)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    traverse(expression);
+}
+
+
+},
+537(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  L: () => (SchemaTypes)
+});
+var SchemaTypes = /*#__PURE__*/ function(SchemaTypes) {
+    SchemaTypes["Array"] = "Array";
+    SchemaTypes["Boolean"] = "Boolean";
+    SchemaTypes["Date"] = "Date";
+    SchemaTypes["Number"] = "Number";
+    SchemaTypes["Object"] = "Object";
+    SchemaTypes["String"] = "String";
+    SchemaTypes["Definition"] = "Definition";
+    SchemaTypes["Function"] = "Function";
+    SchemaTypes["Computed"] = "Computed";
+    /**
+     * Content in, reference out. The only type whose write shape differs from its stored
+     * shape, and a leaf on purpose — see `SchemaFile`.
+     */ SchemaTypes["File"] = "File";
+    /**
+     * A fixed-length list of numbers, carrying its dimension count — see `SchemaVector`.
+     *
+     * Value-shaped exactly like `s.array(s.number())`, which is why every array codegen
+     * handler accepts it. It is a distinct type only so a backend can recognise it and store
+     * it natively; nothing else needs to tell the two apart.
+     */ SchemaTypes["Vector"] = "Vector";
+    return SchemaTypes;
+}({});
+var HashType = /*#__PURE__*/ (/* unused pure expression or super */ null && (function(HashType) {
+    HashType["Ids"] = "Ids";
+    HashType["Object"] = "Object";
+    return HashType;
+}({})));
+
+
+},
+581(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  vF: () => (logger)
+});
+/**
+ * Levelled logging, resolved once.
+ *
+ * Three things about the previous implementation drove this shape:
+ *
+ *  - **There was no way to turn logging off.** `globalThis.__ROUTIER_DEBUG__` was only ever
+ *    compared against `true`, so setting it to `false` did nothing — while
+ *    `docs/how-to/debug-logging.md` documented exactly that as the way to force logging off.
+ *    A documented switch that silently does nothing is worse than no switch.
+ *  - **`NODE_ENV === 'test'` enabled it.** Every Jest run therefore logged, because Jest always
+ *    sets `NODE_ENV=test`. Measured on the S7 stress scenario, which drives ~2,000 saves through
+ *    a plugin that logs three lines per query: 12.4s with logging, ~6s without. Test runners also
+ *    capture console output by snapshotting a stack trace per call, so the cost is far above what
+ *    writing to a terminal would suggest — and the output buries whatever the failure was.
+ *  - **It was all-or-nothing, and re-resolved per call.** An error could not be kept while debug
+ *    was dropped, and every one of the ~97 call sites re-read `globalThis` and `process.env`.
+ *
+ * Levels are compared numerically against a value cached at module load. Measured against a
+ * no-op console at 200k calls: an enabled call costs ~70ns, a call rejected by the gate ~3ns.
+ * Building the arguments the call site passes in accounts for ~0.2ns of that 3ns, which is why
+ * this keeps the ordinary `logger.debug(msg, payload)` signature instead of taking a thunk —
+ * a lazy API would recover 0.3% of an enabled call's cost and would have to change every call
+ * site to do it.
+ */ /** Ordered from most severe to most verbose. `silent` discards everything. */ const LOG_LEVELS = [
+    'silent',
+    'error',
+    'warn',
+    'info',
+    'debug'
+];
+/** Numeric rank, so a gate is one integer comparison. */ const RANK = {
+    silent: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4
+};
+const isLogLevel = (value)=>typeof value === 'string' && LOG_LEVELS.includes(value);
+/**
+ * Resolves the configured level, in precedence order.
+ *
+ * Ordered most specific first: an explicit level beats a boolean flag, a boolean flag beats an
+ * environment variable, and an environment variable beats an inference from `NODE_ENV`. Anything
+ * unrecognised is ignored rather than treated as an error — a typo'd level should not take down
+ * an application, and `silent` is the safe direction to fall back to.
+ */ const resolveLevel = ()=>{
+    if (typeof globalThis !== 'undefined') {
+        const g = globalThis;
+        if (isLogLevel(g.__ROUTIER_LOG_LEVEL__)) {
+            return g.__ROUTIER_LOG_LEVEL__;
+        }
+        // Both directions honoured. `=== false` used to fall through to the NODE_ENV checks
+        // below and re-enable the logging it was asked to suppress.
+        if (g.__ROUTIER_DEBUG__ === true) return 'debug';
+        if (g.__ROUTIER_DEBUG__ === false) return 'silent';
+    }
+    // There is deliberately no `import.meta.env` branch, although the documentation used to
+    // promise one. It could never work: this package is bundled with rspack, which replaces
+    // `import.meta` with `undefined`, so the check would read the *library's* build-time
+    // environment rather than the application's — and referencing `import.meta` at all is a parse
+    // error under a CommonJS build target, which is how the test suite loads this file. Vite and
+    // similar apps set `__ROUTIER_LOG_LEVEL__` or `__ROUTIER_DEBUG__` from their own
+    // `import.meta.env`, which is what the docs now describe.
+    if (typeof process !== 'undefined' && process.env != null) {
+        if (isLogLevel(process.env.ROUTIER_LOG_LEVEL)) {
+            return process.env.ROUTIER_LOG_LEVEL;
+        }
+        const debug = process.env.DEBUG;
+        if (debug === 'routier' || debug === '*') return 'debug';
+        const env = "production"?.toLowerCase();
+        // `test` is deliberately absent. It used to be here, which meant no test suite anywhere
+        // could run Routier quietly. Opt in with DEBUG=routier or ROUTIER_LOG_LEVEL when a test
+        // needs the output.
+        if (env === 'dev' || env === 'development') return 'debug';
+    }
+    return 'silent';
+};
+let level = resolveLevel();
+let rank = RANK[level];
+/**
+ * Overrides the level for the rest of the process.
+ *
+ * The configuration above is read once, at import, which is what makes the gate cheap — but it
+ * also means an application that decides its verbosity after startup, or a test that wants to
+ * assert on output, has no way in. This is that way in.
+ */ const setLogLevel = (next)=>{
+    if (isLogLevel(next) === false) {
+        throw new Error(`Unknown log level "${next}". Expected one of: ${LOG_LEVELS.join(', ')}`);
+    }
+    level = next;
+    rank = RANK[next];
+};
+const getLogLevel = ()=>level;
+/** Re-reads the environment. For tests that change it after this module was imported. */ const resetLogLevel = ()=>{
+    level = resolveLevel();
+    rank = RANK[level];
+};
+/**
+ * Whether a message at this level would be emitted.
+ *
+ * For the rare call site whose *arguments* are expensive to build — a serialization, a deep
+ * clone, a join over a large collection. An ordinary payload object is not worth guarding; see
+ * the measurement in the header.
+ */ const isLogLevelEnabled = (at)=>rank >= RANK[at];
+const emit = (at, method, args)=>{
+    if (rank < RANK[at]) {
+        return;
+    }
+    // Resolved at call time rather than captured once: test harnesses and browser devtools both
+    // replace console methods after modules have loaded, and a captured reference would keep
+    // writing past the replacement.
+    console[method](...args);
+};
+const logger = {
+    /** General-purpose output. Carried at `info`, since `log` names a console method, not a level. */ log: (...args)=>emit('info', 'log', args),
+    info: (...args)=>emit('info', 'info', args),
+    warn: (...args)=>emit('warn', 'warn', args),
+    error: (...args)=>emit('error', 'error', args),
+    debug: (...args)=>emit('debug', 'debug', args),
+    /** Diagnostic tabular output; verbose by nature, so it sits at `debug`. */ table: (...args)=>emit('debug', 'table', args)
+};
+
+
+},
+
+});
+// The module cache
+var __webpack_module_cache__ = {};
+
+// The require function
+function __webpack_require__(moduleId) {
+
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+
+}
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
+(() => {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  ComparatorExpression: () => (/* reexport safe */ _types__rspack_import_2.bQ),
+  EXPRESSION_TYPES: () => (/* reexport safe */ _constants__rspack_import_4.t),
+  EmptyExpression: () => (/* reexport safe */ _types__rspack_import_2.Sm),
+  Expression: () => (/* reexport safe */ _types__rspack_import_2.r4),
+  NotParsableExpression: () => (/* reexport safe */ _types__rspack_import_2.SC),
+  OperatorExpression: () => (/* reexport safe */ _types__rspack_import_2.fw),
+  PropertyExpression: () => (/* reexport safe */ _types__rspack_import_2.ep),
+  ValueExpression: () => (/* reexport safe */ _types__rspack_import_2.Ko),
+  combineExpressions: () => (/* reexport safe */ _parser__rspack_import_1.pg),
+  evaluate: () => (/* reexport safe */ _evaluate__rspack_import_0._3),
+  forEach: () => (/* reexport safe */ _utils__rspack_import_3.j),
+  getProperties: () => (/* reexport safe */ _utils__rspack_import_3.o),
+  parseFragment: () => (/* reexport safe */ _parser__rspack_import_1.oH),
+  toExpression: () => (/* reexport safe */ _parser__rspack_import_1.MY),
+  toPredicate: () => (/* reexport safe */ _evaluate__rspack_import_0.Vu),
+  toStrictPredicate: () => (/* reexport safe */ _evaluate__rspack_import_0.wS)
+});
+/* import */ var _evaluate__rspack_import_0 = __webpack_require__(379);
+/* import */ var _parser__rspack_import_1 = __webpack_require__(91);
+/* import */ var _types__rspack_import_2 = __webpack_require__(27);
+/* import */ var _utils__rspack_import_3 = __webpack_require__(63);
+/* import */ var _constants__rspack_import_4 = __webpack_require__(835);
+
+
+
+
+
+
+})();
+
+module.exports = __webpack_exports__;
+})()
+;
+//# sourceMappingURL=index.cjs.map