{
  "version": 3,
  "sources": ["../src/regex.js", "../src/pattern.js", "../node_modules/regex-utilities/src/index.js", "../src/utils.js", "../src/atomic.js", "../src/backcompat.js", "../src/flag-n.js", "../src/flag-x.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 {subroutines} from './subroutines.js';\nimport {adjustNumberedBackrefs, capturingDelim, CharClassContext, containsCharClassUnion, countCaptures, emulationGroupMarker, enclosedTokenCharClassContexts, enclosedTokenRegexContexts, escapeV, flagVSupported, getBreakoutChar, getEndContextForIncompleteExpression, patternModsSupported, 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 {{flags: string; useEmulationGroups: boolean;}} PluginData\n@typedef {TemplateStringsArray | {raw: Array<string>}} RawTemplate\n@typedef {{\n  flags?: string;\n  subclass?: boolean;\n  plugins?: Array<(expression: string, data: PluginData) => string>;\n  unicodeSetsPlugin?: ((expression: string, data: PluginData) => string) | 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<WrappedRegExp>;\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 = handlePreprocessors(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 wrapEscapedStr = !!(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(substitution, opts.flags, regexContext, charClassContext, wrapEscapedStr, precedingCaptures);\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  expression = handlePlugins(expression, opts);\n  let captureMap;\n  if (opts.subclass) {\n    ({expression, captureMap} = unmarkEmulationGroups(expression));\n  }\n  try {\n    return opts.subclass ?\n      new WrappedRegExp(expression, opts.flags, {captureMap}) :\n      new RegExp(expression, opts.flags);\n  } catch (err) {\n    // Improve DX by always including the generated source in the error message. Some browsers\n    // include it automatically, but not Firefox or Safari\n    const stripped = err.message.replace(/ \\/.+\\/[a-z]*:/, '');\n    err.message = `${stripped}: /${expression}/${opts.flags}`;\n    throw err;\n  }\n};\n\n/**\nReturns the processed expression and flags as strings.\n@param {string} expression\n@param {RegexTagOptions} [options]\n@returns {{expression: string; flags: string;}}\n*/\nfunction rewrite(expression = '', options = {}) {\n  const opts = getOptions(options);\n  if (opts.subclass) {\n    // Don't allow including emulation group markers in output\n    throw new Error('Cannot use option subclass');\n  }\n  return {\n    expression: handlePlugins(\n      handlePreprocessors({raw: [expression]}, [], opts).template.raw[0],\n      opts\n    ),\n    flags: opts.flags,\n  };\n}\n\n/**\nReturns a complete set of options, with default values set for options that weren't provided, and\nsome options augmented for use.\n@param {RegexTagOptions} options\n@returns {Required<RegexTagOptions>}\n*/\nfunction getOptions(options) {\n  const opts = {\n    flags: '',\n    subclass: false,\n    plugins: [],\n    unicodeSetsPlugin: backcompatPlugin,\n    disable: {/* n, v, x, atomic, subroutines */},\n    force: {/* v */},\n    ...options,\n  };\n  if (/[nuvx]/.test(opts.flags)) {\n    throw new Error('Implicit flags v/u/x/n cannot be explicitly added');\n  }\n  const useFlagV = opts.force.v || (opts.disable.v ? false : flagVSupported);\n  opts.flags += useFlagV ? 'v' : 'u';\n  if (useFlagV) {\n    opts.unicodeSetsPlugin = null;\n  }\n  return opts;\n}\n\n/**\n@param {RawTemplate} template\n@param {ReadonlyArray<InterpolatedValue>} substitutions\n@param {Required<RegexTagOptions>} options\n@returns {{\n  template: RawTemplate;\n  substitutions: ReadonlyArray<InterpolatedValue>;\n}}\n*/\nfunction handlePreprocessors(template, substitutions, options) {\n  const preprocessors = [];\n  // Implicit flag x is handled first because otherwise some regex syntax (if unescaped) within\n  // comments could cause problems when parsing\n  if (!options.disable.x) {\n    preprocessors.push(flagXPreprocessor);\n  }\n  // Implicit flag n is a preprocessor because capturing groups affect backreference rewriting in\n  // both interpolation and plugins\n  if (!options.disable.n) {\n    preprocessors.push(flagNPreprocessor);\n  }\n  for (const pp of preprocessors) {\n    ({template, substitutions} = preprocess(template, substitutions, pp, options));\n  }\n  return {\n    template,\n    substitutions,\n  };\n}\n\n/**\n@param {string} expression\n@param {Required<RegexTagOptions>} options\n@returns {string}\n*/\nfunction handlePlugins(expression, options) {\n  const {flags, plugins, unicodeSetsPlugin, disable, subclass} = options;\n  [ ...plugins, // Run first, so provided plugins can output extended syntax\n    ...(disable.subroutines ? [] : [subroutines]),\n    ...(disable.atomic      ? [] : [possessive, atomic]),\n    ...(disable.x           ? [] : [clean]),\n    // Run last, so it doesn't have to worry about parsing extended syntax\n    ...(!unicodeSetsPlugin  ? [] : [unicodeSetsPlugin]),\n  ].forEach(p => expression = p(expression, {flags, useEmulationGroups: subclass}));\n  return expression;\n}\n\nclass WrappedRegExp extends RegExp {\n  #captureMap;\n  /**\n  @param {string | WrappedRegExp} expression\n  @param {string} [flags]\n  @param {{captureMap: Array<boolean>;}} [data]\n  */\n  constructor(expression, flags, data) {\n    super(expression, flags);\n    if (data) {\n      this.#captureMap = data.captureMap;\n    // The third argument `data` isn't provided when regexes are copied as part of the internal\n    // handling of string methods `matchAll` and `split`\n    } else if (expression instanceof WrappedRegExp) {\n      // Can read private properties of the existing object since it was created by this class\n      this.#captureMap = expression.#captureMap;\n    }\n  }\n  /**\n  Called internally by all String/RegExp methods that use regexes.\n  @override\n  @param {string} str\n  @returns {RegExpExecArray | null}\n  */\n  exec(str) {\n    const match = RegExp.prototype.exec.call(this, str);\n    if (!match || !this.#captureMap) {\n      return match;\n    }\n    const copy = [...match];\n    // Empty all but the first value of the array while preserving its other properties\n    match.length = 1;\n    for (let i = 1; i < copy.length; i++) {\n      if (this.#captureMap[i]) {\n        match.push(copy[i]);\n      }\n    }\n    return match;\n  }\n}\n\n/**\n@param {InterpolatedValue} value\n@param {string} flags\n@param {string} regexContext\n@param {string} charClassContext\n@param {boolean} wrapEscapedStr\n@param {number} precedingCaptures\n@returns {string}\n*/\nfunction interpolate(value, flags, regexContext, charClassContext, wrapEscapedStr, precedingCaptures) {\n  if (value instanceof RegExp && regexContext !== RegexContext.DEFAULT) {\n    throw new Error('Cannot interpolate a RegExp at this position because the syntax context does not match');\n  }\n  if (regexContext === RegexContext.INVALID_INCOMPLETE_TOKEN || charClassContext === CharClassContext.INVALID_INCOMPLETE_TOKEN) {\n    // Throw in all cases, but only *need* to handle a preceding unescaped backslash (which would\n    // break sandboxing) since other errors would be handled by the invalid generated regex syntax\n    throw new Error('Interpolation preceded by invalid incomplete token');\n  }\n  if (\n    typeof value === 'number' &&\n    (regexContext === RegexContext.ENCLOSED_U || charClassContext === CharClassContext.ENCLOSED_U)\n  ) {\n    return value.toString(16);\n  }\n  const isPattern = value instanceof Pattern;\n  let escapedValue = '';\n  if (!(value instanceof RegExp)) {\n    value = String(value);\n    if (!isPattern) {\n      escapedValue = escapeV(\n        value,\n        regexContext === RegexContext.CHAR_CLASS ? Context.CHAR_CLASS : Context.DEFAULT\n      );\n    }\n    // Check `escapedValue` (not just patterns) since possible breakout char `>` isn't escaped\n    const breakoutChar = getBreakoutChar(escapedValue || value, regexContext, charClassContext);\n    if (breakoutChar) {\n      throw new Error(`Unescaped stray \"${breakoutChar}\" in the interpolated value would have side effects outside it`);\n    }\n  }\n\n  if (\n    regexContext === RegexContext.INTERVAL_QUANTIFIER ||\n    regexContext === RegexContext.GROUP_NAME ||\n    enclosedTokenRegexContexts.has(regexContext) ||\n    enclosedTokenCharClassContexts.has(charClassContext)\n  ) {\n    return isPattern ? String(value) : escapedValue;\n  } else if (regexContext === RegexContext.CHAR_CLASS) {\n    if (isPattern) {\n      if (hasUnescaped(String(value), '^-|^&&|-$|&&$')) {\n        // Sandboxing so we don't change the chars outside the pattern into being part of an\n        // operation they didn't initiate. Same problem as starting a pattern with a quantifier\n        throw new Error('Cannot use range or set operator at boundary of interpolated pattern; move the operation into the pattern or the operator outside of it');\n      }\n      const sandboxedValue = sandboxLoneCharClassCaret(sandboxLoneDoublePunctuatorChar(value));\n      // Atomize via nested character class `[\u2026]` if it contains implicit or explicit union (check\n      // the unadjusted value)\n      return containsCharClassUnion(value) ? `[${sandboxedValue}]` : sandboxUnsafeNulls(sandboxedValue);\n    }\n    // Atomize via nested character class `[\u2026]` if more than one node\n    return containsCharClassUnion(escapedValue) ? `[${escapedValue}]` : escapedValue;\n  }\n  // `RegexContext.DEFAULT`\n  if (value instanceof RegExp) {\n    const transformed = transformForLocalFlags(value, flags);\n    const backrefsAdjusted = adjustNumberedBackrefs(transformed.value, precedingCaptures);\n    // Sandbox and atomize; if we used a pattern modifier it has the same effect\n    return transformed.usedModifier ? backrefsAdjusted : `(?:${backrefsAdjusted})`;\n  }\n  if (isPattern) {\n    // Sandbox and atomize\n    return `(?:${value})`;\n  }\n  // Sandbox and atomize\n  return wrapEscapedStr ? `(?:${escapedValue})` : escapedValue;\n}\n\n/**\n@param {RegExp} re\n@param {string} outerFlags\n@returns {{value: string; usedModifier?: boolean;}}\n*/\nfunction transformForLocalFlags(re, outerFlags) {\n  /** @type {{i: boolean | null; m: boolean | null; s: boolean | null;}} */\n  const modFlagsObj = {\n    i: null,\n    m: null,\n    s: null,\n  };\n  const newlines = '\\\\n\\\\r\\\\u2028\\\\u2029';\n  let value = re.source;\n  if (re.ignoreCase !== outerFlags.includes('i')) {\n    if (patternModsSupported) {\n      modFlagsObj.i = re.ignoreCase;\n    } else {\n      throw new Error('Pattern modifiers not supported, so flag i on the outer and interpolated regex must match');\n    }\n  }\n  if (re.dotAll !== outerFlags.includes('s')) {\n    if (patternModsSupported) {\n      modFlagsObj.s = re.dotAll;\n    } else {\n      value = replaceUnescaped(value, '\\\\.', (re.dotAll ? '[^]' : `[^${newlines}]`), Context.DEFAULT);\n    }\n  }\n  if (re.multiline !== outerFlags.includes('m')) {\n    if (patternModsSupported) {\n      modFlagsObj.m = re.multiline;\n    } else {\n      value = replaceUnescaped(value, '\\\\^', (re.multiline ? `(?<=^|[${newlines}])` : '(?<![^])'), Context.DEFAULT);\n      value = replaceUnescaped(value, '\\\\$', (re.multiline ? `(?=$|[${newlines}])` : '(?![^])'), Context.DEFAULT);\n    }\n  }\n  if (patternModsSupported) {\n    const keys = Object.keys(modFlagsObj);\n    let modifier = keys.filter(k => modFlagsObj[k] === true).join('');\n    const modOff = keys.filter(k => modFlagsObj[k] === false).join('');\n    if (modOff) {\n      modifier += `-${modOff}`;\n    }\n    if (modifier) {\n      return {\n        value: `(?${modifier}:${value})`,\n        usedModifier: true,\n      };\n    }\n  }\n  return {value};\n}\n\n/**\nBuild the capturing group map (with emulation groups marked as `false` to indicate their submatches\nshouldn't appear in results), and remove the markers for anonymous captures which were added to\nemulate extended syntax.\n@param {string} expression\n@returns {{expression: string; captureMap: Array<boolean>;}}\n*/\nfunction unmarkEmulationGroups(expression) {\n  const marker = emulationGroupMarker.replace(/\\$/g, '\\\\$');\n  const captureMap = [true];\n  expression = replaceUnescaped(\n    expression,\n    `(?:${capturingDelim})(?<mark>${marker})?`,\n    ({0: m, groups: {mark}}) => {\n      if (mark) {\n        captureMap.push(false);\n        return m.slice(0, -emulationGroupMarker.length);\n      }\n      captureMap.push(true);\n      return m;\n    },\n    Context.DEFAULT\n  );\n  return {\n    captureMap,\n    expression,\n  };\n}\n\nexport {\n  pattern,\n  regex,\n  rewrite,\n};\n", "export class Pattern {\n  #value;\n  /** @param {string} value */\n  constructor(value) {\n    this.#value = value;\n  }\n  /** @returns {string} */\n  toString() {\n    return String(this.#value);\n  }\n}\n\n/**\nReturns a value that can be interpolated into a `regex` template string without having its special\ncharacters escaped.\n\nCan be called as a function or template tag:\n- `pattern(value)` - String or value coerced to string.\n- `` pattern`\u2026` `` - Same as ``pattern(String.raw`\u2026`)``.\n\n@overload\n@param {string | number} value\n@returns {Pattern}\n\n@overload\n@param {TemplateStringsArray} template\n@param {...string} substitutions\n@returns {Pattern}\n*/\nexport function pattern(first, ...substitutions) {\n  if (Array.isArray(first?.raw)) {\n    return new Pattern(\n      // Intersperse raw template strings and substitutions\n      first.raw.flatMap((raw, i) => i < first.raw.length - 1 ? [raw, substitutions[i]] : raw).join('')\n    );\n  } else if (!substitutions.length) {\n    return new Pattern(first === undefined ? '' : first);\n  }\n  throw new Error(`Unexpected arguments: ${JSON.stringify([first, ...substitutions])}`);\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      numCharClassesOpen--;\n    }\n    // Avoid an infinite loop on zero-length matches\n    if (re.lastIndex == match.index) {\n      re.lastIndex++;\n    }\n  }\n  return null;\n}\n\n/**\nChecks whether an unescaped instance of a regex pattern appears 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 {'DEFAULT' | 'CHAR_CLASS'} [context] All contexts if not specified\n@returns {boolean} Whether the pattern was found\n*/\nexport function hasUnescaped(expression, needle, context) {\n  // Do this the easy way\n  return !!execUnescaped(expression, needle, 0, context);\n}\n\n/**\nExtracts the full contents of a group (subpattern) from the given expression, accounting for\nescaped characters, nested groups, and character classes. The group is identified by the position\nwhere its contents start (the string index just after the group's opening delimiter). Returns the\nrest of the string if the group is unclosed.\n\nAssumes UnicodeSets-mode syntax.\n@param {string} expression Search target\n@param {number} contentsStartPos\n@returns {string}\n*/\nexport function getGroupContents(expression, contentsStartPos) {\n  const token = /\\\\?./gsu;\n  token.lastIndex = contentsStartPos;\n  let contentsEndPos = expression.length;\n  let numCharClassesOpen = 0;\n  // Starting search within an open group, after the group's opening\n  let numGroupsOpen = 1;\n  let match;\n  while (match = token.exec(expression)) {\n    const [m] = match;\n    if (m === '[') {\n      numCharClassesOpen++;\n    } else if (!numCharClassesOpen) {\n      if (m === '(') {\n        numGroupsOpen++;\n      } else if (m === ')') {\n        numGroupsOpen--;\n        if (!numGroupsOpen) {\n          contentsEndPos = match.index;\n          break;\n        }\n      }\n    } else if (m === ']') {\n      numCharClassesOpen--;\n    }\n  }\n  return expression.slice(contentsStartPos, contentsEndPos);\n}\n", "import {Pattern, pattern} from './pattern.js';\nimport {Context, forEachUnescaped, replaceUnescaped} from 'regex-utilities';\n\nexport const RegexContext = {\n  DEFAULT: 'DEFAULT',\n  CHAR_CLASS: 'CHAR_CLASS',\n  ENCLOSED_P: 'ENCLOSED_P',\n  ENCLOSED_U: 'ENCLOSED_U',\n  GROUP_NAME: 'GROUP_NAME',\n  INTERVAL_QUANTIFIER: 'INTERVAL_QUANTIFIER',\n  INVALID_INCOMPLETE_TOKEN: 'INVALID_INCOMPLETE_TOKEN',\n};\n\nexport const CharClassContext = {\n  DEFAULT: 'DEFAULT',\n  ENCLOSED_P: 'ENCLOSED_P',\n  ENCLOSED_Q: 'ENCLOSED_Q',\n  ENCLOSED_U: 'ENCLOSED_U',\n  INVALID_INCOMPLETE_TOKEN: 'INVALID_INCOMPLETE_TOKEN',\n  RANGE: 'RANGE',\n};\n\nexport const enclosedTokenRegexContexts = new Set([\n  RegexContext.ENCLOSED_P,\n  RegexContext.ENCLOSED_U,\n]);\n\nexport const enclosedTokenCharClassContexts = new Set([\n  CharClassContext.ENCLOSED_P,\n  CharClassContext.ENCLOSED_Q,\n  CharClassContext.ENCLOSED_U,\n]);\n\nexport const patternModsSupported = (() => {\n  try {\n    new RegExp('(?i:)');\n  } catch (e) {\n    return false;\n  }\n  return true;\n})();\n\nexport const flagVSupported = (() => {\n  try {\n    new RegExp('', 'v');\n  } catch (e) {\n    return false;\n  }\n  return true;\n})();\n\n// This marker was chosen because it's impossible to match (so its extemely unlikely to be used in\n// a user-provided regex); it's not at risk of being optimized away, transformed, or flagged as an\n// error by a plugin; and it ends with an unquantifiable token\nexport const emulationGroupMarker = '$E$';\nexport const doublePunctuatorChars = '&!#$%*+,.:;<=>?@^`~';\nexport const namedCapturingDelim = String.raw`\\(\\?<(?![=!])(?<captureName>[^>]+)>`;\nexport const capturingDelim = String.raw`\\((?!\\?)(?!(?<=\\(\\?\\()DEFINE\\))|${namedCapturingDelim}`;\nexport const noncapturingDelim = String.raw`\\(\\?(?:[:=!>A-Za-z\\-]|<[=!]|\\(DEFINE\\))`;\n\n/**\n@param {string} expression\n@param {number} precedingCaptures\n@returns {string}\n*/\nexport function adjustNumberedBackrefs(expression, precedingCaptures) {\n  return replaceUnescaped(\n    expression,\n    String.raw`\\\\(?<num>[1-9]\\d*)`,\n    ({groups: {num}}) => `\\\\${+num + precedingCaptures}`,\n    Context.DEFAULT\n  );\n}\n\n// Properties of strings as of ES2024\nconst stringPropertyNames = [\n  'Basic_Emoji',\n  'Emoji_Keycap_Sequence',\n  'RGI_Emoji_Modifier_Sequence',\n  'RGI_Emoji_Flag_Sequence',\n  'RGI_Emoji_Tag_Sequence',\n  'RGI_Emoji_ZWJ_Sequence',\n  'RGI_Emoji',\n].join('|');\nconst charClassUnionToken = new RegExp(String.raw`\n\\\\(?: c[A-Za-z]\n  | p\\{(?<pStrProp>${stringPropertyNames})\\}\n  | [pP]\\{[^\\}]+\\}\n  | (?<qStrProp>q)\n  | u(?:[A-Fa-f\\d]{4}|\\{[A-Fa-f\\d]+\\})\n  | x[A-Fa-f\\d]{2}\n  | .\n)\n| --\n| &&\n| .\n`.replace(/\\s+/g, ''), 'gsu');\n\n// Assumes flag v and doesn't worry about syntax errors that are caught by it\nexport function containsCharClassUnion(charClassPattern) {\n  // Return `true` if it contains:\n  // - `\\p` (lowercase only) and the name is a property of strings (case sensitive).\n  // - `\\q`.\n  // - Two single-char-matching tokens in sequence.\n  // - One single-char-matching token followed immediately by unescaped `[`.\n  // - One single-char-matching token preceded immediately by unescaped `]`.\n  // Else, `false`.\n  // Ranges with `-` create a single token.\n  // Subtraction and intersection with `--` and `&&` create a single token.\n  // Supports any number of nested classes\n  let hasFirst = false;\n  let lastM;\n  for (const {0: m, groups} of charClassPattern.matchAll(charClassUnionToken)) {\n    if (groups.pStrProp || groups.qStrProp) {\n      return true;\n    }\n    if (m === '[' && hasFirst) {\n      return true;\n    }\n    if (['-', '--', '&&'].includes(m)) {\n      hasFirst = false;\n    } else if (m !== '[' && m !== ']') {\n      if (hasFirst || lastM === ']') {\n        return true;\n      }\n      hasFirst = true;\n    }\n    lastM = m;\n  }\n  return false;\n}\n\n/**\n@param {string} expression\n@returns {number}\n*/\nexport function countCaptures(expression) {\n  let num = 0;\n  forEachUnescaped(expression, capturingDelim, () => num++, Context.DEFAULT);\n  return num;\n}\n\n/**\nEscape special characters for the given context, assuming flag v.\n@param {string} str String to escape\n@param {'DEFAULT' | 'CHAR_CLASS'} context `Context` option from lib `regex-utilities`\n@returns {string} Escaped string\n*/\nexport function escapeV(str, context) {\n  if (context === Context.CHAR_CLASS) {\n    // Escape all double punctuators (including ^, which is special on its own in the first\n    // position) in case they're bordered by the same character in or outside of the escaped string\n    return str.replace(new RegExp(String.raw`[()\\[\\]{}|\\\\/\\-${doublePunctuatorChars}]`, 'g'), '\\\\$&');\n  }\n  return str.replace(/[()\\[\\]{}|\\\\^$*+?.]/g, '\\\\$&');\n}\n\n// Look for characters that would change the meaning of subsequent tokens outside an interpolated value\nexport function getBreakoutChar(expression, regexContext, charClassContext) {\n  const escapesRemoved = expression.replace(/\\\\./gsu, '');\n  // Trailing unescaped `\\`; checking `.includes('\\\\')` would also work\n  if (escapesRemoved.endsWith('\\\\')) {\n    return '\\\\';\n  }\n  if (regexContext === RegexContext.DEFAULT) {\n    // Unbalanced `[` or `]` are also errors but don't breakout; they're caught by the wrapper\n    return getUnbalancedChar(escapesRemoved, '(', ')');\n  } else if (\n    regexContext === RegexContext.CHAR_CLASS &&\n    !enclosedTokenCharClassContexts.has(charClassContext)\n  ) {\n    return getUnbalancedChar(escapesRemoved, '[', ']');\n  } else if (\n    regexContext === RegexContext.INTERVAL_QUANTIFIER ||\n    enclosedTokenRegexContexts.has(regexContext) ||\n    enclosedTokenCharClassContexts.has(charClassContext)\n  ) {\n    if (escapesRemoved.includes('}')) {\n      return '}';\n    }\n  } else if (regexContext === RegexContext.GROUP_NAME) {\n    if (escapesRemoved.includes('>')) {\n      return '>';\n    }\n  }\n  return '';\n}\n\nconst contextToken = new RegExp(String.raw`\n(?<groupN>\\(\\?<(?![=!])|\\\\[gk]<)\n| (?<enclosedPU>\\\\[pPu]\\{)\n| (?<enclosedQ>\\\\q\\{)\n| (?<intervalQ>\\{)\n| (?<incompleteT>\\\\(?: $\n  | c(?![A-Za-z])\n  | u(?![A-Fa-f\\d]{4})[A-Fa-f\\d]{0,3}\n  | x(?![A-Fa-f\\d]{2})[A-Fa-f\\d]?\n  )\n)\n| --\n| \\\\?.\n`.replace(/\\s+/g, ''), 'gsu');\n\n/**\n@typedef {{\n  regexContext: string;\n  charClassContext: string;\n  charClassDepth: number;\n  lastPos: number;\n}} RunningContext\n*/\n/**\nAccepts and returns its full state so it doesn't have to reprocess parts that have already been\nseen. Assumes flag v and doesn't worry about syntax errors that are caught by it.\n@param {string} incompleteExpression\n@param {Partial<RunningContext>} [runningContext]\n@returns {RunningContext}\n*/\nexport function getEndContextForIncompleteExpression(incompleteExpression, {\n  regexContext = RegexContext.DEFAULT,\n  charClassContext = CharClassContext.DEFAULT,\n  charClassDepth = 0,\n  lastPos = 0,\n} = {}) {\n  contextToken.lastIndex = lastPos;\n  let match;\n  while (match = contextToken.exec(incompleteExpression)) {\n    const {0: m, groups: {groupN, enclosedPU, enclosedQ, intervalQ, incompleteT}} = match;\n    if (m === '[') {\n      charClassDepth++;\n      regexContext = RegexContext.CHAR_CLASS;\n      charClassContext = CharClassContext.DEFAULT;\n    } else if (m === ']' && regexContext === RegexContext.CHAR_CLASS) {\n      if (charClassDepth) {\n        charClassDepth--;\n      }\n      if (!charClassDepth) {\n        regexContext = RegexContext.DEFAULT;\n      }\n      charClassContext = CharClassContext.DEFAULT;\n    } else if (regexContext === RegexContext.CHAR_CLASS) {\n      if (incompleteT) {\n        charClassContext = CharClassContext.INVALID_INCOMPLETE_TOKEN;\n      } else if (m === '-') {\n        charClassContext = CharClassContext.RANGE;\n      } else if (enclosedPU) {\n        charClassContext = m[1] === 'u' ? CharClassContext.ENCLOSED_U : CharClassContext.ENCLOSED_P;\n      } else if (enclosedQ) {\n        charClassContext = CharClassContext.ENCLOSED_Q;\n      } else if (\n        (m === '}' && enclosedTokenCharClassContexts.has(charClassContext)) ||\n        // Don't continue in these contexts since we've advanced another token\n        charClassContext === CharClassContext.INVALID_INCOMPLETE_TOKEN ||\n        charClassContext === CharClassContext.RANGE\n      ) {\n        charClassContext = CharClassContext.DEFAULT;\n      }\n    } else {\n      if (incompleteT) {\n        regexContext = RegexContext.INVALID_INCOMPLETE_TOKEN;\n      } else if (groupN) {\n        regexContext = RegexContext.GROUP_NAME;\n      } else if (enclosedPU) {\n        regexContext = m[1] === 'u' ? RegexContext.ENCLOSED_U : RegexContext.ENCLOSED_P;\n      } else if (intervalQ) {\n        regexContext = RegexContext.INTERVAL_QUANTIFIER;\n      } else if (\n        (m === '>' && regexContext === RegexContext.GROUP_NAME) ||\n        (m === '}' && (regexContext === RegexContext.INTERVAL_QUANTIFIER || enclosedTokenRegexContexts.has(regexContext))) ||\n        // Don't continue in this context since we've advanced another token\n        regexContext === RegexContext.INVALID_INCOMPLETE_TOKEN\n       ) {\n        regexContext = RegexContext.DEFAULT;\n      }\n    }\n  }\n  return {\n    regexContext,\n    charClassContext,\n    charClassDepth,\n    lastPos: incompleteExpression.length,\n  };\n}\n\n// No special handling for escaped versions of the characters\nfunction getUnbalancedChar(expression, leftChar, rightChar) {\n  let numOpen = 0;\n  for (const [m] of expression.matchAll(new RegExp(`[${escapeV(leftChar + rightChar, Context.CHAR_CLASS)}]`, 'g'))) {\n    numOpen += m === leftChar ? 1 : -1;\n    if (numOpen < 0) {\n      return rightChar;\n    }\n  }\n  if (numOpen > 0) {\n    return leftChar;\n  }\n  return '';\n}\n\n/**\n@typedef {import('./regex.js').InterpolatedValue} InterpolatedValue\n@typedef {import('./regex.js').RawTemplate} RawTemplate\n@typedef {import('./regex.js').RegexTagOptions} RegexTagOptions\n@typedef {(\n  value: InterpolatedValue,\n  runningContext: RunningContext,\n  options: Required<RegexTagOptions>\n) => {\n  transformed: string;\n  runningContext: RunningContext;\n}} Preprocessor\n*/\n/**\nReturns transformed versions of a template and substitutions, using the given preprocessor. Only\nprocesses substitutions that are instanceof `Pattern`.\n@param {RawTemplate} template\n@param {ReadonlyArray<InterpolatedValue>} substitutions\n@param {Preprocessor} preprocessor\n@param {Required<RegexTagOptions>} options\n@returns {{template: RawTemplate; substitutions: ReadonlyArray<InterpolatedValue>;}}\n*/\nexport function preprocess(template, substitutions, preprocessor, options) {\n  let /** @type {RawTemplate} */ newTemplate = {raw: []};\n  let newSubstitutions = [];\n  let runningContext;\n  template.raw.forEach((raw, i) => {\n    const result = preprocessor(raw, {...runningContext, lastPos: 0}, options);\n    newTemplate.raw.push(result.transformed);\n    runningContext = result.runningContext;\n    if (i < template.raw.length - 1) {\n      const substitution = substitutions[i];\n      if (substitution instanceof Pattern) {\n        const result = preprocessor(substitution, {...runningContext, lastPos: 0}, options);\n        newSubstitutions.push(pattern(result.transformed));\n        runningContext = result.runningContext;\n      } else {\n        newSubstitutions.push(substitution);\n      }\n    }\n  });\n  return {\n    template: newTemplate,\n    substitutions: newSubstitutions,\n  };\n}\n\n// Sandbox `^` if relevant, done so it can't change the meaning of the surrounding character class\n// if we happen to be at the first position. See `sandboxLoneDoublePunctuatorChar` for more details\nexport function sandboxLoneCharClassCaret(str) {\n  return str.replace(/^\\^/, '\\\\^^');\n}\n\n// Sandbox without escaping by repeating the character and escaping only the first one. The second\n// one is so that, if followed by the same symbol, the resulting double punctuator will still throw\n// as expected. Details:\n// - Only need to check the first position because, if it's part of an implicit union,\n//   interpolation handling will wrap it in nested `[\u2026]`.\n// - Can't just wrap in nested `[\u2026]` here, since the value might be used in a range.\n// - Can't add a second unescaped symbol if a lone symbol is the entire string because it might be\n//   followed by the same unescaped symbol outside an interpolation, and since it won't be wrapped,\n//   the second symbol wouldn't be sandboxed from the one following it.\nexport function sandboxLoneDoublePunctuatorChar(str) {\n  return str.replace(new RegExp(`^([${doublePunctuatorChars}])(?!\\\\1)`), (m, _, pos) => {\n    return `\\\\${m}${pos + 1 === str.length ? '' : m}`;\n  });\n}\n\n/**\nConverts `\\0` tokens to `\\x00` in the given context.\n@param {string} str\n@param {'DEFAULT' | 'CHAR_CLASS'} [context] `Context` option from lib `regex-utilities`\n@returns {string}\n*/\nexport function sandboxUnsafeNulls(str, context) {\n  // regex`[\\0${0}]` and regex`[${pattern`\\0`}0]` can't be guarded against via nested `[\u2026]`\n  // sandboxing in character classes if the interpolated value doesn't contain union (since it\n  // might be placed on a range boundary). So escape `\\0` in character classes as `\\x00`\n  return replaceUnescaped(str, String.raw`\\\\0(?!\\d)`, '\\\\x00', context);\n}\n\n/**\n@param {string} str\n@param {number} pos\n@param {string} oldValue\n@param {string} newValue\n@returns {string}\n*/\nexport function spliceStr(str, pos, oldValue, newValue) {\n  return str.slice(0, pos) + newValue + str.slice(pos + oldValue.length);\n}\n", "import {emulationGroupMarker, noncapturingDelim, spliceStr} from './utils.js';\nimport {Context, replaceUnescaped} from 'regex-utilities';\n\nconst atomicPluginToken = new RegExp(String.raw`(?<noncapturingStart>${noncapturingDelim})|(?<capturingStart>\\((?:\\?<[^>]+>)?)|\\\\?.`, 'gsu');\n\n/**\nApply transformations for atomic groups: `(?>\u2026)`.\n@param {string} expression\n@param {import('./regex.js').PluginData} [data]\n@returns {string}\n*/\nexport function atomic(expression, data) {\n  if (!/\\(\\?>/.test(expression)) {\n    return expression;\n  }\n  const aGDelim = '(?>';\n  const emulatedAGDelim = `(?:(?=(${data?.useEmulationGroups ? emulationGroupMarker : ''}`;\n  const captureNumMap = [0];\n  let numCapturesBeforeAG = 0;\n  let numAGs = 0;\n  let aGPos = NaN;\n  let hasProcessedAG;\n  do {\n    hasProcessedAG = false;\n    let numCharClassesOpen = 0;\n    let numGroupsOpenInAG = 0;\n    let inAG = false;\n    let match;\n    atomicPluginToken.lastIndex = Number.isNaN(aGPos) ? 0 : aGPos + emulatedAGDelim.length;\n    while (match = atomicPluginToken.exec(expression)) {\n      const {0: m, index, groups: {capturingStart, noncapturingStart}} = match;\n      if (m === '[') {\n        numCharClassesOpen++;\n      } else if (!numCharClassesOpen) {\n\n        if (m === aGDelim && !inAG) {\n          aGPos = index;\n          inAG = true;\n        } else if (inAG && noncapturingStart) {\n          numGroupsOpenInAG++;\n        } else if (capturingStart) {\n          if (inAG) {\n            numGroupsOpenInAG++;\n          } else {\n            numCapturesBeforeAG++;\n            captureNumMap.push(numCapturesBeforeAG + numAGs);\n          }\n        } else if (m === ')' && inAG) {\n          if (!numGroupsOpenInAG) {\n            numAGs++;\n            // Replace `expression` and use `<$$N>` as a temporary wrapper for the backref so it\n            // can avoid backref renumbering afterward. Need to wrap the whole substitution\n            // (including the lookahead and following backref) in a noncapturing group to handle\n            // following quantifiers and literal digits\n            expression = `${expression.slice(0, aGPos)}${emulatedAGDelim}${\n                expression.slice(aGPos + aGDelim.length, index)\n              }))<$$${numAGs + numCapturesBeforeAG}>)${expression.slice(index + 1)}`;\n            hasProcessedAG = true;\n            break;\n          }\n          numGroupsOpenInAG--;\n        }\n\n      } else if (m === ']') {\n        numCharClassesOpen--;\n      }\n    }\n  // Start over from the beginning of the last atomic group's contents, in case the processed group\n  // contains additional atomic groups\n  } while (hasProcessedAG);\n\n  // Second pass to adjust numbered backrefs\n  expression = replaceUnescaped(\n    expression,\n    String.raw`\\\\(?<backrefNum>[1-9]\\d*)|<\\$\\$(?<wrappedBackrefNum>\\d+)>`,\n    ({0: m, groups: {backrefNum, wrappedBackrefNum}}) => {\n      if (backrefNum) {\n        const bNum = +backrefNum;\n        if (bNum > captureNumMap.length - 1) {\n          throw new Error(`Backref \"${m}\" greater than number of captures`);\n        }\n        return `\\\\${captureNumMap[bNum]}`;\n      }\n      return `\\\\${wrappedBackrefNum}`;\n    },\n    Context.DEFAULT\n  );\n  return expression;\n}\n\nconst baseQuantifier = String.raw`(?:[?*+]|\\{\\d+(?:,\\d*)?\\})`;\n// Complete tokenizer for base syntax; doesn't (need to) know about character-class-only syntax\nconst possessivePluginToken = new RegExp(String.raw`\n\\\\(?: \\d+\n  | c[A-Za-z]\n  | [gk]<[^>]+>\n  | [pPu]\\{[^\\}]+\\}\n  | u[A-Fa-f\\d]{4}\n  | x[A-Fa-f\\d]{2}\n  )\n| \\((?: \\? (?: [:=!>]\n  | <(?:[=!]|[^>]+>)\n  | [A-Za-z\\-]+:\n  | \\(DEFINE\\)\n  ))?\n| (?<qBase>${baseQuantifier})(?<qMod>[?+]?)(?<invalidQ>[?*+\\{]?)\n| \\\\?.\n`.replace(/\\s+/g, ''), 'gsu');\n\n/**\nTransform posessive quantifiers into atomic groups. The posessessive quantifiers are:\n`?+`, `*+`, `++`, `{N}+`, `{N,}+`, `{N,N}+`.\nThis follows Java, PCRE, Perl, and Python.\nPossessive quantifiers in Oniguruma and Onigmo are only: `?+`, `*+`, `++`.\n@param {string} expression\n@returns {string}\n*/\nexport function possessive(expression) {\n  if (!(new RegExp(`${baseQuantifier}\\\\+`).test(expression))) {\n    return expression;\n  }\n  const openGroupIndices = [];\n  let lastGroupIndex = null;\n  let lastCharClassIndex = null;\n  let lastToken = '';\n  let numCharClassesOpen = 0;\n  let match;\n  possessivePluginToken.lastIndex = 0;\n  while (match = possessivePluginToken.exec(expression)) {\n    const {0: m, index, groups: {qBase, qMod, invalidQ}} = match;\n    if (m === '[') {\n      if (!numCharClassesOpen) {\n        lastCharClassIndex = index;\n      }\n      numCharClassesOpen++;\n    } else if (m === ']') {\n      if (numCharClassesOpen) {\n        numCharClassesOpen--;\n      // Unmatched `]`\n      } else {\n        lastCharClassIndex = null;\n      }\n    } else if (!numCharClassesOpen) {\n\n      if (qMod === '+' && lastToken && !lastToken.startsWith('(')) {\n        // Invalid following quantifier would become valid via the wrapping group\n        if (invalidQ) {\n          throw new Error(`Invalid quantifier \"${m}\"`);\n        }\n        let charsAdded = -1; // -1 for removed trailing `+`\n        // Possessivizing fixed repetition quantifiers like `{2}` does't change their behavior, so\n        // avoid doing so (convert them to greedy)\n        if (/^\\{\\d+\\}$/.test(qBase)) {\n          expression = spliceStr(expression, index + qBase.length, qMod, '');\n        } else {\n          if (lastToken === ')' || lastToken === ']') {\n            const nodeIndex = lastToken === ')' ? lastGroupIndex : lastCharClassIndex;\n            // Unmatched `)` would break out of the wrapping group and mess with handling.\n            // Unmatched `]` wouldn't be a problem, but it's unnecessary to have dedicated support\n            // for unescaped `]++` since this won't work with flag u or v anyway\n            if (nodeIndex === null) {\n              throw new Error(`Invalid unmatched \"${lastToken}\"`);\n            }\n            expression = `${expression.slice(0, nodeIndex)}(?>${expression.slice(nodeIndex, index)}${qBase})${expression.slice(index + m.length)}`;\n          } else {\n            expression = `${expression.slice(0, index - lastToken.length)}(?>${lastToken}${qBase})${expression.slice(index + m.length)}`;\n          }\n          charsAdded += 4; // `(?>)`\n        }\n        possessivePluginToken.lastIndex += charsAdded;\n      } else if (m[0] === '(') {\n        openGroupIndices.push(index);\n      } else if (m === ')') {\n        lastGroupIndex = openGroupIndices.length ? openGroupIndices.pop() : null;\n      }\n\n    }\n    lastToken = m;\n  }\n  return expression;\n}\n", "import {doublePunctuatorChars} from './utils.js';\n\nconst incompatibleEscapeChars = '&!#%,:;<=>@`~';\nconst token = new RegExp(String.raw`\n\\[\\^?-?\n| --?\\]\n| (?<dp>[${doublePunctuatorChars}])\\k<dp>\n| --\n| \\\\(?<vOnlyEscape>[${incompatibleEscapeChars}])\n| \\\\[pPu]\\{[^}]+\\}\n| \\\\?.\n`.replace(/\\s+/g, ''), 'gsu');\n\n/**\nApplies flag v rules when using flag u, for forward compatibility.\nAssumes flag u and doesn't worry about syntax errors that are caught by it.\n@param {string} expression\n@returns {string}\n*/\nexport function backcompatPlugin(expression) {\n  const unescapedLiteralHyphenMsg = 'Invalid unescaped \"-\" in character class';\n  let inCharClass = false;\n  let result = '';\n  for (const {0: m, groups: {dp, vOnlyEscape}} of expression.matchAll(token)) {\n    if (m[0] === '[') {\n      if (inCharClass) {\n        throw new Error('Invalid nested character class when flag v not supported; possibly from interpolation');\n      }\n      if (m.endsWith('-')) {\n        throw new Error(unescapedLiteralHyphenMsg);\n      }\n      inCharClass = true;\n    } else if (m.endsWith(']')) {\n      if (m[0] === '-') {\n        throw new Error(unescapedLiteralHyphenMsg);\n      }\n      inCharClass = false;\n    } else if (inCharClass) {\n      if (m === '&&' || m === '--') {\n        throw new Error(`Invalid set operator \"${m}\" when flag v not supported`);\n      } else if (dp) {\n        throw new Error(`Invalid double punctuator \"${m}\", reserved by flag v`);\n      } else if ('(){}/|'.includes(m)) {\n        throw new Error(`Invalid unescaped \"${m}\" in character class`);\n      } else if (vOnlyEscape) {\n        // Remove the escaping backslash to emulate flag v rules, since this character is allowed\n        // to be escaped within character classes with flag v but not with flag u\n        result += vOnlyEscape;\n        continue;\n      }\n    }\n    result += m;\n  }\n  return result;\n}\n", "import {getEndContextForIncompleteExpression, noncapturingDelim, RegexContext} from './utils.js';\n\nconst token = new RegExp(String.raw`\n${noncapturingDelim}\n| \\(\\?<\n| (?<backrefNum>\\\\[1-9]\\d*)\n| \\\\?.\n`.replace(/\\s+/g, ''), 'gsu');\n\n/**\nApply transformations for flag n (named capture only).\n\nPreprocessors are applied to the outer regex and interpolated patterns, but not interpolated\nregexes or strings.\n@type {import('./utils.js').Preprocessor}\n*/\nexport function flagNPreprocessor(value, runningContext) {\n  value = String(value);\n  let expression = '';\n  let transformed = '';\n  for (const {0: m, groups: {backrefNum}} of value.matchAll(token)) {\n    expression += m;\n    runningContext = getEndContextForIncompleteExpression(expression, runningContext);\n    const {regexContext} = runningContext;\n    if (regexContext === RegexContext.DEFAULT) {\n      if (m === '(') {\n        transformed += '(?:';\n      } else if (backrefNum) {\n        throw new Error(`Invalid decimal escape \"${m}\" with implicit flag n; replace with named backreference`);\n      } else {\n        transformed += m;\n      }\n    } else {\n      transformed += m;\n    }\n  }\n  return {\n    transformed,\n    runningContext,\n  };\n}\n", "import {CharClassContext, doublePunctuatorChars, emulationGroupMarker, getEndContextForIncompleteExpression, noncapturingDelim, RegexContext, sandboxLoneDoublePunctuatorChar, sandboxUnsafeNulls} from './utils.js';\nimport {Context, replaceUnescaped} from 'regex-utilities';\n\nconst ws = /^\\s$/;\nconst escapedWsOrHash = /^\\\\[\\s#]$/;\nconst charClassWs = /^[ \\t]$/;\nconst escapedCharClassWs = /^\\\\[ \\t]$/;\nconst token = new RegExp(String.raw`\n\\\\(?: [gk]<\n  | [pPu]\\{\n  | c[A-Za-z]\n  | u[A-Fa-f\\d]{4}\n  | x[A-Fa-f\\d]{2}\n  | 0\\d+\n)\n| \\[\\^\n| ${noncapturingDelim}\n| \\(\\?<\n| (?<dp>[${doublePunctuatorChars}])\\k<dp>\n| --\n| \\\\?.\n`.replace(/\\s+/g, ''), 'gsu');\n\n/**\nApply transformations for flag x (insignificant whitespace and line comments).\n\nPreprocessors are applied to the outer regex and interpolated patterns, but not interpolated\nregexes or strings.\n@type {import('./utils.js').Preprocessor}\n*/\nexport function flagXPreprocessor(value, runningContext, options) {\n  value = String(value);\n  let ignoringWs = false;\n  let ignoringCharClassWs = false;\n  let ignoringComment = false;\n  let expression = '';\n  let transformed = '';\n  let lastSignificantToken = '';\n  let lastSignificantCharClassContext = '';\n  let separatorNeeded = false;\n  const update = (str, {prefix = true, postfix = false} = {}) => {\n    str = (separatorNeeded && prefix ? '(?:)' : '') + str + (postfix ? '(?:)' : '');\n    separatorNeeded = false;\n    return str;\n  };\n  for (const {0: m, index} of value.matchAll(token)) {\n    if (ignoringComment) {\n      if (m === '\\n') {\n        ignoringComment = false;\n        separatorNeeded = true;\n      }\n      continue;\n    }\n    if (ignoringWs) {\n      if (ws.test(m)) {\n        continue;\n      }\n      ignoringWs = false;\n      separatorNeeded = true;\n    } else if (ignoringCharClassWs) {\n      if (charClassWs.test(m)) {\n        continue;\n      }\n      ignoringCharClassWs = false;\n    }\n\n    expression += m;\n    runningContext = getEndContextForIncompleteExpression(expression, runningContext);\n    const {regexContext, charClassContext} = runningContext;\n    if (\n      // `--` is matched in one step, so boundary chars aren't `-` unless separated by whitespace\n      m === '-' &&\n      regexContext === RegexContext.CHAR_CLASS &&\n      lastSignificantCharClassContext === CharClassContext.RANGE &&\n      (options.flags.includes('v') || options.unicodeSetsPlugin)\n    ) {\n      // Need to handle this here since the main regex-parsing code would think the hyphen forms\n      // part of a subtraction operator since we've removed preceding whitespace\n      throw new Error('Invalid unescaped hyphen as the end value for a range');\n    }\n    if (\n      // `??` is matched in one step by the double punctuator token\n      (regexContext === RegexContext.DEFAULT && /^(?:[?*+]|\\?\\?)$/.test(m)) ||\n      (regexContext === RegexContext.INTERVAL_QUANTIFIER && m === '{')\n    ) {\n      // Skip the separator prefix and connect the quantifier to the previous token. This also\n      // allows whitespace between a quantifier and the `?` that makes it lazy. Add a postfix\n      // separator if `m` is `?` and we're following token `(`, to sandbox the `?` from following\n      // tokens (since `?` can be a group-type marker). Ex: `( ?:)` becomes `(?(?:):)` and throws.\n      // The loop we're in matches valid group openings in one step, so we won't arrive here if\n      // matching e.g. `(?:`. Flag n could prevent the need for the postfix since bare `(` is\n      // converted to `(?:`, but flag x handling always comes first and flag n can be turned off\n      transformed += update(m, {prefix: false, postfix: lastSignificantToken === '(' && m === '?'});\n    } else if (regexContext === RegexContext.DEFAULT) {\n      if (ws.test(m)) {\n        ignoringWs = true;\n      } else if (m.startsWith('#')) {\n        ignoringComment = true;\n      } else if (escapedWsOrHash.test(m)) {\n        transformed += update(m[1], {prefix: false});\n      } else {\n        transformed += update(m);\n      }\n    } else if (regexContext === RegexContext.CHAR_CLASS && m !== '[' && m !== '[^') {\n      if (\n        charClassWs.test(m) &&\n        ( charClassContext === CharClassContext.DEFAULT ||\n          charClassContext === CharClassContext.ENCLOSED_Q ||\n          charClassContext === CharClassContext.RANGE\n        )\n      ) {\n        ignoringCharClassWs = true;\n      } else if (charClassContext === CharClassContext.INVALID_INCOMPLETE_TOKEN) {\n        // Need to handle this here since the main regex-parsing code wouldn't know where the token\n        // ends if we removed whitespace after an incomplete token that is followed by something\n        // that completes the token\n        throw new Error(`Invalid incomplete token in character class: \"${m}\"`);\n      } else if (\n        escapedCharClassWs.test(m) &&\n        (charClassContext === CharClassContext.DEFAULT || charClassContext === CharClassContext.ENCLOSED_Q)\n      ) {\n        transformed += update(m[1], {prefix: false});\n      } else if (charClassContext === CharClassContext.DEFAULT) {\n        const nextChar = value[index + 1] ?? '';\n        let updated = sandboxUnsafeNulls(m);\n        // Avoid escaping lone double punctuators unless required, since some of them are not\n        // allowed to be escaped with flag u (the `unicodeSetsPlugin` already unescapes them when\n        // using flag u, but it can be set to `null` via an option)\n        if (charClassWs.test(nextChar) || m === '^') {\n          updated = sandboxLoneDoublePunctuatorChar(updated);\n        }\n        transformed += update(updated);\n      } else {\n        transformed += update(m);\n      }\n    } else {\n      transformed += update(m);\n    }\n    if (!(ignoringWs || ignoringCharClassWs || ignoringComment)) {\n      lastSignificantToken = m;\n      lastSignificantCharClassContext = charClassContext;\n    }\n  }\n  return {\n    transformed,\n    runningContext,\n  };\n}\n\n/**\nRemove `(?:)` token separators (most likely added by flag x) in cases where it's safe to do so.\n@param {string} expression\n@returns {string}\n*/\nexport function clean(expression) {\n  const sep = String.raw`\\(\\?:\\)`;\n  // No need for repeated separators\n  expression = replaceUnescaped(expression, `(?:${sep}){2,}`, '(?:)', Context.DEFAULT);\n  // No need for separators at:\n  // - The beginning, if not followed by a quantifier.\n  // - The end.\n  // - Outside of character classes:\n  //   - If followed by one of `)|.[$\\\\`, or `(` if that's not followed by `DEFINE)`.\n  //     - Technically we shouldn't remove `(?:)` if preceded by `(?(DEFINE` and followed by `)`,\n  //       but in this case flag x injects a sandboxing `(?:)` after the preceding invalid `(?`,\n  //       so we already get an error from that.\n  //   - If preceded by one of `()|.]^>`, `\\\\[bBdDfnrsStvwW]`, `(?:`, or a lookaround opening.\n  //     - So long as the separator is not followed by a quantifier.\n  //   - And, not followed by an emulation group marker.\n  // Examples of things that are not safe to remove `(?:)` at the boundaries of:\n  // - Anywhere: Letters, numbers, or any of `-=_,<?*+{}`.\n  // - If followed by any of `:!>`.\n  // - If preceded by any of `\\\\[cgkpPux]`.\n  // - Anything inside character classes.\n  const marker = emulationGroupMarker.replace(/\\$/g, '\\\\$');\n  expression = replaceUnescaped(\n    expression,\n    String.raw`(?:${sep}(?=[)|.[$\\\\]|\\((?!DEFINE)|$)|(?<=[()|.\\]^>]|\\\\[bBdDfnrsStvwW]|\\(\\?(?:[:=!]|<[=!])|^)${sep}(?![?*+{]))(?!${marker})`,\n    '',\n    Context.DEFAULT\n  );\n  return expression;\n}\n", "import {capturingDelim, countCaptures, emulationGroupMarker, namedCapturingDelim, spliceStr} from './utils.js';\nimport {Context, execUnescaped, forEachUnescaped, getGroupContents, hasUnescaped, replaceUnescaped} from 'regex-utilities';\n\n/**\n@param {string} expression\n@param {import('./regex.js').PluginData} [data]\n@returns {string}\n*/\nexport function subroutines(expression, data) {\n  // NOTE: subroutines and definition groups fully support numbered backreferences and unnamed\n  // captures (from interpolated regexes or from turning implicit flag n off), and all of the\n  // complex forward and backward backreference adjustments that can result\n  const namedGroups = getNamedCapturingGroups(expression, {includeContents: true});\n  const transformed = processSubroutines(expression, namedGroups, !!data?.useEmulationGroups);\n  return processDefinitionGroup(transformed, namedGroups);\n}\n\n// Explicitly exclude `&` from subroutine name chars because it's used by extension\n// `regex-recursion` for recursive subroutines via `\\g<name&R=N>`\nconst subroutinePattern = String.raw`\\\\g<(?<subroutineName>[^>&]+)>`;\nconst token = new RegExp(String.raw`\n${subroutinePattern}\n| (?<capturingStart>${capturingDelim})\n| \\\\(?<backrefNum>[1-9]\\d*)\n| \\\\k<(?<backrefName>[^>]+)>\n| \\\\?.\n`.replace(/\\s+/g, ''), 'gsu');\n\n/**\n@typedef {\n  Map<string, {\n    isUnique: boolean;\n    contents?: string;\n    groupNum?: number;\n    numCaptures?: number;\n  }>} NamedCapturingGroupsMap\n*/\n/**\nApply transformations for subroutines: `\\g<name>`.\n@param {string} expression\n@param {NamedCapturingGroupsMap} namedGroups\n@param {boolean} useEmulationGroups\n@returns {string}\n*/\nfunction processSubroutines(expression, namedGroups, useEmulationGroups) {\n  if (!/\\\\g</.test(expression)) {\n    return expression;\n  }\n  // Can skip a lot of processing and avoid adding captures if there are no backrefs\n  const hasBackrefs = hasUnescaped(expression, '\\\\\\\\(?:[1-9]|k<[^>]+>)', Context.DEFAULT);\n  const subroutineWrapper = hasBackrefs ? `(${useEmulationGroups ? emulationGroupMarker : ''}` : '(?:';\n  const openSubroutines = new Map();\n  const openSubroutinesStack = [];\n  const captureNumMap = [0];\n  let numCapturesPassedOutsideSubroutines = 0;\n  let numCapturesPassedInsideSubroutines = 0;\n  let numCapturesPassedInsideThisSubroutine = 0;\n  let numSubroutineCapturesTrackedInRemap = 0;\n  let numCharClassesOpen = 0;\n  let result = expression;\n  let match;\n  token.lastIndex = 0;\n  while (match = token.exec(result)) {\n    const {0: m, index, groups: {subroutineName, capturingStart, backrefNum, backrefName}} = match;\n    if (m === '[') {\n      numCharClassesOpen++;\n    } else if (!numCharClassesOpen) {\n\n      if (subroutineName) {\n        if (!namedGroups.has(subroutineName)) {\n          throw new Error(`Invalid named capture referenced by subroutine ${m}`);\n        }\n        if (openSubroutines.has(subroutineName)) {\n          throw new Error(`Subroutine ${m} followed a recursive reference`);\n        }\n        const contents = namedGroups.get(subroutineName).contents;\n        // Wrap value in case it has top-level alternation or is followed by a quantifier. The\n        // wrapper also marks the end of the expanded contents, which we'll track using\n        // `unclosedGroupCount`. If there are any backrefs in the expression, wrap with `()`\n        // instead of `(?:)` in case there are backrefs inside the subroutine that refer to their\n        // containing capturing group\n        const subroutineValue = `${subroutineWrapper}${contents})`;\n        if (hasBackrefs) {\n          numCapturesPassedInsideThisSubroutine = 0;\n          numCapturesPassedInsideSubroutines++;\n        }\n        openSubroutines.set(subroutineName, {\n          // Incrementally decremented to track when we've left the group\n          unclosedGroupCount: countOpenParens(subroutineValue),\n        });\n        openSubroutinesStack.push(subroutineName);\n        // Expand the subroutine's contents into the pattern we're looping over\n        result = spliceStr(result, index, m, subroutineValue);\n        token.lastIndex -= m.length - subroutineWrapper.length;\n      } else if (capturingStart) {\n        // Somewhere within an expanded subroutine\n        if (openSubroutines.size) {\n          if (hasBackrefs) {\n            numCapturesPassedInsideThisSubroutine++;\n            numCapturesPassedInsideSubroutines++;\n          }\n          // Named capturing group\n          if (m !== '(') {\n            // Replace named with unnamed capture. Subroutines ideally wouldn't create any new\n            // captures, but it can't be helped since we need any backrefs to this capture to work.\n            // Given that flag n prevents unnamed capture and thereby requires you to rely on named\n            // backrefs and `groups`, switching to unnamed essentially accomplishes not creating a\n            // capture. Can fully avoid capturing if there are no backrefs in the expression\n            result = spliceStr(result, index, m, subroutineWrapper);\n            token.lastIndex -= m.length - subroutineWrapper.length;\n          }\n        } else if (hasBackrefs) {\n          captureNumMap.push(\n            lastOf(captureNumMap) + 1 +\n            numCapturesPassedInsideSubroutines -\n            numSubroutineCapturesTrackedInRemap\n          );\n          numSubroutineCapturesTrackedInRemap = numCapturesPassedInsideSubroutines;\n          numCapturesPassedOutsideSubroutines++;\n        }\n      } else if ((backrefNum || backrefName) && openSubroutines.size) {\n        // Unify handling for named and unnamed by always using the backref num\n        const num = backrefNum ? +backrefNum : namedGroups.get(backrefName)?.groupNum;\n        let isGroupFromThisSubroutine = false;\n        // Search for the group in the contents of the subroutine stack\n        for (const s of openSubroutinesStack) {\n          const group = namedGroups.get(s);\n          if (num >= group.groupNum && num <= (group.groupNum + group.numCaptures)) {\n            isGroupFromThisSubroutine = true;\n            break;\n          }\n        }\n        if (isGroupFromThisSubroutine) {\n          const group = namedGroups.get(lastOf(openSubroutinesStack));\n          // Replace the backref with metadata we'll need to rewrite it later, using\n          // `\\k<$$bNsNrNcN>` as a temporary wrapper:\n          // - b: The unmodified matched backref num, or the corresponding num of a named backref\n          // - s: The capture num of the subroutine we're most deeply nested in, including captures\n          //      added by expanding the contents of preceding subroutines\n          // - r: The original capture num of the group that the subroutine we're most deeply\n          //      nested in references, not counting the effects of subroutines\n          // - c: The number of captures within `r`, not counting the effects of subroutines\n          const subroutineNum = numCapturesPassedOutsideSubroutines + numCapturesPassedInsideSubroutines - numCapturesPassedInsideThisSubroutine;\n          const metadata = `\\\\k<$$b${num}s${subroutineNum}r${group.groupNum}c${group.numCaptures}>`;\n          result = spliceStr(result, index, m, metadata);\n          token.lastIndex += metadata.length - m.length;\n        }\n      } else if (m === ')') {\n        if (openSubroutines.size) {\n          const subroutine = openSubroutines.get(lastOf(openSubroutinesStack));\n          subroutine.unclosedGroupCount--;\n          if (!subroutine.unclosedGroupCount) {\n            openSubroutines.delete(openSubroutinesStack.pop());\n          }\n        }\n      }\n\n    } else if (m === ']') {\n      numCharClassesOpen--;\n    }\n  }\n\n  if (hasBackrefs) {\n    // Second pass to adjust backrefs\n    result = replaceUnescaped(\n      result,\n      String.raw`\\\\(?:(?<bNum>[1-9]\\d*)|k<\\$\\$b(?<bNumSub>\\d+)s(?<subNum>\\d+)r(?<refNum>\\d+)c(?<refCaps>\\d+)>)`,\n      ({0: m, groups: {bNum, bNumSub, subNum, refNum, refCaps}}) => {\n        if (bNum) {\n          const backrefNum = +bNum;\n          if (backrefNum > captureNumMap.length - 1) {\n            throw new Error(`Backref \"${m}\" greater than number of captures`);\n          }\n          return `\\\\${captureNumMap[backrefNum]}`;\n        }\n        const backrefNumInSubroutine = +bNumSub;\n        const subroutineGroupNum = +subNum;\n        const refGroupNum = +refNum;\n        const numCapturesInRef = +refCaps;\n        if (backrefNumInSubroutine < refGroupNum || backrefNumInSubroutine > (refGroupNum + numCapturesInRef)) {\n          return `\\\\${captureNumMap[backrefNumInSubroutine]}`;\n        }\n        return `\\\\${subroutineGroupNum - refGroupNum + backrefNumInSubroutine}`;\n      },\n      Context.DEFAULT\n    );\n  }\n\n  return result;\n}\n\n// `(?:)` allowed because it can be added by flag x's preprocessing of whitespace and comments\nconst defineGroupToken = new RegExp(String.raw`${namedCapturingDelim}|\\(\\?:\\)|(?<invalid>\\\\?.)`, 'gsu');\n\n/**\nRemove valid subroutine definition groups: `(?(DEFINE)\u2026)`.\n@param {string} expression\n@param {NamedCapturingGroupsMap} namedGroups\nIMPORTANT: Avoid using the `contents` property of `namedGroups` objects, because at this point\nsubroutine substitution has been performed on the corresponding substrings in `expression`\n@returns {string}\n*/\nfunction processDefinitionGroup(expression, namedGroups) {\n  const defineMatch = execUnescaped(expression, String.raw`\\(\\?\\(DEFINE\\)`, 0, Context.DEFAULT);\n  if (!defineMatch) {\n    return expression;\n  }\n  const defineGroup = getGroup(expression, defineMatch);\n  if (defineGroup.afterPos < expression.length) {\n    // Supporting DEFINE at positions other than the end would complicate backref handling.\n    // NOTE: Flag x's preprocessing permits trailing whitespace and comments\n    throw new Error('DEFINE group allowed only at the end of a regex');\n  } else if (defineGroup.afterPos > expression.length) {\n    throw new Error('DEFINE group is unclosed');\n  }\n  let match;\n  defineGroupToken.lastIndex = 0;\n  while (match = defineGroupToken.exec(defineGroup.contents)) {\n    const {captureName, invalid} = match.groups;\n    if (captureName) {\n      const group = getGroup(defineGroup.contents, match);\n      let duplicateName;\n      if (!namedGroups.get(captureName).isUnique) {\n        duplicateName = captureName;\n      } else {\n        const nestedNamedGroups = getNamedCapturingGroups(group.contents);\n        for (const name of nestedNamedGroups.keys()) {\n          if (!namedGroups.get(name).isUnique) {\n            duplicateName = name;\n            break;\n          }\n        }\n      }\n      if (duplicateName) {\n        throw new Error(`Duplicate group name \"${duplicateName}\" within DEFINE`);\n      }\n      defineGroupToken.lastIndex = group.afterPos;\n    } else if (invalid) {\n      // Since a DEFINE group is stripped from its expression, we can't easily determine whether\n      // unreferenced top-level syntax within it is valid. Such syntax serves no purpose, so it's\n      // easiest to not allow it\n      throw new Error(`DEFINE group includes unsupported syntax at top level`);\n    }\n  }\n  return expression.slice(0, defineMatch.index);\n}\n\n/**\nCounts unescaped open parens outside of character classes, regardless of group type\n@param {string} expression\n@returns {number}\n*/\nfunction countOpenParens(expression) {\n  let num = 0;\n  forEachUnescaped(expression, '\\\\(', () => num++, Context.DEFAULT);\n  return num;\n}\n\n/**\n@param {string} expression\n@param {string} groupName\n@returns {number}\n*/\nfunction getCaptureNum(expression, groupName) {\n  let num = 0;\n  let pos = 0;\n  let match;\n  while (match = execUnescaped(expression, capturingDelim, pos, Context.DEFAULT)) {\n    const {0: m, index, groups: {captureName}} = match;\n    num++;\n    if (captureName === groupName) {\n      break;\n    }\n    pos = index + m.length;\n  }\n  return num;\n}\n\n/**\n@param {string} expression\n@param {RegExpExecArray} delimMatch\n@returns {{contents: string; afterPos: number}}\n*/\nfunction getGroup(expression, delimMatch) {\n  const contentsStart = delimMatch.index + delimMatch[0].length;\n  const contents = getGroupContents(expression, contentsStart);\n  const afterPos = contentsStart + contents.length + 1;\n  return {\n    contents,\n    afterPos,\n  };\n}\n\n/**\n@param {string} expression\n@param {{includeContents: boolean}} [options]\n@returns {NamedCapturingGroupsMap}\n*/\nfunction getNamedCapturingGroups(expression, {includeContents} = {}) {\n  const namedGroups = new Map();\n  forEachUnescaped(\n    expression,\n    namedCapturingDelim,\n    ({0: m, index, groups: {captureName}}) => {\n      // If there are duplicate capture names, subroutines refer to the first instance of the given\n      // group (matching the behavior of PCRE and Perl)\n      if (namedGroups.has(captureName)) {\n        namedGroups.get(captureName).isUnique = false;\n      } else {\n        const group = {isUnique: true};\n        if (includeContents) {\n          const contents = getGroupContents(expression, index + m.length);\n          Object.assign(group, {\n            contents,\n            groupNum: getCaptureNum(expression, captureName),\n            numCaptures: countCaptures(contents),\n          });\n        }\n        namedGroups.set(captureName, group);\n      }\n    },\n    Context.DEFAULT\n  );\n  return namedGroups;\n}\n\n/**\n@param {Array<any>} arr\n@returns {any}\n*/\nfunction lastOf(arr) {\n  // Remove when support for ES2022 array method `at` (Node.js 16.6) is no longer an issue:\n  // <https://caniuse.com/mdn-javascript_builtins_array_at>\n  return arr[arr.length - 1];\n}\n"],
  "mappings": "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",
  "names": ["regex_exports", "__export", "pattern", "regex", "rewrite", "Pattern", "#value", "value", "pattern", "first", "substitutions", "raw", "i", "Context", "replaceUnescaped", "expression", "needle", "replacement", "context", "re", "negated", "numCharClassesOpen", "result", "match", "m", "$skip", "forEachUnescaped", "callback", "execUnescaped", "pos", "hasUnescaped", "getGroupContents", "contentsStartPos", "token", "contentsEndPos", "numGroupsOpen", "RegexContext", "CharClassContext", "enclosedTokenRegexContexts", "enclosedTokenCharClassContexts", "patternModsSupported", "flagVSupported", "emulationGroupMarker", "doublePunctuatorChars", "namedCapturingDelim", "capturingDelim", "noncapturingDelim", "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", "charClassDepth", "lastPos", "match", "groupN", "enclosedPU", "enclosedQ", "intervalQ", "incompleteT", "leftChar", "rightChar", "numOpen", "preprocess", "template", "substitutions", "preprocessor", "options", "newTemplate", "newSubstitutions", "runningContext", "raw", "i", "result", "substitution", "Pattern", "pattern", "sandboxLoneCharClassCaret", "sandboxLoneDoublePunctuatorChar", "_", "pos", "sandboxUnsafeNulls", "spliceStr", "oldValue", "newValue", "atomicPluginToken", "noncapturingDelim", "atomic", "expression", "data", "aGDelim", "emulatedAGDelim", "emulationGroupMarker", "captureNumMap", "numCapturesBeforeAG", "numAGs", "aGPos", "hasProcessedAG", "numCharClassesOpen", "numGroupsOpenInAG", "inAG", "match", "index", "capturingStart", "noncapturingStart", "replaceUnescaped", "m", "backrefNum", "wrappedBackrefNum", "bNum", "Context", "baseQuantifier", "possessivePluginToken", "possessive", "openGroupIndices", "lastGroupIndex", "lastCharClassIndex", "lastToken", "qBase", "qMod", "invalidQ", "charsAdded", "spliceStr", "nodeIndex", "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", "prefix", "postfix", "m", "index", "getEndContextForIncompleteExpression", "regexContext", "charClassContext", "RegexContext", "CharClassContext", "nextChar", "updated", "sandboxUnsafeNulls", "sandboxLoneDoublePunctuatorChar", "clean", "sep", "replaceUnescaped", "Context", "marker", "emulationGroupMarker", "subroutines", "expression", "data", "namedGroups", "getNamedCapturingGroups", "transformed", "processSubroutines", "processDefinitionGroup", "subroutinePattern", "token", "capturingDelim", "useEmulationGroups", "hasBackrefs", "hasUnescaped", "Context", "subroutineWrapper", "emulationGroupMarker", "openSubroutines", "openSubroutinesStack", "captureNumMap", "numCapturesPassedOutsideSubroutines", "numCapturesPassedInsideSubroutines", "numCapturesPassedInsideThisSubroutine", "numSubroutineCapturesTrackedInRemap", "numCharClassesOpen", "result", "match", "m", "index", "subroutineName", "capturingStart", "backrefNum", "backrefName", "contents", "subroutineValue", "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", "regex", "first", "substitutions", "regexFromTemplate", "options", "template", "opts", "getOptions", "prepped", "handlePreprocessors", "precedingCaptures", "expression", "runningContext", "raw", "i", "wrapEscapedStr", "countCaptures", "sandboxUnsafeNulls", "Context", "getEndContextForIncompleteExpression", "regexContext", "charClassContext", "substitution", "interpolate", "Pattern", "handlePlugins", "captureMap", "unmarkEmulationGroups", "WrappedRegExp", "err", "stripped", "rewrite", "backcompatPlugin", "useFlagV", "flagVSupported", "preprocessors", "flagXPreprocessor", "flagNPreprocessor", "pp", "preprocess", "flags", "plugins", "unicodeSetsPlugin", "disable", "subclass", "subroutines", "possessive", "atomic", "clean", "p", "_WrappedRegExp", "#captureMap", "data", "str", "match", "copy", "value", "RegexContext", "CharClassContext", "isPattern", "escapedValue", "escapeV", "breakoutChar", "getBreakoutChar", "enclosedTokenRegexContexts", "enclosedTokenCharClassContexts", "hasUnescaped", "sandboxedValue", "sandboxLoneCharClassCaret", "sandboxLoneDoublePunctuatorChar", "containsCharClassUnion", "transformed", "transformForLocalFlags", "backrefsAdjusted", "adjustNumberedBackrefs", "re", "outerFlags", "modFlagsObj", "newlines", "patternModsSupported", "replaceUnescaped", "keys", "modifier", "k", "modOff", "marker", "emulationGroupMarker", "capturingDelim", "m", "mark"]
}