regex-partial-match 1.3.0 → 2.0.1

package/package.json

@@ -1,17 +1,7 @@
 {
   "name": "regex-partial-match",
-  "version": "1.3.0",
+  "version": "2.0.1",
   "description": "A regular expression transform for partial matching",
-  "devEngines": {
-    "runtime": {
-      "name": "node",
-      "version": ">=24.12"
-    },
-    "packageManager": {
-      "name": "npm",
-      "version": "11.19.0+sha512.48377f8478372aa1c4e47b763475b135836da82436a5700f2e5e8eb5084fc840f93c7b117eb3ad3b5f7d3194c81b6710a10d59448f6ddbcb21ac3fb672bdc003"
-    }
-  },
   "keywords": [
     "regexp",
     "regular expressions",
@@ -33,12 +23,12 @@
     }
   ],
   "type": "module",
-  "main": "lib/partialMatchRegExp/index.js",
+  "main": "lib/index.js",
   "exports": {
     ".": {
-      "types": "./lib/partialMatchRegExp/index.d.ts",
-      "import": "./lib/partialMatchRegExp/index.js",
-      "default": "./lib/partialMatchRegExp/index.js"
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js",
+      "default": "./lib/index.js"
     },
     "./extend": {
       "types": "./lib/extend/index.d.ts",
@@ -46,9 +36,39 @@
       "default": "./lib/extend/index.js"
     },
     "./partialMatchRegExp": {
-      "types": "./lib/partialMatchRegExp/partialMatchRegExp.d.ts",
-      "import": "./lib/partialMatchRegExp/partialMatchRegExp.js",
-      "default": "./lib/partialMatchRegExp/partialMatchRegExp.js"
+      "types": "./lib/partialMatchRegExp/index.d.ts",
+      "import": "./lib/partialMatchRegExp/index.js",
+      "default": "./lib/partialMatchRegExp/index.js"
+    },
+    "./hitEnd": {
+      "types": "./lib/hitEnd/index.d.ts",
+      "import": "./lib/hitEnd/index.js",
+      "default": "./lib/hitEnd/index.js"
+    },
+    "./features": {
+      "types": "./lib/features/index.d.ts",
+      "import": "./lib/features/index.js",
+      "default": "./lib/features/index.js"
+    },
+    "./core": {
+      "types": "./lib/core/index.d.ts",
+      "import": "./lib/core/index.js",
+      "default": "./lib/core/index.js"
+    },
+    "./modules": {
+      "types": "./lib/modules/index.d.ts",
+      "import": "./lib/modules/index.js",
+      "default": "./lib/modules/index.js"
+    },
+    "./modules/carets": {
+      "types": "./lib/modules/carets/index.d.ts",
+      "import": "./lib/modules/carets/index.js",
+      "default": "./lib/modules/carets/index.js"
+    },
+    "./modules/backreferences": {
+      "types": "./lib/modules/backreferences/index.d.ts",
+      "import": "./lib/modules/backreferences/index.js",
+      "default": "./lib/modules/backreferences/index.js"
     }
   },
   "files": [
@@ -58,47 +78,10 @@
     "type": "git",
     "url": "git+https://github.com/TomStrepsil/regex-partial-match.git"
   },
-  "workspaces": [
-    "test/benchmarking"
-  ],
   "sideEffects": [
     "./lib/extend/index.js"
   ],
-  "scripts": {
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "prepare": "simple-git-hooks",
-    "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:coverage": "vitest run --config ./test/vitest.config.ts --coverage"
-  },
-  "simple-git-hooks": {
-    "pre-commit": "node_modules/.bin/lint-staged"
-  },
-  "lint-staged": {
-    "*.{ts,js}": [
-      "eslint --fix"
-    ]
-  },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
-  },
-  "devDependencies": {
-    "@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",
-    "simple-git-hooks": "^2.12.1",
-    "typescript": "^6.0.3",
-    "typescript-eslint": "^8.18.1",
-    "vitest": "^4.0.15"
   }
-}
+}

package/lib/partialMatchRegExp/compilePartial/asNativeAtom.d.ts

