poe-code 14.0.74 → 14.0.76

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

@@ -1,15 +1,23 @@
 import { isSandboxRegExpIterator, regexpIteratorState } from "../regexp-iterator.js";
-import { createSandboxClosure } from "../values.js";
-import { executeRegex, toMatchArray } from "./regex.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 || !matcher.flags.includes("g")) {
+    if (match === null || !(state.global ?? matcher.flags.includes("g"))) {
         state.exhausted = true;
         state.matcher = undefined;
         state.input = undefined;
@@ -18,12 +26,56 @@ export function nextRegExpIterator(iterator, budget) {
         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 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);
     }
-    budget?.allocateArrayLength(match.captures.length + 1);
-    return { value: toMatchArray(match, input), done: false };
+    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)
@@ -43,7 +95,7 @@ export function getRegExpIteratorMember(property, budget) {
             const receiver = context?.thisValue;
             if (!isSandboxRegExpIterator(receiver))
                 throw new TypeError("RegExp string iterator next requires a matching receiver.");
-            return nextRegExpIterator(receiver, budget);
+            return context === undefined ? nextRegExpIterator(receiver, budget) : nextObservableRegExpIterator(receiver, budget, context);
         }
     });
 }

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

@@ -1,14 +1,14 @@
 import { types } from "node:util";
 import { invokeBuiltinClosure } from "../builtin-call.js";
 import { CompileScope } from "../regex/compile-guard.js";
-import { normalizeLastIndex } from "../regex/engine.js";
+import { advanceStringIndex, normalizeLastIndex } from "../regex/engine.js";
 import { sandboxNumber, sandboxString } from "../string-coercion.js";
 import { retainValues } from "../resources.js";
 import { getSandboxDataProperty, getSandboxPropertyDescriptor, hasRegexPropertyOverride } from "../object-model.js";
 import { readPropertyDescriptor } from "../accessors.js";
 import { createSandboxBox } from "../boxed.js";
 import { setSandboxProperty } from "../interpreter.js";
