@jbrowse/jexl 3.0.2 → 3.1.0

package/CHANGELOG.md

@@ -1,249 +0,0 @@
-# Jexl Change Log
-
-This project adheres to [Semantic Versioning](http://semver.org/).
-
-## [development]
-
-Nothing yet!
-
-## [v3.0.0]
-
-### BREAKING CHANGES
-
-- **Removed async evaluation support**: Jexl now only supports synchronous evaluation
-- **Renamed methods**: `evalSync()` has been renamed to `eval()`. The async `eval()` method has been removed.
-- **Removed PromiseSync class**: Internal implementation detail removed
-- **Removed transforms**: The transform/pipe operator (`|`) has been completely removed. Use functions instead.
-- **Removed array filtering**: Relative filter expressions (e.g., `array[.property == value]`) have been removed. Bracket notation for array/object access (e.g., `array[0]`, `object["key"]`) still works.
-- **Removed transform methods**: `addTransform()`, `addTransforms()`, and `getTransform()` have been removed.
-
-### Changed
-
-- Simplified codebase by removing Promise/PromiseSync abstraction layer
-- All evaluation is now synchronous, improving performance and simplifying error handling
-- Errors are now thrown directly rather than being rejected Promises
-- Removed pipe operator (`|`) from grammar
-- Removed filter bracket syntax for relative filtering
-
-### Migration Guide
-
-- Replace `await jexl.eval(expr)` with `jexl.eval(expr)` (remove await)
-- Replace `jexl.evalSync(expr)` with `jexl.eval(expr)` (remove Sync suffix)
-- Replace transforms with functions: change `value|transform(arg)` to `transform(value, arg)`
-- Remove uses of relative filtering syntax `array[.prop == value]` (note: direct indexing like `array[0]` still works)
-- Replace `.catch()` error handling with `try/catch` blocks
-
-## [v2.3.0]
-
-### Added
-
-- Top-level expression functions, along with `jexl.addFunction` and
-  `jexl.addFunctions`. (#25)
-- Binary operators can now be set to evaluate their operands manually, allowing
-  them to decide if and when to resolve the value of the left or right sides.
-  See the new `manualEval` option in `jexl.addBinaryOp`.
-- Support for Latin 1 Suppliment characters in identifiers (#68) (@heharkon)
-- Support for Russian chatacters in identifiers (#90) (@a-gorbunov)
-- ES5 build for browser support (#87) (@czosel)
-
-### Fixed
-
-- The binary operators `&&` and `||` now evaluate the right operand
-  conditionally, depending on the value of the left.
-
-## [v2.2.2]
-
-### Changes
-
-- Jexl now officially supports Node v12. It's been working, but now CI tests it!
-
-### Fixed
-
-- Accessing children of null should resolve to undefined rather than throwing
-  (#64)
-
-## [v2.2.1]
-
-### Fixed
-
-- Relative collection filters didn't function appropriately when evalSync was
-  used, as it would sometimes revert to using an actual Promise object.
-  (#61)
-
-## [v2.2.0]
-
-### Added
-
-- Introducing the `Expression` object, which allows expressions to be compiled
-  only once and evaluated many times
-- Get an Expression by calling `jexl.createExpression('2 + 2')`
-- Get a pre-compiled expression by calling `jexl.compile('2 + 2')`
-- Evaluate Expressions asyncronoushly or synchronously by calling
-  `myExpression.eval(context)` or `myExpression.evalSync(context)`
-- Create expressions using a convenient tagged template: `` jexl.expr`2 + 2` ``
-
-### Fixed
-
-- Transform errors did not always get thrown when using `evalSync` (#55, #56)
-  (@bitghostm)
-- Arbitrary whitespace is now re-supported (#54) (@czosel)
-- Strings were not tokenized correctly when ending with an escaped quote (#51)
-  (@rehandalal)
-- Identifier names can now start with `$` (#36) (@glromeo)
-
-## [v2.1.1]
-
-### Fixed
-
-- Applying a filter to an undefined identifier now returns an empty array
-  instead of an array with one undefined element.
-
-## [v2.1.0]
-
-### Added
-
-- Jexl now has synchronous evaluation! Just call `evalSync`.
-
-## [v2.0.2]
-
-### Fixed
-
-- Issue #47: Revert unintentional change to strict === and !== comparisons
-
-## [v2.0.1]
-
-### Fixed
-
-- Issue where Jexl might mistake an identifier as being relative to a parent
-  when it should refer to the top level of the context in one specific case
-
-## [v2.0.0]
-
-### Changed
-
-- The pre-minified Jexl has been removed; in modern times, frontend
-  webapps have their own build stack, and Jexl should't make assumptions
-  about the module format a frontend app wants to use.
-- Support for Node 4 and earlier has been dropped.
-- The codebase has been modernized to the subset of ES6 supported in
-  Node 6 LTS and beyond. Tests require Node 8 or later.
-- The codebase has been shifted to Standard JS style.
-- jexl.eval no longer accepts a callback function. Jexl is now promises-only.
-- Tests have been converted to Jest to eliminate sneaky error swallowing
-
-## [v1.1.4]
-
-### Fixed
-
-- Falsey identifiers are no longer treated as undefined
-
-## [v1.1.3]
-
-### Fixed
-
-- Binary operators after nested identifiers were not balanced properly,
-  resulting in a broken expression/AST
-- Gulp (or one of its plugins) had a breaking change in a minor release,
-  preventing the frontend build from running. This build method will be
-  removed from the next major version of Jexl. For now, Jexl is now version-
-  locked to the original gulp+plugins that worked.
-
-## [v1.1.2]
-
-### Changed
-
-- Code coverage thresholds are now enforced through `gulp coverage-test`
-
-### Fixed
-
-- Operators found in identifier names (such as 'in' in 'incident') were being
-  tokenized separately from the rest of the identifier
-
-## [v1.1.1]
-
-### Fixed
-
-- Minus did not denote a negative number at the start of a ternary's consequent
-  section
-
-## [v1.1.0]
-
-### Added
-
-- The ability to define new binary and unary operators, or override existing
-  ones.
-- The ability to delete existing binary and unary operators.
-
-## [v1.0.2]
-
-### Fixed
-
-- Bad Gulpfile resulted in frontend dist falling out of sync. Fixed and
-  re-synced.
-
-## [v1.0.1]
-
-### Changed
-
-- Refactored Parser and Evaluator. Both operations are now marginally faster.
-- Removed balance tracking in favor of passing maps of token types at which
-  the sub-parser should stop.
-
-### Fixed
-
-- Object literals could not be defined in the consequent section of a ternary
-  expression.
-
-## [v1.0.0]
-
-### Added
-
-- Object literals. Objects can now be defined inline with
-  `{standard: 'syntax'}`.
-- Array literals. Arrays can also be defined with `["standard", 'syntax']`.
-- The 'in' operator, for checking to see if a string appears inside a larger
-  string, or if an element exists in an array.
-- Ternary expressions with `this ? "standard" : "syntax"`
-- Ternary expressions with `alternate ?: "syntax"`
-
-### Changed
-
-- Simplified Grammar, reduced RAM footprint
-- Dot notation can now be used to access properties of literals, such as
-  `"someString".length` or `{foo: 'bar'}.foo`.
-- Transform syntax has changed. Arguments are now passed in parentheses, and
-  multiple arguments can be defined. Arguments are no longer limited to object
-  literals.
-
-## [v0.2.0]
-
-### Added
-
-- "Divide and floor" operator: //
-- Documentation outlining running expressions against XML.
-
-## v0.1.0
-
-### Added
-
-- Initial release
-
-[development]: https://github.com/TomFrost/Jexl/compare/v2.3.0...HEAD
-[v2.3.0]: https://github.com/TomFrost/Jexl/compare/v2.2.2...v2.3.0
-[v2.2.2]: https://github.com/TomFrost/Jexl/compare/v2.2.1...v2.2.2
-[v2.2.1]: https://github.com/TomFrost/Jexl/compare/v2.2.0...v2.2.1
-[v2.2.0]: https://github.com/TomFrost/Jexl/compare/v2.1.1...v2.2.0
-[v2.1.1]: https://github.com/TomFrost/Jexl/compare/v2.1.0...v2.1.1
-[v2.1.0]: https://github.com/TomFrost/Jexl/compare/v2.0.2...v2.1.0
-[v2.0.2]: https://github.com/TomFrost/Jexl/compare/v2.0.1...v2.0.2
-[v2.0.1]: https://github.com/TomFrost/Jexl/compare/v2.0.0...v2.0.1
-[v2.0.0]: https://github.com/TomFrost/Jexl/compare/1.1.4...v2.0.0
-[v1.1.4]: https://github.com/TomFrost/Jexl/compare/1.1.3...1.1.4
-[v1.1.3]: https://github.com/TomFrost/Jexl/compare/1.1.2...1.1.3
-[v1.1.2]: https://github.com/TomFrost/Jexl/compare/1.1.1...1.1.2
-[v1.1.1]: https://github.com/TomFrost/Jexl/compare/1.1.0...1.1.1
-[v1.1.0]: https://github.com/TomFrost/Jexl/compare/1.0.2...1.1.0
-[v1.0.2]: https://github.com/TomFrost/Jexl/compare/1.0.1...1.0.2
-[v1.0.1]: https://github.com/TomFrost/Jexl/compare/1.0.0...1.0.1
-[v1.0.0]: https://github.com/TomFrost/Jexl/compare/0.2.0...1.0.0
-[v0.2.0]: https://github.com/TomFrost/Jexl/compare/0.1.0...0.2.0

package/dist/evaluator/handlers.d.ts

@@ -1,112 +0,0 @@
-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 {[]} an array of 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
- * 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 {*} 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 returning 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 bracket notation for array/object access.
- * Note: Relative filtering (with leading dot) is not supported.
- * @param {{type: 'FilterExpression', relative: <boolean>, expr: {},
- *      subject: {}}} ast An expression tree with a FilterExpression as the top
- *      node
- * @returns {*} the value at the specified index/property.
- * @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 {*} 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 {string} 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 {{}} a map of evaluated values.
- * @private
- */
-export declare function ObjectLiteral(this: Evaluator, ast: any): {
-    [k: string]: 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 {*} the value of the function call.
- * @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 {*} 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/dist/evaluator/handlers.js

@@ -1,208 +0,0 @@
-"use strict";
-/*
- * Jexl
- * Copyright 2020 Tom Shawver
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayLiteral = ArrayLiteral;
-exports.BinaryExpression = BinaryExpression;
-exports.ConditionalExpression = ConditionalExpression;
-exports.FilterExpression = FilterExpression;
-exports.Identifier = Identifier;
-exports.Literal = Literal;
-exports.TemplateLiteral = TemplateLiteral;
-exports.ObjectLiteral = ObjectLiteral;
-exports.FunctionCall = FunctionCall;
-exports.UnaryExpression = UnaryExpression;
-exports.SequenceExpression = SequenceExpression;
-exports.AssignmentExpression = AssignmentExpression;
-const poolNames = {
-    functions: 'Jexl Function'
-};
-/**
- * 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 {[]} an array of evaluated values.
- * @private
- */
-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
- * 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 {*} the value of the BinaryExpression.
- * @private
- */
-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));
-    }
-    const left = this.eval(ast.left);
-    const right = this.eval(ast.right);
-    return grammarOp.eval(left, right);
-}
-/**
- * Evaluates a ConditionalExpression node by first evaluating its test branch,
- * and returning 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
- */
-function ConditionalExpression(ast) {
-    const res = this.eval(ast.test);
-    if (res) {
-        return ast.consequent ? this.eval(ast.consequent) : res;
-    }
-    return this.eval(ast.alternate);
-}
-/**
- * Evaluates a FilterExpression by applying bracket notation for array/object access.
- * Note: Relative filtering (with leading dot) is not supported.
- * @param {{type: 'FilterExpression', relative: <boolean>, expr: {},
- *      subject: {}}} ast An expression tree with a FilterExpression as the top
- *      node
- * @returns {*} the value at the specified index/property.
- * @private
- */
-function FilterExpression(ast) {
-    const subject = this.eval(ast.subject);
-    if (ast.relative) {
-        throw new Error('Relative filter expressions are not supported');
-    }
-    const index = this.eval(ast.expr);
-    return subject?.[index];
-}
-/**
- * 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 {*} the identifier's value.
- * @private
- */
-function Identifier(ast) {
-    if (!ast.from) {
-        const contextSource = ast.relative ? this._relContext : this._context;
-        return contextSource[ast.value];
-    }
-    const context = this.eval(ast.from);
-    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
- */
-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 {string} the final interpolated string
- * @private
- */
-function TemplateLiteral(ast) {
-    const values = ast.parts.map((part) => {
-        if (part.type === 'static') {
-            return part.value;
-        }
-        const result = this.eval(part.value);
-        if (result == null) {
-            return '';
-        }
-        return String(result);
-    });
-    return 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 {{}} a map of evaluated values.
- * @private
- */
-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 {*} the value of the function call.
- * @private
- */
-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.`);
-    }
-    const args = this.evalArray(ast.args || []);
-    return 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 {*} the value of the UnaryExpression.
- * @constructor
- */
-function UnaryExpression(ast) {
-    const right = this.eval(ast.right);
-    return this._grammar.elements[ast.operator].eval(right);
-}
-/**
- * Evaluates a SequenceExpression by evaluating each expression in order
- * and returning the value of the last expression.
- */
-function SequenceExpression(ast) {
-    let lastValue;
-    for (const expr of ast.expressions) {
-        lastValue = this.eval(expr);
-    }
-    return lastValue;
-}
-/**
- * Evaluates an AssignmentExpression by evaluating the right side
- * and assigning it to the variable name on the left side.
- */
-function AssignmentExpression(ast) {
-    const value = this.eval(ast.right);
-    const varName = ast.left.value;
-    this._context[varName] = value;
-    return value;
-}
-//# sourceMappingURL=handlers.js.map

package/dist/evaluator/handlers.js.map

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

package/esm/evaluator/handlers.d.ts

@@ -1,112 +0,0 @@
-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 {[]} an array of 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
- * 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 {*} 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 returning 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 bracket notation for array/object access.
- * Note: Relative filtering (with leading dot) is not supported.
- * @param {{type: 'FilterExpression', relative: <boolean>, expr: {},
- *      subject: {}}} ast An expression tree with a FilterExpression as the top
- *      node
- * @returns {*} the value at the specified index/property.
- * @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 {*} 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 {string} 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 {{}} a map of evaluated values.
- * @private
- */
-export declare function ObjectLiteral(this: Evaluator, ast: any): {
-    [k: string]: 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 {*} the value of the function call.
- * @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 {*} 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;