@jbrowse/jexl 2.3.1

package/dist/parser/handlers.js

@@ -0,0 +1,302 @@
+"use strict";
+/*
+ * Jexl
+ * Copyright 2020 Tom Shawver
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.argVal = argVal;
+exports.arrayStart = arrayStart;
+exports.arrayVal = arrayVal;
+exports.binaryOp = binaryOp;
+exports.dot = dot;
+exports.filter = filter;
+exports.functionCall = functionCall;
+exports.identifier = identifier;
+exports.literal = literal;
+exports.templateString = templateString;
+exports.objKey = objKey;
+exports.objStart = objStart;
+exports.objVal = objVal;
+exports.subExpression = subExpression;
+exports.ternaryEnd = ternaryEnd;
+exports.ternaryMid = ternaryMid;
+exports.ternaryStart = ternaryStart;
+exports.transform = transform;
+exports.unaryOp = unaryOp;
+exports.semicolon = semicolon;
+/**
+ * Handles a subexpression that's used to define a transform argument's value.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+function argVal(ast) {
+    if (ast) {
+        ;
+        this._cursor.args.push(ast);
+    }
+}
+/**
+ * Handles new array literals by adding them as a new node in the AST,
+ * initialized with an empty array.
+ */
+function arrayStart() {
+    this._placeAtCursor({
+        type: 'ArrayLiteral',
+        value: []
+    });
+}
+/**
+ * Handles a subexpression representing an element of an array literal.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+function arrayVal(ast) {
+    if (ast) {
+        ;
+        this._cursor.value.push(ast);
+    }
+}
+/**
+ * Handles tokens of type 'binaryOp', indicating an operation that has two
+ * inputs: a left side and a right side.
+ * @param {{type: <string>}} token A token object
+ */
+function binaryOp(token) {
+    if (token.value === '=') {
+        if (this._cursor?.type !== 'Identifier') {
+            throw new Error('Left side of assignment must be a variable name');
+        }
+        const node = {
+            type: 'AssignmentExpression',
+            operator: '=',
+            left: this._cursor
+        };
+        this._cursor = this._cursor._parent;
+        this._placeAtCursor(node);
+        return;
+    }
+    const precedence = this._grammar.elements[token.value].precedence || 0;
+    let parent = this._cursor?._parent;
+    while (parent &&
+        parent.operator &&
+        this._grammar.elements[parent.operator].precedence >= precedence) {
+        this._cursor = parent;
+        parent = parent._parent;
+    }
+    const node = {
+        type: 'BinaryExpression',
+        operator: token.value,
+        left: this._cursor
+    };
+    this._setParent(this._cursor, node);
+    this._cursor = parent;
+    this._placeAtCursor(node);
+}
+/**
+ * Handles successive nodes in an identifier chain.  More specifically, it
+ * sets values that determine how the following identifier gets placed in the
+ * AST.
+ */
+function dot() {
+    const isBinaryExprWithRight = (node) => node.type === 'BinaryExpression' && node.right;
+    this._nextIdentEncapsulate =
+        this._cursor &&
+            this._cursor.type !== 'UnaryExpression' &&
+            (this._cursor.type !== 'BinaryExpression' ||
+                isBinaryExprWithRight(this._cursor));
+    this._nextIdentRelative = !this._cursor || !this._nextIdentEncapsulate;
+    if (this._nextIdentRelative) {
+        this._relative = true;
+    }
+}
+/**
+ * Handles a subexpression used for filtering an array returned by an
+ * identifier chain.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+function filter(ast) {
+    this._placeBeforeCursor({
+        type: 'FilterExpression',
+        expr: ast,
+        relative: this._subParser.isRelative(),
+        subject: this._cursor
+    });
+}
+/**
+ * Handles identifier tokens when used to indicate the name of a function to
+ * be called.
+ * @param {{type: <string>}} token A token object
+ */
+function functionCall() {
+    this._placeBeforeCursor({
+        type: 'FunctionCall',
+        name: this._cursor.value,
+        args: [],
+        pool: 'functions'
+    });
+}
+/**
+ * Handles identifier tokens by adding them as a new node in the AST.
+ * @param {{type: <string>}} token A token object
+ */
+function identifier(token) {
+    const node = {
+        type: 'Identifier',
+        value: token.value
+    };
+    if (this._nextIdentEncapsulate) {
+        node.from = this._cursor;
+        this._placeBeforeCursor(node);
+        this._nextIdentEncapsulate = false;
+    }
+    else {
+        if (this._nextIdentRelative) {
+            node.relative = true;
+            this._nextIdentRelative = false;
+        }
+        this._placeAtCursor(node);
+    }
+}
+/**
+ * Handles literal values, such as strings, booleans, and numerics, by adding
+ * them as a new node in the AST.
+ * @param {{type: <string>}} token A token object
+ */
+function literal(token) {
+    this._placeAtCursor({
+        type: 'Literal',
+        value: token.value
+    });
+}
+/**
+ * Handles template string tokens by parsing their interpolation expressions
+ * and creating a TemplateLiteral AST node.
+ * @param {{type: <string>}} token A token object
+ */
+function templateString(token) {
+    const parts = [];
+    for (const part of token.value) {
+        if (part.type === 'static') {
+            parts.push({
+                type: 'static',
+                value: this._lexer._unescapeTemplateString(part.value)
+            });
+        }
+        else {
+            const subTokens = this._lexer.tokenize(part.value);
+            const subParser = new this.constructor(this._grammar, this._lexer);
+            subParser.addTokens(subTokens);
+            const subAst = subParser.complete();
+            if (!subAst) {
+                throw new Error('Empty interpolation in template string');
+            }
+            parts.push({
+                type: 'expression',
+                value: subAst
+            });
+        }
+    }
+    this._placeAtCursor({
+        type: 'TemplateLiteral',
+        parts: parts
+    });
+}
+/**
+ * Queues a new object literal key to be written once a value is collected.
+ * @param {{type: <string>}} token A token object
+ */
+function objKey(token) {
+    this._curObjKey = token.value;
+}
+/**
+ * Handles new object literals by adding them as a new node in the AST,
+ * initialized with an empty object.
+ */
+function objStart() {
+    this._placeAtCursor({
+        type: 'ObjectLiteral',
+        value: {}
+    });
+}
+/**
+ * Handles an object value by adding its AST to the queued key on the object
+ * literal node currently at the cursor.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+function objVal(ast) {
+    ;
+    this._cursor.value[this._curObjKey] = ast;
+}
+/**
+ * Handles traditional subexpressions, delineated with the groupStart and
+ * groupEnd elements.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+function subExpression(ast) {
+    this._placeAtCursor(ast);
+}
+/**
+ * Handles a completed alternate subexpression of a ternary operator.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+function ternaryEnd(ast) {
+    ;
+    this._cursor.alternate = ast;
+}
+/**
+ * Handles a completed consequent subexpression of a ternary operator.
+ * @param {{type: <string>}} ast The subexpression tree
+ */
+function ternaryMid(ast) {
+    ;
+    this._cursor.consequent = ast;
+}
+/**
+ * Handles the start of a new ternary expression by encapsulating the entire
+ * AST in a ConditionalExpression node, and using the existing tree as the
+ * test element.
+ */
+function ternaryStart() {
+    this._tree = {
+        type: 'ConditionalExpression',
+        test: this._tree
+    };
+    this._cursor = this._tree;
+}
+/**
+ * Handles identifier tokens when used to indicate the name of a transform to
+ * be applied.
+ * @param {{type: <string>}} token A token object
+ */
+function transform(token) {
+    this._placeBeforeCursor({
+        type: 'FunctionCall',
+        name: token.value,
+        args: [this._cursor],
+        pool: 'transforms'
+    });
+}
+/**
+ * Handles token of type 'unaryOp', indicating that the operation has only
+ * one input: a right side.
+ * @param {{type: <string>}} token A token object
+ */
+function unaryOp(token) {
+    this._placeAtCursor({
+        type: 'UnaryExpression',
+        operator: token.value
+    });
+}
+/**
+ * Handles semicolon separator between expressions
+ */
+function semicolon() {
+    if (!this._sequenceExpressions) {
+        this._sequenceExpressions = [this._tree];
+    }
+    else {
+        this._sequenceExpressions.push(this._tree);
+    }
+    this._tree = null;
+    this._cursor = null;
+    this._state = 'expectOperand';
+}
+//# sourceMappingURL=handlers.js.map