@@ -1,2 +0,0 @@
-import { type Backreference } from "../part.ts";
-export default function asNativeAtom(backref: Backreference): string;

package/lib/partialMatchRegExp/compilePartial/asOptionalAtom.d.ts

@@ -1 +0,0 @@
-export default function asOptionalAtom(text: string): string;

package/lib/partialMatchRegExp/compilePartial/asOptionalAtom.js

@@ -1,4 +0,0 @@
-import { DISJUNCTION_TO_END_OF_INPUT } from "../atomSyntax.js";
-export default function asOptionalAtom(text) {
-    return "(?:" + text + DISJUNCTION_TO_END_OF_INPUT;
-}

package/lib/partialMatchRegExp/compilePartial/asPreScanPart.d.ts

@@ -1,2 +0,0 @@
-import { type Part } from "../part.ts";
-export default function asPreScanPart(part: Part): string;

package/lib/partialMatchRegExp/compilePartial/index.d.ts

@@ -1,2 +0,0 @@
-import { type CompiledPartial } from "./compiled.ts";
-export default function compilePartial(regex: RegExp): CompiledPartial;

package/lib/partialMatchRegExp/compilePartial/index.js

@@ -1,79 +0,0 @@
-import escapeAtom from "../escapeAtom.js";
-import { walk } from "../walk.js";
-import { OPTIONAL_ATOM_OPENING } from "../atomSyntax.js";
-import { isBackreference } from "../part.js";
-import { hasFeature } from "../regexFeatures.js";
-import asOptionalAtom from "./asOptionalAtom.js";
-import asPreScanPart from "./asPreScanPart.js";
-import resolvedFromScan from "./resolvedFromScan.js";
-import startsWithUnderFlags from "./startsWithUnderFlags.js";
-import longestBakedPrefixEndingInput from "./longestBakedPrefixEndingInput.js";
-import flagsAtBackreference from "./flagsAtBackreference.js";
-import reclassifyLegacyEscapes from "./reclassifyLegacyEscapes.js";
-import spliceOriginalSource from "./spliceOriginalSource.js";
-import toStatic from "./toStatic.js";
-import { CompiledDynamic } from "./compiled.js";
-const MAYBE_HAS_BACKREFERENCE_REGEX = /\\[0-9]|\\k</;
-const NEVER = "(?!)";
-const GROUP_CLOSING = ")";
-const ALTERNATION = "|";
-const ONLY_AT_END_OF_INPUT = asOptionalAtom(NEVER);
-export default function compilePartial(regex) {
-    const flags = regex.flags;
-    let walked = walk(regex, true);
-    if (hasFeature(walked.featureMask, "namedBackreference") &&
-        !hasFeature(walked.featureMask, "namedGroup")) {
-        walked = walk(regex, false);
-    }
-    const { parts, groupCount, featureMask, rawLookarounds, namedGroupOpenings } = walked;
-    if (!MAYBE_HAS_BACKREFERENCE_REGEX.test(regex.source)) {
-        return toStatic(parts, flags, rawLookarounds, namedGroupOpenings, featureMask);
-    }
-    const isUnicode = regex.unicode || regex.unicodeSets;
-    const sanitisedParts = isUnicode
-        ? parts
-        : reclassifyLegacyEscapes(parts, regex.source, groupCount);
-    const backreferences = sanitisedParts.filter(isBackreference);
-    if (backreferences.length === 0) {
-        return toStatic(sanitisedParts, flags, rawLookarounds, namedGroupOpenings, featureMask);
-    }
-    return new CompiledDynamic({
-        originalCaptureScan: new RegExp(spliceOriginalSource(regex.source, backreferences), flags),
-        preScan: new RegExp(sanitisedParts.map(asPreScanPart).join(""), flags),
-        expansionFitsCaptures: (expandedFrom, match, input) => {
-            var _a;
-            for (const backref of backreferences) {
-                const baked = resolvedFromScan(backref, expandedFrom);
-                if (baked === undefined)
-                    continue;
-                const resolved = (_a = resolvedFromScan(backref, match)) !== null && _a !== void 0 ? _a : "";
-                const backrefFlags = flagsAtBackreference(backref, flags);
-                const consumed = longestBakedPrefixEndingInput(baked, input, backrefFlags);
-                if (!startsWithUnderFlags(resolved, consumed, backrefFlags))
-                    return false;
-            }
-            return true;
-        },
-        expand: (capture) => {
-            const expanded = [];
-            for (const part of sanitisedParts) {
-                if (!isBackreference(part)) {
-                    expanded.push(part);
-                    continue;
-                }
-                const captured = resolvedFromScan(part, capture);
-                if (captured === undefined || captured === "") {
-                    expanded.push(part);
-                    continue;
-                }
-                const atoms = isUnicode ? Array.from(captured) : captured.split("");
-                expanded.push(OPTIONAL_ATOM_OPENING, part, ALTERNATION);
-                for (const atom of atoms) {
-                    expanded.push(asOptionalAtom(escapeAtom(atom)));
-                }
-                expanded.push(ONLY_AT_END_OF_INPUT, GROUP_CLOSING);
-            }
-            return expanded;
-        }
-    }, rawLookarounds, namedGroupOpenings, featureMask);
-}

