regex-partial-match 1.2.0 → 2.0.0

package/lib/partialMatchRegExp/atomSyntax.js

@@ -0,0 +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 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

@@ -0,0 +1,5 @@
+import type { Part } from "./part.ts";
+export declare const backreferenceExpansion: unique symbol;
+export interface ExpandedMatch extends RegExpExecArray {
+    [backreferenceExpansion]?: Part[];
+}

package/lib/partialMatchRegExp/backreferenceExpansion.js

@@ -0,0 +1 @@
+export const backreferenceExpansion = Symbol("backreferenceExpansion");

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

@@ -0,0 +1,29 @@
+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 {
+    preScan: RegExp;
+    expand: (capture: RegExpExecArray) => Part[];
+    expansionFitsCaptures: (expandedFrom: RegExpExecArray, match: RegExpExecArray, input: string) => boolean;
+}
+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 honoursLastIndex: boolean;
+    constructor(regex: RegExp, parts: string[], featureMask: number, hooks: Hooks);
+}
+export interface CompiledDynamic extends Compiled {
+    readonly dynamic: DynamicPath;
+    readonly execDynamic: (this: RegExp, dynamic: DynamicPath, input: string) => RegExpExecArray | null;
+}
+export type CompiledPartial = CompiledStatic | CompiledDynamic;

package/lib/partialMatchRegExp/compilePartial/compiled.js

