regex-partial-match 1.3.0 → 2.0.1

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);
+}

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

@@ -0,0 +1,9 @@
+import { Compiled, type CompiledDynamic, type DynamicPath } from "../../partialMatchRegExp/compilePartial/compiled.ts";
+import type { Part } from "../../partialMatchRegExp/part.ts";
+import type { Hooks } from "../../partialMatchRegExp/walk.ts";
+import execDynamic from "./execDynamic.ts";
+export declare class CompiledBackreferences extends Compiled implements CompiledDynamic {
+    readonly dynamic: DynamicPath;
+    readonly execDynamic: typeof execDynamic;
+    constructor(dynamic: DynamicPath, parts: readonly Part[], featureMask: number, hooks: Hooks);
+}

package/lib/modules/backreferences/compiledBackreferences.js

@@ -0,0 +1,9 @@
+import { Compiled } from "../../partialMatchRegExp/compilePartial/compiled.js";
+import execDynamic from "./execDynamic.js";
+export class CompiledBackreferences extends Compiled {
+    constructor(dynamic, parts, featureMask, hooks) {
+        super(parts, featureMask, hooks);
+        this.dynamic = dynamic;
+        this.execDynamic = execDynamic;
+    }
+}

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

@@ -0,0 +1,2 @@
+export declare const ANY_CAPTURED_TEXT = "(?:[\\s\\S]*?)";
+export declare const ALTERNATION = "|";

package/lib/modules/backreferences/constants.js

@@ -0,0 +1,2 @@
+export const ANY_CAPTURED_TEXT = "(?:[\\s\\S]*?)";
+export const ALTERNATION = "|";

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

@@ -0,0 +1,2 @@
+import type { DynamicPath } from "../../partialMatchRegExp/compilePartial/compiled.ts";
+export default function execDynamic(this: RegExp, dynamic: DynamicPath, input: string): RegExpExecArray | null;

package/lib/modules/backreferences/execDynamic.js

