regex-partial-match 1.1.2 → 1.3.0

package/lib/partialMatchRegExp/walk.js

@@ -0,0 +1,366 @@
+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) {
+    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, declaresNamedGroup, caseInsensitive) {
+        const result = [];
+        function appendOptional(length) {
+            result.push("(?:" + extractSlice(length) + DISJUNCTION_TO_END_OF_INPUT);
+        }
+        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;
+            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) {
+            switch (source[i]) {
+                case "\\":
+                    switch (source[i + 1]) {
+                        case "c":
+                            featureMask |= FEATURE_BIT.controlLetterEscape;
+                            appendOptional(3);
+                            break;
+                        case "k": {
+                            const referenceEnd = source[i + 2] === "<" ? source.indexOf(">", i) : -1;
+                            if (referenceEnd !== -1 && declaresNamedGroup) {
+                                featureMask |= FEATURE_BIT.namedBackreference;
+                                const start = i;
+                                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
+                                });
+                            }
+                            else {
+                                result.push(LITERAL_K_ATOM);
+                                i += 2;
+                            }
+                            break;
+                        }
+                        case "u":
+                            featureMask |= FEATURE_BIT.unicodeEscapeSequence;
+                            if (isUnicode && source[i + 2] === "{") {
+                                appendOptional(source.indexOf("}", i) - i + 1);
+                            }
+                            else {
+                                appendOptional(6);
+                            }
+                            break;
+                        case "p":
+                        case "P":
+                            if (isUnicode) {
+                                featureMask |= FEATURE_BIT.unicodePropertyEscape;
+                                appendOptional(source.indexOf("}", i) - i + 1);
+                            }
+                            else {
+                                appendOptional(2);
+                            }
+                            break;
+                        case "x":
+                            featureMask |= FEATURE_BIT.hexEscapeSequence;
+                            appendOptional(4);
+                            break;
+                        case "b":
+                            featureMask |= FEATURE_BIT.wordBoundary;
+                            appendOptional(2);
+                            break;
+                        case "B":
+                            featureMask |= FEATURE_BIT.nonWordBoundary;
+                            appendOptional(2);
+                            break;
+                        case "f":
+                        case "n":
+                        case "r":
+                        case "t":
+                        case "v":
+                            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":
+                        case "4":
+                        case "5":
+                        case "6":
+                        case "7":
+                        case "8":
+                        case "9":
+                            appendDigitRun();
+                            break;
+                        case "d":
+                        case "D":
+                        case "w":
+                        case "W":
+                        case "s":
+                        case "S":
+                            featureMask |= FEATURE_BIT.characterClassEscape;
+                            appendOptional(2);
+                            break;
+                        default:
+                            featureMask |= FEATURE_BIT.otherEscape;
+                            appendOptional(2);
+                            break;
+                    }
+                    break;
+                case "[": {
+                    featureMask |= FEATURE_BIT.characterClass;
+                    let depth = 1, j = i + 1, previousSetOperatorCharacter;
+                    while (depth) {
+                        const character = source[j];
+                        switch (character) {
+                            case "\\":
+                                j += 2;
+                                previousSetOperatorCharacter = undefined;
+                                continue;
+                            case "[":
+                                if (regex.unicodeSets) {
+                                    featureMask |= FEATURE_BIT.nestedCharacterClass;
+                                    depth++;
+                                }
+                                break;
+                            case "]":
+                                depth--;
+                                break;
+                            case "&":
+                                if (regex.unicodeSets && previousSetOperatorCharacter === "&") {
+                                    featureMask |= FEATURE_BIT.classIntersection;
+                                }
+                                break;
+                            case "-":
+                                if (regex.unicodeSets && previousSetOperatorCharacter === "-") {
+                                    featureMask |= FEATURE_BIT.classSubtraction;
+                                }
+                                break;
+                        }
+                        previousSetOperatorCharacter = character;
+                        j++;
+                    }
+                    appendOptional(j - i);
+                    break;
+                }
+                case "^":
+                    featureMask |= FEATURE_BIT.startAnchor;
+                    appendRaw(1);
+                    break;
+                case "$":
+                    featureMask |= FEATURE_BIT.endAnchor;
+                    appendRaw(1);
+                    break;
+                case "|":
+                    featureMask |= FEATURE_BIT.disjunction;
+                    appendRaw(1);
+                    break;
+                case "*":
+                case "+":
+                case "?":
+                    featureMask |= FEATURE_BIT.quantifier;
+                    appendRaw(1);
+                    break;
+                case "{": {
+                    OCCURRENCES_REGEX.lastIndex = i;
+                    const regExpExecArray = OCCURRENCES_REGEX.exec(source);
+                    if (regExpExecArray) {
+                        featureMask |= FEATURE_BIT.quantifier;
+                        appendRaw(regExpExecArray[0].length);
+                    }
+                    else {
+                        appendOptional(1);
+                    }
+                    break;
+                }
+                case "(":
+                    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);
+                                break;
+                            case "=":
+                                featureMask |= FEATURE_BIT.lookahead;
+                                result.push("(?=");
+                                i += 3;
+                                result.push(...process(true, declaresNamedGroup, caseInsensitive), ")");
+                                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), ")");
+                                break;
+                            }
+                            case "!":
+                                featureMask |= FEATURE_BIT.negativeLookahead;
+                                appendRawLookaround(3);
+                                break;
+                            case "<":
+                                switch (source[i + 3]) {
+                                    case "=":
+                                        featureMask |= FEATURE_BIT.lookbehind;
+                                        appendRawLookaround(4);
+                                        break;
+                                    case "!":
+                                        featureMask |= FEATURE_BIT.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);
+                                        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);
+                    }
+                    break;
+                case ")":
+                    ++i;
+                    return result;
+                default:
+                    featureMask |= FEATURE_BIT.patternCharacter;
+                    // 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;
+    }
+    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
+    };
+}

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "regex-partial-match",
-  "version": "1.1.2",
+  "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"
@@ -78,11 +86,13 @@
     "registry": "https://registry.npmjs.org"
   },
   "devDependencies": {
-    "@typescript/lib-es2018": "file:types/lib-es2018",
-    "@typescript/lib-es2022": "file:types/lib-es2022",
     "@eslint/js": "^9.17.0",
     "@eslint/markdown": "^7.5.1",
     "@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,16 +0,0 @@
-export type RegexFeature = "patternCharacter" | "startAnchor" | "endAnchor" | "wordBoundary" | "nonWordBoundary" | "lookahead" | "negativeLookahead" | "lookbehind" | "negativeLookbehind" | "backreference" | "namedBackreference" | "namedGroup" | "capturingGroup" | "nonCapturingGroup" | "modifierGroup" | "modifierGroupWithRemoval" | "characterClass" | "nestedCharacterClass" | "classIntersection" | "classSubtraction" | "disjunction" | "quantifier" | "unicodePropertyEscape" | "characterClassEscape" | "controlEscape" | "controlLetterEscape" | "hexEscapeSequence" | "unicodeEscapeSequence" | "otherEscape";
-export interface DynamicPath {
-    originalCaptureScan: RegExp;
-    preScan: RegExp;
-    expand: (capture: RegExpExecArray) => string;
-}
-export type CompiledPartial = ({
-    kind: "static";
-    regex: RegExp;
-} | {
-    kind: "dynamic";
-    dynamic: DynamicPath;
-}) & {
-    features: Set<RegexFeature>;
-};
-export declare const compilePartial: (regex: RegExp) => CompiledPartial;