regex-partial-match 1.2.0 → 2.0.0

package/lib/partialMatchRegExp/walk.js

@@ -0,0 +1,412 @@
+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;
+    let i = 0;
+    let groupCount = 0;
+    let featureMask = 0;
+    let needs = 0;
+    let rawLookaroundCount = 0;
+    let outermostRawLookaroundCount = 0;
+    let rawLookarounds;
+    let rawReferences;
+    let lastBodyRunsOut = false;
+    function extractSlice(length) {
+        return source.slice(i, (i += length));
+    }
+    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) {
+            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) {
+            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;
+            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;
+            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));
+        }
+        while (i < source.length) {
+            switch (source[i]) {
+                case "\\":
+                    switch (source[i + 1]) {
+                        case "c":
+                            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 |= 1024 /* Feature.namedBackreference */;
+                                const ref = source.slice(i + 3, referenceEnd);
+                                i = referenceEnd + 1;
+                                if (result.length === alternativeStart)
+                                    alternativeRunsOut = true;
+                                appendBackreference({ ref });
+                            }
+                            else {
+                                i += 2;
+                                if (result.length === alternativeStart)
+                                    alternativeRunsOut = true;
+                                result.push(asOptionalAtom(LITERAL_K));
+                            }
+                            break;
+                        }
+                        case "u":
+                            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 {
+                                featureMask |= 536870912 /* Feature.otherEscape */;
+                                appendOptional(2);
+                            }
+                            break;
+                        case "p":
+                        case "P":
+                            if (scope & UNICODE) {
+                                featureMask |= 8388608 /* Feature.unicodePropertyEscape */;
+                                appendOptional(source.indexOf("}", i) - i + 1);
+                            }
+                            else {
+                                appendOptional(2);
+                            }
+                            break;
+                        case "x":
+                            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 |= 8 /* Feature.wordBoundary */;
+                            appendOptional(2);
+                            break;
+                        case "B":
+                            featureMask |= 16 /* Feature.nonWordBoundary */;
+                            appendOptional(2);
+                            break;
+                        case "f":
+                        case "n":
+                        case "r":
+                        case "t":
+                        case "v":
+                            featureMask |= 33554432 /* Feature.controlEscape */;
+                            appendOptional(2);
+                            break;
+                        case "0":
+                            if (scope & UNICODE) {
+                                featureMask |= 536870912 /* Feature.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 |= 16777216 /* Feature.characterClassEscape */;
+                            appendOptional(2);
+                            break;
+                        default:
+                            featureMask |= 536870912 /* Feature.otherEscape */;
+                            appendOptional(2);
+                            break;
+                    }
+                    break;
+                case "[": {
+                    featureMask |= 131072 /* Feature.characterClass */;
+                    let depth = 1, j = i + 1, previousSetOperatorCharacter;
+                    while (depth) {
+                        const character = source[j];
+                        switch (character) {
+                            case "\\":
+                                j += 2;
+                                previousSetOperatorCharacter = undefined;
+                                continue;
+                            case "[":
+                                if (scope & UNICODE_SETS) {
+                                    featureMask |= 262144 /* Feature.nestedCharacterClass */;
+                                    depth++;
+                                }
+                                break;
+                            case "]":
+                                depth--;
+                                break;
+                            case "&":
+                                if (scope & UNICODE_SETS &&
+                                    previousSetOperatorCharacter === "&") {
+                                    featureMask |= 524288 /* Feature.classIntersection */;
+                                }
+                                break;
+                            case "-":
+                                if (scope & UNICODE_SETS &&
+                                    previousSetOperatorCharacter === "-") {
+                                    featureMask |= 1048576 /* Feature.classSubtraction */;
+                                }
+                                break;
+                        }
+                        previousSetOperatorCharacter = character;
+                        j++;
+                    }
+                    appendOptional(j - i);
+                    break;
+                }
+                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 |= 4 /* Feature.endAnchor */;
+                    appendRaw(1);
+                    break;
+                case "|":
+                    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 |= 4194304 /* Feature.quantifier */;
+                    appendRaw(1);
+                    break;
+                case "{": {
+                    OCCURRENCES_REGEX.lastIndex = i;
+                    const regExpExecArray = OCCURRENCES_REGEX.exec(source);
+                    if (regExpExecArray) {
+                        featureMask |= 4194304 /* Feature.quantifier */;
+                        appendRaw(regExpExecArray[0].length);
+                    }
+                    else {
+                        appendOptional(1);
+                    }
+                    break;
+                }
+                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 |= 16384 /* Feature.nonCapturingGroup */;
+                                opening = extractSlice(3);
+                                break;
+                            case "=": {
+                                featureMask |= 32 /* Feature.lookahead */;
+                                i += 3;
+                                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 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 |= 64 /* Feature.negativeLookahead */;
+                                appendRawLookaround(3);
+                                break;
+                            case "<":
+                                switch (source[i + 3]) {
+                                    case "=":
+                                        featureMask |= 128 /* Feature.lookbehind */;
+                                        appendRawLookaround(4);
+                                        break;
+                                    case "!":
+                                        featureMask |= 256 /* Feature.negativeLookbehind */;
+                                        appendRawLookaround(4);
+                                        break;
+                                    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 |= 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 |= 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
+                    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(scopeOf(regex));
+    return { parts, featureMask, needs, rawLookarounds };
+}

package/lib/partialMatchRegExp/withModules.d.ts

@@ -0,0 +1,13 @@
+import type { Module } from "./opaqueModule.ts";
+import type { PartialMatchRegExpConstructor } from "./index.ts";
+/**
+ * The `PartialMatchRegExp` class that applies the rules the given modules
+ * supply.
+ *
+ * The same set of modules, in any order, returns the same class.
+ *
+ * @param modules - The modules to bind, from `regex-partial-match/modules`
+ * @returns The `PartialMatchRegExp` class that binds `modules`
+ * @throws `TypeError` if any argument is not a module
+ */
+export default function withModules(...modules: Module[]): PartialMatchRegExpConstructor;

package/lib/partialMatchRegExp/withModules.js

@@ -0,0 +1,27 @@
+import createPartialMatchRegExp from "./createPartialMatchRegExp.js";
+import { definedModuleHooks, moduleHooks } from "./moduleHooks.js";
+const boundByModuleMask = [];
+const isDefinedHooks = (value) => definedModuleHooks.has(value);
+/**
+ * The `PartialMatchRegExp` class that applies the rules the given modules
+ * supply.
+ *
+ * The same set of modules, in any order, returns the same class.
+ *
+ * @param modules - The modules to bind, from `regex-partial-match/modules`
+ * @returns The `PartialMatchRegExp` class that binds `modules`
+ * @throws `TypeError` if any argument is not a module
+ */
+export default function withModules(...modules) {
+    const hooks = {};
+    let moduleMask = 0;
+    for (const module of modules) {
+        const bound = Reflect.get(Object(module), moduleHooks);
+        if (!isDefinedHooks(bound))
+            throw new TypeError("Not a module");
+        moduleMask |= bound.bit;
+        Object.assign(hooks, bound);
+    }
+    return (boundByModuleMask[moduleMask] ||
+        (boundByModuleMask[moduleMask] = createPartialMatchRegExp(Object.freeze(hooks))));
+}

package/package.json

@@ -1,17 +1,7 @@
 {
   "name": "regex-partial-match",
-  "version": "1.2.0",
+  "version": "2.0.0",
   "description": "A regular expression transform for partial matching",
-  "devEngines": {
-    "runtime": {
-      "name": "node",
-      "version": ">=23"
-    },
-    "packageManager": {
-      "name": "npm",
-      "version": "11.17.0+sha512.3eeaf18997b11070d313849268b23766b9db0068997dec9471073170fe43fa17f2b4d0337bf0f52330ee2274e7f5754b21b01052742e48f5c9c74d8b1e32ef43"
-    }
-  },
   "keywords": [
     "regexp",
     "regular expressions",
@@ -33,17 +23,52 @@
     }
   ],
   "type": "module",
-  "main": "lib/partialMatchRegExp.js",
+  "main": "lib/index.js",
   "exports": {
     ".": {
-      "types": "./lib/partialMatchRegExp.d.ts",
-      "import": "./lib/partialMatchRegExp.js",
-      "default": "./lib/partialMatchRegExp.js"
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js",
+      "default": "./lib/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/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": [
@@ -53,42 +78,10 @@
     "type": "git",
     "url": "git+https://github.com/TomStrepsil/regex-partial-match.git"
   },
-  "workspaces": [
-    "benchmarking"
+  "sideEffects": [
+    "./lib/extend/index.js"
   ],
-  "sideEffects": false,
-  "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"
-  },
-  "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",
-    "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/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 {};