regex-partial-match 1.2.0 → 1.3.0

package/lib/{compilePartial.js → partialMatchRegExp/walk.js}

@@ -1,66 +1,28 @@
-import escapeAtom from "./escapeAtom.js";
+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 MAYBE_HAS_BACKREFERENCE_REGEX = /\\[1-9]|\\k</;
-const DISJUNCTION_TO_END_OF_INPUT = "|$(?![\\s\\S]))";
-const ANY_CAPTURED_TEXT = "(?:[\\s\\S]*?)";
-const isBackreference = (part) => typeof part !== "string";
-const isNumericBackreference = (part) => isBackreference(part) && typeof part.ref === "number";
-const REGEX_FEATURES = [
-    "patternCharacter",
-    "startAnchor",
-    "endAnchor",
-    "wordBoundary",
-    "nonWordBoundary",
-    "lookahead",
-    "negativeLookahead",
-    "lookbehind",
-    "negativeLookbehind",
-    "backreference",
-    "namedBackreference",
-    "namedGroup",
-    "capturingGroup",
-    "lookaroundCapture",
-    "nonCapturingGroup",
-    "modifierGroup",
-    "modifierGroupWithRemoval",
-    "characterClass",
-    "nestedCharacterClass",
-    "classIntersection",
-    "classSubtraction",
-    "disjunction",
-    "quantifier",
-    "unicodePropertyEscape",
-    "characterClassEscape",
-    "controlEscape",
-    "controlLetterEscape",
-    "hexEscapeSequence",
-    "unicodeEscapeSequence",
-    "otherEscape"
-];
-const FEATURE_BIT = {};
-for (let index = 0; index < REGEX_FEATURES.length; index++) {
-    FEATURE_BIT[REGEX_FEATURES[index]] = 1 << index;
-}
-function featureSet(mask) {
-    const features = new Set();
-    for (let index = 0; index < REGEX_FEATURES.length; index++) {
-        if (mask & (1 << index))
-            features.add(REGEX_FEATURES[index]);
-    }
-    return features;
-}
-function walk(regex) {
+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) {
     const source = regex.source;
     const isUnicode = regex.unicode || regex.unicodeSets;
     let i = 0;
     let groupCount = 0;
     let featureMask = 0;
+    let rawLookarounds;
+    let namedGroupOpenings;
+    let closedGroupNumbers;
+    let closedGroupNames;
+    let namedBackreferencesSeen;
+    let currentRawLookaroundBackreferences;
     function extractSlice(length) {
         return source.slice(i, (i += length));
     }
-    function process(withinLookaround) {
-        var _a;
+    function process(withinLookaround, declaresNamedGroup, caseInsensitive) {
         const result = [];
         function appendOptional(length) {
             result.push("(?:" + extractSlice(length) + DISJUNCTION_TO_END_OF_INPUT);
@@ -68,10 +30,41 @@ function walk(regex) {
         function appendRaw(length) {
             result.push(extractSlice(length));
         }
+        function appendDigitRun(forcedRef) {
+            featureMask |= FEATURE_BIT.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);
+        }
         function appendRawLookaround(prefixLength) {
             const start = i;
             i += prefixLength;
-            process(true);
+            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;
+            }
             result.push(source.slice(start, i));
         }
         while (i < source.length) {
@@ -84,15 +77,35 @@ function walk(regex) {
                             break;
                         case "k": {
                             const referenceEnd = source[i + 2] === "<" ? source.indexOf(">", i) : -1;
-                            if (referenceEnd === -1) {
-                                appendOptional(2);
-                            }
-                            else {
+                            if (referenceEnd !== -1 && declaresNamedGroup) {
                                 featureMask |= FEATURE_BIT.namedBackreference;
                                 const start = i;
                                 const ref = source.slice(i + 3, referenceEnd);
                                 i = referenceEnd + 1;
-                                result.push({ ref, start, end: i });
+                                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
+                                });
+                            }
+                            else {
+                                result.push(LITERAL_K_ATOM);
+                                i += 2;
                             }
                             break;
                         }
@@ -135,6 +148,15 @@ function walk(regex) {
                             featureMask |= FEATURE_BIT.controlEscape;
                             appendOptional(2);
                             break;
+                        case "0":
+                            if (isUnicode) {
+                                featureMask |= FEATURE_BIT.otherEscape;
+                                appendOptional(2);
+                            }
+                            else {
+                                appendDigitRun(0);
+                            }
+                            break;
                         case "1":
                         case "2":
                         case "3":
@@ -143,17 +165,9 @@ function walk(regex) {
                         case "6":
                         case "7":
                         case "8":
-                        case "9": {
-                            featureMask |= FEATURE_BIT.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 = Number(source.slice(start + 1, end));
-                            i = end;
-                            result.push({ ref, start, end });
+                        case "9":
+                            appendDigitRun();
                             break;
-                        }
                         case "d":
                         case "D":
                         case "w":
@@ -242,13 +256,13 @@ function walk(regex) {
                                 featureMask |= FEATURE_BIT.nonCapturingGroup;
                                 result.push("(?:");
                                 i += 3;
-                                result.push(...process(withinLookaround), DISJUNCTION_TO_END_OF_INPUT);
+                                result.push(...process(withinLookaround, declaresNamedGroup, caseInsensitive), DISJUNCTION_TO_END_OF_INPUT);
                                 break;
                             case "=":
                                 featureMask |= FEATURE_BIT.lookahead;
                                 result.push("(?=");
                                 i += 3;
-                                result.push(...process(true), ")");
+                                result.push(...process(true, declaresNamedGroup, caseInsensitive), ")");
                                 break;
                             case "-":
                             case "i":
@@ -256,12 +270,16 @@ function walk(regex) {
                             case "m": {
                                 const flagsStart = i + 2, colonIndex = source.indexOf(":", flagsStart);
                                 const modifiers = source.slice(flagsStart, colonIndex);
-                                featureMask |= modifiers.includes("-")
+                                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), ")");
+                                result.push(...process(withinLookaround, declaresNamedGroup, modifierGroupCaseInsensitive), ")");
                                 break;
                             }
                             case "!":
@@ -278,15 +296,21 @@ function walk(regex) {
                                         featureMask |= FEATURE_BIT.negativeLookbehind;
                                         appendRawLookaround(4);
                                         break;
-                                    default:
+                                    default: {
                                         featureMask |= FEATURE_BIT.namedGroup;
                                         featureMask |= FEATURE_BIT.capturingGroup;
                                         if (withinLookaround)
                                             featureMask |= FEATURE_BIT.lookaroundCapture;
-                                        ++groupCount;
-                                        appendRaw(source.indexOf(">", i) - i + 1);
-                                        result.push(...process(withinLookaround), DISJUNCTION_TO_END_OF_INPUT);
+                                        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);
                                         break;
+                                    }
                                 }
                                 break;
                         }
@@ -295,9 +319,10 @@ function walk(regex) {
                         featureMask |= FEATURE_BIT.capturingGroup;
                         if (withinLookaround)
                             featureMask |= FEATURE_BIT.lookaroundCapture;
-                        ++groupCount;
+                        const groupNumber = ++groupCount;
                         appendRaw(1);
-                        result.push(...process(withinLookaround), DISJUNCTION_TO_END_OF_INPUT);
+                        result.push(...process(withinLookaround, declaresNamedGroup, caseInsensitive), DISJUNCTION_TO_END_OF_INPUT);
+                        (closedGroupNumbers !== null && closedGroupNumbers !== void 0 ? closedGroupNumbers : (closedGroupNumbers = new Set())).add(groupNumber);
                     }
                     break;
                 case ")":
@@ -305,93 +330,37 @@ function walk(regex) {
                     return result;
                 default:
                     featureMask |= FEATURE_BIT.patternCharacter;
-                    appendOptional(isUnicode && ((_a = source.codePointAt(i)) !== null && _a !== void 0 ? _a : 0) > 0xffff ? 2 : 1);
+                    // 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);
                     break;
             }
         }
         return result;
     }
-    return { parts: process(false), groupCount, featureMask };
-}
-function render(parts, renderBackref) {
-    let rendered = "";
-    for (const part of parts) {
-        rendered += isBackreference(part) ? renderBackref(part) : part;
-    }
-    return rendered;
-}
-function backrefToken(backref) {
-    return isNumericBackreference(backref)
-        ? "\\" + String(backref.ref)
-        : "\\k<" + backref.ref + ">";
-}
-function reclassifyOctalEscapes(parts, source, groupCount) {
-    return parts.map((part) => isNumericBackreference(part) && part.ref > groupCount
-        ? "(?:" + source.slice(part.start, part.end) + DISJUNCTION_TO_END_OF_INPUT
-        : part);
-}
-function spliceOriginalSource(source, backrefs) {
-    let result = "";
-    let cursor = 0;
-    for (const { start, end } of backrefs) {
-        result += source.slice(cursor, start) + ANY_CAPTURED_TEXT;
-        cursor = end;
-    }
-    return result + source.slice(cursor);
-}
-function expandCaptured(value, isUnicode) {
-    return (isUnicode ? Array.from(value) : value.split(""))
-        .map((atom) => "(?:" + escapeAtom(atom) + DISJUNCTION_TO_END_OF_INPUT)
-        .join("");
-}
-class Compiled {
-    constructor(_featureMask) {
-        this._featureMask = _featureMask;
-    }
-    get features() {
-        var _a;
-        return ((_a = this._features) !== null && _a !== void 0 ? _a : (this._features = featureSet(this._featureMask)));
-    }
-}
-class CompiledStatic extends Compiled {
-    constructor(regex, featureMask) {
-        super(featureMask);
-        this.regex = regex;
-        this.kind = "static";
-    }
-}
-class CompiledDynamic extends Compiled {
-    constructor(dynamic, featureMask) {
-        super(featureMask);
-        this.dynamic = dynamic;
-        this.kind = "dynamic";
+    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
+    };
 }
-export const compilePartial = (regex) => {
-    const { parts, groupCount, featureMask } = walk(regex);
-    const flags = regex.flags;
-    if (!MAYBE_HAS_BACKREFERENCE_REGEX.test(regex.source)) {
-        return new CompiledStatic(new RegExp(render(parts, backrefToken), flags), featureMask);
-    }
-    const isUnicode = regex.unicode || regex.unicodeSets;
-    const sanitisedParts = isUnicode
-        ? parts
-        : reclassifyOctalEscapes(parts, regex.source, groupCount);
-    const backreferences = sanitisedParts.filter(isBackreference);
-    if (backreferences.length === 0) {
-        return new CompiledStatic(new RegExp(render(sanitisedParts, backrefToken), flags), featureMask);
-    }
-    return new CompiledDynamic({
-        originalCaptureScan: new RegExp(spliceOriginalSource(regex.source, backreferences), flags),
-        preScan: new RegExp(render(parts, () => ANY_CAPTURED_TEXT), flags),
-        expand: (capture) => render(parts, (backref) => {
-            var _a;
-            const captured = isNumericBackreference(backref)
-                ? capture[backref.ref]
-                : (_a = capture.groups) === null || _a === void 0 ? void 0 : _a[backref.ref];
-            return captured === undefined
-                ? "(?:" + backrefToken(backref) + DISJUNCTION_TO_END_OF_INPUT
-                : expandCaptured(captured, isUnicode);
-        })
-    }, featureMask);
-};

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "regex-partial-match",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "A regular expression transform for partial matching",
   "devEngines": {
     "runtime": {
       "name": "node",
-      "version": ">=23"
+      "version": ">=24.12"
     },
     "packageManager": {
       "name": "npm",
-      "version": "11.17.0+sha512.3eeaf18997b11070d313849268b23766b9db0068997dec9471073170fe43fa17f2b4d0337bf0f52330ee2274e7f5754b21b01052742e48f5c9c74d8b1e32ef43"
+      "version": "11.19.0+sha512.48377f8478372aa1c4e47b763475b135836da82436a5700f2e5e8eb5084fc840f93c7b117eb3ad3b5f7d3194c81b6710a10d59448f6ddbcb21ac3fb672bdc003"
     }
   },
   "keywords": [
@@ -33,17 +33,22 @@
     }
   ],
   "type": "module",