@@ -0,0 +1,43 @@
+import renderParts from "./renderParts.js";
+import { backreferenceExpansion } from "../../partialMatchRegExp/backreferenceExpansion.js";
+import execFrom from "../../partialMatchRegExp/execFrom.js";
+function isAtOrBefore(match, index) {
+    return match !== null && match.index <= index;
+}
+export default function execDynamic(dynamic, input) {
+    const { preScan, expand, expansionFitsCaptures } = dynamic;
+    const honoursLastIndex = this.global || this.sticky;
+    const start = honoursLastIndex ? this.lastIndex : 0;
+    const originalMatch = RegExp.prototype.exec.call(this, 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 = preScanMatch !== null && preScanMatch !== void 0 ? preScanMatch : execFrom(preScan, input, start);
+    if (capture === null)
+        return originalMatch;
+    const scanningFlags = honoursLastIndex ? this.flags : this.flags + "g";
+    let expandedFrom = capture;
+    let expandedParts = expand(expandedFrom);
+    let expanded = new RegExp(renderParts(expandedParts), scanningFlags);
+    let match = execFrom(expanded, input, start);
+    if (match !== null && !expansionFitsCaptures(expandedFrom, match, input)) {
+        expandedFrom = match;
+        expandedParts = expand(expandedFrom);
+        expanded = new RegExp(renderParts(expandedParts), scanningFlags);
+        match = execFrom(expanded, input, expandedFrom.index);
+        if (match !== null && !expansionFitsCaptures(expandedFrom, match, input))
+            match = null;
+    }
+    if (match === null || isAtOrBefore(originalMatch, match.index))
+        return originalMatch;
+    if (honoursLastIndex)
+        this.lastIndex = expanded.lastIndex;
+    match[backreferenceExpansion] = expandedParts;
+    return match;
+}

package/lib/{partialMatchRegExp/compilePartial → modules/backreferences}/flagsAtBackreference.d.ts

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

package/lib/{partialMatchRegExp → modules/backreferences}/groupName.js

@@ -1,4 +1,4 @@
-import { NAMED_GROUP_OPENING } from "./atomSyntax.js";
+import { NAMED_GROUP_OPENING } from "../../partialMatchRegExp/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) {

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

@@ -0,0 +1,10 @@
+import type { Module } from "../../partialMatchRegExp/opaqueModule.ts";
+/**
+ * The module that matches a backreference against the text its group
+ * captured, for `withModules` from `regex-partial-match/core`.
+ *
+ * Without it, the `core` class throws a `TypeError` for a pattern whose
+ * backreference can only be resolved at match time.
+ */
+declare const backreferences: Module;
+export default backreferences;

package/lib/modules/backreferences/index.js

@@ -0,0 +1,20 @@
+import { BACKREFERENCES_MODULE, defineModule } from "../../partialMatchRegExp/moduleHooks.js";
+import backreferenceRecorder from "./backreferenceRecorder.js";
+import compileDynamic from "./compileDynamic.js";
+import { scopeWithModifiers } from "../../partialMatchRegExp/scope.js";
+/**
+ * The module that matches a backreference against the text its group
+ * captured, for `withModules` from `regex-partial-match/core`.
+ *
+ * Without it, the `core` class throws a `TypeError` for a pattern whose
+ * backreference can only be resolved at match time.
+ */
+const backreferences = defineModule({
+    bit: BACKREFERENCES_MODULE,
+    backreference: Object.freeze({
+        record: backreferenceRecorder,
+        compile: compileDynamic
+    }),
+    modifiers: scopeWithModifiers
+});
+export default backreferences;

package/lib/modules/backreferences/longestBakedPrefixEndingInput.js

@@ -0,0 +1,46 @@
+import escapeAtom from "./escapeAtom.js";
+import caseFoldFlags from "./caseFoldFlags.js";
+const NO_CASE_FOLDING = { __proto__: null };
+function foldMatchersFor(atoms, flags) {
+    if (!flags.includes("i"))
+        return NO_CASE_FOLDING;
+    const matchers = { __proto__: null };
+    const foldFlags = caseFoldFlags(flags);
+    for (const atom of atoms) {
+        if (!(atom in matchers)) {
+            matchers[atom] = new RegExp("^" + escapeAtom(atom), foldFlags);
+        }
+    }
+    return matchers;
+}
+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 reach = bakedAtoms.length;
+    const withinReach = input.slice(isUnicode ? -2 * reach : -reach);
+    const inputAtoms = (isUnicode ? Array.from(withinReach) : withinReach.split("")).slice(-reach);
+    const foldMatchers = foldMatchersFor(bakedAtoms, flags);
+    const agrees = (bakedIndex, atom) => {
+        var _a, _b;
+        const bakedAtom = bakedAtoms[bakedIndex];
+        return bakedAtom === atom || ((_b = (_a = foldMatchers[bakedAtom]) === null || _a === void 0 ? void 0 : _a.test(atom)) !== null && _b !== void 0 ? _b : false);
+    };
+    const longestBorder = [0];
+    for (let index = 1; index < reach; index++) {
+        const atom = bakedAtoms[index];
+        let matched = longestBorder[index - 1];
+        while (matched > 0 && !agrees(matched, atom))
+            matched = longestBorder[matched - 1];
+        longestBorder.push(agrees(matched, atom) ? matched + 1 : 0);
+    }
+    let matched = 0;
+    for (const atom of inputAtoms) {
+        while (matched > 0 && !agrees(matched, atom))
+            matched = longestBorder[matched - 1];
+        if (agrees(matched, atom))
+            matched++;
+    }
+    return bakedAtoms.slice(0, matched).join("");
+}

package/lib/{partialMatchRegExp/compilePartial → modules/backreferences}/renderParts.d.ts

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

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

