regex-partial-match 1.1.2 → 1.3.0

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;

package/lib/partialMatchRegExp/compilePartial/toStatic.js

@@ -0,0 +1,4 @@
+import { CompiledStatic } from "./compiled.js";
+export default function toStatic(parts, flags, rawLookarounds, namedGroupOpenings, featureMask) {
+    return new CompiledStatic(new RegExp(parts.join(""), flags), parts, rawLookarounds, namedGroupOpenings, featureMask);
+}

package/lib/partialMatchRegExp/groupName.d.ts

@@ -0,0 +1,2 @@
+export declare const groupNameOf: (namedGroupOpening: string) => string;
+export declare function decodeGroupName(rawName: string): string;

package/lib/partialMatchRegExp/groupName.js

@@ -0,0 +1,8 @@
+import { NAMED_GROUP_OPENING } from "./atomSyntax.js";
+const UNICODE_ESCAPE_IN_NAME_REGEX = /\\u\{([0-9a-fA-F]+)\}|\\u([0-9a-fA-F]{4})/g;
+export const groupNameOf = (namedGroupOpening) => namedGroupOpening.slice(NAMED_GROUP_OPENING.length, -1);
+export function decodeGroupName(rawName) {
+    return rawName.replace(UNICODE_ESCAPE_IN_NAME_REGEX, (_whole, braced, plain) => 
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- one of braced or plain is guaranteed to be defined by the regex
+    String.fromCodePoint(parseInt((braced !== null && braced !== void 0 ? braced : plain), 16)));
+}

package/lib/partialMatchRegExp/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./partialMatchRegExp.ts";
+export { default } from "./partialMatchRegExp.ts";
+export { default as isComplete } from "./isComplete/index.ts";

package/lib/partialMatchRegExp/index.js

@@ -0,0 +1,3 @@
+export * from "./partialMatchRegExp.js";
+export { default } from "./partialMatchRegExp.js";
+export { default as isComplete } from "./isComplete/index.js";

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

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

package/lib/partialMatchRegExp/isComplete/index.js

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

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

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

package/lib/partialMatchRegExp/isComplete/isMatchComplete.js

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

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

@@ -0,0 +1,3 @@
+import { type Part } from "../part.ts";
+export type PartRole = "backreference" | "rawLookaround" | "groupOpen" | "truncationEnd" | "plain";
+export declare function roleOf(part: Part): PartRole;

package/lib/partialMatchRegExp/isComplete/partRole.js

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

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

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

package/lib/partialMatchRegExp/isComplete/truncationProbe.js

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

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

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

package/lib/partialMatchRegExp/isComplete/truncationProbeCache.js

@@ -0,0 +1 @@
+export {};

package/lib/partialMatchRegExp/legacyEscape.d.ts

@@ -0,0 +1,2 @@
+export declare function legacyEscapeAsLiteral(digits: string): string;
+export declare function legacyEscapeAtoms(digits: string): string[];

package/lib/partialMatchRegExp/legacyEscape.js

@@ -0,0 +1,18 @@
+const LEGACY_OCTAL_ESCAPE_REGEX = /^(?:[0-3][0-7]{0,2}|[4-7][0-7]?)/;
+const hexEscape = (codeUnit) => "\\x" + (codeUnit < 0x10 ? "0" : "") + codeUnit.toString(16);
+export function legacyEscapeAsLiteral(digits) {
+    return legacyEscapeAtoms(digits).join("");
+}
+export function legacyEscapeAtoms(digits) {
+    var _a;
+    const octal = (_a = LEGACY_OCTAL_ESCAPE_REGEX.exec(digits)) === null || _a === void 0 ? void 0 : _a[0];
+    const atoms = [];
+    let index = 0;
+    if (octal !== undefined) {
+        atoms.push(hexEscape(parseInt(octal, 8)));
+        index = octal.length;
+    }
+    for (; index < digits.length; index++)
+        atoms.push(digits[index]);
+    return atoms;
+}

package/lib/partialMatchRegExp/part.d.ts

@@ -0,0 +1,24 @@
+interface NumericBackreference {
+    ref: number;
+    start: number;
+    end: number;
+    forward?: boolean;
+    caseInsensitive: boolean;
+}
+interface NamedBackreference {
+    ref: string;
+    start: number;
+    end: number;
+    forward?: boolean;
+    caseInsensitive: boolean;
+}
+export type Backreference = NumericBackreference | NamedBackreference;
+export type Part = string | Backreference;
+export interface RawLookaroundInfo {
+    sourceStart: number;
+    capturingGroupsOpened: number;
+    backreferences: Backreference[];
+}
+export declare const isBackreference: (part: Part) => part is Backreference;
+export declare const isNumericBackreference: (part: Part) => part is NumericBackreference;
+export {};

