ecma-evaluator 1.0.0

package/dist/cjs/index.cjs

@@ -0,0 +1,638 @@
+"use strict";
+var __webpack_require__ = {};
+!function() {
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+}();
+!function() {
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+}();
+!function() {
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+}();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    evaluatorExpression: function() {
+        return evaluatorExpression;
+    },
+    evaluatorTemplate: function() {
+        return evaluatorTemplate;
+    }
+});
+var external_acorn_namespaceObject = require("acorn");
+function _array_like_to_array(arr, len) {
+    if (null == len || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function _construct(Parent, args, Class) {
+    _construct = _is_native_reflect_construct() ? Reflect.construct : function(Parent, args, Class) {
+        var a = [
+            null
+        ];
+        a.push.apply(a, args);
+        var Constructor = Function.bind.apply(Parent, a);
+        var instance = new Constructor();
+        if (Class) _set_prototype_of(instance, Class.prototype);
+        return instance;
+    };
+    return _construct.apply(null, arguments);
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function _iterable_to_array(iter) {
+    if ("undefined" != typeof Symbol && null != iter[Symbol.iterator] || null != iter["@@iterator"]) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
+    if (null == _i) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && null != _i["return"]) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = null != arguments[i] ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if ("function" == typeof Object.getOwnPropertySymbols) ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        }));
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if ("string" == typeof o) return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if ("Object" === n && o.constructor) n = o.constructor.name;
+    if ("Map" === n || "Set" === n) return Array.from(n);
+    if ("Arguments" === n || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+var typeArrayConstructors = [
+    Int8Array,
+    Uint8Array,
+    Uint8ClampedArray,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    Float32Array,
+    Float64Array,
+    globalThis.BigInt64Array,
+    globalThis.BigUint64Array
+].filter(Boolean);
+var mutableMethods = new Set([
+    Array.prototype.push,
+    Array.prototype.pop,
+    Array.prototype.shift,
+    Array.prototype.unshift,
+    Array.prototype.splice,
+    Array.prototype.reverse,
+    Array.prototype.sort,
+    Array.prototype.fill,
+    Array.prototype.copyWithin,
+    ArrayBuffer.prototype.slice,
+    DataView.prototype.setInt8,
+    DataView.prototype.setUint8,
+    DataView.prototype.setInt16,
+    DataView.prototype.setUint16,
+    DataView.prototype.setInt32,
+    DataView.prototype.setUint32,
+    DataView.prototype.setFloat32,
+    DataView.prototype.setFloat64
+].concat(_to_consumable_array(typeArrayConstructors.flatMap(function(TypedArray) {
+    return [
+        TypedArray.prototype.set,
+        TypedArray.prototype.fill,
+        TypedArray.prototype.copyWithin,
+        TypedArray.prototype.reverse,
+        TypedArray.prototype.sort
+    ];
+})), [
+    Object.freeze,
+    Object.defineProperty,
+    Object.defineProperties,
+    Object.preventExtensions,
+    Object.setPrototypeOf,
+    Object.assign,
+    Set.prototype.add,
+    Set.prototype["delete"],
+    Set.prototype.clear,
+    WeakSet.prototype.add,
+    WeakSet.prototype["delete"],
+    Map.prototype.set,
+    Map.prototype["delete"],
+    Map.prototype.clear,
+    WeakMap.prototype.set,
+    WeakMap.prototype["delete"],
+    Date.prototype.setMilliseconds,
+    Date.prototype.setMinutes,
+    Date.prototype.setHours,
+    Date.prototype.setDate,
+    Date.prototype.setFullYear,
+    Date.prototype.setUTCMinutes,
+    Date.prototype.setUTCHours,
+    Date.prototype.setUTCDate,
+    Date.prototype.setUTCFullYear,
+    Date.prototype.setTime
+]));
+var Evaluator_Evaluator = /*#__PURE__*/ function() {
+    "use strict";
+    function Evaluator() {
+        var variables = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {};
+        _class_call_check(this, Evaluator);
+        var globalScope = Object.assign(Object.create(null), _object_spread({
+            Infinity: 1 / 0,
+            null: null,
+            undefined: void 0,
+            NaN: Number.NaN,
+            isNaN: Number.isNaN,
+            isFinite: Number.isFinite,
+            parseFloat: Number.parseFloat,
+            parseInt: Number.parseInt,
+            encodeURI: globalThis.encodeURI,
+            encodeURIComponent: globalThis.encodeURIComponent,
+            decodeURI: globalThis.decodeURI,
+            decodeURIComponent: globalThis.decodeURIComponent,
+            Number: Number,
+            String: String,
+            Boolean: Boolean,
+            BigInt: globalThis.BigInt,
+            Symbol: globalThis.Symbol,
+            Object: Object,
+            Array: Array,
+            Set: Set,
+            WeakSet: WeakSet,
+            Map: Map,
+            WeakMap: WeakMap,
+            Math: Math,
+            JSON: JSON,
+            Date: Date,
+            RegExp: RegExp,
+            Error: Error,
+            EvalError: EvalError,
+            RangeError: RangeError,
+            ReferenceError: ReferenceError,
+            SyntaxError: SyntaxError,
+            TypeError: TypeError,
+            URIError: URIError,
+            Promise: Promise
+        }, typeArrayConstructors.reduce(function(acc, obj) {
+            acc[obj.name] = obj;
+            return acc;
+        }, {})));
+        this.scopes = [
+            variables,
+            globalScope
+        ];
+    }
+    _create_class(Evaluator, [
+        {
+            key: "evaluate",
+            value: function(expression) {
+                var ast = external_acorn_namespaceObject.parse(expression, {
+                    ecmaVersion: "latest"
+                });
+                return this.execute(ast.body);
+            }
+        },
+        {
+            key: "execute",
+            value: function(body) {
+                var result;
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+                try {
+                    for(var _iterator = body[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var node = _step.value;
+                        result = this.visit(node);
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && null != _iterator["return"]) _iterator["return"]();
+                    } finally{
+                        if (_didIteratorError) throw _iteratorError;
+                    }
+                }
+                return result;
+            }
+        },
+        {
+            key: "visit",
+            value: function(node) {
+                var _this = this;
+                switch(node.type){
+                    case "ExpressionStatement":
+                        return this.visit(node.expression);
+                    case "BinaryExpression":
+                        return this.handleBinaryExpression(node);
+                    case "LogicalExpression":
+                        return this.handleLogicalExpression(node);
+                    case "UnaryExpression":
+                        return this.handleUnaryExpression(node);
+                    case "Identifier":
+                        return this.handleIdentifier(node);
+                    case "Literal":
+                        return node.value;
+                    case "MemberExpression":
+                        return this.handleMemberExpression(node);
+                    case "ObjectExpression":
+                        return this.handleObjectExpression(node);
+                    case "ArrayExpression":
+                        return this.handleArrayExpression(node);
+                    case "ArrowFunctionExpression":
+                        return this.handleArrowFunctionExpression(node);
+                    case "CallExpression":
+                        return this.handleCallExpression(node);
+                    case "ConditionalExpression":
+                        return this.visit(node.test) ? this.visit(node.consequent) : this.visit(node.alternate);
+                    case "NewExpression":
+                        if ("Identifier" !== node.callee.type) throw new Error("Unsupported callee type '".concat(node.callee.type, "' in new expression"));
+                        if ("Function" === node.callee.name) throw new Error("Cannot use new with Function constructor");
+                        var Constructor = this.visit(node.callee);
+                        var args = node["arguments"].map(function(arg) {
+                            return _this.visit(arg);
+                        });
+                        return _construct(Constructor, _to_consumable_array(args));
+                    case "ChainExpression":
+                        return this.visit(node.expression);
+                    case "TemplateLiteral":
+                        return this.handleTemplateLiteral(node);
+                    default:
+                        throw new Error("Unsupported node type: ".concat(node.type));
+                }
+            }
+        },
+        {
+            key: "handleBinaryExpression",
+            value: function(node) {
+                switch(node.operator){
+                    case "+":
+                        return this.visit(node.left) + this.visit(node.right);
+                    case "-":
+                        return this.visit(node.left) - this.visit(node.right);
+                    case "*":
+                        return this.visit(node.left) * this.visit(node.right);
+                    case "**":
+                        return Math.pow(this.visit(node.left), this.visit(node.right));
+                    case "/":
+                        var left = this.visit(node.left);
+                        var right = this.visit(node.right);
+                        if (0 === right) throw new Error("Division by zero");
+                        return left / right;
+                    case "==":
+                        return this.visit(node.left) == this.visit(node.right);
+                    case "===":
+                        return this.visit(node.left) === this.visit(node.right);
+                    case "!=":
+                        return this.visit(node.left) != this.visit(node.right);
+                    case "!==":
+                        return this.visit(node.left) !== this.visit(node.right);
+                    case ">":
+                        return this.visit(node.left) > this.visit(node.right);
+                    case ">=":
+                        return this.visit(node.left) >= this.visit(node.right);
+                    case "<":
+                        return this.visit(node.left) < this.visit(node.right);
+                    case "<=":
+                        return this.visit(node.left) <= this.visit(node.right);
+                    case "%":
+                        return this.visit(node.left) % this.visit(node.right);
+                    case "&":
+                        return this.visit(node.left) & this.visit(node.right);
+                    case "|":
+                        return this.visit(node.left) | this.visit(node.right);
+                    case "^":
+                        return this.visit(node.left) ^ this.visit(node.right);
+                    case "<<":
+                        return this.visit(node.left) << this.visit(node.right);
+                    case ">>":
+                        return this.visit(node.left) >> this.visit(node.right);
+                    case ">>>":
+                        return this.visit(node.left) >>> this.visit(node.right);
+                    default:
+                        throw new Error("Unsupported operator: ".concat(node.operator));
+                }
+            }
+        },
+        {
+            key: "handleLogicalExpression",
+            value: function(node) {
+                switch(node.operator){
+                    case "&&":
+                        return this.visit(node.left) && this.visit(node.right);
+                    case "||":
+                        return this.visit(node.left) || this.visit(node.right);
+                    case "??":
+                        var left = this.visit(node.left);
+                        return null != left ? left : this.visit(node.right);
+                    default:
+                        throw new Error("Unsupported logical operator: ".concat(node.operator));
+                }
+            }
+        },
+        {
+            key: "handleUnaryExpression",
+            value: function(node) {
+                switch(node.operator){
+                    case "-":
+                        return -this.visit(node.argument);
+                    case "+":
+                        return +this.visit(node.argument);
+                    case "!":
+                        return !this.visit(node.argument);
+                    case "~":
+                        return ~this.visit(node.argument);
+                    case "typeof":
+                        return _type_of(this.visit(node.argument));
+                    case "void":
+                        return void this.visit(node.argument);
+                    case "delete":
+                        throw new Error("Delete operator is mutable and not supported");
+                    default:
+                        throw new Error("Unsupported unary operator: ".concat(node.operator));
+                }
+            }
+        },
+        {
+            key: "handleIdentifier",
+            value: function(node) {
+                var name = node.name;
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+                try {
+                    for(var _iterator = this.scopes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var scope = _step.value;
+                        if (Object.hasOwn(scope, name)) return scope[name];
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && null != _iterator["return"]) _iterator["return"]();
+                    } finally{
+                        if (_didIteratorError) throw _iteratorError;
+                    }
+                }
+                throw new ReferenceError("".concat(name, " is not defined"));
+            }
+        },
+        {
+            key: "handleMemberExpression",
+            value: function(node) {
+                var object = this.visit(node.object);
+                var property = "Identifier" !== node.property.type || node.computed ? this.visit(node.property) : node.property.name;
+                if (null == object) {
+                    if (node.optional) return;
+                    throw new TypeError("Cannot read property '".concat(property, "' of ").concat(object));
+                }
+                if (Object.hasOwn(object, property)) return object[property];
+                var prototypeValue = object[property];
+                if (mutableMethods.has(prototypeValue)) throw new Error("Cannot call mutable prototype method: ".concat(property));
+                if ("function" == typeof prototypeValue) return prototypeValue.bind(object);
+                return prototypeValue;
+            }
+        },
+        {
+            key: "handleObjectExpression",
+            value: function(node) {
+                var obj = {};
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+                try {
+                    for(var _iterator = node.properties[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var prop = _step.value;
+                        var key = prop.key.name || prop.key.value;
+                        var value = this.visit(prop.value);
+                        obj[key] = value;
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && null != _iterator["return"]) _iterator["return"]();
+                    } finally{
+                        if (_didIteratorError) throw _iteratorError;
+                    }
+                }
+                return obj;
+            }
+        },
+        {
+            key: "handleArrayExpression",
+            value: function(node) {
+                var _this = this;
+                return node.elements.map(function(element) {
+                    return _this.visit(element);
+                });
+            }
+        },
+        {
+            key: "handleArrowFunctionExpression",
+            value: function(node) {
+                var _this = this;
+                return function() {
+                    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++)args[_key] = arguments[_key];
+                    var newScope = {};
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+                    try {
+                        for(var _iterator = node.params.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var _step_value = _sliced_to_array(_step.value, 2), index = _step_value[0], param = _step_value[1];
+                            newScope[param.name] = args[index];
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && null != _iterator["return"]) _iterator["return"]();
+                        } finally{
+                            if (_didIteratorError) throw _iteratorError;
+                        }
+                    }
+                    _this.scopes.unshift(newScope);
+                    var result = _this.visit(node.body);
+                    _this.scopes.shift();
+                    return result;
+                };
+            }
+        },
+        {
+            key: "handleCallExpression",
+            value: function(node) {
+                var _this = this;
+                var calledString = this.getNodeString(node.callee);
+                var func = this.visit(node.callee);
+                if ("function" != typeof func) {
+                    var isOptional = node.optional || node.callee.optional;
+                    if (null == func && isOptional) return;
+                    throw new TypeError("".concat(calledString, " is not a function"));
+                }
+                var args = node["arguments"].map(function(arg) {
+                    return _this.visit(arg);
+                });
+                return func.apply(void 0, _to_consumable_array(args));
+            }
+        },
+        {
+            key: "handleTemplateLiteral",
+            value: function(node) {
+                var _this = this;
+                return node.quasis.concat(node.expressions).filter(Boolean).sort(function(a, b) {
+                    return a.start - b.start;
+                }).map(function(node) {
+                    if ("TemplateElement" === node.type) return node.value.raw;
+                    return _this.visit(node);
+                }).join("");
+            }
+        },
+        {
+            key: "getNodeString",
+            value: function(node) {
+                switch(node.type){
+                    case "Identifier":
+                        return node.name;
+                    case "Literal":
+                        return node.raw;
+                    case "ArrayExpression":
+                        return "(array)";
+                    case "ObjectExpression":
+                        return "(object)";
+                    case "MemberExpression":
+                        var accessor = this.getNodeString(node.object);
+                        if (node.computed) accessor += "[".concat(this.getNodeString(node.property), "]");
+                        else accessor += ".".concat(this.getNodeString(node.property));
+                        return accessor;
+                    default:
+                        return null;
+                }
+            }
+        }
+    ]);
+    return Evaluator;
+}();
+var TEMPLATE_EXPRESSION_REGEX = /\$\{\{((?:[^{}]|{[^{}]*})+)\}\}/g;
+function evaluatorExpression(expression, context) {
+    var evaluator = new Evaluator_Evaluator(context);
+    return evaluator.evaluate(expression);
+}
+function evaluatorTemplate(template, context) {
+    var evaluator = new Evaluator_Evaluator(context);
+    return template.replace(TEMPLATE_EXPRESSION_REGEX, function(match, expression) {
+        try {
+            var value = evaluator.evaluate(expression.trim());
+            return String(value);
+        } catch (error) {
+            if (error instanceof ReferenceError && error.message.endsWith("is not defined")) return "";
+            throw error;
+        }
+    });
+}
+exports.evaluatorExpression = __webpack_exports__.evaluatorExpression;
+exports.evaluatorTemplate = __webpack_exports__.evaluatorTemplate;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "evaluatorExpression",
+    "evaluatorTemplate"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+//# sourceMappingURL=index.cjs.map