@jbrowse/jexl 2.3.1

package/esm/evaluator/handlers.d.ts

@@ -0,0 +1,111 @@
+import type Evaluator from './Evaluator.ts';
+/**
+ * Evaluates an ArrayLiteral by returning its value, with each element
+ * independently run through the evaluator.
+ * @param {{type: 'ObjectLiteral', value: <{}>}} ast An expression tree with an
+ *      ObjectLiteral as the top node
+ * @returns {Promise.<[]>} resolves to a map contained evaluated values.
+ * @private
+ */
+export declare function ArrayLiteral(this: Evaluator, ast: any): any;
+/**
+ * Evaluates a BinaryExpression node by running the Grammar's evaluator for
+ * the given operator. Note that binary expressions support two types of
+ * evaluators: `eval` is called with the left and right operands pre-evaluated.
+ * `evalOnDemand`, if it exists, will be called with the left and right operands
+ * each individually wrapped in an object with an "eval" function that returns
+ * a promise with the resulting value. This allows the binary expression to
+ * evaluate the operands conditionally.
+ * @param {{type: 'BinaryExpression', operator: <string>, left: {},
+ *      right: {}}} ast An expression tree with a BinaryExpression as the top
+ *      node
+ * @returns {Promise<*>} resolves with the value of the BinaryExpression.
+ * @private
+ */
+export declare function BinaryExpression(this: Evaluator, ast: any): any;
+/**
+ * Evaluates a ConditionalExpression node by first evaluating its test branch,
+ * and resolving with the consequent branch if the test is truthy, or the
+ * alternate branch if it is not. If there is no consequent branch, the test
+ * result will be used instead.
+ * @param {{type: 'ConditionalExpression', test: {}, consequent: {},
+ *      alternate: {}}} ast An expression tree with a ConditionalExpression as
+ *      the top node
+ * @private
+ */
+export declare function ConditionalExpression(this: Evaluator, ast: any): any;
+/**
+ * Evaluates a FilterExpression by applying it to the subject value.
+ * @param {{type: 'FilterExpression', relative: <boolean>, expr: {},
+ *      subject: {}}} ast An expression tree with a FilterExpression as the top
+ *      node
+ * @returns {Promise<*>} resolves with the value of the FilterExpression.
+ * @private
+ */
+export declare function FilterExpression(this: Evaluator, ast: any): any;
+/**
+ * Evaluates an Identifier by either stemming from the evaluated 'from'
+ * expression tree or accessing the context provided when this Evaluator was
+ * constructed.
+ * @param {{type: 'Identifier', value: <string>, [from]: {}}} ast An expression
+ *      tree with an Identifier as the top node
+ * @returns {Promise<*>|*} either the identifier's value, or a Promise that
+ *      will resolve with the identifier's value.
+ * @private
+ */
+export declare function Identifier(this: Evaluator, ast: any): any;
+/**
+ * Evaluates a Literal by returning its value property.
+ * @param {{type: 'Literal', value: <string|number|boolean>}} ast An expression
+ *      tree with a Literal as its only node
+ * @returns {string|number|boolean} The value of the Literal node
+ * @private
+ */
+export declare function Literal(this: Evaluator, ast: any): any;
+/**
+ * Evaluates a TemplateLiteral by evaluating each interpolated expression
+ * and concatenating all parts into a final string.
+ * @param {{type: 'TemplateLiteral', parts: Array<{}>}} ast An expression
+ *      tree with a TemplateLiteral as the top node
+ * @returns {Promise<string>} resolves with the final interpolated string
+ * @private
+ */
+export declare function TemplateLiteral(this: Evaluator, ast: any): any;
+/**
+ * Evaluates an ObjectLiteral by returning its value, with each key
+ * independently run through the evaluator.
+ * @param {{type: 'ObjectLiteral', value: <{}>}} ast An expression tree with an
+ *      ObjectLiteral as the top node
+ * @returns {Promise<{}>} resolves to a map contained evaluated values.
+ * @private
+ */
+export declare function ObjectLiteral(this: Evaluator, ast: any): any;
+/**
+ * Evaluates a FunctionCall node by applying the supplied arguments to a
+ * function defined in one of the grammar's function pools.
+ * @param {{type: 'FunctionCall', name: <string>}} ast An
+ *      expression tree with a FunctionCall as the top node
+ * @returns {Promise<*>|*} the value of the function call, or a Promise that
+ *      will resolve with the resulting value.
+ * @private
+ */
+export declare function FunctionCall(this: Evaluator, ast: any): any;
+/**
+ * Evaluates a Unary expression by passing the right side through the
+ * operator's eval function.
+ * @param {{type: 'UnaryExpression', operator: <string>, right: {}}} ast An
+ *      expression tree with a UnaryExpression as the top node
+ * @returns {Promise<*>} resolves with the value of the UnaryExpression.
+ * @constructor
+ */
+export declare function UnaryExpression(this: Evaluator, ast: any): any;
+/**
+ * Evaluates a SequenceExpression by evaluating each expression in order
+ * and returning the value of the last expression.
+ */
+export declare function SequenceExpression(this: Evaluator, ast: any): any;
+/**
+ * Evaluates an AssignmentExpression by evaluating the right side
+ * and assigning it to the variable name on the left side.
+ */
+export declare function AssignmentExpression(this: Evaluator, ast: any): any;