package/dist/parser/handlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.js","sourceRoot":"","sources":["../../src/parser/handlers.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AASH,wBAIC;AAMD,gCAKC;AAMD,4BAIC;AAOD,4BAkCC;AAOD,kBAcC;AAOD,wBAOC;AAOD,oCAOC;AAMD,gCAgBC;AAOD,0BAKC;AAOD,wCAiCC;AAMD,wBAEC;AAMD,4BAKC;AAOD,wBAEC;AAOD,sCAEC;AAMD,gCAEC;AAMD,gCAEC;AAOD,oCAMC;AAOD,8BAOC;AAOD,0BAKC;AAKD,8BAUC;AA5SD;;;GAGG;AACH,SAAgB,MAAM,CAAe,GAAmB;IACtD,IAAI,GAAG,EAAE,CAAC;QACR,CAAC;QAAC,IAAI,CAAC,OAAe,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;IACvC,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,SAAgB,UAAU;IACxB,IAAI,CAAC,cAAc,CAAC;QAClB,IAAI,EAAE,cAAc;QACpB,KAAK,EAAE,EAAE;KACH,CAAC,CAAA;AACX,CAAC;AAED;;;GAGG;AACH,SAAgB,QAAQ,CAAe,GAAmB;IACxD,IAAI,GAAG,EAAE,CAAC;QACR,CAAC;QAAC,IAAI,CAAC,OAAe,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;IACxC,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,SAAgB,QAAQ,CAAe,KAAY;IACjD,IAAI,KAAK,CAAC,KAAK,KAAK,GAAG,EAAE,CAAC;QACxB,IAAI,IAAI,CAAC,OAAO,EAAE,IAAI,KAAK,YAAY,EAAE,CAAC;YACxC,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAA;QACpE,CAAC;QAED,MAAM,IAAI,GAAQ;YAChB,IAAI,EAAE,sBAAsB;YAC5B,QAAQ,EAAE,GAAG;YACb,IAAI,EAAE,IAAI,CAAC,OAAO;SACnB,CAAA;QACD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAA;QACnC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAA;QACzB,OAAM;IACR,CAAC;IAED,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,UAAU,IAAI,CAAC,CAAA;IACtE,IAAI,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,OAAO,CAAA;IAClC,OACE,MAAM;QACL,MAAc,CAAC,QAAQ;QACxB,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAE,MAAc,CAAC,QAAQ,CAAC,CAAC,UAAU,IAAI,UAAU,EACzE,CAAC;QACD,IAAI,CAAC,OAAO,GAAG,MAAM,CAAA;QACrB,MAAM,GAAG,MAAM,CAAC,OAAO,CAAA;IACzB,CAAC;IACD,MAAM,IAAI,GAAQ;QAChB,IAAI,EAAE,kBAAkB;QACxB,QAAQ,EAAE,KAAK,CAAC,KAAK;QACrB,IAAI,EAAE,IAAI,CAAC,OAAO;KACnB,CAAA;IACD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAQ,EAAE,IAAI,CAAC,CAAA;IACpC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAA;IACrB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAA;AAC3B,CAAC;AAED;;;;GAIG;AACH,SAAgB,GAAG;IACjB,MAAM,qBAAqB,GAAG,CAAC,IAAa,EAAE,EAAE,CAC9C,IAAI,CAAC,IAAI,KAAK,kBAAkB,IAAK,IAAY,CAAC,KAAK,CAAA;IAEzD,IAAI,CAAC,qBAAqB;QACxB,IAAI,CAAC,OAAO;YACZ,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,iBAAiB;YACvC,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,kBAAkB;gBACvC,qBAAqB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAA;IAExC,IAAI,CAAC,kBAAkB,GAAG,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAA;IACtE,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC5B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAA;IACvB,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,SAAgB,MAAM,CAAe,GAAmB;IACtD,IAAI,CAAC,kBAAkB,CAAC;QACtB,IAAI,EAAE,kBAAkB;QACxB,IAAI,EAAE,GAAG;QACT,QAAQ,EAAE,IAAI,CAAC,UAAW,CAAC,UAAU,EAAE;QACvC,OAAO,EAAE,IAAI,CAAC,OAAO;KACf,CAAC,CAAA;AACX,CAAC;AAED;;;;GAIG;AACH,SAAgB,YAAY;IAC1B,IAAI,CAAC,kBAAkB,CAAC;QACtB,IAAI,EAAE,cAAc;QACpB,IAAI,EAAG,IAAI,CAAC,OAAe,CAAC,KAAK;QACjC,IAAI,EAAE,EAAE;QACR,IAAI,EAAE,WAAW;KACX,CAAC,CAAA;AACX,CAAC;AAED;;;GAGG;AACH,SAAgB,UAAU,CAAe,KAAY;IACnD,MAAM,IAAI,GAAQ;QAChB,IAAI,EAAE,YAAY;QAClB,KAAK,EAAE,KAAK,CAAC,KAAK;KACnB,CAAA;IACD,IAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC/B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,OAAO,CAAA;QACxB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAA;QAC7B,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAA;IACpC,CAAC;SAAM,CAAC;QACN,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC5B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAA;YACpB,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAA;QACjC,CAAC;QACD,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAA;IAC3B,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,SAAgB,OAAO,CAAe,KAAY;IAChD,IAAI,CAAC,cAAc,CAAC;QAClB,IAAI,EAAE,SAAS;QACf,KAAK,EAAE,KAAK,CAAC,KAAK;KACZ,CAAC,CAAA;AACX,CAAC;AAED;;;;GAIG;AACH,SAAgB,cAAc,CAAe,KAAY;IACvD,MAAM,KAAK,GAAiE,EAAE,CAAA;IAE9E,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;QAC/B,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC3B,KAAK,CAAC,IAAI,CAAC;gBACT,IAAI,EAAE,QAAQ;gBACd,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,uBAAuB,CAAC,IAAI,CAAC,KAAK,CAAC;aACvD,CAAC,CAAA;QACJ,CAAC;aAAM,CAAC;YACN,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YAClD,MAAM,SAAS,GAAG,IAAK,IAAI,CAAC,WAAmB,CAC7C,IAAI,CAAC,QAAQ,EACb,IAAI,CAAC,MAAM,CACZ,CAAA;YACD,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,CAAA;YAC9B,MAAM,MAAM,GAAG,SAAS,CAAC,QAAQ,EAAE,CAAA;YAEnC,IAAI,CAAC,MAAM,EAAE,CAAC;gBACZ,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAA;YAC3D,CAAC;YAED,KAAK,CAAC,IAAI,CAAC;gBACT,IAAI,EAAE,YAAY;gBAClB,KAAK,EAAE,MAAM;aACd,CAAC,CAAA;QACJ,CAAC;IACH,CAAC;IAED,IAAI,CAAC,cAAc,CAAC;QAClB,IAAI,EAAE,iBAAiB;QACvB,KAAK,EAAE,KAAK;KACN,CAAC,CAAA;AACX,CAAC;AAED;;;GAGG;AACH,SAAgB,MAAM,CAAe,KAAY;IAC/C,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC,KAAK,CAAA;AAC/B,CAAC;AAED;;;GAGG;AACH,SAAgB,QAAQ;IACtB,IAAI,CAAC,cAAc,CAAC;QAClB,IAAI,EAAE,eAAe;QACrB,KAAK,EAAE,EAAE;KACH,CAAC,CAAA;AACX,CAAC;AAED;;;;GAIG;AACH,SAAgB,MAAM,CAAe,GAAmB;IACtD,CAAC;IAAC,IAAI,CAAC,OAAe,CAAC,KAAK,CAAC,IAAI,CAAC,UAAW,CAAC,GAAG,GAAG,CAAA;AACtD,CAAC;AAED;;;;GAIG;AACH,SAAgB,aAAa,CAAe,GAAmB;IAC7D,IAAI,CAAC,cAAc,CAAC,GAAI,CAAC,CAAA;AAC3B,CAAC;AAED;;;GAGG;AACH,SAAgB,UAAU,CAAe,GAAmB;IAC1D,CAAC;IAAC,IAAI,CAAC,OAAe,CAAC,SAAS,GAAG,GAAG,CAAA;AACxC,CAAC;AAED;;;GAGG;AACH,SAAgB,UAAU,CAAe,GAAmB;IAC1D,CAAC;IAAC,IAAI,CAAC,OAAe,CAAC,UAAU,GAAG,GAAG,CAAA;AACzC,CAAC;AAED;;;;GAIG;AACH,SAAgB,YAAY;IAC1B,IAAI,CAAC,KAAK,GAAG;QACX,IAAI,EAAE,uBAAuB;QAC7B,IAAI,EAAE,IAAI,CAAC,KAAK;KACV,CAAA;IACR,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,KAAK,CAAA;AAC3B,CAAC;AAED;;;;GAIG;AACH,SAAgB,SAAS,CAAe,KAAY;IAClD,IAAI,CAAC,kBAAkB,CAAC;QACtB,IAAI,EAAE,cAAc;QACpB,IAAI,EAAE,KAAK,CAAC,KAAK;QACjB,IAAI,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC;QACpB,IAAI,EAAE,YAAY;KACZ,CAAC,CAAA;AACX,CAAC;AAED;;;;GAIG;AACH,SAAgB,OAAO,CAAe,KAAY;IAChD,IAAI,CAAC,cAAc,CAAC;QAClB,IAAI,EAAE,iBAAiB;QACvB,QAAQ,EAAE,KAAK,CAAC,KAAK;KACf,CAAC,CAAA;AACX,CAAC;AAED;;GAEG;AACH,SAAgB,SAAS;IACvB,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC/B,IAAI,CAAC,oBAAoB,GAAG,CAAC,IAAI,CAAC,KAAM,CAAC,CAAA;IAC3C,CAAC;SAAM,CAAC;QACN,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAM,CAAC,CAAA;IAC7C,CAAC;IAED,IAAI,CAAC,KAAK,GAAG,IAAI,CAAA;IACjB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAA;IACnB,IAAI,CAAC,MAAM,GAAG,eAAe,CAAA;AAC/B,CAAC"}