@@ -1,4 +1,4 @@
-import { isBackreference } from "../part.js";
+import { isBackreference } from "../../partialMatchRegExp/part.js";
 import asNativeAtom from "./asNativeAtom.js";
 export default function renderParts(parts) {
     let rendered = "";

package/lib/{partialMatchRegExp/compilePartial → modules/backreferences}/resolvedFromScan.d.ts

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

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

@@ -1,5 +1,5 @@
-import { decodeGroupName } from "../groupName.js";
-import { isNumericBackreference } from "../part.js";
+import { decodeGroupName } from "./groupName.js";
+import { isNumericBackreference } from "../../partialMatchRegExp/part.js";
 export default function resolvedFromScan(backref, capture) {
     var _a;
     if (backref.forward)

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

@@ -1,4 +1,4 @@
-import escapeAtom from "../escapeAtom.js";
+import escapeAtom from "./escapeAtom.js";
 import caseFoldFlags from "./caseFoldFlags.js";
 export default function startsWithUnderFlags(text, prefix, flags) {
     if (prefix === "" || !flags.includes("i"))

package/lib/modules/carets/appendMultilineCaret.d.ts

@@ -0,0 +1,7 @@
+import { type Part } from "../../partialMatchRegExp/part.ts";
+export type LookaheadSpan = [open: number, close: number];
+export declare const CANNOT_END_LINE = -2;
+export declare function partDecidingCaret(result: Part[], index: number, floor: number, scope: number, lookaheadSpans: LookaheadSpan[] | undefined, spanOffset: number): number;
+export declare function canEndLine(body: Part[], starts: readonly number[], scope: number, lookaheadSpans: LookaheadSpan[] | undefined): boolean;
+declare function appendMultilineCaret(result: Part[], lastGroupOpen: number, lastGroupClose: number, lastGroupScope: number, lastGroupAlternativeStarts: number[] | undefined, lastGroupLookaheadSpans: LookaheadSpan[] | undefined, lookaheadSpans: LookaheadSpan[] | undefined, scope: number): number;
+export default appendMultilineCaret;

package/lib/modules/carets/appendMultilineCaret.js

@@ -0,0 +1,181 @@
+import { DISJUNCTION_TO_END_OF_INPUT, END_ANCHOR, GROUP_CLOSING, ONLY_AT_END_OF_INPUT, OPTIONAL_ATOM_OPENING, UNSATISFIABLE, asOptionalAtom, isOptionalAtom, isRawLookaround, isWordBoundaryAtom } from "../../partialMatchRegExp/atomSyntax.js";
+import { caretFor, isCaret } from "./caretSyntax.js";
+import canMatchLineTerminator from "./lineTerminator.js";
+import { isBackreference } from "../../partialMatchRegExp/part.js";
+import { isQuantifier, quantifierEndingAt } from "../../partialMatchRegExp/quantifier.js";
+import { minimumOf } from "./quantifierBounds.js";
+export const CANNOT_END_LINE = -2;
+const NO_LOOKAHEAD = -1;
+const isTransparentToCaret = (part) => typeof part === "string" &&
+    (part === END_ANCHOR ||
+        isWordBoundaryAtom(part) ||
+        isCaret(part) ||
+        isRawLookaround(part));
+function lookaheadOpeningClosedAt(lookaheadSpans, index, spanOffset) {
+    for (const span of lookaheadSpans) {
+        if (span[1] + spanOffset === index)
+            return span[0] + spanOffset;
+    }
+    return NO_LOOKAHEAD;
+}
+export function partDecidingCaret(result, index, floor, scope, lookaheadSpans, spanOffset) {
+    while (index > floor) {
+        const part = result[index];
+        if (lookaheadSpans !== undefined) {
+            const lookaheadOpening = lookaheadOpeningClosedAt(lookaheadSpans, index, spanOffset);
+            if (lookaheadOpening !== NO_LOOKAHEAD) {
+                index = lookaheadOpening - 1;
+                continue;
+            }
+        }
+        if (isTransparentToCaret(part)) {
+            index--;
+            continue;
+        }
+        if (isOptionalAtom(part)) {
+            return canMatchLineTerminator(part, scope) ? index : CANNOT_END_LINE;
+        }
+        if (!isQuantifier(part))
+            return result[index] === UNSATISFIABLE ? CANNOT_END_LINE : index;
+        const quantifierIndex = quantifierEndingAt(result, index);
+        const atom = result[quantifierIndex - 1];
+        if (!isOptionalAtom(atom) || canMatchLineTerminator(atom, scope)) {
+            return index;
+        }
+        if (minimumOf(result[quantifierIndex]) > 0) {
+            return CANNOT_END_LINE;
+        }
+        result[quantifierIndex - 1] = ONLY_AT_END_OF_INPUT;
+        index = quantifierIndex - 2;
+    }
+    return floor;
+}
+export function canEndLine(body, starts, scope, lookaheadSpans) {
+    const scanned = body.slice();
+    let end = body.length;
+    for (let k = starts.length; k--;) {
+        const start = starts[k];
+        if (partDecidingCaret(scanned, end - 1, start - 1, scope, lookaheadSpans, 0) !== CANNOT_END_LINE)
+            return true;
+        end = start - 1;
+    }
+    return false;
+}
+function shiftSpans(lookaheadSpans, after, by) {
+    if (!lookaheadSpans)
+        return;
+    for (const span of lookaheadSpans) {
+        if (span[0] > after) {
+            span[0] += by;
+            span[1] += by;
+        }
+    }
+}
+const isPositionUncertain = (part) => isBackreference(part) || isQuantifier(part);
+function foldCaret(result, index, caret) {
+    const atom = result[index];
+    result[index] =
+        atom.slice(0, -DISJUNCTION_TO_END_OF_INPUT.length) +
+            caret +
+            DISJUNCTION_TO_END_OF_INPUT;
+}
+function wrapGroup(result, open, close, scope, lookaheadSpans) {
+    result.splice(open + 1, 0, OPTIONAL_ATOM_OPENING);
+    result.splice(close + 1, 1, GROUP_CLOSING + caretFor(scope), DISJUNCTION_TO_END_OF_INPUT);
+    shiftSpans(lookaheadSpans, close, 2);
+    return close + 2;
+}
+function appendCaretToAlternatives(result, open, close, scope, starts, bodySpans, lookaheadSpans) {
+    const anchors = [];
+    const ends = [];
+    let end = close;
+    for (let k = starts.length; k--;) {
+        const floor = open + starts[k];
+        const anchor = partDecidingCaret(result, end - 1, floor, scope, bodySpans, open + 1);
+        if (anchor === floor ||
+            (anchor !== CANNOT_END_LINE &&
+                !isOptionalAtom(result[anchor]) &&
+                !isPositionUncertain(result[anchor])))
+            return wrapGroup(result, open, close, scope, lookaheadSpans);
+        anchors.push(anchor);
+        ends.push(end);
+        end = floor;
+    }
+    const caret = caretFor(scope);
+    let inserted = 0;
+    for (let n = 0; n < anchors.length; n++) {
+        const anchor = anchors[n];
+        if (anchor !== CANNOT_END_LINE && isOptionalAtom(result[anchor])) {
+            foldCaret(result, anchor, caret);
+            continue;
+        }
+        const at = anchor === CANNOT_END_LINE ? ends[n] : anchor + 1;
+        result.splice(at, 0, anchor === CANNOT_END_LINE ? UNSATISFIABLE : asOptionalAtom(caret));
+        shiftSpans(lookaheadSpans, at - 1, 1);
+        shiftSpans(bodySpans, at - open - 2, 1);
+        for (let k = starts.length; k--;)
+            if (open + starts[k] >= at)
+                starts[k]++;
+        inserted++;
+    }
+    return close + inserted;
+}
+function appendMultilineCaret(result, lastGroupOpen, lastGroupClose, lastGroupScope, lastGroupAlternativeStarts, lastGroupLookaheadSpans, lookaheadSpans, scope) {
+    const caret = caretFor(scope);
+    let lookedThroughGroup = false;
+    let anchor = partDecidingCaret(result, result.length - 1, -1, scope, lookaheadSpans, 0);
+    if (anchor >= 0 && anchor === lastGroupClose) {
+        if (lastGroupAlternativeStarts)
+            return appendCaretToAlternatives(result, lastGroupOpen, lastGroupClose, lastGroupScope, lastGroupAlternativeStarts, lastGroupLookaheadSpans, lookaheadSpans);
+        const bodyAnchor = partDecidingCaret(result, anchor - 1, lastGroupOpen, lastGroupScope, lastGroupLookaheadSpans, lastGroupOpen + 1);
+        if (bodyAnchor === CANNOT_END_LINE) {
+            anchor = CANNOT_END_LINE;
+        }
+        else if (bodyAnchor === lastGroupOpen) {
+            lookedThroughGroup = true;
+            anchor = partDecidingCaret(result, lastGroupOpen - 1, -1, scope, lookaheadSpans, 0);
+        }
+        else if (isOptionalAtom(result[bodyAnchor])) {
+            foldCaret(result, bodyAnchor, caretFor(lastGroupScope));
+            return lastGroupClose;
+        }
+        else if (isPositionUncertain(result[bodyAnchor])) {
+            result.splice(bodyAnchor + 1, 0, asOptionalAtom(caretFor(lastGroupScope)));
+            shiftSpans(lookaheadSpans, bodyAnchor, 1);
+            shiftSpans(lastGroupLookaheadSpans, bodyAnchor - lastGroupOpen - 1, 1);
+            return lastGroupClose + 1;
+        }
+        else {
+            return wrapGroup(result, lastGroupOpen, lastGroupClose, lastGroupScope, lookaheadSpans);
+        }
+    }
+    if (anchor === CANNOT_END_LINE) {
+        result.push(UNSATISFIABLE);
+        return lastGroupClose;
+    }
+    if (anchor < 0) {
+        result.push(caret);
+        return lastGroupClose;
+    }
+    const previous = result[anchor];
+    if (isOptionalAtom(previous)) {
+        foldCaret(result, anchor, caret);
+        return lastGroupClose;
+    }
+    const positionUncertain = isBackreference(previous) || isQuantifier(previous);
+    if (lookedThroughGroup &&
+        (positionUncertain ||
+            previous === DISJUNCTION_TO_END_OF_INPUT ||
+            previous === GROUP_CLOSING)) {
+        return wrapGroup(result, lastGroupOpen, lastGroupClose, lastGroupScope, lookaheadSpans);
+    }
+    if (positionUncertain) {
+        result.splice(anchor + 1, 0, asOptionalAtom(caret));
+        shiftSpans(lookaheadSpans, anchor, 1);
+    }
+    else {
+        result.push(caret);
+    }
+    return lastGroupClose;
+}
+export default appendMultilineCaret;

package/lib/modules/carets/caretRecorder.d.ts

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

package/lib/modules/carets/caretRecorder.js

@@ -0,0 +1,164 @@
+import { DISJUNCTION_TO_END_OF_INPUT, END_ANCHOR, GROUP_CLOSING, LOOKAHEAD_OPENING, ONLY_AT_END_OF_INPUT, START_ANCHOR, UNSATISFIABLE, asOptionalAtom, isRawLookaround, isWordBoundaryAtom } from "../../partialMatchRegExp/atomSyntax.js";
+import { LAZY_MARK, isQuantifier } from "../../partialMatchRegExp/quantifier.js";
+import { MULTILINE } from "../../partialMatchRegExp/scope.js";
+import { ON_ALTERNATIVE, ON_CARET, ON_GROUP, ON_LOOKAHEAD } from "../../partialMatchRegExp/caretHook.js";
+import appendMultilineCaret, { canEndLine } from "./appendMultilineCaret.js";
+import { isQuantifierAhead, minimumOf, quantifierAhead } from "./quantifierBounds.js";
+const NO_ALTERNATIVES = [0];
+const NO_LOOKAHEAD_SPANS = [];
+const GROUP_OPENING = /^\((?:\?(?:<[^=!][^>]*>|[a-z-]*:))?$/;
+function lookaheadClosing(lookaheadSpans, opening) {
+    let closing = opening;
+    for (const span of lookaheadSpans) {
+        if (span[0] === opening)
+            closing = span[1];
+    }
+    return closing;
+}
+function leadingCaret(body, index, lookaheadSpans) {
+    for (;;) {
+        const part = body[index];
+        if (part === START_ANCHOR)
+            return index;
+        if (typeof part !== "string")
+            return -1;
+        if (part === END_ANCHOR ||
+            isWordBoundaryAtom(part) ||
+            isRawLookaround(part))
+            index++;
+        else if (part === LOOKAHEAD_OPENING)
+            index = lookaheadClosing(lookaheadSpans, index) + 1;
+        else if (part === ONLY_AT_END_OF_INPUT && isQuantifier(body[index + 1]))
+            index++;
+        else if ((body[index + 1] === GROUP_CLOSING ||
+            body[index + 1] === DISJUNCTION_TO_END_OF_INPUT) &&
+            GROUP_OPENING.test(part))
+            index += 2;
+        else
+            return -1;
+        if (isQuantifier(body[index]))
+            index += body[index + 1] === LAZY_MARK ? 2 : 1;
+    }
+}
+function leadingCarets(body, starts, lookaheadSpans) {
+    const carets = [];
+    for (const start of starts) {
+        const caret = leadingCaret(body, start, lookaheadSpans);
+        if (caret === -1)
+            return undefined;
+        carets.push(caret);
+    }
+    return carets;
+}
+export default function caretRecorder() {
+    let lastBodyAlternativeStarts;
+    let lastBodyLookaheadSpans;
+    let lastBodyCaretsBefore = 0;
+    let lastBodyVerbatimMultilineCaretsBefore = 0;
+    let caretsSeen = 0;
+    let verbatimMultilineCarets = 0;
+    return (result, scope) => {
+        const caretsBefore = caretsSeen;
+        const verbatimMultilineCaretsBefore = verbatimMultilineCarets;
+        let lastGroupOpen = -1;
+        let lastGroupClose = -1;
+        let lastGroupScope = scope;
+        let lastGroupAlternativeStarts;
+        let lastGroupLookaheadSpans;
+        let lookaheadSpans;
+        let alternativeStarts;
+        return ((event, body, groupScope, source, i, closing, containsRawLookaround) => {
+            if (event === ON_CARET) {
+                caretsSeen++;
+                if (scope & MULTILINE) {
+                    lastGroupClose = appendMultilineCaret(result, lastGroupOpen, lastGroupClose, lastGroupScope, lastGroupAlternativeStarts, lastGroupLookaheadSpans, lookaheadSpans, scope);
+                    if (result[result.length - 1] === START_ANCHOR)
+                        verbatimMultilineCarets++;
+                }
+                else {
+                    result.push(START_ANCHOR);
+                }
+            }
+            else if (event === ON_ALTERNATIVE) {
+                (alternativeStarts !== null && alternativeStarts !== void 0 ? alternativeStarts : (alternativeStarts = [0])).push(result.length + 1);
+            }
+            else if (event === ON_LOOKAHEAD) {
+                if (scope & MULTILINE &&
+                    body[0] === START_ANCHOR &&
+                    !lastBodyAlternativeStarts &&
+                    !isQuantifierAhead(source, i)) {
+                    body.shift();
+                    lastGroupClose = appendMultilineCaret(result, lastGroupOpen, lastGroupClose, lastGroupScope, lastGroupAlternativeStarts, lastGroupLookaheadSpans, lookaheadSpans, scope);
+                }
+                const lookaheadOpen = result.length;
+                const lookaheadClose = lookaheadOpen + body.length + 1;
+                (lookaheadSpans !== null && lookaheadSpans !== void 0 ? lookaheadSpans : (lookaheadSpans = [])).push([lookaheadOpen, lookaheadClose]);
+            }
+            else if (event === ON_GROUP) {
+                const starts = lastBodyAlternativeStarts !== null && lastBodyAlternativeStarts !== void 0 ? lastBodyAlternativeStarts : NO_ALTERNATIVES;
+                const containsCaret = caretsSeen !== lastBodyCaretsBefore;
+                const carets = containsCaret
+                    ? leadingCarets(body, starts, lastBodyLookaheadSpans !== null && lastBodyLookaheadSpans !== void 0 ? lastBodyLookaheadSpans : NO_LOOKAHEAD_SPANS)
+                    : undefined;
+                const containsMultilineCaret = verbatimMultilineCarets !== lastBodyVerbatimMultilineCaretsBefore;
+                let hoistedCaretStays = false;
+                if (carets && (groupScope & MULTILINE || !(scope & MULTILINE))) {
+                    const quantifier = quantifierAhead(source, i);
+                    const minimum = quantifier === undefined ? 1 : minimumOf(quantifier);
+                    if (minimum > 0) {
+                        if (groupScope & MULTILINE) {
+                            hoistedCaretStays = !(scope & MULTILINE);
+                            lastGroupClose = appendMultilineCaret(result, lastGroupOpen, lastGroupClose, lastGroupScope, lastGroupAlternativeStarts, lastGroupLookaheadSpans, lookaheadSpans, scope);
+                        }
+                        else
+                            result.push(START_ANCHOR);
+                    }
+                    if (quantifier === undefined) {
+                        for (let k = carets.length; k--;) {
+                            body.splice(carets[k], 1);
+                            if (lastBodyLookaheadSpans)
+                                for (const span of lastBodyLookaheadSpans) {
+                                    if (span[0] > carets[k]) {
+                                        span[0]--;
+                                        span[1]--;
+                                    }
+                                }
+                        }
+                        if (lastBodyAlternativeStarts)
+                            for (let k = starts.length; k--;)
+                                lastBodyAlternativeStarts[k] -= k;
+                    }
+                    else if (groupScope & MULTILINE) {
+                        const repeatedCaret = minimum > 1 &&
+                            !canEndLine(body, starts, groupScope, lastBodyLookaheadSpans)
+                            ? UNSATISFIABLE
+                            : asOptionalAtom(START_ANCHOR);
+                        for (const caret of carets)
+                            body[caret] = repeatedCaret;
+                    }
+                    else if (!containsRawLookaround)
+                        closing = GROUP_CLOSING;
+                }
+                let forced = false;
+                if (groupScope & MULTILINE &&
+                    containsMultilineCaret &&
+                    body.indexOf(START_ANCHOR) !== -1) {
+                    closing = DISJUNCTION_TO_END_OF_INPUT;
+                    forced = true;
+                }
+                lastGroupOpen = result.length;
+                lastGroupClose = lastGroupOpen + body.length + 1;
+                lastGroupScope = groupScope;
+                lastGroupAlternativeStarts = lastBodyAlternativeStarts;
+                lastGroupLookaheadSpans = lastBodyLookaheadSpans;
+                return { closing, forced, stays: hoistedCaretStays };
+            }
+            else {
+                lastBodyAlternativeStarts = alternativeStarts;
+                lastBodyLookaheadSpans = lookaheadSpans;
+                lastBodyCaretsBefore = caretsBefore;
+                lastBodyVerbatimMultilineCaretsBefore = verbatimMultilineCaretsBefore;
+            }
+        });
+    };
+}

package/lib/modules/carets/caretSyntax.d.ts

@@ -0,0 +1,3 @@
+export declare const caretFor: (scope: number) => "^" | "(?m:^)";
+export declare const isCaret: (part: string) => boolean;
+export declare const optionalAtomTextOf: (atom: string) => string;

package/lib/modules/carets/caretSyntax.js

@@ -0,0 +1,11 @@
+import { DISJUNCTION_TO_END_OF_INPUT, MULTILINE_CARET, OPTIONAL_ATOM_OPENING, START_ANCHOR, asOptionalAtom } from "../../partialMatchRegExp/atomSyntax.js";
+import { MULTILINE } from "../../partialMatchRegExp/scope.js";
+const CARET_SPELLINGS = [
+    START_ANCHOR,
+    MULTILINE_CARET,
+    asOptionalAtom(START_ANCHOR),
+    asOptionalAtom(MULTILINE_CARET)
+];
+export const caretFor = (scope) => scope & MULTILINE ? START_ANCHOR : MULTILINE_CARET;
+export const isCaret = (part) => CARET_SPELLINGS.indexOf(part) !== -1;
+export const optionalAtomTextOf = (atom) => atom.slice(OPTIONAL_ATOM_OPENING.length, -DISJUNCTION_TO_END_OF_INPUT.length);

package/lib/modules/carets/index.d.ts

@@ -0,0 +1,9 @@
+import type { Module } from "../../partialMatchRegExp/opaqueModule.ts";
+/**
+ * The carets module: the rules for a `^` inside a group or positive
+ * lookahead, or after other input under the `m` flag. Bind it with
+ * `withModules` from `regex-partial-match/core` to render `^` exactly as the
+ * default `PartialMatchRegExp` does.
+ */
+declare const carets: Module;
+export default carets;