regex-partial-match 1.1.2 → 1.2.0

package/README.md

@@ -372,13 +372,14 @@ This is useful for consumers building on top of `PartialMatchRegExp` who need to
 
 - **Flagging patterns likely to hit one of the [caveats](#caveats) documented above.** For example, a pattern combining `backreference` with `lookbehind`, `negativeLookahead`, or `negativeLookbehind` is a candidate for the [atomic-backreference caveat](#backreferences); one combining `backreference` with `disjunction` is a candidate for the [prefix-ambiguous top-level alternation caveat](#prefix-ambiguous-top-level-alternation). A consumer accepting user-supplied patterns can surface a warning instead of letting the edge case surprise someone later.
 - **Restricting which constructs a product surface allows.** e.g. a system that only wants to accept "simple" patterns (no lookaround, no backreferences) from untrusted input can check `features` against an allow-list and reject the rest, without needing to hand-roll that check against the raw pattern source.
+- **Deciding at construction time whether a pattern needs a careful path.** A capture nested inside a lookaround is decided by the assertion rather than by the consumed text, so its value can vary with how far the input has been seen. `features.has("lookaroundCapture")` isolates exactly those patterns, where `features.has("lookahead") && features.has("capturingGroup")` would also catch the ordinary `/(\w+)(?= END)/`.
 
 ```javascript
 import PartialMatchRegExp from "regex-partial-match";
 
 const partial = new PartialMatchRegExp(/^[a-z]+(?<domain>\.[a-z]+)\1/);
 
-partial.features; // Set { "startAnchor", "characterClass", "quantifier", "namedGroup", "capturingGroup", "backreference" }
+partial.features; // Set { "startAnchor", "backreference", "namedGroup", "capturingGroup", "characterClass", "quantifier", "otherEscape" }
 partial.features.has("backreference"); // true
 ```
 
@@ -399,6 +400,7 @@ partial.features.has("backreference"); // true
 | `namedBackreference`         | `\k<name>`                                              |                                                                                 |
 | `namedGroup`                 | `(?<name>...)`                                          | Always accompanied by `capturingGroup` — see below                            |
 | `capturingGroup`             | `(...)`, including named groups                        |                                                                                 |
+| `lookaroundCapture`          | A capturing group inside any lookaround                | Nesting, not a construct — always accompanied by `capturingGroup`             |
 | `nonCapturingGroup`          | `(?:...)`                                               |                                                                                 |
 | `modifierGroup`              | `(?ims:...)`                                            |                                                                                 |
 | `modifierGroupWithRemoval`   | `(?ims-ims:...)`                                        | Mutually exclusive with `modifierGroup`                                       |
@@ -416,10 +418,11 @@ partial.features.has("backreference"); // true
 | `unicodeEscapeSequence`      | `\uXXXX`, `\u{...}`                                     |                                                                                 |
 | `otherEscape`                 | Any other `\X`, e.g. `\.`, `\0`                         |                                                                                 |
 
-Two things worth knowing about how these tags line up with the grammar:
+Three things worth knowing about how these tags line up with the grammar:
 
 - **One ECMA-262 production can map to several tags.** `Assertion` alone covers `^`, `$`, `\b`, `\B`, and all four lookarounds — `features` splits it by whichever discriminant is easiest to read off during the walk (`^` vs `$`, `=` vs `!` after `(?<`, etc.), since that information is free at the point each construct is recognised.
 - **A named capturing group always carries both `namedGroup` and `capturingGroup`.** The grammar treats a capturing group with a name and one without as the same production (`( GroupSpecifier? Disjunction )`), not two, so both tags are added together.
+- **`lookaroundCapture` records nesting, not a construct.** Every other tag names something the source contains; this one names where something sits — a capturing group appearing lexically inside `(?=...)`, `(?!...)`, `(?<=...)` or `(?<!...)`, at any depth of nested groups. It is the one relationship between constructs the flattened set cannot otherwise express: `/(\w+)(?= END)/` and `/a(?=(?:b(?:x|(c))d|b))/` both report `lookahead` and `capturingGroup`, but only the second has a capture whose value the assertion decides.
 
 ## 📜 License
 

package/lib/compilePartial.d.ts

@@ -1,16 +1,26 @@
-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";
+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;
 }