@@ -0,0 +1,14 @@
+export class Compiled {
+    constructor(parts, featureMask, hooks) {
+        this.parts = parts;
+        this.featureMask = featureMask;
+        this.hooks = hooks;
+    }
+}
+export class CompiledStatic extends Compiled {
+    constructor(regex, parts, featureMask, hooks) {
+        super(parts, featureMask, hooks);
+        this.regex = regex;
+        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

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

package/lib/partialMatchRegExp/compilePartial/toStatic.js

@@ -0,0 +1,4 @@
+import { CompiledStatic } from "./compiled.js";
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,31 @@
+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/legacyEscape.d.ts

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

package/lib/partialMatchRegExp/legacyEscape.js

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

package/lib/partialMatchRegExp/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

@@ -0,0 +1,15 @@
+interface NumericBackreference {
+    ref: number;
+    forward?: boolean;
+    caseInsensitive?: boolean;
+}
+interface NamedBackreference {
+    ref: string;
+    forward?: boolean;
+    caseInsensitive?: boolean;
+}
+export type Backreference = NumericBackreference | NamedBackreference;
+export type Part = string | Backreference;
+export declare const isBackreference: (part: Part) => part is Backreference;
+export declare const isNumericBackreference: (part: Part) => part is NumericBackreference;
+export {};

package/lib/partialMatchRegExp/part.js

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

package/lib/partialMatchRegExp/partialMatchInternals.d.ts

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

package/lib/partialMatchRegExp/partialMatchInternals.js

@@ -0,0 +1,4 @@
+export const compiledPartial = Symbol("compiledPartial");
+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

@@ -0,0 +1,2 @@
+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];

package/lib/partialMatchRegExp/regexFeatures.js

@@ -0,0 +1,41 @@
+export const REGEX_FEATURES = [
+    "patternCharacter",
+    "startAnchor",
+    "endAnchor",
+    "wordBoundary",
+    "nonWordBoundary",
+    "lookahead",
+    "negativeLookahead",
+    "lookbehind",
+    "negativeLookbehind",
+    "backreference",
+    "namedBackreference",
+    "namedGroup",
+    "capturingGroup",
+    "lookaroundCapture",
+    "nonCapturingGroup",
+    "modifierGroup",
+    "modifierGroupWithRemoval",
+    "characterClass",
+    "nestedCharacterClass",
+    "classIntersection",
+    "classSubtraction",
+    "disjunction",
+    "quantifier",
+    "unicodePropertyEscape",
+    "characterClassEscape",
+    "controlEscape",
+    "controlLetterEscape",
+    "hexEscapeSequence",
+    "unicodeEscapeSequence",
+    "otherEscape"
+];
+/** @internal */
+export function featureSet(mask) {
+    const features = new Set();
+    for (let index = 0; index < REGEX_FEATURES.length; index++) {
+        if (mask & (1 << index))
+            features.add(REGEX_FEATURES[index]);
+    }
+    return features;
+}

package/lib/partialMatchRegExp/scope.d.ts

@@ -0,0 +1,12 @@
+export declare const CASE_INSENSITIVE = 1;
+export declare const MULTILINE = 2;
+export declare const DOT_ALL = 4;
+export declare const UNICODE = 8;
+export declare const UNICODE_SETS = 16;
+export declare const WITHIN_LOOKAROUND = 32;
+export declare const WITHIN_GROUP = 64;
+export declare const WITHIN_RAW_LOOKAROUND = 128;
+export declare function scopeOf(regex: RegExp): number;
+export type ModifiersHook = (scope: number, modifiers: string) => number;
+export declare function scopeWithModifiers(scope: number, modifiers: string): number;
+export declare function flagsOf(scope: number): string;

package/lib/partialMatchRegExp/scope.js

@@ -0,0 +1,45 @@
+export const CASE_INSENSITIVE = 1;
+export const MULTILINE = 2;
+export const DOT_ALL = 4;
+export const UNICODE = 8;
+export const UNICODE_SETS = 16;
+export const WITHIN_LOOKAROUND = 32;
+export const WITHIN_GROUP = 64;
+export const WITHIN_RAW_LOOKAROUND = 128;
+const MODIFIER_REMOVAL = "-";
+function modifierBit(modifier) {
+    switch (modifier) {
+        case "i":
+            return CASE_INSENSITIVE;
+        case "m":
+            return MULTILINE;
+        default:
+            return DOT_ALL;
+    }
+}
+export function scopeOf(regex) {
+    return ((regex.ignoreCase ? CASE_INSENSITIVE : 0) |
+        (regex.multiline ? MULTILINE : 0) |
+        (regex.dotAll ? DOT_ALL : 0) |
+        (regex.unicode ? UNICODE : 0) |
+        (regex.unicodeSets ? UNICODE | UNICODE_SETS : 0));
+}
+export function scopeWithModifiers(scope, modifiers) {
+    let removing = false;
+    for (let index = 0; index < modifiers.length; index++) {
+        const modifier = modifiers[index];
+        if (modifier === MODIFIER_REMOVAL)
+            removing = true;
+        else if (removing)
+            scope &= ~modifierBit(modifier);
+        else
+            scope |= modifierBit(modifier);
+    }
+    return scope;
+}
+export function flagsOf(scope) {
+    return ((scope & CASE_INSENSITIVE ? "i" : "") +
+        (scope & MULTILINE ? "m" : "") +
+        (scope & DOT_ALL ? "s" : "") +
+        (scope & UNICODE_SETS ? "v" : scope & UNICODE ? "u" : ""));
+}

package/lib/partialMatchRegExp/walk.d.ts

@@ -0,0 +1,16 @@
+import type { Part } from "./part.ts";
+import { type CaretHook, type CaretRecorder } from "./caretHook.ts";
+import type { BackreferenceRecorder, BackreferenceHook } from "./backreferenceHook.ts";
+import type { RawLookaroundInfo } from "./rawLookaroundInfo.ts";
+import { type ModifiersHook } from "./scope.ts";
+export interface Hooks {
+    caret?: CaretHook;
+    backreference?: BackreferenceHook;
+    modifiers?: ModifiersHook;
+}
+export declare function walk(regex: RegExp, declaresNamedGroup: boolean, groupLimit: number, caretRecorder: CaretRecorder | undefined, backreferenceRecorder: BackreferenceRecorder | undefined, withModifiers: Hooks["modifiers"]): {
+    parts: Part[];
+    featureMask: number;
+    needs: number;
+    rawLookarounds: RawLookaroundInfo[] | undefined;
+};