package/dist/parser/states.d.ts

@@ -0,0 +1,47 @@
+import type { AstNode } from '../types.ts';
+import type Parser from './Parser.ts';
+interface TokenTypeOptions {
+    toState?: string;
+    handler?: (this: Parser, ...args: any[]) => void;
+}
+interface StateDefinition {
+    tokenTypes?: Record<string, TokenTypeOptions>;
+    subHandler?: (this: Parser, ast: AstNode | null) => void;
+    endStates?: Record<string, string>;
+    completable?: boolean;
+}
+type States = Record<string, StateDefinition>;
+/**
+ * A mapping of all states in the finite state machine to a set of instructions
+ * for handling or transitioning into other states. Each state can be handled
+ * in one of two schemes: a tokenType map, or a subHandler.
+ *
+ * Standard expression elements are handled through the tokenType object. This
+ * is an object map of all legal token types to encounter in this state (and
+ * any unexpected token types will generate a thrown error) to an options
+ * object that defines how they're handled.  The available options are:
+ *
+ *      {string} toState: The name of the state to which to transition
+ *          immediately after handling this token
+ *      {string} handler: The handler function to call when this token type is
+ *          encountered in this state.  If omitted, the default handler
+ *          matching the token's "type" property will be called. If the handler
+ *          function does not exist, no call will be made and no error will be
+ *          generated.  This is useful for tokens whose sole purpose is to
+ *          transition to other states.
+ *
+ * States that consume a subexpression should define a subHandler, the
+ * function to be called with an expression tree argument when the
+ * subexpression is complete. Completeness is determined through the
+ * endStates object, which maps tokens on which an expression should end to the
+ * state to which to transition once the subHandler function has been called.
+ *
+ * Additionally, any state in which it is legal to mark the AST as completed
+ * should have a 'completable' property set to boolean true.  Attempting to
+ * call {@link Parser#complete} in any state without this property will result
+ * in a thrown Error.
+ *
+ * @type {{}}
+ */
+export declare const states: States;
+export {};

