regex-partial-match 1.3.0 → 2.0.0

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

@@ -1,4 +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 const ANY_CAPTURED_TEXT = "(?:[\\s\\S]*?)";
+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;

package/lib/partialMatchRegExp/atomSyntax.js

@@ -1,4 +1,27 @@
+export const START_ANCHOR = "^";
+export const END_ANCHOR = "$";
+export const GROUP_CLOSING = ")";
+export const LOOKAHEAD_OPENING = "(?=";
 export const DISJUNCTION_TO_END_OF_INPUT = "|$(?![\\s\\S]))";
 export const OPTIONAL_ATOM_OPENING = "(?:";
 export const NAMED_GROUP_OPENING = "(?<";
-export const ANY_CAPTURED_TEXT = "(?:[\\s\\S]*?)";
+export function asOptionalAtom(text) {
+    return OPTIONAL_ATOM_OPENING + text + DISJUNCTION_TO_END_OF_INPUT;
+}
+export const MULTILINE_CARET = "(?m:^)";
+export const UNSATISFIABLE = "[]";
+export const ONLY_AT_END_OF_INPUT = asOptionalAtom(UNSATISFIABLE);
+export const WORD_BOUNDARY_ATOMS = [
+    asOptionalAtom("\\b"),
+    asOptionalAtom("\\B")
+];
+export const isWordBoundaryAtom = (part) => part === WORD_BOUNDARY_ATOMS[0] || part === WORD_BOUNDARY_ATOMS[1];
+export const isOptionalAtom = (part) => typeof part === "string" &&
+    part.startsWith(OPTIONAL_ATOM_OPENING) &&
+    part.endsWith(DISJUNCTION_TO_END_OF_INPUT);
+export function isRawLookaround(part) {
+    return (part.startsWith("(?!") ||
+        (part.startsWith(NAMED_GROUP_OPENING) &&
+            "=!".includes(part[NAMED_GROUP_OPENING.length])));
+}
+export const endsAtTruncationBranch = (part) => part === DISJUNCTION_TO_END_OF_INPUT || isOptionalAtom(part);

package/lib/partialMatchRegExp/backreferenceExpansion.d.ts

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

package/lib/partialMatchRegExp/backreferenceHook.d.ts

@@ -0,0 +1,11 @@
+import type { Backreference, Part } from "./part.ts";
+import type { Hooks } from "./walk.ts";
+import type { CompiledDynamic } from "./compilePartial/compiled.ts";
+export interface BackreferenceRecorder {
+    groupClosed(groupNumber: number, opening: string): void;
+    backreference(backreference: Backreference, scope: number): void;
+}
+export interface BackreferenceHook {
+    record: () => BackreferenceRecorder;
+    compile: (parts: readonly Part[], backreferences: readonly Backreference[], flags: string, isUnicode: boolean, featureMask: number, hooks: Hooks) => CompiledDynamic;
+}

package/lib/partialMatchRegExp/backreferenceHook.js

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

package/lib/partialMatchRegExp/caretHook.d.ts

@@ -0,0 +1,17 @@
+import type { Part } from "./part.ts";
+export declare const ON_CARET = 0;
+export declare const ON_ALTERNATIVE = 1;
+export declare const ON_LOOKAHEAD = 2;
+export declare const ON_GROUP = 3;
+export declare const ON_END = 4;
+export interface CaretFrame {
+    (event: typeof ON_CARET | typeof ON_ALTERNATIVE | typeof ON_END): void;
+    (event: typeof ON_LOOKAHEAD, body: Part[], scope: number, source: string, i: number): void;
+    (event: typeof ON_GROUP, body: Part[], groupScope: number, source: string, i: number, closing: string, containsRawLookaround: boolean): {
+        closing: string;
+        forced: boolean;
+        stays: boolean;
+    };
+}
+export type CaretRecorder = (result: Part[], scope: number) => CaretFrame;
+export type CaretHook = (source?: string) => CaretRecorder | undefined;

package/lib/partialMatchRegExp/caretHook.js

@@ -0,0 +1,5 @@
+export const ON_CARET = 0;
+export const ON_ALTERNATIVE = 1;
+export const ON_LOOKAHEAD = 2;
+export const ON_GROUP = 3;
+export const ON_END = 4;

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

@@ -0,0 +1,3 @@
+import { type Hooks } from "../walk.ts";
+import type { CompiledPartial } from "./compiled.ts";
+export default function compileWith(regex: RegExp, hooks: Hooks): CompiledPartial;

package/lib/partialMatchRegExp/compilePartial/compileWith.js