package/lib/partialMatchRegExp/part.js

@@ -0,0 +1,2 @@
+export const isBackreference = (part) => typeof part !== "string";
+export const isNumericBackreference = (part) => isBackreference(part) && typeof part.ref === "number";

package/lib/partialMatchRegExp/partialMatchInternals.d.ts

@@ -0,0 +1,2 @@
+export declare const compiledPartial: unique symbol;
+export declare const truncationProbeCache: unique symbol;

package/lib/partialMatchRegExp/partialMatchInternals.js

@@ -0,0 +1,2 @@
+export const compiledPartial = Symbol("compiledPartial");
+export const truncationProbeCache = Symbol("truncationProbeCache");

package/lib/{partialMatchRegExp.d.ts → partialMatchRegExp/partialMatchRegExp.d.ts}

@@ -1,4 +1,7 @@
-import { type RegexFeature } from "./compilePartial.ts";
+import type { CompiledPartial } from "./compilePartial/compiled.ts";
+import { compiledPartial, truncationProbeCache } from "./partialMatchInternals.ts";
+import type { TruncationProbeCache } from "./isComplete/truncationProbeCache.ts";
+import type { RegexFeature } from "./regexFeatures.ts";
 export type { RegexFeature };
 /**
  * A `RegExp` subclass that supports partial (prefix) matching.
@@ -27,9 +30,25 @@ export type { RegexFeature };
  * @see {@link https://github.com/TomStrepsil/regex-partial-match#readme | Documentation}
  */
 declare class PartialMatchRegExp extends RegExp {
-    #private;
-    readonly features: ReadonlySet<RegexFeature>;
+    [compiledPartial]: CompiledPartial;
+    [truncationProbeCache]: TruncationProbeCache;
     constructor(pattern: RegExp | string, flags?: string);
+    /**
+     * The syntactic constructs the original pattern uses, recorded as a side
+     * effect of the single walk that builds the partial-match regex.
+     *
+     * The set is built on first read and cached, so patterns that are only ever
+     * matched against never pay for it. It iterates in `RegexFeature` declaration
+     * order, not the order the constructs appear in the pattern.
+     *
+     * @returns The features the original pattern contains
+     *
+     * @example
+     * ```typescript
+     * new PartialMatchRegExp(/^[a-z]+/).features.has("startAnchor"); // true
+     * ```
+     */
+    get features(): ReadonlySet<RegexFeature>;
     exec(input: string): RegExpExecArray | null;
     private _execDynamic;
 }

package/lib/partialMatchRegExp/partialMatchRegExp.js