-  "main": "lib/partialMatchRegExp.js",
+  "main": "lib/partialMatchRegExp/index.js",
   "exports": {
     ".": {
-      "types": "./lib/partialMatchRegExp.d.ts",
-      "import": "./lib/partialMatchRegExp.js",
-      "default": "./lib/partialMatchRegExp.js"
+      "types": "./lib/partialMatchRegExp/index.d.ts",
+      "import": "./lib/partialMatchRegExp/index.js",
+      "default": "./lib/partialMatchRegExp/index.js"
     },
     "./extend": {
-      "types": "./lib/extend.d.ts",
-      "import": "./lib/extend.js",
-      "default": "./lib/extend.js"
+      "types": "./lib/extend/index.d.ts",
+      "import": "./lib/extend/index.js",
+      "default": "./lib/extend/index.js"
+    },
+    "./partialMatchRegExp": {
+      "types": "./lib/partialMatchRegExp/partialMatchRegExp.d.ts",
+      "import": "./lib/partialMatchRegExp/partialMatchRegExp.js",
+      "default": "./lib/partialMatchRegExp/partialMatchRegExp.js"
     }
   },
   "files": [
@@ -54,9 +59,11 @@
     "url": "git+https://github.com/TomStrepsil/regex-partial-match.git"
   },
   "workspaces": [
-    "benchmarking"
+    "test/benchmarking"
+  ],
+  "sideEffects": [
+    "./lib/extend/index.js"
   ],
