ecma-evaluator 1.0.0 → 2.0.0

package/dist/esm/index.mjs

@@ -1,4 +1,145 @@
-import * as __WEBPACK_EXTERNAL_MODULE_acorn__ from "acorn";
+import { parse as external_acorn_parse } from "acorn";
+import globals from "globals";
+var mutableMethods = [
+    "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",
+    "Object.defineProperty",
+    "Object.defineProperties",
+    "Object.preventExtensions",
+    "Object.seal",
+    "Object.freeze",
+    "Object.setPrototypeOf",
+    "Object.assign",
+    "Reflect.set",
+    "Reflect.defineProperty",
+    "Reflect.deleteProperty",
+    "Reflect.setPrototypeOf",
+    "Reflect.preventExtensions",
+    "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.setTime",
+    "Date.prototype.setMilliseconds",
+    "Date.prototype.setUTCSeconds",
+    "Date.prototype.setSeconds",
+    "Date.prototype.setMinutes",
+    "Date.prototype.setHours",
+    "Date.prototype.setDate",
+    "Date.prototype.setMonth",
+    "Date.prototype.setFullYear",
+    "Date.prototype.setYear",
+    "Date.prototype.setUTCMilliseconds",
+    "Date.prototype.setUTCMinutes",
+    "Date.prototype.setUTCHours",
+    "Date.prototype.setUTCDate",
+    "Date.prototype.setUTCMonth",
+    "Date.prototype.setUTCFullYear",
+    "RegExp.prototype.compile",
+    "Int8Array.prototype.set",
+    "Uint8Array.prototype.set",
+    "Uint8ClampedArray.prototype.set",
+    "Int16Array.prototype.set",
+    "Uint16Array.prototype.set",
+    "Int32Array.prototype.set",
+    "Uint32Array.prototype.set",
+    "Float32Array.prototype.set",
+    "Float64Array.prototype.set",
+    "BigInt64Array.prototype.set",
+    "BigUint64Array.prototype.set",
+    "Int8Array.prototype.fill",
+    "Uint8Array.prototype.fill",
+    "Uint8ClampedArray.prototype.fill",
+    "Int16Array.prototype.fill",
+    "Uint16Array.prototype.fill",
+    "Int32Array.prototype.fill",
+    "Uint32Array.prototype.fill",
+    "Float32Array.prototype.fill",
+    "Float64Array.prototype.fill",
+    "BigInt64Array.prototype.fill",
+    "BigUint64Array.prototype.fill",
+    "Int8Array.prototype.reverse",
+    "Uint8Array.prototype.reverse",
+    "Uint8ClampedArray.prototype.reverse",
+    "Int16Array.prototype.reverse",
+    "Uint16Array.prototype.reverse",
+    "Int32Array.prototype.reverse",
+    "Uint32Array.prototype.reverse",
+    "Float32Array.prototype.reverse",
+    "Float64Array.prototype.reverse",
+    "BigInt64Array.prototype.reverse",
+    "BigUint64Array.prototype.reverse",
+    "Int8Array.prototype.sort",
+    "Uint8Array.prototype.sort",
+    "Uint8ClampedArray.prototype.sort",
+    "Int16Array.prototype.sort",
+    "Uint16Array.prototype.sort",
+    "Int32Array.prototype.sort",
+    "Uint32Array.prototype.sort",
+    "Float32Array.prototype.sort",
+    "Float64Array.prototype.sort",
+    "BigInt64Array.prototype.sort",
+    "BigUint64Array.prototype.sort",
+    "Int8Array.prototype.copyWithin",
+    "Uint8Array.prototype.copyWithin",
+    "Uint8ClampedArray.prototype.copyWithin",
+    "Int16Array.prototype.copyWithin",
+    "Uint16Array.prototype.copyWithin",
+    "Int32Array.prototype.copyWithin",
+    "Uint32Array.prototype.copyWithin",
+    "Float32Array.prototype.copyWithin",
+    "Float64Array.prototype.copyWithin",
+    "BigInt64Array.prototype.copyWithin",
+    "BigUint64Array.prototype.copyWithin",
+    "ArrayBuffer.prototype.transfer",
+    "ArrayBuffer.prototype.transferToFixedLength",
+    "SharedArrayBuffer.prototype.grow",
+    "DataView.prototype.setInt8",
+    "DataView.prototype.setUint8",
+    "DataView.prototype.setInt16",
+    "DataView.prototype.setUint16",
+    "DataView.prototype.setInt32",
+    "DataView.prototype.setUint32",
+    "DataView.prototype.setFloat32",
+    "DataView.prototype.setFloat64",
+    "DataView.prototype.setBigInt64",
+    "DataView.prototype.setBigUint64",
+    "Promise.prototype.catch",
+    "Promise.prototype.finally",
+    "Generator.prototype.next",
+    "Generator.prototype.return",
+    "Generator.prototype.throw",
+    "AsyncGenerator.prototype.next",
+    "AsyncGenerator.prototype.return",
+    "AsyncGenerator.prototype.throw",
+    "Iterator.prototype.next",
+    "WeakRef.prototype.deref",
+    "FinalizationRegistry.prototype.register",
+    "FinalizationRegistry.prototype.unregister",
+    "URLSearchParams.prototype.append",
+    "URLSearchParams.prototype.delete",
+    "URLSearchParams.prototype.set",
+    "URLSearchParams.prototype.sort",
+    "FormData.prototype.append",
+    "FormData.prototype.delete",
+    "FormData.prototype.set",
+    "Headers.prototype.append",
+    "Headers.prototype.delete",
+    "Headers.prototype.set"
+];
 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];
