regex-partial-match 1.2.0 → 1.3.0

package/README.md

@@ -36,6 +36,39 @@ partial.test("hello world"); // true - full match
 partial.test("goodbye"); // false - cannot match
 ```
 
+### Telling a prefix from a complete match
+
+`test()` and `exec()` answer "could this match?", which is `true` for a prefix and for a complete match alike. [`isComplete()`](#iscompletepartial-partialmatchregexp-match-regexpexecarray-boolean) separates the two, testing the original pattern instead doesn't [^1], giving the three states progressive validation actually needs:
+
+```javascript
+import PartialMatchRegExp, { isComplete } from "regex-partial-match";
+
+const partial = new PartialMatchRegExp(/^\d{4}-\d{2}-\d{2}/);
+
+function state(input) {
+  const match = partial.exec(input);
+
+  if (match === null) return "invalid";
+  return isComplete(partial, match) ? "complete" : "incomplete";
+}
+
+state("20xx"); // 'invalid'    - reject
+state("2024"); // 'incomplete' - no error, keep typing
+state("2024-06"); // 'incomplete' - no error, keep typing
+state("2024-06-15"); // 'complete'   - accept, enable submit
+```
+
+[^1]: 
+    Testing the original, untransformed pattern looks like it should answer this — "did the input fully satisfy the original pattern?" — but it asks a different question: whether the original matches *at all* here, not whether *this* match got there by truncation. The two agree almost always, but a truncation branch firing inside a zero-width assertion can make both return an identical result by different paths. See [Why the question can't be answered from the outside](#why-the-question-cant-be-answered-from-the-outside) for the case where they diverge.
+
+### A note on Tree-Shaking
+
+If your environment doesn't tree-shake (e.g. Deno, or unbundled Node) and you have no use for `isComplete`, import `PartialMatchRegExp` from its own subpath instead of the default entry, to avoid pulling in `isComplete`'s code:
+
+```javascript
+import PartialMatchRegExp from "regex-partial-match/partialMatchRegExp";
+```
+
 ### Extending RegExp.prototype
 
 ```javascript
@@ -48,7 +81,7 @@ partial.test("hel"); // true
 
 ## ⚙️ How It Works
 