package/lib/partialMatchRegExp/compilePartial/longestBakedPrefixEndingInput.js

@@ -1,50 +0,0 @@
-import escapeAtom from "../escapeAtom.js";
-import caseFoldFlags from "./caseFoldFlags.js";
-const SENTINEL = null;
-function foldMatchersFor(atoms, flags) {
-    const matchers = Object.create(null);
-    if (!flags.includes("i"))
-        return matchers;
-    const foldFlags = caseFoldFlags(flags);
-    for (const atom of atoms) {
-        if (!(atom in matchers)) {
-            matchers[atom] = new RegExp("^" + escapeAtom(atom), foldFlags);
-        }
-    }
-    return matchers;
-}
-function atomsAgree(a, b, foldMatchers) {
-    var _a, _b;
-    if (a === SENTINEL || b === SENTINEL)
-        return false;
-    if (a === b)
-        return true;
-    return (_b = (_a = foldMatchers[a]) === null || _a === void 0 ? void 0 : _a.test(b)) !== null && _b !== void 0 ? _b : false;
-}
-export default function longestBakedPrefixEndingInput(baked, input, flags) {
-    if (baked === "")
-        return "";
-    const isUnicode = flags.includes("u") || flags.includes("v");
-    const bakedAtoms = isUnicode ? Array.from(baked) : baked.split("");
-    const inputAtoms = isUnicode ? Array.from(input) : input.split("");
-    const foldMatchers = foldMatchersFor(bakedAtoms, flags);
-    const sentinelIndex = bakedAtoms.length;
-    const totalLength = bakedAtoms.length + 1 + inputAtoms.length;
-    const atIndex = (index) => index < sentinelIndex
-        ? bakedAtoms[index]
-        : index === sentinelIndex
-            ? SENTINEL
-            : inputAtoms[index - sentinelIndex - 1];
-    const longestBorder = [0];
-    for (let index = 1; index < totalLength; index++) {
-        let matched = longestBorder[index - 1];
-        while (matched > 0 &&
-            !atomsAgree(atIndex(matched), atIndex(index), foldMatchers)) {
-            matched = longestBorder[matched - 1];
-        }
-        if (atomsAgree(atIndex(matched), atIndex(index), foldMatchers))
-            matched++;
-        longestBorder.push(matched);
-    }
-    return bakedAtoms.slice(0, longestBorder[totalLength - 1]).join("");
-}

package/lib/partialMatchRegExp/compilePartial/reclassifyLegacyEscapes.d.ts

@@ -1,2 +0,0 @@
-import { type Part } from "../part.ts";
-export default function reclassifyLegacyEscapes(parts: Part[], source: string, groupCount: number): Part[];

package/lib/partialMatchRegExp/compilePartial/reclassifyLegacyEscapes.js

