regex-partial-match 1.3.0 → 2.0.0

package/lib/core/corePartialMatchRegExp.js

@@ -0,0 +1,22 @@
+import withModules from "../partialMatchRegExp/withModules.js";
+/**
+ * `PartialMatchRegExp` without the rules that place a `^` in a group or after
+ * other parts under the `m` flag, or match a backreference, so that a bundle
+ * importing only `regex-partial-match/core` leaves them out.
+ *
+ * A pattern that needs either throws one `TypeError` naming every module it
+ * needs; every other pattern is transformed exactly as the class exported
+ * from `regex-partial-match` transforms it.
+ *
+ * @example
+ * ```typescript
+ * import PartialMatchRegExp from "regex-partial-match/core";
+ *
+ * new PartialMatchRegExp(/^hello world/).test("hello"); // true
+ * new PartialMatchRegExp(/(a)\1/); // throws TypeError
+ * ```
+ *
+ * @see {@link https://github.com/TomStrepsil/regex-partial-match#readme | Documentation}
+ */
+const PartialMatchRegExp = withModules();
+export default PartialMatchRegExp;

package/lib/core/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./corePartialMatchRegExp.ts";
+export type { PartialMatchRegExp, PartialMatchRegExpConstructor } from "./corePartialMatchRegExp.ts";
+export { default as withModules } from "../partialMatchRegExp/withModules.ts";
+export type { Module } from "../partialMatchRegExp/opaqueModule.ts";

package/lib/core/index.js

@@ -0,0 +1,2 @@
+export { default } from "./corePartialMatchRegExp.js";
+export { default as withModules } from "../partialMatchRegExp/withModules.js";

package/lib/extend/index.d.ts

