regex-partial-match 1.3.0 → 2.0.0

package/lib/partialMatchRegExp/scope.d.ts

@@ -0,0 +1,12 @@
+export declare const CASE_INSENSITIVE = 1;
+export declare const MULTILINE = 2;
+export declare const DOT_ALL = 4;
+export declare const UNICODE = 8;
+export declare const UNICODE_SETS = 16;
+export declare const WITHIN_LOOKAROUND = 32;
+export declare const WITHIN_GROUP = 64;
+export declare const WITHIN_RAW_LOOKAROUND = 128;
+export declare function scopeOf(regex: RegExp): number;
+export type ModifiersHook = (scope: number, modifiers: string) => number;
+export declare function scopeWithModifiers(scope: number, modifiers: string): number;
+export declare function flagsOf(scope: number): string;

package/lib/partialMatchRegExp/scope.js

@@ -0,0 +1,45 @@
+export const CASE_INSENSITIVE = 1;
+export const MULTILINE = 2;
+export const DOT_ALL = 4;
+export const UNICODE = 8;
+export const UNICODE_SETS = 16;
+export const WITHIN_LOOKAROUND = 32;
+export const WITHIN_GROUP = 64;
+export const WITHIN_RAW_LOOKAROUND = 128;
+const MODIFIER_REMOVAL = "-";
+function modifierBit(modifier) {
+    switch (modifier) {
+        case "i":
+            return CASE_INSENSITIVE;
+        case "m":
+            return MULTILINE;
+        default:
+            return DOT_ALL;
+    }
+}
+export function scopeOf(regex) {
+    return ((regex.ignoreCase ? CASE_INSENSITIVE : 0) |
+        (regex.multiline ? MULTILINE : 0) |
+        (regex.dotAll ? DOT_ALL : 0) |
+        (regex.unicode ? UNICODE : 0) |
+        (regex.unicodeSets ? UNICODE | UNICODE_SETS : 0));
+}
+export function scopeWithModifiers(scope, modifiers) {
+    let removing = false;
+    for (let index = 0; index < modifiers.length; index++) {
+        const modifier = modifiers[index];
+        if (modifier === MODIFIER_REMOVAL)
+            removing = true;
+        else if (removing)
+            scope &= ~modifierBit(modifier);
+        else
+            scope |= modifierBit(modifier);
+    }
+    return scope;
+}
+export function flagsOf(scope) {
+    return ((scope & CASE_INSENSITIVE ? "i" : "") +
+        (scope & MULTILINE ? "m" : "") +
+        (scope & DOT_ALL ? "s" : "") +
+        (scope & UNICODE_SETS ? "v" : scope & UNICODE ? "u" : ""));
+}

package/lib/partialMatchRegExp/walk.d.ts