package/esm/evaluator/handlers.js

@@ -0,0 +1,202 @@
+/*
+ * Jexl
+ * Copyright 2020 Tom Shawver
+ */
+const poolNames = {
+    functions: 'Jexl Function',
+    transforms: 'Transform'
+};
+/**
+ * Evaluates an ArrayLiteral by returning its value, with each element
+ * independently run through the evaluator.
+ * @param {{type: 'ObjectLiteral', value: <{}>}} ast An expression tree with an
+ *      ObjectLiteral as the top node
+ * @returns {Promise.<[]>} resolves to a map contained evaluated values.
+ * @private
+ */
+export function ArrayLiteral(ast) {
+    return this.evalArray(ast.value);
+}
+/**
+ * Evaluates a BinaryExpression node by running the Grammar's evaluator for
+ * the given operator. Note that binary expressions support two types of
+ * evaluators: `eval` is called with the left and right operands pre-evaluated.
+ * `evalOnDemand`, if it exists, will be called with the left and right operands
+ * each individually wrapped in an object with an "eval" function that returns
+ * a promise with the resulting value. This allows the binary expression to
+ * evaluate the operands conditionally.
+ * @param {{type: 'BinaryExpression', operator: <string>, left: {},
+ *      right: {}}} ast An expression tree with a BinaryExpression as the top
+ *      node
+ * @returns {Promise<*>} resolves with the value of the BinaryExpression.
+ * @private
+ */
+export function BinaryExpression(ast) {
+    const grammarOp = this._grammar.elements[ast.operator];
+    if (grammarOp.evalOnDemand) {
+        const wrap = (subAst) => ({ eval: () => this.eval(subAst) });
+        return grammarOp.evalOnDemand(wrap(ast.left), wrap(ast.right));
+    }
+    return this.Promise.all([this.eval(ast.left), this.eval(ast.right)]).then((arr) => grammarOp.eval(arr[0], arr[1]));
+}
+/**
+ * Evaluates a ConditionalExpression node by first evaluating its test branch,
+ * and resolving with the consequent branch if the test is truthy, or the
+ * alternate branch if it is not. If there is no consequent branch, the test
+ * result will be used instead.
+ * @param {{type: 'ConditionalExpression', test: {}, consequent: {},
+ *      alternate: {}}} ast An expression tree with a ConditionalExpression as
+ *      the top node
+ * @private
+ */
+export function ConditionalExpression(ast) {
+    return this.eval(ast.test).then((res) => {
+        if (res) {
+            if (ast.consequent) {
+                return this.eval(ast.consequent);
+            }
+            return res;
+        }
+        return this.eval(ast.alternate);
+    });
+}
+/**
+ * Evaluates a FilterExpression by applying it to the subject value.
+ * @param {{type: 'FilterExpression', relative: <boolean>, expr: {},
+ *      subject: {}}} ast An expression tree with a FilterExpression as the top
+ *      node
+ * @returns {Promise<*>} resolves with the value of the FilterExpression.
+ * @private
+ */
+export function FilterExpression(ast) {
+    return this.eval(ast.subject).then((subject) => {
+        if (ast.relative) {
+            return this._filterRelative(subject, ast.expr);
+        }
+        return this._filterStatic(subject, ast.expr);
+    });
+}
+/**
+ * Evaluates an Identifier by either stemming from the evaluated 'from'
+ * expression tree or accessing the context provided when this Evaluator was
+ * constructed.
+ * @param {{type: 'Identifier', value: <string>, [from]: {}}} ast An expression
+ *      tree with an Identifier as the top node
+ * @returns {Promise<*>|*} either the identifier's value, or a Promise that
+ *      will resolve with the identifier's value.
+ * @private
+ */
+export function Identifier(ast) {
+    if (!ast.from) {
+        const contextSource = ast.relative ? this._relContext : this._context;
+        return contextSource[ast.value];
+    }
+    return this.eval(ast.from).then((context) => {
+        if (context == null) {
+            return undefined;
+        }
+        const ctx = Array.isArray(context) ? context[0] : context;
+        return ctx?.[ast.value];
+    });
+}
+/**
+ * Evaluates a Literal by returning its value property.
+ * @param {{type: 'Literal', value: <string|number|boolean>}} ast An expression
+ *      tree with a Literal as its only node
+ * @returns {string|number|boolean} The value of the Literal node
+ * @private
+ */
+export function Literal(ast) {
+    return ast.value;
+}
+/**
+ * Evaluates a TemplateLiteral by evaluating each interpolated expression
+ * and concatenating all parts into a final string.
+ * @param {{type: 'TemplateLiteral', parts: Array<{}>}} ast An expression
+ *      tree with a TemplateLiteral as the top node
+ * @returns {Promise<string>} resolves with the final interpolated string
+ * @private
+ */
+export function TemplateLiteral(ast) {
+    const promises = ast.parts.map((part) => {
+        if (part.type === 'static') {
+            return this.Promise.resolve(part.value);
+        }
+        return this.eval(part.value).then((result) => {
+            if (result == null) {
+                return '';
+            }
+            return String(result);
+        });
+    });
+    return this.Promise.all(promises).then((values) => values.join(''));
+}
+/**
+ * Evaluates an ObjectLiteral by returning its value, with each key
+ * independently run through the evaluator.
+ * @param {{type: 'ObjectLiteral', value: <{}>}} ast An expression tree with an
+ *      ObjectLiteral as the top node
+ * @returns {Promise<{}>} resolves to a map contained evaluated values.
+ * @private
+ */
+export function ObjectLiteral(ast) {
+    return this.evalMap(ast.value);
+}
+/**
+ * Evaluates a FunctionCall node by applying the supplied arguments to a
+ * function defined in one of the grammar's function pools.
+ * @param {{type: 'FunctionCall', name: <string>}} ast An
+ *      expression tree with a FunctionCall as the top node
+ * @returns {Promise<*>|*} the value of the function call, or a Promise that
+ *      will resolve with the resulting value.
+ * @private
+ */
+export function FunctionCall(ast) {
+    const poolName = poolNames[ast.pool];
+    if (!poolName) {
+        throw new Error(`Corrupt AST: Pool '${ast.pool}' not found`);
+    }
+    const pool = this._grammar[ast.pool];
+    const func = pool?.[ast.name];
+    if (!func) {
+        throw new Error(`${poolName} ${ast.name} is not defined.`);
+    }
+    return this.evalArray(ast.args || []).then((args) => func(...args));
+}
+/**
+ * Evaluates a Unary expression by passing the right side through the
+ * operator's eval function.
+ * @param {{type: 'UnaryExpression', operator: <string>, right: {}}} ast An
+ *      expression tree with a UnaryExpression as the top node
+ * @returns {Promise<*>} resolves with the value of the UnaryExpression.
+ * @constructor
+ */
+export function UnaryExpression(ast) {
+    return this.eval(ast.right).then((right) => this._grammar.elements[ast.operator].eval(right));
+}
+/**
+ * Evaluates a SequenceExpression by evaluating each expression in order
+ * and returning the value of the last expression.
+ */
+export function SequenceExpression(ast) {
+    let lastValue;
+    let promise = this.Promise.resolve();
+    for (const expr of ast.expressions) {
+        promise = promise.then(() => this.eval(expr).then((val) => {
+            lastValue = val;
+        }));
+    }
+    return promise.then(() => lastValue);
+}
+/**
+ * Evaluates an AssignmentExpression by evaluating the right side
+ * and assigning it to the variable name on the left side.
+ */
+export function AssignmentExpression(ast) {
+    return this.eval(ast.right).then((value) => {
+        const varName = ast.left.value;
+        this._context[varName] = value;
+        return value;
+    });
+}
+//# sourceMappingURL=handlers.js.map

