poe-code 14.0.74 → 14.0.75

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;

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

@@ -1,11 +1,16 @@
 import { type CompileScope } from "./compile-guard.js";
 export type RegexFlags = {
+    hasIndices: boolean;
     global: boolean;
+    sticky: boolean;
+    unicode: boolean;
+    unicodeSets: boolean;
     ignoreCase: boolean;
     multiline: boolean;
     dotAll: boolean;
 };
 export type CharacterKind = "digit" | "word" | "space";
+type RegexModifiers = Partial<Pick<RegexFlags, "ignoreCase" | "multiline" | "dotAll">>;
 export type CharacterClassItem = {
     type: "character";
     value: string;
@@ -17,12 +22,35 @@ export type CharacterClassItem = {
     type: "kind";
     kind: CharacterKind;
     negated: boolean;
+} | {
+    type: "property";
+    value: string;
+    negated: boolean;
+    strings?: boolean;
+} | {
+    type: "strings";
+    values: string[];
+} | {
+    type: "set";
+    value: CharacterSet;
+};
+export type CharacterSet = {
+    negated: boolean;
+    items: CharacterClassItem[];
+    operation?: "intersection" | "subtraction";
+    strings?: boolean;
 };
 export type RegexNode = {
     type: "empty";
 } | {
     type: "literal";
     value: string;
+} | {
+    type: "backreference";
+    index: number;
+} | {
+    type: "namedBackreference";
+    name: string;
 } | {
     type: "dot";
 } | {
@@ -31,11 +59,9 @@ export type RegexNode = {
 } | {
     type: "wordBoundary";
     negated: boolean;
-} | {
+} | ({
     type: "characterClass";
-    negated: boolean;
-    items: CharacterClassItem[];
-} | {
+} & CharacterSet) | {
     type: "sequence";
     elements: RegexNode[];
 } | {
@@ -45,6 +71,16 @@ export type RegexNode = {
     type: "group";
     capturing: boolean;
     index?: number;
+    name?: string;
+    modifiers?: RegexModifiers;
+    body: RegexNode;
+} | {
+    type: "lookahead";
+    negated: boolean;
+    body: RegexNode;
+} | {
+    type: "lookbehind";
+    negated: boolean;
     body: RegexNode;
 } | {
     type: "quantifier";
@@ -58,5 +94,7 @@ export type RegexPattern = {
     flags: RegexFlags;
     captureCount: number;
     body: RegexNode;
+    groups?: Record<string, number[]>;
 };
 export declare function parseRegex(source: string, flags?: string, compilation?: CompileScope, valueUnits?: number): RegexPattern;
+export {};