regex-partial-match 1.2.0 → 2.0.0

package/lib/modules/backreferences/groupName.js

@@ -0,0 +1,8 @@
+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) {
+    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/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.d.ts

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

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/modules/backreferences/renderParts.d.ts

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

package/lib/modules/backreferences/renderParts.js

@@ -0,0 +1,9 @@
+import { isBackreference } from "../../partialMatchRegExp/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/modules/backreferences/resolvedFromScan.d.ts

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

package/lib/modules/backreferences/resolvedFromScan.js

@@ -0,0 +1,10 @@
+import { decodeGroupName } from "./groupName.js";
+import { isNumericBackreference } from "../../partialMatchRegExp/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/modules/backreferences/startsWithUnderFlags.d.ts

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

package/lib/modules/backreferences/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/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;

package/lib/modules/carets/index.js

@@ -0,0 +1,18 @@
+import { CARETS_MODULE, defineModule } from "../../partialMatchRegExp/moduleHooks.js";
+import caretRecorder from "./caretRecorder.js";
+import needsCaretRules from "./needsCaretRules.js";
+import { scopeWithModifiers } from "../../partialMatchRegExp/scope.js";
+/**
+ * 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.
+ */
+const carets = defineModule({
+    bit: CARETS_MODULE,
+    caret: (source) => source === undefined || needsCaretRules(source)
+        ? caretRecorder()
+        : undefined,
+    modifiers: scopeWithModifiers
+});
+export default carets;

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

@@ -0,0 +1 @@
+export default function canMatchLineTerminator(atom: string, scope: number): boolean;

package/lib/modules/carets/lineTerminator.js

@@ -0,0 +1,31 @@
+import { optionalAtomTextOf } from "./caretSyntax.js";
+import { DOT_ALL, UNICODE_SETS, flagsOf } from "../../partialMatchRegExp/scope.js";
+const LINE_TERMINATORS = "\n\r\u2028\u2029";
+function compiledMatch(text, scope) {
+    return new RegExp("(?:" + text + ")", flagsOf(scope)).test(LINE_TERMINATORS);
+}
+const ESCAPES_MATCHING_A_LINE_TERMINATOR = "nrsWD";
+const ESCAPES_MATCHING_NO_LINE_TERMINATOR = "Swdtvf";
+const ESCAPE = "\\";
+const ANY_CHARACTER = ".";
+const STRING_SET_ESCAPE = /\\q\{/;
+function knownMatch(text, scope) {
+    if (text === ANY_CHARACTER)
+        return (scope & DOT_ALL) !== 0;
+    if (text.length === 1)
+        return LINE_TERMINATORS.indexOf(text) !== -1;
+    if ((scope & UNICODE_SETS) !== 0 && STRING_SET_ESCAPE.test(text))
+        return true;
+    if (text.length !== 2 || text[0] !== ESCAPE)
+        return undefined;
+    if (ESCAPES_MATCHING_A_LINE_TERMINATOR.indexOf(text[1]) !== -1)
+        return true;
+    if (ESCAPES_MATCHING_NO_LINE_TERMINATOR.indexOf(text[1]) !== -1)
+        return false;
+    return undefined;
+}
+export default function canMatchLineTerminator(atom, scope) {
+    var _a;
+    const text = optionalAtomTextOf(atom);
+    return (_a = knownMatch(text, scope)) !== null && _a !== void 0 ? _a : compiledMatch(text, scope);
+}

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

@@ -0,0 +1 @@
+export default function needsCaretRules(source: string): boolean;

package/lib/modules/carets/needsCaretRules.js

@@ -0,0 +1,15 @@
+export default function needsCaretRules(source) {
+    let firstOpenParen;
+    for (let k = source.indexOf("^", 1); k !== -1; k = source.indexOf("^", k + 1)) {
+        const before = source[k - 1];
+        if (before === "[")
+            continue;
+        if (before === "|") {
+            firstOpenParen !== null && firstOpenParen !== void 0 ? firstOpenParen : (firstOpenParen = source.indexOf("("));
+            if (firstOpenParen === -1 || firstOpenParen > k)
+                continue;
+        }
+        return true;
+    }
+    return false;
+}

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

@@ -0,0 +1,3 @@
+export declare function quantifierAhead(source: string, index: number): string | undefined;
+export declare const isQuantifierAhead: (source: string, index: number) => boolean;
+export declare function minimumOf(quantifier: string): number;

package/lib/modules/carets/quantifierBounds.js

@@ -0,0 +1,18 @@
+const QUANTIFIER_AHEAD = /[*+?]|\{\d+(?:,\d*)?\}/y;
+export function quantifierAhead(source, index) {
+    var _a;
+    QUANTIFIER_AHEAD.lastIndex = index;
+    return (_a = QUANTIFIER_AHEAD.exec(source)) === null || _a === void 0 ? void 0 : _a[0];
+}
+export const isQuantifierAhead = (source, index) => quantifierAhead(source, index) !== undefined;
+export function minimumOf(quantifier) {
+    switch (quantifier) {
+        case "*":
+        case "?":
+            return 0;
+        case "+":
+            return 1;
+        default:
+            return parseInt(quantifier.slice(1), 10);
+    }
+}

package/lib/modules/index.d.ts

@@ -0,0 +1,3 @@
+export { default as carets } from "./carets/index.ts";
+export { default as backreferences } from "./backreferences/index.ts";
+export type { Module } from "../partialMatchRegExp/opaqueModule.ts";

package/lib/modules/index.js

@@ -0,0 +1,2 @@
+export { default as carets } from "./carets/index.js";
+export { default as backreferences } from "./backreferences/index.js";

package/lib/partialMatchRegExp/atomSyntax.d.ts

@@ -0,0 +1,17 @@
+import type { Part } from "./part.ts";
+export declare const START_ANCHOR = "^";
+export declare const END_ANCHOR = "$";
+export declare const GROUP_CLOSING = ")";
+export declare const LOOKAHEAD_OPENING = "(?=";
+export declare const DISJUNCTION_TO_END_OF_INPUT = "|$(?![\\s\\S]))";
+export declare const OPTIONAL_ATOM_OPENING = "(?:";
+export declare const NAMED_GROUP_OPENING = "(?<";
+export declare function asOptionalAtom(text: string): string;
+export declare const MULTILINE_CARET = "(?m:^)";
+export declare const UNSATISFIABLE = "[]";
+export declare const ONLY_AT_END_OF_INPUT: string;
+export declare const WORD_BOUNDARY_ATOMS: readonly [string, string];
+export declare const isWordBoundaryAtom: (part: Part) => boolean;
+export declare const isOptionalAtom: (part: Part | undefined) => part is string;
+export declare function isRawLookaround(part: string): boolean;
+export declare const endsAtTruncationBranch: (part: string) => boolean;