@jbrowse/jexl 4.0.1 → 5.0.1

package/dist/grammar.js

@@ -4,17 +4,39 @@
  * Copyright 2020 Tom Shawver
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGrammar = void 0;
-exports.precedenceOf = precedenceOf;
-/**
- * Returns the binding power of a grammar element, or 0 for elements that
- * aren't operators and therefore don't participate in precedence.
- */
-function precedenceOf(elem) {
-    return elem && (elem.type === 'binaryOp' || elem.type === 'unaryOp')
-        ? elem.precedence
-        : 0;
-}
+exports.getGrammar = exports.nullish = exports.or = exports.and = void 0;
+/* eslint eqeqeq:0 */
+const collections_ts_1 = require("./collections.js");
+const operators_ts_1 = require("./operators.js");
+const plus = (left, right) => left + right;
+const minus = (left, right) => left - right;
+const times = (left, right) => left * right;
+const divide = (left, right) => left / right;
+const floorDivide = (left, right) => Math.floor(left / right);
+const modulo = (left, right) => left % right;
+const power = (left, right) => left ** right;
+const loose = (left, right) => left == right;
+// a missing value orders against nothing, as bcftools skips one; JavaScript
+// alone would read null as 0, making [null, 0.2] < 0.05 true
+const greater = (left, right) => left != null && right != null && left > right;
+const atLeast = (left, right) => left != null && right != null && left >= right;
+const less = (left, right) => left != null && right != null && left < right;
+const atMost = (left, right) => left != null && right != null && left <= right;
+// named so the compiler can recognize the built-in forms and short-circuit
+// without the thunks a host's evalOnDemand operator is handed
+const and = (left, right) => {
+    const leftVal = left.eval();
+    return leftVal ? right.eval() : leftVal;
+};
+exports.and = and;
+const or = (left, right) => {
+    const leftVal = left.eval();
+    return leftVal || right.eval();
+};
+exports.or = or;
+const nullish = (left, right) => left.eval() ?? right.eval();
+exports.nullish = nullish;
+const equals = (left, right) => (0, operators_ts_1.isList)(left, right) ? (0, operators_ts_1.anyPair)(loose, left, right) : left == right;
 const getGrammar = () => ({
     /**
      * A map of all expression elements to their properties. Note that changes
@@ -33,111 +55,117 @@ const getGrammar = () => ({
         ')': { type: 'closeParen' },
         '?': { type: 'question' },
         ';': { type: 'semicolon' },
+        '=>': { type: 'arrow' },
         '+': {
             type: 'binaryOp',
             precedence: 30,
-            eval: (left, right) => left + right
+            eval: (left, right) => (0, operators_ts_1.addsPairwise)(left, right)
+                ? (0, operators_ts_1.pairwise)(plus, left, right)
+                : plus(left, right)
         },
         '-': {
             type: 'binaryOp',
             precedence: 30,
-            eval: (left, right) => left - right,
-            unaryEval: (right) => -right
+            eval: (left, right) => (0, operators_ts_1.isList)(left, right) ? (0, operators_ts_1.pairwise)(minus, left, right) : minus(left, right),
+            unaryEval: (right) => Array.isArray(right)
+                ? right.map((value) => -value)
+                : -right
         },
         '*': {
             type: 'binaryOp',
             precedence: 40,
-            eval: (left, right) => left * right
+            eval: (left, right) => (0, operators_ts_1.isList)(left, right) ? (0, operators_ts_1.pairwise)(times, left, right) : times(left, right)
         },
         '/': {
             type: 'binaryOp',
             precedence: 40,
-            eval: (left, right) => left / right
+            eval: (left, right) => (0, operators_ts_1.isList)(left, right)
+                ? (0, operators_ts_1.pairwise)(divide, left, right)
+                : divide(left, right)
         },
         '//': {
             type: 'binaryOp',
             precedence: 40,
-            eval: (left, right) => Math.floor(left / right)
+            eval: (left, right) => (0, operators_ts_1.isList)(left, right)
+                ? (0, operators_ts_1.pairwise)(floorDivide, left, right)
+                : floorDivide(left, right)
         },
         '%': {
             type: 'binaryOp',
             precedence: 50,
-            eval: (left, right) => left % right
+            eval: (left, right) => (0, operators_ts_1.isList)(left, right)
+                ? (0, operators_ts_1.pairwise)(modulo, left, right)
+                : modulo(left, right)
         },
         '^': {
             type: 'binaryOp',
             precedence: 50,
-            eval: (left, right) => left ** right
+            rightAssociative: true,
+            eval: (left, right) => (0, operators_ts_1.isList)(left, right) ? (0, operators_ts_1.pairwise)(power, left, right) : power(left, right)
         },
         '==': {
             type: 'binaryOp',
             precedence: 20,
-            eval: (left, right) => left == right
+            eval: equals
         },
         '!=': {
             type: 'binaryOp',
             precedence: 20,
-            eval: (left, right) => left != right
+            eval: (left, right) => !equals(left, right)
+        },
+        '~': {
+            type: 'binaryOp',
+            precedence: 20,
+            eval: operators_ts_1.matches
+        },
+        '!~': {
+            type: 'binaryOp',
+            precedence: 20,
+            eval: (left, right) => !(0, operators_ts_1.matches)(left, right)
         },
         '>': {
             type: 'binaryOp',
             precedence: 20,
-            eval: (left, right) => left > right
+            eval: (left, right) => (0, operators_ts_1.isList)(left, right)
+                ? (0, operators_ts_1.anyPair)(greater, left, right)
+                : greater(left, right)
         },
         '>=': {
             type: 'binaryOp',
             precedence: 20,
-            eval: (left, right) => left >= right
+            eval: (left, right) => (0, operators_ts_1.isList)(left, right)
+                ? (0, operators_ts_1.anyPair)(atLeast, left, right)
+                : atLeast(left, right)
         },
         '<': {
             type: 'binaryOp',
             precedence: 20,
-            eval: (left, right) => left < right
+            eval: (left, right) => (0, operators_ts_1.isList)(left, right) ? (0, operators_ts_1.anyPair)(less, left, right) : less(left, right)
         },
         '<=': {
             type: 'binaryOp',
             precedence: 20,
-            eval: (left, right) => left <= right
+            eval: (left, right) => (0, operators_ts_1.isList)(left, right) ? (0, operators_ts_1.anyPair)(atMost, left, right) : atMost(left, right)
         },
         '&&': {
             type: 'binaryOp',
-            precedence: 10,
-            evalOnDemand: (left, right) => {
-                const leftVal = left.eval();
-                if (!leftVal) {
-                    return leftVal;
-                }
-                return right.eval();
-            }
+            precedence: 11,
+            evalOnDemand: exports.and
         },
         '||': {
             type: 'binaryOp',
             precedence: 10,
-            evalOnDemand: (left, right) => {
-                const leftVal = left.eval();
-                if (leftVal) {
-                    return leftVal;
-                }
-                return right.eval();
-            }
+            evalOnDemand: exports.or
+        },
+        '??': {
+            type: 'binaryOp',
+            precedence: 10,
+            evalOnDemand: exports.nullish
         },
         in: {
             type: 'binaryOp',
             precedence: 20,
-            eval: (left, right) => {
-                if (typeof right === 'string') {
-                    // only a primitive has a meaningful substring form. An absent or
-                    // structured left operand is not "in" a string, and must not be
-                    // coerced to '' — every string contains the empty string, so that
-                    // made `feature.missingAttr in "someString"` true for every feature.
-                    return typeof left === 'string' ||
-                        typeof left === 'number' ||
-                        typeof left === 'boolean'
-                        ? right.includes(String(left))
-                        : false;
-                }
-                return Array.isArray(right) ? right.includes(left) : false;
-            }
+            eval: operators_ts_1.isIn
         },
         '!': {
             type: 'unaryOp',
@@ -166,7 +194,7 @@ const getGrammar = () => ({
      * than throw. An error is only appropriate when the function would normally
      * return a value, but cannot due to some other failure.
      */
-    functions: {}
+    functions: { ...collections_ts_1.collectionFunctions }
 });
 exports.getGrammar = getGrammar;
 //# sourceMappingURL=grammar.js.map