@@ -1,17 +0,0 @@
-import { legacyEscapeAtoms } from "../legacyEscape.js";
-import { isNumericBackreference } from "../part.js";
-import asOptionalAtom from "./asOptionalAtom.js";
-export default function reclassifyLegacyEscapes(parts, source, groupCount) {
-    const reclassified = [];
-    for (const part of parts) {
-        if (isNumericBackreference(part) && (part.ref < 1 || part.ref > groupCount)) {
-            for (const atom of legacyEscapeAtoms(source.slice(part.start + 1, part.end))) {
-                reclassified.push(asOptionalAtom(atom));
-            }
-        }
-        else {
-            reclassified.push(part);
-        }
-    }
-    return reclassified;
-}

package/lib/partialMatchRegExp/compilePartial/spliceOriginalSource.d.ts

@@ -1,2 +0,0 @@
-import type { Backreference } from "../part.ts";
-export default function spliceOriginalSource(source: string, backrefs: Backreference[]): string;

package/lib/partialMatchRegExp/compilePartial/spliceOriginalSource.js

@@ -1,12 +0,0 @@
-import { ANY_CAPTURED_TEXT } from "../atomSyntax.js";
-export default function spliceOriginalSource(source, backrefs) {
-    let result = "";
-    let cursor = 0;
-    for (const { start, end, forward } of backrefs) {
-        if (forward)
-            continue;
-        result += source.slice(cursor, start) + ANY_CAPTURED_TEXT;
-        cursor = end;
-    }
-    return result + source.slice(cursor);
-}

package/lib/partialMatchRegExp/isComplete/index.d.ts

@@ -1,38 +0,0 @@
-import type PartialMatchRegExp from "../partialMatchRegExp.ts";
-/**
- * Whether `match` — a match `partial` produced — is a match of the original
- * pattern, or merely a prefix of it.
- *
- * `true` means every atom matched literally, so the path the match took is
- * one the original pattern could have taken itself. `false` means the match
- * depended on the input running out: it took a `|$(?![\s\S])` truncation
- * branch, so more input is needed and its captures are provisional.
- *
- * Complete is not the same as final: `/hello \w+/` matches `"hello world"`
- * completely, and would match more of `"hello worldly"`.
- *
- * The implication runs one way only. The original pattern may also match at
- * this index by some *other* path — yielding the same text, and even the
- * same captures — so re-testing the original answers "does anything match
- * here?", not "did this result depend on truncation?", and cannot recover
- * this answer.
- *
- * @param partial - The `PartialMatchRegExp` instance that produced `match`
- * @param match - A match returned by `partial.exec()`
- * @returns `true` when the match is complete, `false` when it is a prefix
- *
- * @remarks
- * Requires ES2018+ regardless of the pattern — the probe this builds uses
- * named capturing groups internally, unlike `exec()` and `test()`.
- *
- * @example
- * ```typescript
- * import PartialMatchRegExp, { isComplete } from "regex-partial-match";
- *
- * const partial = new PartialMatchRegExp(/^\d{4}-\d{2}-\d{2}/);
- * const match = partial.exec('2024-06');
- *
- * match !== null && isComplete(partial, match); // false - keep typing
- * ```
- */
-export default function isComplete(partial: PartialMatchRegExp, match: RegExpExecArray): boolean;

package/lib/partialMatchRegExp/isComplete/index.js

