poe-code 14.0.74 → 14.0.76

package/packages/safe-js/dist/interp/globals/regex.js

@@ -1,12 +1,17 @@
-import { createSandboxClosure, createSandboxRegex, isSandboxRegex, reconcileCompiledValues } from "../values.js";
+import { createSandboxClosure, createSandboxRegex, isSandboxClosure, isSandboxRegex, reconcileCompiledValues } from "../values.js";
 import { CompileScope } from "../regex/compile-guard.js";
 import { SandboxError } from "../budget.js";
-import { sandboxString } from "../string-coercion.js";
+import { sandboxNumber, sandboxString } from "../string-coercion.js";
 import { getSandboxPropertyDescriptor, installRegexPrototype, materializeFunctionProperties, setSandboxPrototype } from "../object-model.js";
 import { accessorAdapter, readPropertyDescriptor } from "../accessors.js";
 import { callRegexMethod, getRegexMember, regexFlagProperties, regexSearch } from "../methods/regex.js";
 import { regexMatch, regexReplace } from "../methods/string.js";
 import { invokeBuiltinClosure } from "../builtin-call.js";
+import { restoreSandboxRegExpIterator } from "../regexp-iterator.js";
+import { normalizeLastIndex } from "../regex/engine.js";
+import { retainValues } from "../resources.js";
+import { setSandboxProperty } from "../interpreter.js";
+import { regexSplit } from "../methods/regex-split.js";
 export function createRegexGlobals(options) {
     const invoke = (construct) => async (args, context) => {
         const selected = options.compileOwner ?? context?.compilation?.owner;
@@ -75,7 +80,52 @@ export function createRegexGlobals(options) {
         }
     };
     const constructor = createSandboxClosure({ guest: true, sandbox: true, name: "RegExp", length: 2, call: invoke(false), construct: invoke(true) });
+    Object.defineProperty(materializeFunctionProperties(constructor), "escape", {
+        value: createSandboxClosure({ guest: true, sandbox: true, name: "escape", length: 1,
+            call: (args) => {
+                const input = args[0];
+                if (typeof input !== "string")
+                    throw new TypeError("RegExp.escape requires a string.");
+                const allocation = {};
+                let escaped = "";
+                try {
+                    for (const character of input) {
+                        options.budget.visitNode();
+                        const point = character.codePointAt(0);
+                        let part = character;
+                        if (escaped.length === 0 && ((point >= 48 && point <= 57) ||
+                            (point >= 65 && point <= 90) || (point >= 97 && point <= 122))) {
+                            part = `\\x${point.toString(16)}`;
+                        }
+                        else if ("^$\\.*+?()[]{}|/".includes(character)) {
+                            part = "\\" + character;
+                        }
+                        else {
+                            const control = "\f\n\r\t\v".indexOf(character);
+                            if (control !== -1)
+                                part = "\\" + "fnrtv"[control];
+                            else if (",-=<>#&!%:;@~'`\"".includes(character) || character.trim() === "" ||
+                                (point >= 0xd800 && point <= 0xdfff)) {
+                                part = point <= 0xff ? `\\x${point.toString(16).padStart(2, "0")}`
+                                    : `\\u${point.toString(16).padStart(4, "0")}`;
+                            }
+                        }
+                        options.budget.setRetainedDataUsage(allocation, escaped.length + part.length);
+                        escaped = options.budget.allocateString(escaped + part);
+                    }
+                    return escaped;
+                }
+                finally {
+                    options.budget.setRetainedDataUsage(allocation, 0);
+                }
+            }
+        }), writable: true, configurable: true
+    });
     const prototype = Object.create(null);
+    Object.defineProperty(materializeFunctionProperties(constructor), Symbol.species, {
+        get: accessorAdapter(createSandboxClosure({ sandbox: true, name: "get [Symbol.species]", length: 0,
+            call: (_args, context) => context?.thisValue }), "get"), configurable: true
+    });
     Object.defineProperty(materializeFunctionProperties(constructor), "prototype", { value: prototype, writable: false });
     Object.defineProperty(prototype, "constructor", { value: constructor, writable: true, configurable: true });
     Object.defineProperty(prototype, Symbol.search, {
@@ -93,6 +143,62 @@ export function createRegexGlobals(options) {
             call: (args, context) => regexReplace(args[0], context?.thisValue, args[1], options.budget, (closure, values) => invokeBuiltinClosure(closure, values, options.budget, context, undefined), context) }),
         writable: true, configurable: true
     });