package/dist/grammar.js.map

@@ -1 +1 @@
-{"version":3,"file":"grammar.js","sourceRoot":"","sources":["../src/grammar.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"grammar.js","sourceRoot":"","sources":["../src/grammar.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -1,5 +1,14 @@
 export { Jexl, default } from './Jexl.ts';
+export type { JexlOptions } from './Jexl.ts';
+export type { GetMember, VariableReader } from './grammar.ts';
 export { default as Expression } from './Expression.ts';
+export { analyze } from './analyze.ts';
+export { check, print, recordOf, union } from './check.ts';
+export { callSubject, conditions, fromConditions, pathSubject, printCondition } from './conditions.ts';
 export { default as Lexer } from './Lexer.ts';
+export { JexlSyntaxError } from './errors.ts';
 export { getGrammar } from './grammar.ts';
+export type * from './analyze.ts';
+export type * from './check.ts';
+export type * from './conditions.ts';
 export type * from './types.ts';

package/dist/index.js

@@ -7,14 +7,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGrammar = exports.Lexer = exports.Expression = exports.default = exports.Jexl = void 0;
+exports.getGrammar = exports.JexlSyntaxError = exports.Lexer = exports.printCondition = exports.pathSubject = exports.fromConditions = exports.conditions = exports.callSubject = exports.union = exports.recordOf = exports.print = exports.check = exports.analyze = exports.Expression = exports.default = exports.Jexl = void 0;
 var Jexl_ts_1 = require("./Jexl.js");
 Object.defineProperty(exports, "Jexl", { enumerable: true, get: function () { return Jexl_ts_1.Jexl; } });
 Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(Jexl_ts_1).default; } });
 var Expression_ts_1 = require("./Expression.js");
 Object.defineProperty(exports, "Expression", { enumerable: true, get: function () { return __importDefault(Expression_ts_1).default; } });