package/esm/evaluator/handlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.js","sourceRoot":"","sources":["../../src/evaluator/handlers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,MAAM,SAAS,GAA2B;IACxC,SAAS,EAAE,eAAe;IAC1B,UAAU,EAAE,WAAW;CACxB,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAAkB,GAAQ;IACpD,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;AAClC,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,gBAAgB,CAAkB,GAAQ;IACxD,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;IACtD,IAAI,SAAS,CAAC,YAAY,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,CAAC,MAAe,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;QACrE,OAAO,SAAS,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAA;IAChE,CAAC;IACD,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CACvE,CAAC,GAAU,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAC/C,CAAA;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,qBAAqB,CAAkB,GAAQ;IAC7D,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,GAAQ,EAAE,EAAE;QAC3C,IAAI,GAAG,EAAE,CAAC;YACR,IAAI,GAAG,CAAC,UAAU,EAAE,CAAC;gBACnB,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;YAClC,CAAC;YACD,OAAO,GAAG,CAAA;QACZ,CAAC;QACD,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;IACjC,CAAC,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAkB,GAAQ;IACxD,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,OAAY,EAAE,EAAE;QAClD,IAAI,GAAG,CAAC,QAAQ,EAAE,CAAC;YACjB,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,GAAG,CAAC,IAAI,CAAC,CAAA;QAChD,CAAC;QACD,OAAO,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,GAAG,CAAC,IAAI,CAAC,CAAA;IAC9C,CAAC,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,UAAU,CAAkB,GAAQ;IAClD,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;QACd,MAAM,aAAa,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAA;QACrE,OAAO,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;IACjC,CAAC;IACD,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,OAAY,EAAE,EAAE;QAC/C,IAAI,OAAO,IAAI,IAAI,EAAE,CAAC;YACpB,OAAO,SAAS,CAAA;QAClB,CAAC;QACD,MAAM,GAAG,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAA;QACzD,OAAO,GAAG,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;IACzB,CAAC,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,OAAO,CAAkB,GAAQ;IAC/C,OAAO,GAAG,CAAC,KAAK,CAAA;AAClB,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAAkB,GAAQ;IACvD,MAAM,QAAQ,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAS,EAAE,EAAE;QAC3C,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC3B,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QACzC,CAAC;QACD,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,MAAW,EAAE,EAAE;YAChD,IAAI,MAAM,IAAI,IAAI,EAAE,CAAC;gBACnB,OAAO,EAAE,CAAA;YACX,CAAC;YACD,OAAO,MAAM,CAAC,MAAM,CAAC,CAAA;QACvB,CAAC,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,MAAgB,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAA;AAC/E,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAAkB,GAAQ;IACrD,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;AAChC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,YAAY,CAAkB,GAAQ;IACpD,MAAM,QAAQ,GAAG,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;IACpC,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CAAC,sBAAsB,GAAG,CAAC,IAAI,aAAa,CAAC,CAAA;IAC9D,CAAC;IACD,MAAM,IAAI,GAAI,IAAI,CAAC,QAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;IAC7C,MAAM,IAAI,GAAG,IAAI,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;IAC7B,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,KAAK,CAAC,GAAG,QAAQ,IAAI,GAAG,CAAC,IAAI,kBAAkB,CAAC,CAAA;IAC5D,CAAC;IACD,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,IAAW,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,CAAA;AAC5E,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAAkB,GAAQ;IACvD,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,KAAU,EAAE,EAAE,CAC9C,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CACjD,CAAA;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAAkB,GAAQ;IAC1D,IAAI,SAAc,CAAA;IAClB,IAAI,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAA;IAEpC,KAAK,MAAM,IAAI,IAAI,GAAG,CAAC,WAAW,EAAE,CAAC;QACnC,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,CAC1B,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,GAAQ,EAAE,EAAE;YAChC,SAAS,GAAG,GAAG,CAAA;QACjB,CAAC,CAAC,CACH,CAAA;IACH,CAAC;IAED,OAAO,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAA;AACtC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAAkB,GAAQ;IAC5D,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,KAAU,EAAE,EAAE;QAC9C,MAAM,OAAO,GAAG,GAAG,CAAC,IAAI,CAAC,KAAK,CAAA;QAC9B,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,KAAK,CAAA;QAC9B,OAAO,KAAK,CAAA;IACd,CAAC,CAAC,CAAA;AACJ,CAAC"}