@@ -40,62 +181,19 @@ function _create_class(Constructor, protoProps, staticProps) {
     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 _instanceof(left, right) {
+    if (null != right && "undefined" != typeof Symbol && right[Symbol.hasInstance]) return !!right[Symbol.hasInstance](left);
+    return left instanceof right;
 }
 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;
@@ -103,8 +201,8 @@ function _set_prototype_of(o, p) {
     };
     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_array(arr) {
+    return _array_with_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _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();
@@ -128,132 +226,110 @@ function _is_native_reflect_construct() {
         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 ERROR_MESSAGES = {
+    DELETE_NOT_SUPPORTED: "Delete operator is not allow",
+    MUTABLE_METHOD: "Mutable method is not allowed",
+    NEW_FUNCTION_NOT_ALLOWED: "Cannot use new with Function constructor",
+    NOT_A_FUNCTION: "is not a function",
+    PROPERTY_READ_ERROR: "Cannot read property",
+    VARIABLE_NOT_DEFINED: "is not defined",
+    FUNCTION_CONSTRUCTOR_NOT_ALLOWED: "Function constructor is not allowed",
+    THIS_NOT_ALLOWED: "'this' keyword is not allowed",
+    NOT_A_VALID_SYNTAX: "is not a valid syntax"
+};
+function createGlobalScope() {
+    var scope = Object.create(null);
+    var builtin = globals.builtin;
+    Object.keys(builtin).forEach(function(key) {
+        if (key in globalThis && "eval" !== key && "globalThis" !== key) {
+            var isWritable = builtin[key];
+            Object.defineProperty(scope, key, {
+                value: globalThis[key],
+                writable: isWritable,
+                enumerable: false,
+                configurable: false
+            });
+        }
+    });
+    Object.defineProperty(scope, "globalThis", {
+        value: scope,
+        writable: false,
+        enumerable: false,
+        configurable: false
+    });
+    return scope;
+}
+var getMutableMethods = function() {
+    var MUTABLE_METHODS = null;
+    return function() {
+        if (MUTABLE_METHODS) return MUTABLE_METHODS;
+        var set = new Set();
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+        try {
+            for(var _iterator = mutableMethods[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var path = _step.value;
+                var _path_split = _to_array(path.split(".")), object = _path_split[0], properties = _path_split.slice(1);
+                var current = globalThis[object];
+                var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+                try {
+                    for(var _iterator1 = properties[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                        var prop = _step1.value;
+                        if (current && Object.hasOwn(current, prop)) current = current[prop];
+                        else {
+                            current = null;
+                            break;
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError1 = true;
+                    _iteratorError1 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion1 && null != _iterator1.return) _iterator1.return();
+                    } finally{
+                        if (_didIteratorError1) throw _iteratorError1;
+                    }
+                }
+                if ("function" == typeof current) set.add(current);
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && null != _iterator.return) _iterator.return();
+            } finally{
+                if (_didIteratorError) throw _iteratorError;
+            }
+        }
+        MUTABLE_METHODS = set;
+        return MUTABLE_METHODS;
+    };
+}();
 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
+            createGlobalScope()
         ];
+        this.source = void 0;
     }
     _create_class(Evaluator, [
         {
             key: "evaluate",
             value: function(expression) {
-                var ast = __WEBPACK_EXTERNAL_MODULE_acorn__.parse(expression, {
+                this.source = expression;
+                var ast = external_acorn_parse(expression, {
                     ecmaVersion: "latest"
                 });
-                return this.execute(ast.body);
+                try {
+                    return this.execute(ast.body);
+                } finally{
+                    this.source = void 0;
+                }
             }
         },
         {
@@ -271,7 +347,7 @@ var Evaluator_Evaluator = /*#__PURE__*/ function() {
                     _iteratorError = err;
                 } finally{
                     try {
-                        if (!_iteratorNormalCompletion && null != _iterator["return"]) _iterator["return"]();
+                        if (!_iteratorNormalCompletion && null != _iterator.return) _iterator.return();
                     } finally{
                         if (_didIteratorError) throw _iteratorError;
                     }
@@ -302,6 +378,10 @@ var Evaluator_Evaluator = /*#__PURE__*/ function() {
                         return this.handleObjectExpression(node);
                     case "ArrayExpression":
                         return this.handleArrayExpression(node);
+                    case "SpreadElement":
+                        return this.handleSpreadElement(node);
+                    case "ObjectExpression":
+                        return this.handleObjectExpression(node);
                     case "ArrowFunctionExpression":
                         return this.handleArrowFunctionExpression(node);
                     case "CallExpression":
@@ -310,68 +390,76 @@ var Evaluator_Evaluator = /*#__PURE__*/ function() {
                         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");
+                        if ("Function" === node.callee.name) throw new Error(ERROR_MESSAGES.NEW_FUNCTION_NOT_ALLOWED);
                         var Constructor = this.visit(node.callee);
-                        var args = node["arguments"].map(function(arg) {
+                        var args = node.arguments.length ? 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);
+                    case "ThisExpression":
+                        throw new Error(ERROR_MESSAGES.THIS_NOT_ALLOWED);
                     default:
-                        throw new Error("Unsupported node type: ".concat(node.type));
+                        var content = this.source.slice(node.start, node.end);
+                        if (content.length > 20) content = content.slice(0, 17) + "...";
+                        throw new Error("'".concat(content, "'") + " " + ERROR_MESSAGES.NOT_A_VALID_SYNTAX);
                 }
             }
         },
         {
             key: "handleBinaryExpression",
             value: function(node) {
-                switch(node.operator){
+                var op = node.operator;
+                var left = this.visit(node.left);
+                var right = this.visit(node.right);
+                switch(op){
                     case "+":
-                        return this.visit(node.left) + this.visit(node.right);
+                        return left + right;
                     case "-":
-                        return this.visit(node.left) - this.visit(node.right);
+                        return left - right;
                     case "*":
-                        return this.visit(node.left) * this.visit(node.right);
+                        return left * 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;
+                        return Math.pow(left, right);
                     case "==":
-                        return this.visit(node.left) == this.visit(node.right);
+                        return left == right;
                     case "===":
-                        return this.visit(node.left) === this.visit(node.right);
+                        return left === right;
                     case "!=":
-                        return this.visit(node.left) != this.visit(node.right);
+                        return left != right;
                     case "!==":
-                        return this.visit(node.left) !== this.visit(node.right);
+                        return left !== right;
                     case ">":
-                        return this.visit(node.left) > this.visit(node.right);
+                        return left > right;
                     case ">=":
-                        return this.visit(node.left) >= this.visit(node.right);
+                        return left >= right;
                     case "<":
-                        return this.visit(node.left) < this.visit(node.right);
+                        return left < right;
                     case "<=":
-                        return this.visit(node.left) <= this.visit(node.right);
+                        return left <= right;
                     case "%":
-                        return this.visit(node.left) % this.visit(node.right);
-                    case "&":
-                        return this.visit(node.left) & this.visit(node.right);
+                        return left % right;
+                    case "/":
+                        return left / right;
                     case "|":
-                        return this.visit(node.left) | this.visit(node.right);
+                        return left | right;
+                    case "&":
+                        return left & right;
                     case "^":
-                        return this.visit(node.left) ^ this.visit(node.right);
+                        return left ^ right;
                     case "<<":
-                        return this.visit(node.left) << this.visit(node.right);
+                        return left << right;
                     case ">>":
-                        return this.visit(node.left) >> this.visit(node.right);
+                        return left >> right;
                     case ">>>":
-                        return this.visit(node.left) >>> this.visit(node.right);
+                        return left >>> right;
+                    case "in":
+                        return left in right;
+                    case "instanceof":
+                        return _instanceof(left, right);
                     default:
                         throw new Error("Unsupported operator: ".concat(node.operator));
                 }
@@ -382,12 +470,14 @@ var Evaluator_Evaluator = /*#__PURE__*/ function() {
             value: function(node) {
                 switch(node.operator){
                     case "&&":
-                        return this.visit(node.left) && this.visit(node.right);
+                        var left = this.visit(node.left);
+                        return left ? this.visit(node.right) : left;
                     case "||":
-                        return this.visit(node.left) || this.visit(node.right);
+                        var left1 = this.visit(node.left);
+                        return left1 ? left1 : this.visit(node.right);
                     case "??":
-                        var left = this.visit(node.left);
-                        return null != left ? left : this.visit(node.right);
+                        var left2 = this.visit(node.left);
+                        return null != left2 ? left2 : this.visit(node.right);
                     default:
                         throw new Error("Unsupported logical operator: ".concat(node.operator));
                 }
@@ -410,7 +500,7 @@ var Evaluator_Evaluator = /*#__PURE__*/ function() {
                     case "void":
                         return void this.visit(node.argument);
                     case "delete":
-                        throw new Error("Delete operator is mutable and not supported");
+                        throw new Error(ERROR_MESSAGES.DELETE_NOT_SUPPORTED);
                     default:
                         throw new Error("Unsupported unary operator: ".concat(node.operator));
                 }
@@ -431,28 +521,25 @@ var Evaluator_Evaluator = /*#__PURE__*/ function() {
                     _iteratorError = err;
                 } finally{
                     try {
-                        if (!_iteratorNormalCompletion && null != _iterator["return"]) _iterator["return"]();
+                        if (!_iteratorNormalCompletion && null != _iterator.return) _iterator.return();
                     } finally{
                         if (_didIteratorError) throw _iteratorError;
                     }
                 }
-                throw new ReferenceError("".concat(name, " is not defined"));
+                throw new ReferenceError("".concat(name, " ").concat(ERROR_MESSAGES.VARIABLE_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;
+                var isStaticProperty = "Identifier" === node.property.type && !node.computed;
+                var property = isStaticProperty ? node.property.name : this.visit(node.property);
                 if (null == object) {
                     if (node.optional) return;
-                    throw new TypeError("Cannot read property '".concat(property, "' of ").concat(object));
+                    throw new TypeError("".concat(ERROR_MESSAGES.PROPERTY_READ_ERROR, " '").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;
+                return object[property];
             }
         },
         {
@@ -463,6 +550,10 @@ var Evaluator_Evaluator = /*#__PURE__*/ function() {
                 try {
                     for(var _iterator = node.properties[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                         var prop = _step.value;
+                        if ("SpreadElement" === prop.type) {
+                            Object.assign(obj, this.visit(prop.argument));
+                            continue;
+                        }
                         var key = prop.key.name || prop.key.value;
                         var value = this.visit(prop.value);
                         obj[key] = value;
@@ -472,7 +563,7 @@ var Evaluator_Evaluator = /*#__PURE__*/ function() {
                     _iteratorError = err;
                 } finally{
                     try {
-                        if (!_iteratorNormalCompletion && null != _iterator["return"]) _iterator["return"]();
+                        if (!_iteratorNormalCompletion && null != _iterator.return) _iterator.return();
                     } finally{
                         if (_didIteratorError) throw _iteratorError;
                     }
@@ -483,10 +574,22 @@ var Evaluator_Evaluator = /*#__PURE__*/ function() {
         {
             key: "handleArrayExpression",
             value: function(node) {
-                var _this = this;
-                return node.elements.map(function(element) {
-                    return _this.visit(element);
-                });
+                var result = [];
+                for(var i = 0; i < node.elements.length; i++){
+                    var element = node.elements.at(i);
+                    var value = this.visit(element);
+                    if ("SpreadElement" === element.type) {
+                        var _result;
+                        (_result = result).push.apply(_result, _to_consumable_array(value));
+                    } else result.push(value);
+                }
+                return result;
+            }
+        },
+        {
+            key: "handleSpreadElement",
+            value: function(node) {
+                return this.visit(node.argument);
             }
         },
         {
@@ -496,22 +599,8 @@ var Evaluator_Evaluator = /*#__PURE__*/ function() {
                 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;
-                        }
-                    }
+                    var paramCount = node.params.length;
+                    for(var i = 0; i < paramCount; i++)newScope[node.params[i].name] = args[i];
                     _this.scopes.unshift(newScope);
                     var result = _this.visit(node.body);
                     _this.scopes.shift();
@@ -523,73 +612,269 @@ var Evaluator_Evaluator = /*#__PURE__*/ function() {
             key: "handleCallExpression",
             value: function(node) {
                 var _this = this;
-                var calledString = this.getNodeString(node.callee);
+                if ("MemberExpression" === node.callee.type) {
+                    var object = this.visit(node.callee.object);
+                    if (getMutableMethods().has(object)) throw new Error(ERROR_MESSAGES.MUTABLE_METHOD);
+                }
+                var calledString = 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"));
+                    throw new TypeError("".concat(calledString, " ").concat(ERROR_MESSAGES.NOT_A_FUNCTION));
                 }
-                var args = node["arguments"].map(function(arg) {
-                    return _this.visit(arg);
-                });
-                return func.apply(void 0, _to_consumable_array(args));
+                if (func === Function) throw new Error(ERROR_MESSAGES.FUNCTION_CONSTRUCTOR_NOT_ALLOWED);
+                var args = function() {
+                    if (0 === node.arguments.length) return [];
+                    var result = [];
+                    for(var i = 0; i < node.arguments.length; i++){
+                        var element = node.arguments.at(i);
+                        var value = _this.visit(element);
+                        if ("SpreadElement" === element.type) {
+                            var _result;
+                            (_result = result).push.apply(_result, _to_consumable_array(value));
+                        } else result.push(value);
+                    }
+                    return result;
+                }();
+                if (getMutableMethods().has(func)) throw new Error(ERROR_MESSAGES.MUTABLE_METHOD);
+                var target = "MemberExpression" === node.callee.type ? this.visit(node.callee.object) : null;
+                return func.apply(target, 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("");
+                var result = "";
+                var expressionCount = node.expressions.length;
+                for(var i = 0; i < node.quasis.length; i++){
+                    result += node.quasis[i].value.raw;
+                    if (i < expressionCount) result += this.visit(node.expressions[i]);
+                }
+                return result;
             }
-        },
+        }
+    ], [
         {
-            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;
-                }
+            key: "evaluate",
+            value: function(expression, context) {
+                var evaluator = new Evaluator(context);
+                return evaluator.evaluate(expression);
             }
         }
     ]);
     return Evaluator;
 }();
-var TEMPLATE_EXPRESSION_REGEX = /\$\{\{((?:[^{}]|{[^{}]*})+)\}\}/g;
-function evaluatorExpression(expression, context) {
-    var evaluator = new Evaluator_Evaluator(context);
-    return evaluator.evaluate(expression);
+function getNodeString(node) {
+    switch(node.type){
+        case "Identifier":
+            return node.name;
+        case "Literal":
+            return node.raw;
+        case "ArrayExpression":
+            return "[".concat(node.elements.map(function(child) {
+                return getNodeString(child);
+            }).join(","), "]");
+        case "ObjectExpression":
+            if (0 === node.properties.length) return "{}";
+            return "{(intermediate value)}";
+        case "MemberExpression":
+            var objectStr = getNodeString(node.object);
+            var propertyStr = getNodeString(node.property);
+            if (node.computed) return "".concat(objectStr, "[").concat(propertyStr, "]");
+            return "".concat(objectStr, ".").concat(propertyStr);
+        default:
+            return null;
+    }
+}
+function TemplateParser_class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function TemplateParser_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 TemplateParser_create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) TemplateParser_defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) TemplateParser_defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+var TemplateParser_TemplateParser = /*#__PURE__*/ function() {
+    "use strict";
+    function TemplateParser() {
+        var options = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {};
+        TemplateParser_class_call_check(this, TemplateParser);
+        this.exprStart = options.expressionStart || "{{";
+        this.exprEnd = options.expressionEnd || "}}";
+        this.startLen = this.exprStart.length;
+        this.endLen = this.exprEnd.length;
+        this.preserveWhitespace = true === options.preserveWhitespace;
+    }
+    TemplateParser_create_class(TemplateParser, [
+        {
+            key: "parse",
+            value: function(template) {
+                if ("string" != typeof template) throw new TypeError("模板必须是字符串");
+                var tokens = [];
+                var length = template.length;
+                var state = "TEXT";
+                var buffer = "";
+                var exprStartPos = 0;
+                var pos = 0;
+                while(pos < length){
+                    var char = template[pos];
+                    var nextChar = template[pos + 1];
+                    switch(state){
+                        case "TEXT":
+                            if (this._isMatch(pos, template, this.exprStart)) {
+                                if (buffer.length > 0) {
+                                    tokens.push({
+                                        type: "text",
+                                        value: buffer,
+                                        start: pos - buffer.length,
+                                        end: pos
+                                    });
+                                    buffer = "";
+                                }
+                                state = "EXPR";
+                                exprStartPos = pos;
+                                pos += this.startLen;
+                                continue;
+                            }
+                            buffer += char;
+                            break;
+                        case "EXPR":
+                            if ("'" === char) state = "STRING_SQ";
+                            else if ('"' === char) state = "STRING_DQ";
+                            else if ("`" === char) state = "TEMPLATE";
+                            else if ("\\" === char) state = "'" === nextChar ? "ESCAPE_SQ" : '"' === nextChar ? "ESCAPE_DQ" : "`" === nextChar ? "ESCAPE_TEMPLATE" : "ESCAPE_EXPR";
+                            else if (this._isMatch(pos, template, this.exprEnd)) {
+                                var exprValue = this.preserveWhitespace ? buffer : buffer.trim();
+                                if (exprValue.length > 0) tokens.push({
+                                    type: "expression",
+                                    value: exprValue,
+                                    start: exprStartPos,
+                                    end: pos + this.endLen,
+                                    contentStart: exprStartPos + this.startLen,
+                                    contentEnd: pos
+                                });
+                                buffer = "";
+                                state = "TEXT";
+                                pos += this.endLen;
+                                continue;
+                            }
+                            buffer += char;
+                            break;
+                        case "STRING_SQ":
+                            if ("\\" === char) state = "ESCAPE_SQ";
+                            else if ("'" === char) state = "EXPR";
+                            buffer += char;
+                            break;
+                        case "STRING_DQ":
+                            if ("\\" === char) state = "ESCAPE_DQ";
+                            else if ('"' === char) state = "EXPR";
+                            buffer += char;
+                            break;
+                        case "TEMPLATE":
+                            if ("\\" === char) state = "ESCAPE_TEMPLATE";
+                            else if ("`" === char) state = "EXPR";
+                            buffer += char;
+                            break;
+                        case "ESCAPE_SQ":
+                            buffer += char;
+                            state = "STRING_SQ";
+                            break;
+                        case "ESCAPE_DQ":
+                            buffer += char;
+                            state = "STRING_DQ";
+                            break;
+                        case "ESCAPE_TEMPLATE":
+                            buffer += char;
+                            state = "TEMPLATE";
+                            break;
+                        case "ESCAPE_EXPR":
+                            buffer += char;
+                            state = "EXPR";
+                            break;
+                    }
+                    pos++;
+                }
+                if (buffer.length > 0) if ("TEXT" === state) tokens.push({
+                    type: "text",
+                    value: buffer,
+                    start: pos - buffer.length,
+                    end: pos
+                });
+                else {
+                    var incompleteExpr = this.exprStart + buffer;
+                    tokens.push({
+                        type: "text",
+                        value: incompleteExpr,
+                        start: exprStartPos,
+                        end: pos
+                    });
+                    console.warn("警告：在位置 ".concat(exprStartPos, " 开始的表达式未正确结束"));
+                }
+                return tokens;
+            }
+        },
+        {
+            key: "_isMatch",
+            value: function(pos, template, sequence) {
+                if (pos + sequence.length > template.length) return false;
+                for(var i = 0; i < sequence.length; i++)if (template[pos + i] !== sequence[i]) return false;
+                return true;
+            }
+        }
+    ], [
+        {
+            key: "parse",
+            value: function(template, options) {
+                var parser = new TemplateParser(options);
+                return parser.parse(template);
+            }
+        }
+    ]);
+    return TemplateParser;
+}();
+function src_instanceof(left, right) {
+    if (null != right && "undefined" != typeof Symbol && right[Symbol.hasInstance]) return !!right[Symbol.hasInstance](left);
+    return left instanceof right;
 }
-function evaluatorTemplate(template, context) {
-    var evaluator = new Evaluator_Evaluator(context);
-    return template.replace(TEMPLATE_EXPRESSION_REGEX, function(match, expression) {
+function evalExpression(expression, context) {
+    return Evaluator_Evaluator.evaluate(expression, context);
+}
+function evalTemplate(template, context, templateParserOptions) {
+    var result = "";
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+    try {
+        for(var _iterator = TemplateParser_TemplateParser.parse(template, templateParserOptions)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var token = _step.value;
+            if ("text" === token.type) result += token.value;
+            else if ("expression" === token.type) try {
+                result += Evaluator_Evaluator.evaluate(token.value, context);
+            } catch (error) {
+                if (src_instanceof(error, ReferenceError) && error.message.endsWith("is not defined")) result += "undefined";
+                else throw error;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
         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;
+            if (!_iteratorNormalCompletion && null != _iterator.return) _iterator.return();
+        } finally{
+            if (_didIteratorError) throw _iteratorError;
         }
-    });
+    }
+    return result;
 }
-export { evaluatorExpression, evaluatorTemplate };
+export { Evaluator_Evaluator as Evaluator, evalExpression, evalTemplate };
 
 //# sourceMappingURL=index.mjs.map