poe-code 14.0.73 → 14.0.75

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

@@ -9,11 +9,14 @@ export declare function getGuestFunctionProperty(closure: SandboxClosure, key: P
 export declare function installObjectPrototype(budget: Budget, prototype: SandboxObject, constructor: SandboxClosure): void;
 export declare function installBoxedPrototype(budget: Budget, prototype: SandboxObject, constructor: SandboxClosure, kind?: BoxedKind): void;
 export declare function getBoxedPrototype(value: BoxedPrimitive, budget: Budget): SandboxObject | undefined;
+export declare function installRegexPrototype(budget: Budget, prototype: SandboxObject, constructor: SandboxClosure): void;
+export declare function hasRegexPropertyOverride(value: SandboxValue, keys: readonly string[], budget: Budget): boolean;
 export declare function isDefaultBoxedMethod(value: BoxedPrimitive, key: string, budget: Budget): boolean;
 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

@@ -9,6 +9,8 @@ const functionProperties = new WeakMap();
 const prototypes = new WeakMap();
 const intrinsicPrototypes = new WeakMap();
 const boxedPrototypes = new WeakMap();
+const regexPrototypes = new WeakMap();
+const initialRegexDescriptors = new WeakMap();
 const intrinsicPrototypeRoots = new WeakMap();
 const intrinsicConstructors = new WeakMap();
 const initialBoxedMethods = new WeakMap();
@@ -80,6 +82,24 @@ export function installBoxedPrototype(budget, prototype, constructor, kind = typ
 export function getBoxedPrototype(value, budget) {
     return boxedPrototypes.get(budget)?.get(typeof value);
 }
+export function installRegexPrototype(budget, prototype, constructor) {
+    regexPrototypes.set(budget, prototype);
+    initialRegexDescriptors.set(budget, Object.getOwnPropertyDescriptors(prototype));
+    registerIntrinsicPrototype(budget, prototype, constructor);
+}
+export function hasRegexPropertyOverride(value, keys, budget) {
+    const initial = initialRegexDescriptors.get(budget);
+    const prototype = regexPrototypes.get(budget);
+    const defaultPrototype = isSandboxRegex(value) && prototype !== undefined && getSandboxPrototype(value, budget) === prototype;
+    return keys.some(key => {
+        const current = defaultPrototype
+            ? Object.getOwnPropertyDescriptor(getRegexProperties(value), key) ?? Object.getOwnPropertyDescriptor(prototype, key)
+            : getSandboxPropertyDescriptor(value, key, budget);
+        const expected = initial?.[key];
+        return expected === undefined ? current !== undefined : current === undefined ||
+            current.value !== expected.value || current.get !== expected.get || current.set !== expected.set;
+    });
+}
 export function isDefaultBoxedMethod(value, key, budget) {
     const prototype = getBoxedPrototype(value, budget);
     return prototype !== undefined && initialBoxedMethods.get(prototype)?.has(key) === true &&
@@ -93,7 +113,10 @@ function registerIntrinsicPrototype(budget, prototype, constructor) {
     if (roots === undefined)
         intrinsicPrototypeRoots.set(budget, (roots = new Set()));
     roots.add(prototype);
-    const records = [prototype, constructor]
+    const methods = Reflect.ownKeys(prototype)
+        .map(key => Object.getOwnPropertyDescriptor(prototype, key)?.value)
+        .filter(isGuestClosure);
+    const records = [...new Set([prototype, constructor, ...methods])]
         .map((target) => ({
         target,
         value: isGuestClosure(target) ? materializeFunctionProperties(target) : target,
@@ -102,7 +125,7 @@ function registerIntrinsicPrototype(budget, prototype, constructor) {
     }))
         .map((record) => ({
         ...record,
-        descriptors: new Map(Object.entries(Object.getOwnPropertyDescriptors(record.value)))
+        descriptors: new Map(Reflect.ownKeys(record.value).map(key => [key, Object.getOwnPropertyDescriptor(record.value, key)]))
     }));
     const unchanged = (before, after) => before !== undefined &&
         after !== undefined &&
@@ -116,16 +139,19 @@ function registerIntrinsicPrototype(budget, prototype, constructor) {
         const current = Object.getOwnPropertyDescriptors(value);
         return (getSandboxPrototype(target) === parent &&
             hasExplicitSandboxPrototype(target) === explicit &&
-            Object.keys(current).length === descriptors.size &&
-            Object.keys(current).every((key) => unchanged(descriptors.get(key), current[key])));
+            Reflect.ownKeys(current).length === descriptors.size &&
+            Reflect.ownKeys(value).every((key) => unchanged(descriptors.get(key), Object.getOwnPropertyDescriptor(value, key))));
     }));
     budget.setRetainedValues(prototype, () => records.flatMap(({ target, value, descriptors, prototype: parent }) => [
         ...(getSandboxPrototype(target) === parent
             ? []
             : [getSandboxPrototype(target)]),
-        ...Object.entries(Object.getOwnPropertyDescriptors(value)).flatMap(([key, descriptor]) => unchanged(descriptors.get(key), descriptor)
-            ? []
-            : [key, descriptor.value, ...retainedAccessorClosures(descriptor)])
+        ...Reflect.ownKeys(value).flatMap(key => {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            return unchanged(descriptors.get(key), descriptor)
+                ? []
+                : [key, descriptor.value, ...retainedAccessorClosures(descriptor)];
+        })
     ]));
 }
 export function releaseObjectPrototype(budget) {
@@ -133,11 +159,15 @@ export function releaseObjectPrototype(budget) {
         budget.setRetainedValues(prototype, undefined);
     intrinsicPrototypeRoots.delete(budget);
     boxedPrototypes.delete(budget);
+    regexPrototypes.delete(budget);
+    initialRegexDescriptors.delete(budget);
     intrinsicPrototypes.delete(budget);
 }
 export function getSandboxPrototype(value, budget) {
     if (prototypes.has(value))
         return prototypes.get(value) ?? null;
+    if (budget !== undefined && isSandboxRegex(value))
+        return regexPrototypes.get(budget) ?? null;
     if (budget !== undefined && isSandboxBox(value)) {
         const prototype = getBoxedPrototype(boxedValue(value), budget);
         if (prototype !== undefined && prototype !== value)
@@ -150,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))
@@ -213,13 +246,13 @@ export function setSandboxPrototype(value, prototype, budget) {
     if (budget !== undefined && intrinsicPrototypes.get(budget) === value && prototype !== null) {
         throw new TypeError("Object.prototype has an immutable null prototype.");
     }
-    if ((!Array.isArray(value) && !isPrototypeRecord(value)) ||
+    if ((!Array.isArray(value) && !isSandboxRegex(value) && !isPrototypeRecord(value)) ||
         (prototype !== null && !Array.isArray(prototype) && !isPrototypeRecord(prototype))) {
         throw new TypeError("Prototype links require ordinary sandbox objects, arrays, or guest functions.");
     }
     if (prototypes.has(value) && getSandboxPrototype(value, budget) === prototype)
         return;
-    if (!Object.isExtensible(isGuestClosure(value) ? materializeFunctionProperties(value) : value)) {
+    if (!Object.isExtensible(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : value)) {
         throw new TypeError("Cannot change the prototype of a non-extensible object.");
     }
     let depth = 0;
@@ -258,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;