package/esm/grammar.d.ts

@@ -0,0 +1,25 @@
+export interface BinaryOp {
+    type: 'binaryOp';
+    precedence: number;
+    eval?: (left: any, right: any) => any;
+    evalOnDemand?: (left: {
+        eval: () => Promise<any>;
+    }, right: {
+        eval: () => Promise<any>;
+    }) => Promise<any>;
+}
+export interface UnaryOp {
+    type: 'unaryOp';
+    precedence: number;
+    eval: (right: any) => any;
+}
+export interface SimpleElement {
+    type: string;
+}
+export type GrammarElement = BinaryOp | UnaryOp | SimpleElement;
+export interface Grammar {
+    elements: Record<string, GrammarElement>;
+    functions: Record<string, (...args: any[]) => any>;
+    transforms: Record<string, (val: any, ...args: any[]) => any>;
+}
+export declare const getGrammar: () => Grammar;

package/esm/grammar.js

@@ -0,0 +1,175 @@
+/*
+ * Jexl
+ * Copyright 2020 Tom Shawver
+ */
+export const getGrammar = () => ({
+    /**
+     * A map of all expression elements to their properties. Note that changes
+     * here may require changes in the Lexer or Parser.
+     * @type {{}}
+     */
+    elements: {
+        '.': { type: 'dot' },
+        '[': { type: 'openBracket' },
+        ']': { type: 'closeBracket' },
+        '|': { type: 'pipe' },
+        '{': { type: 'openCurl' },
+        '}': { type: 'closeCurl' },
+        ':': { type: 'colon' },
+        ',': { type: 'comma' },
+        '(': { type: 'openParen' },
+        ')': { type: 'closeParen' },
+        '?': { type: 'question' },
+        ';': { type: 'semicolon' },
+        '+': {
+            type: 'binaryOp',
+            precedence: 30,
+            eval: (left, right) => left + right
+        },
+        '-': {
+            type: 'binaryOp',
+            precedence: 30,
+            eval: (left, right) => left - right
+        },
+        '*': {
+            type: 'binaryOp',
+            precedence: 40,
+            eval: (left, right) => left * right
+        },
+        '/': {
+            type: 'binaryOp',
+            precedence: 40,
+            eval: (left, right) => left / right
+        },
+        '//': {
+            type: 'binaryOp',
+            precedence: 40,
+            eval: (left, right) => Math.floor(left / right)
+        },
+        '%': {
+            type: 'binaryOp',
+            precedence: 50,
+            eval: (left, right) => left % right
+        },
+        '^': {
+            type: 'binaryOp',
+            precedence: 50,
+            eval: (left, right) => Math.pow(left, right)
+        },
+        '==': {
+            type: 'binaryOp',
+            precedence: 20,
+            eval: (left, right) => left == right
+        },
+        '!=': {
+            type: 'binaryOp',
+            precedence: 20,
+            eval: (left, right) => left != right
+        },
+        '>': {
+            type: 'binaryOp',
+            precedence: 20,
+            eval: (left, right) => left > right
+        },
+        '>=': {
+            type: 'binaryOp',
+            precedence: 20,
+            eval: (left, right) => left >= right
+        },
+        '<': {
+            type: 'binaryOp',
+            precedence: 20,
+            eval: (left, right) => left < right
+        },
+        '<=': {
+            type: 'binaryOp',
+            precedence: 20,
+            eval: (left, right) => left <= right
+        },
+        '&&': {
+            type: 'binaryOp',
+            precedence: 10,
+            evalOnDemand: (left, right) => {
+                return left.eval().then((leftVal) => {
+                    if (!leftVal) {
+                        return leftVal;
+                    }
+                    return right.eval();
+                });
+            }
+        },
+        '||': {
+            type: 'binaryOp',
+            precedence: 10,
+            evalOnDemand: (left, right) => {
+                return left.eval().then((leftVal) => {
+                    if (leftVal) {
+                        return leftVal;
+                    }
+                    return right.eval();
+                });
+            }
+        },
+        in: {
+            type: 'binaryOp',
+            precedence: 20,
+            eval: (left, right) => {
+                if (typeof right === 'string') {
+                    return right.includes(left);
+                }
+                if (Array.isArray(right)) {
+                    return right.includes(left);
+                }
+                return false;
+            }
+        },
+        '!': {
+            type: 'unaryOp',
+            precedence: Infinity,
+            eval: (right) => !right
+        },
+        '=': {
+            type: 'binaryOp',
+            precedence: 2,
+            eval: (_left, _right) => {
+                throw new Error('Assignment handled specially');
+            }
+        }
+    },
+    /**
+     * A map of function names to javascript functions. A Jexl function
+     * takes zero ore more arguemnts:
+     *
+     *     - {*} ...args: A variable number of arguments passed to this function.
+     *       All of these are pre-evaluated to their actual values before calling
+     *       the function.
+     *
+     * The Jexl function should return either the transformed value, or
+     * a Promises/A+ Promise object that resolves with the value and rejects
+     * or throws only when an unrecoverable error occurs. Functions should
+     * generally return undefined when they don't make sense to be used on the
+     * given value type, rather than throw/reject. An error is only
+     * appropriate when the function would normally return a value, but
+     * cannot due to some other failure.
+     */
+    functions: {},
+    /**
+     * A map of transform names to transform functions. A transform function
+     * takes one ore more arguemnts:
+     *
+     *     - {*} val: A value to be transformed
+     *     - {*} ...args: A variable number of arguments passed to this transform.
+     *       All of these are pre-evaluated to their actual values before calling
+     *       the function.
+     *
+     * The transform function should return either the transformed value, or
+     * a Promises/A+ Promise object that resolves with the value and rejects
+     * or throws only when an unrecoverable error occurs. Transforms should
+     * generally return undefined when they don't make sense to be used on the
+     * given value type, rather than throw/reject. An error is only
+     * appropriate when the transform would normally return a value, but
+     * cannot due to some other failure.
+     */
+    transforms: {}
+});
+//# sourceMappingURL=grammar.js.map