-  "sideEffects": false,
   "scripts": {
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
@@ -64,7 +71,8 @@
     "prepublishOnly": "tsc -p tsconfig.build.json",
     "ci:smoke-test-built-package": "node .github/scripts/smoke-test-built-package.ts",
     "test": "vitest run --config ./test/vitest.config.ts",
-    "test:watch": "vitest --config ./test/vitest.config.ts"
+    "test:watch": "vitest --config ./test/vitest.config.ts",
+    "test:coverage": "vitest run --config ./test/vitest.config.ts --coverage"
   },
   "simple-git-hooks": {
     "pre-commit": "node_modules/.bin/lint-staged"
@@ -83,6 +91,8 @@
     "@types/node": "^25.9.3",
     "@typescript/lib-es2018": "file:types/lib-es2018",
     "@typescript/lib-es2022": "file:types/lib-es2022",
+    "@vitest/coverage-v8": "^4.1.11",
+    "esbuild": "^0.28.1",
     "eslint": "^9.17.0",
     "jiti": "^2.6.1",
     "lint-staged": "^15.2.11",

package/lib/compilePartial.d.ts

@@ -1,26 +0,0 @@
-declare const REGEX_FEATURES: readonly ["patternCharacter", "startAnchor", "endAnchor", "wordBoundary", "nonWordBoundary", "lookahead", "negativeLookahead", "lookbehind", "negativeLookbehind", "backreference", "namedBackreference", "namedGroup", "capturingGroup", "lookaroundCapture", "nonCapturingGroup", "modifierGroup", "modifierGroupWithRemoval", "characterClass", "nestedCharacterClass", "classIntersection", "classSubtraction", "disjunction", "quantifier", "unicodePropertyEscape", "characterClassEscape", "controlEscape", "controlLetterEscape", "hexEscapeSequence", "unicodeEscapeSequence", "otherEscape"];
-export type RegexFeature = (typeof REGEX_FEATURES)[number];
-export interface DynamicPath {
-    originalCaptureScan: RegExp;
-    preScan: RegExp;
-    expand: (capture: RegExpExecArray) => string;
-}
-declare abstract class Compiled {
-    private readonly _featureMask;
-    private _features?;
-    constructor(_featureMask: number);
-    get features(): ReadonlySet<RegexFeature>;
-}
-declare class CompiledStatic extends Compiled {
-    readonly regex: RegExp;
-    readonly kind = "static";
-    constructor(regex: RegExp, featureMask: number);
-}
-declare class CompiledDynamic extends Compiled {
-    readonly dynamic: DynamicPath;
-    readonly kind = "dynamic";
-    constructor(dynamic: DynamicPath, featureMask: number);
-}
-export type CompiledPartial = CompiledStatic | CompiledDynamic;
-export declare const compilePartial: (regex: RegExp) => CompiledPartial;
-export {};