Astro+Directus(Visual-Editing)+Snipcart Test-Stack

node_modules/regex/dist/cjs/atomic.d.ts

@@ -0,0 +1,18 @@
+/**
+Apply transformations for atomic groups: `(?>…)`.
+@param {string} expression
+@param {PluginData} [data]
+@returns {Required<PluginResult>}
+*/
+export function atomic(expression: string, data?: PluginData): Required<PluginResult>;
+/**
+Transform posessive quantifiers into atomic groups. The posessessive quantifiers are:
+`?+`, `*+`, `++`, `{N}+`, `{N,}+`, `{N,N}+`.
+This follows Java, PCRE, Perl, and Python.
+Possessive quantifiers in Oniguruma and Onigmo are only: `?+`, `*+`, `++`.
+@param {string} expression
+@returns {PluginResult}
+*/
+export function possessive(expression: string): PluginResult;
+import type { PluginData } from './regex.js';
+import type { PluginResult } from './regex.js';

node_modules/regex/dist/cjs/backcompat.d.ts

@@ -0,0 +1,8 @@
+/**
+Applies flag v rules when using flag u, for forward compatibility.
+Assumes flag u and doesn't worry about syntax errors that are caught by it.
+@param {string} expression
+@returns {PluginResult}
+*/
+export function backcompatPlugin(expression: string): PluginResult;
+import type { PluginResult } from './regex.js';

node_modules/regex/dist/cjs/flag-n.d.ts

@@ -0,0 +1,4 @@
+export function flagNPreprocessor(value: import("./regex.js").InterpolatedValue, runningContext: import("./utils.js").RunningContext, options: Required<import("./regex.js").RegexTagOptions>): {
+    transformed: string;
+    runningContext: import("./utils.js").RunningContext;
+};

node_modules/regex/dist/cjs/flag-x.d.ts

@@ -0,0 +1,11 @@
+/**
+Remove `(?:)` token separators (most likely added by flag x) in cases where it's safe to do so.
+@param {string} expression
+@returns {PluginResult}
+*/
+export function clean(expression: string): PluginResult;
+export function flagXPreprocessor(value: import("./regex.js").InterpolatedValue, runningContext: import("./utils.js").RunningContext, options: Required<import("./regex.js").RegexTagOptions>): {
+    transformed: string;
+    runningContext: import("./utils.js").RunningContext;
+};
+import type { PluginResult } from './regex.js';

node_modules/regex/dist/cjs/internals.d.ts

@@ -0,0 +1,2 @@
+export { RegExpSubclass } from "./subclass.js";
+export { atomic, possessive } from "./atomic.js";

node_modules/regex/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

node_modules/regex/dist/cjs/pattern.d.ts

@@ -0,0 +1,43 @@
+export class Pattern {
+    /** @param {string} value */
+    constructor(value: string);
+    /** @returns {string} */
+    toString(): string;
+    #private;
+}
+/**
+Returns a value that can be interpolated into a `regex` template string without having its special
+characters escaped.
+
+Can be called as a function or template tag:
+- `pattern(value)` - String or value coerced to string.
+- `` pattern`…` `` - Same as ``pattern(String.raw`…`)``.
+
+@overload
+@param {string | number} value
+@returns {Pattern}
+
+@overload
+@param {TemplateStringsArray} template
+@param {...string} substitutions
+@returns {Pattern}
+*/
+export function pattern(value: string | number): Pattern;
+/**
+Returns a value that can be interpolated into a `regex` template string without having its special
+characters escaped.
+
+Can be called as a function or template tag:
+- `pattern(value)` - String or value coerced to string.
+- `` pattern`…` `` - Same as ``pattern(String.raw`…`)``.
+
+@overload
+@param {string | number} value
+@returns {Pattern}
+
+@overload
+@param {TemplateStringsArray} template
+@param {...string} substitutions
+@returns {Pattern}
+*/
+export function pattern(template: TemplateStringsArray, ...substitutions: string[]): Pattern;

node_modules/regex/dist/cjs/regex.d.ts

@@ -0,0 +1,111 @@
+export type InterpolatedValue = string | RegExp | Pattern | number;
+export type PluginData = {
+    flags?: string;
+    captureTransfers?: Map<number, Array<number>>;
+    hiddenCaptures?: Array<number>;
+};
+export type PluginResult = {
+    pattern: string;
+    captureTransfers?: Map<number, Array<number>>;
+    hiddenCaptures?: Array<number>;
+};
+export type RawTemplate = TemplateStringsArray | {
+    raw: Array<string>;
+};
+export type RegexTagOptions = {
+    flags?: string;
+    subclass?: boolean;
+    plugins?: Array<(expression: string, data: PluginData) => PluginResult>;
+    unicodeSetsPlugin?: ((expression: string, data: PluginData) => PluginResult) | null;
+    disable?: {
+        x?: boolean;
+        n?: boolean;
+        v?: boolean;
+        atomic?: boolean;
+        subroutines?: boolean;
+    };
+    force?: {
+        v?: boolean;
+    };
+};
+export type RegexTag<T> = {
+    (template: RawTemplate, ...substitutions: ReadonlyArray<InterpolatedValue>): T;
+    (flags?: string): RegexTag<T>;
+    (options: RegexTagOptions & {
+        subclass?: false;
+    }): RegexTag<T>;
+    (options: RegexTagOptions & {
+        subclass: true;
+    }): RegexTag<RegExpSubclass>;
+};
+export type RegexFromTemplate<T> = {
+    (options: RegexTagOptions, template: RawTemplate, ...substitutions: ReadonlyArray<InterpolatedValue>): T;
+};
+import { pattern } from './pattern.js';
+/**
+@typedef {string | RegExp | Pattern | number} InterpolatedValue
+@typedef {{
+  flags?: string;
+  captureTransfers?: Map<number, Array<number>>;
+  hiddenCaptures?: Array<number>;
+}} PluginData
+@typedef {{
+  pattern: string;
+  captureTransfers?: Map<number, Array<number>>;
+  hiddenCaptures?: Array<number>;
+}} PluginResult
+@typedef {TemplateStringsArray | {raw: Array<string>}} RawTemplate
+@typedef {{
+  flags?: string;
+  subclass?: boolean;
+  plugins?: Array<(expression: string, data: PluginData) => PluginResult>;
+  unicodeSetsPlugin?: ((expression: string, data: PluginData) => PluginResult) | null;
+  disable?: {
+    x?: boolean;
+    n?: boolean;
+    v?: boolean;
+    atomic?: boolean;
+    subroutines?: boolean;
+  };
+  force?: {
+    v?: boolean;
+  };
+}} RegexTagOptions
+*/
+/**
+@template T
+@typedef RegexTag
+@type {{
+  (template: RawTemplate, ...substitutions: ReadonlyArray<InterpolatedValue>): T;
+  (flags?: string): RegexTag<T>;
+  (options: RegexTagOptions & {subclass?: false}): RegexTag<T>;
+  (options: RegexTagOptions & {subclass: true}): RegexTag<RegExpSubclass>;
+}}
+*/
+/**
+Template tag for constructing a regex with extended syntax and context-aware interpolation of
+regexes, strings, and patterns.
+
+Can be called in several ways:
+1. `` regex`…` `` - Regex pattern as a raw string.
+2. `` regex('gi')`…` `` - To specify flags.
+3. `` regex({flags: 'gi'})`…` `` - With options.
+@type {RegexTag<RegExp>}
+*/
+export const regex: RegexTag<RegExp>;
+/**
+Returns the processed expression and flags as strings.
+@param {string} expression
+@param {RegexTagOptions} [options]
+@returns {{
+  pattern: string;
+  flags: string;
+}}
+*/
+export function rewrite(expression?: string, options?: RegexTagOptions): {
+    pattern: string;
+    flags: string;
+};
+import { Pattern } from './pattern.js';
+import { RegExpSubclass } from './subclass.js';
+export { pattern };

