poe-code 14.0.72 → 14.0.74

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

@@ -1,22 +1,84 @@
-import { createSandboxClosure, getSandboxRegexPattern, isSandboxClosure, isSandboxRegex } from "../values.js";
+import { createSandboxClosure, getSandboxRegexPattern, getRegexProperties, isSandboxClosure, isSandboxRegex } from "../values.js";
 import { matchRegex } from "../regex/engine.js";
 import { invokeBuiltinClosure } from "../builtin-call.js";
-import { getSandboxDataProperty } from "../object-model.js";
+import { getSandboxPropertyDescriptor, getSandboxPrototype, hasExplicitSandboxPrototype } from "../object-model.js";
+import { readPropertyDescriptor } from "../accessors.js";
+import { retainValues } from "../resources.js";
 import { sandboxNumber, sandboxString } from "../string-coercion.js";
-const regexMethodNames = new Set(["exec", "test"]);
-const regexFlagProperties = {
+import { setSandboxProperty } from "../interpreter.js";
+export async function regexSearch(target, input, budget, context) {
+    if (target === null || typeof target !== "object")
+        throw new TypeError("RegExp search requires an object receiver.");
+    let string;
+    let previous;
+    let result;
+    const release = retainValues(budget, () => [target, input, string, previous, 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);
+    };
+    try {
+        string = await sandboxString(input, budget, context);
+        input = undefined;
+        previous = await read(target, "lastIndex");
+        if (!Object.is(previous, 0))
+            await setSandboxProperty(target, "lastIndex", 0, budget, true, context);
+        result = await regexExec(target, string, budget, context);
+        if (!Object.is(await read(target, "lastIndex"), previous))
+            await setSandboxProperty(target, "lastIndex", previous, budget, true, context);
+        return result === null ? -1 : await read(result, "index");
+    }
+    finally {
+        release();
+    }
+}
+const regexMethodNames = new Set(["exec", "test", "toString"]);
+export const regexFlagProperties = {
     hasIndices: "d", global: "g", ignoreCase: "i", multiline: "m",
     dotAll: "s", unicode: "u", unicodeSets: "v", sticky: "y"
 };
 export function isRegexMethodName(property) {
     return typeof property === "string" && regexMethodNames.has(property);
 }
-export function getRegexMember(target, property, budget) {
+export function getRegexMember(target, property, budget, context) {
     if (property === "source")
         return escapeRegexSource(target.source, budget);
     if (property === "flags") {
-        const flags = [..."gims"].filter((flag) => target.flags.includes(flag)).join("");
-        return budget === undefined ? flags : budget.allocateString(flags);
+        let flags = "";
+        const entries = Object.entries(regexFlagProperties);
+        const release = retainValues(budget, () => [target, flags]);
+        const read = (index) => {
+            if (index === entries.length)
+                return budget.allocateString(flags);
+            budget.visitNode();
+            const [key, flag] = entries[index];
+            const descriptor = context?.getProperty === undefined
+                ? getSandboxPropertyDescriptor(target, key, budget) : undefined;
+            const value = context?.getProperty !== undefined
+                ? context.getProperty(target, key)
+                : descriptor !== undefined
+                    ? readPropertyDescriptor(descriptor, target, context)
+                    : target.flags.includes(flag);
+            const append = (value) => {
+                if (value)
+                    flags += flag;
+                return read(index + 1);
+            };
+            return value instanceof Promise ? value.then(append) : append(value);
+        };
+        try {
+            const result = read(0);
+            if (result instanceof Promise)
+                return result.finally(release);
+            release();
+            return result;
+        }
+        catch (error) {
+            release();
+            throw error;
+        }
     }
     if (property === "lastIndex")
         return target.lastIndex;
@@ -27,7 +89,7 @@ export function getRegexMember(target, property, budget) {
     }
     return createSandboxClosure({
         sandbox: true,
-        name: `RegExp#${property}`,
+        name: property === "toString" ? "toString" : `RegExp#${property}`,
         call: (args, context) => callRegexMethod(context?.thisValue, property, args, budget, context)
     });
 }
@@ -66,13 +128,18 @@ function escapeRegexSource(source, budget) {
     text = text === "" ? "(?:)" : text;
     return budget === undefined ? text : budget.allocateString(text);
 }
-export function setRegexMember(target, property, value) {
-    if (property !== "lastIndex") {
+export function setRegexMember(target, property, value, budget) {
+    const properties = getRegexProperties(target);
+    if (!hasExplicitSandboxPrototype(target) && getSandboxPrototype(target, budget) === null && !Object.hasOwn(properties, property) &&
+        (property === "source" || property === "flags" || Object.hasOwn(regexFlagProperties, property))) {
         throw new TypeError(`RegExp#${String(property)} is not writable.`);
     }
-    target.lastIndex = value;
+    if (!Reflect.set(properties, property, value))
+        throw new TypeError(`RegExp#${String(property)} is not writable.`);
 }
 export async function callRegexMethod(target, methodName, args, budget, context) {
+    if (methodName === "toString")
+        return regexToString(target, budget, context);
     if (target === null || typeof target !== "object" || (methodName === "exec" && !isSandboxRegex(target))) {
         throw new TypeError(`RegExp#${methodName} requires ${methodName === "exec" ? "a regex" : "an object"} receiver.`);
     }
@@ -83,29 +150,71 @@ export async function callRegexMethod(target, methodName, args, budget, context)
     try {
         const input = await sandboxString(args[0], budget, context);
         if (methodName === "test") {
-            const exec = context?.getProperty === undefined
-                ? getSandboxDataProperty(target, "exec", budget) : await context.getProperty(target, "exec");
-            if (isSandboxClosure(exec)) {
-                const result = await invokeBuiltinClosure(exec, [input], budget, context, target);
-                if (result !== null && typeof result !== "object") {
-                    throw new TypeError("RegExp#test exec must return an object or null.");
-                }
-                return result !== null;
-            }
+            budget.setRetainedValues(retained, undefined);
+            return await regexExec(target, input, budget, context) !== null;
         }
-        if (!isSandboxRegex(target))
-            throw new TypeError("RegExp execution requires a regex receiver.");
         if (typeof args[0] !== "string")
             convertedInput = input;
+        if (!isSandboxRegex(target))
+            throw new TypeError("RegExp execution requires a regex receiver.");
         cursor = target.lastIndex;
         const lastIndex = await sandboxNumber(cursor, budget, context);
         const match = executeRegex(target, input, lastIndex);
-        return methodName === "test" ? match !== null : toMatchArray(match, input);
+        return toMatchArray(match, input);
     }
     finally {
         budget.setRetainedValues(retained, undefined);
     }
 }
+export async function regexExec(target, input, budget, context) {
+    let exec;
+    const release = retainValues(budget, () => [target, input, exec]);
+    try {
+        const descriptor = context?.getProperty === undefined
+            ? getSandboxPropertyDescriptor(target, "exec", budget) : undefined;
+        exec = await (context?.getProperty !== undefined ? context.getProperty(target, "exec")
+            : descriptor === undefined ? undefined : readPropertyDescriptor(descriptor, target, context));
+        if (isSandboxClosure(exec)) {
+            const result = await invokeBuiltinClosure(exec, [input], budget, context, target);
+            if (result !== null && typeof result !== "object")
+                throw new TypeError("RegExp exec must return an object or null.");
+            return result;
+        }
+        return await callRegexMethod(target, "exec", [input], budget, context);
+    }
+    finally {
+        release();
+    }
+}
+export async function regexToString(target, budget, context) {
+    if (target === null || typeof target !== "object")
+        throw new TypeError("RegExp#toString requires an object receiver.");
+    const read = (key) => {
+        if (context?.getProperty !== undefined)
+            return context.getProperty(target, key);
+        const descriptor = getSandboxPropertyDescriptor(target, key, budget);
+        if (descriptor !== undefined)
+            return readPropertyDescriptor(descriptor, target, context);
+        return isSandboxRegex(target) ? getRegexMember(target, key, budget, context) : undefined;
+    };
+    let sourceValue;
+    let flagsValue;
+    let source;
+    let flags;
+    const release = retainValues(budget, () => [target, sourceValue, flagsValue, source, flags]);
+    try {
+        sourceValue = await read("source");
+        source = await sandboxString(sourceValue, budget, context);
+        sourceValue = undefined;
+        flagsValue = await read("flags");
+        flags = await sandboxString(flagsValue, budget, context);
+        flagsValue = undefined;
+        return budget.allocateString(`/${source}/${flags}`);
+    }
+    finally {
+        release();
+    }
+}
 export function executeRegex(target, input, lastIndex) {
     const pattern = getSandboxRegexPattern(target);
     const match = matchRegex(pattern, input, lastIndex);

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

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

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

@@ -0,0 +1,49 @@
+import { isSandboxRegExpIterator, regexpIteratorState } from "../regexp-iterator.js";
+import { createSandboxClosure } from "../values.js";
+import { executeRegex, toMatchArray } from "./regex.js";
+export function nextRegExpIterator(iterator, budget) {
+    const state = regexpIteratorState(iterator);
+    budget?.visitNode();
+    if (state.exhausted)
+        return { value: undefined, done: true };
+    const matcher = state.matcher;
+    const input = state.input;
+    const match = executeRegex(matcher, input, Number(matcher.lastIndex));
+    if (match === null || !matcher.flags.includes("g")) {
+        state.exhausted = true;
+        state.matcher = undefined;
+        state.input = undefined;
+    }
+    if (match === null)
+        return { value: undefined, done: true };
+    if (!state.exhausted && match.text.length === 0) {
+        const index = Number(matcher.lastIndex);
+        const unicode = matcher.flags.includes("u") || matcher.flags.includes("v");
+        const codePoint = input.codePointAt(index);
+        matcher.lastIndex = index + (unicode && codePoint !== undefined && codePoint > 0xffff ? 2 : 1);
+    }
+    budget?.allocateArrayLength(match.captures.length + 1);
+    return { value: toMatchArray(match, input), done: false };
+}
+export function getRegExpIteratorMember(property, budget) {
+    if (property === Symbol.toStringTag)
+        return "RegExp String Iterator";
+    if (property === Symbol.iterator)
+        return createSandboxClosure({
+            sandbox: true,
+            name: "[Symbol.iterator]",
+            call: (_args, context) => context?.thisValue
+        });
+    if (property !== "next")
+        return undefined;
+    return createSandboxClosure({
+        sandbox: true,
+        name: "next",
+        call: (_args, context) => {
+            const receiver = context?.thisValue;
+            if (!isSandboxRegExpIterator(receiver))
+                throw new TypeError("RegExp string iterator next requires a matching receiver.");
+            return nextRegExpIterator(receiver, budget);
+        }
+    });
+}

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

@@ -9,4 +9,6 @@ export declare function getStringIndex(property: string | number): number | unde
 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: SandboxValue, methodName: StringMethodName, args: readonly SandboxValue[], budget: Budget, callClosure?: (closure: SandboxClosure, args: readonly SandboxValue[]) => Promise<SandboxValue>, parent?: CompileScope, context?: SandboxCallContext): SandboxValue | Promise<SandboxValue>;
+export declare function regexReplace(input: SandboxValue, regex: SandboxValue, replacementInput: SandboxValue, budget: Budget, callClosure: (closure: SandboxClosure, args: readonly SandboxValue[]) => Promise<SandboxValue>, context?: SandboxCallContext): Promise<string>;
+export declare function regexMatch(input: SandboxValue, regex: SandboxValue, budget: Budget, context?: SandboxCallContext): Promise<SandboxValue>;
 export {};