-export type CompiledPartial = ({
-    kind: "static";
-    regex: RegExp;
-} | {
-    kind: "dynamic";
-    dynamic: DynamicPath;
-}) & {
-    features: Set<RegexFeature>;
-};
+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 {};

package/lib/compilePartial.js

@@ -3,18 +3,63 @@ 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 source = regex.source;
     const isUnicode = regex.unicode || regex.unicodeSets;
     let i = 0;
     let groupCount = 0;
-    const features = new Set();
+    let featureMask = 0;
     function extractSlice(length) {
         return source.slice(i, (i += length));
     }
-    function process() {
+    function process(withinLookaround) {
         var _a;
         const result = [];
         function appendOptional(length) {
@@ -23,10 +68,10 @@ function walk(regex) {
         function appendRaw(length) {
             result.push(extractSlice(length));
         }
-        function appendRawGroup(prefixLength) {
+        function appendRawLookaround(prefixLength) {
             const start = i;
             i += prefixLength;
-            process();
+            process(true);
             result.push(source.slice(start, i));
         }
         while (i < source.length) {
@@ -34,7 +79,7 @@ function walk(regex) {
                 case "\\":
                     switch (source[i + 1]) {
                         case "c":
-                            features.add("controlLetterEscape");
+                            featureMask |= FEATURE_BIT.controlLetterEscape;
                             appendOptional(3);
                             break;
                         case "k": {
@@ -43,7 +88,7 @@ function walk(regex) {
                                 appendOptional(2);
                             }
                             else {
-                                features.add("namedBackreference");
+                                featureMask |= FEATURE_BIT.namedBackreference;
                                 const start = i;
                                 const ref = source.slice(i + 3, referenceEnd);
                                 i = referenceEnd + 1;
@@ -52,7 +97,7 @@ function walk(regex) {
                             break;
                         }
                         case "u":
-                            features.add("unicodeEscapeSequence");
+                            featureMask |= FEATURE_BIT.unicodeEscapeSequence;
                             if (isUnicode && source[i + 2] === "{") {
                                 appendOptional(source.indexOf("}", i) - i + 1);
                             }
@@ -63,7 +108,7 @@ function walk(regex) {
                         case "p":
                         case "P":
                             if (isUnicode) {
-                                features.add("unicodePropertyEscape");
+                                featureMask |= FEATURE_BIT.unicodePropertyEscape;
                                 appendOptional(source.indexOf("}", i) - i + 1);
                             }
                             else {
@@ -71,15 +116,15 @@ function walk(regex) {
                             }
                             break;
                         case "x":
-                            features.add("hexEscapeSequence");
+                            featureMask |= FEATURE_BIT.hexEscapeSequence;
                             appendOptional(4);
                             break;
                         case "b":
-                            features.add("wordBoundary");
+                            featureMask |= FEATURE_BIT.wordBoundary;
                             appendOptional(2);
                             break;
                         case "B":
-                            features.add("nonWordBoundary");
+                            featureMask |= FEATURE_BIT.nonWordBoundary;
                             appendOptional(2);
                             break;
                         case "f":
@@ -87,7 +132,7 @@ function walk(regex) {
                         case "r":
                         case "t":
                         case "v":
-                            features.add("controlEscape");
+                            featureMask |= FEATURE_BIT.controlEscape;
                             appendOptional(2);
                             break;
                         case "1":
@@ -99,7 +144,7 @@ function walk(regex) {
                         case "7":
                         case "8":
                         case "9": {
-                            features.add("backreference");
+                            featureMask |= FEATURE_BIT.backreference;
                             NOT_NUMBERS_REGEX.lastIndex = i + 1;
                             const nextNonDigit = NOT_NUMBERS_REGEX.exec(source);
                             const start = i;
@@ -115,17 +160,17 @@ function walk(regex) {
                         case "W":
                         case "s":
                         case "S":
-                            features.add("characterClassEscape");
+                            featureMask |= FEATURE_BIT.characterClassEscape;
                             appendOptional(2);
                             break;
                         default:
-                            features.add("otherEscape");
+                            featureMask |= FEATURE_BIT.otherEscape;
                             appendOptional(2);
                             break;
                     }
                     break;
                 case "[": {
-                    features.add("characterClass");
+                    featureMask |= FEATURE_BIT.characterClass;
                     let depth = 1, j = i + 1, previousSetOperatorCharacter;
                     while (depth) {
                         const character = source[j];
@@ -136,7 +181,7 @@ function walk(regex) {
                                 continue;
                             case "[":
                                 if (regex.unicodeSets) {
-                                    features.add("nestedCharacterClass");
+                                    featureMask |= FEATURE_BIT.nestedCharacterClass;
                                     depth++;
                                 }
                                 break;
@@ -145,12 +190,12 @@ function walk(regex) {
                                 break;
                             case "&":
                                 if (regex.unicodeSets && previousSetOperatorCharacter === "&") {
-                                    features.add("classIntersection");
+                                    featureMask |= FEATURE_BIT.classIntersection;
                                 }
                                 break;
                             case "-":
                                 if (regex.unicodeSets && previousSetOperatorCharacter === "-") {
-                                    features.add("classSubtraction");
+                                    featureMask |= FEATURE_BIT.classSubtraction;
                                 }
                                 break;
                         }
@@ -161,28 +206,28 @@ function walk(regex) {
                     break;
                 }
                 case "^":
-                    features.add("startAnchor");
+                    featureMask |= FEATURE_BIT.startAnchor;
                     appendRaw(1);
                     break;
                 case "$":
-                    features.add("endAnchor");
+                    featureMask |= FEATURE_BIT.endAnchor;
                     appendRaw(1);
                     break;
                 case "|":
-                    features.add("disjunction");
+                    featureMask |= FEATURE_BIT.disjunction;
                     appendRaw(1);
                     break;
                 case "*":
                 case "+":
                 case "?":
-                    features.add("quantifier");
+                    featureMask |= FEATURE_BIT.quantifier;
                     appendRaw(1);
                     break;
                 case "{": {
                     OCCURRENCES_REGEX.lastIndex = i;
                     const regExpExecArray = OCCURRENCES_REGEX.exec(source);
                     if (regExpExecArray) {
-                        features.add("quantifier");
+                        featureMask |= FEATURE_BIT.quantifier;
                         appendRaw(regExpExecArray[0].length);
                     }
                     else {
@@ -194,16 +239,16 @@ function walk(regex) {
                     if (source[i + 1] == "?") {
                         switch (source[i + 2]) {
                             case ":":
-                                features.add("nonCapturingGroup");
+                                featureMask |= FEATURE_BIT.nonCapturingGroup;
                                 result.push("(?:");
                                 i += 3;
-                                result.push(...process(), DISJUNCTION_TO_END_OF_INPUT);
+                                result.push(...process(withinLookaround), DISJUNCTION_TO_END_OF_INPUT);
                                 break;
                             case "=":
-                                features.add("lookahead");
+                                featureMask |= FEATURE_BIT.lookahead;
                                 result.push("(?=");
                                 i += 3;
-                                result.push(...process(), ")");
+                                result.push(...process(true), ")");
                                 break;
                             case "-":
                             case "i":
@@ -211,63 +256,69 @@ function walk(regex) {
                             case "m": {
                                 const flagsStart = i + 2, colonIndex = source.indexOf(":", flagsStart);
                                 const modifiers = source.slice(flagsStart, colonIndex);
-                                features.add(modifiers.includes("-")
-                                    ? "modifierGroupWithRemoval"
-                                    : "modifierGroup");
+                                featureMask |= modifiers.includes("-")
+                                    ? FEATURE_BIT.modifierGroupWithRemoval
+                                    : FEATURE_BIT.modifierGroup;
                                 result.push("(?" + modifiers + ":");
                                 i = colonIndex + 1;
-                                result.push(...process(), ")");
+                                result.push(...process(withinLookaround), ")");
                                 break;
                             }
                             case "!":
-                                features.add("negativeLookahead");
-                                appendRawGroup(3);
+                                featureMask |= FEATURE_BIT.negativeLookahead;
+                                appendRawLookaround(3);
                                 break;
                             case "<":
                                 switch (source[i + 3]) {
                                     case "=":
-                                        features.add("lookbehind");
-                                        appendRawGroup(4);
+                                        featureMask |= FEATURE_BIT.lookbehind;
+                                        appendRawLookaround(4);
                                         break;
                                     case "!":
-                                        features.add("negativeLookbehind");
-                                        appendRawGroup(4);
+                                        featureMask |= FEATURE_BIT.negativeLookbehind;
+                                        appendRawLookaround(4);
                                         break;
                                     default:
-                                        features.add("namedGroup");
-                                        features.add("capturingGroup");
+                                        featureMask |= FEATURE_BIT.namedGroup;
+                                        featureMask |= FEATURE_BIT.capturingGroup;
+                                        if (withinLookaround)
+                                            featureMask |= FEATURE_BIT.lookaroundCapture;
                                         ++groupCount;
                                         appendRaw(source.indexOf(">", i) - i + 1);
-                                        result.push(...process(), DISJUNCTION_TO_END_OF_INPUT);
+                                        result.push(...process(withinLookaround), DISJUNCTION_TO_END_OF_INPUT);
                                         break;
                                 }
                                 break;
                         }
                     }
                     else {
-                        features.add("capturingGroup");
+                        featureMask |= FEATURE_BIT.capturingGroup;
+                        if (withinLookaround)
+                            featureMask |= FEATURE_BIT.lookaroundCapture;
                         ++groupCount;
                         appendRaw(1);
-                        result.push(...process(), DISJUNCTION_TO_END_OF_INPUT);
+                        result.push(...process(withinLookaround), DISJUNCTION_TO_END_OF_INPUT);
                     }
                     break;
                 case ")":
                     ++i;
                     return result;
                 default:
-                    features.add("patternCharacter");
+                    featureMask |= FEATURE_BIT.patternCharacter;
                     appendOptional(isUnicode && ((_a = source.codePointAt(i)) !== null && _a !== void 0 ? _a : 0) > 0xffff ? 2 : 1);
                     break;
             }
         }
         return result;
     }
-    return { parts: process(), groupCount, features };
+    return { parts: process(false), groupCount, featureMask };
 }
 function render(parts, renderBackref) {
-    return parts
-        .map((part) => (isBackreference(part) ? renderBackref(part) : part))
-        .join("");
+    let rendered = "";
+    for (const part of parts) {
+        rendered += isBackreference(part) ? renderBackref(part) : part;
+    }
+    return rendered;
 }
 function backrefToken(backref) {
     return isNumericBackreference(backref)
@@ -283,7 +334,7 @@ function spliceOriginalSource(source, backrefs) {
     let result = "";
     let cursor = 0;
     for (const { start, end } of backrefs) {
-        result += source.slice(cursor, start) + "(?:[\\s\\S]*?)";
+        result += source.slice(cursor, start) + ANY_CAPTURED_TEXT;
         cursor = end;
     }
     return result + source.slice(cursor);
@@ -293,14 +344,34 @@ function expandCaptured(value, isUnicode) {
         .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";
+    }
+}
 export const compilePartial = (regex) => {
-    const { parts, groupCount, features } = walk(regex);
+    const { parts, groupCount, featureMask } = walk(regex);
+    const flags = regex.flags;
     if (!MAYBE_HAS_BACKREFERENCE_REGEX.test(regex.source)) {
-        return {
-            kind: "static",
-            regex: new RegExp(render(parts, backrefToken), regex.flags),
-            features
-        };
+        return new CompiledStatic(new RegExp(render(parts, backrefToken), flags), featureMask);
     }
     const isUnicode = regex.unicode || regex.unicodeSets;
     const sanitisedParts = isUnicode
@@ -308,27 +379,19 @@ export const compilePartial = (regex) => {
         : reclassifyOctalEscapes(parts, regex.source, groupCount);
     const backreferences = sanitisedParts.filter(isBackreference);
     if (backreferences.length === 0) {
-        return {
-            kind: "static",
-            regex: new RegExp(render(sanitisedParts, backrefToken), regex.flags),
-            features
-        };
+        return new CompiledStatic(new RegExp(render(sanitisedParts, backrefToken), flags), featureMask);
     }
-    return {
-        kind: "dynamic",
-        features,
-        dynamic: {
-            originalCaptureScan: new RegExp(spliceOriginalSource(regex.source, backreferences), regex.flags),
-            preScan: new RegExp(render(parts, () => "(?:[\\s\\S]*?)"), regex.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);
-            })
-        }
-    };
+    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/lib/partialMatchRegExp.d.ts

@@ -1,5 +1,6 @@
 import { type RegexFeature } from "./compilePartial.ts";
 export type { RegexFeature };
+declare const compiledPartial: unique symbol;
 /**
  * A `RegExp` subclass that supports partial (prefix) matching.
  *
@@ -27,9 +28,24 @@ export type { RegexFeature };
  * @see {@link https://github.com/TomStrepsil/regex-partial-match#readme | Documentation}
  */
 declare class PartialMatchRegExp extends RegExp {
-    #private;
-    readonly features: ReadonlySet<RegexFeature>;
+    private [compiledPartial];
     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;
 }

package/lib/partialMatchRegExp.js

@@ -1,16 +1,5 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _PartialMatchRegExp_compiledPartial;
 import { compilePartial } from "./compilePartial.js";
+const compiledPartial = Symbol("compiledPartial");
 /**
  * A `RegExp` subclass that supports partial (prefix) matching.
  *
@@ -40,12 +29,28 @@ import { compilePartial } from "./compilePartial.js";
 class PartialMatchRegExp extends RegExp {
     constructor(pattern, flags) {
         super(pattern, flags);
-        _PartialMatchRegExp_compiledPartial.set(this, void 0);
-        __classPrivateFieldSet(this, _PartialMatchRegExp_compiledPartial, compilePartial(this), "f");
-        this.features = __classPrivateFieldGet(this, _PartialMatchRegExp_compiledPartial, "f").features;
+        this[compiledPartial] = compilePartial(this);
+    }
+    /**
+     * 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() {
+        return this[compiledPartial].features;
     }
     exec(input) {
-        const compiled = __classPrivateFieldGet(this, _PartialMatchRegExp_compiledPartial, "f");
+        const compiled = this[compiledPartial];
         if (compiled.kind === "dynamic")
             return this._execDynamic(compiled.dynamic, input);
         const { regex } = compiled;
@@ -81,7 +86,6 @@ class PartialMatchRegExp extends RegExp {
         return match;
     }
 }
-_PartialMatchRegExp_compiledPartial = new WeakMap();
 function execFrom(regex, input, start) {
     regex.lastIndex = start;
     return regex.exec(input);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "regex-partial-match",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "A regular expression transform for partial matching",
   "devEngines": {
     "runtime": {
@@ -78,11 +78,11 @@
     "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",
     "eslint": "^9.17.0",
     "jiti": "^2.6.1",
     "lint-staged": "^15.2.11",