{"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;\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, key: string, val: operand) => operand;\nexport declare type evaluatorCallback = (this: ExpressionEval, node: T, context?: Context) => unknown;\n\nexport type AnyExpression = jsep.Expression;\n\nexport type JseEvalPlugin = Partial & {\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> = {\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 = {\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 = {\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 = {\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 = {\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(nodeType: string, evaluator: evaluatorCallback): void {\n ExpressionEval.evaluators[nodeType] = evaluator;\n }\n\n static registerPlugin(...plugins: Array) {\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 {\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 {\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 {\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, 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 = (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' && (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' && (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(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 ? (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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"}