+    Object.defineProperty(prototype, Symbol.matchAll, {
+        value: createSandboxClosure({ guest: true, sandbox: true, name: "[Symbol.matchAll]", length: 1,
+            call: async (args, context) => {
+                const target = context?.thisValue;
+                if (target === null || typeof target !== "object")
+                    throw new TypeError("RegExp matchAll requires an object receiver.");
+                let input = args[0];
+                let string;
+                let species;
+                let field;
+                let flags;
+                let matcher;
+                const release = retainValues(options.budget, () => [target, input, string, species, field, flags, matcher]);
+                const read = (value, key) => {
+                    if (context?.getProperty !== undefined)
+                        return context.getProperty(value, key);
+                    const descriptor = getSandboxPropertyDescriptor(value, key, options.budget);
+                    return descriptor === undefined ? undefined : readPropertyDescriptor(descriptor, value, context);
+                };
+                try {
+                    string = await sandboxString(input, options.budget, context);
+                    input = undefined;
+                    field = await read(target, "constructor");
+                    species = constructor;
+                    if (field !== undefined) {
+                        if (field === null || typeof field !== "object")
+                            throw new TypeError("Invalid RegExp species constructor.");
+                        species = await read(field, Symbol.species);
+                        if (species === null || species === undefined)
+                            species = constructor;
+                    }
+                    field = undefined;
+                    if (!isSandboxClosure(species) || species.construct === undefined)
+                        throw new TypeError("RegExp species must be a constructor.");
+                    field = await read(target, "flags");
+                    flags = await sandboxString(field, options.budget, context);
+                    field = undefined;
+                    matcher = await invokeBuiltinClosure(species, [target, flags], options.budget, context, undefined, true);
+                    field = await read(target, "lastIndex");
+                    const cursor = normalizeLastIndex(await sandboxNumber(field, options.budget, context));
+                    field = undefined;
+                    await setSandboxProperty(matcher, "lastIndex", cursor, options.budget, true, context);
+                    return restoreSandboxRegExpIterator({ matcher, input: string, exhausted: false,
+                        global: flags.includes("g"), unicode: flags.includes("u") || flags.includes("v") });
+                }
+                finally {
+                    release();
+                }
+            } }),
+        writable: true, configurable: true
+    });
+    Object.defineProperty(prototype, Symbol.split, {
+        value: createSandboxClosure({ guest: true, sandbox: true, name: "[Symbol.split]", length: 2,
+            call: (args, context) => regexSplit(context?.thisValue, args[0], args[1], constructor, options.budget, context) }),
+        writable: true, configurable: true
+    });
     for (const name of ["exec", "test", "toString"]) {
         Object.defineProperty(prototype, name, {
             value: createSandboxClosure({ sandbox: true, name, length: name === "toString" ? 0 : 1,

package/packages/safe-js/dist/interp/globals.d.ts

@@ -28,6 +28,7 @@ export declare function createBuiltinBindings(options: Parameters<typeof createC
     Float32Array: import("./values.js").SandboxClosure;
     Date: import("./values.js").SandboxClosure;
     Symbol: import("./values.js").SandboxClosure;
+    BigInt: import("./values.js").SandboxClosure;
     Map: import("./values.js").SandboxClosure;
     Set: import("./values.js").SandboxClosure;
     JSON: import("./values.js").SandboxObject;

package/packages/safe-js/dist/interp/globals.js

@@ -9,6 +9,7 @@ import { createObjectArrayGlobals } from "./globals/object-array.js";
 import { createPromiseGlobals } from "./promise.js";
 import { createDateGlobal } from "./globals/date.js";
 import { createSymbolGlobal } from "./globals/symbol.js";
+import { createBigIntGlobal } from "./globals/bigint.js";
 export function createBuiltinBindings(options) {
     return {
         ...createConsoleJsonGlobals(options),
@@ -16,6 +17,7 @@ export function createBuiltinBindings(options) {
         Float32Array: createFloat32ArrayGlobal(options.budget),
         Date: createDateGlobal(options),
         Symbol: createSymbolGlobal(options.budget),
+        BigInt: createBigIntGlobal(options.budget),
         ...createErrorGlobals(options),
         ...createMathGlobals({ random: options.random }),
         ...createObjectArrayGlobals(options),

package/packages/safe-js/dist/interp/host-bridge.js

@@ -561,6 +561,7 @@ function isSandboxLikeValue(value) {
         value === undefined ||
         typeof value === "string" ||
         typeof value === "number" ||
+        typeof value === "bigint" ||
         typeof value === "boolean") {
         return true;
     }
@@ -628,6 +629,7 @@ export function copyHostValueToSandbox(value, stackFrames, options, state, path)
     if (value === null ||
         value === undefined ||
         typeof value === "number" ||
+        typeof value === "bigint" ||
         typeof value === "boolean") {
         return value;
     }

package/packages/safe-js/dist/interp/interpreter.js

@@ -1,4 +1,5 @@
 import { promiseReplayContext } from "./promise-replay.js";
+import { bigIntOperation } from "./bigint-operators.js";
 import { accessorAdapter, readPropertyDescriptor, writePropertyDescriptor } from "./accessors.js";
 import { deleteHostObjectMember, getHostObjectKeys, getHostObjectMember, hasHostObjectMember, isGuestHostObject, setHostObjectMember } from "./host-capabilities.js";
 import { propertyFunctionName, toPropertyKey } from "./property-key.js";
@@ -51,6 +52,17 @@ const dispatchTable = {
     ArrowFunctionExpression: evaluateArrowFunction,
     AwaitExpression: evaluateAwait,
     BinaryExpression: evaluateBinaryExpression,
+    BigIntLiteral: async (node, context) => {
+        const allocation = {};
+        context.budget.visitNode(node.value.length);
+        context.budget.setRetainedDataUsage(allocation, node.value.length);
+        try {
+            return { kind: "normal", hasValue: true, value: BigInt(node.value) };
+        }
+        finally {
+            context.budget.setRetainedDataUsage(allocation, 0);
+        }
+    },
     BlockStatement: evaluateBlockStatement,
     BooleanLiteral: evaluatePrimitiveLiteral,
     CallExpression: evaluateCallExpression,
@@ -1805,8 +1817,11 @@ async function evaluateIdentifierUpdateExpression(node, context) {
             error: createError("UNBOUND_IDENTIFIER", node.argument, `Identifier '${node.argument.name}' is not defined.`)
         };
     }
-    const current = toNumber(await toNumericPrimitive(binding.value, context));
-    const next = node.operator === "++" ? current + 1 : current - 1;
+    const primitive = await toNumericPrimitive(binding.value, context);
+    const current = typeof primitive === "bigint" ? primitive : toNumber(primitive);
+    const next = typeof current === "bigint"
+        ? bigIntOperation(node.operator === "++" ? "+" : "-", current, 1n, context.budget)
+        : node.operator === "++" ? current + 1 : current - 1;
     context.scope.assign(node.argument.name, next);
     return {
         kind: "normal",
@@ -1823,8 +1838,11 @@ async function evaluateMemberUpdateExpression(node, context) {
             throw new TypeError("Cannot update properties of null or undefined.");
         }
         const property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
-        const current = toNumber(await toNumericPrimitive(await getPropertyValue(member.object, property, context, member.superReceiver === undefined ? member.object : member.superReceiver.value), context));
-        const next = node.operator === "++" ? current + 1 : current - 1;
+        const primitive = await toNumericPrimitive(await getPropertyValue(member.object, property, context, member.superReceiver === undefined ? member.object : member.superReceiver.value), context);
+        const current = typeof primitive === "bigint" ? primitive : toNumber(primitive);
+        const next = typeof current === "bigint"
+            ? bigIntOperation(node.operator === "++" ? "+" : "-", current, 1n, context.budget)
+            : node.operator === "++" ? current + 1 : current - 1;
         if (member.superReceiver === undefined)
             await setSandboxProperty(member.object, property, next, context.budget, true, createCoercionContext(context));
         else
@@ -1858,7 +1876,7 @@ function getPropertyValue(target, property, context, receiver = target) {
         return readPropertyDescriptor(descriptor, receiver, createCoercionContext(context), true);
     if (isSandboxRegExpIterator(target))
         return getRegExpIteratorMember(property, context.budget);
-    if (typeof target === "symbol") {
+    if (typeof target === "symbol" || typeof target === "bigint") {
         const prototype = getBoxedPrototype(target, context.budget);
         return prototype === undefined ? undefined : getPropertyValue(prototype, property, context, receiver);
     }
@@ -2041,6 +2059,8 @@ async function evaluateObjectPropertyKey(node, context) {
     return evaluateMemberProperty(node.key, context);
 }
 function getStaticPropertyName(node) {
+    if (node.type === "BigIntLiteral")
+        return BigInt(node.value).toString();
     if (node.type === "Identifier") {
         return node.name;
     }
@@ -2074,7 +2094,7 @@ async function evaluateMemberCallExpression(node, context) {
             return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context), context, member.object);
         if (Array.isArray(member.object) && hasExplicitSandboxPrototype(member.object))
             return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context), context, member.object);
-        if ((typeof member.object === "string" || typeof member.object === "number" || typeof member.object === "boolean" || typeof member.object === "symbol") &&
+        if ((typeof member.object === "string" || typeof member.object === "number" || typeof member.object === "bigint" || typeof member.object === "boolean" || typeof member.object === "symbol") &&
             getBoxedPrototype(member.object, context.budget) !== undefined) {
             if (isDefaultBoxedMethod(member.object, member.property, context.budget)) {
                 if (typeof member.object === "string" && isStringMethodName(member.property))
@@ -2259,10 +2279,14 @@ async function applyUnaryOperator(operator, value, context) {
             return undefined;
         case "+":
             return toNumber(await toNumericPrimitive(value, context));
-        case "-":
-            return -toNumber(await toNumericPrimitive(value, context));
-        case "~":
-            return ~toNumber(await toNumericPrimitive(value, context));
+        case "-": {
+            const primitive = await toNumericPrimitive(value, context);
+            return typeof primitive === "bigint" ? bigIntOperation("-", 0n, primitive, context.budget) : -toNumber(primitive);
+        }
+        case "~": {
+            const primitive = await toNumericPrimitive(value, context);
+            return typeof primitive === "bigint" ? bigIntOperation("^", primitive, -1n, context.budget) : ~toNumber(primitive);
+        }
     }
 }
 function describeTypeofValue(value) {
@@ -2278,6 +2302,12 @@ function isTruthy(value) {
     return Boolean(value);
 }
 function applyBinaryOperator(node, left, right, context) {
+    if ((typeof left === "bigint" || typeof right === "bigint") &&
+        ["-", "*", "/", "%", "**", "&", "|", "^", "<<", ">>", ">>>"].includes(node.operator)) {
+        if (typeof left !== "bigint" || typeof right !== "bigint")
+            throw new TypeError("Cannot mix BigInt and other numeric types.");
+        return bigIntOperation(node.operator, left, right, context.budget);
+    }
     switch (node.operator) {
         case "+":
             return applyAdditionOperator(left, right, context);
@@ -2410,6 +2440,11 @@ async function applyCompoundAssignmentOperator(operator, left, right, context) {
         if (convertingObject)
             convertedLeft = left;
         right = await toNumericPrimitive(right, context, operator === "+=" ? "default" : "number");
+        if (operator !== "+=" && (typeof left === "bigint" || typeof right === "bigint")) {
+            if (typeof left !== "bigint" || typeof right !== "bigint")
+                throw new TypeError("Cannot mix BigInt and other numeric types.");
+            return bigIntOperation(operator.slice(0, -1), left, right, context.budget);
+        }
         switch (operator) {
             case "+=":
                 return applyAdditionOperator(left, right, context);
@@ -2447,6 +2482,11 @@ function applyAdditionOperator(left, right, context) {
     if (typeof leftPrimitive === "string" || typeof rightPrimitive === "string") {
         return context.budget.allocateString(toString(leftPrimitive) + toString(rightPrimitive));
     }
+    if (typeof leftPrimitive === "bigint" || typeof rightPrimitive === "bigint") {
+        if (typeof leftPrimitive !== "bigint" || typeof rightPrimitive !== "bigint")
+            throw new TypeError("Cannot mix BigInt and other numeric types.");
+        return bigIntOperation("+", leftPrimitive, rightPrimitive, context.budget);
+    }
     return toNumber(leftPrimitive) + toNumber(rightPrimitive);
 }
 function compareRelational(left, right, operator) {
@@ -2464,8 +2504,9 @@ function compareRelational(left, right, operator) {
                 return leftPrimitive >= rightPrimitive;
         }
     }
-    const leftNumber = toNumber(leftPrimitive);
-    const rightNumber = toNumber(rightPrimitive);
+    const hasBigInt = typeof leftPrimitive === "bigint" || typeof rightPrimitive === "bigint";
+    const leftNumber = typeof leftPrimitive === "bigint" || (hasBigInt && typeof leftPrimitive === "string") ? leftPrimitive : toNumber(leftPrimitive);
+    const rightNumber = typeof rightPrimitive === "bigint" || (hasBigInt && typeof rightPrimitive === "string") ? rightPrimitive : toNumber(rightPrimitive);
     switch (operator) {
         case "<":
             return leftNumber < rightNumber;
@@ -2478,6 +2519,8 @@ function compareRelational(left, right, operator) {
     }
 }
 function isLooselyEqual(left, right) {
+    if (typeof left === "bigint" || typeof right === "bigint")
+        return left == right;
     const leftType = getCoercionType(left);
     const rightType = getCoercionType(right);
     if (leftType === rightType) {
@@ -2510,6 +2553,8 @@ function isPrimitiveCoercionType(type) {
     return type !== "object";
 }
 function getCoercionType(value) {
+    if (typeof value === "bigint")
+        return "bigint";
     if (typeof value === "symbol")
         return "symbol";
     if (value === null) {
@@ -2544,6 +2589,8 @@ async function toNumericPrimitive(value, context, hint = "number") {
     throw new TypeError("Expected a sandbox value.");
 }
 function toNumber(value) {
+    if (typeof value === "bigint")
+        throw new TypeError("Cannot convert a BigInt value to a number");
     if (typeof value === "symbol")
         throw new TypeError("Cannot convert a Symbol value to a number");
     if (isSandboxDate(value))

package/packages/safe-js/dist/interp/iteration.js

@@ -5,7 +5,7 @@ import { boxedValue, isSandboxBox } from "./boxed.js";
 import { getHostObjectIterator, isGuestHostObject } from "./host-capabilities.js";
 import { isSandboxCollectionIterator, nextCollectionIterator } from "./collection-iterator.js";
 import { isSandboxRegExpIterator } from "./regexp-iterator.js";
-import { nextRegExpIterator } from "./methods/regexp-iterator.js";
+import { nextObservableRegExpIterator, nextRegExpIterator } from "./methods/regexp-iterator.js";
 import { Budget, isFatalSandboxError } from "./budget.js";
 import { sandboxString } from "./string-coercion.js";
 import { awaitSandboxValue, awaitWithSignal } from "./cancel.js";
@@ -225,8 +225,11 @@ export function getSandboxIterator(value, budget, context) {
     }
     if (isSandboxCollectionIterator(value))
         return { next: () => nextCollectionIterator(value, budget), snapshotIndex: () => 0 };
-    if (isSandboxRegExpIterator(value))
+    if (isSandboxRegExpIterator(value)) {
+        if (context !== undefined && budget !== undefined)
+            return { asynchronous: true, next: () => nextObservableRegExpIterator(value, budget, context), snapshotIndex: () => 0 };
         return { next: () => nextRegExpIterator(value, budget), snapshotIndex: () => 0 };
+    }
     if (isGuestHostObject(value))
         return getHostObjectIterator(value);
     if (isFloat32Array(value)) {

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

@@ -30,7 +30,7 @@ export function callNumberMethod(value, methodName, args, budget, context) {
     if (argument !== null && typeof argument === "object") {
         return formatObjectArgument(value, methodName, argument, budget, context);
     }
-    return formatNumber(value, methodName, argument === undefined ? undefined : Number(argument), budget);
+    return formatNumber(value, methodName, argument === undefined ? undefined : +argument, budget);
 }
 async function formatObjectArgument(value, methodName, argument, budget, context) {
     const retainedArgument = {};

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

@@ -0,0 +1,3 @@
+import { type Budget } from "../budget.js";
+import { type SandboxCallContext, type SandboxClosure, type SandboxValue } from "../values.js";
+export declare function regexSplit(target: SandboxValue, input: SandboxValue, limit: SandboxValue, constructor: SandboxClosure, budget: Budget, context?: SandboxCallContext): Promise<SandboxValue[]>;

package/packages/safe-js/dist/interp/methods/regex-split.js

@@ -0,0 +1,102 @@
+import { isSandboxClosure } from "../values.js";
+import { getSandboxPropertyDescriptor } from "../object-model.js";
+import { readPropertyDescriptor } from "../accessors.js";
+import { invokeBuiltinClosure } from "../builtin-call.js";
+import { setSandboxProperty } from "../interpreter.js";
+import { sandboxNumber, sandboxString } from "../string-coercion.js";
+import { normalizeLastIndex } from "../regex/engine.js";
+import { retainValues } from "../resources.js";
+import { regexExec } from "./regex.js";
+export async function regexSplit(target, input, limit, constructor, budget, context) {
+    if (target === null || typeof target !== "object")
+        throw new TypeError("RegExp split requires an object receiver.");
+    let string;
+    let species;
+    let field;
+    let flags;
+    let matcher;
+    let match;
+    const result = [];
+    const release = retainValues(budget, () => [target, input, limit, string, species, field, flags, matcher, match, result]);
+    const read = (value, key) => {
+        if (context?.getProperty !== undefined)
+            return context.getProperty(value, key);
+        const descriptor = getSandboxPropertyDescriptor(value, key, budget);
+        return descriptor === undefined ? undefined : readPropertyDescriptor(descriptor, value, context);
+    };
+    const append = (value) => {
+        budget.allocateArrayLength(result.length + 1);
+        result.push(value);
+    };
+    try {
+        string = await sandboxString(input, budget, context);
+        input = undefined;
+        field = await read(target, "constructor");
+        species = constructor;
+        if (field !== undefined) {
+            if (field === null || typeof field !== "object")
+                throw new TypeError("Invalid RegExp species constructor.");
+            species = await read(field, Symbol.species);
+            if (species === null || species === undefined)
+                species = constructor;
+        }
+        field = undefined;
+        if (!isSandboxClosure(species) || species.construct === undefined)
+            throw new TypeError("RegExp species must be a constructor.");
+        field = await read(target, "flags");
+        flags = await sandboxString(field, budget, context);
+        field = undefined;
+        const unicode = flags.includes("u") || flags.includes("v");
+        if (!flags.includes("y"))
+            flags = budget.allocateString(flags + "y");
+        matcher = await invokeBuiltinClosure(species, [target, flags], budget, context, undefined, true);
+        const maximum = limit === undefined ? 2 ** 32 - 1 : (await sandboxNumber(limit, budget, context)) >>> 0;
+        limit = undefined;
+        if (maximum === 0)
+            return result;
+        if (string.length === 0) {
+            match = await regexExec(matcher, string, budget, context);
+            if (match === null)
+                append(string);
+            return result;
+        }
+        let end = 0;
+        let index = 0;
+        while (index < string.length) {
+            budget.visitNode();
+            match = undefined;
+            await setSandboxProperty(matcher, "lastIndex", index, budget, true, context);
+            match = await regexExec(matcher, string, budget, context);
+            if (match !== null) {
+                field = await read(matcher, "lastIndex");
+                const next = Math.min(normalizeLastIndex(await sandboxNumber(field, budget, context)), string.length);
+                field = undefined;
+                if (next !== end) {
+                    append(budget.allocateString(string.slice(end, index)));
+                    if (result.length === maximum)
+                        return result;
+                    end = next;
+                    field = await read(match, "length");
+                    const length = normalizeLastIndex(await sandboxNumber(field, budget, context));
+                    field = undefined;
+                    for (let capture = 1; capture < length; capture++) {
+                        budget.visitNode();
+                        field = await read(match, String(capture));
+                        append(field);
+                        field = undefined;
+                        if (result.length === maximum)
+                            return result;
+                    }
+                    index = end;
+                    continue;
+                }
+            }
+            index += unicode && (string.codePointAt(index) ?? 0) > 0xffff ? 2 : 1;
+        }
+        append(budget.allocateString(string.slice(end)));
+        return result;
+    }
+    finally {
+        release();
+    }
+}

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

@@ -11,4 +11,4 @@ export declare function callRegexMethod(target: SandboxValue, methodName: RegexM
 export declare function regexExec(target: SandboxValue, input: string, budget: Budget, context?: SandboxCallContext): Promise<SandboxValue>;
 export declare function regexToString(target: SandboxValue, budget: Budget, context?: SandboxCallContext): Promise<string>;
 export declare function executeRegex(target: SandboxRegex, input: string, lastIndex: number): RegexMatch | null;
-export declare function toMatchArray(match: RegexMatch | null, input: string): SandboxValue;
+export declare function toMatchArray(match: RegexMatch | null, input: string, budget?: Budget): SandboxValue;

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

@@ -1,7 +1,7 @@
 import { createSandboxClosure, getSandboxRegexPattern, getRegexProperties, isSandboxClosure, isSandboxRegex } from "../values.js";
 import { matchRegex } from "../regex/engine.js";
 import { invokeBuiltinClosure } from "../builtin-call.js";
-import { getSandboxPropertyDescriptor, getSandboxPrototype, hasExplicitSandboxPrototype } from "../object-model.js";
+import { getSandboxPropertyDescriptor, getSandboxPrototype, hasExplicitSandboxPrototype, setSandboxPrototype } from "../object-model.js";
 import { readPropertyDescriptor } from "../accessors.js";
 import { retainValues } from "../resources.js";
 import { sandboxNumber, sandboxString } from "../string-coercion.js";
@@ -160,7 +160,7 @@ export async function callRegexMethod(target, methodName, args, budget, context)
         cursor = target.lastIndex;
         const lastIndex = await sandboxNumber(cursor, budget, context);
         const match = executeRegex(target, input, lastIndex);
-        return toMatchArray(match, input);
+        return toMatchArray(match, input, budget);
     }
     finally {
         budget.setRetainedValues(retained, undefined);
@@ -218,16 +218,27 @@ export async function regexToString(target, budget, context) {
 export function executeRegex(target, input, lastIndex) {
     const pattern = getSandboxRegexPattern(target);
     const match = matchRegex(pattern, input, lastIndex);
-    if (pattern.flags.global) {
+    if (pattern.flags.global || pattern.flags.sticky) {
         target.lastIndex = match === null ? 0 : match.index + match.text.length;
     }
     return match;
 }
-export function toMatchArray(match, input) {
+export function toMatchArray(match, input, budget) {
     if (match === null) {
         return null;
     }
+    budget?.allocateArrayLength(match.captures.length + 1);
     const result = [match.text, ...match.captures];
-    Object.assign(result, { index: match.index, input, groups: undefined });
+    if (match.groups !== undefined)
+        setSandboxPrototype(match.groups, null, budget);
+    if (match.indicesGroups !== undefined)
+        setSandboxPrototype(match.indicesGroups, null, budget);
+    Object.assign(result, { index: match.index, input, groups: match.groups });
+    if (match.indices !== undefined) {
+        budget?.allocateArrayLength(match.indices.length);
+        budget?.allocateArrayLength(2);
+        Object.assign(match.indices, { groups: match.indicesGroups });
+        Object.assign(result, { indices: match.indices });
+    }
     return result;
 }

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

@@ -1,8 +1,12 @@
 import type { Budget } from "../budget.js";
 import { type SandboxRegExpIterator } from "../regexp-iterator.js";
-import { type SandboxValue } from "../values.js";
+import { type SandboxCallContext, type SandboxValue } from "../values.js";
 export declare function nextRegExpIterator(iterator: SandboxRegExpIterator, budget?: Budget): {
     value: SandboxValue;
     done: boolean;
 };
+export declare function nextObservableRegExpIterator(iterator: SandboxRegExpIterator, budget: Budget, context: SandboxCallContext): Promise<{
+    value: SandboxValue;
+    done: boolean;
+}>;
 export declare function getRegExpIteratorMember(property: PropertyKey, budget: Budget): SandboxValue;