poe-code 14.0.73 → 14.0.75

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

@@ -1,22 +1,84 @@
 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, setSandboxPrototype } 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,9 +128,9 @@ function escapeRegexSource(source, budget) {
     text = text === "" ? "(?:)" : text;
     return budget === undefined ? text : budget.allocateString(text);
 }
-export function setRegexMember(target, property, value) {
+export function setRegexMember(target, property, value, budget) {
     const properties = getRegexProperties(target);
-    if (!Object.hasOwn(properties, property) &&
+    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.`);
     }
@@ -76,6 +138,8 @@ export function setRegexMember(target, 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.`);
     }
@@ -86,42 +150,95 @@ 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, budget);
     }
     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);
-    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

@@ -0,0 +1,12 @@
+import type { Budget } from "../budget.js";
+import { type SandboxRegExpIterator } from "../regexp-iterator.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;

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

@@ -0,0 +1,101 @@
+import { isSandboxRegExpIterator, regexpIteratorState } from "../regexp-iterator.js";
+import { createSandboxClosure, isSandboxRegex } from "../values.js";
+import { executeRegex, regexExec, toMatchArray } from "./regex.js";
+import { getSandboxPropertyDescriptor, hasRegexPropertyOverride } from "../object-model.js";
+import { readPropertyDescriptor } from "../accessors.js";
+import { setSandboxProperty } from "../interpreter.js";
+import { sandboxNumber, sandboxString } from "../string-coercion.js";
+import { normalizeLastIndex } from "../regex/engine.js";
+import { retainValues } from "../resources.js";
+export function nextRegExpIterator(iterator, budget) {
+    const state = regexpIteratorState(iterator);
+    budget?.visitNode();
+    if (state.exhausted)
+        return { value: undefined, done: true };
+    const matcher = state.matcher;
+    if (!isSandboxRegex(matcher))
+        throw new TypeError("Custom RegExp iterator execution requires a sandbox context.");
+    const input = state.input;
+    const match = executeRegex(matcher, input, Number(matcher.lastIndex));
+    if (match === null || !(state.global ?? 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 = state.unicode ?? (matcher.flags.includes("u") || matcher.flags.includes("v"));
+        const codePoint = input.codePointAt(index);
+        matcher.lastIndex = index + (unicode && codePoint !== undefined && codePoint > 0xffff ? 2 : 1);
+    }
+    return { value: toMatchArray(match, input, budget), done: false };
+}
+export async function nextObservableRegExpIterator(iterator, budget, context) {
+    const state = regexpIteratorState(iterator);
+    if (state.exhausted)
+        return { value: undefined, done: true };
+    const matcher = state.matcher;
+    if (isSandboxRegex(matcher) && !hasRegexPropertyOverride(matcher, ["exec"], budget) &&
+        (matcher.lastIndex === null || typeof matcher.lastIndex !== "object"))
+        return nextRegExpIterator(iterator, budget);
+    const input = state.input;
+    let result;
+    let field;
+    const release = retainValues(budget, () => [iterator, matcher, input, result, field]);
+    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 {
+        budget.visitNode();
+        result = await regexExec(matcher, input, budget, context);
+        const global = state.global ?? (isSandboxRegex(matcher) && matcher.flags.includes("g"));
+        if (result === null || !global) {
+            state.exhausted = true;
+            state.matcher = undefined;
+            state.input = undefined;
+            return result === null ? { value: undefined, done: true } : { value: result, done: false };
+        }
+        field = await read(result, "0");
+        const text = await sandboxString(field, budget, context);
+        field = undefined;
+        if (text.length === 0) {
+            field = await read(matcher, "lastIndex");
+            const index = normalizeLastIndex(await sandboxNumber(field, budget, context));
+            field = undefined;
+            const unicode = state.unicode ?? (isSandboxRegex(matcher) && (matcher.flags.includes("u") || matcher.flags.includes("v")));
+            const point = input.codePointAt(index);
+            await setSandboxProperty(matcher, "lastIndex", index + (unicode && point !== undefined && point > 0xffff ? 2 : 1), budget, true, context);
+        }
+        return { value: result, done: false };
+    }
+    finally {
+        release();
+    }
+}
+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 context === undefined ? nextRegExpIterator(receiver, budget) : nextObservableRegExpIterator(receiver, budget, context);
+        }
+    });
+}

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 {};