node_modules/regex/dist/cjs/regex.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/regex.js", "../../src/utils-internals.js", "../../node_modules/.pnpm/regex-utilities@2.3.0/node_modules/regex-utilities/src/index.js", "../../src/atomic.js", "../../src/pattern.js", "../../src/utils.js", "../../src/backcompat.js", "../../src/flag-n.js", "../../src/flag-x.js", "../../src/subclass.js", "../../src/subroutines.js"],
+  "sourcesContent": ["import {atomic, possessive} from './atomic.js';\nimport {backcompatPlugin} from './backcompat.js';\nimport {flagNPreprocessor} from './flag-n.js';\nimport {clean, flagXPreprocessor} from './flag-x.js';\nimport {Pattern, pattern} from './pattern.js';\nimport {RegExpSubclass} from './subclass.js';\nimport {subroutines} from './subroutines.js';\nimport {adjustNumberedBackrefs, CharClassContext, containsCharClassUnion, countCaptures, enclosedTokenCharClassContexts, enclosedTokenRegexContexts, envSupportsFlagGroups, envSupportsFlagV, escapeV, getBreakoutChar, getEndContextForIncompleteExpression, preprocess, RegexContext, sandboxLoneCharClassCaret, sandboxLoneDoublePunctuatorChar, sandboxUnsafeNulls} from './utils.js';\nimport {Context, hasUnescaped, replaceUnescaped} from 'regex-utilities';\n\n/**\n@typedef {string | RegExp | Pattern | number} InterpolatedValue\n@typedef {{\n  flags?: string;\n  captureTransfers?: Map<number, Array<number>>;\n  hiddenCaptures?: Array<number>;\n}} PluginData\n@typedef {{\n  pattern: string;\n  captureTransfers?: Map<number, Array<number>>;\n  hiddenCaptures?: Array<number>;\n}} PluginResult\n@typedef {TemplateStringsArray | {raw: Array<string>}} RawTemplate\n@typedef {{\n  flags?: string;\n  subclass?: boolean;\n  plugins?: Array<(expression: string, data: PluginData) => PluginResult>;\n  unicodeSetsPlugin?: ((expression: string, data: PluginData) => PluginResult) | null;\n  disable?: {\n    x?: boolean;\n    n?: boolean;\n    v?: boolean;\n    atomic?: boolean;\n    subroutines?: boolean;\n  };\n  force?: {\n    v?: boolean;\n  };\n}} RegexTagOptions\n*/\n/**\n@template T\n@typedef RegexTag\n@type {{\n  (template: RawTemplate, ...substitutions: ReadonlyArray<InterpolatedValue>): T;\n  (flags?: string): RegexTag<T>;\n  (options: RegexTagOptions & {subclass?: false}): RegexTag<T>;\n  (options: RegexTagOptions & {subclass: true}): RegexTag<RegExpSubclass>;\n}}\n*/\n/**\nTemplate tag for constructing a regex with extended syntax and context-aware interpolation of\nregexes, strings, and patterns.\n\nCan be called in several ways:\n1. `` regex`\u2026` `` - Regex pattern as a raw string.\n2. `` regex('gi')`\u2026` `` - To specify flags.\n3. `` regex({flags: 'gi'})`\u2026` `` - With options.\n@type {RegexTag<RegExp>}\n*/\nconst regex = (first, ...substitutions) => {\n  // Given a template\n  if (Array.isArray(first?.raw)) {\n    return regexFromTemplate({}, first, ...substitutions);\n  // Given flags\n  } else if ((typeof first === 'string' || first === undefined) && !substitutions.length) {\n    return regexFromTemplate.bind(null, {flags: first ?? ''});\n  // Given an options object\n  } else if ({}.toString.call(first) === '[object Object]' && !substitutions.length) {\n    return regexFromTemplate.bind(null, first);\n  }\n  throw new Error(`Unexpected arguments: ${JSON.stringify([first, ...substitutions])}`);\n};\n\n/**\n@template T\n@typedef RegexFromTemplate\n@type {{\n  (options: RegexTagOptions, template: RawTemplate, ...substitutions: ReadonlyArray<InterpolatedValue>) : T;\n}}\n*/\n/**\nReturns a RegExp from a template and substitutions to fill the template holes.\n@type {RegexFromTemplate<RegExp>}\n*/\nconst regexFromTemplate = (options, template, ...substitutions) => {\n  const opts = getOptions(options);\n  const prepped = runPreprocessors(template, substitutions, opts);\n\n  let precedingCaptures = 0;\n  let expression = '';\n  let runningContext;\n  // Intersperse raw template strings and substitutions\n  prepped.template.raw.forEach((raw, i) => {\n    const hasNonEmptyRawBoundary = !!(prepped.template.raw[i] || prepped.template.raw[i + 1]);\n    // Even with flag n enabled, we might have named captures\n    precedingCaptures += countCaptures(raw);\n    // Sandbox `\\0` in character classes. Not needed outside character classes because in other\n    // cases a following interpolated value would always be atomized\n    expression += sandboxUnsafeNulls(raw, Context.CHAR_CLASS);\n    runningContext = getEndContextForIncompleteExpression(expression, runningContext);\n    const {regexContext, charClassContext} = runningContext;\n    if (i < prepped.template.raw.length - 1) {\n      const substitution = prepped.substitutions[i];\n      expression += interpolate(\n        substitution,\n        opts.flags,\n        regexContext,\n        charClassContext,\n        hasNonEmptyRawBoundary,\n        precedingCaptures\n      );\n      if (substitution instanceof RegExp) {\n        precedingCaptures += countCaptures(substitution.source);\n      } else if (substitution instanceof Pattern) {\n        precedingCaptures += countCaptures(String(substitution));\n      }\n    }\n  });\n\n  const plugged = runPlugins(expression, opts);\n  expression = plugged.pattern;\n  try {\n    return opts.subclass ?\n      new RegExpSubclass(expression, opts.flags, {hiddenCaptures: plugged.hiddenCaptures}) :\n      new RegExp(expression, opts.flags);\n  } catch (err) {\n    // ImproLine truncated
+  "mappings": "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 truncated
+  "names": ["token", "result", "token", "token", "options", "token"]
+}

node_modules/regex/dist/cjs/subclass.d.ts

@@ -0,0 +1,31 @@
+/**
+Works the same as JavaScript's native `RegExp` constructor in all contexts, but automatically
+adjusts subpattern matches and indices (with flag `d`) to account for captures added as part of
+emulating extended syntax.
+*/
+export class RegExpSubclass extends RegExp {
+    /**
+     @overload
+     @param {string} expression
+     @param {string} [flags]
+     @param {{
+     hiddenCaptures?: Array<number>;
+     }} [options]
+     */
+    constructor(expression: string, flags?: string, options?: {
+        hiddenCaptures?: Array<number>;
+    });
+    /**
+     @overload
+     @param {RegExpSubclass} expression
+     @param {string} [flags]
+     */
+    constructor(expression: RegExpSubclass, flags?: string);
+    /**
+    @private
+    @type {Map<number, {
+      hidden: true;
+    }>}
+    */
+    private _captureMap;
+}

node_modules/regex/dist/cjs/subroutines.d.ts

@@ -0,0 +1,17 @@
+export type NamedCapturingGroupsMap = Map<string, {
+    isUnique: boolean;
+    contents?: string;
+    groupNum?: number;
+    numCaptures?: number;
+}>;
+/**
+@import {PluginData, PluginResult} from './regex.js';
+*/
+/**
+@param {string} expression
+@param {PluginData} [data]
+@returns {PluginResult}
+*/
+export function subroutines(expression: string, data?: PluginData): PluginResult;
+import type { PluginData } from './regex.js';
+import type { PluginResult } from './regex.js';

node_modules/regex/dist/cjs/utils-internals.d.ts

@@ -0,0 +1,15 @@
+/**
+Updates the array in place by incrementing each value greater than or equal to the threshold.
+@param {Array<number>} arr
+@param {number} threshold
+*/
+export function incrementIfAtLeast(arr: Array<number>, threshold: number): void;
+export const noncapturingDelim: any;
+/**
+@param {string} str
+@param {number} pos
+@param {string} oldValue
+@param {string} newValue
+@returns {string}
+*/
+export function spliceStr(str: string, pos: number, oldValue: string, newValue: string): string;

node_modules/regex/dist/cjs/utils.d.ts

@@ -0,0 +1,115 @@
+export type RunningContext = {
+    regexContext: string;
+    charClassContext: string;
+    charClassDepth: number;
+    lastPos: number;
+};
+export type InterpolatedValue = InterpolatedValue;
+export type RawTemplate = RawTemplate;
+export type RegexTagOptions = RegexTagOptions;
+export type Preprocessor = (value: InterpolatedValue, runningContext: RunningContext, options: Required<RegexTagOptions>) => {
+    transformed: string;
+    runningContext: RunningContext;
+};
+/**
+@param {string} expression
+@param {number} precedingCaptures
+@returns {string}
+*/
+export function adjustNumberedBackrefs(expression: string, precedingCaptures: number): string;
+export const capturingDelim: any;
+export namespace CharClassContext {
+    let DEFAULT: string;
+    let ENCLOSED_P: string;
+    let ENCLOSED_Q: string;
+    let ENCLOSED_U: string;
+    let INVALID_INCOMPLETE_TOKEN: string;
+    let RANGE: string;
+}
+export function containsCharClassUnion(charClassPattern: any): boolean;
+/**
+@param {string} expression
+@returns {number}
+*/
+export function countCaptures(expression: string): number;
+export const doublePunctuatorChars: "&!#$%*+,.:;<=>?@^`~";
+export const enclosedTokenCharClassContexts: any;
+export const enclosedTokenRegexContexts: any;
+export const envSupportsFlagGroups: boolean;
+export const envSupportsFlagV: boolean;
+/**
+Escape special characters for the given context, assuming flag v.
+@param {string} str String to escape
+@param {'DEFAULT' | 'CHAR_CLASS'} context `Context` option from lib `regex-utilities`
+@returns {string} Escaped string
+*/
+export function escapeV(str: string, context: "DEFAULT" | "CHAR_CLASS"): string;
+export function getBreakoutChar(expression: any, regexContext: any, charClassContext: any): any;
+/**
+@typedef {{
+  regexContext: string;
+  charClassContext: string;
+  charClassDepth: number;
+  lastPos: number;
+}} RunningContext
+*/
+/**
+Accepts and returns its full state so it doesn't have to reprocess parts that have already been
+seen. Assumes flag v and doesn't worry about syntax errors that are caught by it.
+@param {string} incompleteExpression
+@param {Partial<RunningContext>} [runningContext]
+@returns {RunningContext}
+*/
+export function getEndContextForIncompleteExpression(incompleteExpression: string, runningContext?: Partial<RunningContext>): RunningContext;
+export const namedCapturingDelim: any;
+/**
+@typedef {InterpolatedValue} InterpolatedValue
+@typedef {RawTemplate} RawTemplate
+@typedef {RegexTagOptions} RegexTagOptions
+@typedef {(
+  value: InterpolatedValue,
+  runningContext: RunningContext,
+  options: Required<RegexTagOptions>
+) => {
+  transformed: string;
+  runningContext: RunningContext;
+}} Preprocessor
+*/
+/**
+Returns transformed versions of a template and substitutions, using the given preprocessor. Only
+processes substitutions that are instanceof `Pattern`.
+@param {RawTemplate} template
+@param {ReadonlyArray<InterpolatedValue>} substitutions
+@param {Preprocessor} preprocessor
+@param {Required<RegexTagOptions>} options
+@returns {{template: RawTemplate; substitutions: ReadonlyArray<InterpolatedValue>;}}
+*/
+export function preprocess(template: RawTemplate, substitutions: ReadonlyArray<InterpolatedValue>, preprocessor: Preprocessor, options: Required<RegexTagOptions>): {
+    template: RawTemplate;
+    substitutions: ReadonlyArray<InterpolatedValue>;
+};
+export namespace RegexContext {
+    let DEFAULT_1: string;
+    export { DEFAULT_1 as DEFAULT };
+    export let CHAR_CLASS: string;
+    let ENCLOSED_P_1: string;
+    export { ENCLOSED_P_1 as ENCLOSED_P };
+    let ENCLOSED_U_1: string;
+    export { ENCLOSED_U_1 as ENCLOSED_U };
+    export let GROUP_NAME: string;
+    export let INTERVAL_QUANTIFIER: string;
+    let INVALID_INCOMPLETE_TOKEN_1: string;
+    export { INVALID_INCOMPLETE_TOKEN_1 as INVALID_INCOMPLETE_TOKEN };
+}
+export function sandboxLoneCharClassCaret(str: any): any;
+export function sandboxLoneDoublePunctuatorChar(str: any): any;
+/**
+Converts `\0` tokens to `\x00` in the given context.
+@param {string} str
+@param {'DEFAULT' | 'CHAR_CLASS'} [context] `Context` option from lib `regex-utilities`
+@returns {string}
+*/
+export function sandboxUnsafeNulls(str: string, context?: "DEFAULT" | "CHAR_CLASS"): string;
+import type { InterpolatedValue } from './regex.js';
+import type { RawTemplate } from './regex.js';
+import type { RegexTagOptions } from './regex.js';