package/dist/parser/states.js

@@ -0,0 +1,195 @@
+"use strict";
+/*
+ * Jexl
+ * Copyright 2020 Tom Shawver
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.states = void 0;
+const h = __importStar(require("./handlers.js"));
+/**
+ * A mapping of all states in the finite state machine to a set of instructions
+ * for handling or transitioning into other states. Each state can be handled
+ * in one of two schemes: a tokenType map, or a subHandler.
+ *
+ * Standard expression elements are handled through the tokenType object. This
+ * is an object map of all legal token types to encounter in this state (and
+ * any unexpected token types will generate a thrown error) to an options
+ * object that defines how they're handled.  The available options are:
+ *
+ *      {string} toState: The name of the state to which to transition
+ *          immediately after handling this token
+ *      {string} handler: The handler function to call when this token type is
+ *          encountered in this state.  If omitted, the default handler
+ *          matching the token's "type" property will be called. If the handler
+ *          function does not exist, no call will be made and no error will be
+ *          generated.  This is useful for tokens whose sole purpose is to
+ *          transition to other states.
+ *
+ * States that consume a subexpression should define a subHandler, the
+ * function to be called with an expression tree argument when the
+ * subexpression is complete. Completeness is determined through the
+ * endStates object, which maps tokens on which an expression should end to the
+ * state to which to transition once the subHandler function has been called.
+ *
+ * Additionally, any state in which it is legal to mark the AST as completed
+ * should have a 'completable' property set to boolean true.  Attempting to
+ * call {@link Parser#complete} in any state without this property will result
+ * in a thrown Error.
+ *
+ * @type {{}}
+ */
+exports.states = {
+    expectOperand: {
+        tokenTypes: {
+            literal: { toState: 'expectBinOp' },
+            templateString: { toState: 'expectBinOp' },
+            identifier: { toState: 'identifier' },
+            unaryOp: {},
+            openParen: { toState: 'subExpression' },
+            openCurl: { toState: 'expectObjKey', handler: h.objStart },
+            dot: { toState: 'traverse' },
+            openBracket: { toState: 'arrayVal', handler: h.arrayStart }
+        }
+    },
+    expectBinOp: {
+        tokenTypes: {
+            binaryOp: { toState: 'expectOperand' },
+            pipe: { toState: 'expectTransform' },
+            dot: { toState: 'traverse' },
+            question: { toState: 'ternaryMid', handler: h.ternaryStart },
+            semicolon: { handler: h.semicolon }
+        },
+        completable: true
+    },
+    expectTransform: {
+        tokenTypes: {
+            identifier: { toState: 'postTransform', handler: h.transform }
+        }
+    },
+    expectObjKey: {
+        tokenTypes: {
+            literal: { toState: 'expectKeyValSep', handler: h.objKey },
+            identifier: { toState: 'expectKeyValSep', handler: h.objKey },
+            closeCurl: { toState: 'expectBinOp' }
+        }
+    },
+    expectKeyValSep: {
+        tokenTypes: {
+            colon: { toState: 'objVal' }
+        }
+    },
+    postTransform: {
+        tokenTypes: {
+            openParen: { toState: 'argVal' },
+            binaryOp: { toState: 'expectOperand' },
+            dot: { toState: 'traverse' },
+            openBracket: { toState: 'filter' },
+            pipe: { toState: 'expectTransform' },
+            question: { toState: 'ternaryMid', handler: h.ternaryStart }
+        },
+        completable: true
+    },
+    postArgs: {
+        tokenTypes: {
+            binaryOp: { toState: 'expectOperand' },
+            dot: { toState: 'traverse' },
+            openBracket: { toState: 'filter' },
+            pipe: { toState: 'expectTransform' },
+            question: { toState: 'ternaryMid', handler: h.ternaryStart }
+        },
+        completable: true
+    },
+    identifier: {
+        tokenTypes: {
+            binaryOp: { toState: 'expectOperand' },
+            dot: { toState: 'traverse' },
+            openBracket: { toState: 'filter' },
+            openParen: { toState: 'argVal', handler: h.functionCall },
+            pipe: { toState: 'expectTransform' },
+            question: { toState: 'ternaryMid', handler: h.ternaryStart }
+        },
+        completable: true
+    },
+    traverse: {
+        tokenTypes: {
+            identifier: { toState: 'identifier' }
+        }
+    },
+    filter: {
+        subHandler: h.filter,
+        endStates: {
+            closeBracket: 'identifier'
+        }
+    },
+    subExpression: {
+        subHandler: h.subExpression,
+        endStates: {
+            closeParen: 'expectBinOp'
+        }
+    },
+    argVal: {
+        subHandler: h.argVal,
+        endStates: {
+            comma: 'argVal',
+            closeParen: 'postArgs'
+        }
+    },
+    objVal: {
+        subHandler: h.objVal,
+        endStates: {
+            comma: 'expectObjKey',
+            closeCurl: 'expectBinOp'
+        }
+    },
+    arrayVal: {
+        subHandler: h.arrayVal,
+        endStates: {
+            comma: 'arrayVal',
+            closeBracket: 'expectBinOp'
+        }
+    },
+    ternaryMid: {
+        subHandler: h.ternaryMid,
+        endStates: {
+            colon: 'ternaryEnd'
+        }
+    },
+    ternaryEnd: {
+        subHandler: h.ternaryEnd,
+        completable: true
+    }
+};
+//# sourceMappingURL=states.js.map