@@ -0,0 +1,36 @@
+import { walk } from "../walk.js";
+import { CARETS_MODULE, MODULES_NAMED_BY_MASK } from "../moduleHooks.js";
+import { MAYBE_HAS_BACKREFERENCE_REGEX } from "../constants.js";
+import { UNCONSTRAINED_GROUP_SHAPE } from "./constants.js";
+import { isBackreference } from "../part.js";
+import groupShape from "./groupShape.js";
+import toStatic from "./toStatic.js";
+function walkWithCaretRulesWhereNeeded(regex, declaresNamedGroup, groupLimit, caret, record, withModifiers) {
+    const walked = walk(regex, declaresNamedGroup, groupLimit, caret === null || caret === void 0 ? void 0 : caret(regex.source), record === null || record === void 0 ? void 0 : record(), withModifiers);
+    return walked.needs & CARETS_MODULE && caret !== undefined
+        ? walk(regex, declaresNamedGroup, groupLimit, caret(), record === null || record === void 0 ? void 0 : record(), withModifiers)
+        : walked;
+}
+export default function compileWith(regex, hooks) {
+    const flags = regex.flags;
+    const isUnicode = regex.unicode || regex.unicodeSets;
+    const maybeHasBackreference = MAYBE_HAS_BACKREFERENCE_REGEX.test(regex.source);
+    const { groupLimit, declaresNamedGroup } = maybeHasBackreference && !isUnicode
+        ? groupShape(regex)
+        : UNCONSTRAINED_GROUP_SHAPE;
+    const backreferenceHook = maybeHasBackreference
+        ? hooks.backreference
+        : undefined;
+    const { parts, featureMask, needs, rawLookarounds } = walkWithCaretRulesWhereNeeded(regex, declaresNamedGroup, groupLimit, hooks.caret, backreferenceHook === null || backreferenceHook === void 0 ? void 0 : backreferenceHook.record, hooks.modifiers);
+    if (needs)
+        throw new TypeError("Needs the " + MODULES_NAMED_BY_MASK[needs]);
+    const backreferences = backreferenceHook
+        ? parts.filter(isBackreference)
+        : [];
+    const compiled = backreferenceHook === undefined || backreferences.length === 0
+        ? toStatic(parts, flags, featureMask, hooks)
+        : backreferenceHook.compile(parts, backreferences, flags, isUnicode, featureMask, hooks);
+    if (rawLookarounds)
+        compiled.rawLookarounds = rawLookarounds;
+    return compiled;
+}

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

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

package/lib/partialMatchRegExp/compilePartial/compiled.js

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

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

@@ -0,0 +1,4 @@
+export declare const UNCONSTRAINED_GROUP_SHAPE: {
+    groupLimit: number;
+    declaresNamedGroup: boolean;
+};

package/lib/partialMatchRegExp/compilePartial/constants.js

@@ -0,0 +1,4 @@
+export const UNCONSTRAINED_GROUP_SHAPE = {
+    groupLimit: Infinity,
+    declaresNamedGroup: true
+};

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

@@ -0,0 +1,4 @@
+export default function groupShape(regex: RegExp): {
+    groupLimit: number;
+    declaresNamedGroup: boolean;
+};

package/lib/partialMatchRegExp/compilePartial/groupShape.js

@@ -0,0 +1,9 @@
+import { FLAGS_IRRELEVANT_TO_REBUILD } from "../constants.js";
+export default function groupShape(regex) {
+    const emptyMatch = new RegExp("|" + regex.source, regex.flags.replace(FLAGS_IRRELEVANT_TO_REBUILD, "")).exec("");
+    return {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- match must succeed, since pattern starts with empty alternative
+        groupLimit: emptyMatch.length - 1,
+        declaresNamedGroup: (emptyMatch === null || emptyMatch === void 0 ? void 0 : emptyMatch.groups) !== undefined
+    };
+}

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

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

package/lib/partialMatchRegExp/compilePartial/toStatic.js

@@ -1,4 +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);
+export default function toStatic(parts, flags, featureMask, hooks) {
+    return new CompiledStatic(new RegExp(parts.join(""), flags), parts, featureMask, hooks);
 }

package/lib/partialMatchRegExp/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const NOT_NUMBERS_REGEX: RegExp;
+export declare const FLAGS_IRRELEVANT_TO_REBUILD: RegExp;
+export declare const LITERAL_BACKSLASH = "\\\\";
+export declare const LITERAL_K = "k";
+export declare const MAYBE_HAS_BACKREFERENCE_REGEX: RegExp;

package/lib/partialMatchRegExp/constants.js