@@ -1,41 +0,0 @@
-import { compiledPartial, truncationProbeCache } from "../partialMatchInternals.js";
-import isMatchComplete from "./isMatchComplete.js";
-/**
- * Whether `match` — a match `partial` produced — is a match of the original
- * pattern, or merely a prefix of it.
- *
- * `true` means every atom matched literally, so the path the match took is
- * one the original pattern could have taken itself. `false` means the match
- * depended on the input running out: it took a `|$(?![\s\S])` truncation
- * branch, so more input is needed and its captures are provisional.
- *
- * Complete is not the same as final: `/hello \w+/` matches `"hello world"`
- * completely, and would match more of `"hello worldly"`.
- *
- * The implication runs one way only. The original pattern may also match at
- * this index by some *other* path — yielding the same text, and even the
- * same captures — so re-testing the original answers "does anything match
- * here?", not "did this result depend on truncation?", and cannot recover
- * this answer.
- *
- * @param partial - The `PartialMatchRegExp` instance that produced `match`
- * @param match - A match returned by `partial.exec()`
- * @returns `true` when the match is complete, `false` when it is a prefix
- *
- * @remarks
- * Requires ES2018+ regardless of the pattern — the probe this builds uses
- * named capturing groups internally, unlike `exec()` and `test()`.
- *
- * @example
- * ```typescript
- * import PartialMatchRegExp, { isComplete } from "regex-partial-match";
- *
- * const partial = new PartialMatchRegExp(/^\d{4}-\d{2}-\d{2}/);
- * const match = partial.exec('2024-06');
- *
- * match !== null && isComplete(partial, match); // false - keep typing
- * ```
- */
-export default function isComplete(partial, match) {
-    return isMatchComplete(partial[compiledPartial], match, partial.flags, partial[truncationProbeCache]);
-}

package/lib/partialMatchRegExp/isComplete/isMatchComplete.d.ts

@@ -1,3 +0,0 @@
-import type { CompiledPartial } from "../compilePartial/compiled.ts";
-import type { TruncationProbeCache } from "./truncationProbeCache.ts";
-export default function isMatchComplete(compiled: CompiledPartial, match: RegExpExecArray, flags: string, cache: TruncationProbeCache): boolean;

package/lib/partialMatchRegExp/isComplete/isMatchComplete.js

@@ -1,14 +0,0 @@
-import { buildTruncationProbe, tookTruncationBranch } from "./truncationProbe.js";
-import { backreferenceExpansion } from "../backreferenceExpansion.js";
-export default function isMatchComplete(compiled, match, flags, cache) {
-    var _a, _b;
-    if (compiled.kind === "dynamic") {
-        const expansion = match[backreferenceExpansion];
-        if (expansion === undefined)
-            return true;
-        (_a = expansion.probe) !== null && _a !== void 0 ? _a : (expansion.probe = buildTruncationProbe(expansion.parts, compiled.rawLookarounds, compiled.namedGroupOpenings, flags));
-        return !tookTruncationBranch(expansion.probe, match.input, match.index);
-    }
-    (_b = cache.probe) !== null && _b !== void 0 ? _b : (cache.probe = buildTruncationProbe(compiled.parts, compiled.rawLookarounds, compiled.namedGroupOpenings, flags));
-    return !tookTruncationBranch(cache.probe, match.input, match.index);
-}

package/lib/partialMatchRegExp/isComplete/partRole.js

@@ -1,28 +0,0 @@
-import { DISJUNCTION_TO_END_OF_INPUT, OPTIONAL_ATOM_OPENING, NAMED_GROUP_OPENING } from "../atomSyntax.js";
-import { isBackreference } from "../part.js";
-function isGroupOpen(part) {
-    return (part === "(" ||
-        (part.startsWith(NAMED_GROUP_OPENING) &&
-            !"=!".includes(part[NAMED_GROUP_OPENING.length])));
-}
-function isRawLookaroundOpen(part) {
-    return (part.startsWith("(?!") ||
-        part.startsWith(NAMED_GROUP_OPENING + "=") ||
-        part.startsWith(NAMED_GROUP_OPENING + "!"));
-}
-function endsAtTruncationBranch(part) {
-    return (part === DISJUNCTION_TO_END_OF_INPUT ||
-        (part.startsWith(OPTIONAL_ATOM_OPENING) &&
-            part.endsWith(DISJUNCTION_TO_END_OF_INPUT)));
-}
-export function roleOf(part) {
-    if (isBackreference(part))
-        return "backreference";
-    if (isRawLookaroundOpen(part))
-        return "rawLookaround";
-    if (isGroupOpen(part))
-        return "groupOpen";
-    if (endsAtTruncationBranch(part))
-        return "truncationEnd";
-    return "plain";
-}

package/lib/partialMatchRegExp/isComplete/truncationProbe.d.ts