node_modules/regex/dist/esm/atomic.d.ts

@@ -0,0 +1,18 @@
+/**
+Apply transformations for atomic groups: `(?>…)`.
+@param {string} expression
+@param {PluginData} [data]
+@returns {Required<PluginResult>}
+*/
+export function atomic(expression: string, data?: PluginData): Required<PluginResult>;
+/**
+Transform posessive quantifiers into atomic groups. The posessessive quantifiers are:
+`?+`, `*+`, `++`, `{N}+`, `{N,}+`, `{N,N}+`.
+This follows Java, PCRE, Perl, and Python.
+Possessive quantifiers in Oniguruma and Onigmo are only: `?+`, `*+`, `++`.
+@param {string} expression
+@returns {PluginResult}
+*/
+export function possessive(expression: string): PluginResult;
+import type { PluginData } from './regex.js';
+import type { PluginResult } from './regex.js';

node_modules/regex/dist/esm/backcompat.d.ts

@@ -0,0 +1,8 @@
+/**
+Applies flag v rules when using flag u, for forward compatibility.
+Assumes flag u and doesn't worry about syntax errors that are caught by it.
+@param {string} expression
+@returns {PluginResult}
+*/
+export function backcompatPlugin(expression: string): PluginResult;
+import type { PluginResult } from './regex.js';

node_modules/regex/dist/esm/flag-n.d.ts

@@ -0,0 +1,4 @@
+export function flagNPreprocessor(value: import("./regex.js").InterpolatedValue, runningContext: import("./utils.js").RunningContext, options: Required<import("./regex.js").RegexTagOptions>): {
+    transformed: string;
+    runningContext: import("./utils.js").RunningContext;
+};

node_modules/regex/dist/esm/flag-x.d.ts

@@ -0,0 +1,11 @@
+/**
+Remove `(?:)` token separators (most likely added by flag x) in cases where it's safe to do so.
+@param {string} expression
+@returns {PluginResult}
+*/
+export function clean(expression: string): PluginResult;
+export function flagXPreprocessor(value: import("./regex.js").InterpolatedValue, runningContext: import("./utils.js").RunningContext, options: Required<import("./regex.js").RegexTagOptions>): {
+    transformed: string;
+    runningContext: import("./utils.js").RunningContext;
+};
+import type { PluginResult } from './regex.js';

node_modules/regex/dist/esm/internals.d.ts

@@ -0,0 +1,2 @@
+export { RegExpSubclass } from "./subclass.js";
+export { atomic, possessive } from "./atomic.js";

node_modules/regex/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

node_modules/regex/dist/esm/pattern.d.ts

@@ -0,0 +1,43 @@
+export class Pattern {
+    /** @param {string} value */
+    constructor(value: string);
+    /** @returns {string} */
+    toString(): string;
+    #private;
+}
+/**
+Returns a value that can be interpolated into a `regex` template string without having its special
+characters escaped.
+
+Can be called as a function or template tag:
+- `pattern(value)` - String or value coerced to string.
+- `` pattern`…` `` - Same as ``pattern(String.raw`…`)``.
+
+@overload
+@param {string | number} value
+@returns {Pattern}
+
+@overload
+@param {TemplateStringsArray} template
+@param {...string} substitutions
+@returns {Pattern}
+*/
+export function pattern(value: string | number): Pattern;
+/**
+Returns a value that can be interpolated into a `regex` template string without having its special
+characters escaped.
+
+Can be called as a function or template tag:
+- `pattern(value)` - String or value coerced to string.
+- `` pattern`…` `` - Same as ``pattern(String.raw`…`)``.
+
+@overload
+@param {string | number} value
+@returns {Pattern}
+
+@overload
+@param {TemplateStringsArray} template
+@param {...string} substitutions
+@returns {Pattern}
+*/
+export function pattern(template: TemplateStringsArray, ...substitutions: string[]): Pattern;

node_modules/regex/dist/esm/regex.d.ts

@@ -0,0 +1,111 @@
+export type InterpolatedValue = string | RegExp | Pattern | number;
+export type PluginData = {
+    flags?: string;
+    captureTransfers?: Map<number, Array<number>>;
+    hiddenCaptures?: Array<number>;
+};
+export type PluginResult = {
+    pattern: string;
+    captureTransfers?: Map<number, Array<number>>;
+    hiddenCaptures?: Array<number>;
+};
+export type RawTemplate = TemplateStringsArray | {
+    raw: Array<string>;
+};
+export type RegexTagOptions = {
+    flags?: string;
+    subclass?: boolean;
+    plugins?: Array<(expression: string, data: PluginData) => PluginResult>;
+    unicodeSetsPlugin?: ((expression: string, data: PluginData) => PluginResult) | null;
+    disable?: {
+        x?: boolean;
+        n?: boolean;
+        v?: boolean;
+        atomic?: boolean;
+        subroutines?: boolean;
+    };
+    force?: {
+        v?: boolean;
+    };
+};
+export type RegexTag<T> = {
+    (template: RawTemplate, ...substitutions: ReadonlyArray<InterpolatedValue>): T;
+    (flags?: string): RegexTag<T>;
+    (options: RegexTagOptions & {
+        subclass?: false;
+    }): RegexTag<T>;
+    (options: RegexTagOptions & {
+        subclass: true;
+    }): RegexTag<RegExpSubclass>;
+};
+export type RegexFromTemplate<T> = {
+    (options: RegexTagOptions, template: RawTemplate, ...substitutions: ReadonlyArray<InterpolatedValue>): T;
+};
+import { pattern } from './pattern.js';
+/**
+@typedef {string | RegExp | Pattern | number} InterpolatedValue
+@typedef {{
+  flags?: string;
+  captureTransfers?: Map<number, Array<number>>;
+  hiddenCaptures?: Array<number>;
+}} PluginData
+@typedef {{
+  pattern: string;
+  captureTransfers?: Map<number, Array<number>>;
+  hiddenCaptures?: Array<number>;
+}} PluginResult
+@typedef {TemplateStringsArray | {raw: Array<string>}} RawTemplate
+@typedef {{
+  flags?: string;
+  subclass?: boolean;
+  plugins?: Array<(expression: string, data: PluginData) => PluginResult>;
+  unicodeSetsPlugin?: ((expression: string, data: PluginData) => PluginResult) | null;
+  disable?: {
+    x?: boolean;
+    n?: boolean;
+    v?: boolean;
+    atomic?: boolean;
+    subroutines?: boolean;
+  };
+  force?: {
+    v?: boolean;
+  };
+}} RegexTagOptions
+*/
+/**
+@template T
+@typedef RegexTag
+@type {{
+  (template: RawTemplate, ...substitutions: ReadonlyArray<InterpolatedValue>): T;
+  (flags?: string): RegexTag<T>;
+  (options: RegexTagOptions & {subclass?: false}): RegexTag<T>;
+  (options: RegexTagOptions & {subclass: true}): RegexTag<RegExpSubclass>;
+}}
+*/
+/**
+Template tag for constructing a regex with extended syntax and context-aware interpolation of
+regexes, strings, and patterns.
+
+Can be called in several ways:
+1. `` regex`…` `` - Regex pattern as a raw string.
+2. `` regex('gi')`…` `` - To specify flags.
+3. `` regex({flags: 'gi'})`…` `` - With options.
+@type {RegexTag<RegExp>}
+*/
+export const regex: RegexTag<RegExp>;
+/**
+Returns the processed expression and flags as strings.
+@param {string} expression
+@param {RegexTagOptions} [options]
+@returns {{
+  pattern: string;
+  flags: string;
+}}
+*/
+export function rewrite(expression?: string, options?: RegexTagOptions): {
+    pattern: string;
+    flags: string;
+};
+import { Pattern } from './pattern.js';
+import { RegExpSubclass } from './subclass.js';
+export { pattern };

