regex-partial-match 1.1.0 → 1.1.1

package/README.md

@@ -71,7 +71,7 @@ Such combinations have not been tested.
 
 ### Patterns with backreferences
 
-Backreferences cannot be handled by the `|$(?![\s\S])` transform alone because they are atomic — `\1` must match the entire captured string or fail, and its length is only known at runtime. `PartialMatchRegExp` first tries a full match natively, as a short-circuit — if the input already satisfies the whole pattern, there's nothing further to do. Otherwise it runs a "capture scan": a variant of the pattern with each backreference swapped for a lazy `(?:[\s\S]*?)` wildcard, so the group it depends on can still capture against a partial input — matching anything, or nothing at all, without needing to already know the backreference's value. 
+Backreferences cannot be handled by the `|$(?![\s\S])` transform alone because they are atomic — `\1` must match the entire captured string or fail, and its length is only known at runtime. `PartialMatchRegExp` first tries a full match natively, but that native result only wins outright if nothing earlier in the input could still be a viable partial — a cheap bound check settles that without needing to resolve the backreference's actual value, so the common case (no earlier partial exists) stays fast. Otherwise it runs a "capture scan": a variant of the pattern with each backreference swapped for a lazy `(?:[\s\S]*?)` wildcard, so the group it depends on can still capture against a partial input — matching anything, or nothing at all, without needing to already know the backreference's value. 
 
 Whatever that scan captures (or leaves `undefined`, if the group hasn't been reached yet) is then used to build a fresh partial-matching regex for this specific input, expanding the backreference character-by-character from the captured value with the same per-atom transform as the rest of the pattern. See [docs/backreferences.md](./docs/backreferences.md) for the full algorithm, including the prefer-longer post-processing that preserves correct captures for groups inside quantifiers.
 
@@ -418,7 +418,7 @@ partial.features.has("backreference"); // true
 
 Two 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 recognized.
+- **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.
 
 ## 📜 License

package/lib/compilePartial.js

@@ -1,8 +1,8 @@
 import escapeAtom from "./escapeAtom.js";
 const OCCURRENCES_REGEX = /\{\d+,?\d*\}/y;
 const NOT_NUMBERS_REGEX = /\D/g;
+const MAYBE_HAS_BACKREFERENCE_REGEX = /\\[1-9]|\\k</;
 const DISJUNCTION_TO_END_OF_INPUT = "|$(?![\\s\\S]))";
-const MAYBE_HAS_BACKREFERENCE = /\\[1-9]|\\k</;
 const isBackreference = (part) => typeof part !== "string";
 const isNumericBackreference = (part) => isBackreference(part) && typeof part.ref === "number";
 function walk(regex) {
@@ -295,7 +295,7 @@ function expandCaptured(value, isUnicode) {
 }
 export const compilePartial = (regex) => {
     const { parts, groupCount, features } = walk(regex);
-    if (!MAYBE_HAS_BACKREFERENCE.test(regex.source)) {
+    if (!MAYBE_HAS_BACKREFERENCE_REGEX.test(regex.source)) {
         return {
             kind: "static",
             regex: new RegExp(render(parts, backrefToken), regex.flags),
@@ -303,14 +303,14 @@ export const compilePartial = (regex) => {
         };
     }
     const isUnicode = regex.unicode || regex.unicodeSets;
-    const sanitizedParts = isUnicode
+    const sanitisedParts = isUnicode
         ? parts
         : reclassifyOctalEscapes(parts, regex.source, groupCount);
-    const backreferences = sanitizedParts.filter(isBackreference);
+    const backreferences = sanitisedParts.filter(isBackreference);
     if (backreferences.length === 0) {
         return {
             kind: "static",
-            regex: new RegExp(render(sanitizedParts, backrefToken), regex.flags),
+            regex: new RegExp(render(sanitisedParts, backrefToken), regex.flags),
             features
         };
     }

package/lib/partialMatchRegExp.js

@@ -9,7 +9,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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_static, _PartialMatchRegExp_dynamic;
+var _PartialMatchRegExp_instances, _PartialMatchRegExp_compiledPartial, _PartialMatchRegExp_execDynamic;
 import { compilePartial } from "./compilePartial.js";
 /**
  * A `RegExp` subclass that supports partial (prefix) matching.
@@ -39,48 +39,56 @@ import { compilePartial } from "./compilePartial.js";
  */
 class PartialMatchRegExp extends RegExp {
     constructor(pattern, flags) {
-        var _a, _b;
         super(pattern, flags);
-        _PartialMatchRegExp_static.set(this, void 0);
-        _PartialMatchRegExp_dynamic.set(this, void 0);
-        const compiled = compilePartial(this);
-        _a = this, _b = this, [({ set value(_c) { __classPrivateFieldSet(_a, _PartialMatchRegExp_dynamic, _c, "f"); } }).value, ({ set value(_c) { __classPrivateFieldSet(_b, _PartialMatchRegExp_static, _c, "f"); } }).value] = compiled.kind === "dynamic"
-            ? [compiled.dynamic, null]
-            : [null, compiled.regex];
-        this.features = compiled.features;
+        _PartialMatchRegExp_instances.add(this);
+        _PartialMatchRegExp_compiledPartial.set(this, void 0);
+        __classPrivateFieldSet(this, _PartialMatchRegExp_compiledPartial, compilePartial(this), "f");
+        this.features = __classPrivateFieldGet(this, _PartialMatchRegExp_compiledPartial, "f").features;
     }
     exec(input) {
-        if (!__classPrivateFieldGet(this, _PartialMatchRegExp_dynamic, "f")) {
-            const partial = __classPrivateFieldGet(this, _PartialMatchRegExp_static, "f"); // eslint-disable-line @typescript-eslint/no-non-null-assertion -- #static is set whenever #dynamic is null
-            partial.lastIndex = this.lastIndex;
-            const match = partial.exec(input);
-            this.lastIndex = partial.lastIndex;
-            return match;
-        }
-        const start = this.lastIndex;
-        const originalMatch = super.exec(input);
-        if (originalMatch)
-            return originalMatch;
-        const { originalCaptureScan, preScan, expand } = __classPrivateFieldGet(this, _PartialMatchRegExp_dynamic, "f");
-        originalCaptureScan.lastIndex = start;
-        let capture = originalCaptureScan.exec(input);
-        if (capture === null) {
-            preScan.lastIndex = start;
-            capture = preScan.exec(input);
-        }
-        if (capture === null)
-            return null;
-        const expanded = new RegExp(expand(capture), this.flags);
-        expanded.lastIndex = start;
-        const match = expanded.exec(input);
-        if (match === null)
-            return null;
-        preferLongerCaptures(match, capture);
-        this.lastIndex = expanded.lastIndex;
+        const compiled = __classPrivateFieldGet(this, _PartialMatchRegExp_compiledPartial, "f");
+        if (compiled.kind === "dynamic")
+            return __classPrivateFieldGet(this, _PartialMatchRegExp_instances, "m", _PartialMatchRegExp_execDynamic).call(this, compiled.dynamic, input);
+        const { regex } = compiled;
+        const match = execFrom(regex, input, this.lastIndex);
+        this.lastIndex = regex.lastIndex;
         return match;
     }
 }
-_PartialMatchRegExp_static = new WeakMap(), _PartialMatchRegExp_dynamic = new WeakMap();
+_PartialMatchRegExp_compiledPartial = new WeakMap(), _PartialMatchRegExp_instances = new WeakSet(), _PartialMatchRegExp_execDynamic = function _PartialMatchRegExp_execDynamic(dynamic, input) {
+    var _a, _b;
+    const { originalCaptureScan, preScan, expand } = dynamic;
+    const honoursLastIndex = this.global || this.sticky;
+    const start = honoursLastIndex ? this.lastIndex : 0;
+    const originalMatch = super.exec(input);
+    if (isAtOrBefore(originalMatch, start))
+        return originalMatch;
+    let preScanMatch = null;
+    if (originalMatch) {
+        preScanMatch = execFrom(preScan, input, start);
+        const noEarlierPartialPossible = preScanMatch === null || preScanMatch.index >= originalMatch.index;
+        if (noEarlierPartialPossible)
+            return originalMatch;
+    }
+    const capture = (_b = (_a = execFrom(originalCaptureScan, input, start)) !== null && _a !== void 0 ? _a : preScanMatch) !== null && _b !== void 0 ? _b : execFrom(preScan, input, start);
+    if (capture === null)
+        return originalMatch;
+    const expanded = new RegExp(expand(capture), this.flags);
+    const match = execFrom(expanded, input, start);
+    if (match === null || isAtOrBefore(originalMatch, match.index))
+        return originalMatch;
+    preferLongerCaptures(match, capture);
+    if (honoursLastIndex)
+        this.lastIndex = expanded.lastIndex;
+    return match;
+};
+function execFrom(regex, input, start) {
+    regex.lastIndex = start;
+    return regex.exec(input);
+}
+function isAtOrBefore(match, index) {
+    return match !== null && match.index <= index;
+}
 function pickLonger(scanned, matched) {
     return scanned !== undefined &&
         matched !== undefined &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "regex-partial-match",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "A regular expression transform for partial matching",
   "devEngines": {
     "runtime": {