package/dist/parser/states.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"states.js","sourceRoot":"","sources":["../../src/parser/states.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,iDAAkC;AAmBlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACU,QAAA,MAAM,GAAW;IAC5B,aAAa,EAAE;QACb,UAAU,EAAE;YACV,OAAO,EAAE,EAAE,OAAO,EAAE,aAAa,EAAE;YACnC,cAAc,EAAE,EAAE,OAAO,EAAE,aAAa,EAAE;YAC1C,UAAU,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE;YACrC,OAAO,EAAE,EAAE;YACX,SAAS,EAAE,EAAE,OAAO,EAAE,eAAe,EAAE;YACvC,QAAQ,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE;YAC1D,GAAG,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE;YAC5B,WAAW,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC,CAAC,UAAU,EAAE;SAC5D;KACF;IACD,WAAW,EAAE;QACX,UAAU,EAAE;YACV,QAAQ,EAAE,EAAE,OAAO,EAAE,eAAe,EAAE;YACtC,IAAI,EAAE,EAAE,OAAO,EAAE,iBAAiB,EAAE;YACpC,GAAG,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE;YAC5B,QAAQ,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,CAAC,YAAY,EAAE;YAC5D,SAAS,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE;SACpC;QACD,WAAW,EAAE,IAAI;KAClB;IACD,eAAe,EAAE;QACf,UAAU,EAAE;YACV,UAAU,EAAE,EAAE,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,CAAC,CAAC,SAAS,EAAE;SAC/D;KACF;IACD,YAAY,EAAE;QACZ,UAAU,EAAE;YACV,OAAO,EAAE,EAAE,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;YAC1D,UAAU,EAAE,EAAE,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;YAC7D,SAAS,EAAE,EAAE,OAAO,EAAE,aAAa,EAAE;SACtC;KACF;IACD,eAAe,EAAE;QACf,UAAU,EAAE;YACV,KAAK,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE;SAC7B;KACF;IACD,aAAa,EAAE;QACb,UAAU,EAAE;YACV,SAAS,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE;YAChC,QAAQ,EAAE,EAAE,OAAO,EAAE,eAAe,EAAE;YACtC,GAAG,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE;YAC5B,WAAW,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE;YAClC,IAAI,EAAE,EAAE,OAAO,EAAE,iBAAiB,EAAE;YACpC,QAAQ,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,CAAC,YAAY,EAAE;SAC7D;QACD,WAAW,EAAE,IAAI;KAClB;IACD,QAAQ,EAAE;QACR,UAAU,EAAE;YACV,QAAQ,EAAE,EAAE,OAAO,EAAE,eAAe,EAAE;YACtC,GAAG,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE;YAC5B,WAAW,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE;YAClC,IAAI,EAAE,EAAE,OAAO,EAAE,iBAAiB,EAAE;YACpC,QAAQ,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,CAAC,YAAY,EAAE;SAC7D;QACD,WAAW,EAAE,IAAI;KAClB;IACD,UAAU,EAAE;QACV,UAAU,EAAE;YACV,QAAQ,EAAE,EAAE,OAAO,EAAE,eAAe,EAAE;YACtC,GAAG,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE;YAC5B,WAAW,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE;YAClC,SAAS,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC,YAAY,EAAE;YACzD,IAAI,EAAE,EAAE,OAAO,EAAE,iBAAiB,EAAE;YACpC,QAAQ,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,CAAC,YAAY,EAAE;SAC7D;QACD,WAAW,EAAE,IAAI;KAClB;IACD,QAAQ,EAAE;QACR,UAAU,EAAE;YACV,UAAU,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE;SACtC;KACF;IACD,MAAM,EAAE;QACN,UAAU,EAAE,CAAC,CAAC,MAAM;QACpB,SAAS,EAAE;YACT,YAAY,EAAE,YAAY;SAC3B;KACF;IACD,aAAa,EAAE;QACb,UAAU,EAAE,CAAC,CAAC,aAAa;QAC3B,SAAS,EAAE;YACT,UAAU,EAAE,aAAa;SAC1B;KACF;IACD,MAAM,EAAE;QACN,UAAU,EAAE,CAAC,CAAC,MAAM;QACpB,SAAS,EAAE;YACT,KAAK,EAAE,QAAQ;YACf,UAAU,EAAE,UAAU;SACvB;KACF;IACD,MAAM,EAAE;QACN,UAAU,EAAE,CAAC,CAAC,MAAM;QACpB,SAAS,EAAE;YACT,KAAK,EAAE,cAAc;YACrB,SAAS,EAAE,aAAa;SACzB;KACF;IACD,QAAQ,EAAE;QACR,UAAU,EAAE,CAAC,CAAC,QAAQ;QACtB,SAAS,EAAE;YACT,KAAK,EAAE,UAAU;YACjB,YAAY,EAAE,aAAa;SAC5B;KACF;IACD,UAAU,EAAE;QACV,UAAU,EAAE,CAAC,CAAC,UAAU;QACxB,SAAS,EAAE;YACT,KAAK,EAAE,YAAY;SACpB;KACF;IACD,UAAU,EAAE;QACV,UAAU,EAAE,CAAC,CAAC,UAAU;QACxB,WAAW,EAAE,IAAI;KAClB;CACF,CAAA"}