@@ -0,0 +1,5 @@
+export const NOT_NUMBERS_REGEX = /\D/g;
+export const FLAGS_IRRELEVANT_TO_REBUILD = /[dgy]/g;
+export const LITERAL_BACKSLASH = "\\\\";
+export const LITERAL_K = "k";
+export const MAYBE_HAS_BACKREFERENCE_REGEX = /\\[0-9]|\\k</;

package/lib/partialMatchRegExp/createPartialMatchRegExp.d.ts

@@ -0,0 +1,3 @@
+import type { Hooks } from "./walk.ts";
+import type { PartialMatchRegExpConstructor } from "./index.ts";
+export default function createPartialMatchRegExp(hooks: Hooks): PartialMatchRegExpConstructor;

package/lib/partialMatchRegExp/createPartialMatchRegExp.js

@@ -0,0 +1,21 @@
+import compileWith from "./compilePartial/compileWith.js";
+import { compiledPartial } from "./partialMatchInternals.js";
+import execFrom from "./execFrom.js";
+export default function createPartialMatchRegExp(hooks) {
+    return class PartialMatchRegExp extends RegExp {
+        constructor(pattern, flags) {
+            super(pattern, flags);
+            this[compiledPartial] = compileWith(this, hooks);
+        }
+        exec(input) {
+            const compiled = this[compiledPartial];
+            if ("dynamic" in compiled)
+                return compiled.execDynamic.call(this, compiled.dynamic, input);
+            const { regex } = compiled;
+            const match = execFrom(regex, input, this.lastIndex);
+            if (compiled.honoursLastIndex)
+                this.lastIndex = regex.lastIndex;
+            return match;
+        }
+    };
+}

package/lib/partialMatchRegExp/execFrom.d.ts

@@ -0,0 +1 @@
+export default function execFrom(regex: RegExp, input: string, start: number): RegExpExecArray | null;

package/lib/partialMatchRegExp/execFrom.js

@@ -0,0 +1,4 @@
+export default function execFrom(regex, input, start) {
+    regex.lastIndex = start;
+    return regex.exec(input);
+}

package/lib/partialMatchRegExp/index.d.ts

@@ -1,3 +1,49 @@
-export * from "./partialMatchRegExp.ts";
-export { default } from "./partialMatchRegExp.ts";
-export { default as isComplete } from "./isComplete/index.ts";
+import type { RegexFeature } from "./regexFeatures.ts";
+export type { RegexFeature };
+declare const partialMatchRegExpBrand: unique symbol;
+/**
+ * An instance of `PartialMatchRegExp`, from any entry point. Declarations
+ * merged into this interface apply to every such instance.
+ */
+interface PartialMatchRegExp extends RegExp {
+    readonly [partialMatchRegExpBrand]: true;
+    exec(input: string): RegExpExecArray | null;
+}
+/**
+ * The type of a `PartialMatchRegExp` class, from any entry point or
+ * `withModules`.
+ */
+interface PartialMatchRegExpConstructor extends Omit<RegExpConstructor, "prototype" | typeof Symbol.species> {
+    new (pattern: RegExp | string, flags?: string): PartialMatchRegExp;
+    readonly prototype: PartialMatchRegExp;
+    readonly [Symbol.species]: PartialMatchRegExpConstructor;
+}
+/**
+ * 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.
+ * See the documentation for how the `y` (sticky) flag behaves.
+ *
+ * @see {@link https://github.com/TomStrepsil/regex-partial-match#readme | Documentation}
+ */
+declare const PartialMatchRegExp: PartialMatchRegExpConstructor;
+export default PartialMatchRegExp;
+export type { PartialMatchRegExp, PartialMatchRegExpConstructor };

package/lib/partialMatchRegExp/index.js