-import { createSandboxClosure, createSandboxRegex, deepCopyFromSandbox, isSandboxClosure, isSandboxRegex, measureSandboxData } from "../values.js";
+import { createSandboxClosure, createSandboxRegex, deepCopyFromSandbox, getSandboxRegexPattern, isSandboxClosure, isSandboxRegex, measureSandboxData } from "../values.js";
 import { executeRegex, getRegexMember, regexExec, regexFlagProperties, regexSearch, toMatchArray } from "./regex.js";
 import { restoreSandboxRegExpIterator } from "../regexp-iterator.js";
 export const stringMethodNames = new Set([
@@ -356,7 +356,7 @@ function callReplaceLikeMethod(value, methodName, args, budget, callClosure, use
     return replaceWithClosure(value, search, replacement, methodName === "replaceAll", budget, callClosure, context);
 }
 async function replaceRegex(value, regex, replacement, budget, callClosure, context) {
-    if (hasRegexPropertyOverride(regex, ["exec", "flags", ...Object.keys(regexFlagProperties)], budget))
+    if (getSandboxRegexPattern(regex).groups !== undefined || hasRegexPropertyOverride(regex, ["exec", "flags", ...Object.keys(regexFlagProperties)], budget))
         return regexReplace(value, regex, replacement, budget, callClosure, context);
     if (regex.flags.includes("g"))
         regex.lastIndex = 0;
@@ -410,7 +410,7 @@ export async function regexReplace(input, regex, replacementInput, budget, callC
         input = undefined;
         replacement = isSandboxClosure(replacementInput) ? replacementInput : await sandboxString(replacementInput, budget, context);
         replacementInput = undefined;
-        if (isSandboxRegex(regex) && !hasRegexPropertyOverride(regex, ["exec", "flags", ...Object.keys(regexFlagProperties)], budget)) {
+        if (isSandboxRegex(regex) && getSandboxRegexPattern(regex).groups === undefined && !hasRegexPropertyOverride(regex, ["exec", "flags", ...Object.keys(regexFlagProperties)], budget)) {
             release();
             return await replaceRegex(value, regex, replacement, budget, callClosure, context);
         }
@@ -641,7 +641,7 @@ function splitNormalized(value, separator, limit, budget, parent) {
                 if (match === null)
                     break;
                 if (match.text.length === 0)
-                    splitter.lastIndex = match.index + 1;
+                    splitter.lastIndex = advanceStringIndex(value, match.index, splitter.flags.includes("u") || splitter.flags.includes("v"));
                 endedWithZeroWidthMatch = match.text.length === 0 && match.index === value.length;
                 if (match.text.length === 0 &&
                     (match.index === copiedThrough || match.index === value.length))
@@ -822,7 +822,7 @@ function callMatchLikeMethod(value, methodName, args, compilation, lastIndex) {
         return match?.index ?? -1;
     }
     if (methodName === "match" && !regex.flags.includes("g"))
-        return toMatchArray(executeRegex(regex, value, lastIndex ?? Number(regex.lastIndex)), value);
+        return toMatchArray(executeRegex(regex, value, lastIndex ?? Number(regex.lastIndex)), value, compilation.owner?.budget);
     if (methodName === "match")
         regex.lastIndex = 0;
     const matcher = methodName === "matchAll"
@@ -843,7 +843,7 @@ function collectRegexMatches(regex, value, all, budget, lastIndex = 0) {
         matches.push(match);
         lastIndex = match.index + match.text.length;
         if (all && match.text.length === 0)
-            regex.lastIndex = ++lastIndex;
+            regex.lastIndex = lastIndex = advanceStringIndex(value, lastIndex, regex.flags.includes("u") || regex.flags.includes("v"));
     } while (all);
     return matches;
 }
@@ -852,10 +852,10 @@ function splitString(value, separator, limit) {
     return split.call(value, separator, limit);
 }
 function asNumber(value) {
-    return Number(value);
+    return +value;
 }
 function asNumberOrUndefined(value) {
-    return value === undefined ? undefined : Number(value);
+    return value === undefined ? undefined : +value;
 }
 function asStringOrUndefined(value) {
     return value === undefined ? undefined : String(value);

package/packages/safe-js/dist/interp/object-model.d.ts

@@ -16,6 +16,7 @@ export declare function isIntrinsicConstructor(value: object): boolean;
 export declare function releaseObjectPrototype(budget: Budget): void;
 export declare function getSandboxPrototype(value: object, budget?: Budget): object | null;
 export declare function hasExplicitSandboxPrototype(value: object): boolean;
+export declare function hasNullObjectPrototype(value: object): boolean;
 export declare function getSandboxPropertyDescriptor(value: SandboxValue, key: PropertyKey, budget?: Budget): PropertyDescriptor | undefined;
 export declare function getSandboxDataProperty(value: SandboxValue, key: PropertyKey, budget?: Budget): SandboxValue;
 export declare function setSandboxPrototype(value: object, prototype: object | null, budget?: Budget): void;

package/packages/safe-js/dist/interp/object-model.js

@@ -180,6 +180,9 @@ export function getSandboxPrototype(value, budget) {
 export function hasExplicitSandboxPrototype(value) {
     return prototypes.has(value);
 }
+export function hasNullObjectPrototype(value) {
+    return prototypes.get(value) === null && !Array.isArray(value) && !isSandboxClosure(value) && !isSandboxRegex(value);
+}
 export function getSandboxPropertyDescriptor(value, key, budget) {
     const hostProperties = isSandboxClosure(value) ? value.properties : undefined;
     if (isSandboxClosure(value) && !isGuestClosure(value))
@@ -288,7 +291,7 @@ export function hasGuestObjectState(value) {
         return !intrinsicUnchanged();
     if (isLiveCapability(value))
         return true;
-    if (functionProperties.has(value) || prototypes.has(value))
+    if (functionProperties.has(value) || (prototypes.has(value) && !hasNullObjectPrototype(value)))
         return true;
     if (isSandboxBox(value) || isSandboxDate(value))
         return false;

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

@@ -121,7 +121,7 @@ export class RegexCompileGuard {
         this.work(flags.length);
     }
     retain(pattern, valueUnits = 0) {
-        const units = 10 + pattern.source.length + measureNode(pattern.body);
+        const units = measurePattern(pattern);
         if (this.ticket !== undefined) {
             this.ticket.owner.budget.resizeCompileTicket(this.ticket, units + valueUnits);
         }
@@ -139,7 +139,16 @@ export class RegexCompileGuard {
     }
 }
 export function regexCompiledData(pattern) {
-    return (compiledData.get(pattern) ?? { units: 10 + pattern.source.length + measureNode(pattern.body) });
+    return (compiledData.get(pattern) ?? { units: measurePattern(pattern) });
+}
+function measurePattern(pattern) {
+    let units = 10 + pattern.source.length + measureNode(pattern.body);
+    if (pattern.groups !== undefined) {
+        units += 1;
+        for (const [name, indices] of Object.entries(pattern.groups))
+            units += name.length + 2 + indices.length;
+    }
+    return units;
 }
 function measureNode(node) {
     switch (node.type) {
@@ -148,18 +157,27 @@ function measureNode(node) {
             return 2;
         case "literal":
             return 3 + node.value.length;
+        case "namedBackreference":
+            return 3 + node.name.length;
         case "anchor":
         case "wordBoundary":
+        case "backreference":
             return 3;
         case "characterClass": {
             let usage = 5 + node.items.length;
+            if (node.operation !== undefined)
+                usage += 1 + node.operation.length;
+            if (node.strings !== undefined)
+                usage += 1;
             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;
+                            : item.type === "property" ? 4 + item.value.length + (item.strings === undefined ? 0 : 1)
+                                : item.type === "set" ? 3 + measureNode({ type: "characterClass", ...item.value })
+                                    : item.type === "strings" ? 4 + item.values.reduce((total, value) => total + 1 + value.length, 0) : 4;
             }
             return usage;
         }
@@ -172,7 +190,11 @@ function measureNode(node) {
             return usage;
         }
         case "group":
-            return 5 + measureNode(node.body);
+            return 5 + measureNode(node.body) + (node.name === undefined ? 0 : 1 + node.name.length) +
+                (node.modifiers === undefined ? 0 : 2 + Object.keys(node.modifiers).length);
+        case "lookahead":
+        case "lookbehind":
+            return 4 + measureNode(node.body);
         case "quantifier":
             return (Object.hasOwn(node, "max") ? 6 : 5) + measureNode(node.body);
     }

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

@@ -3,7 +3,11 @@ export type RegexMatch = {
     index: number;
     text: string;
     captures: (string | undefined)[];
+    indices?: ([number, number] | undefined)[];
+    groups?: Record<string, string | undefined>;
+    indicesGroups?: Record<string, [number, number] | undefined>;
 };
 export declare function matchRegex(pattern: RegexPattern, input: string, lastIndex?: number): RegexMatch | null;
 export declare function matchRegexFrom(pattern: RegexPattern, input: string, startIndex: number): RegexMatch | null;
 export declare function normalizeLastIndex(lastIndex: number): number;
+export declare function advanceStringIndex(input: string, index: number, unicode: boolean): number;

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

@@ -1,14 +1,19 @@
 import { allocateRegexSteps } from "../budget.js";
 export function matchRegex(pattern, input, lastIndex = 0) {
-    const startIndex = pattern.flags.global ? normalizeLastIndex(lastIndex) : 0;
+    const startIndex = pattern.flags.global || pattern.flags.sticky ? normalizeLastIndex(lastIndex) : 0;
     return matchRegexFrom(pattern, input, startIndex);
 }
 export function matchRegexFrom(pattern, input, startIndex) {
     if (startIndex > input.length) {
         return null;
     }
-    for (let attempt = startIndex; attempt <= input.length; attempt += 1) {
-        const context = { input, flags: pattern.flags, steps: 0 };
+    const unicode = pattern.flags.unicode || pattern.flags.unicodeSets;
+    if (unicode && startIndex > 0 && startIndex < input.length &&
+        input.charCodeAt(startIndex) >= 0xdc00 && input.charCodeAt(startIndex) <= 0xdfff &&
+        input.charCodeAt(startIndex - 1) >= 0xd800 && input.charCodeAt(startIndex - 1) <= 0xdbff)
+        startIndex--;
+    for (let attempt = startIndex; attempt <= input.length; attempt = advanceStringIndex(input, attempt, unicode)) {
+        const context = { input, flags: pattern.flags, groups: pattern.groups, direction: 1, work: { steps: 0 } };
         charge(context);
         const initialState = {
             position: attempt,
@@ -16,26 +21,63 @@ export function matchRegexFrom(pattern, input, startIndex) {
         };
         const result = matchNode(pattern.body, initialState, context).next();
         if (!result.done) {
-            return toRegexMatch(input, attempt, result.value);
+            return toRegexMatch(input, attempt, result.value, pattern.flags.hasIndices, pattern.groups);
         }
+        if (pattern.flags.sticky)
+            break;
     }
     return null;
 }
 function* matchNode(node, state, context) {
     charge(context);
+    const unicode = context.flags.unicode || context.flags.unicodeSets;
+    const character = readCharacter(context.input, state.position, context.direction, unicode);
     switch (node.type) {
         case "empty":
             yield state;
             return;
         case "literal":
-            if (charactersEqual(context.input[state.position], node.value, context.flags.ignoreCase)) {
-                yield { ...state, position: state.position + 1 };
+            if (charactersEqual(character, node.value, context.flags.ignoreCase, unicode)) {
+                yield { ...state, position: state.position + context.direction * character.length };
             }
             return;
+        case "backreference":
+        case "namedBackreference": {
+            let capture;
+            if (node.type === "backreference")
+                capture = state.captures[node.index - 1];
+            else {
+                for (const index of context.groups?.[node.name] ?? []) {
+                    charge(context);
+                    if (state.captures[index - 1] !== undefined) {
+                        capture = state.captures[index - 1];
+                        break;
+                    }
+                }
+            }
+            if (capture === undefined) {
+                yield state;
+                return;
+            }
+            let position = state.position;
+            let reference = context.direction === 1 ? capture.start : capture.end;
+            const end = context.direction === 1 ? capture.end : capture.start;
+            while (reference !== end) {
+                charge(context);
+                const expected = readCharacter(context.input, reference, context.direction, unicode);
+                const actual = readCharacter(context.input, position, context.direction, unicode);
+                if (!charactersEqual(actual, expected, context.flags.ignoreCase, unicode))
+                    return;
+                reference += context.direction * expected.length;
+                position += context.direction * actual.length;
+            }
+            yield { ...state, position };
+            return;
+        }
         case "dot":
-            if (state.position < context.input.length &&
-                (context.flags.dotAll || !isLineTerminator(context.input[state.position]))) {
-                yield { ...state, position: state.position + 1 };
+            if (character !== undefined &&
+                (context.flags.dotAll || !isLineTerminator(character))) {
+                yield { ...state, position: state.position + context.direction * character.length };
             }
             return;
         case "anchor":
@@ -44,18 +86,25 @@ function* matchNode(node, state, context) {
             }
             return;
         case "wordBoundary": {
-            const previousWord = state.position > 0 && isWordCharacter(context.input[state.position - 1]);
-            const nextWord = state.position < context.input.length && isWordCharacter(context.input[state.position]);
+            const previousWord = state.position > 0 && matchesCharacterClassItem(context.input[state.position - 1], { type: "kind", kind: "word", negated: false }, context.flags.ignoreCase, unicode);
+            const nextWord = state.position < context.input.length && matchesCharacterClassItem(context.input[state.position], { type: "kind", kind: "word", negated: false }, context.flags.ignoreCase, unicode);
             if ((previousWord !== nextWord) !== node.negated) {
                 yield state;
             }
             return;
         }
         case "characterClass": {
-            const character = context.input[state.position];
+            if (context.flags.unicodeSets) {
+                const lengths = [...matchUnicodeSet(node, state.position, context)].sort((a, b) => b - a);
+                for (const length of lengths) {
+                    charge(context);
+                    yield { ...state, position: state.position + context.direction * length };
+                }
+                return;
+            }
             if (character !== undefined &&
-                matchesCharacterClass(character, node.items, node.negated, context.flags.ignoreCase)) {
-                yield { ...state, position: state.position + 1 };
+                matchesCharacterClass(character, node.items, node.negated, context)) {
+                yield { ...state, position: state.position + context.direction * character.length };
             }
             return;
         }
@@ -67,14 +116,30 @@ function* matchNode(node, state, context) {
                 yield* matchNode(alternative, cloneState(state), context);
             }
             return;
+        case "lookahead":
+        case "lookbehind": {
+            const result = matchNode(node.body, cloneState(state), {
+                ...context, direction: node.type === "lookbehind" ? -1 : 1
+            }).next();
+            if (node.negated) {
+                if (result.done)
+                    yield state;
+            }
+            else if (!result.done) {
+                yield { position: state.position, captures: result.value.captures };
+            }
+            return;
+        }
         case "group":
-            for (const result of matchNode(node.body, cloneState(state), context)) {
+            for (const result of matchNode(node.body, cloneState(state), node.modifiers === undefined ? context : {
+                ...context, flags: { ...context.flags, ...node.modifiers }
+            })) {
                 if (!node.capturing || node.index === undefined) {
                     yield result;
                     continue;
                 }
                 const captures = result.captures.slice();
-                captures[node.index - 1] = { start: state.position, end: result.position };
+                captures[node.index - 1] = { start: Math.min(state.position, result.position), end: Math.max(state.position, result.position) };
                 yield { position: result.position, captures };
             }
             return;
@@ -88,7 +153,8 @@ function* matchSequence(elements, index, state, context) {
         yield state;
         return;
     }
-    for (const result of matchNode(elements[index], state, context)) {
+    const element = elements[context.direction === 1 ? index : elements.length - 1 - index];
+    for (const result of matchNode(element, state, context)) {
         yield* matchSequence(elements, index + 1, result, context);
     }
 }
@@ -129,11 +195,35 @@ function matchesAnchor(kind, position, context) {
             position < context.input.length &&
             isLineTerminator(context.input[position])));
 }
-function matchesCharacterClass(character, items, negated, ignoreCase) {
-    const matched = items.some((item) => matchesCharacterClassItem(character, item, ignoreCase));
+function matchesCharacterClass(character, items, negated, context) {
+    const matched = items.some((item) => {
+        if (context.flags.unicode)
+            charge(context);
+        return matchesCharacterClassItem(character, item, context.flags.ignoreCase, context.flags.unicode);
+    });
     return negated ? !matched : matched;
 }
-function matchesCharacterClassItem(character, item, ignoreCase) {
+function matchesCharacterClassItem(character, item, ignoreCase, unicode, unicodeSets = false) {
+    if (item.type === "strings" || item.type === "set")
+        return false;
+    if (unicode) {
+        // Generated atoms only: the host classifies one code point, never executes a guest pattern.
+        const hex = (value) => `\\u{${value.codePointAt(0).toString(16)}}`;
+        let atom;
+        if (item.type === "character")
+            atom = hex(item.value);
+        else if (item.type === "range")
+            atom = `[${hex(item.from)}-${hex(item.to)}]`;
+        else if (item.type === "property")
+            atom = `\\${item.negated ? "P" : "p"}{${item.value}}`;
+        else {
+            const kind = item.kind === "digit" ? "d" : item.kind === "word" ? "w" : "s";
+            atom = `\\${item.negated ? kind.toUpperCase() : kind}`;
+        }
+        return new RegExp(`^(?:${atom})$`, (ignoreCase ? "i" : "") + (unicodeSets ? "v" : "u")).test(character);
+    }
+    if (item.type === "property")
+        return false;
     if (item.type === "character") {
         return charactersEqual(character, item.value, ignoreCase);
     }
@@ -147,10 +237,10 @@ function matchesCharacterClassItem(character, item, ignoreCase) {
         if (!ignoreCase) {
             return false;
         }
-        const foldedCandidate = foldCharacter(character, true).charCodeAt(0);
-        const foldedFrom = foldCharacter(item.from, true).charCodeAt(0);
-        const foldedTo = foldCharacter(item.to, true).charCodeAt(0);
-        return foldedCandidate >= foldedFrom && foldedCandidate <= foldedTo;
+        // Folding endpoints does not preserve range membership. Classify one UTF-16
+        // code unit using generated hex endpoints, never a guest pattern.
+        return new RegExp(`^[\\u${from.toString(16).padStart(4, "0")}-\\u${to.toString(16).padStart(4, "0")}]$`, "i")
+            .test(character);
     }
     const matched = item.kind === "digit"
         ? isDigit(character)
@@ -159,12 +249,107 @@ function matchesCharacterClassItem(character, item, ignoreCase) {
             : isSpaceCharacter(character);
     return item.negated ? !matched : matched;
 }
-function toRegexMatch(input, start, state) {
-    return {
+function matchUnicodeSet(set, position, context) {
+    charge(context);
+    let lengths = new Set();
+    for (let index = 0; index < set.items.length; index++) {
+        const next = matchUnicodeSetItem(set.items[index], position, context);
+        if (index === 0)
+            lengths = next;
+        else if (set.operation === undefined) {
+            for (const length of next) {
+                charge(context);
+                lengths.add(length);
+            }
+        }
+        else {
+            for (const length of lengths) {
+                charge(context);
+                if (set.operation === "intersection" ? !next.has(length) : next.has(length))
+                    lengths.delete(length);
+            }
+        }
+    }
+    if (set.negated) {
+        const character = readCharacter(context.input, position, context.direction, true);
+        return new Set(character !== undefined && !lengths.has(character.length) ? [character.length] : []);
+    }
+    return lengths;
+}
+function matchUnicodeSetItem(item, position, context) {
+    charge(context);
+    if (item.type === "set")
+        return matchUnicodeSet(item.value, position, context);
+    const lengths = new Set();
+    if (item.type === "strings") {
+        for (const value of item.values) {
+            charge(context);
+            let reference = context.direction === 1 ? 0 : value.length;
+            let cursor = position;
+            const end = context.direction === 1 ? value.length : 0;
+            while (reference !== end) {
+                charge(context);
+                const expected = readCharacter(value, reference, context.direction, true);
+                const actual = readCharacter(context.input, cursor, context.direction, true);
+                if (!charactersEqual(actual, expected, context.flags.ignoreCase, true))
+                    break;
+                reference += context.direction * expected.length;
+                cursor += context.direction * actual.length;
+            }
+            if (reference === end)
+                lengths.add(Math.abs(cursor - position));
+        }
+        return lengths;
+    }
+    if (item.type === "property" && item.strings) {
+        // A validated property atom denotes a finite Unicode string set. The host
+        // finds its longest member only; guest alternation/backtracking stays here.
+        const atom = `\\p{${item.value}}`;
+        const flags = (context.flags.ignoreCase ? "i" : "") + "v";
+        const matcher = new RegExp(context.direction === 1 ? atom : `(?<=(${atom}))`, flags + "y");
+        matcher.lastIndex = position;
+        const match = matcher.exec(context.input);
+        if (match === null)
+            return lengths;
+        const longest = context.direction === 1 ? match[0] : match[1];
+        const member = new RegExp(`^(?:${atom})$`, flags);
+        let consumed = 0;
+        while (consumed < longest.length) {
+            charge(context);
+            const cursor = context.direction === 1 ? consumed : longest.length - consumed;
+            consumed += readCharacter(longest, cursor, context.direction, true).length;
+            const candidate = context.direction === 1 ? longest.slice(0, consumed) : longest.slice(longest.length - consumed);
+            if (member.test(candidate))
+                lengths.add(consumed);
+        }
+        return lengths;
+    }
+    const character = readCharacter(context.input, position, context.direction, true);
+    if (character !== undefined && matchesCharacterClassItem(character, item, context.flags.ignoreCase, true, true))
+        lengths.add(character.length);
+    return lengths;
+}
+function toRegexMatch(input, start, state, hasIndices, groups) {
+    const match = {
         index: start,
         text: input.slice(start, state.position),
         captures: state.captures.map((capture) => capture === undefined ? undefined : input.slice(capture.start, capture.end))
     };
+    if (hasIndices) {
+        match.indices = [[start, state.position], ...state.captures.map((capture) => capture === undefined ? undefined : [capture.start, capture.end])];
+    }
+    if (groups !== undefined) {
+        match.groups = Object.create(null);
+        if (hasIndices)
+            match.indicesGroups = Object.create(null);
+        for (const [name, indices] of Object.entries(groups)) {
+            const index = indices.find(index => state.captures[index - 1] !== undefined);
+            match.groups[name] = index === undefined ? undefined : match.captures[index - 1];
+            if (match.indicesGroups !== undefined)
+                match.indicesGroups[name] = index === undefined ? undefined : match.indices[index];
+        }
+    }
+    return match;
 }
 function cloneState(state) {
     return { position: state.position, captures: state.captures.slice() };
@@ -194,13 +379,13 @@ function clearNodeCaptures(node, captures) {
         }
         return;
     }
-    if (node.type === "quantifier") {
+    if (node.type === "quantifier" || node.type === "lookahead" || node.type === "lookbehind") {
         clearNodeCaptures(node.body, captures);
     }
 }
 function charge(context) {
-    context.steps += 1;
-    allocateRegexSteps(context.steps);
+    context.work.steps += 1;
+    allocateRegexSteps(context.work.steps);
 }
 export function normalizeLastIndex(lastIndex) {
     if (Number.isNaN(lastIndex) || lastIndex <= 0) {
@@ -208,9 +393,24 @@ export function normalizeLastIndex(lastIndex) {
     }
     return Math.min(Math.floor(lastIndex), Number.MAX_SAFE_INTEGER);
 }
-function charactersEqual(left, right, ignoreCase) {
+function charactersEqual(left, right, ignoreCase, unicode = false) {
+    if (unicode && ignoreCase && left !== undefined)
+        return new RegExp(`^\\u{${right.codePointAt(0).toString(16)}}$`, "iu").test(left);
     return left !== undefined && foldCharacter(left, ignoreCase) === foldCharacter(right, ignoreCase);
 }
+export function advanceStringIndex(input, index, unicode) {
+    return index + (unicode && (input.codePointAt(index) ?? 0) > 0xffff ? 2 : 1);
+}
+function readCharacter(input, position, direction, unicode) {
+    let index = direction === 1 ? position : position - 1;
+    if (index < 0 || index >= input.length)
+        return undefined;
+    if (unicode && direction === -1 && index > 0 &&
+        input.charCodeAt(index) >= 0xdc00 && input.charCodeAt(index) <= 0xdfff &&
+        input.charCodeAt(index - 1) >= 0xd800 && input.charCodeAt(index - 1) <= 0xdbff)
+        index--;
+    return unicode ? String.fromCodePoint(input.codePointAt(index)) : input[index];
+}
 function foldCharacter(character, ignoreCase) {
     if (!ignoreCase) {
         return character;