package/dist/types.d.ts

@@ -0,0 +1,77 @@
+export interface Token {
+    type: string;
+    value: any;
+    raw: string;
+}
+export interface AstNode {
+    type: string;
+    _parent?: AstNode;
+}
+export interface Literal extends AstNode {
+    type: 'Literal';
+    value: string | number | boolean;
+}
+export interface Identifier extends AstNode {
+    type: 'Identifier';
+    value: string;
+    from?: AstNode;
+    relative?: boolean;
+}
+export interface BinaryExpression extends AstNode {
+    type: 'BinaryExpression';
+    operator: string;
+    left: AstNode;
+    right?: AstNode;
+}
+export interface UnaryExpression extends AstNode {
+    type: 'UnaryExpression';
+    operator: string;
+    right?: AstNode;
+}
+export interface ArrayLiteral extends AstNode {
+    type: 'ArrayLiteral';
+    value: AstNode[];
+}
+export interface ObjectLiteral extends AstNode {
+    type: 'ObjectLiteral';
+    value: Record<string, AstNode>;
+}
+export interface TemplateLiteral extends AstNode {
+    type: 'TemplateLiteral';
+    parts: {
+        type: 'static' | 'expression';
+        value: string | AstNode;
+    }[];
+}
+export interface FunctionCall extends AstNode {
+    type: 'FunctionCall';
+    name: string;
+    args: AstNode[];
+    pool: 'functions' | 'transforms';
+}
+export interface FilterExpression extends AstNode {
+    type: 'FilterExpression';
+    expr: AstNode;
+    relative: boolean;
+    subject: AstNode;
+}
+export interface ConditionalExpression extends AstNode {
+    type: 'ConditionalExpression';
+    test: AstNode;
+    consequent?: AstNode;
+    alternate?: AstNode;
+}
+export interface SequenceExpression extends AstNode {
+    type: 'SequenceExpression';
+    expressions: AstNode[];
+}
+export interface AssignmentExpression extends AstNode {
+    type: 'AssignmentExpression';
+    operator: '=';
+    left: Identifier;
+    right: AstNode;
+}
+export type AstNodeUnion = Literal | Identifier | BinaryExpression | UnaryExpression | ArrayLiteral | ObjectLiteral | TemplateLiteral | FunctionCall | FilterExpression | ConditionalExpression | SequenceExpression | AssignmentExpression;
+export type NodeByType<T extends AstNodeUnion['type']> = Extract<AstNodeUnion, {
+    type: T;
+}>;