@@ -1,8 +0,0 @@
-import { type Part, type RawLookaroundInfo } from "../part.ts";
-export interface TruncationProbe {
-    regex: RegExp;
-    markerName: string;
-    markerCount: number;
-}
-export declare const buildTruncationProbe: (parts: readonly Part[], rawLookarounds: readonly RawLookaroundInfo[], namedGroupOpenings: readonly string[], flags: string) => TruncationProbe;
-export declare const tookTruncationBranch: (probe: TruncationProbe, input: string, index: number) => boolean;

package/lib/partialMatchRegExp/isComplete/truncationProbe.js

@@ -1,105 +0,0 @@
-import { legacyEscapeAsLiteral } from "../legacyEscape.js";
-import { DISJUNCTION_TO_END_OF_INPUT, OPTIONAL_ATOM_OPENING } from "../atomSyntax.js";
-import { groupNameOf, decodeGroupName } from "../groupName.js";
-import { isBackreference, isNumericBackreference } from "../part.js";
-import { roleOf } from "./partRole.js";
-const TRUNCATION_MARKER_NAME = "truncation";
-const FLAGS_INCOMPATIBLE_WITH_PROBING = /[dgy]/g;
-function groupShiftTable(rawLookarounds, roles) {
-    const shiftForGroup = [0];
-    let markerCount = 0;
-    let rawLookaroundIndex = 0;
-    for (const role of roles) {
-        switch (role) {
-            case "backreference":
-            case "truncationEnd":
-                markerCount++;
-                break;
-            case "groupOpen":
-                shiftForGroup.push(markerCount);
-                break;
-            case "rawLookaround": {
-                const { capturingGroupsOpened } = rawLookarounds[rawLookaroundIndex++];
-                for (let i = 0; i < capturingGroupsOpened; i++) {
-                    shiftForGroup.push(markerCount);
-                }
-                break;
-            }
-            case "plain":
-                break;
-        }
-    }
-    return shiftForGroup;
-}
-function renumberedToken(backreference, shiftForGroup) {
-    return isNumericBackreference(backreference)
-        ? "\\" + String(backreference.ref + shiftForGroup[backreference.ref])
-        : "\\k<" + backreference.ref + ">";
-}
-function renumberRawBackreferences(part, info, shiftForGroup, declaresNamedGroup) {
-    let renumbered = "";
-    let cursor = 0;
-    for (const backreference of info.backreferences) {
-        const relativeStart = backreference.start - info.sourceStart;
-        const relativeEnd = backreference.end - info.sourceStart;
-        renumbered +=
-            part.slice(cursor, relativeStart) +
-                rawReferenceReplacement(part.slice(relativeStart, relativeEnd), backreference, shiftForGroup, declaresNamedGroup);
-        cursor = relativeEnd;
-    }
-    return renumbered + part.slice(cursor);
-}
-function rawReferenceReplacement(spelling, backreference, shiftForGroup, declaresNamedGroup) {
-    if (isNumericBackreference(backreference)) {
-        return backreference.ref >= 1 && backreference.ref < shiftForGroup.length
-            ? "\\" + String(backreference.ref + shiftForGroup[backreference.ref])
-            : legacyEscapeAsLiteral(spelling.slice(1));
-    }
-    return declaresNamedGroup ? spelling : "k" + spelling.slice(2);
-}
-export const buildTruncationProbe = (parts, rawLookarounds, namedGroupOpenings, flags) => {
-    const declaresNamedGroup = namedGroupOpenings.length > 0;
-    const declaredNames = namedGroupOpenings.map((opening) => decodeGroupName(groupNameOf(opening)));
-    let markerName = TRUNCATION_MARKER_NAME;
-    while (declaredNames.some((name) => name.startsWith(markerName))) {
-        markerName += "_";
-    }
-    const roles = parts.map(roleOf);
-    const shiftForGroup = groupShiftTable(rawLookarounds, roles);
-    let markerCount = 0;
-    let rawLookaroundIndex = 0;
-    const probed = parts.map((part, index) => {
-        if (isBackreference(part)) {
-            const marker = "|(?<" + markerName + String(markerCount++) + ">)";
-            return (OPTIONAL_ATOM_OPENING +
-                renumberedToken(part, shiftForGroup) +
-                marker +
-                DISJUNCTION_TO_END_OF_INPUT.slice(1));
-        }
-        if (roles[index] === "rawLookaround") {
-            return renumberRawBackreferences(part, rawLookarounds[rawLookaroundIndex++], shiftForGroup, declaresNamedGroup);
-        }
-        if (roles[index] !== "truncationEnd")
-            return part;
-        const marker = "|(?<" + markerName + String(markerCount++) + ">)";
-        return (part.slice(0, -DISJUNCTION_TO_END_OF_INPUT.length) +
-            marker +
-            DISJUNCTION_TO_END_OF_INPUT.slice(1));
-    });
-    return {
-        regex: new RegExp(probed.join(""), flags.replace(FLAGS_INCOMPATIBLE_WITH_PROBING, "") + "y"),
-        markerName,
-        markerCount
-    };
-};
-export const tookTruncationBranch = (probe, input, index) => {
-    var _a, _b;
-    const { regex, markerName, markerCount } = probe;
-    regex.lastIndex = index;
-    const markers = (_b = (_a = regex.exec(input)) === null || _a === void 0 ? void 0 : _a.groups) !== null && _b !== void 0 ? _b : {};
-    for (let marker = 0; marker < markerCount; marker++) {
-        if (markers[markerName + String(marker)] !== undefined)
-            return true;
-    }
-    return false;
-};