node_modules/regex/dist/esm/regex.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils-internals.js", "../../node_modules/.pnpm/regex-utilities@2.3.0/node_modules/regex-utilities/src/index.js", "../../src/atomic.js", "../../src/pattern.js", "../../src/utils.js", "../../src/backcompat.js", "../../src/flag-n.js", "../../src/flag-x.js", "../../src/subclass.js", "../../src/subroutines.js", "../../src/regex.js"],
+  "sourcesContent": ["// Separating some utils for improved tree shaking of the `./internals` export\n\nconst noncapturingDelim = String.raw`\\(\\?(?:[:=!>A-Za-z\\-]|<[=!]|\\(DEFINE\\))`;\n\n/**\nUpdates the array in place by incrementing each value greater than or equal to the threshold.\n@param {Array<number>} arr\n@param {number} threshold\n*/\nfunction incrementIfAtLeast(arr, threshold) {\n  for (let i = 0; i < arr.length; i++) {\n    if (arr[i] >= threshold) {\n      arr[i]++;\n    }\n  }\n}\n\n/**\n@param {string} str\n@param {number} pos\n@param {string} oldValue\n@param {string} newValue\n@returns {string}\n*/\nfunction spliceStr(str, pos, oldValue, newValue) {\n  return str.slice(0, pos) + newValue + str.slice(pos + oldValue.length);\n}\n\nexport {\n  incrementIfAtLeast,\n  noncapturingDelim,\n  spliceStr,\n};\n", "// Constant properties for tracking regex syntax context\nexport const Context = Object.freeze({\n  DEFAULT: 'DEFAULT',\n  CHAR_CLASS: 'CHAR_CLASS',\n});\n\n/**\nReplaces all unescaped instances of a regex pattern in the given context, using a replacement\nstring or callback.\n\nDoesn't skip over complete multicharacter tokens (only `\\` plus its folowing char) so must be used\nwith knowledge of what's safe to do given regex syntax. Assumes UnicodeSets-mode syntax.\n@param {string} expression Search target\n@param {string} needle Search as a regex pattern, with flags `su` applied\n@param {string | (match: RegExpExecArray, details: {\n  context: 'DEFAULT' | 'CHAR_CLASS';\n  negated: boolean;\n}) => string} replacement\n@param {'DEFAULT' | 'CHAR_CLASS'} [context] All contexts if not specified\n@returns {string} Updated expression\n@example\nconst str = '.\\\\.\\\\\\\\.[[\\\\.].].';\nreplaceUnescaped(str, '\\\\.', '@');\n// \u2192 '@\\\\.\\\\\\\\@[[\\\\.]@]@'\nreplaceUnescaped(str, '\\\\.', '@', Context.DEFAULT);\n// \u2192 '@\\\\.\\\\\\\\@[[\\\\.].]@'\nreplaceUnescaped(str, '\\\\.', '@', Context.CHAR_CLASS);\n// \u2192 '.\\\\.\\\\\\\\.[[\\\\.]@].'\n*/\nexport function replaceUnescaped(expression, needle, replacement, context) {\n  const re = new RegExp(String.raw`${needle}|(?<$skip>\\[\\^?|\\\\?.)`, 'gsu');\n  const negated = [false];\n  let numCharClassesOpen = 0;\n  let result = '';\n  for (const match of expression.matchAll(re)) {\n    const {0: m, groups: {$skip}} = match;\n    if (!$skip && (!context || (context === Context.DEFAULT) === !numCharClassesOpen)) {\n      if (replacement instanceof Function) {\n        result += replacement(match, {\n          context: numCharClassesOpen ? Context.CHAR_CLASS : Context.DEFAULT,\n          negated: negated[negated.length - 1],\n        });\n      } else {\n        result += replacement;\n      }\n      continue;\n    }\n    if (m[0] === '[') {\n      numCharClassesOpen++;\n      negated.push(m[1] === '^');\n    } else if (m === ']' && numCharClassesOpen) {\n      numCharClassesOpen--;\n      negated.pop();\n    }\n    result += m;\n  }\n  return result;\n}\n\n/**\nRuns a callback for each unescaped instance of a regex pattern in the given context.\n\nDoesn't skip over complete multicharacter tokens (only `\\` plus its folowing char) so must be used\nwith knowledge of what's safe to do given regex syntax. Assumes UnicodeSets-mode syntax.\n@param {string} expression Search target\n@param {string} needle Search as a regex pattern, with flags `su` applied\n@param {(match: RegExpExecArray, details: {\n  context: 'DEFAULT' | 'CHAR_CLASS';\n  negated: boolean;\n}) => void} callback\n@param {'DEFAULT' | 'CHAR_CLASS'} [context] All contexts if not specified\n*/\nexport function forEachUnescaped(expression, needle, callback, context) {\n  // Do this the easy way\n  replaceUnescaped(expression, needle, callback, context);\n}\n\n/**\nReturns a match object for the first unescaped instance of a regex pattern in the given context, or\n`null`.\n\nDoesn't skip over complete multicharacter tokens (only `\\` plus its folowing char) so must be used\nwith knowledge of what's safe to do given regex syntax. Assumes UnicodeSets-mode syntax.\n@param {string} expression Search target\n@param {string} needle Search as a regex pattern, with flags `su` applied\n@param {number} [pos] Offset to start the search\n@param {'DEFAULT' | 'CHAR_CLASS'} [context] All contexts if not specified\n@returns {RegExpExecArray | null}\n*/\nexport function execUnescaped(expression, needle, pos = 0, context) {\n  // Quick partial test; avoid the loop if not needed\n  if (!(new RegExp(needle, 'su').test(expression))) {\n    return null;\n  }\n  const re = new RegExp(`${needle}|(?<$skip>\\\\\\\\?.)`, 'gsu');\n  re.lastIndex = pos;\n  let numCharClassesOpen = 0;\n  let match;\n  while (match = re.exec(expression)) {\n    const {0: m, groups: {$skip}} = match;\n    if (!$skip && (!context || (context === Context.DEFAULT) === !numCharClassesOpen)) {\n      return match;\n    }\n    if (m === '[') {\n      numCharClassesOpen++;\n    } else if (m === ']' && numCharClassesOpen) {\n      numCharCLine truncated
+  "mappings": "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 truncated
+  "names": ["token", "result", "token", "token", "options", "token"]
+}

node_modules/regex/dist/esm/subclass.d.ts

@@ -0,0 +1,31 @@
+/**
+Works the same as JavaScript's native `RegExp` constructor in all contexts, but automatically
+adjusts subpattern matches and indices (with flag `d`) to account for captures added as part of
+emulating extended syntax.
+*/
+export class RegExpSubclass extends RegExp {
+    /**
+     @overload
+     @param {string} expression
+     @param {string} [flags]
+     @param {{
+     hiddenCaptures?: Array<number>;
+     }} [options]
+     */
+    constructor(expression: string, flags?: string, options?: {
+        hiddenCaptures?: Array<number>;
+    });
+    /**
+     @overload
+     @param {RegExpSubclass} expression
+     @param {string} [flags]
+     */
+    constructor(expression: RegExpSubclass, flags?: string);
+    /**
+    @private
+    @type {Map<number, {
+      hidden: true;
+    }>}
+    */
+    private _captureMap;
+}

node_modules/regex/dist/esm/subroutines.d.ts

@@ -0,0 +1,17 @@
+export type NamedCapturingGroupsMap = Map<string, {
+    isUnique: boolean;
+    contents?: string;
+    groupNum?: number;
+    numCaptures?: number;
+}>;
+/**
+@import {PluginData, PluginResult} from './regex.js';
+*/
+/**
+@param {string} expression
+@param {PluginData} [data]
+@returns {PluginResult}
+*/
+export function subroutines(expression: string, data?: PluginData): PluginResult;
+import type { PluginData } from './regex.js';
+import type { PluginResult } from './regex.js';

node_modules/regex/dist/esm/utils-internals.d.ts

@@ -0,0 +1,15 @@
+/**
+Updates the array in place by incrementing each value greater than or equal to the threshold.
+@param {Array<number>} arr
+@param {number} threshold
+*/
+export function incrementIfAtLeast(arr: Array<number>, threshold: number): void;
+export const noncapturingDelim: any;
+/**
+@param {string} str
+@param {number} pos
+@param {string} oldValue
+@param {string} newValue
+@returns {string}
+*/
+export function spliceStr(str: string, pos: number, oldValue: string, newValue: string): string;

node_modules/regex/dist/esm/utils.d.ts

@@ -0,0 +1,115 @@
+export type RunningContext = {
+    regexContext: string;
+    charClassContext: string;
+    charClassDepth: number;
+    lastPos: number;
+};
+export type InterpolatedValue = InterpolatedValue;
+export type RawTemplate = RawTemplate;
+export type RegexTagOptions = RegexTagOptions;
+export type Preprocessor = (value: InterpolatedValue, runningContext: RunningContext, options: Required<RegexTagOptions>) => {
+    transformed: string;
+    runningContext: RunningContext;
+};
+/**
+@param {string} expression
+@param {number} precedingCaptures
+@returns {string}
+*/
+export function adjustNumberedBackrefs(expression: string, precedingCaptures: number): string;
+export const capturingDelim: any;
+export namespace CharClassContext {
+    let DEFAULT: string;
+    let ENCLOSED_P: string;
+    let ENCLOSED_Q: string;
+    let ENCLOSED_U: string;
+    let INVALID_INCOMPLETE_TOKEN: string;
+    let RANGE: string;
+}
+export function containsCharClassUnion(charClassPattern: any): boolean;
+/**
+@param {string} expression
+@returns {number}
+*/
+export function countCaptures(expression: string): number;
+export const doublePunctuatorChars: "&!#$%*+,.:;<=>?@^`~";
+export const enclosedTokenCharClassContexts: any;
+export const enclosedTokenRegexContexts: any;
+export const envSupportsFlagGroups: boolean;
+export const envSupportsFlagV: boolean;
+/**
+Escape special characters for the given context, assuming flag v.
+@param {string} str String to escape
+@param {'DEFAULT' | 'CHAR_CLASS'} context `Context` option from lib `regex-utilities`
+@returns {string} Escaped string
+*/
+export function escapeV(str: string, context: "DEFAULT" | "CHAR_CLASS"): string;
+export function getBreakoutChar(expression: any, regexContext: any, charClassContext: any): any;
+/**
+@typedef {{
+  regexContext: string;
+  charClassContext: string;
+  charClassDepth: number;
+  lastPos: number;
+}} RunningContext
+*/
+/**
+Accepts and returns its full state so it doesn't have to reprocess parts that have already been
+seen. Assumes flag v and doesn't worry about syntax errors that are caught by it.
+@param {string} incompleteExpression
+@param {Partial<RunningContext>} [runningContext]
+@returns {RunningContext}
+*/
+export function getEndContextForIncompleteExpression(incompleteExpression: string, runningContext?: Partial<RunningContext>): RunningContext;
+export const namedCapturingDelim: any;
+/**
+@typedef {InterpolatedValue} InterpolatedValue
+@typedef {RawTemplate} RawTemplate
+@typedef {RegexTagOptions} RegexTagOptions
+@typedef {(
+  value: InterpolatedValue,
+  runningContext: RunningContext,
+  options: Required<RegexTagOptions>
+) => {
+  transformed: string;
+  runningContext: RunningContext;
+}} Preprocessor
+*/
+/**
+Returns transformed versions of a template and substitutions, using the given preprocessor. Only
+processes substitutions that are instanceof `Pattern`.
+@param {RawTemplate} template
+@param {ReadonlyArray<InterpolatedValue>} substitutions
+@param {Preprocessor} preprocessor
+@param {Required<RegexTagOptions>} options
+@returns {{template: RawTemplate; substitutions: ReadonlyArray<InterpolatedValue>;}}
+*/
+export function preprocess(template: RawTemplate, substitutions: ReadonlyArray<InterpolatedValue>, preprocessor: Preprocessor, options: Required<RegexTagOptions>): {
+    template: RawTemplate;
+    substitutions: ReadonlyArray<InterpolatedValue>;
+};
+export namespace RegexContext {
+    let DEFAULT_1: string;
+    export { DEFAULT_1 as DEFAULT };
+    export let CHAR_CLASS: string;
+    let ENCLOSED_P_1: string;
+    export { ENCLOSED_P_1 as ENCLOSED_P };
+    let ENCLOSED_U_1: string;
+    export { ENCLOSED_U_1 as ENCLOSED_U };
+    export let GROUP_NAME: string;
+    export let INTERVAL_QUANTIFIER: string;
+    let INVALID_INCOMPLETE_TOKEN_1: string;
+    export { INVALID_INCOMPLETE_TOKEN_1 as INVALID_INCOMPLETE_TOKEN };
+}
+export function sandboxLoneCharClassCaret(str: any): any;
+export function sandboxLoneDoublePunctuatorChar(str: any): any;
+/**
+Converts `\0` tokens to `\x00` in the given context.
+@param {string} str
+@param {'DEFAULT' | 'CHAR_CLASS'} [context] `Context` option from lib `regex-utilities`
+@returns {string}
+*/
+export function sandboxUnsafeNulls(str: string, context?: "DEFAULT" | "CHAR_CLASS"): string;
+import type { InterpolatedValue } from './regex.js';
+import type { RawTemplate } from './regex.js';
+import type { RegexTagOptions } from './regex.js';

