@loancrate/json-selector 5.0.0 → 5.1.0

package/dist/json-selector.esm.js

@@ -80,6 +80,17 @@ class JsonSelectorRuntimeError extends JsonSelectorError {
  */
 class JsonSelectorTypeError extends JsonSelectorRuntimeError {
 }
+/**
+ * Error thrown when an accessor operation cannot be applied to the given context.
+ */
+class AccessorError extends JsonSelectorRuntimeError {
+    constructor(code, path, operation, message) {
+        super(message);
+        this.code = code;
+        this.path = path;
+        this.operation = operation;
+    }
+}
 /**
  * Error thrown when reading an unbound lexical-scope variable.
  */
@@ -220,6 +231,15 @@ function formatRawString(s) {
     // eslint-disable-next-line no-control-regex
     return `'${s.replace(/[\0-\x1F]/g, "").replace(/['\\]/g, (c) => `\\${c}`)}'`;
 }
+function describeValueType(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (isArray(value)) {
+        return "array";
+    }
+    return typeof value;
+}
 
 /** Matches any value regardless of type. */
 const ANY_TYPE = Object.freeze({
@@ -1688,15 +1708,6 @@ function ensureNumber(value, operand, operator) {
     }
     return value;
 }
-function describeValueType(value) {
-    if (value === null) {
-        return "null";
-    }
-    if (isArray(value)) {
-        return "array";
-    }
-    return typeof value;
-}
 function performArithmetic(lv, rv, operator) {
     const l = ensureNumber(lv, "left operand", operator);
     const r = ensureNumber(rv, "right operand", operator);
@@ -1863,49 +1874,6 @@ function compare(lv, rv, operator) {
     return null;
 }
 
-function replaceArray(target, source) {
-    target.length = 0;
-    target.push(...source);
-    return target;
-}
-function invertedFilter(value, condition, evalCtx) {
-    return value.filter((e) => isFalseOrEmpty(evaluateJsonSelector(condition, e, evalCtx)));
-}
-/** Returns the complement of a slice: the elements that would NOT be selected by the given slice parameters. */
-function invertedSlice(value, start, end, step) {
-    ({ start, end, step } = normalizeSlice(value.length, start, end, step));
-    const collected = [];
-    if (step > 0) {
-        if (start >= end) {
-            return value;
-        }
-        let skip = start;
-        for (let i = 0; i < value.length; ++i) {
-            if (i < skip || i >= end) {
-                collected.push(value[i]);
-            }
-            else {
-                skip += step;
-            }
-        }
-    }
-    else {
-        if (start <= end) {
-            return value;
-        }
-        let skip = start;
-        for (let i = value.length - 1; i >= 0; --i) {
-            if (i > skip || i <= end) {
-                collected.push(value[i]);
-            }
-            else {
-                skip += step;
-            }
-        }
-    }
-    return collected;
-}
-
 const PRECEDENCE_ACCESS = 1;
 const PRECEDENCE_NOT = 2;
 const PRECEDENCE_MULTIPLY = 3;
@@ -2129,2108 +2097,2401 @@ function format(selector) {
     }, undefined);
 }
 
-class BaseAccessor {
-    constructor(selector) {
-        this.selector = selector;
-    }
+const READ_ONLY_CONSTRUCTS = {
+    not: "not expression",
+    compare: "comparison",
+    arithmetic: "arithmetic expression",
+    unaryArithmetic: "unary arithmetic expression",
+    and: "and expression",
+    or: "or expression",
+    ternary: "ternary expression",
+    functionCall: "function call",
+    expressionRef: "expression reference",
+    variableRef: "variable reference",
+    let: "let expression",
+    multiSelectList: "multi-select list",
+    multiSelectHash: "multi-select hash",
+    literal: "literal",
+    current: "current node reference",
+    root: "root reference",
+};
+const MISSING_PARENT_DETAIL = "parent does not exist";
+function accessorError(code, selector, operation, detail) {
+    const path = formatJsonSelector(selector);
+    return new AccessorError(code, path, operation, `Cannot ${operation} '${path}': ${detail}`);
 }
-class ReadOnlyAccessor extends BaseAccessor {
-    constructor(selector) {
-        super(selector);
-    }
-    isValidContext() {
-        return true;
-    }
-    set() {
-        // ignored
+function readOnlyError(selector, operation, construct = READ_ONLY_CONSTRUCTS[selector.type]) {
+    return accessorError("NOT_WRITABLE", selector, operation, `${construct} is read-only`);
+}
+function requireObjectContext(value, selector, operation) {
+    if (!isObject(value)) {
+        throw accessorError("TYPE_MISMATCH", selector, operation, `expected object, got ${describeValueType(value)}`);
     }
-    delete() {
-        // ignored
+    return value;
+}
+function requireObjectParent(value, selector, operation) {
+    if (value == null) {
+        throw accessorError("MISSING_PARENT", selector, operation, MISSING_PARENT_DETAIL);
     }
+    return requireObjectContext(value, selector, operation);
 }
-class ConstantAccessor extends ReadOnlyAccessor {
-    constructor(selector, value) {
-        super(selector);
-        this.value = value;
+function requireArrayParent(value, selector, operation) {
+    if (value == null) {
+        throw accessorError("MISSING_PARENT", selector, operation, MISSING_PARENT_DETAIL);
     }
-    get() {
-        return this.value;
+    if (!isArray(value)) {
+        throw accessorError("TYPE_MISMATCH", selector, operation, `expected array, got ${describeValueType(value)}`);
     }
+    return value;
 }
-class ContextAccessor extends ReadOnlyAccessor {
-    constructor() {
-        super({ type: "current" });
+function requireArrayOrStringParent(value, selector, operation) {
+    if (value == null) {
+        throw accessorError("MISSING_PARENT", selector, operation, MISSING_PARENT_DETAIL);
     }
-    get(context) {
-        return context;
+    if (!isArray(value) && typeof value !== "string") {
+        throw accessorError("TYPE_MISMATCH", selector, operation, `expected array or string, got ${describeValueType(value)}`);
     }
+    return value;
 }
-class RootContextAccessor extends ReadOnlyAccessor {
-    constructor() {
-        super({ type: "root" });
+function resolveInBoundsIndex(arr, index, selector, operation) {
+    const resolvedIndex = index < 0 ? arr.length + index : index;
+    if (resolvedIndex < 0 || resolvedIndex >= arr.length) {
+        throw accessorError("INDEX_OUT_OF_BOUNDS", selector, operation, `index ${resolvedIndex} is out of bounds`);
     }
-    get(context, rootContext = context) {
-        return rootContext;
+    return resolvedIndex;
+}
+function requireIdIndex(arr, id, selector, operation) {
+    const index = findIdIndex(arr, id);
+    if (index < 0) {
+        throw accessorError("MISSING_ID", selector, operation, `id '${String(id)}' was not found`);
     }
+    return index;
 }
-class EvaluateAccessor extends ReadOnlyAccessor {
-    constructor(selector, options) {
-        super(selector);
-        this.options = options;
+
+function replaceArray(target, source) {
+    target.length = 0;
+    target.push(...source);
+    return target;
+}
+function invertedFilter(value, condition, evalCtx) {
+    return value.filter((e) => isFalseOrEmpty(evaluateJsonSelector(condition, e, evalCtx)));
+}
+/** Returns the complement of a slice: the elements that would NOT be selected by the given slice parameters. */
+function invertedSlice(value, start, end, step) {
+    ({ start, end, step } = normalizeSlice(value.length, start, end, step));
+    const collected = [];
+    if (step > 0) {
+        if (start >= end) {
+            return value;
+        }
+        let skip = start;
+        for (let i = 0; i < value.length; ++i) {
+            if (i < skip || i >= end) {
+                collected.push(value[i]);
+            }
+            else {
+                skip += step;
+            }
+        }
     }
-    get(context, rootContext = context) {
-        return evaluateJsonSelector(this.selector, context, Object.assign(Object.assign({}, this.options), { rootContext }));
+    else {
+        if (start <= end) {
+            return value;
+        }
+        let skip = start;
+        for (let i = value.length - 1; i >= 0; --i) {
+            if (i > skip || i <= end) {
+                collected.push(value[i]);
+            }
+            else {
+                skip += step;
+            }
+        }
     }
+    return collected;
 }
-/** Compiles a selector AST into an {@link UnboundAccessor} that can be repeatedly bound to different contexts. */
-function makeJsonSelectorAccessor(selector, options) {
+
+const TOKEN_LIMIT = 42 /* TokenType.ASSIGN */ + 1;
+const EOF_DESCRIPTION = "end of input";
+const TOKEN_DESCRIPTIONS = {
+    [0 /* TokenType.EOF */]: EOF_DESCRIPTION,
+    [1 /* TokenType.LPAREN */]: "'('",
+    [2 /* TokenType.RPAREN */]: "')'",
+    [3 /* TokenType.LBRACKET */]: "'['",
+    [4 /* TokenType.RBRACKET */]: "']'",
+    [5 /* TokenType.LBRACE */]: "'{'",
+    [6 /* TokenType.RBRACE */]: "'}'",
+    [7 /* TokenType.DOT */]: "'.'",
+    [8 /* TokenType.COMMA */]: "','",
+    [9 /* TokenType.COLON */]: "':'",
+    [10 /* TokenType.PIPE */]: "'|'",
+    [11 /* TokenType.OR */]: "'||'",
+    [12 /* TokenType.AND */]: "'&&'",
+    [13 /* TokenType.NOT */]: "'!'",
+    [14 /* TokenType.EQ */]: "'=='",
+    [15 /* TokenType.NEQ */]: "'!='",
+    [16 /* TokenType.LT */]: "'<'",
+    [17 /* TokenType.LTE */]: "'<='",
+    [18 /* TokenType.GT */]: "'>'",
+    [19 /* TokenType.GTE */]: "'>='",
+    [20 /* TokenType.PLUS */]: "'+'",
+    [21 /* TokenType.MINUS */]: "'-'",
+    [22 /* TokenType.MULTIPLY */]: "'\u00D7'",
+    [23 /* TokenType.DIVIDE */]: "'/'",
+    [24 /* TokenType.MODULO */]: "'%'",
+    [25 /* TokenType.INT_DIVIDE */]: "'//'",
+    [26 /* TokenType.AT */]: "'@'",
+    [27 /* TokenType.DOLLAR */]: "'$'",
+    [28 /* TokenType.STAR */]: "'*'",
+    [29 /* TokenType.QUESTION */]: "'?'",
+    [30 /* TokenType.AMPERSAND */]: "'&'",
+    [31 /* TokenType.FILTER_BRACKET */]: "'[?'",
+    [32 /* TokenType.FLATTEN_BRACKET */]: "'[]'",
+    [33 /* TokenType.IDENTIFIER */]: "identifier",
+    [34 /* TokenType.QUOTED_STRING */]: "quoted string",
+    [35 /* TokenType.RAW_STRING */]: "raw string",
+    [36 /* TokenType.BACKTICK_LITERAL */]: "backtick literal",
+    [37 /* TokenType.NUMBER */]: "number",
+    [38 /* TokenType.NULL */]: "'null'",
+    [39 /* TokenType.TRUE */]: "'true'",
+    [40 /* TokenType.FALSE */]: "'false'",
+    [41 /* TokenType.VARIABLE */]: "variable",
+    [42 /* TokenType.ASSIGN */]: "'='",
+};
+function describeTokenType(type) {
     var _a;
-    return makeAccessorInternal(selector, {
-        functionProvider: (_a = options === null || options === void 0 ? void 0 : options.functionProvider) !== null && _a !== void 0 ? _a : getBuiltinFunctionProvider(),
-    });
+    return (_a = TOKEN_DESCRIPTIONS[type]) !== null && _a !== void 0 ? _a : `unknown token ${type}`;
 }
-function makeAccessorInternal(selector, options) {
-    return visitJsonSelector(selector, {
-        current() {
-            return new ContextAccessor();
-        },
-        root() {
-            return new RootContextAccessor();
-        },
-        literal(selector) {
-            return new ConstantAccessor(selector, selector.value);
-        },
-        identifier(selector) {
-            const { id } = selector;
-            const Accessor = class extends BaseAccessor {
-                constructor() {
-                    super(selector);
-                }
-                isValidContext(context) {
-                    return isObject(context);
-                }
-                get(context) {
-                    return getField(context, id);
-                }
-                set(value, context) {
-                    if (isObject(context)) {
-                        context[id] = value;
-                    }
-                }
-                delete(context) {
-                    if (isObject(context)) {
-                        delete context[id];
-                    }
-                }
-            };
-            return new Accessor();
-        },
-        fieldAccess(selector) {
-            const { expression, field } = selector;
-            const base = makeAccessorInternal(expression, options);
-            const Accessor = class extends BaseAccessor {
-                constructor() {
-                    super(selector);
-                }
-                isValidContext(context, rootContext = context) {
-                    const value = base.get(context, rootContext);
-                    return isObject(value);
-                }
-                get(context, rootContext = context) {
-                    const obj = base.get(context, rootContext);
-                    return getField(obj, field);
-                }
-                set(value, context, rootContext = context) {
-                    const obj = base.get(context, rootContext);
-                    if (isObject(obj)) {
-                        obj[field] = value;
-                    }
-                }
-                delete(context, rootContext = context) {
-                    const obj = base.get(context, rootContext);
-                    if (isObject(obj)) {
-                        delete obj[field];
-                    }
+
+const KEYWORDS = {
+    null: 38 /* TokenType.NULL */,
+    true: 39 /* TokenType.TRUE */,
+    false: 40 /* TokenType.FALSE */,
+};
+// Escape sequence lookup for quoted strings
+const ESCAPE_CHARS = {
+    '"': '"',
+    "\\": "\\",
+    "/": "/",
+    b: "\b",
+    f: "\f",
+    n: "\n",
+    r: "\r",
+    t: "\t",
+    "`": "`",
+};
+/**
+ * Hand-written lexer for JSON Selector expressions providing single token
+ * lookahead.
+ */
+class Lexer {
+    constructor(input, options) {
+        var _a;
+        this.pos = 0;
+        this.input = input;
+        this.length = input.length;
+        this.rawStringBackslashEscape = (_a = options === null || options === void 0 ? void 0 : options.rawStringBackslashEscape) !== null && _a !== void 0 ? _a : true;
+        this.current = this.scanNext();
+    }
+    /**
+     * Peek at current token without consuming.
+     */
+    peek() {
+        return this.current;
+    }
+    /**
+     * Advance to next token and return it.
+     */
+    advance() {
+        this.current = this.scanNext();
+        return this.current;
+    }
+    /**
+     * Consume current token if it matches type, throw otherwise.
+     */
+    consume(type) {
+        const token = this.peek();
+        if (token.type !== type) {
+            const expected = describeTokenType(type);
+            const actual = token.text || describeTokenType(token.type);
+            throw new UnexpectedTokenError(this.input, token.offset, actual, expected);
+        }
+        this.advance();
+        // Type assertion is safe due to the type check above
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        return token;
+    }
+    /**
+     * Try to consume token if it matches type, return null otherwise.
+     */
+    tryConsume(type) {
+        const token = this.peek();
+        if (token.type !== type) {
+            return null;
+        }
+        this.advance();
+        // Type assertion is safe due to the type check above
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        return token;
+    }
+    /**
+     * Get next token (EOF token at end of input)
+     */
+    scanNext() {
+        let ch = this.peekCharCode();
+        while (isWhitespace(ch)) {
+            ch = this.advanceCharCode();
+        }
+        const start = this.pos;
+        let singleType = 0;
+        switch (ch) {
+            // End of input
+            case -1:
+                return { type: 0 /* TokenType.EOF */, text: "", offset: this.length };
+            // Multi-character scanner entry points
+            case 91: // [
+                return this.scanBracket(start);
+            case 124: // |
+                return this.scanPipe(start);
+            case 33: // !
+                return this.scanBang(start);
+            case 60: // <
+                return this.scanLessThan(start);
+            case 62: // >
+                return this.scanGreaterThan(start);
+            case 61: // =
+                return this.scanEquals(start);
+            case 38: // &
+                return this.scanAmpersand(start);
+            case 47: // /
+                return this.scanSlash(start);
+            // String/literal openers
+            case 34: // "
+                return this.scanQuotedString(start);
+            case 39: // '
+                return this.scanRawString(start);
+            case 96: // `
+                return this.scanBacktickLiteral(start);
+            // Arithmetic operators (including Unicode aliases)
+            case 43: // +
+                singleType = 20 /* TokenType.PLUS */;
+                break;
+            case 45: // -
+                singleType = 21 /* TokenType.MINUS */;
+                break;
+            case 0x2212: // −
+                singleType = 21 /* TokenType.MINUS */;
+                break;
+            case 42: // *
+                singleType = 28 /* TokenType.STAR */;
+                break;
+            case 0x00d7: // ×
+                singleType = 22 /* TokenType.MULTIPLY */;
+                break;
+            case 37: // %
+                singleType = 24 /* TokenType.MODULO */;
+                break;
+            case 0x00f7: // ÷
+                singleType = 23 /* TokenType.DIVIDE */;
+                break;
+            // Delimiters and punctuation
+            case 40: // (
+                singleType = 1 /* TokenType.LPAREN */;
+                break;
+            case 41: // )
+                singleType = 2 /* TokenType.RPAREN */;
+                break;
+            case 93: // ]
+                singleType = 4 /* TokenType.RBRACKET */;
+                break;
+            case 123: // {
+                singleType = 5 /* TokenType.LBRACE */;
+                break;
+            case 125: // }
+                singleType = 6 /* TokenType.RBRACE */;
+                break;
+            case 46: // .
+                singleType = 7 /* TokenType.DOT */;
+                break;
+            case 44: // ,
+                singleType = 8 /* TokenType.COMMA */;
+                break;
+            case 58: // :
+                singleType = 9 /* TokenType.COLON */;
+                break;
+            // Context and control symbols
+            case 64: // @
+                singleType = 26 /* TokenType.AT */;
+                break;
+            case 36: {
+                // $ or variable reference ($name)
+                const next = this.peekCharCode(this.pos + 1);
+                if (isIdentStart(next)) {
+                    return this.scanVariable(start);
                 }
+                singleType = 27 /* TokenType.DOLLAR */;
+                break;
+            }
+            case 63: // ?
+                singleType = 29 /* TokenType.QUESTION */;
+                break;
+        }
+        if (singleType !== 0) {
+            this.pos++;
+            return {
+                type: singleType,
+                text: this.input[start],
+                offset: start,
             };
-            return new Accessor();
-        },
-        indexAccess(selector) {
-            const { expression, index } = selector;
-            const base = makeAccessorInternal(expression, options);
-            const Accessor = class extends BaseAccessor {
-                constructor() {
-                    super(selector);
-                }
-                isValidContext(context, rootContext = context) {
-                    const value = base.get(context, rootContext);
-                    return isArray(value);
-                }
-                get(context, rootContext = context) {
-                    const arr = base.get(context, rootContext);
-                    return getIndex(arr, index);
-                }
-                set(value, context, rootContext = context) {
-                    const arr = base.get(context, rootContext);
-                    if (isArray(arr)) {
-                        arr[index < 0 ? arr.length + index : index] = value;
-                    }
-                }
-                delete(context, rootContext = context) {
-                    const arr = base.get(context, rootContext);
-                    if (isArray(arr)) {
-                        arr.splice(index, 1);
-                    }
-                }
+        }
+        if (isDigit(ch)) {
+            return this.scanNumber(start);
+        }
+        if (isIdentStart(ch)) {
+            return this.scanIdentifier(start);
+        }
+        throw new UnexpectedCharacterError(this.input, start, this.input[start]);
+    }
+    /**
+     * Scan [, [?, or []
+     */
+    scanBracket(start) {
+        const ch = this.advanceCharCode();
+        if (ch === 63) {
+            // ?
+            this.pos++;
+            return {
+                type: 31 /* TokenType.FILTER_BRACKET */,
+                text: "[?",
+                offset: start,
             };
-            return new Accessor();
-        },
-        idAccess(selector) {
-            const { expression, id } = selector;
-            const base = makeAccessorInternal(expression, options);
-            const Accessor = class extends BaseAccessor {
-                constructor() {
-                    super(selector);
-                }
-                isValidContext(context, rootContext = context) {
-                    const value = base.get(context, rootContext);
-                    return isArray(value);
-                }
-                get(context, rootContext = context) {
-                    const arr = base.get(context, rootContext);
-                    return findId(arr, id);
-                }
-                set(value, context, rootContext = context) {
-                    const arr = base.get(context, rootContext);
-                    if (isArray(arr)) {
-                        const index = findIdIndex(arr, id);
-                        if (index >= 0) {
-                            arr[index] = value;
-                        }
+        }
+        if (ch === 93) {
+            // ]
+            this.pos++;
+            return {
+                type: 32 /* TokenType.FLATTEN_BRACKET */,
+                text: "[]",
+                offset: start,
+            };
+        }
+        return {
+            type: 3 /* TokenType.LBRACKET */,
+            text: "[",
+            offset: start,
+        };
+    }
+    /**
+     * Scan | or ||
+     */
+    scanPipe(start) {
+        const ch = this.advanceCharCode(); // consume |
+        if (ch === 124) {
+            // |
+            this.pos++;
+            return { type: 11 /* TokenType.OR */, text: "||", offset: start };
+        }
+        return { type: 10 /* TokenType.PIPE */, text: "|", offset: start };
+    }
+    /**
+     * Scan ! or !=
+     */
+    scanBang(start) {
+        const ch = this.advanceCharCode(); // consume !
+        if (ch === 61) {
+            // =
+            this.pos++;
+            return { type: 15 /* TokenType.NEQ */, text: "!=", offset: start };
+        }
+        return { type: 13 /* TokenType.NOT */, text: "!", offset: start };
+    }
+    /**
+     * Scan < or <=
+     */
+    scanLessThan(start) {
+        const ch = this.advanceCharCode(); // consume <
+        if (ch === 61) {
+            // =
+            this.pos++;
+            return { type: 17 /* TokenType.LTE */, text: "<=", offset: start };
+        }
+        return { type: 16 /* TokenType.LT */, text: "<", offset: start };
+    }
+    /**
+     * Scan > or >=
+     */
+    scanGreaterThan(start) {
+        const ch = this.advanceCharCode(); // consume >
+        if (ch === 61) {
+            // =
+            this.pos++;
+            return { type: 19 /* TokenType.GTE */, text: ">=", offset: start };
+        }
+        return { type: 18 /* TokenType.GT */, text: ">", offset: start };
+    }
+    /**
+     * Scan = or ==
+     */
+    scanEquals(start) {
+        const ch = this.advanceCharCode(); // consume first =
+        if (ch === 61) {
+            // =
+            this.pos++;
+            return { type: 14 /* TokenType.EQ */, text: "==", offset: start };
+        }
+        return { type: 42 /* TokenType.ASSIGN */, text: "=", offset: start };
+    }
+    /**
+     * Scan & or &&
+     */
+    scanAmpersand(start) {
+        const ch = this.advanceCharCode(); // consume &
+        if (ch === 38) {
+            // &&
+            this.pos++;
+            return { type: 12 /* TokenType.AND */, text: "&&", offset: start };
+        }
+        // Single & for expression references
+        return { type: 30 /* TokenType.AMPERSAND */, text: "&", offset: start };
+    }
+    /**
+     * Scan / or //
+     */
+    scanSlash(start) {
+        const ch = this.advanceCharCode(); // consume /
+        if (ch === 47) {
+            // /
+            this.pos++;
+            return { type: 25 /* TokenType.INT_DIVIDE */, text: "//", offset: start };
+        }
+        return { type: 23 /* TokenType.DIVIDE */, text: "/", offset: start };
+    }
+    /**
+     * Scan raw string: '...'
+     * When rawStringBackslashEscape is true (default), both \' and \\ are unescaped.
+     * When false, only \' is unescaped.
+     * Optimized to use slicing for long strings
+     */
+    scanRawString(start) {
+        this.pos++; // consume opening '
+        const startPos = this.pos;
+        // First pass: find end and check for escapes
+        let hasEscape = false;
+        let endPos = this.pos;
+        while (endPos < this.length) {
+            const ch = this.input.charCodeAt(endPos);
+            if (ch === 39) {
+                // Found closing '
+                break;
+            }
+            if (ch === 92) {
+                // Backslash - potential escape
+                hasEscape = true;
+                endPos += 2; // Skip backslash and next char
+            }
+            else {
+                endPos++;
+            }
+        }
+        if (endPos >= this.length) {
+            throw new UnterminatedTokenError(this.input, start, "raw string", "'");
+        }
+        const text = this.input.slice(start, endPos + 1);
+        let value = this.input.slice(startPos, endPos);
+        if (hasEscape) {
+            value = this.rawStringBackslashEscape
+                ? value.replace(/\\([\\'])/g, "$1")
+                : value.replace(/\\'/g, "'");
+        }
+        this.pos = endPos + 1;
+        return { type: 35 /* TokenType.RAW_STRING */, text, value, offset: start };
+    }
+    /**
+     * Scan backtick literal: `...`
+     * Extracts content between backticks, handles \` escape (JMESPath extension)
+     * Returns raw content for JSON.parse() in parser
+     */
+    scanBacktickLiteral(start) {
+        this.pos++; // consume opening `
+        const startPos = this.pos;
+        // Find end and handle \` escapes
+        let endPos = this.pos;
+        let hasEscape = false;
+        while (endPos < this.length) {
+            const ch = this.input.charCodeAt(endPos);
+            if (ch === 96) {
+                // A backtick is escaped only when preceded by an odd number of backslashes.
+                let slashCount = 0;
+                for (let i = endPos - 1; i >= startPos; i--) {
+                    if (this.input.charCodeAt(i) !== 92) {
+                        break;
                     }
+                    slashCount++;
                 }
-                delete(context, rootContext = context) {
-                    const arr = base.get(context, rootContext);
-                    if (isArray(arr)) {
-                        const index = findIdIndex(arr, id);
-                        if (index >= 0) {
-                            arr.splice(index, 1);
-                        }
-                    }
+                if (slashCount % 2 === 1) {
+                    hasEscape = true;
+                    endPos++;
+                    continue;
                 }
-            };
-            return new Accessor();
-        },
-        project(selector) {
-            const { expression, projection } = selector;
-            const base = makeAccessorInternal(expression, options);
-            const proj = !isIdentityProjection(projection)
-                ? makeAccessorInternal(projection, options)
-                : undefined;
-            const Accessor = class extends BaseAccessor {
-                constructor() {
-                    super(selector);
+                // Found closing `.
+                break;
+            }
+            endPos++;
+        }
+        if (endPos >= this.length) {
+            throw new UnterminatedTokenError(this.input, start, "JSON literal", "`");
+        }
+        const text = this.input.slice(start, endPos + 1);
+        let value = this.input.slice(startPos, endPos);
+        if (hasEscape) {
+            value = value.replace(/\\`/g, "`");
+        }
+        this.pos = endPos + 1;
+        return { type: 36 /* TokenType.BACKTICK_LITERAL */, text, value, offset: start };
+    }
+    /**
+     * Scan quoted string: "..."
+     * Handles standard JSON escapes plus backtick (\`)
+     */
+    scanQuotedString(start) {
+        this.pos++; // consume opening "
+        const end = this.scanQuotedStringEnd();
+        const text = this.input.slice(start, end);
+        this.pos = end;
+        // Parse escape sequences (including backtick which JSON.parse doesn't handle)
+        const inner = text.slice(1, -1); // remove quotes
+        let value = "";
+        let i = 0;
+        while (i < inner.length) {
+            if (inner[i] === "\\") {
+                // It's impossible to have a backslash at end due to scanQuotedStringEnd
+                const next = inner[i + 1];
+                if (next === "u") {
+                    // Unicode escape: \uXXXX (must have exactly 4 hex digits)
+                    const hex = inner.slice(i + 2, i + 6);
+                    if (/^[0-9a-fA-F]{4}$/.test(hex)) {
+                        value += String.fromCharCode(parseInt(hex, 16));
+                        i += 6;
+                    }
+                    else {
+                        throw new InvalidTokenError(this.input, start + 1 + i, "unicode escape", "expected 4 hexadecimal digits");
+                    }
                 }
-                isValidContext(context, rootContext = context) {
-                    const value = base.get(context, rootContext);
-                    return isArray(value);
+                else if (next in ESCAPE_CHARS) {
+                    value += ESCAPE_CHARS[next];
+                    i += 2;
                 }
-                get(context, rootContext = context) {
-                    const arr = base.get(context, rootContext);
-                    return project(arr, projection, Object.assign(Object.assign({}, options), { rootContext }));
+                else {
+                    // Unknown escape, keep both chars
+                    value += "\\" + next;
+                    i += 2;
                 }
-                set(value, context, rootContext = context) {
-                    const arr = base.get(context, rootContext);
-                    if (isArray(arr)) {
-                        if (proj) {
-                            for (const element of arr) {
-                                proj.set(value, element, rootContext);
-                            }
-                        }
-                        else {
-                            replaceArray(arr, asArray(value));
-                        }
-                    }
-                }
-                delete(context, rootContext = context) {
-                    const arr = base.get(context, rootContext);
-                    if (isArray(arr)) {
-                        if (proj) {
-                            for (const element of arr) {
-                                proj.delete(element, rootContext);
-                            }
-                        }
-                        else {
-                            arr.length = 0;
-                        }
-                    }
-                }
-            };
-            return new Accessor();
-        },
-        objectProject(selector) {
-            const { expression, projection } = selector;
-            const base = makeAccessorInternal(expression, options);
-            const proj = !isIdentityProjection(projection)
-                ? makeAccessorInternal(projection, options)
-                : undefined;
-            const Accessor = class extends BaseAccessor {
-                constructor() {
-                    super(selector);
-                }
-                isValidContext(context, rootContext = context) {
-                    const value = base.get(context, rootContext);
-                    return isObject(value);
-                }
-                get(context, rootContext = context) {
-                    const obj = base.get(context, rootContext);
-                    return objectProject(obj, projection, Object.assign(Object.assign({}, options), { rootContext }));
-                }
-                set(value, context, rootContext = context) {
-                    const obj = base.get(context, rootContext);
-                    if (isObject(obj)) {
-                        if (proj) {
-                            for (const v of Object.values(obj)) {
-                                proj.set(value, v, rootContext);
-                            }
-                        }
-                        else {
-                            for (const key of Object.keys(obj)) {
-                                obj[key] = value;
-                            }
-                        }
-                    }
-                }
-                delete(context, rootContext = context) {
-                    const obj = base.get(context, rootContext);
-                    if (isObject(obj)) {
-                        if (proj) {
-                            for (const v of Object.values(obj)) {
-                                proj.delete(v, rootContext);
-                            }
-                        }
-                        else {
-                            for (const key of Object.keys(obj)) {
-                                delete obj[key];
-                            }
-                        }
-                    }
-                }
-            };
-            return new Accessor();
-        },
-        filter(selector) {
-            const { expression, condition } = selector;
-            const base = makeAccessorInternal(expression, options);
-            const Accessor = class extends BaseAccessor {
-                constructor() {
-                    super(selector);
-                }
-                isValidContext(context, rootContext = context) {
-                    const value = base.get(context, rootContext);
-                    return isArray(value);
-                }
-                get(context, rootContext = context) {
-                    const arr = base.get(context, rootContext);
-                    return filter(arr, condition, Object.assign(Object.assign({}, options), { rootContext }));
-                }
-                set(value, context, rootContext = context) {
-                    const arr = base.get(context, rootContext);
-                    if (isArray(arr)) {
-                        replaceArray(arr, invertedFilter(arr, condition, Object.assign(Object.assign({}, options), { rootContext })).concat(asArray(value)));
-                    }
-                }
-                delete(context, rootContext = context) {
-                    const arr = base.get(context, rootContext);
-                    if (isArray(arr)) {
-                        replaceArray(arr, invertedFilter(arr, condition, Object.assign(Object.assign({}, options), { rootContext })));
-                    }
-                }
-            };
-            return new Accessor();
-        },
-        slice(selector) {
-            const { expression, start, end, step } = selector;
-            const base = makeAccessorInternal(expression, options);
-            const Accessor = class extends BaseAccessor {
-                constructor() {
-                    super(selector);
-                }
-                isValidContext(context, rootContext = context) {
-                    const value = base.get(context, rootContext);
-                    return isArray(value) || typeof value === "string";
-                }
-                get(context, rootContext = context) {
-                    const arr = base.get(context, rootContext);
-                    return slice(arr, start, end, step);
-                }
-                set(value, context, rootContext = context) {
-                    const arr = base.get(context, rootContext);
-                    if (isArray(arr)) {
-                        replaceArray(arr, invertedSlice(arr, start, end, step).concat(asArray(value)));
-                    }
-                }
-                delete(context, rootContext = context) {
-                    const arr = base.get(context, rootContext);
-                    if (isArray(arr)) {
-                        replaceArray(arr, invertedSlice(arr, start, end, step));
-                    }
-                }
-            };
-            return new Accessor();
-        },
-        flatten(selector) {
-            const { expression } = selector;
-            const base = makeAccessorInternal(expression, options);
-            const Accessor = class extends BaseAccessor {
-                constructor() {
-                    super(selector);
-                }
-                isValidContext(context, rootContext = context) {
-                    const value = base.get(context, rootContext);
-                    return isArray(value);
-                }
-                get(context, rootContext = context) {
-                    const arr = base.get(context, rootContext);
-                    return flatten(arr);
-                }
-                set(value, context, rootContext = context) {
-                    const arr = base.get(context, rootContext);
-                    if (isArray(arr)) {
-                        replaceArray(arr, asArray(value));
-                    }
-                }
-                delete(context, rootContext = context) {
-                    const arr = base.get(context, rootContext);
-                    if (isArray(arr)) {
-                        arr.length = 0;
-                    }
-                }
-            };
-            return new Accessor();
-        },
-        not(selector) {
-            const { expression } = selector;
-            const base = makeAccessorInternal(expression, options);
-            const Accessor = class extends ReadOnlyAccessor {
-                constructor() {
-                    super(selector);
-                }
-                get(context, rootContext = context) {
-                    const value = base.get(context, rootContext);
-                    return isFalseOrEmpty(value);
-                }
-            };
-            return new Accessor();
-        },
-        compare(selector) {
-            const { lhs, rhs, operator } = selector;
-            const la = makeAccessorInternal(lhs, options);
-            const ra = makeAccessorInternal(rhs, options);
-            const Accessor = class extends ReadOnlyAccessor {
-                constructor() {
-                    super(selector);
-                }
-                get(context, rootContext = context) {
-                    const lv = la.get(context, rootContext);
-                    const rv = ra.get(context, rootContext);
-                    return compare(lv, rv, operator);
-                }
-            };
-            return new Accessor();
-        },
-        arithmetic(selector) {
-            const la = makeAccessorInternal(selector.lhs, options);
-            const ra = makeAccessorInternal(selector.rhs, options);
-            const Accessor = class extends ReadOnlyAccessor {
-                constructor() {
-                    super(selector);
-                }
-                get(context, rootContext = context) {
-                    return performArithmetic(la.get(context, rootContext), ra.get(context, rootContext), selector.operator);
-                }
-            };
-            return new Accessor();
-        },
-        unaryArithmetic(selector) {
-            const base = makeAccessorInternal(selector.expression, options);
-            const Accessor = class extends ReadOnlyAccessor {
-                constructor() {
-                    super(selector);
-                }
-                get(context, rootContext = context) {
-                    return performUnaryArithmetic(base.get(context, rootContext), selector.operator);
-                }
-            };
-            return new Accessor();
-        },
-        and(selector) {
-            const { lhs, rhs } = selector;
-            const la = makeAccessorInternal(lhs, options);
-            const ra = makeAccessorInternal(rhs, options);
-            const Accessor = class extends ReadOnlyAccessor {
-                constructor() {
-                    super(selector);
-                }
-                get(context, rootContext = context) {
-                    const lv = la.get(context, rootContext);
-                    return isFalseOrEmpty(lv) ? lv : ra.get(context, rootContext);
-                }
-            };
-            return new Accessor();
-        },
-        or(selector) {
-            const { lhs, rhs } = selector;
-            const la = makeAccessorInternal(lhs, options);
-            const ra = makeAccessorInternal(rhs, options);
-            const Accessor = class extends ReadOnlyAccessor {
-                constructor() {
-                    super(selector);
-                }
-                get(context, rootContext = context) {
-                    const lv = la.get(context, rootContext);
-                    return !isFalseOrEmpty(lv) ? lv : ra.get(context, rootContext);
-                }
-            };
-            return new Accessor();
-        },
-        ternary(selector) {
-            const { condition, consequent, alternate } = selector;
-            const ca = makeAccessorInternal(condition, options);
-            const ta = makeAccessorInternal(consequent, options);
-            const aa = makeAccessorInternal(alternate, options);
-            const Accessor = class extends ReadOnlyAccessor {
-                constructor() {
-                    super(selector);
-                }
-                get(context, rootContext = context) {
-                    const cv = ca.get(context, rootContext);
-                    return isFalseOrEmpty(cv)
-                        ? aa.get(context, rootContext)
-                        : ta.get(context, rootContext);
-                }
-            };
-            return new Accessor();
-        },
-        pipe(selector) {
-            const { lhs, rhs } = selector;
-            const la = makeAccessorInternal(lhs, options);
-            const ra = makeAccessorInternal(rhs, options);
-            const Accessor = class extends BaseAccessor {
-                constructor() {
-                    super(selector);
-                }
-                isValidContext(context, rootContext = context) {
-                    const lv = la.get(context, rootContext);
-                    return ra.isValidContext(lv, rootContext);
-                }
-                get(context, rootContext = context) {
-                    const lv = la.get(context, rootContext);
-                    return ra.get(lv, rootContext);
-                }
-                set(value, context, rootContext = context) {
-                    const lv = la.get(context, rootContext);
-                    ra.set(value, lv, rootContext);
-                }
-                delete(context, rootContext = context) {
-                    const lv = la.get(context, rootContext);
-                    ra.delete(lv, rootContext);
-                }
-            };
-            return new Accessor();
-        },
-        functionCall(selector) {
-            return new EvaluateAccessor(selector, options);
-        },
-        expressionRef(selector) {
-            // Expression references are only meaningful as function arguments
-            return new ConstantAccessor(selector, null);
-        },
-        variableRef(selector) {
-            return new EvaluateAccessor(selector, options);
-        },
-        let(selector) {
-            return new EvaluateAccessor(selector, options);
-        },
-        multiSelectList(selector) {
-            const { expressions } = selector;
-            const accessors = expressions.map((e) => makeAccessorInternal(e, options));
-            const Accessor = class extends ReadOnlyAccessor {
-                constructor() {
-                    super(selector);
-                }
-                get(context, rootContext = context) {
-                    if (context == null) {
-                        return null;
-                    }
-                    return accessors.map((a) => a.get(context, rootContext));
-                }
-            };
-            return new Accessor();
-        },
-        multiSelectHash(selector) {
-            const { entries } = selector;
-            const entryAccessors = entries.map(({ key, value }) => ({
-                key,
-                accessor: makeAccessorInternal(value, options),
-            }));
-            const Accessor = class extends ReadOnlyAccessor {
-                constructor() {
-                    super(selector);
-                }
-                get(context, rootContext = context) {
-                    if (context == null) {
-                        return null;
-                    }
-                    const result = {};
-                    for (const { key, accessor } of entryAccessors) {
-                        result[key] = accessor.get(context, rootContext);
-                    }
-                    return result;
-                }
-            };
-            return new Accessor();
-        },
-    }, undefined);
+            }
+            else {
+                value += inner[i];
+                i++;
+            }
+        }
+        return { type: 34 /* TokenType.QUOTED_STRING */, text, value, offset: start };
+    }
+    /**
+     * Find end of quoted string (handles escape sequences)
+     * Rejects unescaped backticks (not valid in JSON strings)
+     */
+    scanQuotedStringEnd() {
+        let pos = this.pos;
+        while (pos < this.length) {
+            const ch = this.input.charCodeAt(pos);
+            if (ch === 34) {
+                // closing "
+                return pos + 1;
+            }
+            if (ch === 96) {
+                // unescaped backtick - not allowed in quoted strings
+                throw new InvalidTokenError(this.input, pos, "backtick in string", "unescaped backtick");
+            }
+            if (ch === 92) {
+                // backslash (escape)
+                pos += 2; // skip backslash and next char
+            }
+            else {
+                pos++;
+            }
+        }
+        throw new UnterminatedTokenError(this.input, this.pos - 1, "string", '"');
+    }
+    /**
+     * Scan number: [0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?
+     */
+    scanNumber(start) {
+        var _a;
+        let ch = this.peekCharCode();
+        // Leading zero or digits
+        if (ch === 48) {
+            ch = this.advanceCharCode();
+        }
+        else {
+            // 1-9 followed by any digits
+            while (isDigit(ch)) {
+                ch = this.advanceCharCode();
+            }
+        }
+        // Optional decimal part
+        if (ch === 46 && // .
+            this.pos + 1 < this.length &&
+            isDigit(this.input.charCodeAt(this.pos + 1))) {
+            ch = this.advanceCharCode();
+            while (isDigit(ch)) {
+                ch = this.advanceCharCode();
+            }
+        }
+        // Optional exponent part: e or E
+        if (ch === 101 || ch === 69) {
+            ch = this.advanceCharCode();
+            // Optional sign: + or -
+            if (ch === 43 || ch === 45) {
+                ch = this.advanceCharCode();
+            }
+            // Exponent digits
+            if (!isDigit(ch)) {
+                const digit = (_a = this.input[this.pos]) !== null && _a !== void 0 ? _a : EOF_DESCRIPTION;
+                throw new InvalidTokenError(this.input, start, "number", `invalid exponent: ${digit}`);
+            }
+            while (isDigit(ch)) {
+                ch = this.advanceCharCode();
+            }
+        }
+        const text = this.input.slice(start, this.pos);
+        return {
+            type: 37 /* TokenType.NUMBER */,
+            text,
+            value: parseFloat(text),
+            offset: start,
+        };
+    }
+    /**
+     * Scan variable: $[a-zA-Z_][a-zA-Z0-9_]*
+     */
+    scanVariable(start) {
+        // Start is at "$". Consume first variable-name character.
+        let ch = this.advanceCharCode();
+        while (isIdentChar(ch)) {
+            ch = this.advanceCharCode();
+        }
+        const text = this.input.slice(start, this.pos);
+        return {
+            type: 41 /* TokenType.VARIABLE */,
+            text,
+            value: text.slice(1),
+            offset: start,
+        };
+    }
+    /**
+     * Scan identifier or keyword: [a-zA-Z_][a-zA-Z0-9_]*
+     */
+    scanIdentifier(start) {
+        let ch = this.advanceCharCode();
+        while (isIdentChar(ch)) {
+            ch = this.advanceCharCode();
+        }
+        const text = this.input.slice(start, this.pos);
+        // Check for keywords
+        const keywordType = KEYWORDS[text];
+        if (keywordType !== undefined) {
+            // Return keyword token with appropriate value
+            if (keywordType === 38 /* TokenType.NULL */) {
+                return {
+                    type: 38 /* TokenType.NULL */,
+                    text: "null",
+                    value: null,
+                    offset: start,
+                };
+            }
+            else if (keywordType === 39 /* TokenType.TRUE */) {
+                return {
+                    type: 39 /* TokenType.TRUE */,
+                    text: "true",
+                    value: true,
+                    offset: start,
+                };
+            }
+            else {
+                return {
+                    type: 40 /* TokenType.FALSE */,
+                    text: "false",
+                    value: false,
+                    offset: start,
+                };
+            }
+        }
+        return { type: 33 /* TokenType.IDENTIFIER */, text, value: text, offset: start };
+    }
+    peekCharCode(pos = this.pos) {
+        return pos < this.length ? this.input.charCodeAt(pos) : -1;
+    }
+    advanceCharCode() {
+        return this.peekCharCode(++this.pos);
+    }
+}
+function isWhitespace(ch) {
+    return ch === 32 || ch === 9 || ch === 10 || ch === 13; // space, tab, newline, carriage return
 }
-/** Binds an {@link UnboundAccessor} to a specific context and root, producing a ready-to-use {@link Accessor}. */
-function bindJsonSelectorAccessor(unbound, context, rootContext = context) {
-    const { selector } = unbound;
-    const valid = unbound.isValidContext(context, rootContext);
-    return {
-        selector,
-        valid,
-        path: formatJsonSelector(selector),
-        get() {
-            return unbound.get(context, rootContext);
-        },
-        set(value) {
-            unbound.set(value, context, rootContext);
-        },
-        delete() {
-            unbound.delete(context, rootContext);
-        },
-    };
+function isDigit(ch) {
+    return ch >= 48 && ch <= 57; // 0-9
 }
-/** One-step convenience: parses a selector into an accessor already bound to the given context. */
-function accessWithJsonSelector(selector, context, rootContext = context, options) {
-    return bindJsonSelectorAccessor(makeJsonSelectorAccessor(selector, options), context, rootContext);
+function isIdentStart(ch) {
+    return ((ch >= 65 && ch <= 90) || // A-Z
+        (ch >= 97 && ch <= 122) || // a-z
+        ch === 95 // _
+    );
+}
+function isIdentChar(ch) {
+    return ((ch >= 48 && ch <= 57) || // 0-9
+        (ch >= 65 && ch <= 90) || // A-Z
+        (ch >= 97 && ch <= 122) || // a-z
+        ch === 95 // _
+    );
 }
 
+// Pre-computed singleton AST nodes
+const CURRENT_NODE = Object.freeze({
+    type: "current",
+});
+const ROOT_NODE = Object.freeze({
+    type: "root",
+});
+// Binding power constants (higher = tighter binding)
+const BP_PIPE = 1;
+const BP_TERNARY = 2;
+const BP_OR = 3;
+const BP_AND = 4;
+const BP_COMPARE = 5;
+const BP_ADD = 6;
+const BP_MUL = 7;
+const BP_FLATTEN = 9;
+const BP_FILTER = 21;
+const BP_DOT = 40;
+const BP_NOT = 45;
+const BP_BRACKET = 55;
+// Projection stop threshold: operators below this terminate projections
+// Separates terminators (pipe, ternary, or, and, comparisons) from continuators (dot, brackets)
+const PROJECTION_STOP_BP = 10;
+// Binding power table (higher = tighter binding)
+// Use array indexed by TokenType for fast lookup
+const TOKEN_BP = (() => {
+    const bp = new Array(TOKEN_LIMIT).fill(0);
+    // Terminators (lowest precedence) - already 0
+    // TokenType.RPAREN, RBRACKET, RBRACE, COMMA - all 0
+    // Binary operators (low to high)
+    bp[10 /* TokenType.PIPE */] = BP_PIPE; // |
+    bp[29 /* TokenType.QUESTION */] = BP_TERNARY; // ?:
+    bp[11 /* TokenType.OR */] = BP_OR; // ||
+    bp[12 /* TokenType.AND */] = BP_AND; // &&
+    // Comparison operators (all same precedence - non-associative, cannot chain)
+    bp[14 /* TokenType.EQ */] = BP_COMPARE; // ==
+    bp[15 /* TokenType.NEQ */] = BP_COMPARE; // !=
+    bp[16 /* TokenType.LT */] = BP_COMPARE; // <
+    bp[17 /* TokenType.LTE */] = BP_COMPARE; // <=
+    bp[18 /* TokenType.GT */] = BP_COMPARE; // >
+    bp[19 /* TokenType.GTE */] = BP_COMPARE; // >=
+    bp[20 /* TokenType.PLUS */] = BP_ADD; // +
+    bp[21 /* TokenType.MINUS */] = BP_ADD; // -
+    bp[28 /* TokenType.STAR */] = BP_MUL; // * (multiplication in led context)
+    bp[22 /* TokenType.MULTIPLY */] = BP_MUL; // ×
+    bp[23 /* TokenType.DIVIDE */] = BP_MUL; // /, ÷
+    bp[24 /* TokenType.MODULO */] = BP_MUL; // %
+    bp[25 /* TokenType.INT_DIVIDE */] = BP_MUL; // //
+    // Projection operators
+    // flatten has lower bp (9) than star/filter to allow chaining: foo[*][] or foo[?x][].bar
+    bp[32 /* TokenType.FLATTEN_BRACKET */] = BP_FLATTEN; // []
+    bp[31 /* TokenType.FILTER_BRACKET */] = BP_FILTER; // [?...]
+    // Postfix operators (high precedence)
+    bp[7 /* TokenType.DOT */] = BP_DOT; // .
+    // Prefix operators
+    bp[13 /* TokenType.NOT */] = BP_NOT; // !
+    // Bracket access (highest)
+    bp[3 /* TokenType.LBRACKET */] = BP_BRACKET; // [n], ['id'], [n:], etc.
+    return bp;
+})();
 /**
- * Read-only {@link Map} view that layers a primary map over an optional fallback,
- * with primary entries taking precedence on key collisions.
+ * Hand-written parser for JSON Selectors.
+ *
+ * Uses precedence-climbing (Pratt parsing) with binding power (0-55 range) to handle
+ * operator precedence efficiently. The parser uses two main methods:
+ * - nud() for prefix/primary expressions (no left context)
+ * - led() for infix/postfix operators (with left context)
  */
-class FallbackMapView {
-    constructor(primary, fallback) {
-        this.primary = primary;
-        this.fallback = fallback;
+class Parser {
+    constructor(input, options) {
+        this.input = input;
+        this.lexer = new Lexer(input, {
+            rawStringBackslashEscape: options === null || options === void 0 ? void 0 : options.rawStringBackslashEscape,
+        });
+        this.strictJsonLiterals = (options === null || options === void 0 ? void 0 : options.strictJsonLiterals) === true;
     }
-    get(name) {
-        var _a, _b;
-        return (_a = this.primary.get(name)) !== null && _a !== void 0 ? _a : (_b = this.fallback) === null || _b === void 0 ? void 0 : _b.get(name);
+    /**
+     * Main entry point: parse a complete expression
+     */
+    parse() {
+        const result = this.expression(0);
+        const token = this.lexer.peek();
+        if (token.type !== 0 /* TokenType.EOF */) {
+            throw this.unexpectedToken(token, EOF_DESCRIPTION);
+        }
+        return result;
     }
-    has(name) {
-        var _a;
-        return this.primary.has(name) || ((_a = this.fallback) === null || _a === void 0 ? void 0 : _a.has(name)) === true;
+    /**
+     * Core Pratt parser: expression parsing with binding power
+     *
+     * @param rbp Right binding power - controls when to stop parsing
+     * @returns Parsed expression node
+     */
+    expression(rbp) {
+        return this.expressionFrom(this.nud(), rbp);
     }
-    get size() {
-        let result = this.primary.size;
-        if (this.fallback) {
-            for (const k of this.fallback.keys()) {
-                if (!this.primary.has(k)) {
-                    ++result;
+    /**
+     * Continue Pratt parsing from a given left-hand side node.
+     * Applies led (left denotation) operators while their binding power exceeds rbp.
+     */
+    expressionFrom(left, rbp) {
+        let current = left;
+        let token = this.lexer.peek();
+        while (token.type !== 0 /* TokenType.EOF */ && rbp < TOKEN_BP[token.type]) {
+            current = this.led(current, token);
+            token = this.lexer.peek();
+        }
+        return current;
+    }
+    /**
+     * NUD (Null Denotation): Handle prefix operators and primary expressions
+     * Called when we don't have a left-hand side yet
+     */
+    nud() {
+        const token = this.lexer.peek();
+        if (token.type === 0 /* TokenType.EOF */) {
+            throw new UnexpectedEndOfInputError(this.input);
+        }
+        switch (token.type) {
+            // Hot path: field names (most common) or function calls
+            case 33 /* TokenType.IDENTIFIER */: {
+                this.lexer.advance();
+                // Check if this is a function call (identifier followed by `(`)
+                if (this.lexer.peek().type === 1 /* TokenType.LPAREN */) {
+                    return this.parseFunctionCall(token.value);
+                }
+                // Contextual keyword: let expressions
+                if (token.value === "let" &&
+                    this.lexer.peek().type === 41 /* TokenType.VARIABLE */) {
+                    return this.parseLetExpression();
+                }
+                return { type: "identifier", id: token.value };
+            }
+            case 34 /* TokenType.QUOTED_STRING */:
+                this.lexer.advance();
+                return { type: "identifier", id: token.value };
+            case 26 /* TokenType.AT */:
+                this.lexer.advance();
+                return { type: "current", explicit: true };
+            case 3 /* TokenType.LBRACKET */:
+                return this.parseBracketExpression();
+            case 32 /* TokenType.FLATTEN_BRACKET */: {
+                // Leading [] applies to @
+                this.lexer.consume(32 /* TokenType.FLATTEN_BRACKET */);
+                const flattenNode = {
+                    type: "flatten",
+                    expression: CURRENT_NODE,
+                };
+                return this.parseProjectionRHS(flattenNode);
+            }
+            case 31 /* TokenType.FILTER_BRACKET */:
+                return this.parseFilterExpression();
+            case 27 /* TokenType.DOLLAR */:
+                this.lexer.advance();
+                return ROOT_NODE;
+            case 41 /* TokenType.VARIABLE */:
+                this.lexer.advance();
+                return { type: "variableRef", name: token.value };
+            case 35 /* TokenType.RAW_STRING */:
+            case 39 /* TokenType.TRUE */:
+            case 40 /* TokenType.FALSE */:
+            case 38 /* TokenType.NULL */:
+            case 37 /* TokenType.NUMBER */:
+                this.lexer.advance();
+                return { type: "literal", value: token.value };
+            case 36 /* TokenType.BACKTICK_LITERAL */: {
+                this.lexer.advance();
+                const content = trimJsonWhitespace(token.value);
+                try {
+                    // Type assertion is safe as JSON.parse returns a JsonValue
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    const value = JSON.parse(content);
+                    return { type: "literal", value, backtickSyntax: true };
+                }
+                catch (_a) {
+                    if (this.strictJsonLiterals) {
+                        throw new InvalidTokenError(this.input, token.offset, "JSON literal", "expected valid JSON content between backticks");
+                    }
+                    return {
+                        type: "literal",
+                        value: content.replace(/\\"/g, '"'),
+                        backtickSyntax: true,
+                    };
                 }
             }
-        }
-        return result;
-    }
-    *entries() {
-        for (const [k, v] of this.primary) {
-            yield [k, v];
-        }
-        if (this.fallback) {
-            for (const [k, v] of this.fallback) {
-                if (!this.primary.has(k)) {
-                    yield [k, v];
-                }
+            case 13 /* TokenType.NOT */:
+                this.lexer.advance();
+                return {
+                    type: "not",
+                    expression: this.expression(BP_NOT),
+                };
+            case 20 /* TokenType.PLUS */:
+                this.lexer.advance();
+                return this.foldUnaryArithmeticLiteral("+", this.expression(BP_ADD));
+            case 21 /* TokenType.MINUS */:
+                this.lexer.advance();
+                return this.foldUnaryArithmeticLiteral("-", this.expression(BP_ADD));
+            case 1 /* TokenType.LPAREN */: {
+                this.lexer.advance();
+                const expr = this.expression(0);
+                this.lexer.consume(2 /* TokenType.RPAREN */);
+                return expr;
+            }
+            case 5 /* TokenType.LBRACE */:
+                // Multi-select hash: {a: x, b: y}
+                return this.parseMultiSelectHash();
+            case 28 /* TokenType.STAR */: {
+                // Root object projection: * or *.foo
+                this.lexer.advance();
+                return this.parseObjectProjection(CURRENT_NODE);
+            }
+            case 30 /* TokenType.AMPERSAND */: {
+                // Expression reference: &expr (for sort_by, max_by, etc.)
+                // Use binding power 0 to capture the full expression (up to comma or closing bracket)
+                this.lexer.advance();
+                return {
+                    type: "expressionRef",
+                    expression: this.expression(0),
+                };
             }
+            default:
+                throw this.unexpectedToken(token, "expression");
         }
     }
-    *keys() {
-        for (const [k] of this.entries()) {
-            yield k;
-        }
-    }
-    *values() {
-        for (const [, v] of this.entries()) {
-            yield v;
-        }
-    }
-    [Symbol.iterator]() {
-        return this.entries();
-    }
-    forEach(callbackfn, thisArg) {
-        for (const [k, v] of this.entries()) {
-            callbackfn.call(thisArg, v, k, this);
-        }
-    }
-}
-
-/**
- * Function registry for built-in and custom functions.
- * Pass `null` as the base provider to omit built-in functions.
- */
-class FunctionRegistry extends FallbackMapView {
-    constructor(baseProvider = getBuiltinFunctionProvider()) {
-        const custom = new Map();
-        super(custom, baseProvider !== null && baseProvider !== void 0 ? baseProvider : undefined);
-        this.custom = custom;
-    }
-    /**
-     * Register a custom function (can override built-ins).
-     */
-    register(def) {
-        this.custom.set(def.name, def);
-    }
     /**
-     * Unregister a custom function.
+     * LED (Left Denotation): Handle infix and postfix operators
+     * Called when we have a left-hand side
      */
-    unregister(name) {
-        return this.custom.delete(name);
-    }
-}
-
-/** Evaluates a selector against a context and returns the selected value (read-only convenience wrapper). */
-function getWithJsonSelector(selector, context, options) {
-    return accessWithJsonSelector(selector, context, context, options).get();
-}
-
-const TOKEN_LIMIT = 42 /* TokenType.ASSIGN */ + 1;
-const EOF_DESCRIPTION = "end of input";
-const TOKEN_DESCRIPTIONS = {
-    [0 /* TokenType.EOF */]: EOF_DESCRIPTION,
-    [1 /* TokenType.LPAREN */]: "'('",
-    [2 /* TokenType.RPAREN */]: "')'",
-    [3 /* TokenType.LBRACKET */]: "'['",
-    [4 /* TokenType.RBRACKET */]: "']'",
-    [5 /* TokenType.LBRACE */]: "'{'",
-    [6 /* TokenType.RBRACE */]: "'}'",
-    [7 /* TokenType.DOT */]: "'.'",
-    [8 /* TokenType.COMMA */]: "','",
-    [9 /* TokenType.COLON */]: "':'",
-    [10 /* TokenType.PIPE */]: "'|'",
-    [11 /* TokenType.OR */]: "'||'",
-    [12 /* TokenType.AND */]: "'&&'",
-    [13 /* TokenType.NOT */]: "'!'",
-    [14 /* TokenType.EQ */]: "'=='",
-    [15 /* TokenType.NEQ */]: "'!='",
-    [16 /* TokenType.LT */]: "'<'",
-    [17 /* TokenType.LTE */]: "'<='",
-    [18 /* TokenType.GT */]: "'>'",
-    [19 /* TokenType.GTE */]: "'>='",
-    [20 /* TokenType.PLUS */]: "'+'",
-    [21 /* TokenType.MINUS */]: "'-'",
-    [22 /* TokenType.MULTIPLY */]: "'\u00D7'",
-    [23 /* TokenType.DIVIDE */]: "'/'",
-    [24 /* TokenType.MODULO */]: "'%'",
-    [25 /* TokenType.INT_DIVIDE */]: "'//'",
-    [26 /* TokenType.AT */]: "'@'",
-    [27 /* TokenType.DOLLAR */]: "'$'",
-    [28 /* TokenType.STAR */]: "'*'",
-    [29 /* TokenType.QUESTION */]: "'?'",
-    [30 /* TokenType.AMPERSAND */]: "'&'",
-    [31 /* TokenType.FILTER_BRACKET */]: "'[?'",
-    [32 /* TokenType.FLATTEN_BRACKET */]: "'[]'",
-    [33 /* TokenType.IDENTIFIER */]: "identifier",
-    [34 /* TokenType.QUOTED_STRING */]: "quoted string",
-    [35 /* TokenType.RAW_STRING */]: "raw string",
-    [36 /* TokenType.BACKTICK_LITERAL */]: "backtick literal",
-    [37 /* TokenType.NUMBER */]: "number",
-    [38 /* TokenType.NULL */]: "'null'",
-    [39 /* TokenType.TRUE */]: "'true'",
-    [40 /* TokenType.FALSE */]: "'false'",
-    [41 /* TokenType.VARIABLE */]: "variable",
-    [42 /* TokenType.ASSIGN */]: "'='",
-};
-function describeTokenType(type) {
-    var _a;
-    return (_a = TOKEN_DESCRIPTIONS[type]) !== null && _a !== void 0 ? _a : `unknown token ${type}`;
-}
-
-const KEYWORDS = {
-    null: 38 /* TokenType.NULL */,
-    true: 39 /* TokenType.TRUE */,
-    false: 40 /* TokenType.FALSE */,
-};
-// Escape sequence lookup for quoted strings
-const ESCAPE_CHARS = {
-    '"': '"',
-    "\\": "\\",
-    "/": "/",
-    b: "\b",
-    f: "\f",
-    n: "\n",
-    r: "\r",
-    t: "\t",
-    "`": "`",
-};
-/**
- * Hand-written lexer for JSON Selector expressions providing single token
- * lookahead.
- */
-class Lexer {
-    constructor(input, options) {
-        var _a;
-        this.pos = 0;
-        this.input = input;
-        this.length = input.length;
-        this.rawStringBackslashEscape = (_a = options === null || options === void 0 ? void 0 : options.rawStringBackslashEscape) !== null && _a !== void 0 ? _a : true;
-        this.current = this.scanNext();
+    led(left, token) {
+        switch (token.type) {
+            // Hot path: field access (most common!)
+            case 7 /* TokenType.DOT */: {
+                this.lexer.advance();
+                const nextToken = this.lexer.peek();
+                // Object projection: foo.*
+                if (nextToken.type === 28 /* TokenType.STAR */) {
+                    this.lexer.advance();
+                    return this.parseObjectProjection(left);
+                }
+                // Multi-select hash: foo.{a: x, b: y}
+                if (nextToken.type === 5 /* TokenType.LBRACE */) {
+                    const multiSelectHash = this.parseMultiSelectHash();
+                    return {
+                        type: "pipe",
+                        lhs: left,
+                        rhs: multiSelectHash,
+                        dotSyntax: true,
+                    };
+                }
+                // Multi-select list: foo.[a, b]
+                if (nextToken.type === 3 /* TokenType.LBRACKET */) {
+                    return this.parseDotBracket(left);
+                }
+                // Standard field access or function call
+                const field = this.parseIdentifier();
+                // Check if this is a function call: foo.func(args)
+                // This is equivalent to: foo | func(args)
+                if (this.lexer.peek().type === 1 /* TokenType.LPAREN */) {
+                    const funcCall = this.parseFunctionCall(field);
+                    return {
+                        type: "pipe",
+                        lhs: left,
+                        rhs: funcCall,
+                        dotSyntax: true,
+                    };
+                }
+                return { type: "fieldAccess", expression: left, field };
+            }
+            case 3 /* TokenType.LBRACKET */:
+                return this.parseBracketExpression(left);
+            case 32 /* TokenType.FLATTEN_BRACKET */: {
+                this.lexer.consume(32 /* TokenType.FLATTEN_BRACKET */);
+                const flattenNode = {
+                    type: "flatten",
+                    expression: left,
+                };
+                return this.parseProjectionRHS(flattenNode);
+            }
+            case 31 /* TokenType.FILTER_BRACKET */:
+                return this.parseFilterExpression(left);
+            case 10 /* TokenType.PIPE */:
+                this.lexer.advance();
+                return {
+                    type: "pipe",
+                    lhs: left,
+                    rhs: this.expression(BP_PIPE),
+                };
+            case 12 /* TokenType.AND */:
+                this.lexer.advance();
+                return {
+                    type: "and",
+                    lhs: left,
+                    rhs: this.expression(BP_AND),
+                };
+            case 11 /* TokenType.OR */:
+                this.lexer.advance();
+                return {
+                    type: "or",
+                    lhs: left,
+                    rhs: this.expression(BP_OR),
+                };
+            case 20 /* TokenType.PLUS */:
+                return this.parseArithmetic(left, "+", BP_ADD);
+            case 21 /* TokenType.MINUS */:
+                return this.parseArithmetic(left, "-", BP_ADD);
+            case 28 /* TokenType.STAR */:
+            case 22 /* TokenType.MULTIPLY */:
+                return this.parseArithmetic(left, "*", BP_MUL);
+            case 23 /* TokenType.DIVIDE */:
+                return this.parseArithmetic(left, "/", BP_MUL);
+            case 24 /* TokenType.MODULO */:
+                return this.parseArithmetic(left, "%", BP_MUL);
+            case 25 /* TokenType.INT_DIVIDE */:
+                return this.parseArithmetic(left, "//", BP_MUL);
+            case 29 /* TokenType.QUESTION */: {
+                this.lexer.advance();
+                const consequent = this.expression(0);
+                this.lexer.consume(9 /* TokenType.COLON */);
+                return {
+                    type: "ternary",
+                    condition: left,
+                    consequent,
+                    // NOTE: This differs from jmespath-community/typescript-jmespath, which
+                    // parses the false branch with expression(0).
+                    //
+                    // We intentionally parse with BP_TERNARY - 1 so the current ternary keeps
+                    // ownership of lower-precedence operators like pipe. This yields:
+                    //   a ? b : c | d  =>  (a ? b : c) | d
+                    //
+                    // This follows JEP-21 exactly:
+                    // - "higher precedence than the `|` pipe expression and lower precedence
+                    //   than the `||` and `&&` logical expressions"
+                    // - "Expressions within a ternary conditional expression are evaluated
+                    //   using a right-associative reading."
+                    // Spec: https://github.com/jmespath-community/jmespath.spec/blob/main/jep-0021-ternary-conditionals.md
+                    alternate: this.expression(BP_TERNARY - 1),
+                };
+            }
+            case 14 /* TokenType.EQ */:
+                return this.parseCompare(left, "==");
+            case 15 /* TokenType.NEQ */:
+                return this.parseCompare(left, "!=");
+            case 16 /* TokenType.LT */:
+                return this.parseCompare(left, "<");
+            case 17 /* TokenType.LTE */:
+                return this.parseCompare(left, "<=");
+            case 18 /* TokenType.GT */:
+                return this.parseCompare(left, ">");
+            case 19 /* TokenType.GTE */:
+                return this.parseCompare(left, ">=");
+            default:
+                throw this.unexpectedToken(token);
+        }
     }
     /**
-     * Peek at current token without consuming.
+     * Parse lexical scope expression:
+     *   let $a = expr, $b = expr in body
+     *
+     * Called after consuming contextual "let".
      */
-    peek() {
-        return this.current;
+    parseLetExpression() {
+        const bindings = [];
+        do {
+            const variable = this.lexer.consume(41 /* TokenType.VARIABLE */);
+            this.lexer.consume(42 /* TokenType.ASSIGN */);
+            bindings.push({
+                name: variable.value,
+                value: this.expression(0),
+            });
+        } while (this.lexer.tryConsume(8 /* TokenType.COMMA */));
+        const token = this.lexer.peek();
+        if (token.type !== 33 /* TokenType.IDENTIFIER */ || token.value !== "in") {
+            throw this.unexpectedToken(token, "'in'", "after let bindings");
+        }
+        this.lexer.advance();
+        return {
+            type: "let",
+            bindings,
+            expression: this.expression(0),
+        };
     }
-    /**
-     * Advance to next token and return it.
-     */
-    advance() {
-        this.current = this.scanNext();
-        return this.current;
+    parseCompare(left, operator) {
+        this.lexer.advance();
+        return {
+            type: "compare",
+            operator,
+            lhs: left,
+            rhs: this.expression(BP_COMPARE),
+        };
     }
-    /**
-     * Consume current token if it matches type, throw otherwise.
-     */
-    consume(type) {
-        const token = this.peek();
-        if (token.type !== type) {
-            const expected = describeTokenType(type);
-            const actual = token.text || describeTokenType(token.type);
-            throw new UnexpectedTokenError(this.input, token.offset, actual, expected);
-        }
-        this.advance();
-        // Type assertion is safe due to the type check above
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        return token;
+    parseArithmetic(left, operator, bp) {
+        this.lexer.advance();
+        return {
+            type: "arithmetic",
+            operator,
+            lhs: left,
+            rhs: this.expression(bp),
+        };
     }
-    /**
-     * Try to consume token if it matches type, return null otherwise.
-     */
-    tryConsume(type) {
-        const token = this.peek();
-        if (token.type !== type) {
-            return null;
+    foldUnaryArithmeticLiteral(operator, expression) {
+        if (expression.type === "literal" && typeof expression.value === "number") {
+            const value = operator === "+" ? expression.value : -expression.value;
+            return Object.assign({ type: "literal", value }, (expression.backtickSyntax !== undefined && {
+                backtickSyntax: expression.backtickSyntax,
+            }));
         }
-        this.advance();
-        // Type assertion is safe due to the type check above
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        return token;
+        return {
+            type: "unaryArithmetic",
+            operator,
+            expression,
+        };
     }
     /**
-     * Get next token (EOF token at end of input)
+     * Parse bracket expression: foo[0], foo[:], foo[*], foo['id']
+     * Also handles leading brackets (no LHS): [0], [:], [*], ['id']
+     *
+     * When a bracket appears at the start of an expression or after an operator,
+     * it implicitly applies to @ (current context). For example:
+     * - `[0]` means `@[0]`
+     * - `foo | [*]` means `foo | @[*]`
+     *
+     * Note: foo[] (flatten) is handled separately via FLATTEN_BRACKET token in led()
      */
-    scanNext() {
-        let ch = this.peekCharCode();
-        while (isWhitespace(ch)) {
-            ch = this.advanceCharCode();
-        }
-        const start = this.pos;
-        let singleType = 0;
-        switch (ch) {
-            // End of input
-            case -1:
-                return { type: 0 /* TokenType.EOF */, text: "", offset: this.length };
-            // Multi-character scanner entry points
-            case 91: // [
-                return this.scanBracket(start);
-            case 124: // |
-                return this.scanPipe(start);
-            case 33: // !
-                return this.scanBang(start);
-            case 60: // <
-                return this.scanLessThan(start);
-            case 62: // >
-                return this.scanGreaterThan(start);
-            case 61: // =
-                return this.scanEquals(start);
-            case 38: // &
-                return this.scanAmpersand(start);
-            case 47: // /
-                return this.scanSlash(start);
-            // String/literal openers
-            case 34: // "
-                return this.scanQuotedString(start);
-            case 39: // '
-                return this.scanRawString(start);
-            case 96: // `
-                return this.scanBacktickLiteral(start);
-            // Arithmetic operators (including Unicode aliases)
-            case 43: // +
-                singleType = 20 /* TokenType.PLUS */;
-                break;
-            case 45: // -
-                singleType = 21 /* TokenType.MINUS */;
-                break;
-            case 0x2212: // −
-                singleType = 21 /* TokenType.MINUS */;
-                break;
-            case 42: // *
-                singleType = 28 /* TokenType.STAR */;
-                break;
-            case 0x00d7: // ×
-                singleType = 22 /* TokenType.MULTIPLY */;
-                break;
-            case 37: // %
-                singleType = 24 /* TokenType.MODULO */;
-                break;
-            case 0x00f7: // ÷
-                singleType = 23 /* TokenType.DIVIDE */;
-                break;
-            // Delimiters and punctuation
-            case 40: // (
-                singleType = 1 /* TokenType.LPAREN */;
-                break;
-            case 41: // )
-                singleType = 2 /* TokenType.RPAREN */;
-                break;
-            case 93: // ]
-                singleType = 4 /* TokenType.RBRACKET */;
-                break;
-            case 123: // {
-                singleType = 5 /* TokenType.LBRACE */;
-                break;
-            case 125: // }
-                singleType = 6 /* TokenType.RBRACE */;
-                break;
-            case 46: // .
-                singleType = 7 /* TokenType.DOT */;
-                break;
-            case 44: // ,
-                singleType = 8 /* TokenType.COMMA */;
-                break;
-            case 58: // :
-                singleType = 9 /* TokenType.COLON */;
-                break;
-            // Context and control symbols
-            case 64: // @
-                singleType = 26 /* TokenType.AT */;
-                break;
-            case 36: {
-                // $ or variable reference ($name)
-                const next = this.peekCharCode(this.pos + 1);
-                if (isIdentStart(next)) {
-                    return this.scanVariable(start);
+    parseBracketExpression(left = CURRENT_NODE) {
+        // Must be LBRACKET - consume it and check what follows
+        this.lexer.consume(3 /* TokenType.LBRACKET */);
+        const token = this.lexer.peek();
+        switch (token.type) {
+            case 28 /* TokenType.STAR */: {
+                // At root level, [*...] could be:
+                // - [*] = array projection
+                // - [*.*] = multi-select list containing object projection chain
+                // We need to lookahead to distinguish
+                this.lexer.consume(28 /* TokenType.STAR */);
+                // Check what comes after *
+                const nextToken = this.lexer.peek();
+                if (nextToken.type === 4 /* TokenType.RBRACKET */) {
+                    // [*] - array projection
+                    this.lexer.consume(4 /* TokenType.RBRACKET */);
+                    const projectNode = {
+                        type: "project",
+                        expression: left,
+                        projection: CURRENT_NODE,
+                    };
+                    return this.parseProjectionRHS(projectNode);
+                }
+                // Not just [*], so this is multi-select list starting with * expression
+                // We've already consumed *, so we need to build the expression from there
+                if (left !== CURRENT_NODE) {
+                    // foo[*.something] is not valid - multi-select list after expression needs .[
+                    throw this.unexpectedToken(nextToken, "']'", "after '[*'");
+                }
+                // Build the rest of the * expression and continue parsing multi-select list
+                const starExpr = this.expressionFrom({
+                    type: "objectProject",
+                    expression: CURRENT_NODE,
+                    projection: CURRENT_NODE,
+                }, 0);
+                return this.parseMultiSelectListFromBracket(starExpr);
+            }
+            case 35 /* TokenType.RAW_STRING */: {
+                // foo['id'] - id access (no projection)
+                const id = this.lexer.consume(35 /* TokenType.RAW_STRING */).value;
+                this.lexer.consume(4 /* TokenType.RBRACKET */);
+                return {
+                    type: "idAccess",
+                    expression: left,
+                    id,
+                };
+            }
+            case 37 /* TokenType.NUMBER */:
+                return this.parseIndexOrSlice(left, this.lexer.consume(37 /* TokenType.NUMBER */).value);
+            case 21 /* TokenType.MINUS */: {
+                this.lexer.consume(21 /* TokenType.MINUS */);
+                const numberToken = this.lexer.tryConsume(37 /* TokenType.NUMBER */);
+                if (numberToken) {
+                    return this.parseIndexOrSlice(left, -numberToken.value);
                 }
-                singleType = 27 /* TokenType.DOLLAR */;
-                break;
+                // Root multi-select list can still start with unary minus (e.g. [-foo])
+                if (left !== CURRENT_NODE) {
+                    const nextToken = this.lexer.peek();
+                    throw this.unexpectedToken(nextToken, "number", "after '[-'");
+                }
+                return this.parseMultiSelectListFromBracket(this.foldUnaryArithmeticLiteral("-", this.expression(BP_ADD)));
+            }
+            case 9 /* TokenType.COLON */: {
+                // Slice starting with colon: foo[:n] or foo[:]
+                const sliceNode = this.parseSlice(left);
+                return this.parseProjectionRHS(sliceNode);
+            }
+            default: {
+                // Multi-select list: [expr1, expr2, ...]
+                // Only valid at root level (left === CURRENT_NODE), not after foo[
+                // Requires foo.[a, b] syntax, not foo[a, b]
+                if (left !== CURRENT_NODE) {
+                    throw this.unexpectedToken(token, "number, ':', '*', or string", "after '['");
+                }
+                return this.parseMultiSelectListFromBracket(this.expression(0));
             }
-            case 63: // ?
-                singleType = 29 /* TokenType.QUESTION */;
-                break;
-        }
-        if (singleType !== 0) {
-            this.pos++;
-            return {
-                type: singleType,
-                text: this.input[start],
-                offset: start,
-            };
-        }
-        if (isDigit(ch)) {
-            return this.scanNumber(start);
-        }
-        if (isIdentStart(ch)) {
-            return this.scanIdentifier(start);
         }
-        throw new UnexpectedCharacterError(this.input, start, this.input[start]);
     }
     /**
-     * Scan [, [?, or []
+     * Parse filter expression: foo[?bar]
+     * Also handles leading filter expression (no LHS): [?...]
+     *
+     * When [? appears without a left-hand side, it implicitly applies to @ (current context).
+     * Example: `[?x > 5]` means `@[?x > 5]`
      */
-    scanBracket(start) {
-        const ch = this.advanceCharCode();
-        if (ch === 63) {
-            // ?
-            this.pos++;
-            return {
-                type: 31 /* TokenType.FILTER_BRACKET */,
-                text: "[?",
-                offset: start,
-            };
-        }
-        if (ch === 93) {
-            // ]
-            this.pos++;
-            return {
-                type: 32 /* TokenType.FLATTEN_BRACKET */,
-                text: "[]",
-                offset: start,
-            };
-        }
-        return {
-            type: 3 /* TokenType.LBRACKET */,
-            text: "[",
-            offset: start,
+    parseFilterExpression(left = CURRENT_NODE) {
+        // Lexer emits FILTER_BRACKET token for [?
+        this.lexer.consume(31 /* TokenType.FILTER_BRACKET */);
+        const condition = this.expression(0);
+        this.lexer.consume(4 /* TokenType.RBRACKET */);
+        const filterNode = {
+            type: "filter",
+            expression: left,
+            condition,
         };
+        return this.parseProjectionRHS(filterNode);
     }
     /**
-     * Scan | or ||
-     */
-    scanPipe(start) {
-        const ch = this.advanceCharCode(); // consume |
-        if (ch === 124) {
-            // |
-            this.pos++;
-            return { type: 11 /* TokenType.OR */, text: "||", offset: start };
-        }
-        return { type: 10 /* TokenType.PIPE */, text: "|", offset: start };
-    }
-    /**
-     * Scan ! or !=
+     * Parse projection RHS: what comes after [*], [], [?...], or slice
+     *
+     * Key insight: After a projection, subsequent operations may either:
+     * 1. Continue the projection chain (e.g., foo[].bar[].baz)
+     * 2. Terminate the projection
+     *
+     * Uses PROJECTION_STOP_THRESHOLD to distinguish:
+     * - Below threshold: terminators (pipe, ternary, or, and, comparisons, EOF, closing brackets)
+     * - At/above threshold: continuation operators (flatten, filter, star, dot, bracket access)
+     *
+     * This allows proper precedence: `foo[] | bar` pipes the projection result,
+     * while `foo[].bar` continues the projection to select .bar from each element.
+     *
+     * NOTE: Unlike the reference implementation which uses binding power (rbp) to control
+     * projection continuation, we use a fixed threshold. This is because our AST structure is
+     * different: the reference chains projections (project(project(x, y), z)) while we nest
+     * them in the projection field (project(x, project(y, z))). Both approaches produce the same results,
+     * but our nested structure creates clearer semantics for expressions like foo[*].bar[*].
      */
-    scanBang(start) {
-        const ch = this.advanceCharCode(); // consume !
-        if (ch === 61) {
-            // =
-            this.pos++;
-            return { type: 15 /* TokenType.NEQ */, text: "!=", offset: start };
+    parseProjectionRHS(projectionNode) {
+        const rhs = this.parseProjectionContinuation();
+        if (rhs === undefined) {
+            return projectionNode;
         }
-        return { type: 13 /* TokenType.NOT */, text: "!", offset: start };
-    }
-    /**
-     * Scan < or <=
-     */
-    scanLessThan(start) {
-        const ch = this.advanceCharCode(); // consume <
-        if (ch === 61) {
-            // =
-            this.pos++;
-            return { type: 17 /* TokenType.LTE */, text: "<=", offset: start };
+        // [*] nodes already have a projection field, so update it directly
+        //
+        // SAFETY: This mutation is safe because projectionNode is freshly created
+        // in parseBracketExpression, parseFilterExpression, or parseSlice,
+        // and has not been shared or returned yet.
+        if (projectionNode.type === "project") {
+            projectionNode.projection = rhs;
+            return projectionNode;
         }
-        return { type: 16 /* TokenType.LT */, text: "<", offset: start };
+        // flatten/filter/slice nodes don't have projection fields, so wrap them
+        return {
+            type: "project",
+            expression: projectionNode,
+            projection: rhs,
+        };
     }
     /**
-     * Scan > or >=
+     * Parse the continuation of a projection: the chain of postfix operators
+     * (dot, bracket, filter) that apply to each projected element.
+     *
+     * Returns undefined if the next token does not continue the projection
+     * (e.g. pipe, comparison, EOF, or closing brackets).
      */
-    scanGreaterThan(start) {
-        const ch = this.advanceCharCode(); // consume >
-        if (ch === 61) {
-            // =
-            this.pos++;
-            return { type: 19 /* TokenType.GTE */, text: ">=", offset: start };
+    parseProjectionContinuation() {
+        const token = this.lexer.peek();
+        if (token.type !== 7 /* TokenType.DOT */ &&
+            token.type !== 3 /* TokenType.LBRACKET */ &&
+            token.type !== 31 /* TokenType.FILTER_BRACKET */) {
+            return undefined;
         }
-        return { type: 18 /* TokenType.GT */, text: ">", offset: start };
+        return this.expressionFrom(CURRENT_NODE, PROJECTION_STOP_BP - 1);
     }
     /**
-     * Scan = or ==
+     * Parse slice after [ and optional start have been consumed: [start:end:step]
+     *
+     * Called when pattern is [:...] (start undefined) or [n:...] / [-n:...] (start known).
      */
-    scanEquals(start) {
-        const ch = this.advanceCharCode(); // consume first =
-        if (ch === 61) {
-            // =
-            this.pos++;
-            return { type: 14 /* TokenType.EQ */, text: "==", offset: start };
+    parseSlice(left, start) {
+        // [ and optional start already consumed, current token should be COLON
+        this.lexer.consume(9 /* TokenType.COLON */);
+        const end = this.tryConsumeSignedNumber();
+        let step;
+        if (this.lexer.tryConsume(9 /* TokenType.COLON */)) {
+            step = this.tryConsumeSignedNumber();
         }
-        return { type: 42 /* TokenType.ASSIGN */, text: "=", offset: start };
+        this.lexer.consume(4 /* TokenType.RBRACKET */);
+        return {
+            type: "slice",
+            expression: left,
+            start,
+            end,
+            step,
+        };
     }
     /**
-     * Scan & or &&
+     * After consuming [ and a number, determine if this is an index or slice.
      */
-    scanAmpersand(start) {
-        const ch = this.advanceCharCode(); // consume &
-        if (ch === 38) {
-            // &&
-            this.pos++;
-            return { type: 12 /* TokenType.AND */, text: "&&", offset: start };
+    parseIndexOrSlice(left, num) {
+        if (this.lexer.peek().type === 9 /* TokenType.COLON */) {
+            return this.parseProjectionRHS(this.parseSlice(left, num));
         }
-        // Single & for expression references
-        return { type: 30 /* TokenType.AMPERSAND */, text: "&", offset: start };
+        this.lexer.consume(4 /* TokenType.RBRACKET */);
+        return { type: "indexAccess", expression: left, index: num };
     }
-    /**
-     * Scan / or //
-     */
-    scanSlash(start) {
-        const ch = this.advanceCharCode(); // consume /
-        if (ch === 47) {
-            // /
-            this.pos++;
-            return { type: 25 /* TokenType.INT_DIVIDE */, text: "//", offset: start };
+    tryConsumeSignedNumber() {
+        const token = this.lexer.peek();
+        if (token.type === 37 /* TokenType.NUMBER */) {
+            return this.lexer.consume(37 /* TokenType.NUMBER */).value;
         }
-        return { type: 23 /* TokenType.DIVIDE */, text: "/", offset: start };
-    }
-    /**
-     * Scan raw string: '...'
-     * When rawStringBackslashEscape is true (default), both \' and \\ are unescaped.
-     * When false, only \' is unescaped.
-     * Optimized to use slicing for long strings
-     */
-    scanRawString(start) {
-        this.pos++; // consume opening '
-        const startPos = this.pos;
-        // First pass: find end and check for escapes
-        let hasEscape = false;
-        let endPos = this.pos;
-        while (endPos < this.length) {
-            const ch = this.input.charCodeAt(endPos);
-            if (ch === 39) {
-                // Found closing '
-                break;
-            }
-            if (ch === 92) {
-                // Backslash - potential escape
-                hasEscape = true;
-                endPos += 2; // Skip backslash and next char
-            }
-            else {
-                endPos++;
+        if (token.type === 20 /* TokenType.PLUS */ || token.type === 21 /* TokenType.MINUS */) {
+            const sign = token.type === 21 /* TokenType.MINUS */ ? -1 : 1;
+            this.lexer.advance();
+            const numberToken = this.lexer.tryConsume(37 /* TokenType.NUMBER */);
+            if (!numberToken) {
+                const nextToken = this.lexer.peek();
+                throw this.unexpectedToken(nextToken, "number");
             }
+            return sign * numberToken.value;
         }
-        if (endPos >= this.length) {
-            throw new UnterminatedTokenError(this.input, start, "raw string", "'");
+        return undefined;
+    }
+    parseIdentifier() {
+        const id = this.lexer.tryConsume(33 /* TokenType.IDENTIFIER */);
+        if (id) {
+            return id.value;
         }
-        const text = this.input.slice(start, endPos + 1);
-        let value = this.input.slice(startPos, endPos);
-        if (hasEscape) {
-            value = this.rawStringBackslashEscape
-                ? value.replace(/\\([\\'])/g, "$1")
-                : value.replace(/\\'/g, "'");
+        const quoted = this.lexer.tryConsume(34 /* TokenType.QUOTED_STRING */);
+        if (quoted) {
+            return quoted.value;
         }
-        this.pos = endPos + 1;
-        return { type: 35 /* TokenType.RAW_STRING */, text, value, offset: start };
+        const token = this.lexer.peek();
+        throw this.unexpectedToken(token, "identifier");
     }
     /**
-     * Scan backtick literal: `...`
-     * Extracts content between backticks, handles \` escape (JMESPath extension)
-     * Returns raw content for JSON.parse() in parser
+     * Parse comma-separated expressions and closing bracket into a multi-select list.
+     * Called after the first expression has already been parsed.
      */
-    scanBacktickLiteral(start) {
-        this.pos++; // consume opening `
-        const startPos = this.pos;
-        // Find end and handle \` escapes
-        let endPos = this.pos;
-        let hasEscape = false;
-        while (endPos < this.length) {
-            const ch = this.input.charCodeAt(endPos);
-            if (ch === 96) {
-                // A backtick is escaped only when preceded by an odd number of backslashes.
-                let slashCount = 0;
-                for (let i = endPos - 1; i >= startPos; i--) {
-                    if (this.input.charCodeAt(i) !== 92) {
-                        break;
-                    }
-                    slashCount++;
-                }
-                if (slashCount % 2 === 1) {
-                    hasEscape = true;
-                    endPos++;
-                    continue;
-                }
-                // Found closing `.
-                break;
-            }
-            endPos++;
-        }
-        if (endPos >= this.length) {
-            throw new UnterminatedTokenError(this.input, start, "JSON literal", "`");
-        }
-        const text = this.input.slice(start, endPos + 1);
-        let value = this.input.slice(startPos, endPos);
-        if (hasEscape) {
-            value = value.replace(/\\`/g, "`");
+    parseMultiSelectListFromBracket(first) {
+        const expressions = [first];
+        while (this.lexer.tryConsume(8 /* TokenType.COMMA */)) {
+            expressions.push(this.expression(0));
         }
-        this.pos = endPos + 1;
-        return { type: 36 /* TokenType.BACKTICK_LITERAL */, text, value, offset: start };
+        this.lexer.consume(4 /* TokenType.RBRACKET */);
+        return { type: "multiSelectList", expressions };
     }
     /**
-     * Scan quoted string: "..."
-     * Handles standard JSON escapes plus backtick (\`)
+     * Parse function call: name(arg1, arg2, ...)
+     * Called after identifier has been consumed and ( has been peeked
      */
-    scanQuotedString(start) {
-        this.pos++; // consume opening "
-        const end = this.scanQuotedStringEnd();
-        const text = this.input.slice(start, end);
-        this.pos = end;
-        // Parse escape sequences (including backtick which JSON.parse doesn't handle)
-        const inner = text.slice(1, -1); // remove quotes
-        let value = "";
-        let i = 0;
-        while (i < inner.length) {
-            if (inner[i] === "\\") {
-                // It's impossible to have a backslash at end due to scanQuotedStringEnd
-                const next = inner[i + 1];
-                if (next === "u") {
-                    // Unicode escape: \uXXXX (must have exactly 4 hex digits)
-                    const hex = inner.slice(i + 2, i + 6);
-                    if (/^[0-9a-fA-F]{4}$/.test(hex)) {
-                        value += String.fromCharCode(parseInt(hex, 16));
-                        i += 6;
-                    }
-                    else {
-                        throw new InvalidTokenError(this.input, start + 1 + i, "unicode escape", "expected 4 hexadecimal digits");
-                    }
-                }
-                else if (next in ESCAPE_CHARS) {
-                    value += ESCAPE_CHARS[next];
-                    i += 2;
-                }
-                else {
-                    // Unknown escape, keep both chars
-                    value += "\\" + next;
-                    i += 2;
-                }
-            }
-            else {
-                value += inner[i];
-                i++;
+    parseFunctionCall(name) {
+        this.lexer.consume(1 /* TokenType.LPAREN */);
+        const args = [];
+        // Handle empty args: func()
+        if (this.lexer.peek().type !== 2 /* TokenType.RPAREN */) {
+            // First argument
+            args.push(this.expression(0));
+            // Additional arguments
+            while (this.lexer.tryConsume(8 /* TokenType.COMMA */)) {
+                args.push(this.expression(0));
             }
         }
-        return { type: 34 /* TokenType.QUOTED_STRING */, text, value, offset: start };
+        this.lexer.consume(2 /* TokenType.RPAREN */);
+        return {
+            type: "functionCall",
+            name,
+            args,
+        };
     }
     /**
-     * Find end of quoted string (handles escape sequences)
-     * Rejects unescaped backticks (not valid in JSON strings)
+     * Parse multi-select hash: {key: expr, key: expr, ...}
      */
-    scanQuotedStringEnd() {
-        let pos = this.pos;
-        while (pos < this.length) {
-            const ch = this.input.charCodeAt(pos);
-            if (ch === 34) {
-                // closing "
-                return pos + 1;
-            }
-            if (ch === 96) {
-                // unescaped backtick - not allowed in quoted strings
-                throw new InvalidTokenError(this.input, pos, "backtick in string", "unescaped backtick");
-            }
-            if (ch === 92) {
-                // backslash (escape)
-                pos += 2; // skip backslash and next char
-            }
-            else {
-                pos++;
-            }
+    parseMultiSelectHash() {
+        this.lexer.consume(5 /* TokenType.LBRACE */);
+        const entries = [];
+        // Empty multi-select hash {} is invalid
+        if (this.lexer.peek().type === 6 /* TokenType.RBRACE */) {
+            const token = this.lexer.peek();
+            throw this.unexpectedToken(token, "key-value pair", "in multi-select hash");
         }
-        throw new UnterminatedTokenError(this.input, this.pos - 1, "string", '"');
+        // Parse first key-value pair
+        entries.push(this.parseMultiSelectHashEntry());
+        // Parse remaining comma-separated entries
+        while (this.lexer.tryConsume(8 /* TokenType.COMMA */)) {
+            entries.push(this.parseMultiSelectHashEntry());
+        }
+        this.lexer.consume(6 /* TokenType.RBRACE */);
+        return {
+            type: "multiSelectHash",
+            entries,
+        };
     }
     /**
-     * Scan number: [0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?
+     * Parse a single key: value entry in a multi-select hash
      */
-    scanNumber(start) {
+    parseMultiSelectHashEntry() {
+        const key = this.parseIdentifier();
+        this.lexer.consume(9 /* TokenType.COLON */);
+        const value = this.expression(0);
+        return { key, value };
+    }
+    /**
+     * Parse object projection: creates the objectProject node and parses
+     * any continuation operators.
+     */
+    parseObjectProjection(expression) {
         var _a;
-        let ch = this.peekCharCode();
-        // Leading zero or digits
-        if (ch === 48) {
-            ch = this.advanceCharCode();
-        }
-        else {
-            // 1-9 followed by any digits
-            while (isDigit(ch)) {
-                ch = this.advanceCharCode();
-            }
+        return {
+            type: "objectProject",
+            expression,
+            projection: (_a = this.parseProjectionContinuation()) !== null && _a !== void 0 ? _a : CURRENT_NODE,
+        };
+    }
+    /**
+     * Parse dot-bracket: foo.[...] which could be:
+     * - Multi-select list: foo.[a, b]
+     * - Array projection: foo.[*]
+     *
+     * Note: foo.[0], foo.[:], and foo.['id'] are rejected as syntax errors.
+     */
+    parseDotBracket(left) {
+        this.lexer.consume(3 /* TokenType.LBRACKET */);
+        const token = this.lexer.peek();
+        // After .[, only STAR and expressions are valid
+        // NUMBER, COLON, RAW_STRING are NOT valid (use foo[0], foo[:], foo['id'] instead)
+        if (token.type === 28 /* TokenType.STAR */) {
+            // .[*] is valid as projection
+            this.lexer.advance();
+            this.lexer.consume(4 /* TokenType.RBRACKET */);
+            const projectNode = {
+                type: "project",
+                expression: left,
+                projection: CURRENT_NODE,
+            };
+            return this.parseProjectionRHS(projectNode);
         }
-        // Optional decimal part
-        if (ch === 46 && // .
-            this.pos + 1 < this.length &&
-            isDigit(this.input.charCodeAt(this.pos + 1))) {
-            ch = this.advanceCharCode();
-            while (isDigit(ch)) {
-                ch = this.advanceCharCode();
-            }
+        // NUMBER, COLON, RAW_STRING after .[ are syntax errors
+        if (token.type === 37 /* TokenType.NUMBER */ ||
+            token.type === 9 /* TokenType.COLON */ ||
+            token.type === 35 /* TokenType.RAW_STRING */) {
+            throw this.unexpectedToken(token, "expression or '*'", "after '.['");
         }
-        // Optional exponent part: e or E
-        if (ch === 101 || ch === 69) {
-            ch = this.advanceCharCode();
-            // Optional sign: + or -
-            if (ch === 43 || ch === 45) {
-                ch = this.advanceCharCode();
-            }
-            // Exponent digits
-            if (!isDigit(ch)) {
-                const digit = (_a = this.input[this.pos]) !== null && _a !== void 0 ? _a : EOF_DESCRIPTION;
-                throw new InvalidTokenError(this.input, start, "number", `invalid exponent: ${digit}`);
-            }
-            while (isDigit(ch)) {
-                ch = this.advanceCharCode();
+        // Multi-select list: [expr1, expr2, ...]
+        const expressions = [];
+        expressions.push(this.expression(0));
+        while (this.lexer.tryConsume(8 /* TokenType.COMMA */)) {
+            const next = this.lexer.peek();
+            if (next.type === 37 /* TokenType.NUMBER */ ||
+                next.type === 9 /* TokenType.COLON */ ||
+                next.type === 35 /* TokenType.RAW_STRING */) {
+                throw this.unexpectedToken(next, "expression", "after '.['");
             }
+            expressions.push(this.expression(0));
         }
-        const text = this.input.slice(start, this.pos);
-        return {
-            type: 37 /* TokenType.NUMBER */,
-            text,
-            value: parseFloat(text),
-            offset: start,
-        };
-    }
-    /**
-     * Scan variable: $[a-zA-Z_][a-zA-Z0-9_]*
-     */
-    scanVariable(start) {
-        // Start is at "$". Consume first variable-name character.
-        let ch = this.advanceCharCode();
-        while (isIdentChar(ch)) {
-            ch = this.advanceCharCode();
-        }
-        const text = this.input.slice(start, this.pos);
+        this.lexer.consume(4 /* TokenType.RBRACKET */);
         return {
-            type: 41 /* TokenType.VARIABLE */,
-            text,
-            value: text.slice(1),
-            offset: start,
+            type: "pipe",
+            lhs: left,
+            rhs: {
+                type: "multiSelectList",
+                expressions,
+            },
+            dotSyntax: true,
         };
     }
-    /**
-     * Scan identifier or keyword: [a-zA-Z_][a-zA-Z0-9_]*
-     */
-    scanIdentifier(start) {
-        let ch = this.advanceCharCode();
-        while (isIdentChar(ch)) {
-            ch = this.advanceCharCode();
-        }
-        const text = this.input.slice(start, this.pos);
-        // Check for keywords
-        const keywordType = KEYWORDS[text];
-        if (keywordType !== undefined) {
-            // Return keyword token with appropriate value
-            if (keywordType === 38 /* TokenType.NULL */) {
-                return {
-                    type: 38 /* TokenType.NULL */,
-                    text: "null",
-                    value: null,
-                    offset: start,
-                };
-            }
-            else if (keywordType === 39 /* TokenType.TRUE */) {
-                return {
-                    type: 39 /* TokenType.TRUE */,
-                    text: "true",
-                    value: true,
-                    offset: start,
-                };
-            }
-            else {
-                return {
-                    type: 40 /* TokenType.FALSE */,
-                    text: "false",
-                    value: false,
-                    offset: start,
-                };
-            }
-        }
-        return { type: 33 /* TokenType.IDENTIFIER */, text, value: text, offset: start };
+    unexpectedToken(token, expected, context) {
+        return new UnexpectedTokenError(this.input, token.offset, token.text || EOF_DESCRIPTION, expected, context);
     }
-    peekCharCode(pos = this.pos) {
-        return pos < this.length ? this.input.charCodeAt(pos) : -1;
+}
+function trimJsonWhitespace(value) {
+    let start = 0;
+    let end = value.length;
+    while (start < end && isWhitespace(value.charCodeAt(start))) {
+        ++start;
     }
-    advanceCharCode() {
-        return this.peekCharCode(++this.pos);
+    while (end > start && isWhitespace(value.charCodeAt(end - 1))) {
+        --end;
     }
+    return value.slice(start, end);
 }
-function isWhitespace(ch) {
-    return ch === 32 || ch === 9 || ch === 10 || ch === 13; // space, tab, newline, carriage return
+
+class BaseAccessor {
+    constructor(selector) {
+        this.selector = selector;
+    }
 }
-function isDigit(ch) {
-    return ch >= 48 && ch <= 57; // 0-9
+class ReadOnlyAccessor extends BaseAccessor {
+    constructor(selector) {
+        super(selector);
+    }
+    isValidContext() {
+        return true;
+    }
+    getOrThrow(context, rootContext) {
+        return this.get(context, rootContext);
+    }
+    set() {
+        // ignored
+    }
+    setOrThrow() {
+        throw readOnlyError(this.selector, "set");
+    }
+    delete() {
+        // ignored
+    }
+    deleteOrThrow() {
+        throw readOnlyError(this.selector, "delete");
+    }
 }
-function isIdentStart(ch) {
-    return ((ch >= 65 && ch <= 90) || // A-Z
-        (ch >= 97 && ch <= 122) || // a-z
-        ch === 95 // _
-    );
+class ConstantAccessor extends ReadOnlyAccessor {
+    constructor(selector, value) {
+        super(selector);
+        this.value = value;
+    }
+    get() {
+        return this.value;
+    }
 }
-function isIdentChar(ch) {
-    return ((ch >= 48 && ch <= 57) || // 0-9
-        (ch >= 65 && ch <= 90) || // A-Z
-        (ch >= 97 && ch <= 122) || // a-z
-        ch === 95 // _
-    );
+class ContextAccessor extends ReadOnlyAccessor {
+    constructor() {
+        super(CURRENT_NODE);
+    }
+    get(context) {
+        return context;
+    }
 }
-
-// Pre-computed singleton AST nodes
-const CURRENT_NODE = Object.freeze({
-    type: "current",
-});
-const ROOT_NODE = Object.freeze({
-    type: "root",
-});
-// Binding power constants (higher = tighter binding)
-const BP_PIPE = 1;
-const BP_TERNARY = 2;
-const BP_OR = 3;
-const BP_AND = 4;
-const BP_COMPARE = 5;
-const BP_ADD = 6;
-const BP_MUL = 7;
-const BP_FLATTEN = 9;
-const BP_FILTER = 21;
-const BP_DOT = 40;
-const BP_NOT = 45;
-const BP_BRACKET = 55;
-// Projection stop threshold: operators below this terminate projections
-// Separates terminators (pipe, ternary, or, and, comparisons) from continuators (dot, brackets)
-const PROJECTION_STOP_BP = 10;
-// Binding power table (higher = tighter binding)
-// Use array indexed by TokenType for fast lookup
-const TOKEN_BP = (() => {
-    const bp = new Array(TOKEN_LIMIT).fill(0);
-    // Terminators (lowest precedence) - already 0
-    // TokenType.RPAREN, RBRACKET, RBRACE, COMMA - all 0
-    // Binary operators (low to high)
-    bp[10 /* TokenType.PIPE */] = BP_PIPE; // |
-    bp[29 /* TokenType.QUESTION */] = BP_TERNARY; // ?:
-    bp[11 /* TokenType.OR */] = BP_OR; // ||
-    bp[12 /* TokenType.AND */] = BP_AND; // &&
-    // Comparison operators (all same precedence - non-associative, cannot chain)
-    bp[14 /* TokenType.EQ */] = BP_COMPARE; // ==
-    bp[15 /* TokenType.NEQ */] = BP_COMPARE; // !=
-    bp[16 /* TokenType.LT */] = BP_COMPARE; // <
-    bp[17 /* TokenType.LTE */] = BP_COMPARE; // <=
-    bp[18 /* TokenType.GT */] = BP_COMPARE; // >
-    bp[19 /* TokenType.GTE */] = BP_COMPARE; // >=
-    bp[20 /* TokenType.PLUS */] = BP_ADD; // +
-    bp[21 /* TokenType.MINUS */] = BP_ADD; // -
-    bp[28 /* TokenType.STAR */] = BP_MUL; // * (multiplication in led context)
-    bp[22 /* TokenType.MULTIPLY */] = BP_MUL; // ×
-    bp[23 /* TokenType.DIVIDE */] = BP_MUL; // /, ÷
-    bp[24 /* TokenType.MODULO */] = BP_MUL; // %
-    bp[25 /* TokenType.INT_DIVIDE */] = BP_MUL; // //
-    // Projection operators
-    // flatten has lower bp (9) than star/filter to allow chaining: foo[*][] or foo[?x][].bar
-    bp[32 /* TokenType.FLATTEN_BRACKET */] = BP_FLATTEN; // []
-    bp[31 /* TokenType.FILTER_BRACKET */] = BP_FILTER; // [?...]
-    // Postfix operators (high precedence)
-    bp[7 /* TokenType.DOT */] = BP_DOT; // .
-    // Prefix operators
-    bp[13 /* TokenType.NOT */] = BP_NOT; // !
-    // Bracket access (highest)
-    bp[3 /* TokenType.LBRACKET */] = BP_BRACKET; // [n], ['id'], [n:], etc.
-    return bp;
-})();
-/**
- * Hand-written parser for JSON Selectors.
- *
- * Uses precedence-climbing (Pratt parsing) with binding power (0-55 range) to handle
- * operator precedence efficiently. The parser uses two main methods:
- * - nud() for prefix/primary expressions (no left context)
- * - led() for infix/postfix operators (with left context)
- */
-class Parser {
-    constructor(input, options) {
-        this.input = input;
-        this.lexer = new Lexer(input, {
-            rawStringBackslashEscape: options === null || options === void 0 ? void 0 : options.rawStringBackslashEscape,
-        });
-        this.strictJsonLiterals = (options === null || options === void 0 ? void 0 : options.strictJsonLiterals) === true;
+class RootContextAccessor extends ReadOnlyAccessor {
+    constructor() {
+        super(ROOT_NODE);
     }
-    /**
-     * Main entry point: parse a complete expression
-     */
-    parse() {
-        const result = this.expression(0);
-        const token = this.lexer.peek();
-        if (token.type !== 0 /* TokenType.EOF */) {
-            throw this.unexpectedToken(token, EOF_DESCRIPTION);
-        }
-        return result;
+    get(context, rootContext = context) {
+        return rootContext;
     }
-    /**
-     * Core Pratt parser: expression parsing with binding power
-     *
-     * @param rbp Right binding power - controls when to stop parsing
-     * @returns Parsed expression node
-     */
-    expression(rbp) {
-        return this.expressionFrom(this.nud(), rbp);
+}
+class EvaluateAccessor extends ReadOnlyAccessor {
+    constructor(selector, options) {
+        super(selector);
+        this.options = options;
     }
-    /**
-     * Continue Pratt parsing from a given left-hand side node.
-     * Applies led (left denotation) operators while their binding power exceeds rbp.
-     */
-    expressionFrom(left, rbp) {
-        let current = left;
-        let token = this.lexer.peek();
-        while (token.type !== 0 /* TokenType.EOF */ && rbp < TOKEN_BP[token.type]) {
-            current = this.led(current, token);
-            token = this.lexer.peek();
-        }
-        return current;
+    get(context, rootContext = context) {
+        return evaluateJsonSelector(this.selector, context, Object.assign(Object.assign({}, this.options), { rootContext }));
     }
-    /**
-     * NUD (Null Denotation): Handle prefix operators and primary expressions
-     * Called when we don't have a left-hand side yet
-     */
-    nud() {
-        const token = this.lexer.peek();
-        if (token.type === 0 /* TokenType.EOF */) {
-            throw new UnexpectedEndOfInputError(this.input);
-        }
-        switch (token.type) {
-            // Hot path: field names (most common) or function calls
-            case 33 /* TokenType.IDENTIFIER */: {
-                this.lexer.advance();
-                // Check if this is a function call (identifier followed by `(`)
-                if (this.lexer.peek().type === 1 /* TokenType.LPAREN */) {
-                    return this.parseFunctionCall(token.value);
+}
+/** Compiles a selector AST into an {@link UnboundAccessor} that can be repeatedly bound to different contexts. */
+function makeJsonSelectorAccessor(selector, options) {
+    var _a;
+    return makeAccessorInternal(selector, {
+        functionProvider: (_a = options === null || options === void 0 ? void 0 : options.functionProvider) !== null && _a !== void 0 ? _a : getBuiltinFunctionProvider(),
+    });
+}
+function makeAccessorInternal(selector, options) {
+    return visitJsonSelector(selector, {
+        current() {
+            return new ContextAccessor();
+        },
+        root() {
+            return new RootContextAccessor();
+        },
+        literal(selector) {
+            return new ConstantAccessor(selector, selector.value);
+        },
+        identifier(selector) {
+            const { id } = selector;
+            const Accessor = class extends BaseAccessor {
+                constructor() {
+                    super(selector);
+                }
+                isValidContext(context) {
+                    return isObject(context);
+                }
+                get(context) {
+                    return getField(context, id);
+                }
+                getOrThrow(context) {
+                    var _a;
+                    const objectContext = requireObjectContext(context, selector, "get");
+                    return (_a = objectContext[id]) !== null && _a !== void 0 ? _a : null;
+                }
+                set(value, context) {
+                    if (isObject(context)) {
+                        context[id] = value;
+                    }
+                }
+                setOrThrow(value, context) {
+                    const objectContext = requireObjectContext(context, selector, "set");
+                    objectContext[id] = value;
+                }
+                delete(context) {
+                    if (isObject(context)) {
+                        delete context[id];
+                    }
+                }
+                deleteOrThrow(context) {
+                    const objectContext = requireObjectContext(context, selector, "delete");
+                    delete objectContext[id];
+                }
+            };
+            return new Accessor();
+        },
+        fieldAccess(selector) {
+            const { expression, field } = selector;
+            const base = makeAccessorInternal(expression, options);
+            const Accessor = class extends BaseAccessor {
+                constructor() {
+                    super(selector);
+                }
+                isValidContext(context, rootContext = context) {
+                    const value = base.get(context, rootContext);
+                    return isObject(value);
+                }
+                get(context, rootContext = context) {
+                    const obj = base.get(context, rootContext);
+                    return getField(obj, field);
+                }
+                getOrThrow(context, rootContext = context) {
+                    var _a;
+                    const obj = requireObjectParent(base.getOrThrow(context, rootContext), selector, "get");
+                    return (_a = obj[field]) !== null && _a !== void 0 ? _a : null;
+                }
+                set(value, context, rootContext = context) {
+                    const obj = base.get(context, rootContext);
+                    if (isObject(obj)) {
+                        obj[field] = value;
+                    }
+                }
+                setOrThrow(value, context, rootContext = context) {
+                    const obj = requireObjectParent(base.getOrThrow(context, rootContext), selector, "set");
+                    obj[field] = value;
+                }
+                delete(context, rootContext = context) {
+                    const obj = base.get(context, rootContext);
+                    if (isObject(obj)) {
+                        delete obj[field];
+                    }
+                }
+                deleteOrThrow(context, rootContext = context) {
+                    const obj = requireObjectParent(base.getOrThrow(context, rootContext), selector, "delete");
+                    delete obj[field];
+                }
+            };
+            return new Accessor();
+        },
+        indexAccess(selector) {
+            const { expression, index } = selector;
+            const base = makeAccessorInternal(expression, options);
+            const Accessor = class extends BaseAccessor {
+                constructor() {
+                    super(selector);
+                }
+                isValidContext(context, rootContext = context) {
+                    const value = base.get(context, rootContext);
+                    return isArray(value);
+                }
+                get(context, rootContext = context) {
+                    const arr = base.get(context, rootContext);
+                    return getIndex(arr, index);
+                }
+                getOrThrow(context, rootContext = context) {
+                    var _a;
+                    const arr = requireArrayParent(base.getOrThrow(context, rootContext), selector, "get");
+                    return (_a = arr[index < 0 ? arr.length + index : index]) !== null && _a !== void 0 ? _a : null;
+                }
+                set(value, context, rootContext = context) {
+                    const arr = base.get(context, rootContext);
+                    if (isArray(arr)) {
+                        arr[index < 0 ? arr.length + index : index] = value;
+                    }
+                }
+                setOrThrow(value, context, rootContext = context) {
+                    const arr = requireArrayParent(base.getOrThrow(context, rootContext), selector, "set");
+                    const resolvedIndex = resolveInBoundsIndex(arr, index, selector, "set");
+                    arr[resolvedIndex] = value;
+                }
+                delete(context, rootContext = context) {
+                    const arr = base.get(context, rootContext);
+                    if (isArray(arr)) {
+                        arr.splice(index, 1);
+                    }
+                }
+                deleteOrThrow(context, rootContext = context) {
+                    const arr = requireArrayParent(base.getOrThrow(context, rootContext), selector, "delete");
+                    const resolvedIndex = resolveInBoundsIndex(arr, index, selector, "delete");
+                    arr.splice(resolvedIndex, 1);
+                }
+            };
+            return new Accessor();
+        },
+        idAccess(selector) {
+            const { expression, id } = selector;
+            const base = makeAccessorInternal(expression, options);
+            const Accessor = class extends BaseAccessor {
+                constructor() {
+                    super(selector);
+                }
+                isValidContext(context, rootContext = context) {
+                    const value = base.get(context, rootContext);
+                    return isArray(value);
+                }
+                get(context, rootContext = context) {
+                    const arr = base.get(context, rootContext);
+                    return findId(arr, id);
+                }
+                getOrThrow(context, rootContext = context) {
+                    const arr = requireArrayParent(base.getOrThrow(context, rootContext), selector, "get");
+                    const index = findIdIndex(arr, id);
+                    return index >= 0 ? arr[index] : null;
+                }
+                set(value, context, rootContext = context) {
+                    const arr = base.get(context, rootContext);
+                    if (isArray(arr)) {
+                        const index = findIdIndex(arr, id);
+                        if (index >= 0) {
+                            arr[index] = value;
+                        }
+                    }
+                }
+                setOrThrow(value, context, rootContext = context) {
+                    const arr = requireArrayParent(base.getOrThrow(context, rootContext), selector, "set");
+                    const index = requireIdIndex(arr, id, selector, "set");
+                    arr[index] = value;
+                }
+                delete(context, rootContext = context) {
+                    const arr = base.get(context, rootContext);
+                    if (isArray(arr)) {
+                        const index = findIdIndex(arr, id);
+                        if (index >= 0) {
+                            arr.splice(index, 1);
+                        }
+                    }
+                }
+                deleteOrThrow(context, rootContext = context) {
+                    const arr = requireArrayParent(base.getOrThrow(context, rootContext), selector, "delete");
+                    const index = requireIdIndex(arr, id, selector, "delete");
+                    arr.splice(index, 1);
+                }
+            };
+            return new Accessor();
+        },
+        project(selector) {
+            const { expression, projection } = selector;
+            const base = makeAccessorInternal(expression, options);
+            const proj = !isIdentityProjection(projection)
+                ? makeAccessorInternal(projection, options)
+                : undefined;
+            const Accessor = class extends BaseAccessor {
+                constructor() {
+                    super(selector);
+                }
+                isValidContext(context, rootContext = context) {
+                    const value = base.get(context, rootContext);
+                    return isArray(value);
+                }
+                get(context, rootContext = context) {
+                    const arr = base.get(context, rootContext);
+                    return project(arr, projection, Object.assign(Object.assign({}, options), { rootContext }));
+                }
+                getOrThrow(context, rootContext = context) {
+                    const arr = requireArrayParent(base.getOrThrow(context, rootContext), selector, "get");
+                    return project(arr, projection, Object.assign(Object.assign({}, options), { rootContext }));
+                }
+                set(value, context, rootContext = context) {
+                    const arr = base.get(context, rootContext);
+                    if (isArray(arr)) {
+                        if (proj) {
+                            for (const element of arr) {
+                                proj.set(value, element, rootContext);
+                            }
+                        }
+                        else {
+                            replaceArray(arr, asArray(value));
+                        }
+                    }
+                }
+                setOrThrow(value, context, rootContext = context) {
+                    const arr = requireArrayParent(base.getOrThrow(context, rootContext), selector, "set");
+                    if (proj) {
+                        for (const element of arr) {
+                            proj.setOrThrow(value, element, rootContext);
+                        }
+                    }
+                    else {
+                        replaceArray(arr, asArray(value));
+                    }
+                }
+                delete(context, rootContext = context) {
+                    const arr = base.get(context, rootContext);
+                    if (isArray(arr)) {
+                        if (proj) {
+                            for (const element of arr) {
+                                proj.delete(element, rootContext);
+                            }
+                        }
+                        else {
+                            arr.length = 0;
+                        }
+                    }
+                }
+                deleteOrThrow(context, rootContext = context) {
+                    const arr = requireArrayParent(base.getOrThrow(context, rootContext), selector, "delete");
+                    if (proj) {
+                        for (const element of arr) {
+                            proj.deleteOrThrow(element, rootContext);
+                        }
+                    }
+                    else {
+                        arr.length = 0;
+                    }
+                }
+            };
+            return new Accessor();
+        },
+        objectProject(selector) {
+            const { expression, projection } = selector;
+            const base = makeAccessorInternal(expression, options);
+            const proj = !isIdentityProjection(projection)
+                ? makeAccessorInternal(projection, options)
+                : undefined;
+            const Accessor = class extends BaseAccessor {
+                constructor() {
+                    super(selector);
+                }
+                isValidContext(context, rootContext = context) {
+                    const value = base.get(context, rootContext);
+                    return isObject(value);
+                }
+                get(context, rootContext = context) {
+                    const obj = base.get(context, rootContext);
+                    return objectProject(obj, projection, Object.assign(Object.assign({}, options), { rootContext }));
+                }
+                getOrThrow(context, rootContext = context) {
+                    const obj = requireObjectParent(base.getOrThrow(context, rootContext), selector, "get");
+                    return objectProject(obj, projection, Object.assign(Object.assign({}, options), { rootContext }));
+                }
+                set(value, context, rootContext = context) {
+                    const obj = base.get(context, rootContext);
+                    if (isObject(obj)) {
+                        if (proj) {
+                            for (const v of Object.values(obj)) {
+                                proj.set(value, v, rootContext);
+                            }
+                        }
+                        else {
+                            for (const key of Object.keys(obj)) {
+                                obj[key] = value;
+                            }
+                        }
+                    }
                 }
-                // Contextual keyword: let expressions
-                if (token.value === "let" &&
-                    this.lexer.peek().type === 41 /* TokenType.VARIABLE */) {
-                    return this.parseLetExpression();
+                setOrThrow(value, context, rootContext = context) {
+                    const obj = requireObjectParent(base.getOrThrow(context, rootContext), selector, "set");
+                    if (proj) {
+                        for (const v of Object.values(obj)) {
+                            proj.setOrThrow(value, v, rootContext);
+                        }
+                    }
+                    else {
+                        for (const key of Object.keys(obj)) {
+                            obj[key] = value;
+                        }
+                    }
                 }
-                return { type: "identifier", id: token.value };
-            }
-            case 34 /* TokenType.QUOTED_STRING */:
-                this.lexer.advance();
-                return { type: "identifier", id: token.value };
-            case 26 /* TokenType.AT */:
-                this.lexer.advance();
-                return { type: "current", explicit: true };
-            case 3 /* TokenType.LBRACKET */:
-                return this.parseBracketExpression();
-            case 32 /* TokenType.FLATTEN_BRACKET */: {
-                // Leading [] applies to @
-                this.lexer.consume(32 /* TokenType.FLATTEN_BRACKET */);
-                const flattenNode = {
-                    type: "flatten",
-                    expression: CURRENT_NODE,
-                };
-                return this.parseProjectionRHS(flattenNode);
-            }
-            case 31 /* TokenType.FILTER_BRACKET */:
-                return this.parseFilterExpression();
-            case 27 /* TokenType.DOLLAR */:
-                this.lexer.advance();
-                return ROOT_NODE;
-            case 41 /* TokenType.VARIABLE */:
-                this.lexer.advance();
-                return { type: "variableRef", name: token.value };
-            case 35 /* TokenType.RAW_STRING */:
-            case 39 /* TokenType.TRUE */:
-            case 40 /* TokenType.FALSE */:
-            case 38 /* TokenType.NULL */:
-            case 37 /* TokenType.NUMBER */:
-                this.lexer.advance();
-                return { type: "literal", value: token.value };
-            case 36 /* TokenType.BACKTICK_LITERAL */: {
-                this.lexer.advance();
-                const content = trimJsonWhitespace(token.value);
-                try {
-                    // Type assertion is safe as JSON.parse returns a JsonValue
-                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                    const value = JSON.parse(content);
-                    return { type: "literal", value, backtickSyntax: true };
+                delete(context, rootContext = context) {
+                    const obj = base.get(context, rootContext);
+                    if (isObject(obj)) {
+                        if (proj) {
+                            for (const v of Object.values(obj)) {
+                                proj.delete(v, rootContext);
+                            }
+                        }
+                        else {
+                            for (const key of Object.keys(obj)) {
+                                delete obj[key];
+                            }
+                        }
+                    }
                 }
-                catch (_a) {
-                    if (this.strictJsonLiterals) {
-                        throw new InvalidTokenError(this.input, token.offset, "JSON literal", "expected valid JSON content between backticks");
+                deleteOrThrow(context, rootContext = context) {
+                    const obj = requireObjectParent(base.getOrThrow(context, rootContext), selector, "delete");
+                    if (proj) {
+                        for (const v of Object.values(obj)) {
+                            proj.deleteOrThrow(v, rootContext);
+                        }
+                    }
+                    else {
+                        for (const key of Object.keys(obj)) {
+                            delete obj[key];
+                        }
                     }
-                    return {
-                        type: "literal",
-                        value: content.replace(/\\"/g, '"'),
-                        backtickSyntax: true,
-                    };
                 }
-            }
-            case 13 /* TokenType.NOT */:
-                this.lexer.advance();
-                return {
-                    type: "not",
-                    expression: this.expression(BP_NOT),
-                };
-            case 20 /* TokenType.PLUS */:
-                this.lexer.advance();
-                return this.foldUnaryArithmeticLiteral("+", this.expression(BP_ADD));
-            case 21 /* TokenType.MINUS */:
-                this.lexer.advance();
-                return this.foldUnaryArithmeticLiteral("-", this.expression(BP_ADD));
-            case 1 /* TokenType.LPAREN */: {
-                this.lexer.advance();
-                const expr = this.expression(0);
-                this.lexer.consume(2 /* TokenType.RPAREN */);
-                return expr;
-            }
-            case 5 /* TokenType.LBRACE */:
-                // Multi-select hash: {a: x, b: y}
-                return this.parseMultiSelectHash();
-            case 28 /* TokenType.STAR */: {
-                // Root object projection: * or *.foo
-                this.lexer.advance();
-                return this.parseObjectProjection(CURRENT_NODE);
-            }
-            case 30 /* TokenType.AMPERSAND */: {
-                // Expression reference: &expr (for sort_by, max_by, etc.)
-                // Use binding power 0 to capture the full expression (up to comma or closing bracket)
-                this.lexer.advance();
-                return {
-                    type: "expressionRef",
-                    expression: this.expression(0),
-                };
-            }
-            default:
-                throw this.unexpectedToken(token, "expression");
-        }
-    }
-    /**
-     * LED (Left Denotation): Handle infix and postfix operators
-     * Called when we have a left-hand side
-     */
-    led(left, token) {
-        switch (token.type) {
-            // Hot path: field access (most common!)
-            case 7 /* TokenType.DOT */: {
-                this.lexer.advance();
-                const nextToken = this.lexer.peek();
-                // Object projection: foo.*
-                if (nextToken.type === 28 /* TokenType.STAR */) {
-                    this.lexer.advance();
-                    return this.parseObjectProjection(left);
+            };
+            return new Accessor();
+        },
+        filter(selector) {
+            const { expression, condition } = selector;
+            const base = makeAccessorInternal(expression, options);
+            const Accessor = class extends BaseAccessor {
+                constructor() {
+                    super(selector);
+                }
+                isValidContext(context, rootContext = context) {
+                    const value = base.get(context, rootContext);
+                    return isArray(value);
+                }
+                get(context, rootContext = context) {
+                    const arr = base.get(context, rootContext);
+                    return filter(arr, condition, Object.assign(Object.assign({}, options), { rootContext }));
+                }
+                getOrThrow(context, rootContext = context) {
+                    const arr = requireArrayParent(base.getOrThrow(context, rootContext), selector, "get");
+                    return filter(arr, condition, Object.assign(Object.assign({}, options), { rootContext }));
+                }
+                set(value, context, rootContext = context) {
+                    const arr = base.get(context, rootContext);
+                    if (isArray(arr)) {
+                        replaceArray(arr, invertedFilter(arr, condition, Object.assign(Object.assign({}, options), { rootContext })).concat(asArray(value)));
+                    }
+                }
+                setOrThrow(value, context, rootContext = context) {
+                    const arr = requireArrayParent(base.getOrThrow(context, rootContext), selector, "set");
+                    replaceArray(arr, invertedFilter(arr, condition, Object.assign(Object.assign({}, options), { rootContext })).concat(asArray(value)));
+                }
+                delete(context, rootContext = context) {
+                    const arr = base.get(context, rootContext);
+                    if (isArray(arr)) {
+                        replaceArray(arr, invertedFilter(arr, condition, Object.assign(Object.assign({}, options), { rootContext })));
+                    }
+                }
+                deleteOrThrow(context, rootContext = context) {
+                    const arr = requireArrayParent(base.getOrThrow(context, rootContext), selector, "delete");
+                    replaceArray(arr, invertedFilter(arr, condition, Object.assign(Object.assign({}, options), { rootContext })));
+                }
+            };
+            return new Accessor();
+        },
+        slice(selector) {
+            const { expression, start, end, step } = selector;
+            const base = makeAccessorInternal(expression, options);
+            const Accessor = class extends BaseAccessor {
+                constructor() {
+                    super(selector);
+                }
+                isValidContext(context, rootContext = context) {
+                    const value = base.get(context, rootContext);
+                    return isArray(value) || typeof value === "string";
+                }
+                get(context, rootContext = context) {
+                    const arr = base.get(context, rootContext);
+                    return slice(arr, start, end, step);
+                }
+                getOrThrow(context, rootContext = context) {
+                    const value = requireArrayOrStringParent(base.getOrThrow(context, rootContext), selector, "get");
+                    return slice(value, start, end, step);
+                }
+                set(value, context, rootContext = context) {
+                    const arr = base.get(context, rootContext);
+                    if (isArray(arr)) {
+                        replaceArray(arr, invertedSlice(arr, start, end, step).concat(asArray(value)));
+                    }
+                }
+                setOrThrow(value, context, rootContext = context) {
+                    const arr = requireArrayParent(base.getOrThrow(context, rootContext), selector, "set");
+                    replaceArray(arr, invertedSlice(arr, start, end, step).concat(asArray(value)));
+                }
+                delete(context, rootContext = context) {
+                    const arr = base.get(context, rootContext);
+                    if (isArray(arr)) {
+                        replaceArray(arr, invertedSlice(arr, start, end, step));
+                    }
+                }
+                deleteOrThrow(context, rootContext = context) {
+                    const arr = requireArrayParent(base.getOrThrow(context, rootContext), selector, "delete");
+                    replaceArray(arr, invertedSlice(arr, start, end, step));
+                }
+            };
+            return new Accessor();
+        },
+        flatten(selector) {
+            const { expression } = selector;
+            const base = makeAccessorInternal(expression, options);
+            const Accessor = class extends BaseAccessor {
+                constructor() {
+                    super(selector);
+                }
+                isValidContext(context, rootContext = context) {
+                    const value = base.get(context, rootContext);
+                    return isArray(value);
+                }
+                get(context, rootContext = context) {
+                    const arr = base.get(context, rootContext);
+                    return flatten(arr);
+                }
+                getOrThrow(context, rootContext = context) {
+                    const arr = requireArrayParent(base.getOrThrow(context, rootContext), selector, "get");
+                    return flatten(arr);
+                }
+                set(value, context, rootContext = context) {
+                    const arr = base.get(context, rootContext);
+                    if (isArray(arr)) {
+                        replaceArray(arr, asArray(value));
+                    }
+                }
+                setOrThrow(value, context, rootContext = context) {
+                    const arr = requireArrayParent(base.getOrThrow(context, rootContext), selector, "set");
+                    replaceArray(arr, asArray(value));
+                }
+                delete(context, rootContext = context) {
+                    const arr = base.get(context, rootContext);
+                    if (isArray(arr)) {
+                        arr.length = 0;
+                    }
+                }
+                deleteOrThrow(context, rootContext = context) {
+                    const arr = requireArrayParent(base.getOrThrow(context, rootContext), selector, "delete");
+                    arr.length = 0;
+                }
+            };
+            return new Accessor();
+        },
+        not(selector) {
+            const { expression } = selector;
+            const base = makeAccessorInternal(expression, options);
+            const Accessor = class extends ReadOnlyAccessor {
+                constructor() {
+                    super(selector);
+                }
+                get(context, rootContext = context) {
+                    const value = base.get(context, rootContext);
+                    return isFalseOrEmpty(value);
+                }
+            };
+            return new Accessor();
+        },
+        compare(selector) {
+            const { lhs, rhs, operator } = selector;
+            const la = makeAccessorInternal(lhs, options);
+            const ra = makeAccessorInternal(rhs, options);
+            const Accessor = class extends ReadOnlyAccessor {
+                constructor() {
+                    super(selector);
                 }
-                // Multi-select hash: foo.{a: x, b: y}
-                if (nextToken.type === 5 /* TokenType.LBRACE */) {
-                    const multiSelectHash = this.parseMultiSelectHash();
-                    return {
-                        type: "pipe",
-                        lhs: left,
-                        rhs: multiSelectHash,
-                        dotSyntax: true,
-                    };
+                get(context, rootContext = context) {
+                    const lv = la.get(context, rootContext);
+                    const rv = ra.get(context, rootContext);
+                    return compare(lv, rv, operator);
                 }
-                // Multi-select list: foo.[a, b]
-                if (nextToken.type === 3 /* TokenType.LBRACKET */) {
-                    return this.parseDotBracket(left);
+            };
+            return new Accessor();
+        },
+        arithmetic(selector) {
+            const la = makeAccessorInternal(selector.lhs, options);
+            const ra = makeAccessorInternal(selector.rhs, options);
+            const Accessor = class extends ReadOnlyAccessor {
+                constructor() {
+                    super(selector);
                 }
-                // Standard field access or function call
-                const field = this.parseIdentifier();
-                // Check if this is a function call: foo.func(args)
-                // This is equivalent to: foo | func(args)
-                if (this.lexer.peek().type === 1 /* TokenType.LPAREN */) {
-                    const funcCall = this.parseFunctionCall(field);
-                    return {
-                        type: "pipe",
-                        lhs: left,
-                        rhs: funcCall,
-                        dotSyntax: true,
-                    };
+                get(context, rootContext = context) {
+                    return performArithmetic(la.get(context, rootContext), ra.get(context, rootContext), selector.operator);
                 }
-                return { type: "fieldAccess", expression: left, field };
-            }
-            case 3 /* TokenType.LBRACKET */:
-                return this.parseBracketExpression(left);
-            case 32 /* TokenType.FLATTEN_BRACKET */: {
-                this.lexer.consume(32 /* TokenType.FLATTEN_BRACKET */);
-                const flattenNode = {
-                    type: "flatten",
-                    expression: left,
-                };
-                return this.parseProjectionRHS(flattenNode);
-            }
-            case 31 /* TokenType.FILTER_BRACKET */:
-                return this.parseFilterExpression(left);
-            case 10 /* TokenType.PIPE */:
-                this.lexer.advance();
-                return {
-                    type: "pipe",
-                    lhs: left,
-                    rhs: this.expression(BP_PIPE),
-                };
-            case 12 /* TokenType.AND */:
-                this.lexer.advance();
-                return {
-                    type: "and",
-                    lhs: left,
-                    rhs: this.expression(BP_AND),
-                };
-            case 11 /* TokenType.OR */:
-                this.lexer.advance();
-                return {
-                    type: "or",
-                    lhs: left,
-                    rhs: this.expression(BP_OR),
-                };
-            case 20 /* TokenType.PLUS */:
-                return this.parseArithmetic(left, "+", BP_ADD);
-            case 21 /* TokenType.MINUS */:
-                return this.parseArithmetic(left, "-", BP_ADD);
-            case 28 /* TokenType.STAR */:
-            case 22 /* TokenType.MULTIPLY */:
-                return this.parseArithmetic(left, "*", BP_MUL);
-            case 23 /* TokenType.DIVIDE */:
-                return this.parseArithmetic(left, "/", BP_MUL);
-            case 24 /* TokenType.MODULO */:
-                return this.parseArithmetic(left, "%", BP_MUL);
-            case 25 /* TokenType.INT_DIVIDE */:
-                return this.parseArithmetic(left, "//", BP_MUL);
-            case 29 /* TokenType.QUESTION */: {
-                this.lexer.advance();
-                const consequent = this.expression(0);
-                this.lexer.consume(9 /* TokenType.COLON */);
-                return {
-                    type: "ternary",
-                    condition: left,
-                    consequent,
-                    // NOTE: This differs from jmespath-community/typescript-jmespath, which
-                    // parses the false branch with expression(0).
-                    //
-                    // We intentionally parse with BP_TERNARY - 1 so the current ternary keeps
-                    // ownership of lower-precedence operators like pipe. This yields:
-                    //   a ? b : c | d  =>  (a ? b : c) | d
-                    //
-                    // This follows JEP-21 exactly:
-                    // - "higher precedence than the `|` pipe expression and lower precedence
-                    //   than the `||` and `&&` logical expressions"
-                    // - "Expressions within a ternary conditional expression are evaluated
-                    //   using a right-associative reading."
-                    // Spec: https://github.com/jmespath-community/jmespath.spec/blob/main/jep-0021-ternary-conditionals.md
-                    alternate: this.expression(BP_TERNARY - 1),
-                };
-            }
-            case 14 /* TokenType.EQ */:
-                return this.parseCompare(left, "==");
-            case 15 /* TokenType.NEQ */:
-                return this.parseCompare(left, "!=");
-            case 16 /* TokenType.LT */:
-                return this.parseCompare(left, "<");
-            case 17 /* TokenType.LTE */:
-                return this.parseCompare(left, "<=");
-            case 18 /* TokenType.GT */:
-                return this.parseCompare(left, ">");
-            case 19 /* TokenType.GTE */:
-                return this.parseCompare(left, ">=");
-            default:
-                throw this.unexpectedToken(token);
-        }
-    }
-    /**
-     * Parse lexical scope expression:
-     *   let $a = expr, $b = expr in body
-     *
-     * Called after consuming contextual "let".
-     */
-    parseLetExpression() {
-        const bindings = [];
-        do {
-            const variable = this.lexer.consume(41 /* TokenType.VARIABLE */);
-            this.lexer.consume(42 /* TokenType.ASSIGN */);
-            bindings.push({
-                name: variable.value,
-                value: this.expression(0),
-            });
-        } while (this.lexer.tryConsume(8 /* TokenType.COMMA */));
-        const token = this.lexer.peek();
-        if (token.type !== 33 /* TokenType.IDENTIFIER */ || token.value !== "in") {
-            throw this.unexpectedToken(token, "'in'", "after let bindings");
-        }
-        this.lexer.advance();
-        return {
-            type: "let",
-            bindings,
-            expression: this.expression(0),
-        };
-    }
-    parseCompare(left, operator) {
-        this.lexer.advance();
-        return {
-            type: "compare",
-            operator,
-            lhs: left,
-            rhs: this.expression(BP_COMPARE),
-        };
-    }
-    parseArithmetic(left, operator, bp) {
-        this.lexer.advance();
-        return {
-            type: "arithmetic",
-            operator,
-            lhs: left,
-            rhs: this.expression(bp),
-        };
-    }
-    foldUnaryArithmeticLiteral(operator, expression) {
-        if (expression.type === "literal" && typeof expression.value === "number") {
-            const value = operator === "+" ? expression.value : -expression.value;
-            return Object.assign({ type: "literal", value }, (expression.backtickSyntax !== undefined && {
-                backtickSyntax: expression.backtickSyntax,
-            }));
-        }
-        return {
-            type: "unaryArithmetic",
-            operator,
-            expression,
-        };
-    }
-    /**
-     * Parse bracket expression: foo[0], foo[:], foo[*], foo['id']
-     * Also handles leading brackets (no LHS): [0], [:], [*], ['id']
-     *
-     * When a bracket appears at the start of an expression or after an operator,
-     * it implicitly applies to @ (current context). For example:
-     * - `[0]` means `@[0]`
-     * - `foo | [*]` means `foo | @[*]`
-     *
-     * Note: foo[] (flatten) is handled separately via FLATTEN_BRACKET token in led()
-     */
-    parseBracketExpression(left = CURRENT_NODE) {
-        // Must be LBRACKET - consume it and check what follows
-        this.lexer.consume(3 /* TokenType.LBRACKET */);
-        const token = this.lexer.peek();
-        switch (token.type) {
-            case 28 /* TokenType.STAR */: {
-                // At root level, [*...] could be:
-                // - [*] = array projection
-                // - [*.*] = multi-select list containing object projection chain
-                // We need to lookahead to distinguish
-                this.lexer.consume(28 /* TokenType.STAR */);
-                // Check what comes after *
-                const nextToken = this.lexer.peek();
-                if (nextToken.type === 4 /* TokenType.RBRACKET */) {
-                    // [*] - array projection
-                    this.lexer.consume(4 /* TokenType.RBRACKET */);
-                    const projectNode = {
-                        type: "project",
-                        expression: left,
-                        projection: CURRENT_NODE,
-                    };
-                    return this.parseProjectionRHS(projectNode);
+            };
+            return new Accessor();
+        },
+        unaryArithmetic(selector) {
+            const base = makeAccessorInternal(selector.expression, options);
+            const Accessor = class extends ReadOnlyAccessor {
+                constructor() {
+                    super(selector);
+                }
+                get(context, rootContext = context) {
+                    return performUnaryArithmetic(base.get(context, rootContext), selector.operator);
+                }
+            };
+            return new Accessor();
+        },
+        and(selector) {
+            const { lhs, rhs } = selector;
+            const la = makeAccessorInternal(lhs, options);
+            const ra = makeAccessorInternal(rhs, options);
+            const Accessor = class extends ReadOnlyAccessor {
+                constructor() {
+                    super(selector);
+                }
+                get(context, rootContext = context) {
+                    const lv = la.get(context, rootContext);
+                    return isFalseOrEmpty(lv) ? lv : ra.get(context, rootContext);
+                }
+            };
+            return new Accessor();
+        },
+        or(selector) {
+            const { lhs, rhs } = selector;
+            const la = makeAccessorInternal(lhs, options);
+            const ra = makeAccessorInternal(rhs, options);
+            const Accessor = class extends ReadOnlyAccessor {
+                constructor() {
+                    super(selector);
                 }
-                // Not just [*], so this is multi-select list starting with * expression
-                // We've already consumed *, so we need to build the expression from there
-                if (left !== CURRENT_NODE) {
-                    // foo[*.something] is not valid - multi-select list after expression needs .[
-                    throw this.unexpectedToken(nextToken, "']'", "after '[*'");
+                get(context, rootContext = context) {
+                    const lv = la.get(context, rootContext);
+                    return !isFalseOrEmpty(lv) ? lv : ra.get(context, rootContext);
                 }
-                // Build the rest of the * expression and continue parsing multi-select list
-                const starExpr = this.expressionFrom({
-                    type: "objectProject",
-                    expression: CURRENT_NODE,
-                    projection: CURRENT_NODE,
-                }, 0);
-                return this.parseMultiSelectListFromBracket(starExpr);
-            }
-            case 35 /* TokenType.RAW_STRING */: {
-                // foo['id'] - id access (no projection)
-                const id = this.lexer.consume(35 /* TokenType.RAW_STRING */).value;
-                this.lexer.consume(4 /* TokenType.RBRACKET */);
-                return {
-                    type: "idAccess",
-                    expression: left,
-                    id,
-                };
-            }
-            case 37 /* TokenType.NUMBER */:
-                return this.parseIndexOrSlice(left, this.lexer.consume(37 /* TokenType.NUMBER */).value);
-            case 21 /* TokenType.MINUS */: {
-                this.lexer.consume(21 /* TokenType.MINUS */);
-                const numberToken = this.lexer.tryConsume(37 /* TokenType.NUMBER */);
-                if (numberToken) {
-                    return this.parseIndexOrSlice(left, -numberToken.value);
+            };
+            return new Accessor();
+        },
+        ternary(selector) {
+            const { condition, consequent, alternate } = selector;
+            const ca = makeAccessorInternal(condition, options);
+            const ta = makeAccessorInternal(consequent, options);
+            const aa = makeAccessorInternal(alternate, options);
+            const Accessor = class extends ReadOnlyAccessor {
+                constructor() {
+                    super(selector);
                 }
-                // Root multi-select list can still start with unary minus (e.g. [-foo])
-                if (left !== CURRENT_NODE) {
-                    const nextToken = this.lexer.peek();
-                    throw this.unexpectedToken(nextToken, "number", "after '[-'");
+                get(context, rootContext = context) {
+                    const cv = ca.get(context, rootContext);
+                    return isFalseOrEmpty(cv)
+                        ? aa.get(context, rootContext)
+                        : ta.get(context, rootContext);
                 }
-                return this.parseMultiSelectListFromBracket(this.foldUnaryArithmeticLiteral("-", this.expression(BP_ADD)));
-            }
-            case 9 /* TokenType.COLON */: {
-                // Slice starting with colon: foo[:n] or foo[:]
-                const sliceNode = this.parseSlice(left);
-                return this.parseProjectionRHS(sliceNode);
-            }
-            default: {
-                // Multi-select list: [expr1, expr2, ...]
-                // Only valid at root level (left === CURRENT_NODE), not after foo[
-                // Requires foo.[a, b] syntax, not foo[a, b]
-                if (left !== CURRENT_NODE) {
-                    throw this.unexpectedToken(token, "number, ':', '*', or string", "after '['");
+            };
+            return new Accessor();
+        },
+        pipe(selector) {
+            const { lhs, rhs } = selector;
+            const la = makeAccessorInternal(lhs, options);
+            const ra = makeAccessorInternal(rhs, options);
+            const Accessor = class extends BaseAccessor {
+                constructor() {
+                    super(selector);
                 }
-                return this.parseMultiSelectListFromBracket(this.expression(0));
-            }
-        }
-    }
-    /**
-     * Parse filter expression: foo[?bar]
-     * Also handles leading filter expression (no LHS): [?...]
-     *
-     * When [? appears without a left-hand side, it implicitly applies to @ (current context).
-     * Example: `[?x > 5]` means `@[?x > 5]`
-     */
-    parseFilterExpression(left = CURRENT_NODE) {
-        // Lexer emits FILTER_BRACKET token for [?
-        this.lexer.consume(31 /* TokenType.FILTER_BRACKET */);
-        const condition = this.expression(0);
-        this.lexer.consume(4 /* TokenType.RBRACKET */);
-        const filterNode = {
-            type: "filter",
-            expression: left,
-            condition,
-        };
-        return this.parseProjectionRHS(filterNode);
-    }
-    /**
-     * Parse projection RHS: what comes after [*], [], [?...], or slice
-     *
-     * Key insight: After a projection, subsequent operations may either:
-     * 1. Continue the projection chain (e.g., foo[].bar[].baz)
-     * 2. Terminate the projection
-     *
-     * Uses PROJECTION_STOP_THRESHOLD to distinguish:
-     * - Below threshold: terminators (pipe, ternary, or, and, comparisons, EOF, closing brackets)
-     * - At/above threshold: continuation operators (flatten, filter, star, dot, bracket access)
-     *
-     * This allows proper precedence: `foo[] | bar` pipes the projection result,
-     * while `foo[].bar` continues the projection to select .bar from each element.
-     *
-     * NOTE: Unlike the reference implementation which uses binding power (rbp) to control
-     * projection continuation, we use a fixed threshold. This is because our AST structure is
-     * different: the reference chains projections (project(project(x, y), z)) while we nest
-     * them in the projection field (project(x, project(y, z))). Both approaches produce the same results,
-     * but our nested structure creates clearer semantics for expressions like foo[*].bar[*].
-     */
-    parseProjectionRHS(projectionNode) {
-        const rhs = this.parseProjectionContinuation();
-        if (rhs === undefined) {
-            return projectionNode;
-        }
-        // [*] nodes already have a projection field, so update it directly
-        //
-        // SAFETY: This mutation is safe because projectionNode is freshly created
-        // in parseBracketExpression, parseFilterExpression, or parseSlice,
-        // and has not been shared or returned yet.
-        if (projectionNode.type === "project") {
-            projectionNode.projection = rhs;
-            return projectionNode;
-        }
-        // flatten/filter/slice nodes don't have projection fields, so wrap them
-        return {
-            type: "project",
-            expression: projectionNode,
-            projection: rhs,
-        };
+                isValidContext(context, rootContext = context) {
+                    const lv = la.get(context, rootContext);
+                    return ra.isValidContext(lv, rootContext);
+                }
+                get(context, rootContext = context) {
+                    const lv = la.get(context, rootContext);
+                    return ra.get(lv, rootContext);
+                }
+                getOrThrow(context, rootContext = context) {
+                    const lv = la.getOrThrow(context, rootContext);
+                    return ra.getOrThrow(lv, rootContext);
+                }
+                set(value, context, rootContext = context) {
+                    const lv = la.get(context, rootContext);
+                    ra.set(value, lv, rootContext);
+                }
+                setOrThrow(value, context, rootContext = context) {
+                    const lv = la.getOrThrow(context, rootContext);
+                    ra.setOrThrow(value, lv, rootContext);
+                }
+                delete(context, rootContext = context) {
+                    const lv = la.get(context, rootContext);
+                    ra.delete(lv, rootContext);
+                }
+                deleteOrThrow(context, rootContext = context) {
+                    const lv = la.getOrThrow(context, rootContext);
+                    ra.deleteOrThrow(lv, rootContext);
+                }
+            };
+            return new Accessor();
+        },
+        functionCall(selector) {
+            return new EvaluateAccessor(selector, options);
+        },
+        expressionRef(selector) {
+            // Expression references are only meaningful as function arguments
+            return new ConstantAccessor(selector, null);
+        },
+        variableRef(selector) {
+            return new EvaluateAccessor(selector, options);
+        },
+        let(selector) {
+            return new EvaluateAccessor(selector, options);
+        },
+        multiSelectList(selector) {
+            const { expressions } = selector;
+            const accessors = expressions.map((e) => makeAccessorInternal(e, options));
+            const Accessor = class extends ReadOnlyAccessor {
+                constructor() {
+                    super(selector);
+                }
+                get(context, rootContext = context) {
+                    if (context == null) {
+                        return null;
+                    }
+                    return accessors.map((a) => a.get(context, rootContext));
+                }
+            };
+            return new Accessor();
+        },
+        multiSelectHash(selector) {
+            const { entries } = selector;
+            const entryAccessors = entries.map(({ key, value }) => ({
+                key,
+                accessor: makeAccessorInternal(value, options),
+            }));
+            const Accessor = class extends ReadOnlyAccessor {
+                constructor() {
+                    super(selector);
+                }
+                get(context, rootContext = context) {
+                    if (context == null) {
+                        return null;
+                    }
+                    const result = {};
+                    for (const { key, accessor } of entryAccessors) {
+                        result[key] = accessor.get(context, rootContext);
+                    }
+                    return result;
+                }
+            };
+            return new Accessor();
+        },
+    }, undefined);
+}
+
+/** Binds an {@link UnboundAccessor} to a specific context and root, producing a ready-to-use {@link Accessor}. */
+function bindJsonSelectorAccessor(unbound, context, rootContext = context) {
+    const { selector } = unbound;
+    const valid = unbound.isValidContext(context, rootContext);
+    return {
+        selector,
+        valid,
+        path: formatJsonSelector(selector),
+        get() {
+            return unbound.get(context, rootContext);
+        },
+        getOrThrow() {
+            return unbound.getOrThrow(context, rootContext);
+        },
+        set(value) {
+            unbound.set(value, context, rootContext);
+        },
+        setOrThrow(value) {
+            unbound.setOrThrow(value, context, rootContext);
+        },
+        delete() {
+            unbound.delete(context, rootContext);
+        },
+        deleteOrThrow() {
+            unbound.deleteOrThrow(context, rootContext);
+        },
+    };
+}
+/** One-step convenience: parses a selector into an accessor already bound to the given context. */
+function accessWithJsonSelector(selector, context, rootContext = context, options) {
+    return bindJsonSelectorAccessor(makeJsonSelectorAccessor(selector, options), context, rootContext);
+}
+
+/**
+ * Read-only {@link Map} view that layers a primary map over an optional fallback,
+ * with primary entries taking precedence on key collisions.
+ */
+class FallbackMapView {
+    constructor(primary, fallback) {
+        this.primary = primary;
+        this.fallback = fallback;
     }
-    /**
-     * Parse the continuation of a projection: the chain of postfix operators
-     * (dot, bracket, filter) that apply to each projected element.
-     *
-     * Returns undefined if the next token does not continue the projection
-     * (e.g. pipe, comparison, EOF, or closing brackets).
-     */
-    parseProjectionContinuation() {
-        const token = this.lexer.peek();
-        if (token.type !== 7 /* TokenType.DOT */ &&
-            token.type !== 3 /* TokenType.LBRACKET */ &&
-            token.type !== 31 /* TokenType.FILTER_BRACKET */) {
-            return undefined;
-        }
-        return this.expressionFrom(CURRENT_NODE, PROJECTION_STOP_BP - 1);
+    get(name) {
+        var _a, _b;
+        return (_a = this.primary.get(name)) !== null && _a !== void 0 ? _a : (_b = this.fallback) === null || _b === void 0 ? void 0 : _b.get(name);
     }
-    /**
-     * Parse slice after [ and optional start have been consumed: [start:end:step]
-     *
-     * Called when pattern is [:...] (start undefined) or [n:...] / [-n:...] (start known).
-     */
-    parseSlice(left, start) {
-        // [ and optional start already consumed, current token should be COLON
-        this.lexer.consume(9 /* TokenType.COLON */);
-        const end = this.tryConsumeSignedNumber();
-        let step;
-        if (this.lexer.tryConsume(9 /* TokenType.COLON */)) {
-            step = this.tryConsumeSignedNumber();
-        }
-        this.lexer.consume(4 /* TokenType.RBRACKET */);
-        return {
-            type: "slice",
-            expression: left,
-            start,
-            end,
-            step,
-        };
+    has(name) {
+        var _a;
+        return this.primary.has(name) || ((_a = this.fallback) === null || _a === void 0 ? void 0 : _a.has(name)) === true;
     }
-    /**
-     * After consuming [ and a number, determine if this is an index or slice.
-     */
-    parseIndexOrSlice(left, num) {
-        if (this.lexer.peek().type === 9 /* TokenType.COLON */) {
-            return this.parseProjectionRHS(this.parseSlice(left, num));
+    get size() {
+        let result = this.primary.size;
+        if (this.fallback) {
+            for (const k of this.fallback.keys()) {
+                if (!this.primary.has(k)) {
+                    ++result;
+                }
+            }
         }
-        this.lexer.consume(4 /* TokenType.RBRACKET */);
-        return { type: "indexAccess", expression: left, index: num };
+        return result;
     }
-    tryConsumeSignedNumber() {
-        const token = this.lexer.peek();
-        if (token.type === 37 /* TokenType.NUMBER */) {
-            return this.lexer.consume(37 /* TokenType.NUMBER */).value;
+    *entries() {
+        for (const [k, v] of this.primary) {
+            yield [k, v];
         }
-        if (token.type === 20 /* TokenType.PLUS */ || token.type === 21 /* TokenType.MINUS */) {
-            const sign = token.type === 21 /* TokenType.MINUS */ ? -1 : 1;
-            this.lexer.advance();
-            const numberToken = this.lexer.tryConsume(37 /* TokenType.NUMBER */);
-            if (!numberToken) {
-                const nextToken = this.lexer.peek();
-                throw this.unexpectedToken(nextToken, "number");
+        if (this.fallback) {
+            for (const [k, v] of this.fallback) {
+                if (!this.primary.has(k)) {
+                    yield [k, v];
+                }
             }
-            return sign * numberToken.value;
         }
-        return undefined;
     }
-    parseIdentifier() {
-        const id = this.lexer.tryConsume(33 /* TokenType.IDENTIFIER */);
-        if (id) {
-            return id.value;
-        }
-        const quoted = this.lexer.tryConsume(34 /* TokenType.QUOTED_STRING */);
-        if (quoted) {
-            return quoted.value;
+    *keys() {
+        for (const [k] of this.entries()) {
+            yield k;
         }
-        const token = this.lexer.peek();
-        throw this.unexpectedToken(token, "identifier");
     }
-    /**
-     * Parse comma-separated expressions and closing bracket into a multi-select list.
-     * Called after the first expression has already been parsed.
-     */
-    parseMultiSelectListFromBracket(first) {
-        const expressions = [first];
-        while (this.lexer.tryConsume(8 /* TokenType.COMMA */)) {
-            expressions.push(this.expression(0));
+    *values() {
+        for (const [, v] of this.entries()) {
+            yield v;
         }
-        this.lexer.consume(4 /* TokenType.RBRACKET */);
-        return { type: "multiSelectList", expressions };
     }
-    /**
-     * Parse function call: name(arg1, arg2, ...)
-     * Called after identifier has been consumed and ( has been peeked
-     */
-    parseFunctionCall(name) {
-        this.lexer.consume(1 /* TokenType.LPAREN */);
-        const args = [];
-        // Handle empty args: func()
-        if (this.lexer.peek().type !== 2 /* TokenType.RPAREN */) {
-            // First argument
-            args.push(this.expression(0));
-            // Additional arguments
-            while (this.lexer.tryConsume(8 /* TokenType.COMMA */)) {
-                args.push(this.expression(0));
-            }
-        }
-        this.lexer.consume(2 /* TokenType.RPAREN */);
-        return {
-            type: "functionCall",
-            name,
-            args,
-        };
+    [Symbol.iterator]() {
+        return this.entries();
     }
-    /**
-     * Parse multi-select hash: {key: expr, key: expr, ...}
-     */
-    parseMultiSelectHash() {
-        this.lexer.consume(5 /* TokenType.LBRACE */);
-        const entries = [];
-        // Empty multi-select hash {} is invalid
-        if (this.lexer.peek().type === 6 /* TokenType.RBRACE */) {
-            const token = this.lexer.peek();
-            throw this.unexpectedToken(token, "key-value pair", "in multi-select hash");
-        }
-        // Parse first key-value pair
-        entries.push(this.parseMultiSelectHashEntry());
-        // Parse remaining comma-separated entries
-        while (this.lexer.tryConsume(8 /* TokenType.COMMA */)) {
-            entries.push(this.parseMultiSelectHashEntry());
+    forEach(callbackfn, thisArg) {
+        for (const [k, v] of this.entries()) {
+            callbackfn.call(thisArg, v, k, this);
         }
-        this.lexer.consume(6 /* TokenType.RBRACE */);
-        return {
-            type: "multiSelectHash",
-            entries,
-        };
     }
-    /**
-     * Parse a single key: value entry in a multi-select hash
-     */
-    parseMultiSelectHashEntry() {
-        const key = this.parseIdentifier();
-        this.lexer.consume(9 /* TokenType.COLON */);
-        const value = this.expression(0);
-        return { key, value };
+}
+
+/**
+ * Function registry for built-in and custom functions.
+ * Pass `null` as the base provider to omit built-in functions.
+ */
+class FunctionRegistry extends FallbackMapView {
+    constructor(baseProvider = getBuiltinFunctionProvider()) {
+        const custom = new Map();
+        super(custom, baseProvider !== null && baseProvider !== void 0 ? baseProvider : undefined);
+        this.custom = custom;
     }
     /**
-     * Parse object projection: creates the objectProject node and parses
-     * any continuation operators.
+     * Register a custom function (can override built-ins).
      */
-    parseObjectProjection(expression) {
-        var _a;
-        return {
-            type: "objectProject",
-            expression,
-            projection: (_a = this.parseProjectionContinuation()) !== null && _a !== void 0 ? _a : CURRENT_NODE,
-        };
+    register(def) {
+        this.custom.set(def.name, def);
     }
     /**
-     * Parse dot-bracket: foo.[...] which could be:
-     * - Multi-select list: foo.[a, b]
-     * - Array projection: foo.[*]
-     *
-     * Note: foo.[0], foo.[:], and foo.['id'] are rejected as syntax errors.
+     * Unregister a custom function.
      */
-    parseDotBracket(left) {
-        this.lexer.consume(3 /* TokenType.LBRACKET */);
-        const token = this.lexer.peek();
-        // After .[, only STAR and expressions are valid
-        // NUMBER, COLON, RAW_STRING are NOT valid (use foo[0], foo[:], foo['id'] instead)
-        if (token.type === 28 /* TokenType.STAR */) {
-            // .[*] is valid as projection
-            this.lexer.advance();
-            this.lexer.consume(4 /* TokenType.RBRACKET */);
-            const projectNode = {
-                type: "project",
-                expression: left,
-                projection: CURRENT_NODE,
-            };
-            return this.parseProjectionRHS(projectNode);
-        }
-        // NUMBER, COLON, RAW_STRING after .[ are syntax errors
-        if (token.type === 37 /* TokenType.NUMBER */ ||
-            token.type === 9 /* TokenType.COLON */ ||
-            token.type === 35 /* TokenType.RAW_STRING */) {
-            throw this.unexpectedToken(token, "expression or '*'", "after '.['");
-        }
-        // Multi-select list: [expr1, expr2, ...]
-        const expressions = [];
-        expressions.push(this.expression(0));
-        while (this.lexer.tryConsume(8 /* TokenType.COMMA */)) {
-            const next = this.lexer.peek();
-            if (next.type === 37 /* TokenType.NUMBER */ ||
-                next.type === 9 /* TokenType.COLON */ ||
-                next.type === 35 /* TokenType.RAW_STRING */) {
-                throw this.unexpectedToken(next, "expression", "after '.['");
-            }
-            expressions.push(this.expression(0));
-        }
-        this.lexer.consume(4 /* TokenType.RBRACKET */);
-        return {
-            type: "pipe",
-            lhs: left,
-            rhs: {
-                type: "multiSelectList",
-                expressions,
-            },
-            dotSyntax: true,
-        };
-    }
-    unexpectedToken(token, expected, context) {
-        return new UnexpectedTokenError(this.input, token.offset, token.text || EOF_DESCRIPTION, expected, context);
+    unregister(name) {
+        return this.custom.delete(name);
     }
 }
-function trimJsonWhitespace(value) {
-    let start = 0;
-    let end = value.length;
-    while (start < end && isWhitespace(value.charCodeAt(start))) {
-        ++start;
-    }
-    while (end > start && isWhitespace(value.charCodeAt(end - 1))) {
-        --end;
-    }
-    return value.slice(start, end);
+
+/** Evaluates a selector against a context and returns the selected value (read-only convenience wrapper). */
+function getWithJsonSelector(selector, context, options) {
+    return accessWithJsonSelector(selector, context, context, options).get();
 }
 
 /** Parses a selector expression string into an AST that can be evaluated, formatted, or compiled into an accessor. */
@@ -4247,5 +4508,5 @@ function setWithJsonSelector(selector, context, value, options) {
     return oldValue;
 }
 
-export { ANY_ARRAY_TYPE, ANY_TYPE, BOOLEAN_TYPE, DivideByZeroError, EXPREF_TYPE, FunctionError, FunctionRegistry, InvalidArgumentError, InvalidArgumentTypeError, InvalidArgumentValueError, InvalidArityError, InvalidTokenError, JsonSelectorError, JsonSelectorRuntimeError, JsonSelectorSyntaxError, JsonSelectorTypeError, NULL_TYPE, NUMBER_ARRAY_TYPE, NUMBER_TYPE, NotANumberError, OBJECT_TYPE, STRING_ARRAY_TYPE, STRING_TYPE, UndefinedVariableError, UnexpectedCharacterError, UnexpectedEndOfInputError, UnexpectedTokenError, UnknownFunctionError, UnterminatedTokenError, accessWithJsonSelector, arg, arrayOf, bindJsonSelectorAccessor, evaluateJsonSelector, formatJsonSelector, formatType, getBuiltinFunctionProvider, getDataType, getDataTypeKind, getExpressionRef, getWithJsonSelector, makeExpressionRef, makeJsonSelectorAccessor, matchesType, optArg, parseJsonSelector, requireInteger, requireNonNegativeInteger, setWithJsonSelector, unionOf, validateArguments, varArg };
+export { ANY_ARRAY_TYPE, ANY_TYPE, AccessorError, BOOLEAN_TYPE, DivideByZeroError, EXPREF_TYPE, FunctionError, FunctionRegistry, InvalidArgumentError, InvalidArgumentTypeError, InvalidArgumentValueError, InvalidArityError, InvalidTokenError, JsonSelectorError, JsonSelectorRuntimeError, JsonSelectorSyntaxError, JsonSelectorTypeError, NULL_TYPE, NUMBER_ARRAY_TYPE, NUMBER_TYPE, NotANumberError, OBJECT_TYPE, STRING_ARRAY_TYPE, STRING_TYPE, UndefinedVariableError, UnexpectedCharacterError, UnexpectedEndOfInputError, UnexpectedTokenError, UnknownFunctionError, UnterminatedTokenError, accessWithJsonSelector, arg, arrayOf, bindJsonSelectorAccessor, evaluateJsonSelector, formatJsonSelector, formatType, getBuiltinFunctionProvider, getDataType, getDataTypeKind, getExpressionRef, getWithJsonSelector, makeExpressionRef, makeJsonSelectorAccessor, matchesType, optArg, parseJsonSelector, requireInteger, requireNonNegativeInteger, setWithJsonSelector, unionOf, validateArguments, varArg };
 //# sourceMappingURL=json-selector.esm.js.map