+var analyze_ts_1 = require("./analyze.js");
+Object.defineProperty(exports, "analyze", { enumerable: true, get: function () { return analyze_ts_1.analyze; } });
+var check_ts_1 = require("./check.js");
+Object.defineProperty(exports, "check", { enumerable: true, get: function () { return check_ts_1.check; } });
+Object.defineProperty(exports, "print", { enumerable: true, get: function () { return check_ts_1.print; } });
+Object.defineProperty(exports, "recordOf", { enumerable: true, get: function () { return check_ts_1.recordOf; } });
+Object.defineProperty(exports, "union", { enumerable: true, get: function () { return check_ts_1.union; } });
+var conditions_ts_1 = require("./conditions.js");
+Object.defineProperty(exports, "callSubject", { enumerable: true, get: function () { return conditions_ts_1.callSubject; } });
+Object.defineProperty(exports, "conditions", { enumerable: true, get: function () { return conditions_ts_1.conditions; } });
+Object.defineProperty(exports, "fromConditions", { enumerable: true, get: function () { return conditions_ts_1.fromConditions; } });
+Object.defineProperty(exports, "pathSubject", { enumerable: true, get: function () { return conditions_ts_1.pathSubject; } });
+Object.defineProperty(exports, "printCondition", { enumerable: true, get: function () { return conditions_ts_1.printCondition; } });
 var Lexer_ts_1 = require("./Lexer.js");
 Object.defineProperty(exports, "Lexer", { enumerable: true, get: function () { return __importDefault(Lexer_ts_1).default; } });