node_modules/regex/dist/regex.min.js

@@ -0,0 +1,76 @@
+var Regex=(()=>{var Z=Object.defineProperty;var Ue=Object.getOwnPropertyDescriptor;var be=Object.getOwnPropertyNames;var Fe=Object.prototype.hasOwnProperty;var Re=(e,n)=>{for(var t in n)Z(e,t,{get:n[t],enumerable:!0})},xe=(e,n,t,r)=>{if(n&&typeof n=="object"||typeof n=="function")for(let s of be(n))!Fe.call(e,s)&&s!==t&&Z(e,s,{get:()=>n[s],enumerable:!(r=Ue(n,s))||r.enumerable});return e};var Oe=e=>xe(Z({},"__esModule",{value:!0}),e);var Ye={};Re(Ye,{pattern:()=>Q,regex:()=>Ke,rewrite:()=>Ze});var U=String.raw`\(\?(?:[:=!>A-Za-z\-]|<[=!]|\(DEFINE\))`;function V(e,n){for(let t=0;t<e.length;t++)e[t]>=n&&e[t]++}function b(e,n,t,r){return e.slice(0,n)+r+e.slice(n+t.length)}var g=Object.freeze({DEFAULT:"DEFAULT",CHAR_CLASS:"CHAR_CLASS"});function N(e,n,t,r){let s=new RegExp(String.raw`${n}|(?<$skip>\[\^?|\\?.)`,"gsu"),a=[!1],i=0,o="";for(let l of e.matchAll(s)){let{0:c,groups:{$skip:f}}=l;if(!f&&(!r||r===g.DEFAULT==!i)){t instanceof Function?o+=t(l,{context:i?g.CHAR_CLASS:g.DEFAULT,negated:a[a.length-1]}):o+=t;continue}c[0]==="["?(i++,a.push(c[1]==="^")):c==="]"&&i&&(i--,a.pop()),o+=c}return o}function k(e,n,t,r){N(e,n,t,r)}function H(e,n,t=0,r){if(!new RegExp(n,"su").test(e))return null;let s=new RegExp(`${n}|(?<$skip>\\\\?.)`,"gsu");s.lastIndex=t;let a=0,i;for(;i=s.exec(e);){let{0:o,groups:{$skip:l}}=i;if(!l&&(!r||r===g.DEFAULT==!a))return i;o==="["?a++:o==="]"&&a&&a--,s.lastIndex==i.index&&s.lastIndex++}return null}function j(e,n,t){return!!H(e,n,0,t)}function J(e,n){let t=/\\?./gsu;t.lastIndex=n;let r=e.length,s=0,a=1,i;for(;i=t.exec(e);){let[o]=i;if(o==="[")s++;else if(s)o==="]"&&s--;else if(o==="(")a++;else if(o===")"&&(a--,!a)){r=i.index;break}}return e.slice(n,r)}var oe=new RegExp(String.raw`(?<noncapturingStart>${U})|(?<capturingStart>\((?:\?<[^>]+>)?)|\\?.`,"gsu");function ae(e,n){let t=n?.hiddenCaptures??[],r=n?.captureTransfers??new Map;if(!/\(\?>/.test(e))return{pattern:e,captureTransfers:r,hiddenCaptures:t};let s="(?>",a="(?:(?=(",i=[0],o=[],l=0,c=0,f=NaN,m;do{m=!1;let u=0,C=0,h=!1,d;for(oe.lastIndex=Number.isNaN(f)?0:f+a.length;d=oe.exec(e);){let{0:S,index:w,groups:{capturingStart:O,noncapturingStart:T}}=d;if(S==="[")u++;else if(u)S==="]"&&u--;else if(S===s&&!h)f=w,h=!0;else if(h&&T)C++;else if(O)h?C++:(l++,i.push(l+c));else if(S===")"&&h){if(!C){c++;let $=l+c;if(e=`${e.slice(0,f)}${a}${e.slice(f+s.length,w)}))<$$${$}>)${e.slice(w+1)}`,m=!0,o.push($),V(t,$),r.size){let A=new Map;r.forEach((D,L)=>{A.set(L>=$?L+1:L,D.map(I=>I>=$?I+1:I))}),r=A}break}C--}}}while(m);return t.push(...o),e=N(e,String.raw`\\(?<backrefNum>[1-9]\d*)|<\$\$(?<wrappedBackrefNum>\d+)>`,({0:u,groups:{backrefNum:C,wrappedBackrefNum:h}})=>{if(C){let d=+C;if(d>i.length-1)throw new Error(`Backref "${u}" greater than number of captures`);return`\\${i[d]}`}return`\\${h}`},g.DEFAULT),{pattern:e,captureTransfers:r,hiddenCaptures:t}}var ie=String.raw`(?:[?*+]|\{\d+(?:,\d*)?\})`,X=new RegExp(String.raw`
+\\(?: \d+
+  | c[A-Za-z]
+  | [gk]<[^>]+>
+  | [pPu]\{[^\}]+\}
+  | u[A-Fa-f\d]{4}
+  | x[A-Fa-f\d]{2}
+  )
+| \((?: \? (?: [:=!>]
+  | <(?:[=!]|[^>]+>)
+  | [A-Za-z\-]+:
+  | \(DEFINE\)
+  ))?
+| (?<qBase>${ie})(?<qMod>[?+]?)(?<invalidQ>[?*+\{]?)
+| \\?.
+`.replace(/\s+/g,""),"gsu");function ue(e){if(!new RegExp(`${ie}\\+`).test(e))return{pattern:e};let n=[],t=null,r=null,s="",a=0,i;for(X.lastIndex=0;i=X.exec(e);){let{0:o,index:l,groups:{qBase:c,qMod:f,invalidQ:m}}=i;if(o==="[")a||(r=l),a++;else if(o==="]")a?a--:r=null;else if(!a)if(f==="+"&&s&&!s.startsWith("(")){if(m)throw new Error(`Invalid quantifier "${o}"`);let u=-1;if(/^\{\d+\}$/.test(c))e=b(e,l+c.length,f,"");else{if(s===")"||s==="]"){let C=s===")"?t:r;if(C===null)throw new Error(`Invalid unmatched "${s}"`);e=`${e.slice(0,C)}(?>${e.slice(C,l)}${c})${e.slice(l+o.length)}`}else e=`${e.slice(0,l-s.length)}(?>${s}${c})${e.slice(l+o.length)}`;u+=4}X.lastIndex+=u}else o[0]==="("?n.push(l):o===")"&&(t=n.length?n.pop():null);s=o}return{pattern:e}}var _=class{#e;constructor(n){this.#e=n}toString(){return String(this.#e)}};function Q(e,...n){if(Array.isArray(e?.raw))return new _(e.raw.flatMap((t,r)=>r<e.raw.length-1?[t,n[r]]:t).join(""));if(!n.length)return new _(e===void 0?"":e);throw new Error(`Unexpected arguments: ${JSON.stringify([e,...n])}`)}var p={DEFAULT:"DEFAULT",CHAR_CLASS:"CHAR_CLASS",ENCLOSED_P:"ENCLOSED_P",ENCLOSED_U:"ENCLOSED_U",GROUP_NAME:"GROUP_NAME",INTERVAL_QUANTIFIER:"INTERVAL_QUANTIFIER",INVALID_INCOMPLETE_TOKEN:"INVALID_INCOMPLETE_TOKEN"},E={DEFAULT:"DEFAULT",ENCLOSED_P:"ENCLOSED_P",ENCLOSED_Q:"ENCLOSED_Q",ENCLOSED_U:"ENCLOSED_U",INVALID_INCOMPLETE_TOKEN:"INVALID_INCOMPLETE_TOKEN",RANGE:"RANGE"},q=new Set([p.ENCLOSED_P,p.ENCLOSED_U]),G=new Set([E.ENCLOSED_P,E.ENCLOSED_Q,E.ENCLOSED_U]),M=(()=>{try{new RegExp("(?i:)")}catch{return!1}return!0})(),fe=(()=>{try{new RegExp("","v")}catch{return!1}return!0})(),F="&!#$%*+,.:;<=>?@^`~",W=String.raw`\(\?<(?![=!])(?<captureName>[^>]+)>`,B=String.raw`\((?!\?)(?!(?<=\(\?\()DEFINE\))|${W}`;function pe(e,n){return N(e,String.raw`\\(?<num>[1-9]\d*)`,({groups:{num:t}})=>`\\${+t+n}`,g.DEFAULT)}var Pe=["Basic_Emoji","Emoji_Keycap_Sequence","RGI_Emoji_Modifier_Sequence","RGI_Emoji_Flag_Sequence","RGI_Emoji_Tag_Sequence","RGI_Emoji_ZWJ_Sequence","RGI_Emoji"].join("|"),ke=new RegExp(String.raw`
+\\(?: c[A-Za-z]
+  | p\{(?<pStrProp>${Pe})\}
+  | [pP]\{[^\}]+\}
+  | (?<qStrProp>q)
+  | u(?:[A-Fa-f\d]{4}|\{[A-Fa-f\d]+\})
+  | x[A-Fa-f\d]{2}
+  | .
+)
+| --
+| &&
+| .
+`.replace(/\s+/g,""),"gsu");function Y(e){let n=!1,t;for(let{0:r,groups:s}of e.matchAll(ke)){if(s.pStrProp||s.qStrProp||r==="["&&n)return!0;if(["-","--","&&"].includes(r))n=!1;else if(r!=="["&&r!=="]"){if(n||t==="]")return!0;n=!0}t=r}return!1}function R(e){let n=0;return k(e,B,()=>n++,g.DEFAULT),n}function ee(e,n){return n===g.CHAR_CLASS?e.replace(new RegExp(String.raw`[()\[\]{}|\\/\-${F}]`,"g"),"\\$&"):e.replace(/[()\[\]{}|\\^$*+?.]/g,"\\$&")}function de(e,n,t){let r=e.replace(/\\./gsu,"");if(r.endsWith("\\"))return"\\";if(n===p.DEFAULT)return ce(r,"(",")");if(n===p.CHAR_CLASS&&!G.has(t))return ce(r,"[","]");if(n===p.INTERVAL_QUANTIFIER||q.has(n)||G.has(t)){if(r.includes("}"))return"}"}else if(n===p.GROUP_NAME&&r.includes(">"))return">";return""}var le=new RegExp(String.raw`
+(?<groupN>\(\?<(?![=!])|\\[gk]<)
+| (?<enclosedPU>\\[pPu]\{)
+| (?<enclosedQ>\\q\{)
+| (?<intervalQ>\{)
+| (?<incompleteT>\\(?: $
+  | c(?![A-Za-z])
+  | u(?![A-Fa-f\d]{4})[A-Fa-f\d]{0,3}
+  | x(?![A-Fa-f\d]{2})[A-Fa-f\d]?
+  )
+)
+| --
+| \\?.
+`.replace(/\s+/g,""),"gsu");function x(e,n){let{regexContext:t,charClassContext:r,charClassDepth:s,lastPos:a}={regexContext:p.DEFAULT,charClassContext:E.DEFAULT,charClassDepth:0,lastPos:0,...n};le.lastIndex=a;let i;for(;i=le.exec(e);){let{0:o,groups:{groupN:l,enclosedPU:c,enclosedQ:f,intervalQ:m,incompleteT:u}}=i;o==="["?(s++,t=p.CHAR_CLASS,r=E.DEFAULT):o==="]"&&t===p.CHAR_CLASS?(s&&s--,s||(t=p.DEFAULT),r=E.DEFAULT):t===p.CHAR_CLASS?u?r=E.INVALID_INCOMPLETE_TOKEN:o==="-"?r=E.RANGE:c?r=o[1]==="u"?E.ENCLOSED_U:E.ENCLOSED_P:f?r=E.ENCLOSED_Q:(o==="}"&&G.has(r)||r===E.INVALID_INCOMPLETE_TOKEN||r===E.RANGE)&&(r=E.DEFAULT):u?t=p.INVALID_INCOMPLETE_TOKEN:l?t=p.GROUP_NAME:c?t=o[1]==="u"?p.ENCLOSED_U:p.ENCLOSED_P:m?t=p.INTERVAL_QUANTIFIER:(o===">"&&t===p.GROUP_NAME||o==="}"&&(t===p.INTERVAL_QUANTIFIER||q.has(t))||t===p.INVALID_INCOMPLETE_TOKEN)&&(t=p.DEFAULT)}return{regexContext:t,charClassContext:r,charClassDepth:s,lastPos:e.length}}function ce(e,n,t){let r=0;for(let[s]of e.matchAll(new RegExp(`[${ee(n+t,g.CHAR_CLASS)}]`,"g")))if(r+=s===n?1:-1,r<0)return t;return r>0?n:""}function ge(e,n,t,r){let s={raw:[]},a=[],i;return e.raw.forEach((o,l)=>{let c=t(o,{...i,lastPos:0},r);if(s.raw.push(c.transformed),i=c.runningContext,l<e.raw.length-1){let f=n[l];if(f instanceof _){let m=t(f,{...i,lastPos:0},r);a.push(Q(m.transformed)),i=m.runningContext}else a.push(f)}}),{template:s,substitutions:a}}function Ee(e){return e.replace(/^\^/,"\\^^")}function z(e){return e.replace(new RegExp(`^([${F}])(?!\\1)`),(n,t,r)=>`\\${n}${r+1===e.length?"":n}`)}function y(e,n){return N(e,String.raw`\\0(?!\d)`,"\\x00",n)}var Ge="&!#%,:;<=>@`~",Me=new RegExp(String.raw`
+\[\^?-?
+| --?\]
+| (?<dp>[${F}])\k<dp>
+| --
+| \\(?<vOnlyEscape>[${Ge}])
+| \\[pPu]\{[^}]+\}
+| \\?.
+`.replace(/\s+/g,""),"gsu");function he(e){let n='Invalid unescaped "-" in character class',t=!1,r="";for(let{0:s,groups:{dp:a,vOnlyEscape:i}}of e.matchAll(Me)){if(s[0]==="["){if(t)throw new Error("Invalid nested character class when flag v not supported; possibly from interpolation");if(s.endsWith("-"))throw new Error(n);t=!0}else if(s.endsWith("]")){if(s[0]==="-")throw new Error(n);t=!1}else if(t){if(s==="&&"||s==="--")throw new Error(`Invalid set operator "${s}" when flag v not supported`);if(a)throw new Error(`Invalid double punctuator "${s}", reserved by flag v`);if("(){}/|".includes(s))throw new Error(`Invalid unescaped "${s}" in character class`);if(i){r+=i;continue}}r+=s}return{pattern:r}}var ye=new RegExp(String.raw`
+${U}
+| \(\?<
+| (?<backrefNum>\\[1-9]\d*)
+| \\?.
+`.replace(/\s+/g,""),"gsu");function me(e,n){e=String(e);let t="",r="";for(let{0:s,groups:{backrefNum:a}}of e.matchAll(ye)){t+=s,n=x(t,n);let{regexContext:i}=n;if(i===p.DEFAULT)if(s==="(")r+="(?:";else{if(a)throw new Error(`Invalid decimal escape "${s}" with implicit flag n; replace with named backreference`);r+=s}else r+=s}return{transformed:r,runningContext:n}}var Ce=/^\s$/,ve=/^\\[\s#]$/,te=/^[ \t]$/,Ve=/^\\[ \t]$/,He=new RegExp(String.raw`
+\\(?: [gk]<
+  | [pPu]\{
+  | c[A-Za-z]
+  | u[A-Fa-f\d]{4}
+  | x[A-Fa-f\d]{2}
+  | 0\d+
+)
+| \[\^
+| ${U}
+| \(\?<
+| (?<dp>[${F}])\k<dp>
+| --
+| \\?.
+`.replace(/\s+/g,""),"gsu");function we(e,n,t){e=String(e);let r=!1,s=!1,a=!1,i="",o="",l="",c="",f=!1,m=(u,C)=>{let h={prefix:!0,postfix:!1,...C};return u=(f&&h.prefix?"(?:)":"")+u+(h.postfix?"(?:)":""),f=!1,u};for(let{0:u,index:C}of e.matchAll(He)){if(a){u===`
+`&&(a=!1,f=!0);continue}if(r){if(Ce.test(u))continue;r=!1,f=!0}else if(s){if(te.test(u))continue;s=!1}i+=u,n=x(i,n);let{regexContext:h,charClassContext:d}=n;if(u==="-"&&h===p.CHAR_CLASS&&c===E.RANGE&&(t.flags.includes("v")||t.unicodeSetsPlugin))throw new Error("Invalid unescaped hyphen as the end value for a range");if(h===p.DEFAULT&&/^(?:[?*+]|\?\?)$/.test(u)||h===p.INTERVAL_QUANTIFIER&&u==="{")o+=m(u,{prefix:!1,postfix:l==="("&&u==="?"});else if(h===p.DEFAULT)Ce.test(u)?r=!0:u.startsWith("#")?a=!0:ve.test(u)?o+=m(u[1],{prefix:!1}):o+=m(u);else if(h===p.CHAR_CLASS&&u!=="["&&u!=="[^")if(te.test(u)&&(d===E.DEFAULT||d===E.ENCLOSED_Q||d===E.RANGE))s=!0;else{if(d===E.INVALID_INCOMPLETE_TOKEN)throw new Error(`Invalid incomplete token in character class: "${u}"`);if(Ve.test(u)&&(d===E.DEFAULT||d===E.ENCLOSED_Q))o+=m(u[1],{prefix:!1});else if(d===E.DEFAULT){let S=e[C+1]??"",w=y(u);(te.test(S)||u==="^")&&(w=z(w)),o+=m(w)}else o+=m(u)}else o+=m(u);r||s||a||(l=u,c=d)}return{transformed:o,runningContext:n}}function Ae(e){let n=String.raw`\(\?:\)`;return e=N(e,`(?:${n}){2,}`,"(?:)",g.DEFAULT),e=N(e,String.raw`${n}(?=[)|.[$\\]|\((?!DEFINE)|$)|(?<=[()|.\]^>]|\\[bBdDfnrsStvwW]|\(\?(?:[:=!]|<[=!])|^)${n}(?![?*+{])`,"",g.DEFAULT),{pattern:e}}var K=class e extends RegExp{_captureMap;constructor(n,t,r){if(n instanceof RegExp){if(r)throw new Error("Cannot provide options when copying a regexp");super(n,t),n instanceof e?this._captureMap=n._captureMap:this._captureMap=new Map}else{super(n,t);let s=r?.hiddenCaptures??[];this._captureMap=je(s)}}exec(n){let t=super.exec(n);if(!t||!this._captureMap.size)return t;let r=[...t];t.length=1;let s;this.hasIndices&&(s=[...t.indices],t.indices.length=1);for(let a=1;a<r.length;a++)this._captureMap.get(a)?.hidden||(t.push(r[a]),this.hasIndices&&t.indices.push(s[a]));return t}};function je(e){let n=new Map;for(let t of e)n.set(t,{hidden:!0});return n}function Le(e,n){let t=Ie(e,{includeContents:!0}),r=qe(e,t,n?.hiddenCaptures??[]);return{pattern:We(r.pattern,t),hiddenCaptures:r.hiddenCaptures}}var Qe=String.raw`\\g<(?<subroutineName>[^>&]+)>`,v=new RegExp(String.raw`
+${Qe}
+| (?<capturingStart>${B})
+| \\(?<backrefNum>[1-9]\d*)
+| \\k<(?<backrefName>[^>]+)>
+| \\?.
+`.replace(/\s+/g,""),"gsu");function qe(e,n,t){if(!/\\g</.test(e))return{pattern:e,hiddenCaptures:t};let r=j(e,"\\\\(?:[1-9]|k<[^>]+>)",g.DEFAULT),s=r?"(":"(?:",a=new Map,i=[],o=[0],l=[],c=0,f=0,m=0,u=0,C=0,h;for(v.lastIndex=0;h=v.exec(e);){let{0:d,index:S,groups:{subroutineName:w,capturingStart:O,backrefNum:T,backrefName:$}}=h;if(d==="[")C++;else if(C)d==="]"&&C--;else if(w){if(!n.has(w))throw new Error(`Invalid named capture referenced by subroutine ${d}`);if(a.has(w))throw new Error(`Subroutine ${d} followed a recursive reference`);let A=n.get(w).contents,D=`${s}${A})`;r&&(m=0,f++,Se(t,l,c+f)),a.set(w,{unclosedGroupCount:Be(D)}),i.push(w),e=b(e,S,d,D),v.lastIndex-=d.length-s.length}else if(O)a.size?(r&&(m++,f++,Se(t,l,c+f)),d!=="("&&(e=b(e,S,d,s),v.lastIndex-=d.length-s.length)):r&&(o.push(re(o)+1+f-u),u=f,c++);else if((T||$)&&a.size){let A=T?+T:n.get($)?.groupNum,D=!1;for(let L of i){let I=n.get(L);if(A>=I.groupNum&&A<=I.groupNum+I.numCaptures){D=!0;break}}if(D){let L=n.get(re(i)),I=c+f-m,P=`\\k<$$b${A}s${I}r${L.groupNum}c${L.numCaptures}>`;e=b(e,S,d,P),v.lastIndex+=P.length-d.length}}else if(d===")"&&a.size){let A=a.get(re(i));A.unclosedGroupCount--,A.unclosedGroupCount||a.delete(i.pop())}}return t.push(...l),r&&(e=N(e,String.raw`\\(?:(?<bNum>[1-9]\d*)|k<\$\$b(?<bNumSub>\d+)s(?<subNum>\d+)r(?<refNum>\d+)c(?<refCaps>\d+)>)`,({0:d,groups:{bNum:S,bNumSub:w,subNum:O,refNum:T,refCaps:$}})=>{if(S){let P=+S;if(P>o.length-1)throw new Error(`Backref "${d}" greater than number of captures`);return`\\${o[P]}`}let A=+w,D=+O,L=+T,I=+$;return A<L||A>L+I?`\\${o[A]}`:`\\${D-L+A}`},g.DEFAULT)),{pattern:e,hiddenCaptures:t}}var ne=new RegExp(String.raw`${W}|\(\?:\)|(?<invalid>\\?.)`,"gsu");function We(e,n){let t=H(e,String.raw`\(\?\(DEFINE\)`,0,g.DEFAULT);if(!t)return e;let r=Ne(e,t);if(r.afterPos<e.length)throw new Error("DEFINE group allowed only at the end of a regex");if(r.afterPos>e.length)throw new Error("DEFINE group is unclosed");let s;for(ne.lastIndex=0;s=ne.exec(r.contents);){let{captureName:a,invalid:i}=s.groups;if(a){let o=Ne(r.contents,s),l;if(!n.get(a).isUnique)l=a;else{let c=Ie(o.contents,{includeContents:!1});for(let f of c.keys())if(!n.get(f).isUnique){l=f;break}}if(l)throw new Error(`Duplicate group name "${l}" within DEFINE`);ne.lastIndex=o.afterPos}else if(i)throw new Error("DEFINE group includes unsupported syntax at top level")}return e.slice(0,t.index)}function Be(e){let n=0;return k(e,"\\(",()=>n++,g.DEFAULT),n}function ze(e,n){let t=0,r=0,s;for(;s=H(e,B,r,g.DEFAULT);){let{0:a,index:i,groups:{captureName:o}}=s;if(t++,o===n)break;r=i+a.length}return t}function Ne(e,n){let t=n.index+n[0].length,r=J(e,t),s=t+r.length+1;return{contents:r,afterPos:s}}function Ie(e,{includeContents:n}){let t=new Map;return k(e,W,({0:r,index:s,groups:{captureName:a}})=>{if(t.has(a))t.get(a).isUnique=!1;else{let i={isUnique:!0};if(n){let o=J(e,s+r.length);Object.assign(i,{contents:o,groupNum:ze(e,a),numCaptures:R(o)})}t.set(a,i)}},g.DEFAULT),t}function re(e){return e[e.length-1]}function Se(e,n,t){n.push(t),V(e,t)}var Ke=(e,...n)=>{if(Array.isArray(e?.raw))return se({},e,...n);if((typeof e=="string"||e===void 0)&&!n.length)return se.bind(null,{flags:e??""});if({}.toString.call(e)==="[object Object]"&&!n.length)return se.bind(null,e);throw new Error(`Unexpected arguments: ${JSON.stringify([e,...n])}`)},se=(e,n,...t)=>{let r=De(e),s=_e(n,t,r),a=0,i="",o;s.template.raw.forEach((c,f)=>{let m=!!(s.template.raw[f]||s.template.raw[f+1]);a+=R(c),i+=y(c,g.CHAR_CLASS),o=x(i,o);let{regexContext:u,charClassContext:C}=o;if(f<s.template.raw.length-1){let h=s.substitutions[f];i+=Je(h,r.flags,u,C,m,a),h instanceof RegExp?a+=R(h.source):h instanceof _&&(a+=R(String(h)))}});let l=Te(i,r);i=l.pattern;try{return r.subclass?new K(i,r.flags,{hiddenCaptures:l.hiddenCaptures}):new RegExp(i,r.flags)}catch(c){let f=c.message.replace(/ \/.+\/[a-z]*:/,"");throw c.message=`${f}: /${i}/${r.flags}`,c}};function Ze(e="",n){let t=De(n);if(t.subclass)throw new Error("Cannot use option subclass");return{pattern:Te(_e({raw:[e]},[],t).template.raw[0],t).pattern,flags:t.flags}}function De(e){let n={flags:"",subclass:!1,plugins:[],unicodeSetsPlugin:he,disable:{},force:{},...e};if(/[nuvx]/.test(n.flags))throw new Error("Implicit flags v/u/x/n cannot be explicitly added");let t=n.force.v||(n.disable.v?!1:fe);return n.flags+=t?"v":"u",t&&(n.unicodeSetsPlugin=null),n}function _e(e,n,t){let r=[];t.disable.x||r.push(we),t.disable.n||r.push(me);for(let s of r)({template:e,substitutions:n}=ge(e,n,s,t));return{template:e,substitutions:n}}function Te(e,{flags:n,plugins:t,unicodeSetsPlugin:r,disable:s}){let a=[];return[...t,...s.subroutines?[]:[Le],...s.atomic?[]:[ue,ae],...s.x?[]:[Ae],...r?[r]:[]].forEach(i=>{let o=i(e,{flags:n,hiddenCaptures:a});if(typeof o?.pattern!="string")throw new Error('Plugin must return an object with a string property "pattern"');e=o.pattern,o.hiddenCaptures&&(a=o.hiddenCaptures)}),{pattern:e,hiddenCaptures:a}}function Je(e,n,t,r,s,a){if(e in
Line truncated
+//# sourceMappingURL=regex.min.js.map

node_modules/regex/dist/regex.min.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/regex.js", "../src/utils-internals.js", "../node_modules/.pnpm/regex-utilities@2.3.0/node_modules/regex-utilities/src/index.js", "../src/atomic.js", "../src/pattern.js", "../src/utils.js", "../src/backcompat.js", "../src/flag-n.js", "../src/flag-x.js", "../src/subclass.js", "../src/subroutines.js"],
+  "sourcesContent": ["import {atomic, possessive} from './atomic.js';\nimport {backcompatPlugin} from './backcompat.js';\nimport {flagNPreprocessor} from './flag-n.js';\nimport {clean, flagXPreprocessor} from './flag-x.js';\nimport {Pattern, pattern} from './pattern.js';\nimport {RegExpSubclass} from './subclass.js';\nimport {subroutines} from './subroutines.js';\nimport {adjustNumberedBackrefs, CharClassContext, containsCharClassUnion, countCaptures, enclosedTokenCharClassContexts, enclosedTokenRegexContexts, envSupportsFlagGroups, envSupportsFlagV, escapeV, getBreakoutChar, getEndContextForIncompleteExpression, preprocess, RegexContext, sandboxLoneCharClassCaret, sandboxLoneDoublePunctuatorChar, sandboxUnsafeNulls} from './utils.js';\nimport {Context, hasUnescaped, replaceUnescaped} from 'regex-utilities';\n\n/**\n@typedef {string | RegExp | Pattern | number} InterpolatedValue\n@typedef {{\n  flags?: string;\n  captureTransfers?: Map<number, Array<number>>;\n  hiddenCaptures?: Array<number>;\n}} PluginData\n@typedef {{\n  pattern: string;\n  captureTransfers?: Map<number, Array<number>>;\n  hiddenCaptures?: Array<number>;\n}} PluginResult\n@typedef {TemplateStringsArray | {raw: Array<string>}} RawTemplate\n@typedef {{\n  flags?: string;\n  subclass?: boolean;\n  plugins?: Array<(expression: string, data: PluginData) => PluginResult>;\n  unicodeSetsPlugin?: ((expression: string, data: PluginData) => PluginResult) | null;\n  disable?: {\n    x?: boolean;\n    n?: boolean;\n    v?: boolean;\n    atomic?: boolean;\n    subroutines?: boolean;\n  };\n  force?: {\n    v?: boolean;\n  };\n}} RegexTagOptions\n*/\n/**\n@template T\n@typedef RegexTag\n@type {{\n  (template: RawTemplate, ...substitutions: ReadonlyArray<InterpolatedValue>): T;\n  (flags?: string): RegexTag<T>;\n  (options: RegexTagOptions & {subclass?: false}): RegexTag<T>;\n  (options: RegexTagOptions & {subclass: true}): RegexTag<RegExpSubclass>;\n}}\n*/\n/**\nTemplate tag for constructing a regex with extended syntax and context-aware interpolation of\nregexes, strings, and patterns.\n\nCan be called in several ways:\n1. `` regex`\u2026` `` - Regex pattern as a raw string.\n2. `` regex('gi')`\u2026` `` - To specify flags.\n3. `` regex({flags: 'gi'})`\u2026` `` - With options.\n@type {RegexTag<RegExp>}\n*/\nconst regex = (first, ...substitutions) => {\n  // Given a template\n  if (Array.isArray(first?.raw)) {\n    return regexFromTemplate({}, first, ...substitutions);\n  // Given flags\n  } else if ((typeof first === 'string' || first === undefined) && !substitutions.length) {\n    return regexFromTemplate.bind(null, {flags: first ?? ''});\n  // Given an options object\n  } else if ({}.toString.call(first) === '[object Object]' && !substitutions.length) {\n    return regexFromTemplate.bind(null, first);\n  }\n  throw new Error(`Unexpected arguments: ${JSON.stringify([first, ...substitutions])}`);\n};\n\n/**\n@template T\n@typedef RegexFromTemplate\n@type {{\n  (options: RegexTagOptions, template: RawTemplate, ...substitutions: ReadonlyArray<InterpolatedValue>) : T;\n}}\n*/\n/**\nReturns a RegExp from a template and substitutions to fill the template holes.\n@type {RegexFromTemplate<RegExp>}\n*/\nconst regexFromTemplate = (options, template, ...substitutions) => {\n  const opts = getOptions(options);\n  const prepped = runPreprocessors(template, substitutions, opts);\n\n  let precedingCaptures = 0;\n  let expression = '';\n  let runningContext;\n  // Intersperse raw template strings and substitutions\n  prepped.template.raw.forEach((raw, i) => {\n    const hasNonEmptyRawBoundary = !!(prepped.template.raw[i] || prepped.template.raw[i + 1]);\n    // Even with flag n enabled, we might have named captures\n    precedingCaptures += countCaptures(raw);\n    // Sandbox `\\0` in character classes. Not needed outside character classes because in other\n    // cases a following interpolated value would always be atomized\n    expression += sandboxUnsafeNulls(raw, Context.CHAR_CLASS);\n    runningContext = getEndContextForIncompleteExpression(expression, runningContext);\n    const {regexContext, charClassContext} = runningContext;\n    if (i < prepped.template.raw.length - 1) {\n      const substitution = prepped.substitutions[i];\n      expression += interpolate(\n        substitution,\n        opts.flags,\n        regexContext,\n        charClassContext,\n        hasNonEmptyRawBoundary,\n        precedingCaptures\n      );\n      if (substitution instanceof RegExp) {\n        precedingCaptures += countCaptures(substitution.source);\n      } else if (substitution instanceof Pattern) {\n        precedingCaptures += countCaptures(String(substitution));\n      }\n    }\n  });\n\n  const plugged = runPlugins(expression, opts);\n  expression = plugged.pattern;\n  try {\n    return opts.subclass ?\n      new RegExpSubclass(expression, opts.flags, {hiddenCaptures: plugged.hiddenCaptures}) :\n      new RegExp(expression, opts.flags);\n  } catch (err) {\n    // ImproLine truncated
+  "mappings": "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 truncated
+  "names": ["regex_exports", "__export", "pattern", "regex", "rewrite", "noncapturingDelim", "incrementIfAtLeast", "arr", "threshold", "i", "spliceStr", "str", "pos", "oldValue", "newValue", "Context", "replaceUnescaped", "expression", "needle", "replacement", "context", "re", "negated", "numCharClassesOpen", "result", "match", "m", "$skip", "forEachUnescaped", "callback", "execUnescaped", "pos", "hasUnescaped", "getGroupContents", "contentsStartPos", "token", "contentsEndPos", "numGroupsOpen", "atomicPluginToken", "noncapturingDelim", "atomic", "expression", "data", "hiddenCaptures", "captureTransfers", "aGDelim", "emulatedAGDelim", "captureNumMap", "addedHiddenCaptures", "numCapturesBeforeAG", "numAGs", "aGPos", "hasProcessedAG", "numCharClassesOpen", "numGroupsOpenInAG", "inAG", "match", "m", "index", "capturingStart", "noncapturingStart", "addedCaptureNum", "incrementIfAtLeast", "newCaptureTransfers", "from", "to", "f", "replaceUnescaped", "backrefNum", "wrappedBackrefNum", "bNum", "Context", "baseQuantifier", "possessivePluginToken", "possessive", "openGroupIndices", "lastGroupIndex", "lastCharClassIndex", "lastToken", "qBase", "qMod", "invalidQ", "charsAdded", "spliceStr", "nodeIndex", "Pattern", "#value", "value", "pattern", "first", "substitutions", "raw", "i", "RegexContext", "CharClassContext", "enclosedTokenRegexContexts", "enclosedTokenCharClassContexts", "envSupportsFlagGroups", "envSupportsFlagV", "doublePunctuatorChars", "namedCapturingDelim", "capturingDelim", "adjustNumberedBackrefs", "expression", "precedingCaptures", "replaceUnescaped", "num", "Context", "stringPropertyNames", "charClassUnionToken", "containsCharClassUnion", "charClassPattern", "hasFirst", "lastM", "m", "groups", "countCaptures", "forEachUnescaped", "escapeV", "str", "context", "getBreakoutChar", "regexContext", "charClassContext", "escapesRemoved", "getUnbalancedChar", "contextToken", "getEndContextForIncompleteExpression", "incompleteExpression", "runningContext", "charClassDepth", "lastPos", "match", "groupN", "enclosedPU", "enclosedQ", "intervalQ", "incompleteT", "leftChar", "rightChar", "numOpen", "preprocess", "template", "substitutions", "preprocessor", "options", "newTemplate", "newSubstitutions", "raw", "i", "result", "substitution", "Pattern", "pattern", "sandboxLoneCharClassCaret", "sandboxLoneDoublePunctuatorChar", "_", "pos", "sandboxUnsafeNulls", "incompatibleEscapeChars", "token", "doublePunctuatorChars", "backcompatPlugin", "expression", "unescapedLiteralHyphenMsg", "inCharClass", "result", "m", "dp", "vOnlyEscape", "token", "noncapturingDelim", "flagNPreprocessor", "value", "runningContext", "expression", "transformed", "m", "backrefNum", "getEndContextForIncompleteExpression", "regexContext", "RegexContext", "ws", "escapedWsOrHash", "charClassWs", "escapedCharClassWs", "token", "noncapturingDelim", "doublePunctuatorChars", "flagXPreprocessor", "value", "runningContext", "options", "ignoringWs", "ignoringCharClassWs", "ignoringComment", "expression", "transformed", "lastSignificantToken", "lastSignificantCharClassContext", "separatorNeeded", "update", "str", "opts", "m", "index", "getEndContextForIncompleteExpression", "regexContext", "charClassContext", "RegexContext", "CharClassContext", "nextChar", "updated", "sandboxUnsafeNulls", "sandboxLoneDoublePunctuatorChar", "clean", "sep", "replaceUnescaped", "Context", "RegExpSubclass", "_RegExpSubclass", "expression", "flags", "options", "hiddenCaptures", "createCaptureMap", "str", "match", "matchCopy", "indicesCopy", "i", "captureMap", "num", "subroutines", "expression", "data", "namedGroups", "getNamedCapturingGroups", "transformed", "processSubroutines", "processDefinitionGroup", "subroutinePattern", "token", "capturingDelim", "hiddenCaptures", "hasBackrefs", "hasUnescaped", "Context", "subroutineWrapper", "openSubroutines", "openSubroutinesStack", "captureNumMap", "addedHiddenCaptures", "numCapturesPassedOutsideSubroutines", "numCapturesPassedInsideSubroutines", "numCapturesPassedInsideThisSubroutine", "numSubroutineCapturesTrackedInRemap", "numCharClassesOpen", "match", "m", "index", "subroutineName", "capturingStart", "backrefNum", "backrefName", "contents", "subroutineValue", "updateHiddenCaptureTracking", "countOpenParens", "spliceStr", "lastOf", "num", "isGroupFromThisSubroutine", "s", "group", "subroutineNum", "metadata", "subroutine", "replaceUnescaped", "bNum", "bNumSub", "subNum", "refNum", "refCaps", "backrefNumInSubroutine", "subroutineGroupNum", "refGroupNum", "numCapturesInRef", "defineGroupToken", "namedCapturingDelim", "defineMatch", "execUnescaped", "defineGroup", "getGroup", "captureName", "invalid", "duplicateName", "nestedNamedGroups", "name", "forEachUnescaped", "getCaptureNum", "groupName", "pos", "delimMatch", "contentsStart", "getGroupContents", "afterPos", "includeContents", "countCaptures", "arr", "addedCaptureNum", "incrementIfAtLeast", "regex", "first", "substitutions", "regexFromTemplate", "options", "template", "opts", "getOpLine truncated
+}