-The library transforms a regular expression by wrapping each [atomic element](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions#atoms) in a [non-capturing group](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Non-capturing_group) with a [disjunction](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Disjunction) to a true-end-of-input sentinel (`$(?![\s\S])`[^1]):
+The library transforms a regular expression by wrapping each [atomic element](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions#atoms) in a [non-capturing group](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Non-capturing_group) with a [disjunction](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Disjunction) to a true-end-of-input sentinel (`$(?![\s\S])`[^2]):
 
 ```javascript
 /abc/ → /(?:a|$(?![\s\S]))(?:b|$(?![\s\S]))(?:c|$(?![\s\S]))/
@@ -56,15 +89,17 @@ The library transforms a regular expression by wrapping each [atomic element](ht
 
 This allows the pattern to match prefixes of the original pattern, enabling validation of incomplete input.
 
-Since the library accepts only valid regular expressions [^2], this enables the algorithm to make lots of unguarded assumptions about the source of the expression.
+Since the library accepts only valid regular expressions [^3], this enables the algorithm to make lots of unguarded assumptions about the source of the expression.
 
 The library has been stress-tested with various regular expression features in isolation, and some in likely combination, but obviously it's an unbounded test space, and syntactically valid regular expressions nevertheless support contradictory patterns e.g.
 
 - `/\b\B/` - impossible to match both a word boundary and a non-word boundary
 - `/$^/` - end cannot come before start
 - `x{2}?` - lazy quantifiers are mutually exclusive to fixed-length assertions
+- `/[]/` - an empty character class matches nothing
+- `/(?=b)(?=c)/` - the next character cannot be two different characters
 
-Such combinations have not been tested.
+Contradictory patterns are not comprehensively supported and may partially match inappropriately.
 
 > [!NOTE]
 > See [Partial Match Parity](/docs/partial-match-parity.md) for full details on how the library compares to reference implementations
@@ -113,6 +148,8 @@ The library is compiled to **ES2015** (ECMAScript 6). Certain regular expression
 - [**`v` (unicodeSets) flag**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/unicodeSets) - ES2024+
 - [**Modifiers**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Modifier) (`(?ims:...)`, `(?-ims:...)`, `(?i-ms:...)`) - ES2025+
 
+Each of these applies only when the *original* pattern uses the feature — everything else, including construction, `exec()` and `test()`, holds to the ES2015 floor. [`isComplete()`](#iscompletepartial-partialmatchregexp-match-regexpexecarray-boolean) is the one exception: it always requires **ES2018+**, regardless of the pattern, since its internal probe uses named capturing groups.
+
 ## ⚠️ Caveats
 
 ### [`.test()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/test) behaviour and non-matching results from [`.exec()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec) and [`.match()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)
@@ -163,6 +200,22 @@ e.g.
 "a".match(/(?:x|$(?![\s\S]))/); // ['', index: 1, input: "a", groups: undefined];
 ```
 
+> [!TIP]
+> [`isComplete()`](#iscompletepartial-partialmatchregexp-match-regexpexecarray-boolean) answers this without a length check, and covers more than one: it reports `false` for the empty end-of-input match, since it exists only because the input ran out, and equally for a non-empty prefix like `"hello"` against `/hello world/`, which a length check would wave through.
+>
+> It describes a match, so ask it from `exec()` rather than `test()`:
+>
+> ```js
+> import PartialMatchRegExp, { isComplete } from "regex-partial-match";
+>
+> const partial = new PartialMatchRegExp(/x/);
+> const match = partial.exec("a"); // ['', index: 1, input: "a", groups: undefined]
+>
+> isComplete(partial, match); // false - the match depended on the input running out
+> ```
+>
+> `false` is "not yet", not "never": for an unanchored `/x/`, `"a"` really is a viable prefix of `"ax"`. It is only when validating that which came before that it should be read as "no match".
+
 > [!NOTE]
 > A more ergonomic `test()` / `exec()` output [was explored](https://github.com/TomStrepsil/regex-partial-match/pull/51), but proved a complex problem space.
 
@@ -173,8 +226,11 @@ e.g.
 The following cases remain atomic (full native value or exactly at true end of input, no mid-value partial matching):
 
 - **Backreferences inside lookbehinds and negative lookarounds.** These are verbatim contexts — the value a lookbehind or negative lookahead requires must be fully present or fully absent, so there's no partial-prefix position to expand into.
-- **`\k<name>` with no named capturing groups in the pattern.** [Annex B](https://tc39.es/ecma262/#sec-regular-expressions-patterns) tolerates this as the literal characters `k<a>`, but it's still treated as if it were a named backreference and matched atomically — `"k"` and `"k<"` will not partially match. A `\k` not immediately followed by a well-formed `<name>` reference is treated as the literal `k` and partially matches as usual.
 - **A backreference whose captured value can't be determined from a partial input.** This only affects the backreference site itself; it's strictly better than rejecting the input outright, and never accepts anything unsound.
+- **A forward reference, outside a lookbehind** — `\1` written before group 1 opens, or referencing it while it's still open (a self-reference inside the group's own body, e.g. `\1` in `/^(\1a)$/`). Its value can't come from the capture scan, which resolves it on a path it could never have taken, so it's left to the engine — which, per ECMAScript, always resolves it to empty there (it can't have participated yet, even on a later iteration of an enclosing quantifier). This costs nothing in practice: there's no real value being withheld. (Inside a lookbehind — already covered above — matching runs right-to-left, so a reference written first can still follow its own group's capture; that's exactly why the whole body stays atomic regardless of `forward`.)
+- **A `\k<name>` referencing a name declared more than once**, which ECMAScript permits only across disjoint alternatives. This one is stricter than the rest — see [docs/backreferences.md](./docs/backreferences.md#duplicate-named-groups) for why, and for the workaround.
+
+ The case-folding a backreference's expansion agrees against tracks a locally-scoped `(?i:...)`/`(?-i:...)` [modifier](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Modifier) around that specific backreference, rather than only the pattern's own flags. This holds for a backreference the local scope makes *more* case-insensitive than the pattern is, or *less*. V8 versions before [the fix](https://issues.chromium.org/issues/447583670) released in Node.js 24.12 can still mishandle the locally-disabled case when the surrounding pattern has `i`; Chromium/Electron support depends on their bundled V8 version.
 
 #### Prefix-ambiguous top-level alternation
 
@@ -197,16 +253,17 @@ partial.test("abca"); // false — but "abca" is a valid prefix of "abcabc" via
 
 See [docs/backreferences.md](./docs/backreferences.md) for why this happens (the internal capture scan resolving the wrong alternative first).
 
-[^1]: 
+[^2]: 
     A bare `$` alone isn't sufficient here: under the `m` (multiline) flag — including one turned on locally via a `(?m:...)` [modifier](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Modifier) — `$` also matches immediately before *any* line terminator, not just the true end of input. That would let a `"\n"` the source pattern never allowed for be silently accepted as if the input had simply run out, e.g. `new PartialMatchRegExp(/^foobar/m)` would wrongly accept `"foo\nbaz"`. Appending `(?![\s\S])` narrows the disjunction down to strict end-of-input, regardless of multiline state.
 
     See [chromium issue 536420076](https://issues.chromium.org/u/2/issues/536420076) for the underlying V8 bug that requires `$` to precede `(?![\s\S])` rather than using the lookahead alone.
 
     A shorter option, `(?-m:$)` — disabling multiline locally so `$` means strict end-of-input on its own — also sidesteps the bug and saves a few bytes per atom. However, modifier groups are new enough that support isn't universal, and feature-detecting them would add a fallback branch the test suite can't exercise honestly, since every engine that can realistically be tested against already supports them.
 
-[^2]: 
+[^3]: 
     To remain lightweight, no runtime type validation is applied, so non-TypeScript consumers will be reliant on underlying errors thrown if used incorrectly.
 
+
 ### Positive Lookbehinds
 
 Whilst forming a match, a positive lookbehind must match in entirety, for the pattern to match. This is inherent in the concept of non-matching groups, since they are not match-worthy themselves, but just qualify matching atoms.
@@ -345,7 +402,7 @@ Useful for parsing log files, network streams, or any chunked data where records
 
 Extends `RegExp`. An instance behaves like a normal `RegExp` — `instanceof RegExp` is `true`, and `.test()`, `.exec()`, `.match()`, `.matchAll()`, `.replace()`, etc. all work as expected — but also matches any input string that is a valid prefix of the original pattern, in addition to full matches.
 
-Available via the default entry point of the package.
+Available via the default entry point of the package, or via `regex-partial-match/partialMatchRegExp` — see [A note on Tree-Shaking](#a-note-on-tree-shaking).
 
 **Parameters:**
 
@@ -364,6 +421,87 @@ When using `import 'regex-partial-match/extend'`, this method is added to `RegEx
 
 - A new `PartialMatchRegExp` that matches partial strings, created from the `RegExp` instance the method was called on.
 
+### `isComplete(partial: PartialMatchRegExp, match: RegExpExecArray): boolean`
+
+Reports whether a match `partial` produced is a **match** of the original pattern, or merely a **prefix** of it. `exec()` alone cannot say: it returns the same shape of array for `"h"`, `"hello"` and `"hello world"` against `/hello world/`.
+
+Available as a named export of the default entry point: `import { isComplete } from 'regex-partial-match'`. Its probe requires ES2018+, so in an environment that doesn't tree-shake and has no use for it, import `PartialMatchRegExp` from `regex-partial-match/partialMatchRegExp` instead of the default entry to avoid bundling `isComplete`'s code; see [A note on Tree-Shaking](#a-note-on-tree-shaking).
+
+**Parameters:**
+
+- `partial` - The `PartialMatchRegExp` instance that produced `match`
+- `match` - A match returned by `partial.exec()`
+
+**Returns:**
+
+- `true` when every atom matched literally, so the path the match took is one the original pattern could have taken itself.
+- `false` when the match depended on the input running out — it took one of the `|$(?![\s\S])` branches described in [How It Works](#how-it-works). More input is needed, and the match's captures are **provisional**: a truncated path can capture values that no complete match ever produces.
+
+```javascript
+import PartialMatchRegExp, { isComplete } from "regex-partial-match";
+
+const partial = new PartialMatchRegExp(/hello world/);
+const prefix = partial.exec("hello");
+
+prefix[0]; // 'hello'
+isComplete(partial, prefix); // false — a prefix, not a match
+
+const complete = partial.exec("hello world");
+
+complete[0]; // 'hello world'
+isComplete(partial, complete); // true
+```
+
+> [!NOTE]
+> Complete is not the same as *final*. A greedy pattern like `/hello \w+/` matches `"hello world"` completely, and would still match more of `"hello worldly"`.
+
+#### Why the question can't be answered from the outside
+
+Neither of the obvious workarounds answers it:
+
+- **Checking whether the match ends at the end of input.** True for every prefix, but also true for the common case of a complete match of input as it is typed — `/^\d{4}/` against `"2024"` ends at end of input and is complete.
+- **Re-running the original pattern.** That asks whether the original matches *at all* at that position, not whether *this result* was arrived at by truncation. Where a truncation branch fires inside a zero-width assertion the two diverge, and the original can return an identical array by a different path:
+
+  ```javascript
+  const pattern = /a(?=(?:b(?:x|(c))d|b))/;
+  const partial = new PartialMatchRegExp(pattern);
+
+  partial.exec("ab");   // ['a', undefined] — truncated inside the assertion
+  pattern.exec("ab");   // ['a', undefined] — identical, and complete
+  pattern.exec("abcd"); // ['a', 'c']       — what more input actually produces
+  ```
+
+  Over `"ab"` the transformed pattern satisfies the atoms after `b` through *their* truncation branches — zero-width, so the match's own end never moves — before ever reaching the `(c)` group. Group 1 is left `undefined` where more input would define it.
+
+The information only exists during matching. `isComplete()` recovers it by re-running the compiled pattern, [sticky](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/sticky) at `match.index`, with an empty named group in front of each truncation branch; an empty group is zero-width and always succeeds, so the twin walks the identical path, and any marker that comes back defined is a truncation branch the match actually took. 
+
+Recognising a truncation branch, a raw lookaround, or a group open back out of the rendered pattern is one classification, shared by every pass that needs it, rather than re-derived independently wherever it's needed. 
+
+The twin is built lazily, on first use, and never escapes the library — the array, `groups`, numbering and `d`-flag indices you hold are the ones `exec()` produced. It is cached once per instance for a pattern without [backreferences](#backreferences); for one with them the pattern is re-expanded per input, so the twin belongs to the expansion behind one particular match and a later match builds its own.
+
+**Cost:** one anchored `exec` per call, plus the twin's construction on the first call that needs it. `exec()` and `test()` are untouched: the expansion a backreference match is answered from is held on the match itself, under a private symbol, so it costs a single field write and is collected with the match. Repeatedly asking about the *same* match is cheap; asking once per match on a backreference pattern pays for a new twin each time.
+
+> [!CAUTION]
+> `isComplete()` itself always requires ES2018+, regardless of the pattern: its truncation probe is built from named capturing groups internally, even for a pattern as plain as `/^abc/`. See [Browser Compatibility](#browser-compatibility) — every other method holds to the ES2015 floor stated there.
+
+#### What it cannot see
+
+`isComplete()` is necessary, but not sufficient, for a scanner whose output must be the same however the input is chunked. It cannot see a capture still growing *inside* an assertion: [`RepeatMatcher`](https://tc39.es/ecma262/#sec-runtime-semantics-repeatmatcher-abstract-operation) discards a repetition once it matches empty, so a truncation sentinel placed after a greedy repetition never gets a chance to fire there.
+
+```javascript
+const partial = new PartialMatchRegExp(/a(?=(b+))/);
+const match = partial.exec("ab");
+
+match[1]; // 'b'
+isComplete(partial, match); // true
+
+/a(?=(b+))/.exec("abbX")[1]; // 'bb' — the same capture, over more input
+```
+
+This isn't a defect: every atom in the `"ab"` match matched literally, so `isComplete()` answers correctly by its own definition. It just doesn't mean *cannot change with more input* — the same distinction the [note above](#iscompletepartial-partialmatchregexp-match-regexpexecarray-boolean) draws for `/hello \w+/`, one level further in.
+
+A chunk-invariant scanner needs a second, independent check: whether any capture's end coincides with the end of the buffer, computable from [`d`-flag](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/hasIndices) indices without this library's help. Defer a match when either check says to.
+
 ### `PartialMatchRegExp.prototype.features: ReadonlySet<RegexFeature>`
 
 Building the partial-match regex requires walking the entire source pattern once. As a side effect of that same walk, each instance records which syntactic constructs its pattern actually uses, exposed as a `features` set — no separate scan of the source is performed to produce it.
@@ -416,7 +554,7 @@ partial.features.has("backreference"); // true
 | `controlLetterEscape`        | `\cX`                                                   |                                                                                 |
 | `hexEscapeSequence`          | `\xXX`                                                  |                                                                                 |
 | `unicodeEscapeSequence`      | `\uXXXX`, `\u{...}`                                     |                                                                                 |
-| `otherEscape`                 | Any other `\X`, e.g. `\.`, `\0`                         |                                                                                 |
+| `otherEscape`                 | Any other `\X`, e.g. `\.`                               | `\0` alone is tagged `otherEscape` only under `u`/`v`; otherwise `backreference`, [like any other digit escape](docs/backreferences.md) |
 
 Three things worth knowing about how these tags line up with the grammar:
 

package/lib/{extend.d.ts → extend/index.d.ts}

@@ -1,4 +1,4 @@
-import PartialMatchRegExp from "./partialMatchRegExp.ts";
+import PartialMatchRegExp from "../partialMatchRegExp/partialMatchRegExp.ts";
 declare global {
     interface RegExp {
         /**

package/lib/{extend.js → extend/index.js}

@@ -1,4 +1,4 @@
-import PartialMatchRegExp from "./partialMatchRegExp.js";
+import PartialMatchRegExp from "../partialMatchRegExp/partialMatchRegExp.js";
 RegExp.prototype.toPartialMatchRegex = function () {
     return new PartialMatchRegExp(this);
 };

package/lib/partialMatchRegExp/atomSyntax.d.ts

@@ -0,0 +1,4 @@
+export declare const DISJUNCTION_TO_END_OF_INPUT = "|$(?![\\s\\S]))";
+export declare const OPTIONAL_ATOM_OPENING = "(?:";
+export declare const NAMED_GROUP_OPENING = "(?<";
+export declare const ANY_CAPTURED_TEXT = "(?:[\\s\\S]*?)";

package/lib/partialMatchRegExp/atomSyntax.js

@@ -0,0 +1,4 @@
+export const DISJUNCTION_TO_END_OF_INPUT = "|$(?![\\s\\S]))";
+export const OPTIONAL_ATOM_OPENING = "(?:";
+export const NAMED_GROUP_OPENING = "(?<";
+export const ANY_CAPTURED_TEXT = "(?:[\\s\\S]*?)";

package/lib/partialMatchRegExp/backreferenceExpansion.d.ts

@@ -0,0 +1,10 @@
+import type { Part } from "./part.ts";
+import type { TruncationProbe } from "./isComplete/truncationProbe.ts";
+export interface BackreferenceExpansion {
+    parts: Part[];
+    probe: TruncationProbe | undefined;
+}
+export declare const backreferenceExpansion: unique symbol;
+export interface ExpandedMatch extends RegExpExecArray {
+    [backreferenceExpansion]?: BackreferenceExpansion;
+}

package/lib/partialMatchRegExp/backreferenceExpansion.js

@@ -0,0 +1 @@
+export const backreferenceExpansion = Symbol("backreferenceExpansion");

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

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

package/lib/partialMatchRegExp/compilePartial/asNativeAtom.js

@@ -0,0 +1,10 @@
+import { isNumericBackreference } from "../part.js";
+import asOptionalAtom from "./asOptionalAtom.js";
+function backrefToken(backref) {
+    return isNumericBackreference(backref)
+        ? "\\" + String(backref.ref)
+        : "\\k<" + backref.ref + ">";
+}
+export default function asNativeAtom(backref) {
+    return asOptionalAtom(backrefToken(backref));
+}

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

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

package/lib/partialMatchRegExp/compilePartial/asOptionalAtom.js

@@ -0,0 +1,4 @@
+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

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

package/lib/partialMatchRegExp/compilePartial/asPreScanPart.js

@@ -0,0 +1,8 @@
+import { ANY_CAPTURED_TEXT } from "../atomSyntax.js";
+import { isBackreference } from "../part.js";
+import asNativeAtom from "./asNativeAtom.js";
+export default function asPreScanPart(part) {
+    if (!isBackreference(part))
+        return part;
+    return part.forward ? asNativeAtom(part) : ANY_CAPTURED_TEXT;
+}

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

@@ -0,0 +1 @@
+export default function caseFoldFlags(flags: string): string;

package/lib/partialMatchRegExp/compilePartial/caseFoldFlags.js

@@ -0,0 +1,3 @@
+export default function caseFoldFlags(flags) {
+    return flags.replace(/[^iuv]/g, "");
+}

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

@@ -0,0 +1,29 @@
+import type { Part, RawLookaroundInfo } from "../part.ts";
+import { type RegexFeature } from "../regexFeatures.ts";
+export interface DynamicPath {
+    originalCaptureScan: RegExp;
+    preScan: RegExp;
+    expand: (capture: RegExpExecArray) => Part[];
+    expansionFitsCaptures: (expandedFrom: RegExpExecArray, match: RegExpExecArray, input: string) => boolean;
+}
+declare abstract class Compiled {
+    readonly rawLookarounds: readonly RawLookaroundInfo[];
+    readonly namedGroupOpenings: readonly string[];
+    private readonly _featureMask;
+    private _features?;
+    constructor(rawLookarounds: readonly RawLookaroundInfo[], namedGroupOpenings: readonly string[], _featureMask: number);
+    get features(): ReadonlySet<RegexFeature>;
+}
+export declare class CompiledStatic extends Compiled {
+    readonly regex: RegExp;
+    readonly parts: string[];
+    readonly kind = "static";
+    constructor(regex: RegExp, parts: string[], rawLookarounds: readonly RawLookaroundInfo[], namedGroupOpenings: readonly string[], featureMask: number);
+}
+export declare class CompiledDynamic extends Compiled {
+    readonly dynamic: DynamicPath;
+    readonly kind = "dynamic";
+    constructor(dynamic: DynamicPath, rawLookarounds: readonly RawLookaroundInfo[], namedGroupOpenings: readonly string[], featureMask: number);
+}
+export type CompiledPartial = CompiledStatic | CompiledDynamic;
+export {};

package/lib/partialMatchRegExp/compilePartial/compiled.js

@@ -0,0 +1,27 @@
+import { featureSet } from "../regexFeatures.js";
+class Compiled {
+    constructor(rawLookarounds, namedGroupOpenings, _featureMask) {
+        this.rawLookarounds = rawLookarounds;
+        this.namedGroupOpenings = namedGroupOpenings;
+        this._featureMask = _featureMask;
+    }
+    get features() {
+        var _a;
+        return ((_a = this._features) !== null && _a !== void 0 ? _a : (this._features = featureSet(this._featureMask)));
+    }
+}
+export class CompiledStatic extends Compiled {
+    constructor(regex, parts, rawLookarounds, namedGroupOpenings, featureMask) {
+        super(rawLookarounds, namedGroupOpenings, featureMask);
+        this.regex = regex;
+        this.parts = parts;
+        this.kind = "static";
+    }
+}
+export class CompiledDynamic extends Compiled {
+    constructor(dynamic, rawLookarounds, namedGroupOpenings, featureMask) {
+        super(rawLookarounds, namedGroupOpenings, featureMask);
+        this.dynamic = dynamic;
+        this.kind = "dynamic";
+    }
+}

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

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

package/lib/partialMatchRegExp/compilePartial/flagsAtBackreference.js

@@ -0,0 +1,4 @@
+export default function flagsAtBackreference(backref, flags) {
+    const unicodeMode = flags.includes("v") ? "v" : flags.includes("u") ? "u" : "";
+    return (backref.caseInsensitive ? "i" : "") + unicodeMode;
+}

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

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

package/lib/partialMatchRegExp/compilePartial/index.js

@@ -0,0 +1,79 @@
+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.d.ts

@@ -0,0 +1 @@
+export default function longestBakedPrefixEndingInput(baked: string, input: string, flags: string): string;

package/lib/partialMatchRegExp/compilePartial/longestBakedPrefixEndingInput.js

@@ -0,0 +1,50 @@
+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

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

package/lib/partialMatchRegExp/compilePartial/reclassifyLegacyEscapes.js

@@ -0,0 +1,17 @@
+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/renderParts.d.ts

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

package/lib/partialMatchRegExp/compilePartial/renderParts.js

@@ -0,0 +1,9 @@
+import { isBackreference } from "../part.js";
+import asNativeAtom from "./asNativeAtom.js";
+export default function renderParts(parts) {
+    let rendered = "";
+    for (const part of parts) {
+        rendered += isBackreference(part) ? asNativeAtom(part) : part;
+    }
+    return rendered;
+}

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

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

package/lib/partialMatchRegExp/compilePartial/resolvedFromScan.js

@@ -0,0 +1,10 @@
+import { decodeGroupName } from "../groupName.js";
+import { isNumericBackreference } from "../part.js";
+export default function resolvedFromScan(backref, capture) {
+    var _a;
+    if (backref.forward)
+        return undefined;
+    return isNumericBackreference(backref)
+        ? capture[backref.ref]
+        : (_a = capture.groups) === null || _a === void 0 ? void 0 : _a[decodeGroupName(backref.ref)];
+}

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

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

package/lib/partialMatchRegExp/compilePartial/spliceOriginalSource.js

@@ -0,0 +1,12 @@
+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/compilePartial/startsWithUnderFlags.d.ts

@@ -0,0 +1 @@
+export default function startsWithUnderFlags(text: string, prefix: string, flags: string): boolean;

package/lib/partialMatchRegExp/compilePartial/startsWithUnderFlags.js

@@ -0,0 +1,7 @@
+import escapeAtom from "../escapeAtom.js";
+import caseFoldFlags from "./caseFoldFlags.js";
+export default function startsWithUnderFlags(text, prefix, flags) {
+    if (prefix === "" || !flags.includes("i"))
+        return text.startsWith(prefix);
+    return new RegExp("^" + escapeAtom(prefix), caseFoldFlags(flags)).test(text);
+}

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

@@ -0,0 +1,3 @@
+import type { RawLookaroundInfo } from "../part.ts";
+import { CompiledStatic } from "./compiled.ts";
+export default function toStatic(parts: string[], flags: string, rawLookarounds: readonly RawLookaroundInfo[], namedGroupOpenings: readonly string[], featureMask: number): CompiledStatic;