@@ -1,3 +1,31 @@
-export * from "./partialMatchRegExp.js";
-export { default } from "./partialMatchRegExp.js";
-export { default as isComplete } from "./isComplete/index.js";
+import carets from "../modules/carets/index.js";
+import backreferences from "../modules/backreferences/index.js";
+import withModules from "./withModules.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.
+ * See the documentation for how the `y` (sticky) flag behaves.
+ *
+ * @see {@link https://github.com/TomStrepsil/regex-partial-match#readme | Documentation}
+ */
+const PartialMatchRegExp = withModules(carets, backreferences);
+export default PartialMatchRegExp;

package/lib/partialMatchRegExp/moduleHooks.d.ts

@@ -0,0 +1,14 @@
+import type { Module } from "./opaqueModule.ts";
+import type { Hooks } from "./walk.ts";
+export declare const CARETS_MODULE = 1;
+export declare const BACKREFERENCES_MODULE = 2;
+export declare const MODULES_NAMED_BY_MASK: Record<number, string>;
+export declare const moduleHooks: unique symbol;
+export interface ModuleHooks extends Hooks {
+    readonly bit: number;
+}
+export interface HooksOfModule extends Module {
+    readonly [moduleHooks]: ModuleHooks;
+}
+export declare const definedModuleHooks: Set<unknown>;
+export declare function defineModule(hooks: ModuleHooks): Module;

package/lib/partialMatchRegExp/moduleHooks.js

@@ -0,0 +1,15 @@
+export const CARETS_MODULE = 1;
+export const BACKREFERENCES_MODULE = 2;
+export const MODULES_NAMED_BY_MASK = {
+    [CARETS_MODULE]: "carets module",
+    [BACKREFERENCES_MODULE]: "backreferences module",
+    [CARETS_MODULE | BACKREFERENCES_MODULE]: "carets and backreferences modules"
+};
+export const moduleHooks = Symbol();
+export const definedModuleHooks = new Set();
+export function defineModule(hooks) {
+    definedModuleHooks.add(Object.freeze(hooks));
+    return Object.freeze({
+        [moduleHooks]: hooks
+    });
+}

package/lib/partialMatchRegExp/opaqueModule.d.ts

@@ -0,0 +1,9 @@
+declare const moduleBrand: unique symbol;
+/**
+ * A module for `withModules`, from `regex-partial-match/modules`. Opaque: its
+ * contents are not part of the public API.
+ */
+export interface Module {
+    readonly [moduleBrand]: true;
+}
+export {};

package/lib/partialMatchRegExp/opaqueModule.js

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

package/lib/partialMatchRegExp/part.d.ts

@@ -1,24 +1,15 @@
 interface NumericBackreference {
     ref: number;
-    start: number;
-    end: number;
     forward?: boolean;
-    caseInsensitive: boolean;
+    caseInsensitive?: boolean;
 }
 interface NamedBackreference {
     ref: string;
-    start: number;
-    end: number;
     forward?: boolean;
-    caseInsensitive: 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/partialMatchInternals.d.ts

@@ -1,2 +1,3 @@
+import type { CompiledPartial } from "./compilePartial/compiled.ts";
 export declare const compiledPartial: unique symbol;
-export declare const truncationProbeCache: unique symbol;
+export declare function compiledOf(partial: RegExp): CompiledPartial;

package/lib/partialMatchRegExp/partialMatchInternals.js

@@ -1,2 +1,4 @@
 export const compiledPartial = Symbol("compiledPartial");
-export const truncationProbeCache = Symbol("truncationProbeCache");
+export function compiledOf(partial) {
+    return partial[compiledPartial];
+}

package/lib/partialMatchRegExp/quantifier.d.ts

@@ -0,0 +1,6 @@
+import type { Part } from "./part.ts";
+export declare const OCCURRENCES_REGEX: RegExp;
+export declare const QUANTIFIER_PART: RegExp;
+export declare const LAZY_MARK = "?";
+export declare const isQuantifier: (part: Part | undefined) => part is string;
+export declare function quantifierEndingAt(parts: readonly Part[], index: number): number;

package/lib/partialMatchRegExp/quantifier.js

@@ -0,0 +1,9 @@
+export const OCCURRENCES_REGEX = /\{\d+(?:,\d*)?\}/y;
+export const QUANTIFIER_PART = /^(?:[*+?]|\{\d+(?:,\d*)?\})$/;
+export const LAZY_MARK = "?";
+export const isQuantifier = (part) => typeof part === "string" && QUANTIFIER_PART.test(part);
+export function quantifierEndingAt(parts, index) {
+    return parts[index] === LAZY_MARK && isQuantifier(parts[index - 1])
+        ? index - 1
+        : index;
+}

package/lib/partialMatchRegExp/rawLookaroundInfo.d.ts

@@ -0,0 +1,11 @@
+export interface RawReference {
+    ref: number;
+    start: number;
+    end: number;
+}
+export interface RawLookaroundInfo {
+    sourceStart: number;
+    capturingGroupsOpened: number;
+    references: readonly RawReference[];
+}
+export type RawLookarounds = readonly (RawLookaroundInfo | undefined)[];

package/lib/partialMatchRegExp/rawLookaroundInfo.js

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

package/lib/partialMatchRegExp/regexFeatures.d.ts

@@ -1,6 +1,2 @@
-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 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

@@ -1,4 +1,4 @@
-const REGEX_FEATURES = [
+export const REGEX_FEATURES = [
     "patternCharacter",
     "startAnchor",
     "endAnchor",
@@ -30,13 +30,7 @@ const REGEX_FEATURES = [
     "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;
-}
+/** @internal */
 export function featureSet(mask) {
     const features = new Set();
     for (let index = 0; index < REGEX_FEATURES.length; index++) {