+var errors_ts_1 = require("./errors.js");
+Object.defineProperty(exports, "JexlSyntaxError", { enumerable: true, get: function () { return errors_ts_1.JexlSyntaxError; } });
 var grammar_ts_1 = require("./grammar.js");
 Object.defineProperty(exports, "getGrammar", { enumerable: true, get: function () { return grammar_ts_1.getGrammar; } });
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;;AAEH,qCAAyC;AAAhC,+FAAA,IAAI,OAAA;AAAE,mHAAA,OAAO,OAAA;AACtB,iDAAuD;AAA9C,4HAAA,OAAO,OAAc;AAC9B,uCAA6C;AAApC,kHAAA,OAAO,OAAS;AACzB,2CAAyC;AAAhC,wGAAA,UAAU,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;;AAEH,qCAAyC;AAAhC,+FAAA,IAAI,OAAA;AAAE,mHAAA,OAAO,OAAA;AAGtB,iDAAuD;AAA9C,4HAAA,OAAO,OAAc;AAC9B,2CAAsC;AAA7B,qGAAA,OAAO,OAAA;AAChB,uCAA0D;AAAjD,iGAAA,KAAK,OAAA;AAAE,iGAAA,KAAK,OAAA;AAAE,oGAAA,QAAQ,OAAA;AAAE,iGAAA,KAAK,OAAA;AACtC,iDAMwB;AALtB,4GAAA,WAAW,OAAA;AACX,2GAAA,UAAU,OAAA;AACV,+GAAA,cAAc,OAAA;AACd,4GAAA,WAAW,OAAA;AACX,+GAAA,cAAc,OAAA;AAEhB,uCAA6C;AAApC,kHAAA,OAAO,OAAS;AACzB,yCAA6C;AAApC,4GAAA,eAAe,OAAA;AACxB,2CAAyC;AAAhC,wGAAA,UAAU,OAAA"}

package/dist/operators.d.ts

@@ -0,0 +1,34 @@
+import type { JexlValue } from './types.ts';
+type Test = (left: JexlValue, right: JexlValue) => boolean;
+type Arithmetic = (left: JexlValue, right: JexlValue) => JexlValue;
+export declare function isList(left: JexlValue, right: JexlValue): boolean;
+/**
+ * A comparison over list operands: it holds when it holds for any value, as
+ * bcftools compares a multi-valued tag, so `AF > 0.05` is true when any
+ * allele's frequency is and `CLNSIG == 'Pathogenic'` when any significance is.
+ * Each operator calls this only once {@link isList} says it must, so the
+ * comparison of two single values stays a direct call V8 can inline.
+ */
+export declare function anyPair(test: Test, left: JexlValue, right: JexlValue): boolean;
+/**
+ * Whether `+` pairs its operands value by value: only when a list is involved
+ * and neither side holds text, so `REF + '>' + ALT` still joins as JavaScript
+ * joins, `'A>T,C'`, while `DP + 1` adds.
+ */
+export declare function addsPairwise(left: JexlValue, right: JexlValue): boolean;
+/**
+ * Arithmetic over list operands, value by value, as bcftools and R apply it:
+ * `AC / AN` divides each count, and a list of one, or a lone value, pairs with
+ * every value of the other side. Lists of two other lengths have no pairing
+ * and yield undefined.
+ */
+export declare function pairwise(fn: Arithmetic, left: JexlValue, right: JexlValue): JexlValue;
+/** Whether a value, or any value of a list, matches a pattern string. */
+export declare function matches(value: JexlValue, pattern: JexlValue): boolean;
+/**
+ * Whether a value is in a container: a substring of a string, a member of a
+ * list or Set, or a key of a Map or plain object. A list on the left is in
+ * the container when any of its values is.
+ */
+export declare function isIn(left: JexlValue, right: JexlValue): boolean;
+export {};

package/dist/operators.js

