@zvenigora/jse-eval/dist/jse-eval.cjs.map

JavaScript expression parsing and evaluation.

{"version":3,"file":"jse-eval.cjs","sources":["../types.ts","../utils.ts","../index.ts"],"sourcesContent":["export declare type Context = Record<string, unknown>;\n\nexport type FunctionBindings = {\n  thisRef?: Context,\n  arguments?: unknown[]\n}\n\nexport type Scope = {\n  options?: Options;\n}\n\nexport type Options = {\n  caseSensitive?: boolean;\n  blockList?: string[];\n  allowList?: string[];\n  functionBindings?: Record<string, FunctionBindings>;\n  scopes?: Record<string, Scope>;\n  currentScopeName?: string;\n  globalScopeName?: string;\n}\n\nexport const literals: Context = {\n  'undefined': undefined,\n  'null': null,\n  'true': true,\n  'false': false,\n}\n","import { Context, Options, FunctionBindings, Scope } from './types';\n\nexport class Utils {\n\n  public static getValue(obj: Context, name: string, \n    options?: Options): unknown | undefined {\n\n    const keyValue: [string | number, unknown, string] | undefined = Utils.getScopedKeyValue(obj, name, options);\n    if (typeof keyValue === 'undefined') {\n      return undefined;\n    }\n    const [, value, scopeName] = keyValue;\n\n    const fn = Utils.getBindFunction(value, name, options, scopeName);\n    if (typeof fn === 'function') {\n      return fn;\n    }\n      \n    return value;\n  }\n\n  public static getScopePair(obj: unknown, name: string, \n    options?: Options): [string | number, Scope] | undefined{\n\n    if (typeof obj !== 'undefined' && options?.scopes) {\n      const keyValue = Utils.getKeyValue(options.scopes, name, options);\n      if (typeof keyValue !== 'undefined') {\n        const [key, value] = keyValue;\n        if (value) {\n          const scope: Scope = value;\n          return [key, scope];\n        }\n      }\n    }\n    return undefined;\n  }\n\n  private static getBindFunction(obj: unknown, name: string, \n    options?: Options, scopeName?: string): ((...args: unknown[]) => unknown) | undefined {\n\n    const scopedOptions = Utils.hasProperty(options?.scopes, scopeName) \n      ? options?.scopes[scopeName]?.options : options;\n    \n    if (typeof obj === 'function' && scopedOptions?.functionBindings) {\n      const keyValue = Utils.getKeyValue(scopedOptions.functionBindings, name, options);\n      if (typeof keyValue !== 'undefined') {\n        const [, value] = keyValue;\n        if (value) {\n          const bindings: FunctionBindings = value;\n          if (bindings?.arguments) {\n            const args: unknown[] = bindings.arguments;\n            const fn = obj.bind(bindings?.thisRef, ...args) as (...args: unknown[]) => unknown;\n            return fn;\n          } else {\n            const fn = obj.bind(bindings?.thisRef) as (...args: unknown[]) => unknown;\n            return fn;\n          }\n        }\n      }\n    }\n    return undefined;\n  }\n\n  private static hasProperty(obj?: Context, name?: string): boolean {\n    if (obj && name) {\n      return Object.prototype.hasOwnProperty.call(obj, name) as boolean;\n    }\n    return false;\n  }\n\n  private static getScopedKeyValue(obj: Context, name: string | number, \n    options?: Options): [string | number, unknown, string] | undefined {\n\n    const scopeNameList: string[] = [''];\n    const currentScope = Utils.hasProperty(obj, options?.currentScopeName) && \n                         Utils.hasProperty(options?.scopes, options?.currentScopeName); \n    const globalScope = Utils.hasProperty(obj, options?.globalScopeName) && \n                        Utils.hasProperty(options?.scopes, options?.globalScopeName);\n\n    if (currentScope) {\n      scopeNameList.push(options?.currentScopeName);\n    }\n    if (globalScope) {\n      scopeNameList.push(options?.globalScopeName);\n    }\n\n    for (const scopeName of scopeNameList) {\n      const scopedObject = (scopeName ? obj[scopeName] : obj) as Context;\n      const keyValue = this.getKeyValue(scopedObject, name, options);\n      if (typeof keyValue !== 'undefined') {\n        const [key, value] = keyValue;\n        return [key, value, scopeName];\n      }\n    }\n\n    return undefined;\n  }\n\n  public static getKeyValue(obj: Context, name: string | number, \n    options?: Options): [string | number, unknown] | undefined {\n\n    Utils.blockListTest(obj, name, options);\n    Utils.allowListTest(obj, name, options);\n\n    if (options?.caseSensitive || typeof name !== 'string') {\n      const value = obj[name];\n      return [name, value];\n    }\n\n    if (typeof name === 'string') {\n      let currentObj = obj;\n      do {\n        const keys: string[] = Object.getOwnPropertyNames(currentObj);\n        if (Array.isArray(keys)) {\n          const key = keys.find(key => key.localeCompare(name, 'en', { sensitivity: 'base' }) === 0);\n          if (key) {\n            const value = currentObj[key];\n            return [key, value];\n          }\n        }\n      } while ((currentObj = Object.getPrototypeOf(currentObj)));\n    }\n\n    return undefined;\n  }\n\n  public static getLiteralKeyValue(obj: Context, name: string, \n    options?: Options): [string, unknown] | undefined {\n\n    Utils.blockListTest(obj, name, options);\n    Utils.allowListTest(obj, name, options);\n  \n    if (options?.caseSensitive) {\n      return [name, obj[name]];\n    } else {\n      for (const [key, value] of Object.entries(obj)) {\n        const found = key.localeCompare(name, 'en', { sensitivity: 'base' }) === 0;\n        if (found) {\n          return [key, value];\n        }\n      }\n    }\n    return undefined;\n  }\n\n  public static blockListTest(obj: Context, name: string | number, \n    options?: Options): void {\n\n    if (options?.blockList && typeof name === 'string') {\n\n      const find = options.caseSensitive \n        ? options.blockList.find(key => key === name)\n        : options.blockList.find(key => key.localeCompare(name, 'en', { sensitivity: 'base' }) === 0);\n\n      if (find) {\n        throw Error(`Access to member \"${name}\" from blockList is not permitted.`);        \n      }\n    }\n  }\n\n  public static allowListTest(obj: Context, name: string | number, \n    options?: Options): void {\n\n    if (options?.allowList && typeof name === 'string') {\n\n      const find = options?.caseSensitive \n        ? options.allowList.find(key => key === name)\n        : options.allowList.find(key => key.localeCompare(name, 'en', { sensitivity: 'base' }) === 0);\n\n      if (!find) {\n        throw Error(`Access to member \"${name}\" not in allowList is not permitted.`);        \n      }\n    }\n  }\n\n}\n","import { ArrowExpression } from '@jsep-plugin/arrow';\nimport { AssignmentExpression, UpdateExpression } from '@jsep-plugin/assignment';\nimport { AwaitExpression } from '@jsep-plugin/async-await';\nimport { NewExpression } from '@jsep-plugin/new';\nimport { ObjectExpression, Property } from '@jsep-plugin/object';\nimport { SpreadElement } from '@jsep-plugin/spread';\nimport { TaggedTemplateExpression, TemplateLiteral } from '@jsep-plugin/template';\nimport jsep from 'jsep';\n\nimport { Context, Options, Scope, literals } from './types';\nimport { Utils } from './utils';\n\n/**\n * Evaluation code from JSEP project, under MIT License.\n * Copyright (c) 2013 Stephen Oney, http://jsep.from.so/\n */\n\nexport declare type operand = any;\nexport declare type unaryCallback = (a: operand) => operand;\nexport declare type binaryCallback = (a: operand, b: operand) => operand;\nexport declare type assignCallback = (obj: Record<string, operand>, key: string, val: operand) => operand;\nexport declare type evaluatorCallback<T extends AnyExpression> = (this: ExpressionEval, node: T, context?: Context) => unknown;\nexport declare type predicateCallback<T extends AnyExpression> = \n  (node: T, context?: Context) => boolean;\nexport declare type conditionalEvaluator<T extends AnyExpression> = \n  {predicate: predicateCallback<T>, evaluator: evaluatorCallback<T>};\n\nexport type AnyExpression = jsep.Expression & {_value?: unknown, _scope?: Scope};\n\nexport type JseEvalPlugin = Partial<jsep.IPlugin> & {\n  initEval?: (this: typeof ExpressionEval, jseEval: typeof ExpressionEval) => void;\n}\n\nexport default class ExpressionEval {\n  static jsep = jsep;\n  static parse = jsep;\n  static evaluate = ExpressionEval.eval;\n\n  static evaluators: Record<string, evaluatorCallback<AnyExpression>> = {\n    'ArrayExpression': ExpressionEval.prototype.evalArrayExpression,\n    'LogicalExpression': ExpressionEval.prototype.evalBinaryExpression,\n    'BinaryExpression': ExpressionEval.prototype.evalBinaryExpression,\n    'CallExpression': ExpressionEval.prototype.evalCallExpression,\n    'Compound': ExpressionEval.prototype.evalCompoundExpression,\n    'ConditionalExpression': ExpressionEval.prototype.evalConditionalExpression,\n    'Identifier': ExpressionEval.prototype.evalIdentifier,\n    'Literal': ExpressionEval.evalLiteral,\n    'OptionalMemberExpression': ExpressionEval.prototype.evalMemberExpression, // acorn uses this\n    'MemberExpression': ExpressionEval.prototype.evalMemberExpression,\n    'ThisExpression': ExpressionEval.prototype.evalThisExpression,\n    'UnaryExpression': ExpressionEval.prototype.evalUnaryExpression,\n    'ArrowFunctionExpression': ExpressionEval.prototype.evalArrowFunctionExpression,\n    'AssignmentExpression': ExpressionEval.prototype.evalAssignmentExpression,\n    'UpdateExpression': ExpressionEval.prototype.evalUpdateExpression,\n    'AwaitExpression': ExpressionEval.prototype.evalAwaitExpression,\n    'NewExpression': ExpressionEval.prototype.evalNewExpression,\n    'ObjectExpression': ExpressionEval.prototype.evalObjectExpression,\n    'SpreadElement': ExpressionEval.prototype.evalSpreadElement,\n    'TaggedTemplateExpression': ExpressionEval.prototype.evalTaggedTemplateExpression,\n    'TemplateLiteral': ExpressionEval.prototype.evalTemplateLiteral,\n  };\n\n  static conditionalEvaluators: Record<string, conditionalEvaluator<AnyExpression>[]> = {\n  };\n\n  // Default operator precedence from https://github.com/EricSmekens/jsep/blob/master/src/jsep.js#L55\n  static DEFAULT_PRECEDENCE: Record<string, number> = {\n    '||': 1,\n    '&&': 2,\n    '|': 3,\n    '^': 4,\n    '&': 5,\n    '==': 6,\n    '!=': 6,\n    '===': 6,\n    '!==': 6,\n    '<': 7,\n    '>': 7,\n    '<=': 7,\n    '>=': 7,\n    '<<': 8,\n    '>>': 8,\n    '>>>': 8,\n    '+': 9,\n    '-': 9,\n    '*': 10,\n    '/': 10,\n    '%': 10\n  };\n\n  static binops: Record<string, binaryCallback> = {\n    '||': function (a, b) { return a || b; },\n    '&&': function (a, b) { return a && b; },\n    '|': function (a, b) { return a | b; },\n    '^': function (a, b) { return a ^ b; },\n    '&': function (a, b) { return a & b; },\n    '==': function (a, b) { return a == b; }, // jshint ignore:line\n    '!=': function (a, b) { return a != b; }, // jshint ignore:line\n    '===': function (a, b) { return a === b; },\n    '!==': function (a, b) { return a !== b; },\n    '<': function (a, b) { return a < b; },\n    '>': function (a, b) { return a > b; },\n    '<=': function (a, b) { return a <= b; },\n    '>=': function (a, b) { return a >= b; },\n    '<<': function (a, b) { return a << b; },\n    '>>': function (a, b) { return a >> b; },\n    '>>>': function (a, b) { return a >>> b; },\n    '+': function (a, b) { return a + b; },\n    '-': function (a, b) { return a - b; },\n    '*': function (a, b) { return a * b; },\n    '/': function (a, b) { return a / b; },\n    '%': function (a, b) { return a % b; }\n  };\n\n  static unops: Record<string, unaryCallback> = {\n    '-': function (a) { return -a; },\n    '+': function (a) { return +a; },\n    '~': function (a) { return ~a; },\n    '!': function (a) { return !a; },\n  };\n\n  static assignOps: Record<string, assignCallback> = {\n    '=': function(obj, key, val) { return obj[key] = val; },\n    '*=': function(obj, key, val) { return obj[key] *= val; },\n    '**=': function(obj, key, val) { return obj[key] **= val; },\n    '/=': function(obj, key, val) { return obj[key] /= val; },\n    '%=': function(obj, key, val) { return obj[key] %= val; },\n    '+=': function(obj, key, val) { return obj[key] += val; },\n    '-=': function(obj, key, val) { return obj[key] -= val; },\n    '<<=': function(obj, key, val) { return obj[key] <<= val; },\n    '>>=': function(obj, key, val) { return obj[key] >>= val; },\n    '>>>=': function(obj, key, val) { return obj[key] >>>= val; },\n    '&=': function(obj, key, val) { return obj[key] &= val; },\n    '^=': function(obj, key, val) { return obj[key] ^= val; },\n    '|=': function(obj, key, val) { return obj[key] |= val; },\n  };\n\n  static defaultOptions: Options = {\n    caseSensitive: true\n  }\n\n  // inject Custom Unary Operators (and override existing ones)\n  static addUnaryOp(operator: string, _function: unaryCallback): void {\n    jsep.addUnaryOp(operator);\n    ExpressionEval.unops[operator] = _function;\n  }\n\n  // inject Custom Binary Operators (and override existing ones)\n  static addBinaryOp(\n    operator: string,\n    precedence_or_fn: number | binaryCallback,\n    _ra_or_callback?: boolean | binaryCallback,\n    _function?: binaryCallback)\n    : void {\n    let precedence, ra, cb;\n    if (typeof precedence_or_fn === 'function') {\n      cb = precedence_or_fn;\n    } else {\n      precedence = precedence_or_fn;\n      if (typeof _ra_or_callback === 'function') {\n        cb = _ra_or_callback;\n      } else {\n        ra = _ra_or_callback;\n        cb = _function;\n      }\n    }\n\n    jsep.addBinaryOp(operator, precedence || 1, ra);\n    ExpressionEval.binops[operator] = cb;\n  }\n\n  // inject custom node evaluators (and override existing ones)\n  static addEvaluator<T extends AnyExpression>(nodeType: string, evaluator: evaluatorCallback<T>): void {\n    ExpressionEval.evaluators[nodeType] = evaluator;\n  }\n\n  // inject conditional evaluators\n  static addConditionalEvaluator<T extends AnyExpression>(nodeType: string,\n    predicate: predicateCallback<T>,\n    evaluator: evaluatorCallback<T>): void {\n    if(!ExpressionEval.conditionalEvaluators[nodeType]) {\n      ExpressionEval.conditionalEvaluators[nodeType] = [];\n    }\n    ExpressionEval.conditionalEvaluators[nodeType].push({evaluator, predicate});\n  }\n\n  static registerPlugin(...plugins: Array<JseEvalPlugin>) {\n    plugins.forEach((p) => {\n      if (p.init) {\n        ExpressionEval.parse.plugins.register(p as jsep.IPlugin);\n      }\n      if (p.initEval) {\n        p.initEval.call(ExpressionEval, ExpressionEval);\n      }\n    });\n  }\n\n  // inject default Options\n  static addOptions(options: Options): void {\n    ExpressionEval.defaultOptions = options;\n  }\n\n  // main evaluator method\n  static eval(ast: jsep.Expression, context?: Context, options?: Options): unknown {\n    return (new ExpressionEval(context, undefined, options)).eval(ast);\n  }\n\n  static async evalAsync(ast: jsep.Expression, context?: Context, options?: Options): Promise<unknown> {\n    return (new ExpressionEval(context, true, options)).eval(ast);\n  }\n\n  // compile an expression and return an evaluator\n  static compile(expression: string): (context?: Context) => unknown {\n    return ExpressionEval.eval.bind(null, ExpressionEval.jsep(expression));\n  }\n\n  static compileAsync(expression: string): (context?: Context) => Promise<unknown> {\n    return ExpressionEval.evalAsync.bind(null, ExpressionEval.jsep(expression));\n  }\n\n  // compile and evaluate\n  static evalExpr(expression: string, context?: Context): unknown {\n    return ExpressionEval.compile(expression)(context);\n  }\n  static evalExprAsync(expression: string, context?: Context): unknown {\n    return ExpressionEval.compileAsync(expression)(context);\n  }\n\n\n  context?: Context;\n  isAsync?: boolean;\n  options?: Options;\n\n  get caseSensitive() {\n    return !!(this.options && this.options.caseSensitive);\n  }\n\n  constructor(context?: Context, isAsync?: boolean, options?: Options) {\n    this.context = context;\n    this.isAsync = isAsync;\n    this.options = options || ExpressionEval.defaultOptions;\n  }\n\n  public eval(node: AnyExpression, cb = v => v): unknown {\n\n    const list = ExpressionEval.conditionalEvaluators[node.type];\n    if (list) {\n      for (const proba of list) {\n        const found = proba.predicate.call(this, node, this.context);\n        if (found) {\n          const conditionalEvaluator = proba.evaluator;\n          return this.evalSyncAsync(conditionalEvaluator.bind(this)(node, this.context), (v) => {\n            (node as any)._value = v;\n            return cb(v);\n          });\n        }\n      }\n    }\n\n    const evaluator = ExpressionEval.evaluators[node.type];\n\n    if (typeof evaluator === 'undefined') {\n      throw new Error(`unknown node type: ${JSON.stringify(node, null, 2)}`);\n    }\n\n    return this.evalSyncAsync(evaluator.bind(this)(node, this.context), (v) => {\n      (node as any)._value = v;\n      return cb(v);\n    });\n  }\n\n  /*\n   * `evalSyncAsync` is a helper to wrap sync/async calls into one so that\n   * we don't have to duplicate all of our node type parsers.\n   * It's basically like old node callback (hell?), but it works because:\n   * for sync:\n   *   an expression like `[1].map(v => v + 1)` returns the result\n   *   after running the callback\n   * for async:\n   *   an expression like `const a = (await x) + 1` is equivalent to\n   *   `Promise.resolve(x).then(res => res + 1)`\n   *\n   * Note: For optimization, there are a few places where it makes sense\n   * to directly check `this.isAsync` to use Promise.all(),\n   * `promisesOrResults = expressions.map(v => this.eval(v))`\n   *   could result in an array of results (sync) or promises (async)\n   */\n  evalSyncAsync(val: unknown, cb: (unknown) => unknown): Promise<unknown> | unknown {\n    if (this.isAsync) {\n      return Promise.resolve(val).then(cb);\n    }\n    return cb(val);\n  }\n\n  private evalArrayExpression(node: jsep.ArrayExpression) {\n    return this.evalArray(node.elements);\n  }\n\n  protected evalArray(list: jsep.Expression[]): unknown[] {\n    const mapped = list.map(v => this.eval(v));\n    const toFullArray = (res) => res\n      .reduce((arr, v, i) => {\n        if ((list[i] as AnyExpression).type === 'SpreadElement') {\n          return [...arr, ...v];\n        }\n        arr.push(v);\n        return arr;\n      }, []);\n    return this.isAsync\n      ? Promise.all(mapped).then(toFullArray)\n      : toFullArray(mapped);\n  }\n\n  private evalBinaryExpression(node: jsep.BinaryExpression) {\n    if (node.operator === '||') {\n      return this.eval(node.left, left => left || this.eval(node.right));\n    } else if (node.operator === '&&') {\n      return this.eval(node.left, left => left && this.eval(node.right));\n    }\n    const leftRight = [\n      this.eval(node.left),\n      this.eval(node.right)\n    ];\n    const op = ([left, right]) => ExpressionEval\n      .binops[node.operator](left, right);\n    return this.isAsync\n      ? Promise.all(leftRight).then(op)\n      : op(leftRight as [operand, operand]);\n  }\n\n  private evalCompoundExpression(node: jsep.Compound) {\n    return this.isAsync\n      ? node.body.reduce((p: Promise<any>, node) => p.then(() => this.eval(node)), Promise.resolve())\n      : node.body.map(v => this.eval(v))[node.body.length - 1]\n  }\n\n  private evalCallExpression(node: jsep.CallExpression) {\n    return this.evalSyncAsync(this.evalCall(node.callee), ([fn, caller]) => this\n      .evalSyncAsync(this.evalArray(node.arguments), args => fn\n        .apply(caller === node.callee ? this.context : caller, args)));\n  }\n\n  protected evalCall(callee: jsep.Expression): unknown {\n    if (callee.type === 'MemberExpression') {\n      return this.evalSyncAsync(\n        this.evaluateMember(callee as jsep.MemberExpression),\n        ([caller, fn]) => ExpressionEval.validateFnAndCall(fn, caller, callee as AnyExpression)\n      );\n    } else if (callee.type === 'Identifier') {\n      //const [, fn] = Utils.getKeyValue(this.context, (callee as jsep.Identifier).name, this.options);\n      const fn = Utils.getValue(this.context, (callee as jsep.Identifier).name, this.options);\n      return ExpressionEval.validateFnAndCall(fn as () => unknown, callee as AnyExpression);\n    }\n    return this.eval(callee, fn => ExpressionEval.validateFnAndCall(fn, callee as AnyExpression));\n  }\n\n  private evalConditionalExpression(node: jsep.ConditionalExpression) {\n    return this.eval(node.test, v => v\n      ? this.eval(node.consequent)\n      : this.eval(node.alternate));\n  }\n\n  private evalIdentifier(node: jsep.Identifier) {\n    if (this.caseSensitive) {\n      const value = Utils.getValue(this.context, node.name, this.options);\n      return value;\n    } else if (node.name.localeCompare('this', 'en', { sensitivity: 'base' }) === 0) {\n      return this.evalThisExpression();\n    } else {\n      const literal = Utils.getLiteralKeyValue(literals, node.name, this.options);\n      if (literal) {\n        const [, value] = literal;\n        return value;\n      }\n      const value = Utils.getValue(this.context, node.name, this.options);\n\n      if (typeof value !== 'undefined' && this.options.scopes) {\n        const scopePair = Utils.getScopePair(this.context, node.name, this.options);\n        if (scopePair) {\n          const [, scope] = scopePair;\n          (node as any)._scope = scope;\n        }\n      }\n\n      return value;\n    }\n  }\n\n  private static evalLiteral(node: jsep.Literal) {\n    return node.value;\n  }\n\n  private evalMemberExpression(node: jsep.MemberExpression) {\n    return this.evalSyncAsync(this.evaluateMember(node), ([, val]) => val);\n  }\n\n  private evaluateMember(node: jsep.MemberExpression) {\n    return this.eval(node.object, (object) => this\n      .evalSyncAsync(\n        node.computed\n          ? this.eval(node.property)\n          : (node.property as jsep.Identifier).name,\n        (key: string) => {\n          if (/^__proto__|prototype|constructor$/.test(key)) {\n            throw Error(`Access to member \"${key}\" disallowed.`);\n          }\n          const obj = (node.optional ? (object || {}) : object);\n          const scope: Scope = node.object._scope as Scope;\n          const options = scope ? {...this.options, ...scope.options} : this.options;\n          const value = Utils.getValue(obj, key, options);\n          return [object, value, key];\n        })\n    );\n  }\n\n  private evalThisExpression() {\n    return this.context;\n  }\n\n  private evalUnaryExpression(node: jsep.UnaryExpression) {\n    return this.eval(node.argument, arg => ExpressionEval\n      .unops[node.operator](arg));\n  }\n\n  private evalArrowFunctionExpression(node: ArrowExpression) {\n    if (this.isAsync !== node.async) {\n      return ExpressionEval[node.async ? 'evalAsync' : 'eval'](node as any, this.context);\n    }\n    return (...arrowArgs) => {\n      const arrowContext = this.evalArrowContext(node, arrowArgs);\n      return ExpressionEval[node.async ? 'evalAsync' : 'eval'](node.body, arrowContext);\n    };\n  }\n\n  private evalArrowContext(node: ArrowExpression, arrowArgs): Context {\n    const arrowContext = { ...this.context };\n\n    ((node.params as AnyExpression[]) || []).forEach((param, i) => {\n      // default value:\n      if (param.type === 'AssignmentExpression') {\n        if (typeof arrowArgs[i] === 'undefined') {\n          arrowArgs[i] = this.eval((param as AssignmentExpression).right);\n        }\n        param = param.left as AnyExpression;\n      }\n\n      if (param.type === 'Identifier') {\n        arrowContext[(param as jsep.Identifier).name] = arrowArgs[i];\n      } else if (param.type === 'ArrayExpression') {\n        // array destructuring\n        (param.elements as AnyExpression[]).forEach((el, j) => {\n          let val = arrowArgs[i][j];\n          if (el.type === 'AssignmentExpression') {\n            if (typeof val === 'undefined') {\n              // default value\n              val = this.eval((el as AssignmentExpression).right);\n            }\n            el = el.left as AnyExpression;\n          }\n\n          if (el.type === 'Identifier') {\n            arrowContext[(el as jsep.Identifier).name] = val;\n          } else {\n            throw new Error('Unexpected arrow function argument');\n          }\n        });\n      } else if (param.type === 'ObjectExpression') {\n        // object destructuring\n        const keys = [];\n        (param.properties as AnyExpression[]).forEach((prop) => {\n          let p = prop;\n          if (p.type === 'AssignmentExpression') {\n            p = p.left as AnyExpression;\n          }\n\n          let key;\n          if (p.type === 'Property') {\n            key = (<jsep.Expression>p.key).type === 'Identifier'\n              ? (p.key as jsep.Identifier).name\n              : this.eval((p as Property).key).toString();\n          } else if (p.type === 'Identifier') {\n            key = p.name;\n          } else if (p.type === 'SpreadElement' && (<jsep.Expression>p.argument).type === 'Identifier') {\n            key = (p.argument as jsep.Identifier).name;\n          } else {\n            throw new Error('Unexpected arrow function argument');\n          }\n\n          let val = arrowArgs[i][key];\n          if (p.type === 'SpreadElement') {\n            // all remaining object properties. Copy arg obj, then delete from our copy\n            val = { ...arrowArgs[i] };\n            keys.forEach((k) => {\n              delete val[k];\n            });\n          } else if (typeof val === 'undefined' && prop.type === 'AssignmentExpression') {\n            // default value\n            val = this.eval((prop as AssignmentExpression).right);\n          }\n\n          arrowContext[key] = val;\n          keys.push(key);\n        });\n      } else if (param.type === 'SpreadElement' && (<jsep.Expression>param.argument).type === 'Identifier') {\n        const key = (param.argument as jsep.Identifier).name;\n        arrowContext[key] = arrowArgs.slice(i);\n      } else {\n        throw new Error('Unexpected arrow function argument');\n      }\n    });\n    return arrowContext;\n  }\n\n  private evalAssignmentExpression(node: AssignmentExpression) {\n    return this.evalSyncAsync(\n      this.getContextAndKey(node.left as AnyExpression),\n      ([destObj, destKey]) => this.eval(node.right, right => ExpressionEval\n        .assignOps[node.operator](destObj, destKey, right))\n    );\n  }\n\n  private evalUpdateExpression(node: UpdateExpression) {\n    return this.evalSyncAsync(\n      this.getContextAndKey(node.argument as AnyExpression),\n      ([destObj, destKey]) => ExpressionEval\n        .evalUpdateOperation(node, destObj, destKey)\n    );\n  }\n\n  private evalAwaitExpression(node: AwaitExpression) {\n    return ExpressionEval.evalAsync(node.argument, this.context);\n  }\n\n  private static evalUpdateOperation(node: UpdateExpression, destObj, destKey) {\n    if (node.prefix) {\n      return node.operator === '++'\n        ? ++destObj[destKey]\n        : --destObj[destKey];\n    }\n    return node.operator === '++'\n      ? destObj[destKey]++\n      : destObj[destKey]--;\n  }\n\n  private getContextAndKey(node: AnyExpression) {\n    if (node.type === 'MemberExpression') {\n      return this.evalSyncAsync(\n        this.evaluateMember(<jsep.MemberExpression>node),\n        ([obj, , key]) => {\n          const keyValue = Utils.getKeyValue(obj, key, this.options);\n          const [newKey, ] = keyValue ? keyValue : [key, undefined];\n          return [obj, newKey];\n        }\n      );\n    } else if (node.type === 'Identifier') {\n      const keyValue = Utils.getKeyValue(this.context, node.name as string | number, this.options);\n      const [key, ] = keyValue ? keyValue : [node.name, undefined];\n      return [this.context, key];\n    } else if (node.type === 'ConditionalExpression') {\n      return this.eval((node as jsep.ConditionalExpression).test, test => this\n        .getContextAndKey((test\n          ? node.consequent\n          : node.alternate) as AnyExpression));\n    } else {\n      throw new Error('Invalid Member Key');\n    }\n  }\n\n  private evalNewExpression(node: NewExpression) {\n    return this.evalSyncAsync(\n      this.evalCall(node.callee),\n      ([ctor]) => this.evalSyncAsync(\n        this.evalArray(node.arguments),\n        args => ExpressionEval.construct(ctor, args, node)));\n  }\n\n  private evalObjectExpression(node: ObjectExpression) {\n    const obj = {};\n    const arr = node.properties.map((prop: Property | SpreadElement) => {\n      if (prop.type === 'SpreadElement') {\n        // always synchronous in this case\n        Object.assign(obj, ExpressionEval.eval(prop.argument, this.context, this.options));\n      } else if (prop.type === 'Property') {\n        return this.evalSyncAsync(\n          prop.key.type === 'Identifier'\n            ? (<jsep.Identifier>prop.key).name\n            : this.eval(prop.key),\n          key => this.eval(\n            prop.shorthand ? prop.key : prop.value,\n            val => { obj[key] = val; }\n          )\n        );\n      }\n    });\n    return this.isAsync\n      ? Promise.all(arr).then(() => obj)\n      : obj;\n  }\n\n  private evalSpreadElement(node: SpreadElement) {\n    return this.eval(node.argument);\n  }\n\n  private evalTaggedTemplateExpression(node: TaggedTemplateExpression) {\n    const fnAndArgs = [\n      this.evalCall(node.tag),\n      this.evalSyncAsync(\n        this.evalArray(node.quasi.expressions),\n        exprs => [\n          node.quasi.quasis.map(q => q.value.cooked),\n          ...exprs,\n        ]\n      ),\n    ];\n    const apply = ([[fn, caller], args]) => fn.apply(caller, args);\n    return this.isAsync\n      ? Promise.all(fnAndArgs).then(apply)\n      : apply(fnAndArgs as [[() => unknown, AnyExpression], unknown]);\n  }\n\n  private evalTemplateLiteral(node: TemplateLiteral) {\n    return this.evalSyncAsync(\n      this.evalArray(node.expressions),\n      expressions => node.quasis.reduce((str, q, i) => {\n        str += q.value.cooked;\n        if (!q.tail) {\n          str += expressions[i];\n        }\n        return str;\n      }, '')\n    );\n  }\n\n  protected static construct(\n    ctor: () => unknown,\n    args: unknown[],\n    node: jsep.CallExpression | jsep.Expression\n  ): unknown {\n    try {\n      return new (Function.prototype.bind.apply(ctor, [null].concat(args)))();\n    } catch (e) {\n      throw new Error(`${ExpressionEval.nodeFunctionName(node.callee as AnyExpression)} is not a constructor`);\n    }\n  }\n\n  protected static validateFnAndCall(\n    fn: () => unknown,\n    callee?: AnyExpression,\n    caller?: AnyExpression,\n  ): [() => unknown, AnyExpression] {\n    if (typeof fn !== 'function') {\n      if (!fn && caller && caller.optional) {\n        return [() => undefined, callee];\n      }\n      const name = ExpressionEval.nodeFunctionName(caller || callee);\n      throw new Error(`'${name}' is not a function`);\n    }\n    return [fn, callee];\n  }\n\n  protected static nodeFunctionName(callee: AnyExpression): string {\n    return callee\n      && ((callee as jsep.Identifier).name\n        || ((callee as jsep.MemberExpression).property\n          && ((callee as jsep.MemberExpression).property as jsep.Identifier).name));\n  }\n\n  static getKeyValue(obj: Context, name: string | number, \n    options: Options): [string | number, unknown] {\n\n    return Utils.getKeyValue(obj, name, options);\n  }\n\n}\n\n/** NOTE: exporting named + default.\n * For CJS, these match the static members of the default export, so they still work.\n */\nexport { default as jsep, default as parse } from 'jsep';\nexport const DEFAULT_PRECEDENCE = ExpressionEval.DEFAULT_PRECEDENCE;\nexport const evaluators = ExpressionEval.evaluators;\nexport const binops = ExpressionEval.binops;\nexport const unops = ExpressionEval.unops;\nexport const assignOps = ExpressionEval.assignOps;\nexport const addUnaryOp = ExpressionEval.addUnaryOp;\nexport const addBinaryOp = ExpressionEval.addBinaryOp;\nexport const addEvaluator = ExpressionEval.addEvaluator;\nexport const registerPlugin = ExpressionEval.registerPlugin;\nexport const addOptions = ExpressionEval.addOptions;\nexport const evaluate = ExpressionEval.eval;\nexport const evalAsync = ExpressionEval.evalAsync;\nexport const compile = ExpressionEval.compile;\nexport const compileAsync = ExpressionEval.compileAsync;\nexport const evalExpr = ExpressionEval.evalExpr;\nexport const evalExprAsync = ExpressionEval.evalExprAsync;\nexport const getKeyValue = ExpressionEval.getKeyValue;\n"],"names":["literals","undefined","null","true","false","Utils","getValue","obj","name","options","keyValue","getScopedKeyValue","value","fn","getBindFunction","getScopePair","scopes","getKeyValue","scopeName","_options$scopes$scope","scopedOptions","hasProperty","functionBindings","bindings","arguments","bind","apply","thisRef","concat","Object","prototype","hasOwnProperty","call","scopeNameList","currentScope","currentScopeName","globalScope","globalScopeName","push","_i","_scopeNameList","length","this","blockListTest","allowListTest","caseSensitive","currentObj","keys","getOwnPropertyNames","Array","isArray","key","find","localeCompare","sensitivity","getPrototypeOf","getLiteralKeyValue","entries","_i2","_Object$entries","_Object$entries$_i","blockList","Error","allowList","ExpressionEval","context","isAsync","defaultOptions","addUnaryOp","operator","_function","jsep","unops","addBinaryOp","precedence_or_fn","_ra_or_callback","precedence","ra","cb","binops","addEvaluator","nodeType","evaluator","evaluators","addConditionalEvaluator","predicate","conditionalEvaluators","registerPlugin","slice","forEach","p","init","parse","plugins","register","initEval","addOptions","eval","ast","evalAsync","Promise","resolve","compile","expression","compileAsync","evalExpr","evalExprAsync","node","v","list","type","_step","_iterator","_createForOfIteratorHelperLoose","done","proba","evalSyncAsync","conditionalEvaluator","_value","JSON","stringify","val","then","evalArrayExpression","evalArray","elements","_this2","mapped","map","toFullArray","res","reduce","arr","i","all","evalBinaryExpression","_this3","left","right","leftRight","op","_ref","evalCompoundExpression","_this4","body","evalCallExpression","_this5","evalCall","callee","_ref2","caller","args","evaluateMember","validateFnAndCall","_ref3","evalConditionalExpression","_this6","test","consequent","alternate","evalIdentifier","evalThisExpression","literal","scopePair","_scope","evalLiteral","evalMemberExpression","_ref4","_this7","object","computed","property","optional","scope","_extends","evalUnaryExpression","argument","arg","evalArrowFunctionExpression","_this","async","arrowContext","evalArrowContext","arrowArgs","_this8","params","param","el","j","properties","prop","toString","k","evalAssignmentExpression","_this9","getContextAndKey","_ref5","destObj","destKey","assignOps","evalUpdateExpression","_ref6","evalUpdateOperation","evalAwaitExpression","prefix","_this10","_ref7","evalNewExpression","_this11","_ref10","ctor","construct","evalObjectExpression","_this12","assign","shorthand","evalSpreadElement","evalTaggedTemplateExpression","fnAndArgs","tag","quasi","expressions","exprs","quasis","q","cooked","_ref11","_ref11$","evalTemplateLiteral","str","tail","Function","e","nodeFunctionName","get","evaluate","ArrayExpression","LogicalExpression","BinaryExpression","CallExpression","Compound","ConditionalExpression","Identifier","Literal","OptionalMemberExpression","MemberExpression","ThisExpression","UnaryExpression","ArrowFunctionExpression","AssignmentExpression","UpdateExpression","AwaitExpression","NewExpression","ObjectExpression","SpreadElement","TaggedTemplateExpression","TemplateLiteral","DEFAULT_PRECEDENCE","a","b","_key","Math","pow"],"mappings":"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