package/esm/grammar.js.map

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

package/esm/index.d.ts

@@ -0,0 +1,5 @@
+export { Jexl, default } from './Jexl.ts';
+export { default as Expression } from './Expression.ts';
+export { default as Lexer } from './Lexer.ts';
+export { getGrammar } from './grammar.ts';
+export type * from './types.ts';

package/esm/index.js

@@ -0,0 +1,9 @@
+/*
+ * Jexl
+ * Copyright 2020 Tom Shawver
+ */
+export { Jexl, default } from "./Jexl.js";
+export { default as Expression } from "./Expression.js";
+export { default as Lexer } from "./Lexer.js";
+export { getGrammar } from "./grammar.js";
+//# sourceMappingURL=index.js.map

package/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACzC,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACvD,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,YAAY,CAAA;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA"}

package/esm/parser/Parser.d.ts

@@ -0,0 +1,112 @@
+import type Lexer from '../Lexer.ts';
+import type { AstNode, Token } from '../types.ts';
+interface Grammar {
+    elements: Record<string, any>;
+}
+/**
+ * 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 the {@link Evaluator}.  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.
+ */
+declare class Parser {
+    _grammar: Grammar;
+    _lexer: Lexer;
+    _state: string;
+    _tree: AstNode | null;
+    _exprStr: string;
+    _relative: boolean;
+    _stopMap: Record<string, any>;
+    _cursor?: AstNode | null;
+    _subParser?: Parser;
+    _parentStop?: boolean;
+    _nextIdentEncapsulate?: boolean;
+    _nextIdentRelative?: boolean;
+    _curObjKey?: string;
+    _sequenceExpressions?: AstNode[];
+    constructor(grammar: Grammar, lexer: Lexer, prefix?: string, stopMap?: Record<string, any>);
+    /**
+     * 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): any;
+    /**
+     * 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.
+     */
+    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 Evaluator#eval} function, or null if no tokens were passed to
+     *      the parser before complete was called
+     * @throws {Error} if the parser is not in a state where it's legal to end
+     *      the expression, indicating that the expression is incomplete
+     */
+    complete(): any;
+    /**
+     * Indicates whether the expression tree contains a relative path identifier.
+     * @returns {boolean} true if a relative identifier exists false otherwise.
+     */
+    isRelative(): boolean;
+    /**
+     * 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
+     * @private
+     */
+    _startSubExpression(exprStr?: string): void;
+}
+export default Parser;