package/lib/partialMatchRegExp/isComplete/truncationProbeCache.d.ts

@@ -1,4 +0,0 @@
-import type { TruncationProbe } from "./truncationProbe.ts";
-export interface TruncationProbeCache {
-    probe: TruncationProbe | undefined;
-}

package/lib/partialMatchRegExp/partialMatchRegExp.d.ts

@@ -1,55 +0,0 @@
-import type { CompiledPartial } from "./compilePartial/compiled.ts";
-import { compiledPartial, truncationProbeCache } from "./partialMatchInternals.ts";
-import type { TruncationProbeCache } from "./isComplete/truncationProbeCache.ts";
-import type { RegexFeature } from "./regexFeatures.ts";
-export type { RegexFeature };
-/**
- * A `RegExp` subclass that supports partial (prefix) matching.
- *
- * An instance behaves like a normal `RegExp` but also matches any input string
- * that is a valid prefix of the original pattern — i.e. strings that could still
- * lead to a full match with more input. This enables validation of incomplete
- * input strings.
- *
- * @example
- * ```typescript
- * const pattern = /^hello world/;
- * const partial = new PartialMatchRegExp(pattern);
- *
- * partial.test('h');           // true - could match
- * partial.test('hello');       // true - could match
- * partial.test('hello world'); // true - full match
- * partial.test('goodbye');     // false - cannot match
- * ```
- *
- * @remarks
- * - The transformed pattern always matches an empty string at the end of input;
- *   use a start anchor (`^`) to prevent false positives from empty string matches
- * - The `y` (sticky) flag may not behave as expected in partial matching scenarios
- *
- * @see {@link https://github.com/TomStrepsil/regex-partial-match#readme | Documentation}
- */
-declare class PartialMatchRegExp extends RegExp {
-    [compiledPartial]: CompiledPartial;
-    [truncationProbeCache]: TruncationProbeCache;
-    constructor(pattern: RegExp | string, flags?: string);
-    /**
-     * The syntactic constructs the original pattern uses, recorded as a side
-     * effect of the single walk that builds the partial-match regex.
-     *
-     * The set is built on first read and cached, so patterns that are only ever
-     * matched against never pay for it. It iterates in `RegexFeature` declaration
-     * order, not the order the constructs appear in the pattern.
-     *
-     * @returns The features the original pattern contains
-     *
-     * @example
-     * ```typescript
-     * new PartialMatchRegExp(/^[a-z]+/).features.has("startAnchor"); // true
-     * ```
-     */
-    get features(): ReadonlySet<RegexFeature>;
-    exec(input: string): RegExpExecArray | null;
-    private _execDynamic;
-}
-export default PartialMatchRegExp;