poe-code 13.0.2 → 13.0.4

package/packages/safe-js/dist/interp/methods/array.js

@@ -1,5 +1,5 @@
 import { createSandboxClosure, isSandboxClosure, isSandboxMap, isSandboxPromise, isSandboxSet } from "../values.js";
-import { assertCollectionMutable, enterCollectionCallback } from "../running-state.js";
+import { assertCollectionMutable, enterRunningState } from "../running-state.js";
 const activeArrayCallbacks = new WeakMap();
 const arrayMethodNames = new Set([
     "map",
@@ -76,7 +76,7 @@ export async function callArrayMethod(value, methodName, args, options, stack =
     if (isCallbackArrayMethod(methodName)) {
         let callbackState = activeArrayCallbacks.get(value);
         if (callbackState === undefined) {
-            callbackState = { depth: 0, leave: enterCollectionCallback(value) };
+            callbackState = { depth: 0, leave: enterRunningState(value) };
             activeArrayCallbacks.set(value, callbackState);
         }
         callbackState.depth += 1;
@@ -267,34 +267,57 @@ function getRequiredCallback(methodName, value) {
 async function mapArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     const result = new Array(length);
-    for (let index = 0; index < length; index += 1) {
-        if (!(index in value)) {
-            continue;
+    options.budget.setRetainedValues(result, () => [result]);
+    try {
+        for (let index = 0; index < length; index += 1) {
+            options.budget.visitNode();
+            if (!(index in value)) {
+                continue;
+            }
+            result[index] = await callArrayCallback(callback, value[index], index, value, options, stack, thisValue);
         }
-        result[index] = await callArrayCallback(callback, value[index], index, value, options, stack, thisValue);
+        return result;
+    }
+    finally {
+        options.budget.setRetainedValues(result, undefined);
     }
-    return result;
 }
 async function filterArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     const result = [];
-    for (let index = 0; index < length; index += 1) {
-        if (!(index in value)) {
-            continue;
-        }
-        if (await callArrayCallback(callback, value[index], index, value, options, stack, thisValue)) {
-            result.push(value[index]);
+    options.budget.setRetainedValues(result, () => [result]);
+    try {
+        for (let index = 0; index < length; index += 1) {
+            options.budget.visitNode();
+            if (!(index in value)) {
+                continue;
+            }
+            const entry = value[index];
+            if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
+                result.push(entry);
+            }
         }
+        return result;
+    }
+    finally {
+        options.budget.setRetainedValues(result, undefined);
     }
-    return result;
 }
 async function findInArray(value, callback, options, stack, thisValue) {
-    const index = await findIndexInArray(value, callback, options, stack, thisValue);
-    return index < 0 ? undefined : value[index];
+    const length = value.length;
+    for (let index = 0; index < length; index += 1) {
+        options.budget.visitNode();
+        const entry = index in value ? value[index] : undefined;
+        if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
+            return entry;
+        }
+    }
+    return undefined;
 }
 async function findIndexInArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = 0; index < length; index += 1) {
+        options.budget.visitNode();
         const entry = index in value ? value[index] : undefined;
         if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
             return index;
@@ -305,6 +328,7 @@ async function findIndexInArray(value, callback, options, stack, thisValue) {
 async function findLastInArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = length - 1; index >= 0; index -= 1) {
+        options.budget.visitNode();
         const entry = index in value ? value[index] : undefined;
         if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
             return entry;
@@ -315,6 +339,7 @@ async function findLastInArray(value, callback, options, stack, thisValue) {
 async function findLastIndexInArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = length - 1; index >= 0; index -= 1) {
+        options.budget.visitNode();
         const entry = index in value ? value[index] : undefined;
         if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
             return index;
@@ -325,6 +350,7 @@ async function findLastIndexInArray(value, callback, options, stack, thisValue)
 async function someInArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = 0; index < length; index += 1) {
+        options.budget.visitNode();
         if (!(index in value)) {
             continue;
         }
@@ -337,6 +363,7 @@ async function someInArray(value, callback, options, stack, thisValue) {
 async function everyInArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = 0; index < length; index += 1) {
+        options.budget.visitNode();
         if (!(index in value)) {
             continue;
         }
@@ -348,10 +375,10 @@ async function everyInArray(value, callback, options, stack, thisValue) {
 }
 async function reduceArray(value, callback, hasInitialValue, initialValue, options, stack) {
     const length = value.length;
-    const start = findNextDefinedIndex(value, 0, 1, length);
     if (hasInitialValue) {
-        return reduceFromLeft(value, callback, initialValue, start, length, options, stack);
+        return reduceFromLeft(value, callback, initialValue, 0, length, options, stack);
     }
+    const start = findNextDefinedIndex(value, 0, 1, length, options.budget);
     if (start < 0) {
         throw new TypeError("Reduce of empty array with no initial value.");
     }
@@ -359,10 +386,10 @@ async function reduceArray(value, callback, hasInitialValue, initialValue, optio
 }
 async function reduceRightArray(value, callback, hasInitialValue, initialValue, options, stack) {
     const length = value.length;
-    const start = findNextDefinedIndex(value, length - 1, -1, length);
     if (hasInitialValue) {
-        return reduceFromRight(value, callback, initialValue, start, length, options, stack);
+        return reduceFromRight(value, callback, initialValue, length - 1, length, options, stack);
     }
+    const start = findNextDefinedIndex(value, length - 1, -1, length, options.budget);
     if (start < 0) {
         throw new TypeError("Reduce of empty array with no initial value.");
     }
@@ -370,27 +397,44 @@ async function reduceRightArray(value, callback, hasInitialValue, initialValue,
 }
 async function reduceFromLeft(value, callback, accumulator, startIndex, length, options, stack) {
     let current = accumulator;
-    for (let index = startIndex; index < length; index += 1) {
-        if (!(index in value)) {
-            continue;
+    const retainedAccumulator = {};
+    options.budget.setRetainedValues(retainedAccumulator, () => [current]);
+    try {
+        for (let index = startIndex; index < length; index += 1) {
+            options.budget.visitNode();
+            if (!(index in value)) {
+                continue;
+            }
+            current = await options.callClosure(callback, [current, value[index], index, value], stack);
         }
-        current = await options.callClosure(callback, [current, value[index], index, value], stack);
+        return current;
+    }
+    finally {
+        options.budget.setRetainedValues(retainedAccumulator, undefined);
     }
-    return current;
 }
 async function reduceFromRight(value, callback, accumulator, startIndex, length, options, stack) {
     let current = accumulator;
-    for (let index = Math.min(startIndex, length - 1); index >= 0; index -= 1) {
-        if (!(index in value)) {
-            continue;
+    const retainedAccumulator = {};
+    options.budget.setRetainedValues(retainedAccumulator, () => [current]);
+    try {
+        for (let index = Math.min(startIndex, length - 1); index >= 0; index -= 1) {
+            options.budget.visitNode();
+            if (!(index in value)) {
+                continue;
+            }
+            current = await options.callClosure(callback, [current, value[index], index, value], stack);
         }
-        current = await options.callClosure(callback, [current, value[index], index, value], stack);
+        return current;
+    }
+    finally {
+        options.budget.setRetainedValues(retainedAccumulator, undefined);
     }
-    return current;
 }
 async function forEachArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = 0; index < length; index += 1) {
+        options.budget.visitNode();
         if (!(index in value)) {
             continue;
         }
@@ -400,25 +444,33 @@ async function forEachArray(value, callback, options, stack, thisValue) {
 async function flatMapArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     const result = [];
-    for (let index = 0; index < length; index += 1) {
-        if (!(index in value)) {
-            continue;
-        }
-        const mapped = await callArrayCallback(callback, value[index], index, value, options, stack, thisValue);
-        if (Array.isArray(mapped)) {
-            for (let mappedIndex = 0; mappedIndex < mapped.length; mappedIndex += 1) {
-                if (!(mappedIndex in mapped)) {
-                    continue;
+    options.budget.setRetainedValues(result, () => [result]);
+    try {
+        for (let index = 0; index < length; index += 1) {
+            options.budget.visitNode();
+            if (!(index in value)) {
+                continue;
+            }
+            const mapped = await callArrayCallback(callback, value[index], index, value, options, stack, thisValue);
+            if (Array.isArray(mapped)) {
+                for (let mappedIndex = 0; mappedIndex < mapped.length; mappedIndex += 1) {
+                    options.budget.visitNode();
+                    if (!(mappedIndex in mapped)) {
+                        continue;
+                    }
+                    result.push(mapped[mappedIndex]);
+                    options.budget.allocateArrayLength(result.length);
                 }
-                result.push(mapped[mappedIndex]);
-                options.budget.allocateArrayLength(result.length);
+                continue;
             }
-            continue;
+            result.push(mapped);
+            options.budget.allocateArrayLength(result.length);
         }
-        result.push(mapped);
-        options.budget.allocateArrayLength(result.length);
+        return result;
+    }
+    finally {
+        options.budget.setRetainedValues(result, undefined);
     }
-    return result;
 }
 function flattenArray(value, depth, budget) {
     const result = [];
@@ -440,48 +492,61 @@ function appendFlattenedEntries(value, depth, result, budget) {
     }
 }
 async function sortArray(value, comparator, options, stack) {
+    const length = value.length;
     const definedValues = [];
     let undefinedCount = 0;
-    for (let index = 0; index < value.length; index += 1) {
-        if (!(index in value)) {
-            continue;
+    let currentEntry;
+    options.budget.setRetainedValues(definedValues, () => [definedValues, currentEntry]);
+    try {
+        for (let index = 0; index < length; index += 1) {
+            options.budget.visitNode();
+            if (!(index in value)) {
+                continue;
+            }
+            const entry = value[index];
+            if (entry === undefined) {
+                undefinedCount += 1;
+                continue;
+            }
+            definedValues.push(entry);
+        }
+        for (let index = 1; index < definedValues.length; index += 1) {
+            currentEntry = definedValues[index];
+            let cursor = index - 1;
+            while (cursor >= 0 &&
+                (await compareEntries(definedValues[cursor], currentEntry, comparator, options, stack)) > 0) {
+                definedValues[cursor + 1] = definedValues[cursor];
+                cursor -= 1;
+            }
+            definedValues[cursor + 1] = currentEntry;
         }
-        const entry = value[index];
-        if (entry === undefined) {
-            undefinedCount += 1;
-            continue;
+        currentEntry = undefined;
+        for (let index = 0; index < definedValues.length; index += 1) {
+            value[index] = definedValues[index];
         }
-        definedValues.push(entry);
-    }
-    for (let index = 1; index < definedValues.length; index += 1) {
-        const entry = definedValues[index];
-        let cursor = index - 1;
-        while (cursor >= 0 &&
-            (await compareEntries(definedValues[cursor], entry, comparator, options, stack)) > 0) {
-            definedValues[cursor + 1] = definedValues[cursor];
-            cursor -= 1;
+        for (let index = 0; index < undefinedCount; index += 1) {
+            value[definedValues.length + index] = undefined;
+        }
+        for (let index = definedValues.length + undefinedCount; index < length; index += 1) {
+            options.budget.visitNode();
+            delete value[index];
         }
-        definedValues[cursor + 1] = entry;
-    }
-    for (let index = 0; index < definedValues.length; index += 1) {
-        value[index] = definedValues[index];
-    }
-    for (let index = 0; index < undefinedCount; index += 1) {
-        value[definedValues.length + index] = undefined;
     }
-    for (let index = definedValues.length + undefinedCount; index < value.length; index += 1) {
-        delete value[index];
+    finally {
+        options.budget.setRetainedValues(definedValues, undefined);
     }
 }
 async function compareEntries(left, right, comparator, options, stack) {
+    options.budget.visitNode();
     const result = Number(await options.callClosure(comparator, [left, right], stack));
     return Number.isNaN(result) ? 0 : result;
 }
 async function callArrayCallback(callback, value, index, array, options, stack, thisValue) {
     return options.callClosure(callback, [value, index, array], stack, thisValue);
 }
-function findNextDefinedIndex(value, startIndex, direction, length) {
+function findNextDefinedIndex(value, startIndex, direction, length, budget) {
     for (let index = startIndex; direction > 0 ? index < length : index >= 0; index += direction) {
+        budget.visitNode();
         if (index in value) {
             return index;
         }

package/packages/safe-js/dist/interp/methods/string.d.ts

@@ -1,9 +1,10 @@
 import type { Expression } from "../../parse.js";
 import { Budget } from "../budget.js";
+import { CompileScope } from "../regex/compile-guard.js";
 import { type SandboxClosure, type SandboxValue } from "../values.js";
 type StringMethodName = "at" | "charAt" | "charCodeAt" | "codePointAt" | "concat" | "endsWith" | "includes" | "indexOf" | "lastIndexOf" | "localeCompare" | "match" | "matchAll" | "normalize" | "padEnd" | "padStart" | "repeat" | "replace" | "replaceAll" | "slice" | "search" | "split" | "startsWith" | "substr" | "substring" | "toLowerCase" | "toUpperCase" | "trim" | "trimEnd" | "trimStart";
 export declare function getStringMember(value: string, property: string | number, budget: Budget): SandboxValue | undefined;
 export declare function isStringMethodName(property: string | number): property is StringMethodName;
 export declare function validateStringMethodArguments(_methodName: StringMethodName, _args: readonly Expression[]): void;
-export declare function callStringMethod(value: string, methodName: StringMethodName, args: readonly SandboxValue[], budget: Budget, callClosure?: (closure: SandboxClosure, args: readonly SandboxValue[]) => Promise<SandboxValue>): SandboxValue | Promise<SandboxValue>;
+export declare function callStringMethod(value: string, methodName: StringMethodName, args: readonly SandboxValue[], budget: Budget, callClosure?: (closure: SandboxClosure, args: readonly SandboxValue[]) => Promise<SandboxValue>, parent?: CompileScope): SandboxValue | Promise<SandboxValue>;
 export {};

package/packages/safe-js/dist/interp/methods/string.js

@@ -1,3 +1,4 @@
+import { CompileScope } from "../regex/compile-guard.js";
 import { createSandboxClosure, createSandboxRegex, deepCopyFromSandbox, isSandboxClosure, isSandboxRegex } from "../values.js";
 import { executeRegex, toMatchArray } from "./regex.js";
 const SPLIT_STRING_MESSAGE = "String#split only supports string separator values.";
@@ -47,7 +48,9 @@ export function getStringMember(value, property, budget) {
         sandbox: true,
         name: `String#${property}`,
         ...(property === "localeCompare" ? { length: 1 } : {}),
-        call: (args) => callStringMethod(value, property, args, budget)
+        call: (args, context) => callStringMethod(value, property, args, budget, context === undefined
+            ? undefined
+            : async (closure, closureArgs) => await closure.call(closureArgs, { ...context, thisValue: undefined }), context?.compilation)
     });
 }
 function getStringIndex(property) {
@@ -61,106 +64,114 @@ export function isStringMethodName(property) {
     return typeof property === "string" && stringMethodNames.has(property);
 }
 export function validateStringMethodArguments(_methodName, _args) { }
-export function callStringMethod(value, methodName, args, budget, callClosure = async (closure, closureArgs) => await closure.call(closureArgs)) {
+export function callStringMethod(value, methodName, args, budget, callClosure = async (closure, closureArgs) => await closure.call(closureArgs), parent) {
     if (methodName === "replace" || methodName === "replaceAll") {
         return callReplaceLikeMethod(value, methodName, args, budget, callClosure);
     }
-    if (methodName === "split") {
-        return callSplit(value, args, budget);
-    }
-    if (methodName === "match" || methodName === "matchAll" || methodName === "search") {
-        return callMatchLikeMethod(value, methodName, args);
-    }
-    if (methodName === "localeCompare") {
-        if (isSandboxClosure(args[0])) {
-            throw new TypeError("String#localeCompare does not support function comparison values.");
+    const operation = budget.acquireCompileOwner(false, parent?.owner);
+    const compilation = new CompileScope(operation.owner);
+    try {
+        if (methodName === "split") {
+            return callSplit(value, args, budget, compilation);
         }
-        const comparison = budget.allocateString(String(deepCopyFromSandbox(args[0])));
-        const locales = Reflect.apply(Intl.getCanonicalLocales, Intl, [
-            deepCopyFromSandbox(args[1])
-        ]);
-        const options = args[2];
-        const nativeOptions = options === undefined || options === null
-            ? options
-            : Object.fromEntries([
-                "usage",
-                "localeMatcher",
-                "collation",
-                "numeric",
-                "caseFirst",
-                "sensitivity",
-                "ignorePunctuation"
-            ].map((property) => {
-                const descriptor = Object.getOwnPropertyDescriptor(options, property);
-                if (descriptor !== undefined && !("value" in descriptor)) {
-                    throw new TypeError("String#localeCompare only supports data option properties.");
-                }
-                const option = descriptor?.value;
-                return [
-                    property,
-                    option === undefined
-                        ? undefined
-                        : property === "numeric" || property === "ignorePunctuation"
-                            ? Boolean(option)
-                            : deepCopyFromSandbox(option)
-                ];
-            }));
-        return Reflect.apply(String.prototype.localeCompare, value, [
-            comparison,
-            locales,
-            nativeOptions
-        ]);
-    }
-    if (args.some(isSandboxClosure)) {
-        throw new TypeError(`String#${methodName} does not support function arguments.`);
-    }
-    switch (methodName) {
-        case "at": {
-            const result = value.at(asNumber(args[0]));
-            return result === undefined ? undefined : budget.allocateString(result);
+        if (methodName === "match" || methodName === "matchAll" || methodName === "search") {
+            return callMatchLikeMethod(value, methodName, args, compilation);
         }
-        case "charAt":
-            return budget.allocateString(value.charAt(asNumber(args[0])));
-        case "charCodeAt":
-            return value.charCodeAt(asNumber(args[0]));
-        case "codePointAt":
-            return value.codePointAt(asNumber(args[0]));
-        case "concat":
-            return budget.allocateString(value.concat(...args.map(String)));
-        case "endsWith":
-            return value.endsWith(String(args[0]), asNumberOrUndefined(args[1]));
-        case "includes":
-            return value.includes(String(args[0]), asNumberOrUndefined(args[1]));
-        case "indexOf":
-            return value.indexOf(String(args[0]), asNumberOrUndefined(args[1]));
-        case "lastIndexOf":
-            return value.lastIndexOf(String(args[0]), asNumberOrUndefined(args[1]));
-        case "normalize":
-            return budget.allocateString(value.normalize(asStringOrUndefined(args[0])));
-        case "padEnd":
-            return budget.allocateString(value.padEnd(asNumber(args[0]), asStringOrUndefined(args[1])));
-        case "padStart":
-            return budget.allocateString(value.padStart(asNumber(args[0]), asStringOrUndefined(args[1])));
-        case "repeat":
-            return budget.allocateString(value.repeat(asNumber(args[0])));
-        case "slice":
-            return budget.allocateString(value.slice(asNumberOrUndefined(args[0]), asNumberOrUndefined(args[1])));
-        case "startsWith":
-            return value.startsWith(String(args[0]), asNumberOrUndefined(args[1]));
-        case "substr":
-            return budget.allocateString(value.substr(asNumber(args[0]), asNumberOrUndefined(args[1])));
-        case "substring":
-            return budget.allocateString(value.substring(asNumber(args[0]), asNumberOrUndefined(args[1])));
-        case "toLowerCase":
-            return budget.allocateString(value.toLowerCase());
-        case "toUpperCase":
-            return budget.allocateString(value.toUpperCase());
-        case "trim":
-            return budget.allocateString(value.trim());
-        case "trimEnd":
-            return budget.allocateString(value.trimEnd());
-        case "trimStart":
-            return budget.allocateString(value.trimStart());
+        if (methodName === "localeCompare") {
+            if (isSandboxClosure(args[0])) {
+                throw new TypeError("String#localeCompare does not support function comparison values.");
+            }
+            const comparison = budget.allocateString(String(deepCopyFromSandbox(args[0], { compilation })));
+            const locales = Reflect.apply(Intl.getCanonicalLocales, Intl, [
+                deepCopyFromSandbox(args[1], { compilation })
+            ]);
+            const options = args[2];
+            const nativeOptions = options === undefined || options === null
+                ? options
+                : Object.fromEntries([
+                    "usage",
+                    "localeMatcher",
+                    "collation",
+                    "numeric",
+                    "caseFirst",
+                    "sensitivity",
+                    "ignorePunctuation"
+                ].map((property) => {
+                    const descriptor = Object.getOwnPropertyDescriptor(options, property);
+                    if (descriptor !== undefined && !("value" in descriptor)) {
+                        throw new TypeError("String#localeCompare only supports data option properties.");
+                    }
+                    const option = descriptor?.value;
+                    return [
+                        property,
+                        option === undefined
+                            ? undefined
+                            : property === "numeric" || property === "ignorePunctuation"
+                                ? Boolean(option)
+                                : deepCopyFromSandbox(option, { compilation })
+                    ];
+                }));
+            return Reflect.apply(String.prototype.localeCompare, value, [
+                comparison,
+                locales,
+                nativeOptions
+            ]);
+        }
+        if (args.some(isSandboxClosure)) {
+            throw new TypeError(`String#${methodName} does not support function arguments.`);
+        }
+        switch (methodName) {
+            case "at": {
+                const result = value.at(asNumber(args[0]));
+                return result === undefined ? undefined : budget.allocateString(result);
+            }
+            case "charAt":
+                return budget.allocateString(value.charAt(asNumber(args[0])));
+            case "charCodeAt":
+                return value.charCodeAt(asNumber(args[0]));
+            case "codePointAt":
+                return value.codePointAt(asNumber(args[0]));
+            case "concat":
+                return budget.allocateString(value.concat(...args.map(String)));
+            case "endsWith":
+                return value.endsWith(String(args[0]), asNumberOrUndefined(args[1]));
+            case "includes":
+                return value.includes(String(args[0]), asNumberOrUndefined(args[1]));
+            case "indexOf":
+                return value.indexOf(String(args[0]), asNumberOrUndefined(args[1]));
+            case "lastIndexOf":
+                return value.lastIndexOf(String(args[0]), asNumberOrUndefined(args[1]));
+            case "normalize":
+                return budget.allocateString(value.normalize(asStringOrUndefined(args[0])));
+            case "padEnd":
+                return budget.allocateString(value.padEnd(asNumber(args[0]), asStringOrUndefined(args[1])));
+            case "padStart":
+                return budget.allocateString(value.padStart(asNumber(args[0]), asStringOrUndefined(args[1])));
+            case "repeat":
+                return budget.allocateString(value.repeat(asNumber(args[0])));
+            case "slice":
+                return budget.allocateString(value.slice(asNumberOrUndefined(args[0]), asNumberOrUndefined(args[1])));
+            case "startsWith":
+                return value.startsWith(String(args[0]), asNumberOrUndefined(args[1]));
+            case "substr":
+                return budget.allocateString(value.substr(asNumber(args[0]), asNumberOrUndefined(args[1])));
+            case "substring":
+                return budget.allocateString(value.substring(asNumber(args[0]), asNumberOrUndefined(args[1])));
+            case "toLowerCase":
+                return budget.allocateString(value.toLowerCase());
+            case "toUpperCase":
+                return budget.allocateString(value.toUpperCase());
+            case "trim":
+                return budget.allocateString(value.trim());
+            case "trimEnd":
+                return budget.allocateString(value.trimEnd());
+            case "trimStart":
+                return budget.allocateString(value.trimStart());
+        }
+    }
+    finally {
+        compilation.dispose();
+        operation.release();
     }
 }
 function callReplaceLikeMethod(value, methodName, args, budget, callClosure) {
@@ -276,12 +287,12 @@ function findReplacementOffsets(value, searchValue, replaceAll) {
     }
     return offsets;
 }
-function callSplit(value, args, budget) {
+function callSplit(value, args, budget, compilation) {
     if (args.some(isSandboxClosure))
         throw new TypeError("String#split does not support function arguments.");
     if (isSandboxRegex(args[0])) {
         const regex = args[0];
-        const splitter = createSandboxRegex(regex.source, regex.flags.includes("g") ? regex.flags : `${regex.flags}g`);
+        const splitter = createSandboxRegex(regex.source, regex.flags.includes("g") ? regex.flags : `${regex.flags}g`, 0, compilation);
         const limit = asNumberOrUndefined(args[1]) ?? 2 ** 32 - 1;
         const result = [];
         let copiedThrough = 0;
@@ -313,7 +324,7 @@ function callSplit(value, args, budget) {
     budget.allocateArrayLength(result.length);
     return result;
 }
-function callMatchLikeMethod(value, methodName, args) {
+function callMatchLikeMethod(value, methodName, args, compilation) {
     const regex = args[0];
     if (!isSandboxRegex(regex))
         throw new TypeError(`String#${methodName} requires a regex argument.`);
@@ -331,7 +342,7 @@ function callMatchLikeMethod(value, methodName, args) {
     if (methodName === "match")
         regex.lastIndex = 0;
     const matcher = methodName === "matchAll"
-        ? createSandboxRegex(regex.source, regex.flags, regex.lastIndex)
+        ? createSandboxRegex(regex.source, regex.flags, regex.lastIndex, compilation)
         : regex;
     const matches = collectRegexMatches(matcher, value, true);
     if (methodName === "match" && matches.length === 0)

package/packages/safe-js/dist/interp/regex/compile-guard.d.ts

@@ -0,0 +1,33 @@
+import { type CompileOwner, type CompileTicket } from "../budget.js";
+import type { RegexPattern } from "./parse.js";
+export declare class CompileScope {
+    readonly owner?: CompileOwner | undefined;
+    readonly parent?: CompileScope | undefined;
+    readonly tickets: Set<CompileTicket>;
+    closed: boolean;
+    constructor(owner?: CompileOwner | undefined, parent?: CompileScope | undefined);
+    forward(tickets: Iterable<CompileTicket>, parent: CompileScope): void;
+    dispose(): void;
+}
+export declare class RegexCompileGuard {
+    private readonly scope?;
+    private allocations;
+    private depth;
+    private readonly ticket?;
+    private retained;
+    constructor(scope?: CompileScope | undefined);
+    checkLength(length: number, flags?: boolean): void;
+    work(units: number): void;
+    allocate(units: number): void;
+    array(length: number): void;
+    enterGroup(): void;
+    leaveGroup(): void;
+    preflight(source: string, flags: string): void;
+    retain(pattern: RegexPattern, valueUnits?: number): void;
+    retainScratch(): void;
+    close(): void;
+}
+export declare function regexCompiledData(pattern: RegexPattern): {
+    units: number;
+    ticket?: CompileTicket;
+};