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

JavaScript expression parsing and evaluation.

{"version":3,"file":"jse-eval.cjs","sources":["../index.ts"],"sourcesContent":["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\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 Context = Record<string, unknown>;\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;\n\nexport type AnyExpression = jsep.Expression;\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  // 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  // 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  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  // main evaluator method\n  static eval(ast: jsep.Expression, context?: Context): unknown {\n    return (new ExpressionEval(context)).eval(ast);\n  }\n  static async evalAsync(ast: jsep.Expression, context?: Context): Promise<unknown> {\n    return (new ExpressionEval(context, true)).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  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\n  constructor(context?: Context, isAsync?: boolean) {\n    this.context = context;\n    this.isAsync = isAsync;\n  }\n\n  public eval(node: unknown, cb = v => v): unknown {\n    const evaluator = ExpressionEval.evaluators[(node as jsep.Expression).type]\n      || ExpressionEval.evaluators.default;\n    if (!evaluator) {\n      throw new Error(`unknown node type: ${JSON.stringify(node, null, 2)}`);\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    }\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    return this.context[node.name];\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          return [object, (node.optional ? (object || {}) : object)[key], 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 (arrowArgs[i] === undefined) {\n          arrowArgs[i] = this.eval(param.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 (val === undefined) {\n              // default value\n              val = this.eval(el.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.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 (val === undefined && prop.type === 'AssignmentExpression') {\n            // default value\n            val = this.eval(prop.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]) => [obj, key]\n      );\n    } else if (node.type === 'Identifier') {\n      return [this.context, node.name];\n    } else if (node.type === 'ConditionalExpression') {\n      return this.eval(node.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));\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\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 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;\n"],"names":["ExpressionEval","context","isAsync","this","addUnaryOp","operator","_function","jsep","unops","addBinaryOp","precedence_or_fn","_ra_or_callback","ra","cb","precedence","binops","addEvaluator","nodeType","evaluator","evaluators","registerPlugin","slice","call","arguments","forEach","p","init","parse","plugins","register","initEval","eval","ast","evalAsync","Promise","resolve","compile","expression","bind","compileAsync","evalExpr","evalExprAsync","node","v","type","JSON","stringify","evalSyncAsync","_value","val","then","evalArrayExpression","evalArray","elements","list","mapped","map","_this2","toFullArray","res","reduce","arr","i","push","all","evalBinaryExpression","_this3","left","right","op","_ref","leftRight","evalCompoundExpression","_this4","body","length","evalCallExpression","_this5","evalCall","callee","fn","caller","_ref2","args","apply","evaluateMember","validateFnAndCall","_ref3","evalConditionalExpression","_this6","test","consequent","alternate","evalIdentifier","name","evalLiteral","value","evalMemberExpression","_this7","object","computed","property","key","Error","optional","evalThisExpression","evalUnaryExpression","argument","arg","evalArrowFunctionExpression","_this","async","arrowContext","evalArrowContext","arrowArgs","_this8","_extends","params","param","undefined","el","j","properties","prop","toString","keys","k","evalAssignmentExpression","_this9","getContextAndKey","_ref5","destKey","assignOps","destObj","evalUpdateExpression","evalUpdateOperation","_ref6","evalAwaitExpression","prefix","_this10","_ref7","evalNewExpression","_this11","ctor","_ref8","construct","evalObjectExpression","_this12","obj","Object","assign","shorthand","evalSpreadElement","evalTaggedTemplateExpression","tag","quasi","expressions","exprs","quasis","q","cooked","fnAndArgs","evalTemplateLiteral","str","tail","Function","prototype","concat","e","nodeFunctionName","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"],"mappings":"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"}