@@ -0,0 +1,114 @@
+import compilePartial from "./compilePartial/index.js";
+import renderParts from "./compilePartial/renderParts.js";
+import { backreferenceExpansion } from "./backreferenceExpansion.js";
+import { compiledPartial, truncationProbeCache } from "./partialMatchInternals.js";
+import { preferLongerCaptures } from "./preferLongerCaptures.js";
+/**
+ * A `RegExp` subclass that supports partial (prefix) matching.
+ *
+ * An instance behaves like a normal `RegExp` but also matches any input string
+ * that is a valid prefix of the original pattern — i.e. strings that could still
+ * lead to a full match with more input. This enables validation of incomplete
+ * input strings.
+ *
+ * @example
+ * ```typescript
+ * const pattern = /^hello world/;
+ * const partial = new PartialMatchRegExp(pattern);
+ *
+ * partial.test('h');           // true - could match
+ * partial.test('hello');       // true - could match
+ * partial.test('hello world'); // true - full match
+ * partial.test('goodbye');     // false - cannot match
+ * ```
+ *
+ * @remarks
+ * - The transformed pattern always matches an empty string at the end of input;
+ *   use a start anchor (`^`) to prevent false positives from empty string matches
+ * - The `y` (sticky) flag may not behave as expected in partial matching scenarios
+ *
+ * @see {@link https://github.com/TomStrepsil/regex-partial-match#readme | Documentation}
+ */
+class PartialMatchRegExp extends RegExp {
+    constructor(pattern, flags) {
+        super(pattern, flags);
+        this[compiledPartial] = compilePartial(this);
+        this[truncationProbeCache] = { probe: undefined };
+    }
+    /**
+     * 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 = this[compiledPartial];
+        if (compiled.kind === "dynamic")
+            return this._execDynamic(compiled.dynamic, input);
+        const { regex } = compiled;
+        const match = execFrom(regex, input, this.lastIndex);
+        this.lastIndex = regex.lastIndex;
+        return match;
+    }
+    _execDynamic(dynamic, input) {
+        var _a, _b;
+        const { originalCaptureScan, preScan, expand, expansionFitsCaptures } = 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;
+        let expandedFrom = capture;
+        let expandedParts = expand(expandedFrom);
+        let expanded = new RegExp(renderParts(expandedParts), this.flags);
+        let match = execFrom(expanded, input, start);
+        if (match !== null && !expansionFitsCaptures(expandedFrom, match, input)) {
+            expandedFrom = match;
+            expandedParts = expand(expandedFrom);
+            expanded = new RegExp(renderParts(expandedParts), this.flags);
+            match = execFrom(expanded, input, start);
+            if (match !== null && !expansionFitsCaptures(expandedFrom, match, input))
+                match = null;
+        }
+        if (match === null || isAtOrBefore(originalMatch, match.index))
+            return originalMatch;
+        preferLongerCaptures(match, capture);
+        if (honoursLastIndex)
+            this.lastIndex = expanded.lastIndex;
+        match[backreferenceExpansion] = {
+            parts: expandedParts,
+            probe: undefined
+        };
+        return match;
+    }
+}
+function execFrom(regex, input, start) {
+    regex.lastIndex = start;
+    return regex.exec(input);
+}
+function isAtOrBefore(match, index) {
+    return match !== null && match.index <= index;
+}
+export default PartialMatchRegExp;

package/lib/partialMatchRegExp/preferLongerCaptures.d.ts

@@ -0,0 +1 @@
+export declare function preferLongerCaptures(match: RegExpExecArray, scanned: RegExpExecArray): void;

package/lib/partialMatchRegExp/preferLongerCaptures.js

@@ -0,0 +1,30 @@
+function pickLonger(scanned, matched) {
+    return scanned !== undefined &&
+        matched !== undefined &&
+        scanned.length > matched.length
+        ? scanned
+        : undefined;
+}
+export function preferLongerCaptures(match, scanned) {
+    var _a, _b, _c, _d;
+    for (let index = 1; index < match.length; index++) {
+        const longer = pickLonger(scanned[index], match[index]);
+        if (longer === undefined)
+            continue;
+        match[index] = longer;
+        if (match.indices && ((_a = scanned.indices) === null || _a === void 0 ? void 0 : _a[index])) {
+            match.indices[index] = scanned.indices[index];
+        }
+    }
+    if (match.groups && scanned.groups) {
+        for (const name of Object.keys(match.groups)) {
+            const longer = pickLonger(scanned.groups[name], match.groups[name]);
+            if (longer === undefined)
+                continue;
+            match.groups[name] = longer;
+            if ((_b = match.indices) === null || _b === void 0 ? void 0 : _b.groups) {
+                match.indices.groups[name] = (_d = (_c = scanned.indices) === null || _c === void 0 ? void 0 : _c.groups) === null || _d === void 0 ? void 0 : _d[name];
+            }
+        }
+    }
+}

package/lib/partialMatchRegExp/regexFeatures.d.ts

@@ -0,0 +1,6 @@
+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 declare const FEATURE_BIT: Record<RegexFeature, number>;
+export declare function hasFeature(mask: number, feature: RegexFeature): boolean;
+export declare function featureSet(mask: number): Set<RegexFeature>;
+export {};

package/lib/partialMatchRegExp/regexFeatures.js

@@ -0,0 +1,47 @@
+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"
+];
+export const FEATURE_BIT = {};
+for (let index = 0; index < REGEX_FEATURES.length; index++) {
+    FEATURE_BIT[REGEX_FEATURES[index]] = 1 << index;
+}
+export function hasFeature(mask, feature) {
+    return (mask & FEATURE_BIT[feature]) !== 0;
+}
+export 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;
+}

package/lib/partialMatchRegExp/walk.d.ts

@@ -0,0 +1,8 @@
+import type { Part, RawLookaroundInfo } from "./part.ts";
+export declare function walk(regex: RegExp, declaresNamedGroup: boolean): {
+    parts: Part[];
+    groupCount: number;
+    featureMask: number;
+    rawLookarounds: readonly RawLookaroundInfo[];
+    namedGroupOpenings: readonly string[];
+};