ecma-evaluator 2.0.9 → 2.1.0

package/dist/esm/index.mjs

@@ -35,6 +35,7 @@ var mutableMethods = [
     "Array.prototype.sort",
     "Array.prototype.fill",
     "Array.prototype.copyWithin",
+    "Object.create",
     "Object.defineProperty",
     "Object.defineProperties",
     "Object.preventExtensions",
@@ -144,8 +145,6 @@ var mutableMethods = [
     "DataView.prototype.setFloat64",
     "DataView.prototype.setBigInt64",
     "DataView.prototype.setBigUint64",
-    "Promise.prototype.catch",
-    "Promise.prototype.finally",
     "Generator.prototype.next",
     "Generator.prototype.return",
     "Generator.prototype.throw",
@@ -180,7 +179,8 @@ var dangerousMethods = [
     "Object.getOwnPropertyDescriptors",
     "Object.getOwnPropertyNames",
     "Object.getOwnPropertySymbols",
-    "Object.getOwnPropertyDescriptors"
+    "Error.captureStackTrace",
+    "Error.prepareStackTrace"
 ];
 mutableMethods.push("Object.prototype.__proto__");
 var blockedMethods = _to_consumable_array(mutableMethods).concat(_to_consumable_array(dangerousMethods));
@@ -227,6 +227,10 @@ var blockedGlobalBuiltIns = [
     "Reflect",
     "Atomics",
     "WebAssembly",
+    "SharedArrayBuffer",
+    "queueMicrotask",
+    "AbortSignal",
+    "Promise",
     "console",
     "Intl",
     "Deno"
@@ -322,14 +326,173 @@ var ERROR_MESSAGES = {
     IS_INVALID_SYNTAX: "{0} is not a valid syntax",
     IS_NOT_FUNCTION: "{0} is not a function",
     IS_NOT_DEFINED: "{0} is not defined",
-    IS_NOT_ALLOWED: "{0} is not allowed"
+    IS_NOT_ALLOWED: "{0} is not allowed",
+    EXPRESSION_TOO_LONG: "Expression exceeds the maximum length of {0} characters"
 };
+var DEFAULT_MAX_INPUT_LENGTH = 10000;
+var MAX_CONFIGURABLE_INPUT_LENGTH = 100000;
+var DEFAULT_MAX_EVALUATION_STEPS = 10000;
+var MAX_CONFIGURABLE_EVALUATION_STEPS = 100000;
+var MAX_ARRAY_LENGTH = 10000;
+var MAX_BUFFER_BYTES = 1000000;
+var MAX_STRING_LENGTH = 100000;
+var MAX_DATA_NODES = 100000;
+var MAX_BIGINT_EXPONENT = 256n;
+var MAX_BIGINT_BITS = 65536;
+var DEFAULT_MAX_DEPTH = 1000;
+var MAX_CONFIGURABLE_DEPTH = 2000;
+var MAX_REGEXP_SOURCE_LENGTH = 1000;
+var MAX_REGEXP_FLAGS_LENGTH = 32;
+var NON_SANDBOX_GLOBALS = new Set([
+    "WeakRef",
+    "FinalizationRegistry",
+    "Iterator",
+    "SharedArrayBuffer",
+    "escape",
+    "unescape"
+]);
+var TYPED_ARRAY_CONSTRUCTORS = new Set([
+    Int8Array,
+    Uint8Array,
+    Uint8ClampedArray,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    "function" == typeof Float16Array ? Float16Array : null,
+    Float32Array,
+    Float64Array,
+    "function" == typeof BigInt64Array ? BigInt64Array : null,
+    "function" == typeof BigUint64Array ? BigUint64Array : null
+].filter(function(constructor) {
+    return "function" == typeof constructor;
+}));
+function isTypedArrayConstructor(value) {
+    return TYPED_ARRAY_CONSTRUCTORS.has(value) || "function" == typeof value && "number" == typeof value.BYTES_PER_ELEMENT;
+}
+var TYPED_ARRAY_MUTATORS = function() {
+    var map = new Map();
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+    try {
+        for(var _iterator = TYPED_ARRAY_CONSTRUCTORS[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var constructor = _step.value;
+            for(var _i = 0, _iter = [
+                "set",
+                "fill",
+                "reverse",
+                "sort",
+                "copyWithin"
+            ]; _i < _iter.length; _i++){
+                var name = _iter[_i];
+                var method = constructor.prototype[name];
+                if ("function" == typeof method && !map.has(method)) map.set(method, name);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && null != _iterator.return) _iterator.return();
+        } finally{
+            if (_didIteratorError) throw _iteratorError;
+        }
+    }
+    return map;
+}();
+var NO_OBJECT = Symbol("no-object");
 var renderErrorMessage = function(template) {
     var context = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {};
     return template.replace(/{(\w+)}/g, function(_, key) {
         return String(context[key]);
     });
 };
+function validateLimit(value, name, defaultValue, maximum) {
+    if (void 0 === value) return defaultValue;
+    if (!Number.isSafeInteger(value) || value < 1 || value > maximum) throw new RangeError("".concat(name, " must be an integer between 1 and ").concat(maximum));
+    return value;
+}
+function countLiteralMatches(value, search, all) {
+    if ("" === search) return all ? value.length + 1 : 1;
+    var count = 0;
+    var position = 0;
+    while(-1 !== (position = value.indexOf(search, position))){
+        count++;
+        if (!all) break;
+        position += search.length;
+    }
+    return count;
+}
+function assertBoundedData(value, label) {
+    var pending = [
+        value
+    ];
+    var seen = new WeakSet();
+    var dataSize = 0;
+    var dataNodes = 0;
+    var enqueueProperties = function(object) {
+        var keys = Object.keys(object);
+        if (pending.length + keys.length > MAX_DATA_NODES) throw new RangeError("".concat(label, " exceeds the maximum data node count"));
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+        try {
+            for(var _iterator = keys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var key = _step.value;
+                dataSize += key.length;
+                var descriptor = Object.getOwnPropertyDescriptor(object, key);
+                if (!descriptor || !Object.hasOwn(descriptor, "value")) throw new TypeError("".concat(label, " cannot contain accessor properties"));
+                pending.push(descriptor.value);
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && null != _iterator.return) _iterator.return();
+            } finally{
+                if (_didIteratorError) throw _iteratorError;
+            }
+        }
+    };
+    while(pending.length > 0){
+        var current = pending.pop();
+        dataNodes++;
+        if (dataNodes > MAX_DATA_NODES) throw new RangeError("".concat(label, " exceeds the maximum data node count"));
+        if ("string" == typeof current) {
+            if (current.length > MAX_STRING_LENGTH) throw new RangeError("".concat(label, " contains a string that exceeds the maximum length"));
+            dataSize += current.length + 8;
+        } else if (null === current || (void 0 === current ? "undefined" : _type_of(current)) !== "object" && "function" != typeof current) {
+            dataSize += 8;
+            continue;
+        } else {
+            if ("function" == typeof current || seen.has(current)) continue;
+            seen.add(current);
+            dataSize += 16;
+            if (_instanceof(current, ArrayBuffer) || ArrayBuffer.isView(current)) dataSize += current.byteLength;
+            else if (Array.isArray(current)) {
+                if (current.length > MAX_ARRAY_LENGTH) throw new RangeError("".concat(label, " contains an array that exceeds the maximum length"));
+                dataSize += 8 * current.length;
+                enqueueProperties(current);
+            } else if (_instanceof(current, Map)) {
+                if (current.size > MAX_ARRAY_LENGTH) throw new RangeError("".concat(label, " contains a map that exceeds the maximum size"));
+                dataSize += 16 * current.size;
+                Map.prototype.forEach.call(current, function(item, key) {
+                    return pending.push(key, item);
+                });
+            } else if (_instanceof(current, Set)) {
+                if (current.size > MAX_ARRAY_LENGTH) throw new RangeError("".concat(label, " contains a set that exceeds the maximum size"));
+                dataSize += 8 * current.size;
+                Set.prototype.forEach.call(current, function(item) {
+                    return pending.push(item);
+                });
+            } else enqueueProperties(current);
+        }
+        if (dataSize > MAX_BUFFER_BYTES) throw new RangeError("".concat(label, " exceeds the maximum data size"));
+    }
+    return {
+        dataSize: dataSize,
+        dataNodes: dataNodes
+    };
+}
 var BINARY_OPERATION_MAP = {
     "+": function(a, b) {
         return a + b;
@@ -401,14 +564,20 @@ var BINARY_OPERATION_MAP = {
 function createGlobalScope() {
     var scope = Object.create(null);
     var builtin = globals.builtin;
-    for(var key in builtin)if (!blockedGlobalBuiltIns.includes(key)) {
-        var isWritable = builtin[key];
-        Object.defineProperty(scope, key, {
-            value: globalThis[key],
-            writable: isWritable,
-            enumerable: false,
-            configurable: false
-        });
+    for(var key in builtin){
+        if (!blockedGlobalBuiltIns.includes(key)) {
+            if (!NON_SANDBOX_GLOBALS.has(key)) {
+                if (Object.hasOwn(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,
@@ -418,6 +587,7 @@ function createGlobalScope() {
     });
     return scope;
 }
+var GLOBAL_SCOPE = createGlobalScope();
 var getBlockedMethods = function() {
     var BLOCKED_METHODS = null;
     return function() {
@@ -468,24 +638,47 @@ var getBlockedMethods = function() {
 var Evaluator_Evaluator = /*#__PURE__*/ function() {
     "use strict";
     function Evaluator() {
-        var variables = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : Object.create(null);
+        var variables = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : Object.create(null), options = arguments.length > 1 ? arguments[1] : void 0;
         _class_call_check(this, Evaluator);
+        this.maxInputLength = validateLimit(null == options ? void 0 : options.maxInputLength, "maxInputLength", DEFAULT_MAX_INPUT_LENGTH, MAX_CONFIGURABLE_INPUT_LENGTH);
+        this.maxEvaluationSteps = validateLimit(null == options ? void 0 : options.maxEvaluationSteps, "maxEvaluationSteps", DEFAULT_MAX_EVALUATION_STEPS, MAX_CONFIGURABLE_EVALUATION_STEPS);
+        this.maxDepth = validateLimit(null == options ? void 0 : options.maxDepth, "maxDepth", DEFAULT_MAX_DEPTH, MAX_CONFIGURABLE_DEPTH);
+        assertBoundedData(variables, "Evaluation context");
+        var clonedVariables = structuredClone(variables);
         this.scopes = [
-            structuredClone(variables),
-            createGlobalScope()
+            clonedVariables,
+            GLOBAL_SCOPE
         ].filter(function(scope) {
             return null != scope;
         });
         this.source = void 0;
+        this.remainingEvaluationSteps = 0;
+        this.remainingDataSize = MAX_BUFFER_BYTES;
+        this.remainingDataNodes = MAX_DATA_NODES;
+        this.evaluationDepth = 0;
     }
     _create_class(Evaluator, [
         {
             key: "evaluate",
             value: function(expression) {
+                if ("string" != typeof expression) throw new TypeError("Expression must be a string");
+                if (expression.length > this.maxInputLength) throw new SyntaxError(renderErrorMessage(ERROR_MESSAGES.EXPRESSION_TOO_LONG, [
+                    this.maxInputLength
+                ]));
                 this.source = expression;
-                var ast = external_acorn_parse(expression, {
-                    ecmaVersion: "latest"
-                });
+                this.remainingEvaluationSteps = this.maxEvaluationSteps;
+                this.remainingDataSize = MAX_BUFFER_BYTES;
+                this.remainingDataNodes = MAX_DATA_NODES;
+                this.evaluationDepth = 0;
+                var ast;
+                try {
+                    ast = external_acorn_parse(expression, {
+                        ecmaVersion: "latest"
+                    });
+                } catch (error) {
+                    if (_instanceof(error, RangeError) && /call stack/i.test(error.message)) throw new SyntaxError("Expression nesting is too deep to parse");
+                    throw error;
+                }
                 try {
                     return this.execute(ast.body);
                 } finally{
@@ -496,6 +689,11 @@ var Evaluator_Evaluator = /*#__PURE__*/ function() {
         {
             key: "execute",
             value: function(body) {
+                if (0 === this.remainingEvaluationSteps) {
+                    this.remainingEvaluationSteps = this.maxEvaluationSteps;
+                    this.remainingDataSize = MAX_BUFFER_BYTES;
+                    this.remainingDataNodes = MAX_DATA_NODES;
+                }
                 var result;
                 var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
                 try {
@@ -516,11 +714,39 @@ var Evaluator_Evaluator = /*#__PURE__*/ function() {
                 if ("function" == typeof result) throw new Error(renderErrorMessage(ERROR_MESSAGES.IS_NOT_ALLOWED, [
                     "Returning functions from expressions"
                 ]));
-                return result;
+                assertBoundedData(result, "Evaluation result");
+                if (_instanceof(result, Promise)) throw new Error(renderErrorMessage(ERROR_MESSAGES.IS_NOT_ALLOWED, [
+                    "Returning promises from expressions"
+                ]));
+                try {
+                    return structuredClone(result);
+                } catch (error) {
+                    if (error && "DataCloneError" === error.name) throw new Error(renderErrorMessage(ERROR_MESSAGES.IS_NOT_ALLOWED, [
+                        "Returning non-cloneable values from expressions"
+                    ]));
+                    throw error;
+                }
             }
         },
         {
             key: "visit",
+            value: function(node) {
+                this.remainingEvaluationSteps--;
+                if (this.remainingEvaluationSteps < 0) throw new RangeError("Evaluation step limit exceeded");
+                this.evaluationDepth++;
+                if (this.evaluationDepth > this.maxDepth) {
+                    this.evaluationDepth--;
+                    throw new RangeError("Maximum evaluation depth exceeded");
+                }
+                try {
+                    return this.visitNode(node);
+                } finally{
+                    this.evaluationDepth--;
+                }
+            }
+        },
+        {
+            key: "visitNode",
             value: function(node) {
                 var _this = this;
                 switch(node.type){
@@ -559,10 +785,14 @@ var Evaluator_Evaluator = /*#__PURE__*/ function() {
                         if ("Function" === node.callee.name) throw new Error(renderErrorMessage(ERROR_MESSAGES.IS_NOT_ALLOWED, [
                             "new Function() constructor"
                         ]));
+                        if ("Promise" === node.callee.name) throw new Error(renderErrorMessage(ERROR_MESSAGES.IS_NOT_ALLOWED, [
+                            "Promise constructor"
+                        ]));
                         var Constructor = this.visit(node.callee);
                         var args = node.arguments.length ? node.arguments.map(function(arg) {
                             return _this.visit(arg);
                         }) : [];
+                        this.assertBoundedConstruction(Constructor, args);
                         return _construct(Constructor, Evaluator_to_consumable_array(args));
                     case "ChainExpression":
                         return this.visit(node.expression);
@@ -591,10 +821,57 @@ var Evaluator_Evaluator = /*#__PURE__*/ function() {
                 var op = node.operator;
                 var left = this.visit(node.left);
                 var right = this.visit(node.right);
+                if ("+" === op && ("string" == typeof left || "string" == typeof right)) {
+                    if (String(left).length + String(right).length > MAX_STRING_LENGTH) throw new RangeError("String result exceeds the maximum allowed length");
+                }
+                if ((void 0 === left ? "undefined" : _type_of(left)) === "bigint" && (void 0 === right ? "undefined" : _type_of(right)) === "bigint") {
+                    if ("**" === op && (right > MAX_BIGINT_EXPONENT || right < 0n)) throw new RangeError("BigInt exponent must be between 0 and ".concat(MAX_BIGINT_EXPONENT));
+                    var leftBits = left.toString(2).length;
+                    var rightBits = right.toString(2).length;
+                    if ("**" === op && leftBits * Number(right) > MAX_BIGINT_BITS || "<<" === op && right > BigInt(MAX_BIGINT_BITS) || "<<" === op && right >= 0n && leftBits + Number(right) > MAX_BIGINT_BITS || "*" === op && leftBits + rightBits > MAX_BIGINT_BITS || ("+" === op || "-" === op) && Math.max(leftBits, rightBits) + 1 > MAX_BIGINT_BITS) throw new RangeError("BigInt result exceeds the maximum allowed size");
+                }
                 if (BINARY_OPERATION_MAP.hasOwnProperty(op)) return BINARY_OPERATION_MAP[op](left, right);
                 throw new SyntaxError("Unsupported operator: ".concat(node.operator));
             }
         },
+        {
+            key: "assertBoundedRegExp",
+            value: function(args) {
+                if ("string" == typeof args[0] && args[0].length > MAX_REGEXP_SOURCE_LENGTH) throw new RangeError("RegExp source exceeds the maximum allowed length");
+                if ("string" == typeof args[1] && args[1].length > MAX_REGEXP_FLAGS_LENGTH) throw new RangeError("RegExp flags exceed the maximum allowed length");
+            }
+        },
+        {
+            key: "assertBoundedConstruction",
+            value: function(Constructor, args) {
+                var _args_;
+                if (Constructor === RegExp) this.assertBoundedRegExp(args);
+                var size = args[0];
+                if (Constructor === Array && 1 === args.length && "number" == typeof size && size > MAX_ARRAY_LENGTH) throw new RangeError("Array length exceeds the maximum allowed length");
+                if (Constructor === ArrayBuffer && (size > MAX_BUFFER_BYTES || (null == (_args_ = args[1]) ? void 0 : _args_.maxByteLength) > MAX_BUFFER_BYTES)) throw new RangeError("ArrayBuffer size exceeds the maximum allowed size");
+                if (Constructor === DataView && _instanceof(size, ArrayBuffer) && size.byteLength > MAX_BUFFER_BYTES) throw new RangeError("DataView size exceeds the maximum allowed size");
+                if (Constructor === Map || Constructor === Set) {
+                    var _size_size;
+                    var collectionSize = "string" == typeof size || Array.isArray(size) ? size.length : null != (_size_size = null == size ? void 0 : size.size) ? _size_size : null == size ? void 0 : size.length;
+                    if ("number" == typeof collectionSize && collectionSize > MAX_ARRAY_LENGTH) throw new RangeError("Collection source exceeds the maximum allowed size");
+                }
+                if (isTypedArrayConstructor(Constructor)) {
+                    var byteLength;
+                    if (_instanceof(size, ArrayBuffer)) {
+                        var _args_1;
+                        var offset = null != (_args_1 = args[1]) ? _args_1 : 0;
+                        var _args_2;
+                        var elementCount = null != (_args_2 = args[2]) ? _args_2 : Math.floor((size.byteLength - offset) / Constructor.BYTES_PER_ELEMENT);
+                        byteLength = elementCount * Constructor.BYTES_PER_ELEMENT;
+                    } else {
+                        var _size_length;
+                        var elementCount1 = "number" == typeof size ? size : null != (_size_length = null == size ? void 0 : size.length) ? _size_length : 0;
+                        byteLength = elementCount1 * Constructor.BYTES_PER_ELEMENT;
+                    }
+                    if (byteLength > MAX_BUFFER_BYTES) throw new RangeError("Typed array size exceeds the maximum allowed size");
+                }
+            }
+        },
         {
             key: "handleLogicalExpression",
             value: function(node) {
@@ -666,10 +943,14 @@ var Evaluator_Evaluator = /*#__PURE__*/ function() {
         {
             key: "handleMemberExpression",
             value: function(node) {
-                var object = this.visit(node.object);
+                var objectValue = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : NO_OBJECT;
+                var object = objectValue === NO_OBJECT ? this.visit(node.object) : objectValue;
                 var isStaticProperty = "Identifier" === node.property.type && !node.computed;
                 var property = isStaticProperty ? node.property.name : this.visit(node.property);
-                if (null != object && object[property] === (null == object ? void 0 : object.__proto__)) throw new Error(renderErrorMessage(ERROR_MESSAGES.IS_NOT_ALLOWED, [
+                if ("stack" === property && _instanceof(object, Error)) throw new Error(renderErrorMessage(ERROR_MESSAGES.IS_NOT_ALLOWED, [
+                    "Accessing error stack"
+                ]));
+                if (null != object && void 0 !== object.__proto__ && object[property] === object.__proto__) throw new Error(renderErrorMessage(ERROR_MESSAGES.IS_NOT_ALLOWED, [
                     "Accessing prototype properties"
                 ]));
                 if (null == object) {
@@ -692,30 +973,52 @@ var Evaluator_Evaluator = /*#__PURE__*/ function() {
                 var result = [];
                 for(var i = 0; i < node.elements.length; i++){
                     var element = node.elements.at(i);
+                    if (null === element) {
+                        result.length++;
+                        continue;
+                    }
                     var value = this.visit(element);
                     if ("SpreadElement" === element.type) {
                         var _result;
+                        this.assertBoundedSpread(result.length, value);
                         (_result = result).push.apply(_result, Evaluator_to_consumable_array(value));
                     } else result.push(value);
                 }
                 return result;
             }
         },
+        {
+            key: "assertBoundedSpread",
+            value: function(currentLength, value) {
+                var size = "string" == typeof value || Array.isArray(value) ? value.length : null == value ? void 0 : value.size;
+                if ("number" == typeof size && currentLength + size > MAX_ARRAY_LENGTH) throw new RangeError("Spread value exceeds the maximum allowed length");
+            }
+        },
         {
             key: "handleObjectExpression",
             value: function(node) {
                 var obj = {};
+                var spreadPropertyCount = 0;
                 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;
                         if ("SpreadElement" === prop.type) {
-                            Object.assign(obj, this.visit(prop.argument));
+                            var spreadValue = this.visit(prop.argument);
+                            spreadPropertyCount += Object.keys(spreadValue).length;
+                            if (spreadPropertyCount > MAX_ARRAY_LENGTH) throw new RangeError("Object spread exceeds the maximum allowed property count");
+                            Object.assign(obj, spreadValue);
                             continue;
                         }
-                        var key = prop.key.name || prop.key.value;
+                        var key = prop.computed ? this.visit(prop.key) : prop.key.name || prop.key.value;
                         var value = this.visit(prop.value);
-                        obj[key] = value;
+                        if (prop.computed) Object.defineProperty(obj, key, {
+                            value: value,
+                            writable: true,
+                            enumerable: true,
+                            configurable: true
+                        });
+                        else obj[key] = value;
                     }
                 } catch (err) {
                     _didIteratorError = true;
@@ -746,28 +1049,52 @@ var Evaluator_Evaluator = /*#__PURE__*/ function() {
                     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();
-                    return result;
+                    try {
+                        var result = _this.visit(node.body);
+                        _this.consumeEvaluationValue(result);
+                        return result;
+                    } finally{
+                        _this.scopes.shift();
+                    }
                 };
             }
         },
+        {
+            key: "consumeEvaluationValue",
+            value: function(value) {
+                var _assertBoundedData = assertBoundedData(value, "Intermediate evaluation result"), dataSize = _assertBoundedData.dataSize, dataNodes = _assertBoundedData.dataNodes;
+                this.remainingDataSize -= dataSize;
+                this.remainingDataNodes -= dataNodes;
+                if (this.remainingDataSize < 0 || this.remainingDataNodes < 0) throw new RangeError("Evaluation allocation budget exceeded");
+            }
+        },
         {
             key: "handleCallExpression",
             value: function(node) {
                 var _this = this;
-                var func = this.visit(node.callee);
-                var isOptional = node.optional || node.callee.optional;
+                var isOptional = node.optional || "MemberExpression" === node.callee.type && node.callee.optional;
+                var func;
+                var target = null;
+                if ("MemberExpression" === node.callee.type) {
+                    target = this.visit(node.callee.object);
+                    func = this.handleMemberExpression(node.callee, target);
+                } else func = this.visit(node.callee);
                 if (null == func && isOptional) return;
                 if (func === Function) throw new Error(renderErrorMessage(ERROR_MESSAGES.IS_NOT_ALLOWED, [
                     "Function constructor"
                 ]));
+                if (func === Error.prepareStackTrace) throw new Error(renderErrorMessage(ERROR_MESSAGES.IS_NOT_ALLOWED, [
+                    "Error.prepareStackTrace"
+                ]));
                 if (getBlockedMethods().has(func)) {
                     var path = getBlockedMethods().get(func);
                     throw new Error(renderErrorMessage(ERROR_MESSAGES.IS_NOT_ALLOWED, [
                         path
                     ]));
                 }
+                if (TYPED_ARRAY_MUTATORS.has(func)) throw new Error(renderErrorMessage(ERROR_MESSAGES.IS_NOT_ALLOWED, [
+                    "TypedArray.prototype.".concat(TYPED_ARRAY_MUTATORS.get(func))
+                ]));
                 var args = function() {
                     if (0 === node.arguments.length) return [];
                     var result = [];
@@ -776,24 +1103,57 @@ var Evaluator_Evaluator = /*#__PURE__*/ function() {
                         var value = _this.visit(element);
                         if ("SpreadElement" === element.type) {
                             var _result;
+                            _this.assertBoundedSpread(result.length, value);
                             (_result = result).push.apply(_result, Evaluator_to_consumable_array(value));
                         } else result.push(value);
                     }
                     return result;
                 }();
-                var target = "MemberExpression" === node.callee.type ? this.visit(node.callee.object) : null;
                 if (args.some(function(arg) {
                     return arg === Function;
                 })) throw new Error(renderErrorMessage(ERROR_MESSAGES.IS_NOT_ALLOWED, [
                     "Function constructor"
                 ]));
+                if ("string" == typeof target) {
+                    if (String.prototype.repeat && func === String.prototype.repeat && target.length * Number(args[0]) > MAX_STRING_LENGTH) throw new RangeError("String result exceeds the maximum allowed length");
+                    if ((String.prototype.padStart && func === String.prototype.padStart || func === String.prototype.padEnd) && Number(args[0]) > MAX_STRING_LENGTH) throw new RangeError("String result exceeds the maximum allowed length");
+                    if (String.prototype.concat && func === String.prototype.concat) {
+                        var resultLength = target.length + args.reduce(function(length, value) {
+                            return length + String(value).length;
+                        }, 0);
+                        if (resultLength > MAX_STRING_LENGTH) throw new RangeError("String result exceeds the maximum allowed length");
+                    }
+                    if (String.prototype.replace && func === String.prototype.replace || String.prototype.replaceAll && func === String.prototype.replaceAll) {
+                        if ("string" == typeof args[0]) {
+                            if ("function" == typeof args[1] || "string" == typeof args[1] && RegExp("\\$(?:[$&'`])", "u").test(args[1])) throw new Error("Only literal string replacements are allowed");
+                            if (target.length * Math.max(1, args[0].length) > 10000000) throw new RangeError("String operation exceeds the maximum work limit");
+                            var matchCount = countLiteralMatches(target, args[0], func === String.prototype.replaceAll);
+                            if (target.length + matchCount * String(args[1]).length > MAX_STRING_LENGTH) throw new RangeError("String result exceeds the maximum allowed length");
+                        }
+                    }
+                    if (func === String.prototype.split) {
+                        if ("" === args[0] && target.length > MAX_ARRAY_LENGTH) throw new RangeError("Split result exceeds the maximum allowed length");
+                        if ("string" == typeof args[0] && "" !== args[0] && countLiteralMatches(target, args[0], true) >= MAX_ARRAY_LENGTH) throw new RangeError("Split result exceeds the maximum allowed length");
+                    }
+                }
+                if (func === RegExp) this.assertBoundedRegExp(args);
+                if ((target === Array || isTypedArrayConstructor(target)) && func === target.from) {
+                    var source = args[0];
+                    var _source_size;
+                    var size = "string" == typeof source || Array.isArray(source) ? source.length : null != (_source_size = null == source ? void 0 : source.size) ? _source_size : null == source ? void 0 : source.length;
+                    if ("number" == typeof size && size > MAX_ARRAY_LENGTH) throw new RangeError("Array.from source exceeds the maximum allowed length");
+                }
                 if ("function" != typeof func) {
                     var calledString = getNodeString(node.callee);
                     throw new TypeError(renderErrorMessage(ERROR_MESSAGES.IS_NOT_FUNCTION, [
                         calledString
                     ]));
                 }
-                return func.apply(target, args);
+                var result = func.apply(target, args);
+                if (_instanceof(result, Promise)) throw new Error(renderErrorMessage(ERROR_MESSAGES.IS_NOT_ALLOWED, [
+                    "Returning promises from expressions"
+                ]));
+                return result;
             }
         },
         {
@@ -827,7 +1187,7 @@ function getNodeString(node) {
             return node.raw;
         case "ArrayExpression":
             return "[".concat(node.elements.map(function(child) {
-                return getNodeString(child);
+                return null === child ? "" : getNodeString(child);
             }).join(","), "]");
         case "ObjectExpression":
             if (0 === node.properties.length) return "{}";
@@ -858,11 +1218,25 @@ function TemplateParser_create_class(Constructor, protoProps, staticProps) {
     if (staticProps) TemplateParser_defineProperties(Constructor, staticProps);
     return Constructor;
 }
+var DEFAULT_MAX_TEMPLATE_LENGTH = 100000;
+var MAX_CONFIGURABLE_TEMPLATE_LENGTH = 1000000;
+var DEFAULT_MAX_TOKENS = 1000;
+var MAX_CONFIGURABLE_TOKENS = 10000;
+function TemplateParser_validateLimit(value, name, defaultValue, maximum) {
+    if (void 0 === value) return defaultValue;
+    if (!Number.isSafeInteger(value) || value < 1 || value > maximum) throw new RangeError("".concat(name, " must be an integer between 1 and ").concat(maximum));
+    return value;
+}
 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);
+        null != options || (options = {});
+        this.maxTemplateLength = TemplateParser_validateLimit(options.maxTemplateLength, "maxTemplateLength", DEFAULT_MAX_TEMPLATE_LENGTH, MAX_CONFIGURABLE_TEMPLATE_LENGTH);
+        this.maxTokens = TemplateParser_validateLimit(options.maxTokens, "maxTokens", DEFAULT_MAX_TOKENS, MAX_CONFIGURABLE_TOKENS);
+        if (void 0 !== options.expressionStart && ("string" != typeof options.expressionStart || 0 === options.expressionStart.length || options.expressionStart.length > 128)) throw new TypeError("expressionStart must be a non-empty string of at most 128 characters");
+        if (void 0 !== options.expressionEnd && ("string" != typeof options.expressionEnd || 0 === options.expressionEnd.length || options.expressionEnd.length > 128)) throw new TypeError("expressionEnd must be a non-empty string of at most 128 characters");
         this.exprStart = options.expressionStart || "{{";
         this.exprEnd = options.expressionEnd || "}}";
         this.startLen = this.exprStart.length;
@@ -873,13 +1247,20 @@ var TemplateParser_TemplateParser = /*#__PURE__*/ function() {
         {
             key: "parse",
             value: function(template) {
+                var _this = this;
                 if ("string" != typeof template) throw new TypeError("模板必须是字符串");
+                if (template.length > this.maxTemplateLength) throw new RangeError("Template exceeds the maximum length of ".concat(this.maxTemplateLength, " characters"));
                 var tokens = [];
+                var pushToken = function(token) {
+                    if (tokens.length >= _this.maxTokens) throw new RangeError("Template exceeds the maximum token count of ".concat(_this.maxTokens));
+                    tokens.push(token);
+                };
                 var length = template.length;
                 var state = "TEXT";
                 var buffer = "";
                 var exprStartPos = 0;
                 var pos = 0;
+                var prevExprChar = "";
                 while(pos < length){
                     var char = template[pos];
                     var nextChar = template[pos + 1];
@@ -887,7 +1268,7 @@ var TemplateParser_TemplateParser = /*#__PURE__*/ function() {
                         case "TEXT":
                             if (this._isMatch(pos, template, this.exprStart)) {
                                 if (buffer.length > 0) {
-                                    tokens.push({
+                                    pushToken({
                                         type: "text",
                                         value: buffer,
                                         start: pos - buffer.length,
@@ -897,6 +1278,7 @@ var TemplateParser_TemplateParser = /*#__PURE__*/ function() {
                                 }
                                 state = "EXPR";
                                 exprStartPos = pos;
+                                prevExprChar = "";
                                 pos += this.startLen;
                                 continue;
                             }
@@ -906,10 +1288,11 @@ var TemplateParser_TemplateParser = /*#__PURE__*/ function() {
                             if ("'" === char) state = "STRING_SQ";
                             else if ('"' === char) state = "STRING_DQ";
                             else if ("`" === char) state = "TEMPLATE";
+                            else if ("/" === char && this._isRegexPosition(prevExprChar)) state = "REGEX";
                             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({
+                                if (exprValue.length > 0) pushToken({
                                     type: "expression",
                                     value: exprValue,
                                     start: exprStartPos,
@@ -922,6 +1305,7 @@ var TemplateParser_TemplateParser = /*#__PURE__*/ function() {
                                 pos += this.endLen;
                                 continue;
                             }
+                            if (!RegExp("\\s", "u").test(char)) prevExprChar = char;
                             buffer += char;
                             break;
                         case "STRING_SQ":
@@ -939,6 +1323,17 @@ var TemplateParser_TemplateParser = /*#__PURE__*/ function() {
                             else if ("`" === char) state = "EXPR";
                             buffer += char;
                             break;
+                        case "REGEX":
+                            if ("\\" === char) state = "ESCAPE_REGEX";
+                            else if ("[" === char) state = "REGEX_CLASS";
+                            else if ("/" === char) state = "EXPR";
+                            buffer += char;
+                            break;
+                        case "REGEX_CLASS":
+                            if ("\\" === char) state = "ESCAPE_REGEX";
+                            else if ("]" === char) state = "REGEX";
+                            buffer += char;
+                            break;
                         case "ESCAPE_SQ":
                             buffer += char;
                             state = "STRING_SQ";
@@ -951,6 +1346,10 @@ var TemplateParser_TemplateParser = /*#__PURE__*/ function() {
                             buffer += char;
                             state = "TEMPLATE";
                             break;
+                        case "ESCAPE_REGEX":
+                            buffer += char;
+                            state = "REGEX";
+                            break;
                         case "ESCAPE_EXPR":
                             buffer += char;
                             state = "EXPR";
@@ -958,7 +1357,7 @@ var TemplateParser_TemplateParser = /*#__PURE__*/ function() {
                     }
                     pos++;
                 }
-                if (buffer.length > 0) if ("TEXT" === state) tokens.push({
+                if (buffer.length > 0) if ("TEXT" === state) pushToken({
                     type: "text",
                     value: buffer,
                     start: pos - buffer.length,
@@ -966,17 +1365,22 @@ var TemplateParser_TemplateParser = /*#__PURE__*/ function() {
                 });
                 else {
                     var incompleteExpr = this.exprStart + buffer;
-                    tokens.push({
+                    pushToken({
                         type: "text",
                         value: incompleteExpr,
                         start: exprStartPos,
                         end: pos
                     });
-                    console.warn("警告：在位置 ".concat(exprStartPos, " 开始的表达式未正确结束"));
                 }
                 return tokens;
             }
         },
+        {
+            key: "_isRegexPosition",
+            value: function(prev) {
+                return "" === prev || "(,=:[!&|?{};+-*%^~<>".includes(prev);
+            }
+        },
         {
             key: "_isMatch",
             value: function(pos, template, sequence) {
@@ -1000,18 +1404,36 @@ function src_instanceof(left, right) {
     if (null != right && "undefined" != typeof Symbol && right[Symbol.hasInstance]) return !!right[Symbol.hasInstance](left);
     return left instanceof right;
 }
+var DEFAULT_MAX_TEMPLATE_EXPRESSIONS = 100;
+var MAX_TEMPLATE_EXPRESSIONS = 1000;
+var DEFAULT_MAX_TEMPLATE_OUTPUT_LENGTH = 100000;
+var MAX_TEMPLATE_OUTPUT_LENGTH = 1000000;
+function src_validateLimit(value, name, defaultValue, maximum) {
+    if (void 0 === value) return defaultValue;
+    if (!Number.isSafeInteger(value) || value < 1 || value > maximum) throw new RangeError("".concat(name, " must be an integer between 1 and ").concat(maximum));
+    return value;
+}
 function evalExpression(expression, context) {
     return Evaluator_Evaluator.evaluate(expression, context);
 }
 function evalTemplate(template, context, templateParserOptions) {
+    var options = null != templateParserOptions ? templateParserOptions : {};
+    var maxExpressions = src_validateLimit(options.maxExpressions, "maxExpressions", DEFAULT_MAX_TEMPLATE_EXPRESSIONS, MAX_TEMPLATE_EXPRESSIONS);
+    var maxOutputLength = src_validateLimit(options.maxOutputLength, "maxOutputLength", DEFAULT_MAX_TEMPLATE_OUTPUT_LENGTH, MAX_TEMPLATE_OUTPUT_LENGTH);
+    var tokens = TemplateParser_TemplateParser.parse(template, options);
     var result = "";
+    var expressionCount = 0;
+    var evaluator = new Evaluator_Evaluator(context, {
+        maxInputLength: options.maxExpressionLength,
+        maxEvaluationSteps: options.maxEvaluationSteps
+    });
     var typeHandler = {
         text: function(token) {
             return token.value;
         },
         expression: function(token) {
             try {
-                return Evaluator_Evaluator.evaluate(token.value, context);
+                return evaluator.evaluate(token.value);
             } catch (error) {
                 if (src_instanceof(error, ReferenceError) && error.message.endsWith("is not defined")) return "undefined";
                 throw error;
@@ -1020,11 +1442,17 @@ function evalTemplate(template, context, templateParserOptions) {
     };
     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){
+        for(var _iterator = tokens[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
             var token = _step.value;
             var _typeHandler_token_type;
             var handler = null != (_typeHandler_token_type = typeHandler[token.type]) ? _typeHandler_token_type : typeHandler["text"];
-            result += handler(token);
+            if ("expression" === token.type) {
+                expressionCount++;
+                if (expressionCount > maxExpressions) throw new RangeError("Template exceeds the maximum expression count of ".concat(maxExpressions));
+            }
+            var chunk = String(handler(token));
+            if (result.length + chunk.length > maxOutputLength) throw new RangeError("Template output exceeds the maximum length of ".concat(maxOutputLength, " characters"));
+            result += chunk;
         }
     } catch (err) {
         _didIteratorError = true;