poe-code 13.0.3 → 13.0.4

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

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

@@ -0,0 +1,179 @@
+import { REGEX_COMPILE_LIMITS, SandboxError } from "../budget.js";
+const compiledData = new WeakMap();
+export class CompileScope {
+    owner;
+    parent;
+    tickets = new Set();
+    closed = false;
+    constructor(owner, parent) {
+        this.owner = owner;
+        this.parent = parent;
+    }
+    forward(tickets, parent) {
+        if (parent === this)
+            return;
+        if (this.owner !== parent.owner)
+            throw new SandboxError("reentry");
+        for (const ticket of tickets) {
+            if (!this.tickets.delete(ticket))
+                continue;
+            if (ticket.owner.budget.compileTicketUsage(ticket) > 0)
+                parent.tickets.add(ticket);
+        }
+    }
+    dispose() {
+        for (const ticket of this.tickets)
+            ticket.owner.budget.discardCompileTicket(ticket);
+        this.tickets.clear();
+        this.closed = true;
+    }
+}
+export class RegexCompileGuard {
+    scope;
+    allocations = 0;
+    depth = 0;
+    ticket;
+    retained = false;
+    constructor(scope) {
+        this.scope = scope;
+        if (scope?.owner !== undefined) {
+            this.ticket = scope.owner.budget.createCompileTicket(scope.owner);
+            scope.tickets.add(this.ticket);
+        }
+    }
+    checkLength(length, flags = false) {
+        const hard = flags ? REGEX_COMPILE_LIMITS.flagsLength : REGEX_COMPILE_LIMITS.sourceLength;
+        const limit = Math.min(hard, this.scope?.owner?.budget.limits.stringLength ?? hard);
+        if (length > limit)
+            throw new SandboxError({ budget: "stringLength", current: length, limit });
+    }
+    work(units) {
+        const budget = this.scope?.owner?.budget;
+        if (budget === undefined)
+            return;
+        for (let index = 0; index < units; index += 1)
+            budget.visitNode();
+    }
+    allocate(units) {
+        const next = this.allocations + units;
+        if (next > REGEX_COMPILE_LIMITS.allocations) {
+            throw new SandboxError({
+                budget: "dataSize",
+                current: next,
+                limit: REGEX_COMPILE_LIMITS.allocations
+            });
+        }
+        this.work(units);
+        if (this.ticket !== undefined) {
+            this.ticket.owner.budget.resizeCompileTicket(this.ticket, next);
+        }
+        this.allocations = next;
+    }
+    array(length) {
+        this.scope?.owner?.budget.allocateArrayLength(length);
+        this.allocate(1);
+    }
+    enterGroup() {
+        const next = this.depth + 1;
+        if (next > REGEX_COMPILE_LIMITS.depth) {
+            throw new SandboxError({
+                budget: "dataDepth",
+                current: next,
+                limit: REGEX_COMPILE_LIMITS.depth
+            });
+        }
+        this.depth = next;
+    }
+    leaveGroup() {
+        this.depth -= 1;
+    }
+    preflight(source, flags) {
+        this.checkLength(source.length);
+        this.checkLength(flags.length, true);
+        let escaped = false;
+        let characterClass = false;
+        let nesting = 0;
+        for (let position = 0; position < source.length; position += 1) {
+            this.work(1);
+            const character = source[position];
+            if (escaped) {
+                escaped = false;
+            }
+            else if (character === "\\") {
+                escaped = true;
+            }
+            else if (character === "[" && !characterClass) {
+                characterClass = true;
+            }
+            else if (character === "]" && characterClass) {
+                characterClass = false;
+            }
+            else if (!characterClass && character === "(") {
+                nesting += 1;
+                this.enterGroup();
+            }
+            else if (!characterClass && character === ")" && nesting > 0) {
+                nesting -= 1;
+                this.leaveGroup();
+            }
+        }
+        this.depth = 0;
+        this.work(flags.length);
+    }
+    retain(pattern, valueUnits = 0) {
+        const units = 10 + pattern.source.length + measureNode(pattern.body);
+        if (this.ticket !== undefined) {
+            this.ticket.owner.budget.resizeCompileTicket(this.ticket, units + valueUnits);
+        }
+        compiledData.set(pattern, { units, ticket: this.ticket });
+        this.retained = true;
+    }
+    retainScratch() {
+        this.retained = true;
+    }
+    close() {
+        if (this.retained || this.ticket === undefined)
+            return;
+        this.ticket.owner.budget.discardCompileTicket(this.ticket);
+        this.scope?.tickets.delete(this.ticket);
+    }
+}
+export function regexCompiledData(pattern) {
+    return (compiledData.get(pattern) ?? { units: 10 + pattern.source.length + measureNode(pattern.body) });
+}
+function measureNode(node) {
+    switch (node.type) {
+        case "empty":
+        case "dot":
+            return 2;
+        case "literal":
+            return 3 + node.value.length;
+        case "anchor":
+        case "wordBoundary":
+            return 3;
+        case "characterClass": {
+            let usage = 5 + node.items.length;
+            for (const item of node.items) {
+                usage +=
+                    item.type === "character"
+                        ? 3 + item.value.length
+                        : item.type === "range"
+                            ? 4 + item.from.length + item.to.length
+                            : 4;
+            }
+            return usage;
+        }
+        case "sequence":
+        case "alternation": {
+            const children = node.type === "sequence" ? node.elements : node.alternatives;
+            let usage = 4 + children.length;
+            for (const child of children)
+                usage += measureNode(child);
+            return usage;
+        }
+        case "group":
+            return 5 + measureNode(node.body);
+        case "quantifier":
+            return (Object.hasOwn(node, "max") ? 6 : 5) + measureNode(node.body);
+    }
+}

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

@@ -1,3 +1,4 @@
+import { type CompileScope } from "./compile-guard.js";
 export type RegexFlags = {
     global: boolean;
     ignoreCase: boolean;
@@ -58,4 +59,4 @@ export type RegexPattern = {
     captureCount: number;
     body: RegexNode;
 };
-export declare function parseRegex(source: string, flags?: string): RegexPattern;
+export declare function parseRegex(source: string, flags?: string, compilation?: CompileScope, valueUnits?: number): RegexPattern;