@@ -1,8 +1,16 @@
-import type { Part, RawLookaroundInfo } from "./part.ts";
-export declare function walk(regex: RegExp, declaresNamedGroup: boolean): {
+import type { Part } from "./part.ts";
+import { type CaretHook, type CaretRecorder } from "./caretHook.ts";
+import type { BackreferenceRecorder, BackreferenceHook } from "./backreferenceHook.ts";
+import type { RawLookaroundInfo } from "./rawLookaroundInfo.ts";
+import { type ModifiersHook } from "./scope.ts";
+export interface Hooks {
+    caret?: CaretHook;
+    backreference?: BackreferenceHook;
+    modifiers?: ModifiersHook;
+}
+export declare function walk(regex: RegExp, declaresNamedGroup: boolean, groupLimit: number, caretRecorder: CaretRecorder | undefined, backreferenceRecorder: BackreferenceRecorder | undefined, withModifiers: Hooks["modifiers"]): {
     parts: Part[];
-    groupCount: number;
     featureMask: number;
-    rawLookarounds: readonly RawLookaroundInfo[];
-    namedGroupOpenings: readonly string[];
+    needs: number;
+    rawLookarounds: RawLookaroundInfo[] | undefined;
 };

package/lib/partialMatchRegExp/walk.js

@@ -1,69 +1,95 @@
-import { DISJUNCTION_TO_END_OF_INPUT, OPTIONAL_ATOM_OPENING } from "./atomSyntax.js";
-import { groupNameOf, decodeGroupName } from "./groupName.js";
-import { FEATURE_BIT } from "./regexFeatures.js";
-const OCCURRENCES_REGEX = /\{\d+,?\d*\}/y;
-const NOT_NUMBERS_REGEX = /\D/g;
-const LITERAL_K_ATOM = OPTIONAL_ATOM_OPENING + "k" + DISJUNCTION_TO_END_OF_INPUT;
-const NO_RAW_LOOKAROUNDS = [];
-const NO_NAMED_GROUP_OPENINGS = [];
-const declaresGroupNamed = (closedGroupNames, name) => { var _a; return (_a = closedGroupNames === null || closedGroupNames === void 0 ? void 0 : closedGroupNames.has(decodeGroupName(name))) !== null && _a !== void 0 ? _a : false; };
-export function walk(regex, declaresNamedGroup) {
+import { NOT_NUMBERS_REGEX, LITERAL_BACKSLASH, LITERAL_K } from "./constants.js";
+import { asOptionalAtom, isWordBoundaryAtom, DISJUNCTION_TO_END_OF_INPUT, END_ANCHOR, isRawLookaround, GROUP_CLOSING, LOOKAHEAD_OPENING, START_ANCHOR } from "./atomSyntax.js";
+import { legacyEscapeAtoms } from "./legacyEscape.js";
+import { ON_ALTERNATIVE, ON_CARET, ON_END, ON_GROUP, ON_LOOKAHEAD } from "./caretHook.js";
+import { BACKREFERENCES_MODULE, CARETS_MODULE } from "./moduleHooks.js";
+import { OCCURRENCES_REGEX } from "./quantifier.js";
+import { MULTILINE, UNICODE, UNICODE_SETS, WITHIN_GROUP, WITHIN_LOOKAROUND, WITHIN_RAW_LOOKAROUND, scopeOf } from "./scope.js";
+const ASCII_LETTER = /[a-z]/iy;
+const TWO_HEX_DIGITS = /[0-9a-f]{2}/iy;
+const FOUR_HEX_DIGITS = /[0-9a-f]{4}/iy;
+function matchesAt(source, start, pattern) {
+    pattern.lastIndex = start;
+    return pattern.test(source);
+}
+const isZeroWidth = (part) => typeof part === "string" &&
+    (part === START_ANCHOR ||
+        part === END_ANCHOR ||
+        isWordBoundaryAtom(part) ||
+        isRawLookaround(part));
+export function walk(regex, declaresNamedGroup, groupLimit, caretRecorder, backreferenceRecorder, withModifiers) {
     const source = regex.source;
-    const isUnicode = regex.unicode || regex.unicodeSets;
     let i = 0;
     let groupCount = 0;
     let featureMask = 0;
+    let needs = 0;
+    let rawLookaroundCount = 0;
+    let outermostRawLookaroundCount = 0;
     let rawLookarounds;
-    let namedGroupOpenings;
-    let closedGroupNumbers;
-    let closedGroupNames;
-    let namedBackreferencesSeen;
-    let currentRawLookaroundBackreferences;
+    let rawReferences;
+    let lastBodyRunsOut = false;
     function extractSlice(length) {
         return source.slice(i, (i += length));
     }
-    function process(withinLookaround, declaresNamedGroup, caseInsensitive) {
+    function process(scope) {
+        var _a;
         const result = [];
+        const caretFrame = caretRecorder === null || caretRecorder === void 0 ? void 0 : caretRecorder(result, scope);
+        let alternativeStart = 0;
+        let alternativeRunsOut = false;
+        let everyAlternativeRunsOut = true;
         function appendOptional(length) {
-            result.push("(?:" + extractSlice(length) + DISJUNCTION_TO_END_OF_INPUT);
+            if (result.length === alternativeStart)
+                alternativeRunsOut = true;
+            result.push(asOptionalAtom(extractSlice(length)));
         }
         function appendRaw(length) {
             result.push(extractSlice(length));
         }
+        function appendBackreference(backreference) {
+            if (backreferenceRecorder)
+                backreferenceRecorder.backreference(backreference, scope);
+            else if (!(scope & WITHIN_RAW_LOOKAROUND))
+                needs |= BACKREFERENCES_MODULE;
+            result.push(backreference);
+        }
         function appendDigitRun(forcedRef) {
-            featureMask |= FEATURE_BIT.backreference;
+            if (result.length === alternativeStart)
+                alternativeRunsOut = true;
+            featureMask |= 512 /* Feature.backreference */;
             NOT_NUMBERS_REGEX.lastIndex = i + 1;
             const nextNonDigit = NOT_NUMBERS_REGEX.exec(source);
             const start = i;
             const end = nextNonDigit ? nextNonDigit.index : source.length;
             const ref = forcedRef !== null && forcedRef !== void 0 ? forcedRef : Number(source.slice(start + 1, end));
             i = end;
-            const backreference = {
-                ref,
-                start,
-                end,
-                forward: !(closedGroupNumbers === null || closedGroupNumbers === void 0 ? void 0 : closedGroupNumbers.has(ref)),
-                caseInsensitive
-            };
-            result.push(backreference);
-            currentRawLookaroundBackreferences === null || currentRawLookaroundBackreferences === void 0 ? void 0 : currentRawLookaroundBackreferences.push(backreference);
+            if (scope & WITHIN_RAW_LOOKAROUND)
+                (rawReferences !== null && rawReferences !== void 0 ? rawReferences : (rawReferences = [])).push({ ref, start, end });
+            if (ref >= 1 && ref <= groupLimit) {
+                appendBackreference({ ref });
+                return;
+            }
+            for (const atom of legacyEscapeAtoms(source.slice(start + 1, end))) {
+                result.push(asOptionalAtom(atom));
+            }
         }
         function appendRawLookaround(prefixLength) {
             const start = i;
             i += prefixLength;
             const groupCountBefore = groupCount;
-            const isOutermost = currentRawLookaroundBackreferences === undefined;
-            const backreferences = currentRawLookaroundBackreferences !== null && currentRawLookaroundBackreferences !== void 0 ? currentRawLookaroundBackreferences : [];
-            if (isOutermost)
-                currentRawLookaroundBackreferences = backreferences;
-            process(true, declaresNamedGroup, caseInsensitive);
-            if (isOutermost) {
-                (rawLookarounds !== null && rawLookarounds !== void 0 ? rawLookarounds : (rawLookarounds = [])).push({
-                    sourceStart: start,
-                    capturingGroupsOpened: groupCount - groupCountBefore,
-                    backreferences
-                });
-                currentRawLookaroundBackreferences = undefined;
+            rawLookaroundCount++;
+            process(scope | WITHIN_LOOKAROUND | WITHIN_RAW_LOOKAROUND);
+            if (!(scope & WITHIN_RAW_LOOKAROUND)) {
+                const capturingGroupsOpened = groupCount - groupCountBefore;
+                if (rawReferences || capturingGroupsOpened) {
+                    (rawLookarounds !== null && rawLookarounds !== void 0 ? rawLookarounds : (rawLookarounds = []))[outermostRawLookaroundCount] = {
+                        sourceStart: start,
+                        capturingGroupsOpened,
+                        references: rawReferences !== null && rawReferences !== void 0 ? rawReferences : []
+                    };
+                    rawReferences = undefined;
+                }
+                outermostRawLookaroundCount++;
             }
             result.push(source.slice(start, i));
         }
@@ -72,56 +98,51 @@ export function walk(regex, declaresNamedGroup) {
                 case "\\":
                     switch (source[i + 1]) {
                         case "c":
-                            featureMask |= FEATURE_BIT.controlLetterEscape;
-                            appendOptional(3);
+                            if (scope & UNICODE || matchesAt(source, i + 2, ASCII_LETTER)) {
+                                featureMask |= 67108864 /* Feature.controlLetterEscape */;
+                                appendOptional(3);
+                            }
+                            else {
+                                featureMask |= 536870912 /* Feature.otherEscape */;
+                                i++;
+                                if (result.length === alternativeStart)
+                                    alternativeRunsOut = true;
+                                result.push(asOptionalAtom(LITERAL_BACKSLASH));
+                            }
                             break;
                         case "k": {
                             const referenceEnd = source[i + 2] === "<" ? source.indexOf(">", i) : -1;
                             if (referenceEnd !== -1 && declaresNamedGroup) {
-                                featureMask |= FEATURE_BIT.namedBackreference;
-                                const start = i;
+                                featureMask |= 1024 /* Feature.namedBackreference */;
                                 const ref = source.slice(i + 3, referenceEnd);
                                 i = referenceEnd + 1;
-                                const namedBackreference = {
-                                    ref,
-                                    start,
-                                    end: i,
-                                    forward: !declaresGroupNamed(closedGroupNames, ref),
-                                    caseInsensitive
-                                };
-                                result.push(namedBackreference);
-                                currentRawLookaroundBackreferences === null || currentRawLookaroundBackreferences === void 0 ? void 0 : currentRawLookaroundBackreferences.push(namedBackreference);
-                                (namedBackreferencesSeen !== null && namedBackreferencesSeen !== void 0 ? namedBackreferencesSeen : (namedBackreferencesSeen = [])).push(namedBackreference);
-                            }
-                            else if (currentRawLookaroundBackreferences) {
-                                const start = i;
-                                i += 2;
-                                currentRawLookaroundBackreferences.push({
-                                    ref: "",
-                                    start,
-                                    end: i,
-                                    caseInsensitive
-                                });
+                                if (result.length === alternativeStart)
+                                    alternativeRunsOut = true;
+                                appendBackreference({ ref });
                             }
                             else {
-                                result.push(LITERAL_K_ATOM);
                                 i += 2;
+                                if (result.length === alternativeStart)
+                                    alternativeRunsOut = true;
+                                result.push(asOptionalAtom(LITERAL_K));
                             }
                             break;
                         }
                         case "u":
-                            featureMask |= FEATURE_BIT.unicodeEscapeSequence;
-                            if (isUnicode && source[i + 2] === "{") {
-                                appendOptional(source.indexOf("}", i) - i + 1);
+                            if (scope & UNICODE ||
+                                matchesAt(source, i + 2, FOUR_HEX_DIGITS)) {
+                                featureMask |= 268435456 /* Feature.unicodeEscapeSequence */;
+                                appendOptional(source[i + 2] === "{" ? source.indexOf("}", i) - i + 1 : 6);
                             }
                             else {
-                                appendOptional(6);
+                                featureMask |= 536870912 /* Feature.otherEscape */;
+                                appendOptional(2);
                             }
                             break;
                         case "p":
                         case "P":
-                            if (isUnicode) {
-                                featureMask |= FEATURE_BIT.unicodePropertyEscape;
+                            if (scope & UNICODE) {
+                                featureMask |= 8388608 /* Feature.unicodePropertyEscape */;
                                 appendOptional(source.indexOf("}", i) - i + 1);
                             }
                             else {
@@ -129,15 +150,21 @@ export function walk(regex, declaresNamedGroup) {
                             }
                             break;
                         case "x":
-                            featureMask |= FEATURE_BIT.hexEscapeSequence;
-                            appendOptional(4);
+                            if (scope & UNICODE || matchesAt(source, i + 2, TWO_HEX_DIGITS)) {
+                                featureMask |= 134217728 /* Feature.hexEscapeSequence */;
+                                appendOptional(4);
+                            }
+                            else {
+                                featureMask |= 536870912 /* Feature.otherEscape */;
+                                appendOptional(2);
+                            }
                             break;
                         case "b":
-                            featureMask |= FEATURE_BIT.wordBoundary;
+                            featureMask |= 8 /* Feature.wordBoundary */;
                             appendOptional(2);
                             break;
                         case "B":
-                            featureMask |= FEATURE_BIT.nonWordBoundary;
+                            featureMask |= 16 /* Feature.nonWordBoundary */;
                             appendOptional(2);
                             break;
                         case "f":
@@ -145,12 +172,12 @@ export function walk(regex, declaresNamedGroup) {
                         case "r":
                         case "t":
                         case "v":
-                            featureMask |= FEATURE_BIT.controlEscape;
+                            featureMask |= 33554432 /* Feature.controlEscape */;
                             appendOptional(2);
                             break;
                         case "0":
-                            if (isUnicode) {
-                                featureMask |= FEATURE_BIT.otherEscape;
+                            if (scope & UNICODE) {
+                                featureMask |= 536870912 /* Feature.otherEscape */;
                                 appendOptional(2);
                             }
                             else {
@@ -174,17 +201,17 @@ export function walk(regex, declaresNamedGroup) {
                         case "W":
                         case "s":
                         case "S":
-                            featureMask |= FEATURE_BIT.characterClassEscape;
+                            featureMask |= 16777216 /* Feature.characterClassEscape */;
                             appendOptional(2);
                             break;
                         default:
-                            featureMask |= FEATURE_BIT.otherEscape;
+                            featureMask |= 536870912 /* Feature.otherEscape */;
                             appendOptional(2);
                             break;
                     }
                     break;
                 case "[": {
-                    featureMask |= FEATURE_BIT.characterClass;
+                    featureMask |= 131072 /* Feature.characterClass */;
                     let depth = 1, j = i + 1, previousSetOperatorCharacter;
                     while (depth) {
                         const character = source[j];
@@ -194,8 +221,8 @@ export function walk(regex, declaresNamedGroup) {
                                 previousSetOperatorCharacter = undefined;
                                 continue;
                             case "[":
-                                if (regex.unicodeSets) {
-                                    featureMask |= FEATURE_BIT.nestedCharacterClass;
+                                if (scope & UNICODE_SETS) {
+                                    featureMask |= 262144 /* Feature.nestedCharacterClass */;
                                     depth++;
                                 }
                                 break;
@@ -203,13 +230,15 @@ export function walk(regex, declaresNamedGroup) {
                                 depth--;
                                 break;
                             case "&":
-                                if (regex.unicodeSets && previousSetOperatorCharacter === "&") {
-                                    featureMask |= FEATURE_BIT.classIntersection;
+                                if (scope & UNICODE_SETS &&
+                                    previousSetOperatorCharacter === "&") {
+                                    featureMask |= 524288 /* Feature.classIntersection */;
                                 }
                                 break;
                             case "-":
-                                if (regex.unicodeSets && previousSetOperatorCharacter === "-") {
-                                    featureMask |= FEATURE_BIT.classSubtraction;
+                                if (scope & UNICODE_SETS &&
+                                    previousSetOperatorCharacter === "-") {
+                                    featureMask |= 1048576 /* Feature.classSubtraction */;
                                 }
                                 break;
                         }
@@ -219,29 +248,47 @@ export function walk(regex, declaresNamedGroup) {
                     appendOptional(j - i);
                     break;
                 }
-                case "^":
-                    featureMask |= FEATURE_BIT.startAnchor;
-                    appendRaw(1);
+                case "^": {
+                    featureMask |= 2 /* Feature.startAnchor */;
+                    i++;
+                    const leadsAlternative = result.length === alternativeStart;
+                    if (caretFrame)
+                        caretFrame(ON_CARET);
+                    else {
+                        if (!(scope & WITHIN_RAW_LOOKAROUND) &&
+                            (scope & (WITHIN_GROUP | WITHIN_LOOKAROUND) ||
+                                (scope & MULTILINE &&
+                                    !result.slice(alternativeStart).every(isZeroWidth))))
+                            needs |= CARETS_MODULE;
+                        result.push(START_ANCHOR);
+                    }
+                    if (leadsAlternative)
+                        alternativeStart = result.length;
                     break;
+                }
                 case "$":
-                    featureMask |= FEATURE_BIT.endAnchor;
+                    featureMask |= 4 /* Feature.endAnchor */;
                     appendRaw(1);
                     break;
                 case "|":
-                    featureMask |= FEATURE_BIT.disjunction;
+                    featureMask |= 2097152 /* Feature.disjunction */;
+                    caretFrame === null || caretFrame === void 0 ? void 0 : caretFrame(ON_ALTERNATIVE);
+                    everyAlternativeRunsOut && (everyAlternativeRunsOut = alternativeRunsOut || result.length === alternativeStart);
+                    alternativeRunsOut = false;
+                    alternativeStart = result.length + 1;
                     appendRaw(1);
                     break;
                 case "*":
                 case "+":
                 case "?":
-                    featureMask |= FEATURE_BIT.quantifier;
+                    featureMask |= 4194304 /* Feature.quantifier */;
                     appendRaw(1);
                     break;
                 case "{": {
                     OCCURRENCES_REGEX.lastIndex = i;
                     const regExpExecArray = OCCURRENCES_REGEX.exec(source);
                     if (regExpExecArray) {
-                        featureMask |= FEATURE_BIT.quantifier;
+                        featureMask |= 4194304 /* Feature.quantifier */;
                         appendRaw(regExpExecArray[0].length);
                     }
                     else {
@@ -249,118 +296,117 @@ export function walk(regex, declaresNamedGroup) {
                     }
                     break;
                 }
-                case "(":
+                case "(": {
+                    let opening;
+                    let groupScope = scope;
+                    let closing = DISJUNCTION_TO_END_OF_INPUT;
+                    let groupNumber = 0;
                     if (source[i + 1] == "?") {
                         switch (source[i + 2]) {
                             case ":":
-                                featureMask |= FEATURE_BIT.nonCapturingGroup;
-                                result.push("(?:");
-                                i += 3;
-                                result.push(...process(withinLookaround, declaresNamedGroup, caseInsensitive), DISJUNCTION_TO_END_OF_INPUT);
+                                featureMask |= 16384 /* Feature.nonCapturingGroup */;
+                                opening = extractSlice(3);
                                 break;
-                            case "=":
-                                featureMask |= FEATURE_BIT.lookahead;
-                                result.push("(?=");
+                            case "=": {
+                                featureMask |= 32 /* Feature.lookahead */;
                                 i += 3;
-                                result.push(...process(true, declaresNamedGroup, caseInsensitive), ")");
+                                const body = process(scope | WITHIN_LOOKAROUND);
+                                caretFrame === null || caretFrame === void 0 ? void 0 : caretFrame(ON_LOOKAHEAD, body, scope, source, i);
+                                result.push(LOOKAHEAD_OPENING, ...body, GROUP_CLOSING);
                                 break;
+                            }
                             case "-":
                             case "i":
                             case "s":
                             case "m": {
                                 const flagsStart = i + 2, colonIndex = source.indexOf(":", flagsStart);
                                 const modifiers = source.slice(flagsStart, colonIndex);
-                                const [additions, removals] = modifiers.split("-");
-                                featureMask |= removals
-                                    ? FEATURE_BIT.modifierGroupWithRemoval
-                                    : FEATURE_BIT.modifierGroup;
-                                const modifierGroupCaseInsensitive = (removals === null || removals === void 0 ? void 0 : removals.includes("i"))
-                                    ? false
-                                    : caseInsensitive || additions.includes("i");
-                                result.push("(?" + modifiers + ":");
-                                i = colonIndex + 1;
-                                result.push(...process(withinLookaround, declaresNamedGroup, modifierGroupCaseInsensitive), ")");
+                                const removalIndex = modifiers.indexOf("-");
+                                featureMask |=
+                                    removalIndex === -1 || removalIndex === modifiers.length - 1
+                                        ? 32768 /* Feature.modifierGroup */
+                                        : 65536 /* Feature.modifierGroupWithRemoval */;
+                                groupScope = (_a = withModifiers === null || withModifiers === void 0 ? void 0 : withModifiers(scope, modifiers)) !== null && _a !== void 0 ? _a : scope;
+                                closing = GROUP_CLOSING;
+                                opening = extractSlice(colonIndex + 1 - i);
                                 break;
                             }
                             case "!":
-                                featureMask |= FEATURE_BIT.negativeLookahead;
+                                featureMask |= 64 /* Feature.negativeLookahead */;
                                 appendRawLookaround(3);
                                 break;
                             case "<":
                                 switch (source[i + 3]) {
                                     case "=":
-                                        featureMask |= FEATURE_BIT.lookbehind;
+                                        featureMask |= 128 /* Feature.lookbehind */;
                                         appendRawLookaround(4);
                                         break;
                                     case "!":
-                                        featureMask |= FEATURE_BIT.negativeLookbehind;
+                                        featureMask |= 256 /* Feature.negativeLookbehind */;
                                         appendRawLookaround(4);
                                         break;
-                                    default: {
-                                        featureMask |= FEATURE_BIT.namedGroup;
-                                        featureMask |= FEATURE_BIT.capturingGroup;
-                                        if (withinLookaround)
-                                            featureMask |= FEATURE_BIT.lookaroundCapture;
-                                        const groupNumber = ++groupCount;
-                                        const opening = extractSlice(source.indexOf(">", i) - i + 1);
-                                        (namedGroupOpenings !== null && namedGroupOpenings !== void 0 ? namedGroupOpenings : (namedGroupOpenings = [])).push(opening);
-                                        const declaredName = decodeGroupName(groupNameOf(opening));
-                                        result.push(opening);
-                                        result.push(...process(withinLookaround, declaresNamedGroup, caseInsensitive), DISJUNCTION_TO_END_OF_INPUT);
-                                        (closedGroupNumbers !== null && closedGroupNumbers !== void 0 ? closedGroupNumbers : (closedGroupNumbers = new Set())).add(groupNumber);
-                                        (closedGroupNames !== null && closedGroupNames !== void 0 ? closedGroupNames : (closedGroupNames = new Set())).add(declaredName);
+                                    default:
+                                        featureMask |= 2048 /* Feature.namedGroup */;
+                                        featureMask |= 4096 /* Feature.capturingGroup */;
+                                        if (scope & WITHIN_LOOKAROUND)
+                                            featureMask |= 8192 /* Feature.lookaroundCapture */;
+                                        groupNumber = ++groupCount;
+                                        opening = extractSlice(source.indexOf(">", i) - i + 1);
                                         break;
-                                    }
                                 }
                                 break;
                         }
                     }
                     else {
-                        featureMask |= FEATURE_BIT.capturingGroup;
-                        if (withinLookaround)
-                            featureMask |= FEATURE_BIT.lookaroundCapture;
-                        const groupNumber = ++groupCount;
-                        appendRaw(1);
-                        result.push(...process(withinLookaround, declaresNamedGroup, caseInsensitive), DISJUNCTION_TO_END_OF_INPUT);
-                        (closedGroupNumbers !== null && closedGroupNumbers !== void 0 ? closedGroupNumbers : (closedGroupNumbers = new Set())).add(groupNumber);
+                        featureMask |= 4096 /* Feature.capturingGroup */;
+                        if (scope & WITHIN_LOOKAROUND)
+                            featureMask |= 8192 /* Feature.lookaroundCapture */;
+                        groupNumber = ++groupCount;
+                        opening = extractSlice(1);
                     }
+                    if (opening === undefined)
+                        break;
+                    const opensAlternative = result.length === alternativeStart;
+                    const rawLookaroundsBefore = rawLookaroundCount;
+                    const body = process(groupScope | WITHIN_GROUP);
+                    const runsOut = lastBodyRunsOut;
+                    const containsRawLookaround = rawLookaroundCount !== rawLookaroundsBefore;
+                    const caretGroup = caretFrame === null || caretFrame === void 0 ? void 0 : caretFrame(ON_GROUP, body, groupScope, source, i, closing, containsRawLookaround);
+                    if (caretGroup)
+                        closing = caretGroup.closing;
+                    if (!containsRawLookaround && runsOut && !(caretGroup === null || caretGroup === void 0 ? void 0 : caretGroup.forced)) {
+                        closing = GROUP_CLOSING;
+                        if (opensAlternative && !(caretGroup === null || caretGroup === void 0 ? void 0 : caretGroup.stays))
+                            alternativeRunsOut = true;
+                    }
+                    else if (containsRawLookaround)
+                        closing = DISJUNCTION_TO_END_OF_INPUT;
+                    result.push(opening, ...body, closing);
+                    if (groupNumber)
+                        backreferenceRecorder === null || backreferenceRecorder === void 0 ? void 0 : backreferenceRecorder.groupClosed(groupNumber, opening);
                     break;
+                }
                 case ")":
                     ++i;
+                    caretFrame === null || caretFrame === void 0 ? void 0 : caretFrame(ON_END);
+                    lastBodyRunsOut =
+                        everyAlternativeRunsOut &&
+                            (alternativeRunsOut || result.length === alternativeStart);
                     return result;
                 default:
-                    featureMask |= FEATURE_BIT.patternCharacter;
+                    featureMask |= 1 /* Feature.patternCharacter */;
+                    appendOptional(
                     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- i < source.length is the loop invariant, so codePointAt(i) is always defined
-                    appendOptional(isUnicode && source.codePointAt(i) > 0xffff ? 2 : 1);
+                    scope & UNICODE && source.codePointAt(i) > 0xffff ? 2 : 1);
                     break;
             }
         }
+        caretFrame === null || caretFrame === void 0 ? void 0 : caretFrame(ON_END);
+        lastBodyRunsOut =
+            everyAlternativeRunsOut &&
+                (alternativeRunsOut || result.length === alternativeStart);
         return result;
     }
-    const parts = process(false, declaresNamedGroup, regex.flags.includes("i"));
-    if (namedGroupOpenings && namedBackreferencesSeen) {
-        const seenOnce = new Set();
-        let duplicated;
-        for (const opening of namedGroupOpenings) {
-            const name = decodeGroupName(groupNameOf(opening));
-            if (seenOnce.has(name))
-                (duplicated !== null && duplicated !== void 0 ? duplicated : (duplicated = new Set())).add(name);
-            else
-                seenOnce.add(name);
-        }
-        if (duplicated) {
-            for (const backreference of namedBackreferencesSeen) {
-                if (duplicated.has(decodeGroupName(backreference.ref))) {
-                    backreference.forward = true;
-                }
-            }
-        }
-    }
-    return {
-        parts,
-        groupCount,
-        featureMask,
-        rawLookarounds: rawLookarounds !== null && rawLookarounds !== void 0 ? rawLookarounds : NO_RAW_LOOKAROUNDS,
-        namedGroupOpenings: namedGroupOpenings !== null && namedGroupOpenings !== void 0 ? namedGroupOpenings : NO_NAMED_GROUP_OPENINGS
-    };
+    const parts = process(scopeOf(regex));
+    return { parts, featureMask, needs, rawLookarounds };
 }