@@ -1,12 +1,11 @@
-import PartialMatchRegExp from "../partialMatchRegExp/partialMatchRegExp.ts";
+import PartialMatchRegExp from "../partialMatchRegExp/index.ts";
 declare global {
     interface RegExp {
         /**
          * Transforms this regular expression to support partial matching.
          *
-         * This method wraps each atomic element of the regex pattern in a non-capturing group
-         * with an alternation to end-of-input (`$`), allowing the pattern to match prefixes
-         * of the original pattern. This enables validation of incomplete input strings.
+         * The result matches any prefix of the original pattern, which enables
+         * validation of incomplete input strings.
          *
          * @returns A new PartialMatchRegExp that matches partial strings of the original pattern
          *
@@ -23,9 +22,9 @@ declare global {
          * ```
          *
          * @remarks
-         * - The transformed regex will always match an empty string at the end of input
-         * - Use with a start anchor (`^`) to prevent false positives from empty string matches
-         * - The `y` (sticky) flag may not behave as expected in partial matching scenarios
+         * 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.
+         * See the documentation for how the `y` (sticky) flag behaves.
          *
          * @see {@link https://github.com/TomStrepsil/regex-partial-match#readme | Documentation}
          */

package/lib/extend/index.js

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

package/lib/features/index.d.ts

@@ -0,0 +1,20 @@
+import type PartialMatchRegExp from "../partialMatchRegExp/index.ts";
+import { type RegexFeature } from "../partialMatchRegExp/regexFeatures.ts";
+export type { RegexFeature };
+/**
+ * The syntactic constructs `partial`'s original pattern uses.
+ *
+ * The set iterates in `RegexFeature` declaration order, not the order the
+ * constructs appear in the pattern.
+ *
+ * @param partial - A `PartialMatchRegExp` instance, from any entry point
+ * @returns The features the original pattern contains
+ *
+ * @example
+ * ```typescript
+ * import PartialMatchRegExp, { features } from "regex-partial-match";
+ *
+ * features(new PartialMatchRegExp(/^[a-z]+/)).has("startAnchor"); // true
+ * ```
+ */
+export default function features(partial: PartialMatchRegExp): ReadonlySet<RegexFeature>;

package/lib/features/index.js

@@ -0,0 +1,23 @@
+import { compiledOf } from "../partialMatchRegExp/partialMatchInternals.js";
+import { featureSet } from "../partialMatchRegExp/regexFeatures.js";
+/**
+ * The syntactic constructs `partial`'s original pattern uses.
+ *
+ * The set iterates in `RegexFeature` declaration order, not the order the
+ * constructs appear in the pattern.
+ *
+ * @param partial - A `PartialMatchRegExp` instance, from any entry point
+ * @returns The features the original pattern contains
+ *
+ * @example
+ * ```typescript
+ * import PartialMatchRegExp, { features } from "regex-partial-match";
+ *
+ * features(new PartialMatchRegExp(/^[a-z]+/)).has("startAnchor"); // true
+ * ```
+ */
+export default function features(partial) {
+    var _a;
+    const compiled = compiledOf(partial);
+    return ((_a = compiled.features) !== null && _a !== void 0 ? _a : (compiled.features = featureSet(compiled.featureMask)));
+}

package/lib/hitEnd/index.d.ts

@@ -0,0 +1,45 @@
+import type PartialMatchRegExp from "../partialMatchRegExp/index.ts";
+/**
+ * Whether the engine reached the end of the input while producing `match` —
+ * a match `partial` produced — so that more input could change it.
+ *
+ * The contract is that of the JDK's `Matcher.hitEnd()`: when this returns
+ * `false`, no continuation of the input changes the match's index or text,
+ * and its captures are the ones the original pattern produces, except for
+ * the two limits noted under `@remarks` below, where `false` is reported
+ * despite a read of the end. `true` means the match read the end of the
+ * input — an atom ran out of input, a greedy quantifier stopped there with
+ * nothing left to read, or `$`, `\b` or `\B` held there — so more input
+ * could extend it, change which alternative wins, or invalidate it, and
+ * its captures are the closest to what a full match would report rather
+ * than final.
+ *
+ * `false` is not "is a match": `/hello \w+/` matches `"hello world"` in full
+ * and still reports `true`, since `\w+` read the end looking for more. An
+ * exact-length match that consumed the last character without reading past
+ * it reports `false`.
+ *
+ * @param partial - The `PartialMatchRegExp` instance that produced `match`
+ * @param match - A match returned by `partial.exec()`
+ * @returns `true` when the match read the end of the input, `false` when it
+ * settled short of it
+ *
+ * @remarks
+ * Conservative where the JDK is exact in one place: a bounded greedy
+ * quantifier (`?`, `{n,m}`) fully taken at the end of the input reports
+ * `true` — on a group, and the same way for an unequal-bound `{n,m}`
+ * directly on a single atom once it's saturated at its maximum. Cannot see
+ * a read of the end inside a raw lookaround, or inside a lookahead in an
+ * earlier iteration of a quantified group.
+ *
+ * @example
+ * ```typescript
+ * import PartialMatchRegExp, { hitEnd } from "regex-partial-match";
+ *
+ * const partial = new PartialMatchRegExp(/^\d{4}-\d{2}-\d{2}/);
+ * const match = partial.exec('2024-06');
+ *
+ * match !== null && hitEnd(partial, match); // true - keep typing
+ * ```
+ */
+export default function hitEnd(partial: PartialMatchRegExp, match: RegExpExecArray): boolean;

package/lib/hitEnd/index.js

@@ -0,0 +1,57 @@
+import { compiledOf } from "../partialMatchRegExp/partialMatchInternals.js";
+import matchHitEnd from "./matchHitEnd.js";
+/**
+ * Whether the engine reached the end of the input while producing `match` —
+ * a match `partial` produced — so that more input could change it.
+ *
+ * The contract is that of the JDK's `Matcher.hitEnd()`: when this returns
+ * `false`, no continuation of the input changes the match's index or text,
+ * and its captures are the ones the original pattern produces, except for
+ * the two limits noted under `@remarks` below, where `false` is reported
+ * despite a read of the end. `true` means the match read the end of the
+ * input — an atom ran out of input, a greedy quantifier stopped there with
+ * nothing left to read, or `$`, `\b` or `\B` held there — so more input
+ * could extend it, change which alternative wins, or invalidate it, and
+ * its captures are the closest to what a full match would report rather
+ * than final.
+ *
+ * `false` is not "is a match": `/hello \w+/` matches `"hello world"` in full
+ * and still reports `true`, since `\w+` read the end looking for more. An
+ * exact-length match that consumed the last character without reading past
+ * it reports `false`.
+ *
+ * @param partial - The `PartialMatchRegExp` instance that produced `match`
+ * @param match - A match returned by `partial.exec()`
+ * @returns `true` when the match read the end of the input, `false` when it
+ * settled short of it
+ *
+ * @remarks
+ * Conservative where the JDK is exact in one place: a bounded greedy
+ * quantifier (`?`, `{n,m}`) fully taken at the end of the input reports
+ * `true` — on a group, and the same way for an unequal-bound `{n,m}`
+ * directly on a single atom once it's saturated at its maximum. Cannot see
+ * a read of the end inside a raw lookaround, or inside a lookahead in an
+ * earlier iteration of a quantified group.
+ *
+ * @example
+ * ```typescript
+ * import PartialMatchRegExp, { hitEnd } from "regex-partial-match";
+ *
+ * const partial = new PartialMatchRegExp(/^\d{4}-\d{2}-\d{2}/);
+ * const match = partial.exec('2024-06');
+ *
+ * match !== null && hitEnd(partial, match); // true - keep typing
+ * ```
+ */
+export default function hitEnd(partial, match) {
+    var _a, _b;
+    const compiled = compiledOf(partial);
+    return matchHitEnd(compiled, match, ((_a = compiled.probeCache) !== null && _a !== void 0 ? _a : (compiled.probeCache = {
+        rawLookarounds: (_b = compiled.rawLookarounds) !== null && _b !== void 0 ? _b : [],
+        flags: partial.flags,
+        probe: undefined,
+        stickyPreScan: undefined,
+        expansions: [],
+        oldestExpansion: 0
+    })));
+}

package/lib/hitEnd/matchHitEnd.d.ts

@@ -0,0 +1,4 @@
+import type { CompiledPartial } from "../partialMatchRegExp/compilePartial/compiled.ts";
+import type { TruncationProbeCache } from "./truncationProbeCache.ts";
+export declare const EXPANDED_PROBES_KEPT = 12;
+export default function matchHitEnd(compiled: CompiledPartial, match: RegExpExecArray, cache: TruncationProbeCache): boolean;

package/lib/hitEnd/matchHitEnd.js

@@ -0,0 +1,51 @@
+import { buildTruncationProbe, tookTruncationBranch } from "./truncationProbe.js";
+import { backreferenceExpansion } from "../partialMatchRegExp/backreferenceExpansion.js";
+import { FLAGS_IRRELEVANT_TO_REBUILD } from "../partialMatchRegExp/constants.js";
+export const EXPANDED_PROBES_KEPT = 12;
+export default function matchHitEnd(compiled, match, cache) {
+    const probe = "dynamic" in compiled
+        ? dynamicProbe(compiled, match, cache)
+        : unexpandedProbe(compiled, cache);
+    return tookTruncationBranch(probe, match.input, match.index);
+}
+function dynamicProbe(compiled, match, cache) {
+    var _a;
+    const parts = (_a = match[backreferenceExpansion]) !== null && _a !== void 0 ? _a : expandedPartsAt(compiled, match, cache);
+    if (parts === undefined)
+        return unexpandedProbe(compiled, cache);
+    for (const expansion of cache.expansions) {
+        if (sameParts(expansion.parts, parts))
+            return expansion.probe;
+    }
+    const probe = probeOf(parts, cache);
+    cache.expansions[cache.oldestExpansion] = { parts, probe };
+    cache.oldestExpansion = (cache.oldestExpansion + 1) % EXPANDED_PROBES_KEPT;
+    return probe;
+}
+function unexpandedProbe(compiled, cache) {
+    var _a;
+    return ((_a = cache.probe) !== null && _a !== void 0 ? _a : (cache.probe = probeOf(compiled.parts, cache)));
+}
+function probeOf(parts, { rawLookarounds, flags }) {
+    return buildTruncationProbe(parts, rawLookarounds, flags);
+}
+function expandedPartsAt(compiled, match, cache) {
+    var _a;
+    const { preScan, expand } = compiled.dynamic;
+    (_a = cache.stickyPreScan) !== null && _a !== void 0 ? _a : (cache.stickyPreScan = new RegExp(preScan.source, cache.flags.replace(FLAGS_IRRELEVANT_TO_REBUILD, "") + "y"));
+    cache.stickyPreScan.lastIndex = match.index;
+    const capture = cache.stickyPreScan.exec(match.input);
+    if (capture === null)
+        return undefined;
+    const parts = expand(capture);
+    return parts.length === compiled.parts.length ? undefined : parts;
+}
+function sameParts(cached, parts) {
+    if (cached.length !== parts.length)
+        return false;
+    for (let index = 0; index < parts.length; index++) {
+        if (cached[index] !== parts[index])
+            return false;
+    }
+    return true;
+}

package/lib/{partialMatchRegExp/isComplete → hitEnd}/partRole.d.ts

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

package/lib/hitEnd/partRole.js

@@ -0,0 +1,17 @@
+import { NAMED_GROUP_OPENING, endsAtTruncationBranch, isRawLookaround } from "../partialMatchRegExp/atomSyntax.js";
+import { isBackreference } from "../partialMatchRegExp/part.js";
+function isGroupOpen(part) {
+    return (part === "(" ||
+        (part.startsWith(NAMED_GROUP_OPENING) && !isRawLookaround(part)));
+}
+export function roleOf(part) {
+    if (isBackreference(part))
+        return "backreference";
+    if (isRawLookaround(part))
+        return "rawLookaround";
+    if (isGroupOpen(part))
+        return "groupOpen";
+    if (endsAtTruncationBranch(part))
+        return "truncationEnd";
+    return "plain";
+}

package/lib/hitEnd/truncationProbe.d.ts

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

package/lib/hitEnd/truncationProbe.js

@@ -0,0 +1,187 @@
+import { legacyEscapeAsLiteral } from "../partialMatchRegExp/legacyEscape.js";
+import { FLAGS_IRRELEVANT_TO_REBUILD } from "../partialMatchRegExp/constants.js";
+import { DISJUNCTION_TO_END_OF_INPUT, END_ANCHOR, OPTIONAL_ATOM_OPENING, isOptionalAtom, isWordBoundaryAtom } from "../partialMatchRegExp/atomSyntax.js";
+import { isQuantifier, quantifierEndingAt } from "../partialMatchRegExp/quantifier.js";
+import { isBackreference, isNumericBackreference } from "../partialMatchRegExp/part.js";
+import { roleOf } from "./partRole.js";
+const END_OF_INPUT = DISJUNCTION_TO_END_OF_INPUT.slice(1, -1);
+const OPTIONAL_QUANTIFIER = "?";
+const EXACT_QUANTIFIER = /^\{0*([1-9]\d*|0)(?:,0*\1)?\}$/;
+const MARKING = {
+    none: 0,
+    groupOpen: 1,
+    rawLookaround: 2,
+    truncationBranch: 3,
+    wordBoundary: 4,
+    endAnchor: 5,
+    readAtEnd: 6,
+    optionalAtEnd: 7
+};
+function isGreedyReadAtEnd(parts, index) {
+    const part = parts[index];
+    return (isQuantifier(part) &&
+        !EXACT_QUANTIFIER.test(part) &&
+        parts[index + 1] !== OPTIONAL_QUANTIFIER &&
+        quantifierEndingAt(parts, index) === index);
+}
+function markingOf(parts, index) {
+    const part = parts[index];
+    switch (roleOf(part)) {
+        case "backreference":
+            return MARKING.truncationBranch;
+        case "rawLookaround":
+            return MARKING.rawLookaround;
+        case "groupOpen":
+            return MARKING.groupOpen;
+        case "truncationEnd":
+            return isWordBoundaryAtom(part)
+                ? MARKING.wordBoundary
+                : MARKING.truncationBranch;
+        case "plain": {
+            if (part === END_ANCHOR)
+                return MARKING.endAnchor;
+            if (!isGreedyReadAtEnd(parts, index))
+                return MARKING.none;
+            const previous = parts[index - 1];
+            return part === OPTIONAL_QUANTIFIER &&
+                (isBackreference(previous) || isOptionalAtom(previous))
+                ? MARKING.optionalAtEnd
+                : MARKING.readAtEnd;
+        }
+    }
+}
+const markingsOf = (parts) => parts.map((_, index) => markingOf(parts, index));
+function markersAddedBy(marking) {
+    switch (marking) {
+        case MARKING.none:
+        case MARKING.groupOpen:
+        case MARKING.rawLookaround:
+            return 0;
+        case MARKING.wordBoundary:
+            return 2;
+        default:
+            return 1;
+    }
+}
+function groupShiftTable(markings, rawLookarounds) {
+    var _a, _b;
+    const shiftForGroup = [0];
+    let markerCount = 0;
+    let rawLookaroundIndex = 0;
+    for (const marking of markings) {
+        if (marking === MARKING.groupOpen) {
+            shiftForGroup.push(markerCount);
+        }
+        else if (marking === MARKING.rawLookaround) {
+            const capturingGroupsOpened = (_b = (_a = rawLookarounds[rawLookaroundIndex++]) === null || _a === void 0 ? void 0 : _a.capturingGroupsOpened) !== null && _b !== void 0 ? _b : 0;
+            for (let opened = 0; opened < capturingGroupsOpened; opened++) {
+                shiftForGroup.push(markerCount);
+            }
+        }
+        markerCount += markersAddedBy(marking);
+    }
+    return shiftForGroup;
+}
+function renumberedToken(backreference, shiftForGroup) {
+    return isNumericBackreference(backreference)
+        ? "\\" + String(backreference.ref + shiftForGroup[backreference.ref])
+        : "\\k<" + backreference.ref + ">";
+}
+function renumberRawBackreferences(part, info, shiftForGroup) {
+    let renumbered = "";
+    let cursor = 0;
+    for (const reference of info.references) {
+        const relativeStart = reference.start - info.sourceStart;
+        const relativeEnd = reference.end - info.sourceStart;
+        renumbered +=
+            part.slice(cursor, relativeStart) +
+                rawReferenceReplacement(part.slice(relativeStart, relativeEnd), reference, shiftForGroup);
+        cursor = relativeEnd;
+    }
+    return renumbered + part.slice(cursor);
+}
+function rawReferenceReplacement(spelling, { ref }, shiftForGroup) {
+    return ref >= 1 && ref < shiftForGroup.length
+        ? "\\" + String(ref + shiftForGroup[ref])
+        : legacyEscapeAsLiteral(spelling.slice(1));
+}
+export const buildTruncationProbe = (parts, rawLookarounds, flags) => {
+    var _a;
+    const markings = markingsOf(parts);
+    const shiftForGroup = groupShiftTable(markings, rawLookarounds);
+    const markerGroups = [];
+    let groupsOpened = 0;
+    let rawLookaroundIndex = 0;
+    const marker = () => {
+        markerGroups.push(groupsOpened + markerGroups.length + 1);
+        return "()";
+    };
+    const truncationBranch = () => "|" + marker() + END_OF_INPUT + ")";
+    const readAtEnd = () => "(?:" + marker() + END_OF_INPUT + "|)";
+    const probed = [];
+    for (let index = 0; index < parts.length; index++) {
+        const part = parts[index];
+        if (isBackreference(part)) {
+            probed.push(OPTIONAL_ATOM_OPENING +
+                renumberedToken(part, shiftForGroup) +
+                truncationBranch());
+            continue;
+        }
+        switch (markings[index]) {
+            case MARKING.rawLookaround: {
+                const rawLookaround = rawLookarounds[rawLookaroundIndex++];
+                groupsOpened += (_a = rawLookaround === null || rawLookaround === void 0 ? void 0 : rawLookaround.capturingGroupsOpened) !== null && _a !== void 0 ? _a : 0;
+                probed.push(rawLookaround
+                    ? renumberRawBackreferences(part, rawLookaround, shiftForGroup)
+                    : part);
+                break;
+            }
+            case MARKING.groupOpen:
+                groupsOpened++;
+                probed.push(part);
+                break;
+            case MARKING.truncationBranch:
+                probed.push(part.slice(0, -DISJUNCTION_TO_END_OF_INPUT.length) + truncationBranch());
+                break;
+            case MARKING.wordBoundary:
+                probed.push(part.slice(0, -DISJUNCTION_TO_END_OF_INPUT.length) +
+                    readAtEnd() +
+                    truncationBranch());
+                break;
+            case MARKING.endAnchor:
+                probed.push(END_ANCHOR + "(?:" + marker() + "(?![\\s\\S])|)");
+                break;
+            case MARKING.readAtEnd:
+                probed.push(part + readAtEnd());
+                break;
+            case MARKING.optionalAtEnd:
+                probed[probed.length - 1] =
+                    OPTIONAL_ATOM_OPENING +
+                        probed[probed.length - 1] +
+                        "|" +
+                        marker() +
+                        END_OF_INPUT +
+                        "|)";
+                break;
+            default:
+                probed.push(part);
+                break;
+        }
+    }
+    return {
+        regex: new RegExp(probed.join(""), flags.replace(FLAGS_IRRELEVANT_TO_REBUILD, "") + "y"),
+        markerGroups
+    };
+};
+export const tookTruncationBranch = (probe, input, index) => {
+    const { regex, markerGroups } = probe;
+    regex.lastIndex = index;
+    const probed = regex.exec(input);
+    if (probed === null)
+        return true;
+    for (const group of markerGroups) {
+        if (probed[group] !== undefined)
+            return true;
+    }
+    return false;
+};

package/lib/hitEnd/truncationProbeCache.d.ts

@@ -0,0 +1,14 @@
+import type { Part } from "../partialMatchRegExp/part.ts";
+import type { RawLookarounds } from "../partialMatchRegExp/rawLookaroundInfo.ts";
+import type { TruncationProbe } from "./truncationProbe.ts";
+export interface TruncationProbeCache {
+    rawLookarounds: RawLookarounds;
+    flags: string;
+    probe: TruncationProbe | undefined;
+    stickyPreScan: RegExp | undefined;
+    expansions: {
+        parts: readonly Part[];
+        probe: TruncationProbe;
+    }[];
+    oldestExpansion: number;
+}

package/lib/index.d.ts

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

package/lib/index.js

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

package/lib/modules/backreferences/asNativeAtom.d.ts

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

package/lib/{partialMatchRegExp/compilePartial → modules/backreferences}/asNativeAtom.js

@@ -1,5 +1,5 @@
-import { isNumericBackreference } from "../part.js";
-import asOptionalAtom from "./asOptionalAtom.js";
+import { isNumericBackreference } from "../../partialMatchRegExp/part.js";
+import { asOptionalAtom } from "../../partialMatchRegExp/atomSyntax.js";
 function backrefToken(backref) {
     return isNumericBackreference(backref)
         ? "\\" + String(backref.ref)

package/lib/modules/backreferences/asPreScanPart.d.ts

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

package/lib/{partialMatchRegExp/compilePartial → modules/backreferences}/asPreScanPart.js

@@ -1,5 +1,5 @@
-import { ANY_CAPTURED_TEXT } from "../atomSyntax.js";
-import { isBackreference } from "../part.js";
+import { ANY_CAPTURED_TEXT } from "./constants.js";
+import { isBackreference } from "../../partialMatchRegExp/part.js";
 import asNativeAtom from "./asNativeAtom.js";
 export default function asPreScanPart(part) {
     if (!isBackreference(part))

package/lib/modules/backreferences/backreferenceRecorder.d.ts

@@ -0,0 +1,2 @@
+import type { BackreferenceRecorder } from "../../partialMatchRegExp/backreferenceHook.ts";
+export default function backreferenceRecorder(): BackreferenceRecorder;

package/lib/modules/backreferences/backreferenceRecorder.js

@@ -0,0 +1,38 @@
+import { decodeGroupName, groupNameOf } from "./groupName.js";
+import { isNumericBackreference } from "../../partialMatchRegExp/part.js";
+import { CASE_INSENSITIVE } from "../../partialMatchRegExp/scope.js";
+const UNNAMED_GROUP_OPENING = "(";
+export default function backreferenceRecorder() {
+    let closedGroupNumbers;
+    let referencesSinceLastClose;
+    return {
+        groupClosed(groupNumber, opening) {
+            (closedGroupNumbers !== null && closedGroupNumbers !== void 0 ? closedGroupNumbers : (closedGroupNumbers = new Set())).add(groupNumber);
+            if (opening === UNNAMED_GROUP_OPENING)
+                return;
+            const name = decodeGroupName(groupNameOf(opening));
+            const earlierReferences = referencesSinceLastClose === null || referencesSinceLastClose === void 0 ? void 0 : referencesSinceLastClose.get(name);
+            if (earlierReferences === undefined)
+                return;
+            for (const earlier of earlierReferences)
+                earlier.forward = true;
+            referencesSinceLastClose === null || referencesSinceLastClose === void 0 ? void 0 : referencesSinceLastClose.delete(name);
+        },
+        backreference(backreference, scope) {
+            backreference.caseInsensitive = (scope & CASE_INSENSITIVE) !== 0;
+            if (isNumericBackreference(backreference)) {
+                backreference.forward = !(closedGroupNumbers === null || closedGroupNumbers === void 0 ? void 0 : closedGroupNumbers.has(backreference.ref));
+                return;
+            }
+            const name = decodeGroupName(backreference.ref);
+            backreference.forward = false;
+            referencesSinceLastClose !== null && referencesSinceLastClose !== void 0 ? referencesSinceLastClose : (referencesSinceLastClose = new Map());
+            const references = referencesSinceLastClose.get(name);
+            if (references === undefined) {
+                referencesSinceLastClose.set(name, [backreference]);
+                return;
+            }
+            references.push(backreference);
+        }
+    };
+}

package/lib/modules/backreferences/compileDynamic.d.ts

@@ -0,0 +1,4 @@
+import { type Backreference, type Part } from "../../partialMatchRegExp/part.ts";
+import type { Hooks } from "../../partialMatchRegExp/walk.ts";
+import { CompiledBackreferences } from "./compiledBackreferences.ts";
+export default function compileDynamic(parts: readonly Part[], backreferences: readonly Backreference[], flags: string, isUnicode: boolean, featureMask: number, hooks: Hooks): CompiledBackreferences;

package/lib/modules/backreferences/compileDynamic.js

@@ -0,0 +1,53 @@
+import escapeAtom from "./escapeAtom.js";
+import { ALTERNATION } from "./constants.js";
+import { GROUP_CLOSING, ONLY_AT_END_OF_INPUT, OPTIONAL_ATOM_OPENING, asOptionalAtom } from "../../partialMatchRegExp/atomSyntax.js";
+import { isBackreference } from "../../partialMatchRegExp/part.js";
+import { CompiledBackreferences } from "./compiledBackreferences.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";
+export default function compileDynamic(parts, backreferences, flags, isUnicode, featureMask, hooks) {
+    const dynamic = {
+        preScan: new RegExp(parts.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 : "";
+                if (resolved === baked)
+                    continue;
+                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 parts) {
+                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;
+        }
+    };
+    return new CompiledBackreferences(dynamic, parts, featureMask, hooks);
+}