package/dist/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/*
+ * Jexl
+ * Copyright 2020 Tom Shawver
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";AAAA;;;GAGG"}

package/esm/Expression.d.ts

@@ -0,0 +1,38 @@
+import PromiseSync from './PromiseSync.ts';
+import type { AstNode } from './types.ts';
+interface Grammar {
+    elements: Record<string, any>;
+    [key: string]: any;
+}
+type PromiseConstructor = typeof Promise | typeof PromiseSync;
+declare class Expression {
+    _grammar: Grammar;
+    _exprStr: string;
+    _ast: AstNode | null;
+    constructor(grammar: Grammar, exprStr: string);
+    /**
+     * Forces a compilation of the expression string that this Expression object
+     * was constructed with. This function can be called multiple times; useful
+     * if the language elements of the associated Jexl instance change.
+     * @returns {Expression} this Expression instance, for convenience
+     */
+    compile(): this;
+    /**
+     * Asynchronously evaluates the expression within an optional context.
+     * @param {Object} [context] A mapping of variables to values, which will be
+     *      made accessible to the Jexl expression when evaluating it
+     * @returns {Promise<*>} resolves with the result of the evaluation.
+     */
+    eval(context?: {}): Promise<any> | PromiseSync<any>;
+    /**
+     * Synchronously evaluates the expression within an optional context.
+     * @param {Object} [context] A mapping of variables to values, which will be
+     *      made accessible to the Jexl expression when evaluating it
+     * @returns {*} the result of the evaluation.
+     * @throws {*} on error
+     */
+    evalSync(context?: {}): unknown;
+    _eval(context: any, promise: PromiseConstructor): Promise<any> | PromiseSync<any>;
+    _getAst(): AstNode | null;
+}
+export default Expression;