@@ -0,0 +1,131 @@
+"use strict";
+/*
+ * Jexl
+ * Copyright 2020 Tom Shawver
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isList = isList;
+exports.anyPair = anyPair;
+exports.addsPairwise = addsPairwise;
+exports.pairwise = pairwise;
+exports.matches = matches;
+exports.isIn = isIn;
+function isList(left, right) {
+    return Array.isArray(left) || Array.isArray(right);
+}
+/**
+ * A comparison over list operands: it holds when it holds for any value, as
+ * bcftools compares a multi-valued tag, so `AF > 0.05` is true when any
+ * allele's frequency is and `CLNSIG == 'Pathogenic'` when any significance is.
+ * Each operator calls this only once {@link isList} says it must, so the
+ * comparison of two single values stays a direct call V8 can inline.
+ */
+function anyPair(test, left, right) {
+    return Array.isArray(left)
+        ? left.some((l) => anyPair(test, l, right))
+        : Array.isArray(right)
+            ? right.some((r) => anyPair(test, left, r))
+            : test(left, right);
+}
+function hasText(value) {
+    return (typeof value === 'string' ||
+        (Array.isArray(value) && value.some((item) => typeof item === 'string')));
+}
+/**
+ * Whether `+` pairs its operands value by value: only when a list is involved
+ * and neither side holds text, so `REF + '>' + ALT` still joins as JavaScript
+ * joins, `'A>T,C'`, while `DP + 1` adds.
+ */
+function addsPairwise(left, right) {
+    return isList(left, right) && !hasText(left) && !hasText(right);
+}
+/**
+ * Arithmetic over list operands, value by value, as bcftools and R apply it:
+ * `AC / AN` divides each count, and a list of one, or a lone value, pairs with
+ * every value of the other side. Lists of two other lengths have no pairing
+ * and yield undefined.
+ */
+function pairwise(fn, left, right) {
+    const ls = Array.isArray(left) ? left : [left];
+    const rs = Array.isArray(right) ? right : [right];
+    if (ls.length !== rs.length && ls.length !== 1 && rs.length !== 1) {
+        return undefined;
+    }
+    const length = ls.length === 1 ? rs.length : ls.length;
+    const out = new Array(length);
+    for (let i = 0; i < length; i++) {
+        out[i] = fn(ls.length === 1 ? ls[0] : ls[i], rs.length === 1 ? rs[0] : rs[i]);
+    }
+    return out;
+}
+const patterns = new Map();
+const MAX_PATTERNS = 1000;
+/**
+ * The regular expression a pattern string stands for. A leading `(?i)`, the
+ * inline flag PCRE, Python and Go read, makes it case-insensitive.
+ */
+function regex(pattern) {
+    let re = patterns.get(pattern);
+    if (!re) {
+        try {
+            re = pattern.startsWith('(?i)')
+                ? new RegExp(pattern.slice(4), 'i')
+                : new RegExp(pattern);
+        }
+        catch {
+            throw new Error(`Invalid regular expression: ${pattern}`);
+        }
+        if (patterns.size >= MAX_PATTERNS) {
+            patterns.clear();
+        }
+        patterns.set(pattern, re);
+    }
+    return re;
+}
+/** Whether a value, or any value of a list, matches a pattern string. */
+function matches(value, pattern) {
+    if (typeof pattern !== 'string') {
+        return false;
+    }
+    const re = regex(pattern);
+    const test = (v) => (typeof v === 'string' ||
+        typeof v === 'number' ||
+        typeof v === 'boolean') &&
+        re.test(String(v));
+    return Array.isArray(value) ? value.some(test) : test(value);
+}
+/**
+ * Whether a value is in a container: a substring of a string, a member of a
+ * list or Set, or a key of a Map or plain object. A list on the left is in
+ * the container when any of its values is.
+ */
+function isIn(left, right) {
+    if (Array.isArray(left)) {
+        return left.some((l) => isIn(l, right));
+    }
+    if (typeof right === 'string') {
+        // only a primitive has a meaningful substring form. An absent or
+        // structured left operand is not "in" a string, and must not be coerced
+        // to '' — every string contains the empty string
+        return typeof left === 'string' ||
+            typeof left === 'number' ||
+            typeof left === 'boolean'
+            ? right.includes(String(left))
+            : false;
+    }
+    if (Array.isArray(right)) {
+        return right.includes(left);
+    }
+    if (right instanceof Set || right instanceof Map) {
+        return right.has(left);
+    }
+    if (typeof right === 'object' &&
+        right !== null &&
+        (typeof left === 'string' ||
+            typeof left === 'number' ||
+            typeof left === 'boolean')) {
+        return Object.hasOwn(right, String(left));
+    }
+    return false;
+}
+//# sourceMappingURL=operators.js.map

