import { regex, Regex } from 'arkregex'; import { Input, Flag, MagicRegExp, createRegExp as createRegExp$1 } from 'magic-regexp'; export { Flag, Input, MagicRegExp, anyOf, carriageReturn, caseInsensitive, char, charIn, charNotIn, digit, dotAll, exactly, global, letter, linefeed, maybe, multiline, not, oneOrMore, sticky, tab, unicode, whitespace, withIndices, word, wordBoundary, wordChar } from 'magic-regexp'; type MagicInput = string | Input; type RegexFlag = "d" | "g" | "i" | "m" | "s" | "u" | "v" | "y"; type MagicFlagInput = Flag | readonly Flag[] | ReadonlySet | string; type RegexMatchMode = "contains" | "exact"; type ArkFlags = `${"d" | ""}${"g" | ""}${"i" | ""}${"m" | ""}${"s" | ""}${"u" | "v" | ""}${"y" | ""}`; type IndexedCaptures = Array; type NamedCaptures = Record; type MagicFromInputs = ReturnType>; type MagicLiteral = R extends MagicRegExp ? Value : never; type SplitMagicBody = Rest extends `${infer Before}\\/${infer After}` ? SplitMagicBody : Rest extends `${infer Before}/${infer Flags}` ? [NormalizeRegexFlags] extends [never] ? never : NormalizeRegexFlags extends infer NormalizedFlags extends ArkFlags ? [source: `${Source}${Before}`, flags: NormalizedFlags] : never : never; type AreRegexFlags = Flags extends "" ? true : Flags extends `${infer First}${infer Rest}` ? First extends RegexFlag ? AreRegexFlags : false : false; type FlagTextIfPresent = Flags extends `${string}${Candidate}${string}` ? Candidate : ""; type NormalizeRegexFlags = AreRegexFlags extends true ? `${FlagTextIfPresent}${FlagTextIfPresent}${FlagTextIfPresent}${FlagTextIfPresent}${FlagTextIfPresent}${FlagTextIfPresent}${FlagTextIfPresent}${FlagTextIfPresent}` : never; /** * Splits Magic Regex's type-level literal form into the source and flags that * ArkRegex expects. * * Magic Regex models compiled values as strings like `"/source/flags"`. This * helper preserves escaped forward slashes in the source so adapter types do not * split on `\/` inside a pattern. */ type RegexParts = Value extends `/${infer Body}` ? SplitMagicBody : never; /** * Readable strict-mode marker returned when a Magic Regex value cannot be * converted into an ArkRegex-typed value. * * The adapter still works at runtime for native `RegExp` syntax supported by the * JavaScript engine. This type exists so library users do not silently lose the * ArkRegex type benefit when the type-level parser cannot prove compatibility. */ type WandCompatibilityError = { readonly __regexWandCompatibilityError__: `${Reason}: ${Pattern}`; }; type WandExtractionError = WandCompatibilityError<"Expected Magic Regex literal /source/flags", MagicLiteral>; type WandParseError = WandCompatibilityError<"ArkRegex could not infer this pattern", Source>; type ArkFromMagic = [RegexParts>] extends [never] ? WandExtractionError : RegexParts> extends [ infer Source extends string, infer FlagText extends ArkFlags ] ? regex.parse extends Regex ? regex.parse : WandParseError : WandExtractionError; type FlagIfPresent = Extract extends never ? "" : Candidate; type CanonicalFlags = `${FlagIfPresent}${FlagIfPresent}${FlagIfPresent}${FlagIfPresent}${FlagIfPresent}${FlagIfPresent}${FlagIfPresent}${FlagIfPresent}`; type FlagTextFromUnion = `${Extract extends never ? "" : "d"}${Extract extends never ? "" : "g"}${Extract extends never ? "" : "i"}${Extract extends never ? "" : "m"}${Extract extends never ? "" : "s"}${Extract extends never ? "" : "u"}${Extract extends never ? "" : "v"}${Extract extends never ? "" : "y"}`; type FlagTextFromInput = Flags extends string ? NormalizeRegexFlags : Flags extends readonly Flag[] ? CanonicalFlags : Flags extends ReadonlySet ? FlagTextFromUnion : Flags extends Flag ? Flags : never; type FlagUnionFromInput = Flags extends string ? NormalizeRegexFlags extends infer FlagText extends string ? FlagText extends `${infer First}${infer Rest}` ? First | FlagUnionFromInput : never : never : Flags extends readonly Flag[] ? Flags[number] : Flags extends ReadonlySet ? FlagUnion : Flags extends Flag ? Flags : never; type WithFlags = R extends MagicRegExp<`/${infer Source}/`, infer Groups extends string, infer Captures extends (string | undefined)[], string> ? MagicRegExp<`/${Source}/${CanonicalFlags}`, Groups, Captures, Flags[number]> : never; type WithFlagInput = R extends MagicRegExp<`/${infer Source}/`, infer Groups extends string, infer Captures extends (string | undefined)[], string> ? MagicRegExp<`/${Source}/${FlagTextFromInput}`, Groups, Captures, FlagUnionFromInput> : never; type Anchored = R extends MagicRegExp<`/${infer Source}/`, infer Groups extends string, infer Captures extends (string | undefined)[], string> ? MagicRegExp<`/^${Source}$/`, Groups, Captures, never> : never; type DefineRegexOptions = { /** * Magic Regex-compatible inputs. Plain strings are escaped and Magic Regex * fragments keep their capture, group, and composition behavior. */ readonly inputs: Inputs; /** Alias for `inputs`; use one of `inputs` or `pattern`. */ readonly pattern?: never; /** * `contains` keeps Magic Regex's default search-style behavior. `exact` adds * start/end anchors at runtime and in the inferred type. */ readonly match?: Match; /** Native RegExp flags as Magic Regex helpers, an array/Set, or a flag string. */ readonly flags?: Flags; } | { /** Alias for `inputs` for teams that prefer domain wording. */ readonly pattern: Inputs; readonly inputs?: never; readonly match?: Match; readonly flags?: Flags; }; type DefineRegexBase = Options extends { readonly match: "exact"; } ? Anchored> : MagicFromInputs; type DefineRegexInputs = Options extends { readonly inputs: infer Inputs extends readonly MagicInput[]; } ? Inputs : Options extends { readonly pattern: infer Inputs extends readonly MagicInput[]; } ? Inputs : never; type DefineRegexMagic = DefineRegexInputs extends infer Inputs extends readonly MagicInput[] ? Options extends { readonly flags: infer Flags extends MagicFlagInput; } ? WithFlagInput, Flags> : DefineRegexBase : never; type WandManualContext = { flags?: ArkFlags; captures?: IndexedCaptures; names?: NamedCaptures; }; type EmptyManualContext = { flags?: never; captures?: never; names?: never; }; type WandRegExp> = ArkFromMagic & { /** The original Magic Regex value used to produce this adapter result. */ readonly magic: R; /** Alias to the ArkRegex-powered result for explicit interop. */ readonly ark: ArkFromMagic; /** Create a plain native `RegExp` with the same source and flags. */ toRegExp(): RegExp; }; /** * Adapt an existing Magic Regex value into a `WandRegExp`. * * Prefer `defineRegex` for new code. Use this when a project already has a * Magic Regex value and wants ArkRegex-powered types at the final compiled * boundary. */ declare function fromMagic>(magic: R): WandRegExp; /** * Adapt an existing Magic Regex value and manually provide ArkRegex result * types. * * This mirrors ArkRegex's `regex.as` escape hatch for expressions that are valid * at runtime but too complex or dynamic for type-level inference. */ declare function fromMagicAs = MagicRegExp>(magic: R): WandRegExp & Regex; /** * Compile a readable object-shaped regex definition. * * This is the recommended high-level API when you want named options instead of * positional builder arguments. It uses the same Magic Regex construction and * ArkRegex-powered adapter as the lower-level helpers. */ declare function defineRegex(options: Options): WandRegExp>; /** * Compile Magic Regex inputs into an ArkRegex-powered contains-style `RegExp`. * * This mirrors Magic Regex authoring: strings are escaped by Magic Regex, and * Magic Regex fragments keep their original composition behavior. */ declare function createRegExp(...inputs: Inputs): WandRegExp>; /** * Compile Magic Regex inputs with explicit flags. * * `inputs` is a tuple so the remaining parameters can stay reserved for Magic * Regex flag helpers while preserving literal flag order in the return type. */ declare function createRegExpWithFlags(inputs: Inputs, ...flags: Flags): WandRegExp, Flags>>; declare function createRegExpWithFlags(inputs: Inputs, flags: Flags): WandRegExp, Flags>>; /** * Compile Magic Regex inputs into an ArkRegex-powered exact-match `RegExp`. * * Use this when `test()` should narrow the tested string to the inferred pattern * type without surrounding `${string}`. */ declare function createExactRegExp(...inputs: Inputs): WandRegExp>>; /** * Compile Magic Regex inputs into an exact-match `RegExp` with explicit flags. */ declare function createExactRegExpWithFlags(inputs: Inputs, ...flags: Flags): WandRegExp>, Flags>>; declare function createExactRegExpWithFlags(inputs: Inputs, flags: Flags): WandRegExp>, Flags>>; export { type DefineRegexOptions, type MagicFlagInput, type MagicInput, type RegexMatchMode, type RegexParts, type WandCompatibilityError, type WandManualContext, type WandRegExp, createExactRegExp, createExactRegExpWithFlags, createRegExp, createRegExpWithFlags, defineRegex, fromMagic, fromMagicAs };