package/dist/operators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.js","sourceRoot":"","sources":["../src/operators.ts"],"names":[],"mappings":"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"}

package/dist/parser/Parser.d.ts

@@ -1,104 +1,61 @@
+import { JexlSyntaxError } from '../errors.ts';
 import type Lexer from '../Lexer.ts';
 import type { Grammar } from '../grammar.ts';
-import type { AstNode, Token } from '../types.ts';
+import type { AstNode, AstNodeUnion, Lambda, ObjectLiteral, TemplateLiteral, TemplatePart, Token } from '../types.ts';
+export { JexlSyntaxError } from '../errors.ts';
 /**
- * The Parser is a state machine that converts tokens from the {@link Lexer}
- * into an Abstract Syntax Tree (AST), capable of being evaluated in any
- * context by {@link compileAst}.  The Parser expects that all tokens
- * provided to it are legal and typed properly according to the grammar, but
- * accepts that the tokens may still be in an invalid order or in some other
- * unparsable configuration that requires it to throw an Error.
- * @param {{}} grammar The grammar object to use to parse Jexl strings
- * @param {string} [prefix] A string prefix to prepend to the expression string
- *      for error messaging purposes.  This is useful for when a new Parser is
- *      instantiated to parse an subexpression, as the parent Parser's
- *      expression string thus far can be passed for a more user-friendly
- *      error message.
- * @param {{}} [stopMap] A mapping of token types to any truthy value. When the
- *      token type is encountered, the parser will return the mapped value
- *      instead of boolean false.
+ * Converts the tokens from the {@link Lexer} into an Abstract Syntax Tree, for
+ * {@link compileAst} to lower to closures. A Pratt parser: each level of the
+ * grammar is a method, from `_sequence` (loosest) down to `_primary`, and
+ * binary operators are climbed by the precedence the grammar gives them, so
+ * operators a host registers slot in without the parser knowing them.
  */
 declare class Parser {
     _grammar: Grammar;
     _lexer: Lexer;
-    _state: string;
-    _tree: AstNode | null;
-    _exprStr: string;
-    _stopMap: Record<string, string>;
-    _cursor?: AstNode | null;
-    _subParser?: Parser;
-    _parentStop?: boolean;
-    _nextIdentEncapsulate?: boolean;
-    _curObjKey?: string;
-    _sequenceExpressions?: AstNode[];
-    constructor(grammar: Grammar, lexer: Lexer, prefix?: string, stopMap?: Record<string, string>);
+    _tokens: Token[];
+    _pos: number;
+    _offset: number;
+    _grouped?: WeakSet<AstNode>;
+    _lambdaDepth: number;
     /**
-     * Processes a new token into the AST and manages the transitions of the state
-     * machine.
-     * @param {{type: <string>}} token A token object, as provided by the
-     *      {@link Lexer#tokenize} function.
-     * @throws {Error} if a token is added when the Parser has been marked as
-     *      complete by {@link #complete}, or if an unexpected token type is added.
-     * @returns {boolean|*} the stopState value if this parser encountered a token
-     *      in the stopState mapb false if tokens can continue.
-     */
-    addToken(token: Token): string | false;
-    /**
-     * Processes an array of tokens iteratively through the {@link #addToken}
-     * function.
-     * @param {Array<{type: <string>}>} tokens An array of tokens, as provided by
-     *      the {@link Lexer#tokenize} function.
+     * @param offset where the tokens start in the source, so that an error
+     *      inside a template interpolation reports its place in the whole
      */
+    constructor(grammar: Grammar, lexer: Lexer, offset?: number);
+    parse(source: string): AstNodeUnion | null;
     addTokens(tokens: Token[]): void;
     /**
-     * Marks this Parser instance as completed and retrieves the full AST.
-     * @returns {{}|null} a full expression tree, ready for evaluation by the
-     *      {@link compileAst} function, or null if no tokens were passed to
-     *      the parser before complete was called
-     * @throws {Error} if the parser is not in a state where it's legal to end
-     *      the expression, indicating that the expression is incomplete
-     */
-    complete(): AstNode | null;
-    /**
-     * Ends a subexpression by completing the subParser and passing its result
-     * to the subHandler configured in the current state.
-     * @private
-     */
-    _endSubExpression(): void;
-    /**
-     * Places a new tree node at the current position of the cursor (to the 'right'
-     * property) and then advances the cursor to the new node. This function also
-     * handles setting the parent of the new node.
-     * @param {{type: <string>}} node A node to be added to the AST
-     * @private
-     */
-    _placeAtCursor(node: AstNode): void;
-    /**
-     * Places a tree node before the current position of the cursor, replacing
-     * the node that the cursor currently points to. This should only be called in
-     * cases where the cursor is known to exist, and the provided node already
-     * contains a pointer to what's at the cursor currently.
-     * @param {{type: <string>}} node A node to be added to the AST
-     * @private
-     */
-    _placeBeforeCursor(node: AstNode): void;
-    /**
-     * Sets the parent of a node by creating a non-enumerable _parent property
-     * that points to the supplied parent argument.
-     * @param {{type: <string>}} node A node of the AST on which to set a new
-     *      parent
-     * @param {{type: <string>}} parent An existing node of the AST to serve as the
-     *      parent of the new node
-     * @private
-     */
-    _setParent(node: AstNode, parent: AstNode): void;
-    /**
-     * Prepares the Parser to accept a subexpression by (re)instantiating the
-     * subParser.
-     * @param {string} [exprStr] The expression string to prefix to the new Parser
-     * @returns {Parser} the new subParser, also stored on this instance
-     * @private
-     */
-    _startSubExpression(exprStr?: string): Parser;
+     * @returns the expression tree, or null for an expression with no tokens
+     * @throws {JexlSyntaxError} if the tokens do not form exactly one expression
+     */
+    complete(): AstNodeUnion | null;
+    _sequence(): AstNodeUnion;
+    _assignment(): AstNodeUnion;
+    _atLambda(): boolean;
+    /** Parses the lambda {@link _atLambda} found, whose shape it has checked. */
+    _lambda(): Lambda;
+    _ternary(): AstNodeUnion;
+    /**
+     * Parses operands joined by binary operators that bind tighter than `floor`.
+     * One exactly at `floor` binds only when it continues a right-associative
+     * chain, which is how `a ^ b ^ c` groups from the right.
+     */
+    _binary(floor: number, rightAssociative?: boolean): AstNodeUnion;
+    /** `a ?? b || c` has no grouping a reader can guess; JS refuses it too. */
+    _mixesNullish(operator: string, ...operands: AstNodeUnion[]): boolean;
+    _unary(): AstNodeUnion;
+    _postfix(subject: AstNodeUnion): AstNodeUnion;
+    _primary(): AstNodeUnion;
+    _list(close: string): AstNode[];
+    _object(): ObjectLiteral;
+    _template(tokenParts: TemplatePart[], index: number): TemplateLiteral;
+    _peek(): Token | undefined;
+    _next(): Token;
+    _eat(type: string): boolean;
+    _expect(type: string): Token;
+    _unexpected(index: number): JexlSyntaxError;
+    _error(message: string, index: number): JexlSyntaxError;
+    _offsetOf(index: number): number;
 }
 export default Parser;