{
  "version": 3,
  "sources": ["../src/index.js", "../src/utils.js", "../src/options.js", "../src/unicode.js", "../src/tokenize.js", "../src/utils-ast.js", "../src/traverse.js", "../src/parse.js", "../node_modules/.pnpm/emoji-regex-xs@1.0.0/node_modules/emoji-regex-xs/index.mjs", "../src/transform.js", "../src/generate.js", "../src/subclass.js", "../node_modules/.pnpm/regex@6.0.1/node_modules/regex/src/utils-internals.js", "../node_modules/.pnpm/regex-utilities@2.3.0/node_modules/regex-utilities/src/index.js", "../node_modules/.pnpm/regex@6.0.1/node_modules/regex/src/atomic.js", "../node_modules/.pnpm/regex-recursion@6.0.2/node_modules/regex-recursion/src/index.js"],
  "sourcesContent": ["import {transform} from './transform.js';\nimport {generate} from './generate.js';\nimport {Accuracy, getOptions, Target} from './options.js';\nimport {parse} from './parse.js';\nimport {EmulatedRegExp} from './subclass.js';\nimport {tokenize} from './tokenize.js';\nimport {atomic, possessive} from 'regex/internals';\nimport {recursion} from 'regex-recursion';\n\n// The transformation and error checking for Oniguruma's unique syntax and behavior differences\n// compared to native JS RegExp is layered into all steps of the compilation process:\n// 1. Tokenizer: Understands Oniguruma syntax, with many large and small differences from JS.\n// 2. Parser: Builds an Oniguruma AST from the tokens, with understanding of Oniguruma differences.\n// 3. Transformer: Converts the Oniguruma AST to a Regex+ AST that preserves all Oniguruma\n//    behavior. This is true even in cases of non-native-JS features that are supported by both\n//    Regex+ and Oniguruma but with subtly different behavior in each (subroutines, flag x).\n// 4. Generator: Converts the Regex+ AST to a Regex+ pattern, flags, and options.\n// 5. Compiler: Components of the Regex+ libray are used to transpile several remaining features\n//    that aren't native to JS (atomic groups, possessive quantifiers, recursion). Regex+ uses a\n//    strict superset of JS RegExp syntax, so using it allows this library to benefit from not\n//    reinventing the wheel for complex features that Regex+ already knows how to transpile to JS.\n\n/**\nReturns an Oniguruma AST generated from an Oniguruma pattern.\n@param {string} pattern Oniguruma regex pattern.\n@param {{\n  flags?: string;\n  rules?: {\n    captureGroup?: boolean;\n    singleline?: boolean;\n  };\n}} [options]\n@returns {import('./parse.js').OnigurumaAst}\n*/\nfunction toOnigurumaAst(pattern, options) {\n  const opts = {\n    flags: options?.flags ?? '',\n    rules: {\n      captureGroup: false,\n      singleline: false,\n      ...(options?.rules),\n    },\n  };\n  return parse(tokenize(pattern, opts.flags, opts.rules));\n}\n\n/**\n@typedef {{\n  accuracy?: keyof Accuracy;\n  avoidSubclass?: boolean;\n  flags?: string;\n  global?: boolean;\n  hasIndices?: boolean;\n  lazyCompileLength?: number;\n  rules?: {\n    allowOrphanBackrefs?: boolean;\n    asciiWordBoundaries?: boolean;\n    captureGroup?: boolean;\n    recursionLimit?: number;\n    singleline?: boolean;\n  };\n  target?: keyof Target;\n  verbose?: boolean;\n}} ToRegExpOptions\n*/\n\n/**\nAccepts an Oniguruma pattern and returns an equivalent JavaScript `RegExp`.\n@param {string} pattern Oniguruma regex pattern.\n@param {ToRegExpOptions} [options]\n@returns {RegExp | EmulatedRegExp}\n*/\nfunction toRegExp(pattern, options) {\n  const d = toRegExpDetails(pattern, options);\n  if (d.options) {\n    return new EmulatedRegExp(d.pattern, d.flags, d.options);\n  }\n  return new RegExp(d.pattern, d.flags);\n}\n\n/**\nAccepts an Oniguruma pattern and returns the details for an equivalent JavaScript `RegExp`.\n@param {string} pattern Oniguruma regex pattern.\n@param {ToRegExpOptions} [options]\n@returns {{\n  pattern: string;\n  flags: string;\n  options?: import('./subclass.js').EmulatedRegExpOptions;\n}}\n*/\nfunction toRegExpDetails(pattern, options) {\n  const opts = getOptions(options);\n  const tokenized = tokenize(pattern, opts.flags, {\n    captureGroup: opts.rules.captureGroup,\n    singleline: opts.rules.singleline,\n  });\n  const onigurumaAst = parse(tokenized, {\n    skipBackrefValidation: opts.rules.allowOrphanBackrefs,\n    verbose: opts.verbose,\n  });\n  const regexAst = transform(onigurumaAst, {\n    accuracy: opts.accuracy,\n    asciiWordBoundaries: opts.rules.asciiWordBoundaries,\n    avoidSubclass: opts.avoidSubclass,\n    bestEffortTarget: opts.target,\n  });\n  const generated = generate(regexAst, opts);\n  const recursionResult = recursion(generated.pattern, {\n    captureTransfers: generated._captureTransfers,\n    hiddenCaptures: generated._hiddenCaptures,\n    mode: 'external',\n  });\n  const possessiveResult = possessive(recursionResult.pattern);\n  const atomicResult = atomic(possessiveResult.pattern, {\n    captureTransfers: recursionResult.captureTransfers,\n    hiddenCaptures: recursionResult.hiddenCaptures,\n  });\n  const details = {\n    pattern: atomicResult.pattern,\n    flags: `${opts.hasIndices ? 'd' : ''}${opts.global ? 'g' : ''}${generated.flags}${generated.options.disable.v ? 'u' : 'v'}`,\n  };\n  if (opts.avoidSubclass) {\n    if (opts.lazyCompileLength !== Infinity) {\n      throw new Error('Lazy compilation requires subclass');\n    }\n  } else {\n    // Sort isn't required; only for readability when serialized\n    const hiddenCaptures = atomicResult.hiddenCaptures.sort((a, b) => a - b);\n    // Change the map to the `EmulatedRegExp` format, serializable as JSON\n    const transfers = Array.from(atomicResult.captureTransfers);\n    const strategy = regexAst._strategy;\n    const lazyCompile = details.pattern.length >= opts.lazyCompileLength;\n    if (hiddenCaptures.length || transfers.length || strategy || lazyCompile) {\n      details.options = {\n        ...(hiddenCaptures.length && {hiddenCaptures}),\n        ...(transfers.length && {transfers}),\n        ...(strategy && {strategy}),\n        ...(lazyCompile && {lazyCompile}),\n      };\n    }\n  }\n  return details;\n}\n\n// // Returns a Regex+ AST generated from an Oniguruma pattern\n// function toRegexAst(pattern, options) {\n//   return transform(toOnigurumaAst(pattern, options));\n// }\n\nexport {\n  EmulatedRegExp,\n  toOnigurumaAst,\n  toRegExp,\n  toRegExpDetails,\n  // toRegexAst,\n};\n", "import {EsVersion, Target} from './options.js';\n\nconst cp = String.fromCodePoint;\nconst r = String.raw;\n\nconst envFlags = {\n  flagGroups: (() => {\n    try {\n      new RegExp('(?i:)');\n    } catch {\n      return false;\n    }\n    return true;\n  })(),\n  unicodeSets: (() => {\n    try {\n      new RegExp('', 'v');\n    } catch {\n      return false;\n    }\n    return true;\n  })(),\n};\n// Detect WebKit bug: <github.com/slevithan/oniguruma-to-es/issues/30>\nenvFlags.literalHyphenIncorrectlyCreatesRange = (() => {\n  if (!envFlags.unicodeSets) {\n    return false;\n  }\n  try {\n    new RegExp(r`[\\d\\-a]`, 'v');\n  } catch {\n    return true;\n  }\n  return false;\n})();\n\nfunction getNewCurrentFlags(current, {enable, disable}) {\n  return {\n    dotAll: !disable?.dotAll && !!(enable?.dotAll || current.dotAll),\n    ignoreCase: !disable?.ignoreCase && !!(enable?.ignoreCase || current.ignoreCase),\n  };\n}\n\nfunction getOrInsert(map, key, defaultValue) {\n  if (!map.has(key)) {\n    map.set(key, defaultValue);\n  }\n  return map.get(key);\n}\n\n/**\n@param {keyof Target} target\n@param {keyof Target} min\n@returns {boolean}\n*/\nfunction isMinTarget(target, min) {\n  return EsVersion[target] >= EsVersion[min];\n}\n\nfunction throwIfNot(value, msg) {\n  if (!value) {\n    throw new Error(msg ?? 'Value expected');\n  }\n  return value;\n}\n\nexport {\n  cp,\n  envFlags,\n  getNewCurrentFlags,\n  getOrInsert,\n  isMinTarget,\n  r,\n  throwIfNot,\n};\n", "import {envFlags} from './utils.js';\n\nconst Accuracy = /** @type {const} */ ({\n  default: 'default',\n  strict: 'strict',\n});\n\nconst EsVersion = {\n  ES2025: 2025,\n  ES2024: 2024,\n  ES2018: 2018,\n};\n\nconst Target = /** @type {const} */ ({\n  auto: 'auto',\n  ES2025: 'ES2025',\n  ES2024: 'ES2024',\n  ES2018: 'ES2018',\n});\n\n/**\nReturns a complete set of options, with default values set for options that weren't provided.\n@param {import('.').ToRegExpOptions} [options]\n@returns {Required<import('.').ToRegExpOptions>}\n*/\nfunction getOptions(options) {\n  if (options?.target !== undefined && !Target[options.target]) {\n    throw new Error(`Unexpected target \"${options.target}\"`)\n  }\n  // Set default values\n  const opts = {\n    // Sets the level of emulation rigor/strictness.\n    accuracy: 'default',\n    // Disables advanced emulation that relies on returning a `RegExp` subclass, resulting in\n    // certain patterns not being emulatable.\n    avoidSubclass: false,\n    // Oniguruma flags; a string with `i`, `m`, `x`, `D`, `S`, `W` in any order (all optional).\n    // Oniguruma's `m` is equivalent to JavaScript's `s` (`dotAll`).\n    flags: '',\n    // Include JavaScript flag `g` (`global`) in the result.\n    global: false,\n    // Include JavaScript flag `d` (`hasIndices`) in the result.\n    hasIndices: false,\n    // Delay regex construction until first use if the transpiled pattern is at least this length.\n    lazyCompileLength: Infinity,\n    // JavaScript version used for generated regexes. Using `auto` detects the best value based on\n    // your environment. Later targets allow faster processing, simpler generated source, and\n    // support for additional features.\n    target: 'auto',\n    // Disables optimizations that simplify the pattern when it doesn't change the meaning.\n    verbose: false,\n    ...options,\n    // Advanced options that override standard behavior, error checking, and flags when enabled.\n    rules: {\n      // Useful with TextMate grammars that merge backreferences across patterns.\n      allowOrphanBackrefs: false,\n      // Use ASCII-based `\\b` and `\\B`, which increases search performance of generated regexes.\n      asciiWordBoundaries: false,\n      // Allow unnamed captures and numbered calls (backreferences and subroutines) when using\n      // named capture. This is Oniguruma option `ONIG_OPTION_CAPTURE_GROUP`; on by default in\n      // `vscode-oniguruma`.\n      captureGroup: false,\n      // Change the recursion depth limit from Oniguruma's `20` to an integer `2`\u2013`20`.\n      recursionLimit: 20,\n      // `^` as `\\A`; `$` as`\\Z`. Improves search performance of generated regexes without changing\n      // meaning if searching line by line. This is Oniguruma option `ONIG_OPTION_SINGLELINE`.\n      singleline: false,\n      ...(options?.rules),\n    },\n  };\n  if (opts.target === 'auto') {\n    opts.target = envFlags.flagGroups ? 'ES2025' : (envFlags.unicodeSets ? 'ES2024' : 'ES2018');\n  }\n  return opts;\n}\n\nexport {\n  Accuracy,\n  EsVersion,\n  getOptions,\n  Target,\n};\n", "import {cp, r} from './utils.js';\n\nconst CharsWithoutIgnoreCaseExpansion = new Set([\n  cp(0x130), // \u0130\n  cp(0x131), // \u0131\n]);\n\nfunction getIgnoreCaseMatchChars(char) {\n  // Some chars should not match the chars they case swap to\n  if (CharsWithoutIgnoreCaseExpansion.has(char)) {\n    return [char];\n  }\n  const set = new Set();\n  const lower = char.toLowerCase();\n  // Everything else is based on `lower`\n  const upper = lower.toUpperCase();\n  const title = LowerToTitleCaseMap.get(lower);\n  const altLower = LowerToAlternativeLowerCaseMap.get(lower);\n  const altUpper = LowerToAlternativeUpperCaseMap.get(lower);\n  // Exclude ucase if multiple chars; count code point length. Excludes ucase versions of German\n  // es-zed '\u00DF', ligatures like '\uFB00', and chars with no precomposed ucase like '\u0149'. See\n  // <unicode.org/Public/UNIDATA/SpecialCasing.txt>\n  if ([...upper].length === 1) {\n    set.add(upper);\n  }\n  altUpper && set.add(altUpper);\n  title && set.add(title);\n  // Lcase of '\u0130' is multiple chars, but it's excluded by `CharsWithoutIgnoreCaseExpansion`\n  set.add(lower);\n  altLower && set.add(altLower);\n  return [...set];\n}\n\n// The following set includes:\n// - All ES2024 general categories and their aliases (all are supported by Oniguruma). See\n//   <github.com/mathiasbynens/unicode-match-property-value-ecmascript/blob/main/data/mappings.js>\n// - All ES2024 binary properties and their aliases (all are supported by Oniguruma). See\n//   <tc39.es/ecma262/multipage/text-processing.html#table-binary-unicode-properties>\n// Unicode properties must be mapped to property names supported by JS, and must also apply JS's\n// stricter rules for casing, whitespace, and underscores in Unicode property names. In order to\n// remain lightweight, this library assumes properties not in this list are Unicode script names\n// (which require a `Script=` or `sc=` prefix in JS). Unlike JS, Oniguruma doesn't support script\n// extensions, and it supports some properties that aren't supported in JS (including blocks with\n// an `In_` prefix). See also:\n// - Properties supported in Oniguruma: <github.com/kkos/oniguruma/blob/master/doc/UNICODE_PROPERTIES>\n// - Properties supported in JS by spec version: <github.com/eslint-community/regexpp/blob/main/src/unicode/properties.ts>\nconst JsUnicodeProperties = new Set(\n`C Other\nCc Control cntrl\nCf Format\nCn Unassigned\nCo Private_Use\nCs Surrogate\nL Letter\nLC Cased_Letter\nLl Lowercase_Letter\nLm Modifier_Letter\nLo Other_Letter\nLt Titlecase_Letter\nLu Uppercase_Letter\nM Mark Combining_Mark\nMc Spacing_Mark\nMe Enclosing_Mark\nMn Nonspacing_Mark\nN Number\nNd Decimal_Number digit\nNl Letter_Number\nNo Other_Number\nP Punctuation punct\nPc Connector_Punctuation\nPd Dash_Punctuation\nPe Close_Punctuation\nPf Final_Punctuation\nPi Initial_Punctuation\nPo Other_Punctuation\nPs Open_Punctuation\nS Symbol\nSc Currency_Symbol\nSk Modifier_Symbol\nSm Math_Symbol\nSo Other_Symbol\nZ Separator\nZl Line_Separator\nZp Paragraph_Separator\nZs Space_Separator\nASCII\nASCII_Hex_Digit AHex\nAlphabetic Alpha\nAny\nAssigned\nBidi_Control Bidi_C\nBidi_Mirrored Bidi_M\nCase_Ignorable CI\nCased\nChanges_When_Casefolded CWCF\nChanges_When_Casemapped CWCM\nChanges_When_Lowercased CWL\nChanges_When_NFKC_Casefolded CWKCF\nChanges_When_Titlecased CWT\nChanges_When_Uppercased CWU\nDash\nDefault_Ignorable_Code_Point DI\nDeprecated Dep\nDiacritic Dia\nEmoji\nEmoji_Component EComp\nEmoji_Modifier EMod\nEmoji_Modifier_Base EBase\nEmoji_Presentation EPres\nExtended_Pictographic ExtPict\nExtender Ext\nGrapheme_Base Gr_Base\nGrapheme_Extend Gr_Ext\nHex_Digit Hex\nIDS_Binary_Operator IDSB\nIDS_Trinary_Operator IDST\nID_Continue IDC\nID_Start IDS\nIdeographic Ideo\nJoin_Control Join_C\nLogical_Order_Exception LOE\nLowercase Lower\nMath\nNoncharacter_Code_Point NChar\nPattern_Syntax Pat_Syn\nPattern_White_Space Pat_WS\nQuotation_Mark QMark\nRadical\nRegional_Indicator RI\nSentence_Terminal STerm\nSoft_Dotted SD\nTerminal_Punctuation Term\nUnified_Ideograph UIdeo\nUppercase Upper\nVariation_Selector VS\nWhite_Space space\nXID_Continue XIDC\nXID_Start XIDS`.split(/\\s/)\n);\n\nconst JsUnicodePropertiesMap = new Map();\nfor (const p of JsUnicodeProperties) {\n  JsUnicodePropertiesMap.set(slug(p), p);\n}\n\nconst JsUnicodePropertiesOfStrings = new Set([\n  // ES2024 properties of strings; none are supported by Oniguruma\n  'Basic_Emoji',\n  'Emoji_Keycap_Sequence',\n  'RGI_Emoji',\n  'RGI_Emoji_Flag_Sequence',\n  'RGI_Emoji_Modifier_Sequence',\n  'RGI_Emoji_Tag_Sequence',\n  'RGI_Emoji_ZWJ_Sequence',\n]);\n\nconst JsUnicodePropertiesOfStringsMap = new Map();\nfor (const p of JsUnicodePropertiesOfStrings) {\n  JsUnicodePropertiesOfStringsMap.set(slug(p), p);\n}\n\nconst LowerToAlternativeLowerCaseMap = new Map([\n  ['s', cp(0x17F)], // s, \u017F\n  [cp(0x17F), 's'], // \u017F, s\n]);\n\nconst LowerToAlternativeUpperCaseMap = new Map([\n  [cp(0xDF), cp(0x1E9E)], // \u00DF, \u1E9E\n  [cp(0x6B), cp(0x212A)], // k, \u212A (Kelvin)\n  [cp(0xE5), cp(0x212B)], // \u00E5, \u212B (Angstrom)\n  [cp(0x3C9), cp(0x2126)], // \u03C9, \u2126 (Ohm)\n]);\n\n// See <github.com/node-unicode/unicode-16.0.0/tree/main/General_Category/Titlecase_Letter>\nconst LowerToTitleCaseMap = new Map([\n  titleEntry(0x1C5),\n  titleEntry(0x1C8),\n  titleEntry(0x1CB),\n  titleEntry(0x1F2),\n  ...titleRange(0x1F88, 0x1F8F),\n  ...titleRange(0x1F98, 0x1F9F),\n  ...titleRange(0x1FA8, 0x1FAF),\n  titleEntry(0x1FBC),\n  titleEntry(0x1FCC),\n  titleEntry(0x1FFC),\n]);\n\n// Unlike Oniguruma's Unicode properties via `\\p` and `\\P`, these names are case sensitive and\n// don't allow inserting whitespace and underscores. Definitions at\n// <github.com/kkos/oniguruma/blob/master/doc/RE> (see: POSIX bracket: Unicode Case)\n// Note: Handling in the transformer assumes all values here are a single, negateable node that's\n// not pre-negated at the top level. It also uses ASCII versions of `graph` and `print` for target\n// `ES2018` (which doesn't allow intersection) if `accuracy` isn't `strict`\nconst PosixClassesMap = new Map([\n  ['alnum', r`[\\p{Alpha}\\p{Nd}]`],\n  ['alpha', r`\\p{Alpha}`],\n  ['ascii', r`\\p{ASCII}`],\n  ['blank', r`[\\p{Zs}\\t]`],\n  ['cntrl', r`\\p{cntrl}`],\n  ['digit', r`\\p{Nd}`],\n  ['graph', r`[\\P{space}&&\\P{cntrl}&&\\P{Cn}&&\\P{Cs}]`],\n  ['lower', r`\\p{Lower}`],\n  ['print', r`[[\\P{space}&&\\P{cntrl}&&\\P{Cn}&&\\P{Cs}]\\p{Zs}]`],\n  ['punct', r`[\\p{P}\\p{S}]`], // New value from Oniguruma 6.9.9\n  ['space', r`\\p{space}`],\n  ['upper', r`\\p{Upper}`],\n  ['word', r`[\\p{Alpha}\\p{M}\\p{Nd}\\p{Pc}]`],\n  ['xdigit', r`\\p{AHex}`],\n]);\n\n// Apart from the property names provided by Unicode, Oniguruma explicitly adds several names (see\n// <github.com/kkos/oniguruma/blob/master/doc/RE>) that can be used within `\\p{}` and `\\P{}` (those\n// below). These should be listed here in lowercase, though they aren't case sensitive when used\nconst PosixProperties = new Set([\n  'alnum',\n  'blank',\n  'graph',\n  'print',\n  'word',\n  'xdigit',\n  // The following are available with the same name in JS (see `JsUnicodeProperties`), so can be\n  // handled as standard Unicode properties\n  // 'alpha', // (JS: Alpha)\n  // 'ascii', // (JS: ASCII)\n  // 'cntrl', // (JS: cntrl)\n  // 'digit', // (JS: digit)\n  // 'lower', // (JS: Lower)\n  // 'punct', // (JS: punct)\n  // 'space', // (JS: space)\n  // 'upper', // (JS: Upper)\n]);\n\nfunction range(start, end) {\n  // const range = Array.from(Array(end + 1 - start), (_, i) => i + start);\n  // const range = Array(end + 1 - start).fill(start).map((x, i) => x + i);\n  const range = [];\n  for (let i = start; i <= end; i++) {\n    range.push(i);\n  }\n  return range;\n}\n\n// Generates a Unicode property lookup name: lowercase, without spaces, hyphens, underscores\nfunction slug(name) {\n  return name.replace(/[- _]+/g, '').toLowerCase();\n}\n\nfunction titleEntry(codePoint) {\n  const char = cp(codePoint);\n  return [char.toLowerCase(), char];\n}\n\nfunction titleRange(start, end) {\n  return range(start, end).map(codePoint => titleEntry(codePoint));\n}\n\nconst UnicodePropertiesWithSpecificCase = new Set([\n  'Lower', 'Lowercase',\n  'Upper', 'Uppercase',\n  'Ll', 'Lowercase_Letter',\n  'Lt', 'Titlecase_Letter',\n  'Lu', 'Uppercase_Letter',\n  // The `Changes_When_*` properties (and their aliases) could be included, but they're very rare.\n  // Some other properties include a handful of chars with specific cases only, but these chars are\n  // generally extreme edge cases and using such properties case insensitively generally produces\n  // undesired behavior anyway\n]);\n\nexport {\n  getIgnoreCaseMatchChars,\n  JsUnicodeProperties,\n  JsUnicodePropertiesMap,\n  JsUnicodePropertiesOfStringsMap,\n  PosixClassesMap,\n  PosixProperties,\n  slug,\n  UnicodePropertiesWithSpecificCase,\n};\n", "import {PosixClassesMap} from './unicode.js';\nimport {r} from './utils.js';\n\nconst TokenTypes = /** @type {const} */ ({\n  Alternator: 'Alternator',\n  Assertion: 'Assertion',\n  Backreference: 'Backreference',\n  Character: 'Character',\n  CharacterClassClose: 'CharacterClassClose',\n  CharacterClassHyphen: 'CharacterClassHyphen',\n  CharacterClassIntersector: 'CharacterClassIntersector',\n  CharacterClassOpen: 'CharacterClassOpen',\n  CharacterSet: 'CharacterSet',\n  Directive: 'Directive',\n  GroupClose: 'GroupClose',\n  GroupOpen: 'GroupOpen',\n  Subroutine: 'Subroutine',\n  Quantifier: 'Quantifier',\n  // These aren't allowed in char classes, so they aren't equivalent to JS `[\\q{}]`\n  VariableLengthCharacterSet: 'VariableLengthCharacterSet',\n  // Intermediate representation not included in results\n  EscapedNumber: 'EscapedNumber',\n});\n\nconst TokenCharacterSetKinds = {\n  any: 'any',\n  digit: 'digit',\n  dot: 'dot',\n  hex: 'hex',\n  non_newline: 'non_newline',\n  posix: 'posix',\n  property: 'property',\n  space: 'space',\n  word: 'word',\n};\n\nconst TokenDirectiveKinds = {\n  flags: 'flags',\n  keep: 'keep',\n};\n\nconst TokenGroupKinds = {\n  absent_repeater: 'absent_repeater',\n  atomic: 'atomic',\n  capturing: 'capturing',\n  group: 'group',\n  lookahead: 'lookahead',\n  lookbehind: 'lookbehind',\n};\n\nconst EscapeCharCodes = new Map([\n  ['a',  7], // alert/bell (Not available in JS)\n  ['b',  8], // backspace (only in char classes)\n  ['e', 27], // escape (Not available in JS)\n  ['f', 12], // form feed\n  ['n', 10], // line feed\n  ['r', 13], // carriage return\n  ['t',  9], // horizontal tab\n  ['v', 11], // vertical tab\n]);\n\nconst charClassOpenPattern = r`\\[\\^?`;\nconst sharedEscapesPattern = `${\n  // Control char\n  'c.? | C(?:-.?)?'\n}|${\n  // Unicode property; Onig considers `\\p` an identity escape, but e.g. `\\p{`, `\\p{ ^L}`, and\n  // `\\p{gc=L}` are invalid\n  r`[pP]\\{(?:\\^?[-\\x20_]*[A-Za-z][-\\x20\\w]*\\})?`\n}|${\n  // Hex encoded byte sequence; attempt match before other `\\xNN` hex char\n  r`x[89A-Fa-f]\\p{AHex}(?:\\\\x[89A-Fa-f]\\p{AHex})*`\n}|${\n  // Hex char\n  r`u(?:\\p{AHex}{4})? | x\\{[^\\}]*\\}? | x\\p{AHex}{0,2}`\n}|${\n  // Enclosed octal code point\n  r`o\\{[^\\}]*\\}?`\n}|${\n  // Escaped number\n  r`\\d{1,3}`\n}`;\n// Even with flag x, Onig doesn't allow whitespace to separate a quantifier from the `?` or `+`\n// that makes it lazy or possessive. Possessive suffixes don't apply to interval quantifiers\nconst quantifierRe = /[?*+][?+]?|\\{(?:\\d+(?:,\\d*)?|,\\d+)\\}\\??/;\nconst tokenRe = new RegExp(r`\n  \\\\ (?:\n    ${sharedEscapesPattern}\n    | [gk]<[^>]*>?\n    | [gk]'[^']*'?\n    | .\n  )\n  | \\( (?:\n    \\? (?:\n      [:=!>({]\n      | <[=!]\n      | <[^>]*>\n      | '[^']*'\n      | ~\\|?\n      | #(?:[^)\\\\]|\\\\.?)*\n      | [^:)]*[:)]\n    )?\n    | \\*\n  )?\n  | ${quantifierRe.source}\n  | ${charClassOpenPattern}\n  | .\n`.replace(/\\s+/g, ''), 'gsu');\nconst charClassTokenRe = new RegExp(r`\n  \\\\ (?:\n    ${sharedEscapesPattern}\n    | .\n  )\n  | \\[:(?:\\^?\\p{Alpha}+|\\^):\\]\n  | ${charClassOpenPattern}\n  | &&\n  | .\n`.replace(/\\s+/g, ''), 'gsu');\n\n/**\n@typedef {{\n  type: keyof TokenTypes;\n  raw: string;\n  [key: string]: string | number | boolean;\n}} Token\n@typedef {{\n  tokens: Array<Token>;\n  flags: {\n    dotAll: boolean;\n    extended: boolean;\n    ignoreCase: boolean;\n  };\n  rules: {\n    captureGroup: boolean;\n    singleline: boolean;\n  };\n}} TokenizerResult\n*/\n/**\n@param {string} pattern Oniguruma pattern.\n@param {string} [flags] Oniguruma flags.\n@param {{\n  captureGroup?: boolean;\n  singleline?: boolean;\n}} [rules] Oniguruma compile-time options.\n@returns {TokenizerResult}\n*/\nfunction tokenize(pattern, flags = '', rules) {\n  rules = {\n    // `ONIG_OPTION_CAPTURE_GROUP`\n    captureGroup: false,\n    // `ONIG_OPTION_SINGLELINE`\n    singleline: false,\n    ...rules,\n  };\n  if (typeof pattern !== 'string') {\n    throw new Error('String expected as pattern');\n  }\n  if (!/^[imxDSW]*$/.test(flags)) {\n    throw new Error(`Flags \"${flags}\" includes unsupported value`);\n  }\n  const extended = flags.includes('x');\n  const xStack = [extended];\n  const context = {\n    captureGroup: rules.captureGroup,\n    getCurrentModX: () => xStack.at(-1),\n    numOpenGroups: 0,\n    popModX() {xStack.pop()},\n    pushModX(isXOn) {xStack.push(isXOn)},\n    replaceCurrentModX(isXOn) {xStack[xStack.length - 1] = isXOn},\n    singleline: rules.singleline,\n  };\n  let tokens = [];\n  let match;\n  tokenRe.lastIndex = 0;\n  while ((match = tokenRe.exec(pattern))) {\n    const result = getTokenWithDetails(context, pattern, match[0], tokenRe.lastIndex);\n    if (result.tokens) {\n      tokens.push(...result.tokens);\n    } else if (result.token) {\n      tokens.push(result.token);\n    }\n    if (result.lastIndex !== undefined) {\n      tokenRe.lastIndex = result.lastIndex;\n    }\n  }\n\n  const potentialUnnamedCaptureTokens = [];\n  let numNamedAndOptInUnnamedCaptures = 0;\n  tokens.forEach(t => {\n    if (t.type === TokenTypes.GroupOpen) {\n      if (t.kind === TokenGroupKinds.capturing) {\n        t.number = ++numNamedAndOptInUnnamedCaptures;\n      } else if (t.raw === '(') {\n        potentialUnnamedCaptureTokens.push(t);\n      }\n    }\n  });\n  // Enable unnamed capturing groups if no named captures (when `captureGroup` not enabled)\n  if (!numNamedAndOptInUnnamedCaptures) {\n    potentialUnnamedCaptureTokens.forEach((t, i) => {\n      t.kind = TokenGroupKinds.capturing;\n      t.number = i + 1;\n    });\n  }\n  const numCaptures = numNamedAndOptInUnnamedCaptures || potentialUnnamedCaptureTokens.length;\n  // Can now split escaped nums accurately, accounting for number of captures\n  tokens = tokens.map(\n    t => t.type === TokenTypes.EscapedNumber ? splitEscapedNumToken(t, numCaptures) : t\n  ).flat();\n\n  return {\n    tokens,\n    flags: {\n      ignoreCase: flags.includes('i'),\n      // Flag m is called `multiline` in Onig, but that has a different meaning in JS. Onig flag m\n      // is equivalent to JS flag s\n      dotAll: flags.includes('m'),\n      // Flag x is fully handled during tokenization\n      extended,\n      // Flags D, S, W are currently only supported as top-level flags\n      digitIsAscii: flags.includes('D'),\n      spaceIsAscii: flags.includes('S'),\n      wordIsAscii: flags.includes('W'),\n    },\n    rules,\n  };\n}\n\nfunction getTokenWithDetails(context, pattern, m, lastIndex) {\n  const [m0, m1] = m;\n\n  if (m0 === '[') {\n    const result = getAllTokensForCharClass(pattern, m, lastIndex);\n    return {\n      // Array of all of the char class's tokens\n      tokens: result.tokens,\n      // Jump forward to the end of the char class\n      lastIndex: result.lastIndex,\n    };\n  }\n\n  if (m0 === '\\\\') {\n    if ('AbBGzZ'.includes(m1)) {\n      return {\n        token: createToken(TokenTypes.Assertion, m, {\n          kind: m,\n        }),\n      };\n    }\n    if (/^\\\\g[<']/.test(m)) {\n      if (!/^\\\\g(?:<[^>]+>|'[^']+')$/.test(m)) {\n        throw new Error(`Invalid group name \"${m}\"`);\n      }\n      return {\n        token: createToken(TokenTypes.Subroutine, m),\n      };\n    }\n    if (/^\\\\k[<']/.test(m)) {\n      if (!/^\\\\k(?:<[^>]+>|'[^']+')$/.test(m)) {\n        throw new Error(`Invalid group name \"${m}\"`);\n      }\n      return {\n        token: createToken(TokenTypes.Backreference, m),\n      };\n    }\n    if (m1 === 'K') {\n      return {\n        token: createToken(TokenTypes.Directive, m, {\n          kind: TokenDirectiveKinds.keep,\n        }),\n      };\n    }\n    if (m1 === 'N') {\n      return {\n        token: createToken(TokenTypes.CharacterSet, m, {\n          kind: TokenCharacterSetKinds.non_newline,\n        }),\n      };\n    }\n    if (m1 === 'O') {\n      return {\n        token: createToken(TokenTypes.CharacterSet, m, {\n          kind: TokenCharacterSetKinds.any,\n        }),\n      };\n    }\n    if ('RX'.includes(m1)) {\n      return {\n        token: createToken(TokenTypes.VariableLengthCharacterSet, m, {\n          kind: m,\n        }),\n      };\n    }\n    // Grapheme boundaries not yet unsupported; avoid treating as an identity escape\n    if ('yY'.includes(m1)) {\n      throw new Error(`Unsupported grapheme boundary \"${m}\"`);\n    }\n    // Run last since it assumes an identity escape as final condition\n    const result = createTokenForSharedEscape(m, {inCharClass: false});\n    return Array.isArray(result) ? {tokens: result} : {token: result};\n  }\n\n  if (m0 === '(') {\n    if (m === '(*') {\n      throw new Error(`Unsupported named callout \"${m}\"`);\n    }\n    if (m === '(?{') {\n      throw new Error(`Unsupported callout \"${m}\"`);\n    }\n    // Comment group\n    if (m === '(?#') {\n      // The closing unescaped `)` isn't included in the match\n      if (pattern[lastIndex] !== ')') {\n        throw new Error('Unclosed comment group \"(?#\"');\n      }\n      return {\n        lastIndex: lastIndex + 1,\n      };\n    }\n    // Flag modifier (directive or group opener)\n    if (/^\\(\\?[-imx]+[:)]$/.test(m)) {\n      return {\n        token: createTokenForFlagMod(m, context),\n      };\n    }\n    // --- Remaining group types all reuse current flag x status ---\n    context.pushModX(context.getCurrentModX());\n    context.numOpenGroups++;\n    if (\n      // Unnamed capture if no named captures present and `captureGroup` not enabled, else\n      // noncapturing group\n      (m === '(' && !context.captureGroup) ||\n      // Noncapturing group\n      m === '(?:'\n    ) {\n      return {\n        token: createToken(TokenTypes.GroupOpen, m, {\n          // For `(`, will later change to `capturing` and add `number` prop if no named captures\n          kind: TokenGroupKinds.group,\n        }),\n      };\n    }\n    // Atomic group\n    if (m === '(?>') {\n      return {\n        token: createToken(TokenTypes.GroupOpen, m, {\n          kind: TokenGroupKinds.atomic,\n        }),\n      };\n    }\n    // Lookaround\n    if (m === '(?=' || m === '(?!' || m === '(?<=' || m === '(?<!') {\n      return {\n        token: createToken(TokenTypes.GroupOpen, m, {\n          kind: m[2] === '<' ? TokenGroupKinds.lookbehind : TokenGroupKinds.lookahead,\n          negate: m.endsWith('!'),\n        }),\n      };\n    }\n    // Unnamed capture when `captureGroup` enabled, or named capture (checked after lookbehind due\n    // to similar syntax)\n    if (\n      (m === '(' && context.captureGroup) ||\n      (m.startsWith('(?<') && m.endsWith('>')) ||\n      (m.startsWith(\"(?'\") && m.endsWith(\"'\"))\n    ) {\n      const token = createToken(TokenTypes.GroupOpen, m, {\n        kind: TokenGroupKinds.capturing,\n        // Will add `number` prop in a second pass\n      });\n      if (m !== '(') {\n        token.name = m.slice(3, -1);\n      }\n      return {\n        token,\n      };\n    }\n    if (m.startsWith('(?~')) {\n      if (m === '(?~|') {\n        throw new Error(`Unsupported absent function kind \"${m}\"`);\n      }\n      return {\n        token: createToken(TokenTypes.GroupOpen, m, {\n          kind: TokenGroupKinds.absent_repeater,\n        }),\n      };\n    }\n    if (m === '(?(') {\n      // Some forms are supportable; can be added\n      throw new Error(`Unsupported conditional \"${m}\"`);\n    }\n    throw new Error(`Invalid or unsupported group option \"${m}\"`);\n  }\n  if (m === ')') {\n    context.popModX();\n    context.numOpenGroups--;\n    if (context.numOpenGroups < 0) {\n      throw new Error('Unmatched \")\"');\n    }\n    return {\n      token: createToken(TokenTypes.GroupClose, m),\n    };\n  }\n\n  if (m === '#' && context.getCurrentModX()) {\n    // Onig's only line break char is line feed\n    const end = pattern.indexOf('\\n', lastIndex);\n    return {\n      // Jump forward to the end of the comment\n      lastIndex: end === -1 ? pattern.length : end,\n    };\n  }\n  if (/^\\s$/.test(m) && context.getCurrentModX()) {\n    const re = /\\s+/y;\n    re.lastIndex = lastIndex;\n    const rest = re.exec(pattern);\n    return {\n      // Jump forward to the end of the whitespace\n      lastIndex: rest ? re.lastIndex : lastIndex,\n    };\n  }\n\n  if (m === '.') {\n    return {\n      token: createToken(TokenTypes.CharacterSet, m, {\n        kind: TokenCharacterSetKinds.dot,\n      }),\n    };\n  }\n\n  if (m === '^' || m === '$') {\n    const kind = context.singleline ? {\n      '^': r`\\A`,\n      '$': r`\\Z`,\n    }[m] : m;\n    return {\n      token: createToken(TokenTypes.Assertion, m, {\n        kind,\n      }),\n    };\n  }\n\n  if (m === '|') {\n    return {\n      token: createToken(TokenTypes.Alternator, m),\n    };\n  }\n\n  if (quantifierRe.test(m)) {\n    return {\n      token: createTokenForQuantifier(m),\n    };\n  }\n\n  assertSingleCodePoint(m);\n  return {\n    token: createToken(TokenTypes.Character, m, {\n      value: m.codePointAt(0),\n    }),\n  };\n}\n\nfunction getAllTokensForCharClass(pattern, opener, lastIndex) {\n  const tokens = [createToken(TokenTypes.CharacterClassOpen, opener, {\n    negate: opener[1] === '^',\n  })];\n  let numCharClassesOpen = 1;\n  let match;\n  charClassTokenRe.lastIndex = lastIndex;\n  while ((match = charClassTokenRe.exec(pattern))) {\n    const m = match[0];\n    // Start of nested char class\n    // POSIX classes are handled as a single token; not as a nested char class\n    if (m[0] === '[' && m[1] !== ':') {\n      numCharClassesOpen++;\n      tokens.push(createToken(TokenTypes.CharacterClassOpen, m, {\n        negate: m[1] === '^',\n      }));\n    } else if (m === ']') {\n      if (tokens.at(-1).type === TokenTypes.CharacterClassOpen) {\n        // Allow unescaped `]` as leading char\n        tokens.push(createToken(TokenTypes.Character, m, {\n          value: 93,\n        }));\n      } else {\n        numCharClassesOpen--;\n        tokens.push(createToken(TokenTypes.CharacterClassClose, m));\n        if (!numCharClassesOpen) {\n          break;\n        }\n      }\n    } else {\n      const result = createTokenForAnyTokenWithinCharClass(m);\n      if (Array.isArray(result)) {\n        tokens.push(...result);\n      } else {\n        tokens.push(result);\n      }\n    }\n  }\n  return {\n    tokens,\n    lastIndex: charClassTokenRe.lastIndex || pattern.length,\n  }\n}\n\nfunction createTokenForAnyTokenWithinCharClass(raw) {\n  if (raw[0] === '\\\\') {\n    // Assumes an identity escape as final condition\n    return createTokenForSharedEscape(raw, {inCharClass: true});\n  }\n  // POSIX class: `[:name:]` or `[:^name:]`\n  if (raw[0] === '[') {\n    const posix = /\\[:(?<negate>\\^?)(?<name>[a-z]+):\\]/.exec(raw);\n    if (!posix || !PosixClassesMap.get(posix.groups.name)) {\n      throw new Error(`Invalid POSIX class \"${raw}\"`);\n    }\n    return createToken(TokenTypes.CharacterSet, raw, {\n      kind: TokenCharacterSetKinds.posix,\n      negate: !!posix.groups.negate,\n      value: posix.groups.name,\n    });\n  }\n  // Range (possibly invalid) or literal hyphen\n  if (raw === '-') {\n    return createToken(TokenTypes.CharacterClassHyphen, raw);\n  }\n  if (raw === '&&') {\n    return createToken(TokenTypes.CharacterClassIntersector, raw);\n  }\n  assertSingleCodePoint(raw);\n  return createToken(TokenTypes.Character, raw, {\n    value: raw.codePointAt(0),\n  });\n}\n\n// Tokens shared by base syntax and char class syntax that start with `\\`\nfunction createTokenForSharedEscape(raw, {inCharClass}) {\n  const char1 = raw[1];\n  if (char1 === 'c' || char1 === 'C') {\n    return createTokenForControlChar(raw);\n  }\n  if ('dDhHsSwW'.includes(char1)) {\n    return createTokenForShorthandCharClass(raw);\n  }\n  if (raw.startsWith(r`\\o{`)) {\n    throw new Error(`Incomplete, invalid, or unsupported octal code point \"${raw}\"`);\n  }\n  if (/^\\\\[pP]\\{/.test(raw)) {\n    if (raw.length === 3) {\n      throw new Error(`Incomplete or invalid Unicode property \"${raw}\"`);\n    }\n    return createTokenForUnicodeProperty(raw);\n  }\n  // Hex UTF-8 encoded byte sequence\n  if (/^\\\\x[89A-Fa-f]\\p{AHex}/u.test(raw)) {\n    try {\n      const bytes = raw.split(/\\\\x/).slice(1).map(hex => parseInt(hex, 16));\n      const decoded = new TextDecoder('utf-8', {\n        ignoreBOM: true,\n        fatal: true,\n      }).decode(new Uint8Array(bytes));\n      const encoder = new TextEncoder();\n      const tokens = [...decoded].map(char => {\n        // Since this regenerates `raw`, it might have different casing for hex A-F than the input\n        const raw = [...encoder.encode(char)].map(byte => `\\\\x${byte.toString(16)}`).join('');\n        return createToken(TokenTypes.Character, raw, {\n          value: char.codePointAt(0),\n        });\n      });\n      return tokens;\n    } catch {\n      throw new Error(`Multibyte code \"${raw}\" incomplete or invalid in Oniguruma`);\n    }\n  }\n  if (char1 === 'u' || char1 === 'x') {\n    return createToken(TokenTypes.Character, raw, {\n      value: getValidatedHexCharCode(raw),\n    });\n  }\n  if (EscapeCharCodes.has(char1)) {\n    return createToken(TokenTypes.Character, raw, {\n      value: EscapeCharCodes.get(char1),\n    });\n  }\n  // Escaped number: backref (possibly invalid), null, octal, or identity escape, possibly followed\n  // by 1-2 literal digits\n  if (/\\d/.test(char1)) {\n    return createToken(TokenTypes.EscapedNumber, raw, {\n      inCharClass,\n    });\n  }\n  if (raw === '\\\\') {\n    throw new Error(r`Incomplete escape \"\\\"`);\n  }\n  // Meta `\\M-x` and `\\M-\\C-x` are unsupported; avoid treating as an identity escape\n  if (char1 === 'M') {\n    // Supportable; see <github.com/kkos/oniguruma/blob/master/doc/SYNTAX.md#12-onig_syn_op2_esc_capital_m_bar_meta-enable-m-x>, <github.com/kkos/oniguruma/blob/43a8c3f3daf263091f3a74019d4b32ebb6417093/src/regparse.c#L4695>, <https://github.com/ammar/regexp_parser/blob/8851030feda68223d74f502335fb254a20d77016/lib/regexp_parser/expression/classes/escape_sequence.rb#L75>\n    throw new Error(`Unsupported meta \"${raw}\"`);\n  }\n  // Identity escape; count code point length\n  if ([...raw].length === 2) {\n    return createToken(TokenTypes.Character, raw, {\n      value: raw.codePointAt(1),\n    });\n  }\n  throw new Error(`Unexpected escape \"${raw}\"`);\n}\n\n/**\n@param {keyof TokenTypes} type\n@param {string} raw\n@param {{[key: string]: string | number | boolean;}} [data]\n@returns {Token}\n*/\nfunction createToken(type, raw, data) {\n  return {\n    type,\n    raw,\n    ...data,\n  };\n}\n\n// Expects `\\cx` or `\\C-x`\nfunction createTokenForControlChar(raw) {\n  const char = raw[1] === 'c' ? raw[2] : raw[3];\n  if (!char || !/[A-Za-z]/.test(char)) {\n    // Unlike JS, Onig allows any char to follow `\\c` or `\\C-`, but this is an extreme edge case\n    // Supportable; see <github.com/kkos/oniguruma/blob/master/doc/SYNTAX.md#11-onig_syn_op2_esc_capital_c_bar_control-enable-c-x>, <github.com/kkos/oniguruma/blob/43a8c3f3daf263091f3a74019d4b32ebb6417093/src/regparse.c#L4695>\n    throw new Error(`Unsupported control character \"${raw}\"`);\n  }\n  return createToken(TokenTypes.Character, raw, {\n    value: char.toUpperCase().codePointAt(0) - 64,\n  });\n}\n\nfunction createTokenForFlagMod(raw, context) {\n  // Allows multiple `-` and solo `-` without `on` or `off` flags\n  let {on, off} = /^\\(\\?(?<on>[imx]*)(?:-(?<off>[-imx]*))?/.exec(raw).groups;\n  off ??= '';\n  // Flag x is used directly by the tokenizer since it changes how to interpret the pattern\n  const isXOn = (context.getCurrentModX() || on.includes('x')) && !off.includes('x');\n  const enabledFlags = getFlagPropsForToken(on);\n  const disabledFlags = getFlagPropsForToken(off);\n  const flagChanges = {};\n  enabledFlags && (flagChanges.enable = enabledFlags);\n  disabledFlags && (flagChanges.disable = disabledFlags);\n  // Flag directive; ex: `(?im-x)`\n  if (raw.endsWith(')')) {\n    // Replace flag x value until the end of the current group\n    context.replaceCurrentModX(isXOn);\n    // Can't remove flag directives without flags like `(?-)`; they affect following quantifiers\n    return createToken(TokenTypes.Directive, raw, {\n      kind: TokenDirectiveKinds.flags,\n      flags: flagChanges,\n    });\n  }\n  // Flag group opener; ex: `(?im-x:`\n  if (raw.endsWith(':')) {\n    context.pushModX(isXOn);\n    context.numOpenGroups++;\n    const token = createToken(TokenTypes.GroupOpen, raw, {\n      kind: TokenGroupKinds.group,\n    });\n    if (enabledFlags || disabledFlags) {\n      token.flags = flagChanges;\n    }\n    return token;\n  }\n  throw new Error(`Unexpected flag modifier \"${raw}\"`);\n}\n\nfunction createTokenForQuantifier(raw) {\n  const data = {};\n  if (raw[0] === '{') {\n    const {min, max} = /^\\{(?<min>\\d*)(?:,(?<max>\\d*))?/.exec(raw).groups;\n    const limit = 100_000;\n    if (+min > limit || +max > limit) {\n      throw new Error('Quantifier value unsupported in Oniguruma');\n    }\n    data.min = +min;\n    data.max = max === undefined ? +min : (max === '' ? Infinity : +max);\n    data.greedy = !raw.endsWith('?');\n    // By default, Onig doesn't support making interval quantifiers possessive\n    data.possessive = false;\n  } else {\n    data.min = raw[0] === '+' ? 1 : 0;\n    data.max = raw[0] === '?' ? 1 : Infinity;\n    data.greedy = raw[1] !== '?';\n    data.possessive = raw[1] === '+';\n  }\n  return createToken(TokenTypes.Quantifier, raw, data);\n}\n\nfunction createTokenForShorthandCharClass(raw) {\n  const lower = raw[1].toLowerCase();\n  return createToken(TokenTypes.CharacterSet, raw, {\n    kind: {\n      'd': TokenCharacterSetKinds.digit,\n      'h': TokenCharacterSetKinds.hex, // Not available in JS\n      's': TokenCharacterSetKinds.space, // Different than JS\n      'w': TokenCharacterSetKinds.word,\n    }[lower],\n    negate: raw[1] !== lower,\n  });\n}\n\nfunction createTokenForUnicodeProperty(raw) {\n  const {p, neg, value} = /^\\\\(?<p>[pP])\\{(?<neg>\\^?)(?<value>[^}]+)/.exec(raw).groups;\n  const negate = (p === 'P' && !neg) || (p === 'p' && !!neg);\n  return createToken(TokenTypes.CharacterSet, raw, {\n    kind: TokenCharacterSetKinds.property,\n    negate,\n    value,\n  });\n}\n\nfunction getFlagPropsForToken(flags) {\n  // Don't include `false` for flags that aren't included\n  const obj = {};\n  if (flags.includes('i')) {\n    obj.ignoreCase = true;\n  }\n  if (flags.includes('m')) {\n    // Onig flag m is equivalent to JS flag s\n    obj.dotAll = true;\n  }\n  if (flags.includes('x')) {\n    obj.extended = true;\n  }\n  return Object.keys(obj).length ? obj : null;\n}\n\n// - Unenclosed `\\xNN` above 0x7F is handled elsewhere as a UTF-8 encoded byte sequence\n// - Enclosed `\\x{}` with value above 0x10FFFF is allowed here; handled in the parser\nfunction getValidatedHexCharCode(raw) {\n  // Note: Onig (tested 6.9.8) has a bug where bare `\\u` and `\\x` are identity escapes if they\n  // appear at the very end of the pattern, so e.g. `\\u` matches `u`, but `\\u0`, `\\u.`, and `[\\u]`\n  // are all errors, and `\\x.` and `[\\x]` aren't errors but instead the `\\x` is equivalent to `\\0`.\n  // Don't emulate these bugs (see #21), and just treat these cases as errors. Also, Onig treats\n  // incomplete `\\x{` (with the brace and not immediately followed by a hex digit) as an identity\n  // escape, so e.g. `\\x{` matches `x{` and `^\\x{,2}$` matches `xx`, but `\\x{2,}` and `\\x{0,2}` are\n  // errors. Don't emulate this pointless ambiguity; just treat incomplete `\\x{` as an error\n  if (/^(?:\\\\u(?!\\p{AHex}{4})|\\\\x(?!\\p{AHex}{1,2}|\\{\\p{AHex}{1,8}\\}))/u.test(raw)) {\n    throw new Error(`Incomplete or invalid escape \"${raw}\"`);\n  }\n  // Might include leading 0s\n  const hex = raw[2] === '{' ?\n    /^\\\\x\\{\\s*(?<hex>\\p{AHex}+)/u.exec(raw).groups.hex :\n    raw.slice(2);\n  const dec = parseInt(hex, 16);\n  return dec;\n}\n\n// Value is 1-3 digits, which can be a backref (possibly invalid), null, octal, or identity escape,\n// possibly followed by 1-2 literal digits\nfunction splitEscapedNumToken(token, numCaptures) {\n  const {raw, inCharClass} = token;\n  // Keep any leading 0s since they indicate octal\n  const value = raw.slice(1);\n  // Backref (possibly invalid)\n  if (\n    !inCharClass &&\n    ( // Single digit 1-9 outside a char class is always treated as a backref\n      (value !== '0' && value.length === 1) ||\n      // Leading 0 makes it octal; backrefs can't include following literal digits\n      (value[0] !== '0' && +value <= numCaptures)\n    )\n  ) {\n    return [createToken(TokenTypes.Backreference, raw)];\n  }\n  const tokens = [];\n  // Returns 1-3 matches; the first (only) might be octal\n  const matches = value.match(/^[0-7]+|\\d/g);\n  for (let i = 0; i < matches.length; i++) {\n    const m = matches[i];\n    let value;\n    // Octal digits are 0-7\n    if (i === 0 && m !== '8' && m !== '9') {\n      value = parseInt(m, 8);\n      if (value > 0o177) {\n        // Octal UTF-8 encoded byte sequence; not yet supported\n        throw new Error(r`Octal encoded byte above 177 unsupported \"${raw}\"`);\n      }\n    } else {\n      value = m.codePointAt(0);\n    }\n    tokens.push(createToken(TokenTypes.Character, (i === 0 ? '\\\\' : '') + m, {\n      value,\n    }));\n  }\n  return tokens;\n}\n\nfunction assertSingleCodePoint(raw) {\n  if ([...raw].length !== 1) {\n    throw new Error(`Expected \"${raw}\" to be a single code point`);\n  }\n}\n\nexport {\n  tokenize,\n  TokenCharacterSetKinds,\n  TokenDirectiveKinds,\n  TokenGroupKinds,\n  TokenTypes,\n};\n", "import {AstAssertionKinds, AstTypes} from './parse.js';\n\nfunction hasOnlyChild({alternatives}, kidFn) {\n  return (\n    alternatives.length === 1 &&\n    alternatives[0].elements.length === 1 &&\n    (!kidFn || kidFn(alternatives[0].elements[0]))\n  );\n}\n\nfunction isAlwaysZeroLength({type}) {\n  return type === AstTypes.Assertion || type === AstTypes.Directive;\n}\n\nfunction isAlwaysNonZeroLength(node) {\n  const types = [\n    AstTypes.Character,\n    AstTypes.CharacterClass,\n    AstTypes.CharacterSet,\n  ];\n  return types.includes(node.type) || (\n    node.type === AstTypes.Quantifier &&\n    node.min &&\n    types.includes(node.element.type)\n  );\n}\n\n// Consumptive groups add to the match.\n// - Includes: Capturing, named capturing, noncapturing, atomic, and flag groups.\n// - Excludes: Lookarounds.\n//   - Special case: Absent functions are consumptive (and negated, quantified) but are different\n//     in other ways so are excluded here.\n// See also `AstTypeAliases.AnyGroup`.\nfunction isConsumptiveGroup({type}) {\n  return type === AstTypes.CapturingGroup || type === AstTypes.Group;\n}\n\nfunction isLookaround({type, kind}) {\n  return (\n    type === AstTypes.Assertion &&\n    (kind === AstAssertionKinds.lookahead || kind === AstAssertionKinds.lookbehind)\n  );\n}\n\nexport {\n  hasOnlyChild,\n  isAlwaysNonZeroLength,\n  isAlwaysZeroLength,\n  isConsumptiveGroup,\n  isLookaround,\n};\n", "import {AstTypes} from './parse.js';\nimport {throwIfNot} from './utils.js';\nimport {isConsumptiveGroup, isLookaround} from './utils-ast.js';\n\nfunction traverse(path, state, visitor) {\n  let ast = path.node;\n  while (ast.parent) {\n    ast = ast.parent;\n  }\n  function traverseArray(array, parent) {\n    for (let i = 0; i < array.length; i++) {\n      const keyShift = traverseNode(array[i], parent, i, array);\n      i = Math.max(-1, i + keyShift);\n    }\n  }\n  function traverseNode(node, parent = null, key = null, container = null) {\n    let keyShift = 0;\n    let skipTraversingKidsOfPath = false;\n    const path = {\n      node,\n      parent,\n      key,\n      container,\n      ast,\n      remove() {\n        throwIfNot(container, 'Container expected').splice(Math.max(0, key + keyShift), 1);\n        keyShift -= 1;\n      },\n      removeAllNextSiblings() {\n        return throwIfNot(container, 'Container expected').splice(key + 1);\n      },\n      removeAllPrevSiblings() {\n        const shifted = key + keyShift;\n        keyShift -= shifted;\n        return throwIfNot(container, 'Container expected').splice(0, Math.max(0, shifted));\n      },\n      replaceWith(newNode) {\n        setParent(newNode, parent);\n        if (container) {\n          container[Math.max(0, key + keyShift)] = newNode;\n        } else {\n          parent[key] = newNode;\n        }\n      },\n      skip() {\n        skipTraversingKidsOfPath = true;\n      },\n    };\n    const visitorKey = getAstTypeAliases(node).find(key => !!visitor[key]);\n    const methods = visitorKey && visitor[visitorKey];\n    const enterFn = typeof methods === 'function' ? methods : methods?.enter;\n    const exitFn = methods?.exit;\n    enterFn?.(path, state);\n    if (!skipTraversingKidsOfPath) {\n      switch (node.type) {\n        case AstTypes.Regex:\n          traverseNode(node.pattern, node, 'pattern');\n          traverseNode(node.flags, node, 'flags');\n          break;\n        case AstTypes.Alternative:\n        case AstTypes.CharacterClass:\n          traverseArray(node.elements, node);\n          break;\n        case AstTypes.Assertion:\n          if (isLookaround(node)) {\n            traverseArray(node.alternatives, node);\n          }\n          break;\n        case AstTypes.Backreference:\n        case AstTypes.Character:\n        case AstTypes.CharacterSet:\n        case AstTypes.Directive:\n        case AstTypes.Flags:\n        case AstTypes.Recursion:\n        case AstTypes.Subroutine:\n        case AstTypes.VariableLengthCharacterSet:\n          break;\n        case AstTypes.AbsentFunction:\n        case AstTypes.CapturingGroup:\n        case AstTypes.Group:\n        case AstTypes.Pattern:\n          traverseArray(node.alternatives, node);\n          break;\n        case AstTypes.CharacterClassIntersection:\n          traverseArray(node.classes, node);\n          break;\n        case AstTypes.CharacterClassRange:\n          traverseNode(node.min, node, 'min');\n          traverseNode(node.max, node, 'max');\n          break;\n        case AstTypes.Quantifier:\n          traverseNode(node.element, node, 'element');\n          break;\n        default:\n          throw new Error(`Unexpected node type \"${node.type}\"`);\n      }\n    }\n    exitFn?.(path, state);\n    return keyShift;\n  }\n  traverseNode(path.node, path.parent, path.key, path.container);\n}\n\nconst AstTypeAliases = {\n  AnyGroup: 'AnyGroup',\n  AnyNode: 'AnyNode',\n};\n\nfunction getAstTypeAliases(node) {\n  const types = [AstTypeAliases.AnyNode];\n  if (isConsumptiveGroup(node) || isLookaround(node)) {\n    types.push(AstTypeAliases.AnyGroup);\n  }\n  types.push(node.type);\n  return types;\n}\n\nfunction setParent(node, parent) {\n  // The traverser can work with ASTs whose nodes include or don't include `parent` props, so only\n  // update the parent if a prop for it exists\n  if ('parent' in parent) {\n    node.parent = parent;\n  }\n}\n\nexport {\n  traverse,\n};\n", "import {TokenCharacterSetKinds, TokenDirectiveKinds, TokenGroupKinds, TokenTypes} from './tokenize.js';\nimport {traverse} from './traverse.js';\nimport {JsUnicodePropertiesMap, JsUnicodePropertiesOfStringsMap, PosixProperties, slug} from './unicode.js';\nimport {getOrInsert, r, throwIfNot} from './utils.js';\nimport {hasOnlyChild} from './utils-ast.js';\n\nconst AstTypes = {\n  AbsentFunction: 'AbsentFunction',\n  Alternative: 'Alternative',\n  Assertion: 'Assertion',\n  Backreference: 'Backreference',\n  CapturingGroup: 'CapturingGroup',\n  Character: 'Character',\n  CharacterClass: 'CharacterClass',\n  CharacterClassIntersection: 'CharacterClassIntersection',\n  CharacterClassRange: 'CharacterClassRange',\n  CharacterSet: 'CharacterSet',\n  Directive: 'Directive',\n  Flags: 'Flags',\n  Group: 'Group',\n  Pattern: 'Pattern',\n  Quantifier: 'Quantifier',\n  Regex: 'Regex',\n  Subroutine: 'Subroutine',\n  VariableLengthCharacterSet: 'VariableLengthCharacterSet',\n  // Used only by the transformer for Regex+ ASTs\n  Recursion: 'Recursion',\n};\n\nconst AstAbsentFunctionKinds = {\n  // See <github.com/slevithan/oniguruma-to-es/issues/13>\n  repeater: 'repeater',\n};\n\nconst AstAssertionKinds = {\n  line_end: 'line_end',\n  line_start: 'line_start',\n  lookahead: 'lookahead',\n  lookbehind: 'lookbehind',\n  search_start: 'search_start',\n  string_end: 'string_end',\n  string_end_newline: 'string_end_newline',\n  string_start: 'string_start',\n  word_boundary: 'word_boundary',\n};\n\n// Identical values\nconst AstCharacterSetKinds = TokenCharacterSetKinds;\nconst AstDirectiveKinds = TokenDirectiveKinds;\n\nconst AstVariableLengthCharacterSetKinds = {\n  grapheme: 'grapheme',\n  newline: 'newline',\n};\n\n/**\n@typedef {{\n  type: 'Regex';\n  parent: null;\n  pattern: Object;\n  flags: Object;\n}} OnigurumaAst\n*/\n/**\n@param {import('./tokenize.js').TokenizerResult} tokenizerResult\n@param {{\n  skipBackrefValidation?: boolean;\n  skipPropertyNameValidation?: boolean;\n  verbose?: boolean;\n}} [options]\n@returns {OnigurumaAst}\n*/\nfunction parse({tokens, flags, rules}, options) {\n  const opts = {\n    skipBackrefValidation: false,\n    skipLookbehindValidation: false,\n    skipPropertyNameValidation: false,\n    verbose: false,\n    ...options,\n  };\n  const context = {\n    capturingGroups: [],\n    current: 0,\n    hasNumberedRef: false,\n    namedGroupsByName: new Map(),\n    parent: null,\n    skipBackrefValidation: opts.skipBackrefValidation,\n    skipLookbehindValidation: opts.skipLookbehindValidation,\n    skipPropertyNameValidation: opts.skipPropertyNameValidation,\n    subroutines: [],\n    token: null,\n    tokens,\n    verbose: opts.verbose,\n    walk,\n  };\n  function walk(parent, state) {\n    const token = tokens[context.current];\n    context.parent = parent;\n    context.token = token;\n    // Advance for the next iteration\n    context.current++;\n    switch (token.type) {\n      case TokenTypes.Alternator:\n        // Top-level only; groups handle their own alternators\n        return createAlternative();\n      case TokenTypes.Assertion:\n        return createAssertionFromToken(token);\n      case TokenTypes.Backreference:\n        return parseBackreference(context);\n      case TokenTypes.Character:\n        return createCharacter(token.value, {useLastValid: !!state.isCheckingRangeEnd});\n      case TokenTypes.CharacterClassHyphen:\n        return parseCharacterClassHyphen(context, state);\n      case TokenTypes.CharacterClassOpen:\n        return parseCharacterClassOpen(context, state);\n      case TokenTypes.CharacterSet:\n        return parseCharacterSet(context);\n      case TokenTypes.Directive:\n        return createDirectiveFromToken(token);\n      case TokenTypes.GroupOpen:\n        return parseGroupOpen(context, state);\n      case TokenTypes.Quantifier:\n        return parseQuantifier(context);\n      case TokenTypes.Subroutine:\n        return parseSubroutine(context);\n      case TokenTypes.VariableLengthCharacterSet:\n        return createVariableLengthCharacterSet(token.kind);\n      default:\n        throw new Error(`Unexpected token type \"${token.type}\"`);\n    }\n  }\n  const ast = createRegex(createPattern(), createFlags(flags));\n  let top = ast.pattern.alternatives[0];\n  while (context.current < tokens.length) {\n    const node = walk(top, {});\n    if (node.type === AstTypes.Alternative) {\n      ast.pattern.alternatives.push(node);\n      top = node;\n    } else {\n      top.elements.push(node);\n    }\n  }\n  // `context` updated by preceding `walk` loop\n  const {capturingGroups, hasNumberedRef, namedGroupsByName, subroutines} = context;\n  // Validation that requires knowledge about the complete pattern\n  if (hasNumberedRef && namedGroupsByName.size && !rules.captureGroup) {\n    throw new Error('Numbered backref/subroutine not allowed when using named capture');\n  }\n  for (const {ref} of subroutines) {\n    if (typeof ref === 'number') {\n      // Relative nums are already resolved\n      if (ref > capturingGroups.length) {\n        throw new Error(`Subroutine uses a group number that's not defined`);\n      }\n    } else if (!namedGroupsByName.has(ref)) {\n      throw new Error(r`Subroutine uses a group name that's not defined \"\\g<${ref}>\"`);\n    } else if (namedGroupsByName.get(ref).length > 1) {\n      throw new Error(r`Subroutine uses a duplicate group name \"\\g<${ref}>\"`);\n    }\n  }\n  // Add `parent` properties now that we have a final AST\n  traverse({node: ast}, null, {\n    AnyNode({node, parent}) {\n      node.parent = parent;\n    },\n  });\n  return ast;\n}\n\n// Supported (if the backref appears to the right of the reffed capture's opening paren):\n// - `\\k<name>`, `\\k'name'`\n// - When named capture not used:\n//   - `\\n`, `\\nn`, `\\nnn`\n//   - `\\k<n>`, `\\k'n'\n//   - `\\k<-n>`, `\\k'-n'`\n// Unsupported:\n// - `\\k<+n>`, `\\k'+n'` - Note that, Unlike Oniguruma, Onigmo doesn't support this as special\n//   syntax and therefore considers it a valid group name.\n// - Backref with recursion level (with num or name): `\\k<n+level>`, `\\k<n-level>`, etc.\n//   (Onigmo also supports `\\k<-n+level>`, `\\k<-n-level>`, etc.)\n// Backrefs in Onig use multiplexing for duplicate group names (the rules can be complicated when\n// overlapping with subroutines), but a `Backreference`'s simple `ref` prop doesn't capture these\n// details so multiplexed ref pointers need to be derived when working with the AST\nfunction parseBackreference(context) {\n  const {raw} = context.token;\n  const hasKWrapper = /^\\\\k[<']/.test(raw);\n  const ref = hasKWrapper ? raw.slice(3, -1) : raw.slice(1);\n  const fromNum = (num, isRelative = false) => {\n    const numCapturesToLeft = context.capturingGroups.length;\n    let orphan = false;\n    // Note: It's not an error for numbered backrefs to come before their referenced group in Onig,\n    // but an error is the best path for this library because:\n    // 1. Most placements are mistakes and can never match (based on the Onig behavior for backrefs\n    //    to nonparticipating groups).\n    // 2. Erroring matches the behavior of named backrefs.\n    // 3. The edge cases where they're matchable rely on rules for backref resetting within\n    //    quantified groups that are different in JS and aren't emulatable. Note that it's not a\n    //    backref in the first place if using `\\10` or higher and not as many capturing groups are\n    //    defined to the left (it's an octal or identity escape).\n    // [TODO] Ideally this would be refactored to include the backref in the AST when it's not an\n    // error in Onig (due to the reffed group being defined to the right), and the error handling\n    // would move to the transformer\n    if (num > numCapturesToLeft) {\n      // [WARNING] Skipping the error breaks assumptions and might create edge case issues, since\n      // backrefs are required to come after their captures; unfortunately this option is needed\n      // for TextMate grammars\n      if (context.skipBackrefValidation) {\n        orphan = true;\n      } else {\n        throw new Error(`Not enough capturing groups defined to the left \"${raw}\"`);\n      }\n    }\n    context.hasNumberedRef = true;\n    return createBackreference(isRelative ? numCapturesToLeft + 1 - num : num, {orphan});\n  };\n  if (hasKWrapper) {\n    const numberedRef = /^(?<sign>-?)0*(?<num>[1-9]\\d*)$/.exec(ref);\n    if (numberedRef) {\n      return fromNum(+numberedRef.groups.num, !!numberedRef.groups.sign);\n    }\n    // Invalid in a backref name even when valid in a group name\n    if (/[-+]/.test(ref)) {\n      throw new Error(`Invalid backref name \"${raw}\"`);\n    }\n    if (!context.namedGroupsByName.has(ref)) {\n      throw new Error(`Group name not defined to the left \"${raw}\"`);\n    }\n    return createBackreference(ref);\n  }\n  return fromNum(+ref);\n}\n\nfunction parseCharacterClassHyphen(context, state) {\n  const {parent, tokens, walk} = context;\n  const prevSiblingNode = parent.elements.at(-1);\n  const nextToken = tokens[context.current];\n  if (\n    !state.isCheckingRangeEnd &&\n    prevSiblingNode &&\n    prevSiblingNode.type !== AstTypes.CharacterClass &&\n    prevSiblingNode.type !== AstTypes.CharacterClassRange &&\n    nextToken &&\n    nextToken.type !== TokenTypes.CharacterClassOpen &&\n    nextToken.type !== TokenTypes.CharacterClassClose &&\n    nextToken.type !== TokenTypes.CharacterClassIntersector\n  ) {\n    const nextNode = walk(parent, {\n      ...state,\n      isCheckingRangeEnd: true,\n    });\n    if (prevSiblingNode.type === AstTypes.Character && nextNode.type === AstTypes.Character) {\n      parent.elements.pop();\n      return createCharacterClassRange(prevSiblingNode, nextNode);\n    }\n    throw new Error('Invalid character class range');\n  }\n  // Literal hyphen\n  return createCharacter(45);\n}\n\nfunction parseCharacterClassOpen(context, state) {\n  const {token, tokens, verbose, walk} = context;\n  const firstClassToken = tokens[context.current];\n  let node = createCharacterClass({negate: token.negate});\n  const intersection = node.elements[0];\n  let nextToken = throwIfUnclosedCharacterClass(firstClassToken);\n  while (nextToken.type !== TokenTypes.CharacterClassClose) {\n    if (nextToken.type === TokenTypes.CharacterClassIntersector) {\n      intersection.classes.push(createCharacterClass({negate: false, baseOnly: true}));\n      // Skip the intersector\n      context.current++;\n    } else {\n      const cc = intersection.classes.at(-1);\n      cc.elements.push(walk(cc, state));\n    }\n    nextToken = throwIfUnclosedCharacterClass(tokens[context.current], firstClassToken);\n  }\n  if (!verbose) {\n    optimizeCharacterClassIntersection(intersection);\n  }\n  // Simplify tree if we don't need the intersection wrapper\n  if (intersection.classes.length === 1) {\n    const cc = intersection.classes[0];\n    // Only needed if `!verbose`; otherwise an intersection's direct kids are never negated\n    cc.negate = node.negate !== cc.negate;\n    node = cc;\n  }\n  // Skip the closing square bracket\n  context.current++;\n  return node;\n}\n\nfunction parseCharacterSet({token, skipPropertyNameValidation}) {\n  let {kind, negate, value} = token;\n  if (kind === TokenCharacterSetKinds.property) {\n    const normalized = slug(value);\n    if (PosixProperties.has(normalized)) {\n      kind = TokenCharacterSetKinds.posix;\n      value = normalized;\n    } else {\n      return createUnicodeProperty(value, {\n        negate,\n        skipPropertyNameValidation,\n      });\n    }\n  }\n  if (kind === TokenCharacterSetKinds.posix) {\n    return {\n      type: AstTypes.CharacterSet,\n      kind: AstCharacterSetKinds.posix,\n      negate,\n      value,\n    };\n  }\n  return createCharacterSet(kind, {negate});\n}\n\nfunction parseGroupOpen(context, state) {\n  const {token, tokens, capturingGroups, namedGroupsByName, skipLookbehindValidation, verbose, walk} = context;\n  let node = createByGroupKind(token);\n  const isAbsentFunction = node.type === AstTypes.AbsentFunction;\n  const isLookbehind = node.kind === AstAssertionKinds.lookbehind;\n  const isNegLookbehind = isLookbehind && node.negate;\n  // Track capturing group details for backrefs and subroutines (before parsing the group's\n  // contents so nested groups with the same name are tracked in order)\n  if (node.type === AstTypes.CapturingGroup) {\n    capturingGroups.push(node);\n    if (node.name) {\n      getOrInsert(namedGroupsByName, node.name, []).push(node);\n    }\n  }\n  // Don't allow nested absent functions\n  if (isAbsentFunction && state.isInAbsentFunction) {\n    // Is officially unsupported in Onig but doesn't throw, gives strange results\n    throw new Error('Nested absent function not supported by Oniguruma');\n  }\n  let nextToken = throwIfUnclosedGroup(tokens[context.current]);\n  while (nextToken.type !== TokenTypes.GroupClose) {\n    if (nextToken.type === TokenTypes.Alternator) {\n      node.alternatives.push(createAlternative());\n      // Skip the alternator\n      context.current++;\n    } else {\n      const alt = node.alternatives.at(-1);\n      const child = walk(alt, {\n        ...state,\n        isInAbsentFunction: state.isInAbsentFunction || isAbsentFunction,\n        isInLookbehind: state.isInLookbehind || isLookbehind,\n        isInNegLookbehind: state.isInNegLookbehind || isNegLookbehind,\n      });\n      alt.elements.push(child);\n      // Centralized validation of lookbehind contents\n      if ((isLookbehind || state.isInLookbehind) && !skipLookbehindValidation) {\n        // JS supports all features within lookbehind, but Onig doesn't. Absent functions of form\n        // `(?~|)` and `(?~|\u2026)` are also invalid in lookbehind (the `(?~\u2026)` and `(?~|\u2026|\u2026)` forms\n        // are allowed), but all forms with `(?~|` throw since they aren't yet supported\n        const msg = 'Lookbehind includes a pattern not allowed by Oniguruma';\n        if (isNegLookbehind || state.isInNegLookbehind) {\n          // - Invalid: `(?=\u2026)`, `(?!\u2026)`, capturing groups\n          // - Valid: `(?<=\u2026)`, `(?<!\u2026)`\n          if (child.kind === AstAssertionKinds.lookahead || child.type === AstTypes.CapturingGroup) {\n            throw new Error(msg);\n          }\n        } else {\n          // - Invalid: `(?=\u2026)`, `(?!\u2026)`, `(?<!\u2026)`\n          // - Valid: `(?<=\u2026)`, capturing groups\n          if (child.kind === AstAssertionKinds.lookahead || (child.kind === AstAssertionKinds.lookbehind && child.negate)) {\n            throw new Error(msg);\n          }\n        }\n      }\n    }\n    nextToken = throwIfUnclosedGroup(tokens[context.current]);\n  }\n  if (!verbose) {\n    node = getOptimizedGroup(node);\n  }\n  // Skip the closing parenthesis\n  context.current++;\n  return node;\n}\n\nfunction parseQuantifier({token, parent}) {\n  const {min, max, greedy, possessive} = token;\n  const quantifiedNode = parent.elements.at(-1);\n  if (\n    !quantifiedNode ||\n    quantifiedNode.type === AstTypes.Assertion ||\n    quantifiedNode.type === AstTypes.Directive\n  ) {\n    throw new Error(`Quantifier requires a repeatable token`);\n  }\n  const node = createQuantifier(quantifiedNode, min, max, greedy, possessive);\n  parent.elements.pop();\n  return node;\n}\n\n// Onig subroutine behavior:\n// - Subroutines can appear before the groups they reference; ex: `\\g<1>(a)` is valid.\n// - Multiple subroutines can reference the same group.\n// - Subroutines can reference groups that themselves contain subroutines, followed to any depth.\n// - Subroutines can be used recursively, and `\\g<0>` recursively references the whole pattern.\n// - Subroutines can use relative references (backward or forward); ex: `\\g<+1>(.)\\g<-1>`.\n// - Subroutines don't get their own capturing group numbers; ex: `(.)\\g<1>\\2` is invalid.\n// - Subroutines use the flags that apply to their referenced group, so e.g.\n//   `(?-i)(?<a>a)(?i)\\g<a>` is fully case sensitive.\n// - Differences from PCRE/Perl/Regex+ subroutines:\n//   - Subroutines can't reference duplicate group names (though duplicate names are valid if no\n//     subroutines reference them).\n//   - Subroutines can't use absolute or relative numbers if named capture is used anywhere.\n//   - Named backrefs must be to the right of their group definition, so the backref in\n//     `\\g<a>\\k<a>(?<a>)` is invalid (not directly related to subroutines).\n//   - Subroutines don't restore capturing group match values (for backrefs) upon exit, so e.g.\n//     `(?<a>(?<b>[ab]))\\g<a>\\k<b>` matches `abb` but not `aba`; same for numbered.\n// The interaction of backref multiplexing (an Onig-specific feature) and subroutines is complex:\n// - Only the most recent value matched by a capturing group and its subroutines is considered for\n//   backref multiplexing, and this also applies to capturing groups nested within a group that's\n//   referenced by a subroutine.\n// - Although a subroutine can't reference a group with a duplicate name, it can reference a group\n//   with a nested capture whose name is duplicated (e.g. outside of the referenced group).\n//   - These duplicate names can then multiplex; but only the most recent value matched from within\n//     the outer group (or the subroutines that reference it) is available for multiplexing.\n//   - Ex: With `(?<a>(?<b>[123]))\\g<a>\\g<a>(?<b>0)\\k<b>`, the backref `\\k<b>` can only match `0`\n//     or whatever was matched by the most recently matched subroutine. If you took out `(?<b>0)`,\n//     no multiplexing would occur.\nfunction parseSubroutine(context) {\n  const {token, capturingGroups, subroutines} = context;\n  let ref = token.raw.slice(3, -1);\n  const numberedRef = /^(?<sign>[-+]?)0*(?<num>[1-9]\\d*)$/.exec(ref);\n  if (numberedRef) {\n    const num = +numberedRef.groups.num;\n    const numCapturesToLeft = capturingGroups.length;\n    context.hasNumberedRef = true;\n    ref = {\n      '': num,\n      '+': numCapturesToLeft + num,\n      '-': numCapturesToLeft + 1 - num,\n    }[numberedRef.groups.sign];\n    if (ref < 1) {\n      throw new Error('Invalid subroutine number');\n    }\n  // Special case for full-pattern recursion; can't be `+0`, `-0`, `00`, etc.\n  } else if (ref === '0') {\n    ref = 0;\n  }\n  const node = createSubroutine(ref);\n  subroutines.push(node);\n  return node;\n}\n\nfunction createAbsentFunction(kind) {\n  if (kind !== AstAbsentFunctionKinds.repeater) {\n    throw new Error(`Unexpected absent function kind \"${kind}\"`);\n  }\n  return {\n    type: AstTypes.AbsentFunction,\n    kind,\n    alternatives: [createAlternative()],\n  };\n}\n\nfunction createAlternative() {\n  return {\n    type: AstTypes.Alternative,\n    elements: [],\n  };\n}\n\nfunction createAssertion(kind, options) {\n  // Use `createLookaround` for lookahead and lookbehind assertions\n  const negate = !!options?.negate;\n  return {\n    type: AstTypes.Assertion,\n    kind,\n    ...(kind === AstAssertionKinds.word_boundary && {negate}),\n  };\n}\n\nfunction createAssertionFromToken({kind}) {\n  return createAssertion(\n    throwIfNot({\n      '^': AstAssertionKinds.line_start,\n      '$': AstAssertionKinds.line_end,\n      '\\\\A': AstAssertionKinds.string_start,\n      '\\\\b': AstAssertionKinds.word_boundary,\n      '\\\\B': AstAssertionKinds.word_boundary,\n      '\\\\G': AstAssertionKinds.search_start,\n      '\\\\z': AstAssertionKinds.string_end,\n      '\\\\Z': AstAssertionKinds.string_end_newline,\n    }[kind], `Unexpected assertion kind \"${kind}\"`),\n    {negate: kind === r`\\B`}\n  );\n}\n\nfunction createBackreference(ref, options) {\n  const orphan = !!options?.orphan;\n  return {\n    type: AstTypes.Backreference,\n    ...(orphan && {orphan}),\n    ref,\n  };\n}\n\nfunction createByGroupKind({flags, kind, name, negate, number}) {\n  switch (kind) {\n    case TokenGroupKinds.absent_repeater:\n      return createAbsentFunction(AstAbsentFunctionKinds.repeater);\n    case TokenGroupKinds.atomic:\n      return createGroup({atomic: true});\n    case TokenGroupKinds.capturing:\n      return createCapturingGroup(number, name);\n    case TokenGroupKinds.group:\n      return createGroup({flags});\n    case TokenGroupKinds.lookahead:\n    case TokenGroupKinds.lookbehind:\n      return createLookaround({\n        behind: kind === TokenGroupKinds.lookbehind,\n        negate,\n      });\n    default:\n      throw new Error(`Unexpected group kind \"${kind}\"`);\n  }\n}\n\nfunction createCapturingGroup(number, name) {\n  const hasName = name !== undefined;\n  if (hasName && !isValidGroupNameOniguruma(name)) {\n    throw new Error(`Group name \"${name}\" invalid in Oniguruma`);\n  }\n  return {\n    type: AstTypes.CapturingGroup,\n    number,\n    ...(hasName && {name}),\n    alternatives: [createAlternative()],\n  };\n}\n\nfunction createCharacter(charCode, options) {\n  const opts = {\n    useLastValid: false,\n    ...options,\n  };\n  if (charCode > 0x10FFFF) {\n    const hex = charCode.toString(16);\n    if (opts.useLastValid) {\n      charCode = 0x10FFFF;\n    } else if (charCode > 0x13FFFF) {\n      throw new Error(`Invalid code point out of range \"\\\\x{${hex}}\"`);\n    } else {\n      throw new Error(`Invalid code point out of range in JS \"\\\\x{${hex}}\"`);\n    }\n  }\n  return {\n    type: AstTypes.Character,\n    value: charCode,\n  };\n}\n\nfunction createCharacterClass(options) {\n  const opts = {\n    baseOnly: false,\n    negate: false,\n    ...options,\n  };\n  return {\n    type: AstTypes.CharacterClass,\n    negate: opts.negate,\n    elements: opts.baseOnly ? [] : [createCharacterClassIntersection()],\n  };\n}\n\nfunction createCharacterClassIntersection() {\n  return {\n    type: AstTypes.CharacterClassIntersection,\n    classes: [createCharacterClass({negate: false, baseOnly: true})],\n  };\n}\n\nfunction createCharacterClassRange(min, max) {\n  if (max.value < min.value) {\n    throw new Error('Character class range out of order');\n  }\n  return {\n    type: AstTypes.CharacterClassRange,\n    min,\n    max,\n  };\n}\n\nfunction createCharacterSet(kind, {negate}) {\n  const node = {\n    type: AstTypes.CharacterSet,\n    kind: throwIfNot(AstCharacterSetKinds[kind], `Unexpected character set kind \"${kind}\"`),\n  };\n  if (\n    kind === TokenCharacterSetKinds.digit ||\n    kind === TokenCharacterSetKinds.hex ||\n    kind === TokenCharacterSetKinds.space ||\n    kind === TokenCharacterSetKinds.word\n  ) {\n    node.negate = negate;\n  }\n  return node;\n}\n\nfunction createDirectiveFromToken({kind, flags}) {\n  const node = {\n    type: AstTypes.Directive,\n    kind: throwIfNot(AstDirectiveKinds[kind], `Unexpected directive kind \"${kind}\"`),\n  };\n  // Can't optimize by simply creating a `Group` with a `flags` prop and wrapping the remainder of\n  // the open group or pattern in it, because the flag modifier's effect might extend across\n  // alternation. Ex: `a(?i)b|c` is equivalent to `a(?i:b)|(?i:c)`, not `a(?i:b|c)`\n  if (kind === TokenDirectiveKinds.flags) {\n    node.flags = flags;\n  }\n  return node;\n}\n\nfunction createFlags({ignoreCase, dotAll, extended, digitIsAscii, spaceIsAscii, wordIsAscii}) {\n  return {\n    type: AstTypes.Flags,\n    ignoreCase,\n    dotAll,\n    extended,\n    digitIsAscii,\n    spaceIsAscii,\n    wordIsAscii,\n  };\n}\n\nfunction createGroup(options) {\n  const atomic = options?.atomic;\n  const flags = options?.flags;\n  return {\n    type: AstTypes.Group,\n    ...(atomic && {atomic}),\n    ...(flags && {flags}),\n    alternatives: [createAlternative()],\n  };\n}\n\nfunction createLookaround(options) {\n  const opts = {\n    behind: false,\n    negate: false,\n    ...options,\n  };\n  return {\n    type: AstTypes.Assertion,\n    kind: opts.behind ? AstAssertionKinds.lookbehind : AstAssertionKinds.lookahead,\n    negate: opts.negate,\n    alternatives: [createAlternative()],\n  };\n}\n\nfunction createPattern() {\n  return {\n    type: AstTypes.Pattern,\n    alternatives: [createAlternative()],\n  };\n}\n\nfunction createQuantifier(element, min, max, greedy = true, possessive = false) {\n  const node = {\n    type: AstTypes.Quantifier,\n    min,\n    max,\n    greedy,\n    possessive,\n    element,\n  };\n  if (max < min) {\n    return {\n      ...node,\n      min: max,\n      max: min,\n      possessive: true,\n    };\n  }\n  return node;\n}\n\nfunction createRegex(pattern, flags) {\n  return {\n    type: AstTypes.Regex,\n    pattern,\n    flags,\n  };\n}\n\nfunction createSubroutine(ref) {\n  return {\n    type: AstTypes.Subroutine,\n    ref,\n  };\n}\n\nfunction createUnicodeProperty(value, options) {\n  const opts = {\n    negate: false,\n    skipPropertyNameValidation: false,\n    ...options,\n  };\n  return {\n    type: AstTypes.CharacterSet,\n    kind: AstCharacterSetKinds.property,\n    value: opts.skipPropertyNameValidation ? value : getJsUnicodePropertyName(value),\n    negate: opts.negate,\n  }\n}\n\nfunction createVariableLengthCharacterSet(kind) {\n  return {\n    type: AstTypes.VariableLengthCharacterSet,\n    kind: throwIfNot({\n      '\\\\R': AstVariableLengthCharacterSetKinds.newline,\n      '\\\\X': AstVariableLengthCharacterSetKinds.grapheme,\n    }[kind], `Unexpected varcharset kind \"${kind}\"`),\n  };\n}\n\n// Unlike Onig, JS Unicode property names are case sensitive, don't ignore spaces, hyphens, and\n// underscores, and require underscores in specific positions\nfunction getJsUnicodePropertyName(value) {\n  const slugged = slug(value);\n  if (JsUnicodePropertiesOfStringsMap.has(slugged)) {\n    // Variable-length properties of strings aren't supported by Onig\n    throw new Error(r`Unicode property \"\\p{${value}}\" unsupported in Oniguruma`);\n  }\n  const jsName = JsUnicodePropertiesMap.get(slugged);\n  if (jsName) {\n    return jsName;\n  }\n  // Assume it's a script name (avoids including heavyweight data for long list of script names);\n  // JS requires formatting `Like_This`, so use best effort to reformat the name (covers a lot, but\n  // isn't able to map for all possible formatting differences)\n  return value.\n    trim().\n    replace(/[- _]+/g, '_').\n    replace(/[A-Z][a-z]+(?=[A-Z])/g, '$&_'). // `PropertyName` to `Property_Name`\n    replace(/[A-Za-z]+/g, m => m[0].toUpperCase() + m.slice(1).toLowerCase());\n}\n\n// If a direct child group is needlessly nested, return it instead (after modifying it)\nfunction getOptimizedGroup(node) {\n  const firstAltFirstEl = node.alternatives[0].elements[0];\n  if (\n    node.type === AstTypes.Group &&\n    hasOnlyChild(node, kid => kid.type === AstTypes.Group) &&\n    !(node.atomic && firstAltFirstEl.flags) &&\n    !(node.flags && (firstAltFirstEl.atomic || firstAltFirstEl.flags))\n  ) {\n    if (node.atomic) {\n      firstAltFirstEl.atomic = true;\n    } else if (node.flags) {\n      firstAltFirstEl.flags = node.flags;\n    }\n    return firstAltFirstEl;\n  }\n  return node;\n}\n\nfunction isValidGroupNameOniguruma(name) {\n  // The more restrictive rules for valid JS group names are captured in `isValidGroupNameJs`. Note\n  // that backrefs and subroutines might contextually use `-` and `+` to indicate relative index or\n  // recursion level\n  return /^[\\p{Alpha}\\p{Pc}][^)]*$/u.test(name);\n}\n\n// For any intersection classes that contain only a class, swap the parent with its (modded) child\nfunction optimizeCharacterClassIntersection(intersection) {\n  for (let i = 0; i < intersection.classes.length; i++) {\n    const cc = intersection.classes[i];\n    const firstChild = cc.elements[0];\n    if (cc.elements.length === 1 && firstChild.type === AstTypes.CharacterClass) {\n      intersection.classes[i] = firstChild;\n      firstChild.negate = cc.negate !== firstChild.negate;\n    }\n  }\n}\n\nfunction throwIfUnclosedCharacterClass(token, firstClassToken) {\n  return throwIfNot(\n    token,\n    // Easier to understand error when applicable\n    `${firstClassToken?.value === 93 ? 'Empty' : 'Unclosed'} character class`\n  );\n}\n\nfunction throwIfUnclosedGroup(token) {\n  return throwIfNot(token, 'Unclosed group');\n}\n\nexport {\n  AstAbsentFunctionKinds,\n  AstAssertionKinds,\n  AstCharacterSetKinds,\n  AstDirectiveKinds,\n  AstTypes,\n  AstVariableLengthCharacterSetKinds,\n  createAbsentFunction,\n  createAlternative,\n  createAssertion,\n  createBackreference,\n  createCapturingGroup,\n  createCharacter,\n  createCharacterClass,\n  createCharacterClassIntersection,\n  createCharacterClassRange,\n  createCharacterSet,\n  createFlags,\n  createGroup,\n  createLookaround,\n  createPattern,\n  createQuantifier,\n  createRegex,\n  createSubroutine,\n  createUnicodeProperty,\n  createVariableLengthCharacterSet,\n  parse,\n};\n", "const r = String.raw;\nconst seq = r`(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation})`;\nconst sTags = r`\\u{E0061}-\\u{E007A}`;\nexport default () => new RegExp(r`[\\u{1F1E6}-\\u{1F1FF}]{2}|\\u{1F3F4}[${sTags}]{2}[\\u{E0030}-\\u{E0039}${sTags}]{1,3}\\u{E007F}|${seq}(?:\\u200D${seq})*`, 'gu');\n", "import {Accuracy, Target} from './options.js';\nimport {AstAssertionKinds, AstCharacterSetKinds, AstDirectiveKinds, AstTypes, AstVariableLengthCharacterSetKinds, createAlternative, createAssertion, createBackreference, createCapturingGroup, createCharacterSet, createGroup, createLookaround, createQuantifier, createUnicodeProperty, parse} from './parse.js';\nimport {tokenize} from './tokenize.js';\nimport {traverse} from './traverse.js';\nimport {JsUnicodeProperties, PosixClassesMap} from './unicode.js';\nimport {cp, getNewCurrentFlags, getOrInsert, isMinTarget, r} from './utils.js';\nimport {hasOnlyChild, isAlwaysNonZeroLength, isAlwaysZeroLength, isConsumptiveGroup, isLookaround} from './utils-ast.js';\nimport emojiRegex from 'emoji-regex-xs';\n\n/**\n@typedef {{\n  type: 'Regex';\n  parent: null;\n  pattern: Object;\n  flags: Object;\n  options: Object;\n  _originMap: Map<Object, Object>;\n  _strategy: string?;\n}} RegexAst\n*/\n/**\nTransforms an Oniguruma AST in-place to a [Regex+](https://github.com/slevithan/regex) AST.\nAssumes target ES2025, expecting the generator to down-convert to the desired JS target version.\n\nRegex+'s syntax and behavior is a strict superset of native JavaScript, so the AST is very close\nto representing native ES2025 `RegExp` but with some added features (atomic groups, possessive\nquantifiers, recursion). The AST doesn't use some of Regex+'s extended features like flag x or\nsubroutines because they follow PCRE behavior and work somewhat differently than in Oniguruma. The\nAST represents what's needed to precisely reproduce Oniguruma behavior using Regex+.\n@param {import('./parse.js').OnigurumaAst} ast\n@param {{\n  accuracy?: keyof Accuracy;\n  asciiWordBoundaries?: boolean;\n  avoidSubclass?: boolean;\n  bestEffortTarget?: keyof Target;\n}} [options]\n@returns {RegexAst}\n*/\nfunction transform(ast, options) {\n  const opts = {\n    // A couple edge cases exist where options `accuracy` and `bestEffortTarget` are used:\n    // - `VariableLengthCharacterSet` kind `grapheme` (`\\X`): An exact representation would require\n    //   heavy Unicode data; a best-effort approximation requires knowing the target.\n    // - `CharacterSet` kind `posix` with values `graph` and `print`: Their complex Unicode-based\n    //   representations would be hard to change to ASCII-based after the fact in the generator\n    //   based on `target`/`accuracy`, so produce the appropriate structure here.\n    accuracy: 'default',\n    asciiWordBoundaries: false,\n    avoidSubclass: false,\n    bestEffortTarget: 'ES2025',\n    ...options,\n  };\n  const firstPassState = {\n    accuracy: opts.accuracy,\n    asciiWordBoundaries: opts.asciiWordBoundaries,\n    avoidSubclass: opts.avoidSubclass,\n    flagDirectivesByAlt: new Map(),\n    jsGroupNameMap: new Map(),\n    minTargetEs2024: isMinTarget(opts.bestEffortTarget, 'ES2024'),\n    passedLookbehind: false,\n    strategy: null,\n    // Subroutines can appear before the groups they ref, so collect reffed nodes for a second pass \n    subroutineRefMap: new Map(),\n    supportedGNodes: new Set(),\n    digitIsAscii: ast.flags.digitIsAscii,\n    spaceIsAscii: ast.flags.spaceIsAscii,\n    wordIsAscii: ast.flags.wordIsAscii,\n  };\n  traverse({node: ast}, firstPassState, FirstPassVisitor);\n  // Global flags modified by the first pass\n  const globalFlags = {\n    dotAll: ast.flags.dotAll,\n    ignoreCase: ast.flags.ignoreCase,\n  };\n  // The interplay of subroutines (with Onig's unique rules/behavior for them; see comments in the\n  // parser for details) with backref multiplexing (a unique Onig feature), flag modifiers, and\n  // duplicate group names (which might be indirectly referenced by subroutines even though\n  // subroutines can't directly reference duplicate names) is extremely complicated to emulate in\n  // JS in a way that handles all edge cases, so we need multiple passes to do it\n  const secondPassState = {\n    currentFlags: globalFlags,\n    prevFlags: null,\n    globalFlags,\n    groupOriginByCopy: new Map(),\n    groupsByName: new Map(),\n    multiplexCapturesToLeftByRef: new Map(),\n    openRefs: new Map(),\n    reffedNodesByReferencer: new Map(),\n    subroutineRefMap: firstPassState.subroutineRefMap,\n  };\n  traverse({node: ast}, secondPassState, SecondPassVisitor);\n  const thirdPassState = {\n    groupsByName: secondPassState.groupsByName,\n    highestOrphanBackref: 0,\n    numCapturesToLeft: 0,\n    reffedNodesByReferencer: secondPassState.reffedNodesByReferencer,\n  };\n  traverse({node: ast}, thirdPassState, ThirdPassVisitor);\n  ast._originMap = secondPassState.groupOriginByCopy;\n  ast._strategy = firstPassState.strategy;\n  return ast;\n}\n\nconst FirstPassVisitor = {\n  AbsentFunction({node, replaceWith}) {\n    // Convert absent repeater `(?~\u2026)` to `(?:(?:(?!\u2026)\\p{Any})*)`\n    const group = prepContainer(createGroup(), [\n      adoptAndSwapKids(createLookaround({negate: true}), node.alternatives),\n      createUnicodeProperty('Any'),\n    ]);\n    const quantifier = createQuantifier(group, 0, Infinity);\n    group.parent = quantifier;\n    replaceWith(prepContainer(createGroup(), [quantifier]));\n  },\n\n  Alternative: {\n    enter({node, parent, key}, {flagDirectivesByAlt}) {\n      // Look for own-level flag directives when entering an alternative because after traversing\n      // the directive itself, any subsequent flag directives will no longer be at the same level\n      const flagDirectives = node.elements.filter(el => el.kind === AstDirectiveKinds.flags);\n      for (let i = key + 1; i < parent.alternatives.length; i++) {\n        const forwardSiblingAlt = parent.alternatives[i];\n        getOrInsert(flagDirectivesByAlt, forwardSiblingAlt, []).push(...flagDirectives);\n      }\n    },\n    exit({node}, {flagDirectivesByAlt}) {\n      // Wait until exiting to wrap an alternative's nodes with flag groups that extend flag\n      // directives from prior sibling alternatives because doing this at the end allows inner\n      // nodes to accurately check their level in the tree\n      if (flagDirectivesByAlt.get(node)?.length) {\n        const flags = getCombinedFlagModsFromFlagNodes(flagDirectivesByAlt.get(node));\n        if (flags) {\n          const flagGroup = prepContainer(createGroup({flags}), node.elements);\n          // Manually set the parent since we're not using `replaceWith`\n          flagGroup.parent = node;\n          node.elements = [flagGroup];\n        }\n      }\n    },\n  },\n\n  Assertion({node, key, container, ast, remove, replaceWith}, state) {\n    const {kind, negate} = node;\n    const {asciiWordBoundaries, avoidSubclass, supportedGNodes, wordIsAscii} = state;\n    if (kind === AstAssertionKinds.line_end) {\n      // Onig's only line break char is line feed, unlike JS\n      replaceWith(parseFragment(r`(?=\\z|\\n)`));\n    } else if (kind === AstAssertionKinds.line_start) {\n      // Onig's only line break char is line feed, unlike JS. Onig's `^` doesn't match after a\n      // string-terminating line feed\n      replaceWith(parseFragment(r`(?<=\\A|\\n(?!\\z))`, {skipLookbehindValidation: true}));\n    } else if (kind === AstAssertionKinds.lookbehind) {\n      state.passedLookbehind = true;\n    } else if (kind === AstAssertionKinds.search_start) {\n      if (supportedGNodes.has(node)) {\n        ast.flags.sticky = true;\n        remove();\n      } else {\n        const prev = container[key - 1]; // parent.elements[key - 1]\n        // Not all ways of blocking the `\\G` from matching are covered (ex: a node prior to the\n        // prev node could block), but blocked `\\G` is an edge case so it's okay if some blocked\n        // cases resulting in the standard error for being unsupported\n        if (prev && isAlwaysNonZeroLength(prev)) {\n          replaceWith(prepContainer(createLookaround({negate: true})));\n        } else if (avoidSubclass) {\n          throw new Error(r`Uses \"\\G\" in a way that requires a subclass`);\n        } else {\n          replaceWith(createAssertion(AstAssertionKinds.string_start));\n          state.strategy = 'clip_search';\n        }\n      }\n    } else if (kind === AstAssertionKinds.string_end_newline) {\n      replaceWith(parseFragment(r`(?=\\n?\\z)`));\n    } else if (kind === AstAssertionKinds.word_boundary && !wordIsAscii && !asciiWordBoundaries) {\n      const b = `(?:(?<=${defaultWordChar})(?!${defaultWordChar})|(?<!${defaultWordChar})(?=${defaultWordChar}))`;\n      const B = `(?:(?<=${defaultWordChar})(?=${defaultWordChar})|(?<!${defaultWordChar})(?!${defaultWordChar}))`;\n      replaceWith(parseFragment(negate ? B : b));\n    }\n    // Kinds `string_end` and `string_start` don't need transformation since JS flag m isn't used.\n    // Kinds `lookahead` and `lookbehind` also don't need transformation\n  },\n\n  Backreference({node}, {jsGroupNameMap}) {\n    let {ref} = node;\n    if (typeof ref === 'string' && !isValidGroupNameJs(ref)) {\n      ref = getAndStoreJsGroupName(ref, jsGroupNameMap);\n      node.ref = ref;\n    }\n  },\n\n  CapturingGroup({node}, {jsGroupNameMap, subroutineRefMap}) {\n    let {name} = node;\n    if (name && !isValidGroupNameJs(name)) {\n      name = getAndStoreJsGroupName(name, jsGroupNameMap);\n      node.name = name;\n    }\n    subroutineRefMap.set(node.number, node);\n    if (name) {\n      subroutineRefMap.set(name, node);\n    }\n  },\n\n  CharacterSet({node, replaceWith}, {accuracy, minTargetEs2024, digitIsAscii, spaceIsAscii, wordIsAscii}) {\n    const {kind, negate, value} = node;\n    // Flag D with `\\d`, `\\p{Digit}`, `[[:digit:]]`\n    if (digitIsAscii && (kind === AstCharacterSetKinds.digit || value === 'digit')) {\n      replaceWith(createCharacterSet(AstCharacterSetKinds.digit, {negate}));\n      return;\n    }\n    // Flag S with `\\s`, `\\p{Space}`, `[[:space:]]`\n    if (spaceIsAscii && (kind === AstCharacterSetKinds.space || value === 'space')) {\n      replaceWith(setNegate(parseFragment(asciiSpaceChar), negate));\n      return;\n    }\n    // Flag W with `\\w`, `\\p{Word}`, `[[:word:]]`\n    if (wordIsAscii && (kind === AstCharacterSetKinds.word || value === 'word')) {\n      replaceWith(createCharacterSet(AstCharacterSetKinds.word, {negate}));\n      return;\n    }\n    if (kind === AstCharacterSetKinds.any) {\n      replaceWith(createUnicodeProperty('Any'));\n    } else if (kind === AstCharacterSetKinds.digit) {\n      replaceWith(createUnicodeProperty('Nd', {negate}));\n    } else if (kind === AstCharacterSetKinds.hex) {\n      replaceWith(createUnicodeProperty('AHex', {negate}));\n    } else if (kind === AstCharacterSetKinds.non_newline) {\n      replaceWith(parseFragment(r`[^\\n]`));\n    } else if (kind === AstCharacterSetKinds.space) {\n      // Can't use JS's Unicode-based `\\s` since unlike Onig it includes `\\uFEFF`, excludes `\\x85`\n      replaceWith(createUnicodeProperty('space', {negate}));\n    } else if (kind === AstCharacterSetKinds.word) {\n      replaceWith(setNegate(parseFragment(defaultWordChar), negate));\n    } else if (kind === AstCharacterSetKinds.property) {\n      if (!JsUnicodeProperties.has(value)) {\n        // Assume it's a script; no error checking is the price for avoiding heavyweight Unicode\n        // data for all script names\n        node.key = 'sc';\n      }\n    } else if (kind === AstCharacterSetKinds.posix) {\n      if (!minTargetEs2024 && (value === 'graph' || value === 'print')) {\n        if (accuracy === 'strict') {\n          throw new Error(`POSIX class \"${value}\" requires min target ES2024 or non-strict accuracy`);\n        }\n        let ascii = {\n          graph: '!-~',\n          print: ' -~',\n        }[value];\n        if (negate) {\n          // POSIX classes are always nested in a char class; manually invert the range rather than\n          // using `[^\u2026]` so it can be unwrapped since ES2018 doesn't support nested classes\n          ascii = `\\0-${cp(ascii.codePointAt(0) - 1)}${cp(ascii.codePointAt(2) + 1)}-\\u{10FFFF}`;\n        }\n        replaceWith(parseFragment(`[${ascii}]`));\n      } else {\n        replaceWith(setNegate(parseFragment(PosixClassesMap.get(value)), negate));\n      }\n    }\n  },\n\n  Directive(path, state) {\n    const {node, parent, ast, remove, replaceWith, removeAllPrevSiblings, removeAllNextSiblings} = path;\n    const {kind, flags} = node;\n    if (kind === AstDirectiveKinds.flags) {\n      if (!flags.enable && !flags.disable) {\n        // Flag directive without flags; ex: `(?-)`, `(?--)`\n        remove();\n      } else {\n        const flagGroup = prepContainer(createGroup({flags}), removeAllNextSiblings());\n        replaceWith(flagGroup);\n        traverseReplacement(flagGroup, path, state, FirstPassVisitor);\n      }\n    } else if (kind === AstDirectiveKinds.keep) {\n      const firstAltFirstEl = ast.pattern.alternatives[0].elements[0];\n      // Supporting a full-pattern wrapper around `\\K` enables use with flag modifiers\n      const hasWrapperGroup =\n        // Not emulatable if within a `CapturingGroup`\n        hasOnlyChild(ast.pattern, kid => kid.type === AstTypes.Group) &&\n        firstAltFirstEl.alternatives.length === 1;\n      const topLevel = hasWrapperGroup ? firstAltFirstEl : ast.pattern;\n      if (parent.parent !== topLevel || topLevel.alternatives.length > 1) {\n        throw new Error(r`Uses \"\\K\" in a way that's unsupported`);\n      }\n      replaceWith(prepContainer(createLookaround({behind: true}), removeAllPrevSiblings()));\n    }\n  },\n\n  Flags({node, parent}) {\n    // Remove Onig flags that aren't available in JS\n    [ 'digitIsAscii', // Flag D\n      'extended', // Flag x\n      'spaceIsAscii', // Flag S\n      'wordIsAscii', // Flag W\n    ].forEach(f => delete node[f]);\n    Object.assign(node, {\n      // JS flag g; no Onig equiv\n      global: false,\n      // JS flag d; no Onig equiv\n      hasIndices: false,\n      // JS flag m; no Onig equiv but its behavior is always on in Onig. Onig's only line break\n      // char is line feed, unlike JS, so this flag isn't used since it would produce inaccurate\n      // results (also allows `^` and `$` to be used in the generator for string start and end)\n      multiline: false,\n      // JS flag y; no Onig equiv, but used for `\\G` emulation\n      sticky: node.sticky ?? false,\n      // Note: Regex+ doesn't allow explicitly adding flags it handles implicitly, so leave out\n      // properties `unicode` (JS flag u) and `unicodeSets` (JS flag v). Keep the existing values\n      // for `ignoreCase` (flag i) and `dotAll` (JS flag s, but Onig flag m)\n    });\n    // Options accepted by Regex+; see <github.com/slevithan/regex#-options>\n    parent.options = {\n      disable: {\n        // Onig uses different rules for flag x than Regex+, so disable the implicit flag\n        x: true,\n        // Onig has no flag to control \"named capture only\" mode but contextually applies its\n        // behavior when named capturing is used, so disable Regex+'s implicit flag for it\n        n: true,\n      },\n      force: {\n        // Always add flag v because we're generating an AST that relies on it (it enables JS\n        // support for Onig features nested classes, set intersection, Unicode properties, etc.).\n        // However, the generator might disable flag v based on its `target` option\n        v: true,\n      },\n    };\n  },\n\n  Group({node}) {\n    if (!node.flags) {\n      return;\n    }\n    const {enable, disable} = node.flags;\n    // Onig's flag x (`extended`) isn't available in JS\n    enable?.extended && delete enable.extended;\n    disable?.extended && delete disable.extended;\n    // JS doesn't support flag groups that enable and disable the same flag; ex: `(?i-i:)`\n    enable?.dotAll && disable?.dotAll && delete enable.dotAll;\n    enable?.ignoreCase && disable?.ignoreCase && delete enable.ignoreCase;\n    // Cleanup\n    enable && !Object.keys(enable).length && delete node.flags.enable;\n    disable && !Object.keys(disable).length && delete node.flags.disable;\n    !node.flags.enable && !node.flags.disable && delete node.flags;\n  },\n\n  Pattern: {\n    enter({node}, {supportedGNodes}) {\n      // For `\\G` to be accurately emulatable using JS flag y, it must be at (and only at) the start\n      // of every top-level alternative (with complex rules for what determines being at the start).\n      // Additional `\\G` error checking in `Assertion` visitor\n      const leadingGs = [];\n      let hasAltWithLeadG = false;\n      let hasAltWithoutLeadG = false;\n      for (const alt of node.alternatives) {\n        if (alt.elements.length === 1 && alt.elements[0].kind === AstAssertionKinds.search_start) {\n          // Remove the `\\G` (leaving behind an empty alternative, and without adding JS flag y)\n          // since a top-level alternative that includes only `\\G` always matches at the start of the\n          // match attempt. Note that this is based on Oniguruma's rules, and is different than other\n          // regex flavors where `\\G` matches at the end of the previous match (a subtle distinction\n          // that's relevant after zero-length matches)\n          alt.elements.pop();\n        } else {\n          const leadingG = getLeadingG(alt.elements);\n          if (leadingG) {\n            hasAltWithLeadG = true;\n            Array.isArray(leadingG) ?\n              leadingGs.push(...leadingG) :\n              leadingGs.push(leadingG);\n          } else {\n            hasAltWithoutLeadG = true;\n          }\n        }\n      }\n      if (hasAltWithLeadG && !hasAltWithoutLeadG) {\n        // Supported `\\G` nodes will be removed (and add flag y) when traversed\n        leadingGs.forEach(g => supportedGNodes.add(g));\n      }\n    },\n    exit(_, {accuracy, passedLookbehind, strategy}) {\n      if (accuracy === 'strict' && passedLookbehind && strategy) {\n        throw new Error(r`Uses \"\\G\" in a way that requires non-strict accuracy`);\n      }\n    },\n  },\n\n  Quantifier({node}) {\n    if (node.element.type === AstTypes.Quantifier) {\n      // Change e.g. `a**` to `(?:a*)*`\n      const group = prepContainer(createGroup(), [node.element]);\n      // Manually set the parent since we're not using `replaceWith`\n      group.parent = node;\n      node.element = group;\n    }\n  },\n\n  Subroutine({node}, {jsGroupNameMap}) {\n    let {ref} = node;\n    if (typeof ref === 'string' && !isValidGroupNameJs(ref)) {\n      ref = getAndStoreJsGroupName(ref, jsGroupNameMap);\n      node.ref = ref;\n    }\n  },\n\n  VariableLengthCharacterSet({node, replaceWith}, {accuracy, minTargetEs2024}) {\n    const {kind} = node;\n    if (kind === AstVariableLengthCharacterSetKinds.newline) {\n      replaceWith(parseFragment('(?>\\r\\n?|[\\n\\v\\f\\x85\\u2028\\u2029])'));\n    } else if (kind === AstVariableLengthCharacterSetKinds.grapheme) {\n      if (accuracy === 'strict') {\n        throw new Error(r`Use of \"\\X\" requires non-strict accuracy`);\n      }\n      // `emojiRegex` is more permissive than `\\p{RGI_Emoji}` since it allows over/under-qualified\n      // emoji using a general pattern that matches any Unicode sequence following the structure of\n      // a valid emoji. That actually makes it more accurate for matching any grapheme\n      const emoji = minTargetEs2024 ? r`\\p{RGI_Emoji}` : emojiRegex().source.replace(/\\\\u\\{/g, `\\\\x{`);\n      // Close approximation of an extended grapheme cluster. Details: <unicode.org/reports/tr29/>.\n      // Skip name check to allow `RGI_Emoji` through, which Onig doesn't support\n      replaceWith(parseFragment(r`(?>\\r\\n|${emoji}|\\P{M}\\p{M}*)`, {skipPropertyNameValidation: true}));\n    } else {\n      throw new Error(`Unexpected varcharset kind \"${kind}\"`);\n    }\n  },\n};\n\nconst SecondPassVisitor = {\n  Backreference({node}, {multiplexCapturesToLeftByRef, reffedNodesByReferencer}) {\n    const {orphan, ref} = node;\n    if (!orphan) {\n      // Copy the current state for later multiplexing expansion. That's done in a subsequent pass\n      // because backref numbers need to be recalculated after subroutine expansion\n      reffedNodesByReferencer.set(node, [...multiplexCapturesToLeftByRef.get(ref).map(({node}) => node)]);\n    }\n  },\n\n  CapturingGroup: {\n    enter(\n      { node,\n        replaceWith,\n        skip,\n      },\n      { groupOriginByCopy,\n        groupsByName,\n        multiplexCapturesToLeftByRef,\n        openRefs,\n        reffedNodesByReferencer,\n      }\n    ) {\n      // Has value if we're within a subroutine expansion\n      const origin = groupOriginByCopy.get(node);\n\n      // ## Handle recursion; runs after subroutine expansion\n      if (origin && openRefs.has(node.number)) {\n        // Recursion doesn't affect any following backrefs to its `ref` (unlike other subroutines),\n        // so don't wrap with a capture. The reffed group might have its name removed due to later\n        // subroutine expansion\n        const recursion = createRecursion(node.number);\n        reffedNodesByReferencer.set(recursion, openRefs.get(node.number));\n        replaceWith(recursion);\n        // This node's kids have been removed from the tree, so no need to traverse them\n        skip();\n        return;\n      }\n      openRefs.set(node.number, node);\n\n      // ## Track data for backref multiplexing\n      multiplexCapturesToLeftByRef.set(node.number, []);\n      if (node.name) {\n        getOrInsert(multiplexCapturesToLeftByRef, node.name, []);\n      }\n      const multiplexNodes = multiplexCapturesToLeftByRef.get(node.name ?? node.number);\n      for (let i = 0; i < multiplexNodes.length; i++) {\n        // Captures added via subroutine expansion (maybe indirectly because they were descendant\n        // captures of the reffed group or in a nested subroutine expansion) form a set with their\n        // origin group and any other copies of it added via subroutines. Only the most recently\n        // matched within this set is added to backref multiplexing. So search the list of already-\n        // tracked multiplexed nodes for this group name or number to see if there's a node being\n        // replaced by this capture\n        const multiplex = multiplexNodes[i];\n        if (\n          // This group is from subroutine expansion, and there's a multiplex value from either the\n          // origin node or a prior subroutine expansion group with the same origin\n          (origin === multiplex.node || (origin && origin === multiplex.origin)) ||\n          // This group is not from subroutine expansion, and it comes after a subroutine expansion\n          // group that refers to this group\n          node === multiplex.origin\n        ) {\n          multiplexNodes.splice(i, 1);\n          break;\n        }\n      }\n      multiplexCapturesToLeftByRef.get(node.number).push({node, origin});\n      if (node.name) {\n        multiplexCapturesToLeftByRef.get(node.name).push({node, origin});\n      }\n\n      // ## Track data for duplicate names\n      // Pre-ES2025 doesn't allow duplicate names, but ES2025 allows duplicate names that are\n      // unique per mutually exclusive alternation path. However, Oniguruma's handling for named\n      // subpatterns on match results means we can't use this ES2025 feature even when in an ES2025\n      // env. So, if using a duplicate name, remove the name from all but the first instance that\n      // wasn't created by subroutine expansion\n      if (node.name) {\n        const groupsWithSameName = getOrInsert(groupsByName, node.name, new Map());\n        let hasDuplicateNameToRemove = false;\n        if (origin) {\n          // Subroutines and their child captures shouldn't hold duplicate names in the final state\n          hasDuplicateNameToRemove = true;\n        } else {\n          for (const groupInfo of groupsWithSameName.values()) {\n            if (!groupInfo.hasDuplicateNameToRemove) {\n              // Will change to an unnamed capture in a later pass\n              hasDuplicateNameToRemove = true;\n              break;\n            }\n          }\n        }\n        groupsByName.get(node.name).set(node, {node, hasDuplicateNameToRemove});\n      }\n    },\n    exit({node}, {openRefs}) {\n      openRefs.delete(node.number);\n    },\n  },\n\n  Group: {\n    enter({node}, state) {\n      // Flag directives have already been converted to flag groups by the previous pass\n      state.prevFlags = state.currentFlags;\n      if (node.flags) {\n        state.currentFlags = getNewCurrentFlags(state.currentFlags, node.flags);\n      }\n    },\n    exit(_, state) {\n      state.currentFlags = state.prevFlags;\n    },\n  },\n\n  Recursion({node, parent}, {reffedNodesByReferencer}) {\n    // Recursion nodes are created during the current traversal; they're only traversed here if a\n    // recursion node created during traversal is then copied by a subroutine expansion, e.g. with\n    // `(?<a>\\g<a>)\\g<a>`\n    const {ref} = node;\n    // Immediate parent is an alternative or quantifier; can skip\n    let reffed = parent;\n    while ((reffed = reffed.parent)) {\n      if (reffed.type === AstTypes.CapturingGroup && (reffed.name === ref || reffed.number === ref)) {\n        break;\n      }\n    }\n    // Track the referenced node because `ref`s are rewritten in a subsequent pass; capturing group\n    // names and numbers might change due to subroutine expansion and duplicate group names\n    reffedNodesByReferencer.set(node, reffed);\n  },\n\n  Subroutine(path, state) {\n    const {node, replaceWith} = path;\n    const {ref} = node;\n    const reffedGroupNode = state.subroutineRefMap.get(ref);\n    // Other forms of recursion are handled by the `CapturingGroup` visitor\n    const isGlobalRecursion = ref === 0;\n    const expandedSubroutine = isGlobalRecursion ?\n      createRecursion(0) :\n      // The reffed group might itself contain subroutines, which are expanded during sub-traversal\n      cloneCapturingGroup(reffedGroupNode, state.groupOriginByCopy, null);\n    let replacement = expandedSubroutine;\n    if (!isGlobalRecursion) {\n      // Subroutines take their flags from the reffed group, not the flags surrounding themselves\n      const reffedGroupFlagMods = getCombinedFlagModsFromFlagNodes(getAllParents(reffedGroupNode, node => {\n        return node.type === AstTypes.Group && !!node.flags;\n      }));\n      const reffedGroupFlags = reffedGroupFlagMods ?\n        getNewCurrentFlags(state.globalFlags, reffedGroupFlagMods) :\n        state.globalFlags;\n      if (!areFlagsEqual(reffedGroupFlags, state.currentFlags)) {\n        replacement = prepContainer(createGroup({\n          flags: getFlagModsFromFlags(reffedGroupFlags),\n        }), [expandedSubroutine]);\n      }\n    }\n    replaceWith(replacement);\n    if (!isGlobalRecursion) {\n      traverseReplacement(replacement, path, state, SecondPassVisitor);\n    }\n  },\n};\n\nconst ThirdPassVisitor = {\n  Backreference({node, replaceWith}, state) {\n    if (node.orphan) {\n      state.highestOrphanBackref = Math.max(state.highestOrphanBackref, node.ref);\n      // Don't renumber; used with `allowOrphanBackrefs`\n      return;\n    }\n    const reffedNodes = state.reffedNodesByReferencer.get(node);\n    const participants = reffedNodes.filter(reffed => canParticipateWithNode(reffed, node));\n    // For the backref's `ref`, use `number` rather than `name` because group names might have been\n    // removed if they're duplicates within their alternation path, or they might be removed later\n    // by the generator (depending on target) if they're duplicates within the overall pattern.\n    // Backrefs must come after groups they ref, so reffed node `number`s are already recalculated\n    if (!participants.length) {\n      // If no participating capture, convert backref to to `(?!)`; backrefs to nonparticipating\n      // groups can't match in Onig but match the empty string in JS\n      replaceWith(prepContainer(createLookaround({negate: true})));\n    } else if (participants.length > 1) {\n      // Multiplex\n      const alts = participants.map(reffed => adoptAndSwapKids(\n        createAlternative(),\n        [createBackreference(reffed.number)]\n      ));\n      replaceWith(adoptAndSwapKids(createGroup(), alts));\n    } else {\n      node.ref = participants[0].number;\n    }\n  },\n\n  CapturingGroup({node}, state) {\n    // Recalculate the number since the current value might be wrong due to subroutine expansion\n    node.number = ++state.numCapturesToLeft;\n    if (node.name) {\n      // Removing duplicate names here rather than in an earlier pass avoids extra complexity when\n      // handling subroutine expansion and backref multiplexing\n      if (state.groupsByName.get(node.name).get(node).hasDuplicateNameToRemove) {\n        delete node.name;\n      }\n    }\n  },\n\n  Recursion({node}, state) {\n    if (node.ref === 0) {\n      return;\n    }\n    // For the recursion's `ref`, use `number` rather than `name` because group names might have\n    // been removed if they're duplicates within their alternation path, or they might be removed\n    // later by the generator (depending on target) if they're duplicates within the overall\n    // pattern. Since recursion appears within the group it refs, the reffed node's `number` has\n    // already been recalculated\n    node.ref = state.reffedNodesByReferencer.get(node).number;\n  },\n\n  Regex: {\n    exit({node}, state) {\n      // [HACK] Add unnamed captures to the end of the regex if needed to allow orphaned backrefs\n      // to be valid in JS with flag u/v. This is needed to support TextMate grammars, which\n      // replace numbered backrefs in their `end` pattern with values matched by captures in their\n      // `begin` pattern! See <github.com/microsoft/vscode-textmate/blob/7e0ea282f4f25fef12a6c84fa4fa7266f67b58dc/src/rule.ts#L661-L663>\n      // An `end` pattern, prior to this substitution, might have backrefs to a group that doesn't\n      // exist within `end`. This presents a dilemma since both Oniguruma and JS (with flag u/v)\n      // error for backrefs to undefined captures. So adding captures to the end is a solution that\n      // doesn't change what the regex matches, and lets invalid numbered backrefs through. Note:\n      // Orphan backrefs are only allowed if `allowOrphanBackrefs` is enabled\n      const numCapsNeeded = Math.max(state.highestOrphanBackref - state.numCapturesToLeft, 0);\n      for (let i = 0; i < numCapsNeeded; i++) {\n        const emptyCapture = createCapturingGroup();\n        node.pattern.alternatives.at(-1).elements.push(emptyCapture);\n      }\n    },\n  },\n};\n\n// `\\t\\n\\v\\f\\r\\x20`\nconst asciiSpaceChar = '[\\t-\\r ]';\n// Different than `PosixClassesMap`'s `word`\nconst defaultWordChar = r`[\\p{L}\\p{M}\\p{N}\\p{Pc}]`;\n\nfunction adoptAndSwapKids(parent, kids) {\n  kids.forEach(kid => kid.parent = parent);\n  parent[getContainerAccessor(parent)] = kids;\n  return parent;\n}\n\nfunction areFlagsEqual(a, b) {\n  return a.dotAll === b.dotAll && a.ignoreCase === b.ignoreCase;\n}\n\nfunction canParticipateWithNode(capture, node) {\n  // Walks to the left (prev siblings), down (sibling descendants), up (parent), then back down\n  // (parent's prev sibling descendants) the tree in a loop\n  let rightmostPoint = node;\n  do {\n    if (rightmostPoint.type === AstTypes.Pattern) {\n      // End of the line; capture is not in node's alternation path\n      return false;\n    }\n    if (rightmostPoint.type === AstTypes.Alternative) {\n      // Skip past alts to their parent because we don't want to look at the kids of preceding alts\n      continue;\n    }\n    if (rightmostPoint === capture) {\n      // Capture is ancestor of node\n      return false;\n    }\n    const kidsOfParent = getKids(rightmostPoint.parent);\n    for (const kid of kidsOfParent) {\n      if (kid === rightmostPoint) {\n        // Reached rightmost node in sibling list that we want to consider; break to parent loop\n        break;\n      }\n      if (kid === capture) {\n        return true;\n      }\n      if (hasDescendant(kid, capture)) {\n        return true;\n      }\n    }\n  } while ((rightmostPoint = rightmostPoint.parent));\n  throw new Error('Unexpected path');\n}\n\n// Creates a deep copy of the provided node, with special handling:\n// - Make `parent` props point to their parent in the copy\n// - Update the provided `originMap` for each cloned capturing group (outer and nested)\nfunction cloneCapturingGroup(obj, originMap, up, up2) {\n  const store = Array.isArray(obj) ? [] : {};\n  for (const [key, value] of Object.entries(obj)) {\n    if (key === 'parent') {\n      // If the last cloned item was a container array (for holding kids), use the object above it\n      store.parent = Array.isArray(up) ? up2 : up;\n    } else if (value && typeof value === 'object') {\n      store[key] = cloneCapturingGroup(value, originMap, store, up);\n    } else {\n      if (key === 'type' && value === AstTypes.CapturingGroup) {\n        // Key is the copied node, value is the origin node\n        originMap.set(store, originMap.get(obj) ?? obj);\n      }\n      store[key] = value;\n    }\n  }\n  return store;\n}\n\n// `Recursion` nodes are used only by the transformer\nfunction createRecursion(ref) {\n  return {\n    type: AstTypes.Recursion,\n    ref,\n  };\n}\n\nfunction getAllParents(node, filterFn) {\n  const results = [];\n  while ((node = node.parent)) {\n    if (!filterFn || filterFn(node)) {\n      results.push(node);\n    }\n  }\n  return results;\n}\n\n// See also `isValidGroupNameJs`\nfunction getAndStoreJsGroupName(name, map) {\n  if (map.has(name)) {\n    return map.get(name);\n  }\n  // Onig group names can't start with `$`, but JS names can\n  const jsName = `$${map.size}_${name.replace(/^[^$_\\p{IDS}]|[^$\\u200C\\u200D\\p{IDC}]/ug, '_')}`;\n  map.set(name, jsName);\n  return jsName;\n}\n\n// Returns the string key for the container that holds the node's kids\nfunction getContainerAccessor(node) {\n  for (const accessor of ['alternatives', 'classes', 'elements']) {\n    if (node[accessor]) {\n      return accessor;\n    }\n  }\n  return null;\n}\n\nfunction getCombinedFlagModsFromFlagNodes(flagNodes) {\n  const flagProps = ['dotAll', 'ignoreCase'];\n  const combinedFlags = {enable: {}, disable: {}};\n  flagNodes.forEach(({flags}) => {\n    flagProps.forEach(prop => {\n      if (flags.enable?.[prop]) {\n        // Need to remove `disable` since disabled flags take precedence\n        delete combinedFlags.disable[prop];\n        combinedFlags.enable[prop] = true;\n      }\n      if (flags.disable?.[prop]) {\n        combinedFlags.disable[prop] = true;\n      }\n    });\n  });\n  if (!Object.keys(combinedFlags.enable).length) {\n    delete combinedFlags.enable;\n  }\n  if (!Object.keys(combinedFlags.disable).length) {\n    delete combinedFlags.disable;\n  }\n  if (combinedFlags.enable || combinedFlags.disable) {\n    return combinedFlags;\n  }\n  return null;\n}\n\nfunction getFlagModsFromFlags({dotAll, ignoreCase}) {\n  const mods = {};\n  if (dotAll || ignoreCase) {\n    mods.enable = {};\n    dotAll && (mods.enable.dotAll = true);\n    ignoreCase && (mods.enable.ignoreCase = true);\n  }\n  if (!dotAll || !ignoreCase) {\n    mods.disable = {};\n    !dotAll && (mods.disable.dotAll = true);\n    !ignoreCase && (mods.disable.ignoreCase = true);\n  }\n  return mods;\n}\n\nfunction getKids(node) {\n  if (!node) {\n    throw new Error('Node expected');\n  }\n  // [NOTE] Not handling `Regex` kids (`pattern`, `flags`) and `CharacterClassRange` kids (`min`,\n  // `max`) only because not needed by current callers\n  if (node.type === AstTypes.Quantifier) {\n    return [node.element];\n  }\n  const accessor = getContainerAccessor(node);\n  return accessor && node[accessor];\n}\n\nfunction getLeadingG(els) {\n  const firstToConsider = els.find(el => (\n    el.kind === AstAssertionKinds.search_start ||\n    isLoneGLookaround(el, {negate: false}) ||\n    !isAlwaysZeroLength(el)\n  ));\n  if (!firstToConsider) {\n    return null;\n  }\n  if (firstToConsider.kind === AstAssertionKinds.search_start) {\n    return firstToConsider;\n  }\n  if (isLookaround(firstToConsider)) {\n    return firstToConsider.alternatives[0].elements[0];\n  }\n  if (isConsumptiveGroup(firstToConsider)) {\n    const gNodesForGroup = [];\n    // Recursively find `\\G` nodes for all alternatives in the group\n    for (const alt of firstToConsider.alternatives) {\n      const leadingG = getLeadingG(alt.elements);\n      if (!leadingG) {\n        // Don't return `gNodesForGroup` collected so far since this alt didn't qualify\n        return null;\n      }\n      Array.isArray(leadingG) ?\n        gNodesForGroup.push(...leadingG) :\n        gNodesForGroup.push(leadingG);\n    }\n    return gNodesForGroup;\n  }\n  return null;\n}\n\nfunction hasDescendant(node, descendant) {\n  const kids = getKids(node) ?? [];\n  for (const kid of kids) {\n    if (\n      kid === descendant ||\n      hasDescendant(kid, descendant)\n    ) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction isLoneGLookaround(node, options) {\n  const opts = {\n    negate: null,\n    ...options,\n  };\n  return (\n    isLookaround(node) &&\n    (opts.negate === null || node.negate === opts.negate) &&\n    hasOnlyChild(node, kid => kid.kind === AstAssertionKinds.search_start)\n  );\n}\n\n// See also `getAndStoreJsGroupName`\nfunction isValidGroupNameJs(name) {\n  // JS group names are more restrictive than Onig; see `isValidGroupNameOniguruma` and\n  // <developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#identifiers>\n  return /^[$_\\p{IDS}][$\\u200C\\u200D\\p{IDC}]*$/u.test(name);\n}\n\n// Returns a single node, either the given node or all nodes wrapped in a noncapturing group\nfunction parseFragment(pattern, options) {\n  const ast = parse(tokenize(pattern), options);\n  const alts = ast.pattern.alternatives;\n  if (alts.length > 1 || alts[0].elements.length > 1) {\n    return adoptAndSwapKids(createGroup(), alts);\n  }\n  return alts[0].elements[0];\n}\n\nfunction prepContainer(node, kids) {\n  const accessor = getContainerAccessor(node);\n  // Set the parent for the default container of a new node\n  node[accessor][0].parent = node;\n  if (kids) {\n    adoptAndSwapKids(node[accessor][0], kids);\n  }\n  return node;\n}\n\nfunction setNegate(node, negate) {\n  node.negate = negate;\n  return node;\n}\n\nfunction traverseReplacement(replacement, {parent, key, container}, state, visitor) {\n  traverse({\n    // Don't use the `node` from `path`\n    node: replacement,\n    parent,\n    key,\n    container,\n  }, state, visitor);\n}\n\nexport {\n  transform,\n};\n", "import {getOptions} from './options.js';\nimport {AstAssertionKinds, AstCharacterSetKinds, AstTypes, createCharacter} from './parse.js';\nimport {traverse} from './traverse.js';\nimport {getIgnoreCaseMatchChars, UnicodePropertiesWithSpecificCase} from './unicode.js';\nimport {cp, envFlags, getNewCurrentFlags, getOrInsert, isMinTarget, r} from './utils.js';\nimport {isLookaround} from './utils-ast.js';\n\n/**\nGenerates a Regex+ compatible `pattern`, `flags`, and `options` from a Regex+ AST.\n@param {import('./transform.js').RegexAst} ast\n@param {import('.').ToRegExpOptions} [options]\n@returns {{\n  pattern: string;\n  flags: string;\n  options: Object;\n  _captureTransfers: Map<number, Array<number>>;\n  _hiddenCaptures: Array<number>;\n}}\n*/\nfunction generate(ast, options) {\n  const opts = getOptions(options);\n  const minTargetEs2024 = isMinTarget(opts.target, 'ES2024');\n  const minTargetEs2025 = isMinTarget(opts.target, 'ES2025');\n  const recursionLimit = opts.rules.recursionLimit;\n  if (!Number.isInteger(recursionLimit) || recursionLimit < 2 || recursionLimit > 20) {\n    throw new Error('Invalid recursionLimit; use 2-20');\n  }\n\n  // If the output can't use flag groups, we need a pre-pass to check for the use of chars with\n  // case in case sensitive/insensitive states. This minimizes the need for case expansions (though\n  // expansions are lossless, even given Unicode case complexities) and allows supporting case\n  // insensitive backrefs in more cases\n  // [TODO] Consider gathering this data in the transformer's final traversal to avoid work here\n  let hasCaseInsensitiveNode = null;\n  let hasCaseSensitiveNode = null;\n  if (!minTargetEs2025) {\n    const iStack = [ast.flags.ignoreCase];\n    traverse({node: ast}, {\n      getCurrentModI: () => iStack.at(-1),\n      popModI() {iStack.pop()},\n      pushModI(isIOn) {iStack.push(isIOn)},\n      setHasCasedChar() {\n        if (iStack.at(-1)) {\n          hasCaseInsensitiveNode = true;\n        } else {\n          hasCaseSensitiveNode = true;\n        }\n      },\n    }, FlagModifierVisitor);\n  }\n\n  const appliedGlobalFlags = {\n    dotAll: ast.flags.dotAll,\n    // - Turn global flag i on if a case insensitive node was used and no case sensitive nodes were\n    //   used (to avoid unnecessary node expansion).\n    // - Turn global flag i off if a case sensitive node was used (since case sensitivity can't be\n    //   forced without the use of ES2025 flag groups)\n    ignoreCase: !!((ast.flags.ignoreCase || hasCaseInsensitiveNode) && !hasCaseSensitiveNode),\n  };\n  let lastNode = null;\n  const state = {\n    accuracy: opts.accuracy,\n    appliedGlobalFlags,\n    captureMap: new Map(),\n    currentFlags: {\n      dotAll: ast.flags.dotAll,\n      ignoreCase: ast.flags.ignoreCase,\n    },\n    inCharClass: false,\n    lastNode,\n    originMap: ast._originMap,\n    recursionLimit,\n    useAppliedIgnoreCase: !!(!minTargetEs2025 && hasCaseInsensitiveNode && hasCaseSensitiveNode),\n    useFlagMods: minTargetEs2025,\n    useFlagV: minTargetEs2024,\n    verbose: opts.verbose,\n  };\n  function gen(node) {\n    state.lastNode = lastNode;\n    lastNode = node;\n    switch (node.type) {\n      case AstTypes.Regex:\n        // Final result is an object; other node types return strings\n        return {\n          pattern: gen(node.pattern),\n          flags: gen(node.flags),\n          options: {...node.options},\n        };\n      case AstTypes.Alternative:\n        return node.elements.map(gen).join('');\n      case AstTypes.Assertion:\n        return genAssertion(node, state, gen);\n      case AstTypes.Backreference:\n        return genBackreference(node, state);\n      case AstTypes.CapturingGroup:\n        return genCapturingGroup(node, state, gen);\n      case AstTypes.Character:\n        return genCharacter(node, state);\n      case AstTypes.CharacterClass:\n        return genCharacterClass(node, state, gen);\n      case AstTypes.CharacterClassIntersection:\n        if (!state.useFlagV) {\n          throw new Error('Use of class intersection requires min target ES2024');\n        }\n        return node.classes.map(gen).join('&&');\n      case AstTypes.CharacterClassRange:\n        return genCharacterClassRange(node, state);\n      case AstTypes.CharacterSet:\n        return genCharacterSet(node, state);\n      case AstTypes.Flags:\n        return genFlags(node, state);\n      case AstTypes.Group:\n        return genGroup(node, state, gen);\n      case AstTypes.Pattern:\n        return node.alternatives.map(gen).join('|');\n      case AstTypes.Quantifier:\n        return gen(node.element) + getQuantifierStr(node);\n      case AstTypes.Recursion:\n        return genRecursion(node, state);\n      default:\n        // Node types `AbsentFunction`, `Directive`, `Subroutine`, and `VariableLengthCharacterSet`\n        // are never included in transformer output\n        throw new Error(`Unexpected node type \"${node.type}\"`);\n    }\n  }\n\n  const result = gen(ast);\n  if (!minTargetEs2024) {\n    // Switch from flag v to u; Regex+ implicitly chooses by default\n    delete result.options.force.v;\n    result.options.disable.v = true;\n    result.options.unicodeSetsPlugin = null;\n  }\n  result._captureTransfers = new Map();\n  result._hiddenCaptures = [];\n  state.captureMap.forEach((value, key) => {\n    if (value.hidden) {\n      result._hiddenCaptures.push(key);\n    }\n    if (value.transferTo) {\n      getOrInsert(result._captureTransfers, value.transferTo, []).push(key);\n    }\n  });\n\n  return result;\n}\n\nconst FlagModifierVisitor = {\n  AnyGroup: {\n    enter({node}, state) {\n      const currentModI = state.getCurrentModI();\n      state.pushModI(\n        node.flags ?\n          getNewCurrentFlags({ignoreCase: currentModI}, node.flags).ignoreCase :\n          currentModI\n      );\n    },\n    exit(_, state) {\n      state.popModI();\n    },\n  },\n  Backreference(_, state) {\n    // Can't know for sure, so assume the backref will include chars with case (best that could be\n    // done is not calling `setHasCasedChar` if the reffed group doesn't contain a char with case\n    // or most kinds of char sets)\n    state.setHasCasedChar();\n  },\n  Character({node}, state) {\n    if (charHasCase(cp(node.value))) {\n      state.setHasCasedChar();\n    }\n  },\n  CharacterClassRange({node, skip}, state) {\n    skip();\n    if (getCasesOutsideCharClassRange(node, {firstOnly: true}).length) {\n      state.setHasCasedChar();\n    }\n  },\n  CharacterSet({node}, state) {\n    if (\n      node.kind === AstCharacterSetKinds.property &&\n      UnicodePropertiesWithSpecificCase.has(node.value)\n    ) {\n      state.setHasCasedChar();\n    }\n  },\n};\n\nconst BaseEscapeChars = new Set([\n  '$', '(', ')', '*', '+', '.', '?', '[', '\\\\', ']', '^', '{', '|', '}',\n]);\nconst CharClassEscapeChars = new Set([\n  '-', '\\\\', ']', '^',\n  // Literal `[` doesn't require escaping with flag u, but this can help work around regex source\n  // linters and regex syntax processors that expect unescaped `[` to create a nested class\n  '[',\n]);\nconst CharClassEscapeCharsFlagV = new Set([\n  '(', ')', '-', '/', '[', '\\\\', ']', '^', '{', '|', '}',\n  // Double punctuators; also includes already-listed `-` and `^`\n  '!', '#', '$', '%', '&', '*', '+', ',', '.', ':', ';', '<', '=', '>', '?', '@', '`', '~',\n]);\nconst CharCodeEscapeMap = new Map([\n  [ 9, r`\\t`], // horizontal tab\n  [10, r`\\n`], // line feed\n  [11, r`\\v`], // vertical tab\n  [12, r`\\f`], // form feed\n  [13, r`\\r`], // carriage return\n  [0x2028, r`\\u2028`], // line separator\n  [0x2029, r`\\u2029`], // paragraph separator\n  [0xFEFF, r`\\uFEFF`], // ZWNBSP/BOM\n]);\n\nconst casedRe = /^\\p{Cased}$/u;\nfunction charHasCase(char) {\n  return casedRe.test(char);\n}\n\nfunction genAssertion(node, _, gen) {\n  const {kind, negate, alternatives} = node;\n  if (isLookaround(node)) {\n    const prefix = `${kind === AstAssertionKinds.lookahead ? '' : '<'}${negate ? '!' : '='}`;\n    return `(?${prefix}${alternatives.map(gen).join('|')})`;\n  }\n  // Can always use `^` and `$` for string boundaries since JS flag m is never relied on; Onig uses\n  // different line break chars\n  if (kind === AstAssertionKinds.string_end) {\n    return '$';\n  }\n  if (kind === AstAssertionKinds.string_start) {\n    return '^';\n  }\n  // If a word boundary came through the transformer unaltered, that means `wordIsAscii` or\n  // `asciiWordBoundaries` is enabled\n  if (kind === AstAssertionKinds.word_boundary) {\n    return negate ? r`\\B` : r`\\b`;\n  }\n  // Kinds `line_end`, `line_start`, `search_start`, and `string_end_newline` are never included in\n  // transformer output\n  throw new Error(`Unexpected assertion kind \"${kind}\"`);\n}\n\nfunction genBackreference({ref}, state) {\n  if (typeof ref !== 'number') {\n    throw new Error('Unexpected named backref in transformed AST');\n  }\n  if (\n    !state.useFlagMods &&\n    state.accuracy === 'strict' &&\n    state.currentFlags.ignoreCase &&\n    !state.captureMap.get(ref).ignoreCase\n  ) {\n    throw new Error('Use of case-insensitive backref to case-sensitive group requires target ES2025 or non-strict accuracy');\n  }\n  return '\\\\' + ref;\n}\n\nfunction genCapturingGroup(node, state, gen) {\n  const {name, number, alternatives} = node;\n  const data = {ignoreCase: state.currentFlags.ignoreCase};\n  // Has origin if the capture is from an expanded subroutine\n  const origin = state.originMap.get(node);\n  if (origin) {\n    // All captures from/within expanded subroutines are marked as hidden\n    data.hidden = true;\n    // If a subroutine (or descendant capture) occurs after its origin group, it's marked to have\n    // its captured value transferred to the origin's capture slot. `number` and `origin.number`\n    // are the capture numbers *after* subroutine expansion\n    if (number > origin.number) {\n      data.transferTo = origin.number;\n    }\n  }\n  state.captureMap.set(number, data);\n  return `(${name ? `?<${name}>` : ''}${alternatives.map(gen).join('|')})`;\n}\n\nfunction genCharacter({value}, state) {\n  const char = cp(value);\n  const escaped = getCharEscape(value, {\n    isAfterBackref: state.lastNode.type === AstTypes.Backreference,\n    inCharClass: state.inCharClass,\n    useFlagV: state.useFlagV,\n  });\n  if (escaped !== char) {\n    return escaped;\n  }\n  if (state.useAppliedIgnoreCase && state.currentFlags.ignoreCase && charHasCase(char)) {\n    const cases = getIgnoreCaseMatchChars(char);\n    return state.inCharClass ?\n      cases.join('') :\n      (cases.length > 1 ? `[${cases.join('')}]` : cases[0]);\n  }\n  return char;\n}\n\nfunction genCharacterClass({negate, parent, elements}, state, gen) {\n  // Work around WebKit parser bug by moving literal hyphens to the end of the class\n  if (envFlags.literalHyphenIncorrectlyCreatesRange && state.useFlagV && elements.some(isLiteralHyphen)) {\n    // Remove all hyphens then add one at the end; can't just sort in case of e.g. `[\\d\\-\\-]`\n    elements = elements.filter(node => !isLiteralHyphen(node));\n    elements.push(createCharacter(45));\n  }\n  const genClass = () => `[${negate ? '^' : ''}${elements.map(gen).join('')}]`;\n  if (!state.inCharClass) {\n    // For the outermost char class, set state\n    state.inCharClass = true;\n    const result = genClass();\n    state.inCharClass = false;\n    return result;\n  }\n  // No first element for implicit class in empty intersection like `[&&]`\n  const firstType = elements[0]?.type;\n  if (\n    !negate &&\n    firstType &&\n    (\n      ( // Allows many nested classes to work with `target` ES2018 which doesn't support nesting\n        (!state.useFlagV || !state.verbose) &&\n        parent.type === AstTypes.CharacterClass &&\n        firstType !== AstTypes.CharacterClassIntersection &&\n        !(envFlags.literalHyphenIncorrectlyCreatesRange && state.useFlagV)\n      ) ||\n      ( !state.verbose &&\n        parent.type === AstTypes.CharacterClassIntersection &&\n        // JS doesn't allow intersection with union or ranges\n        elements.length === 1 &&\n        firstType !== AstTypes.CharacterClass &&\n        firstType !== AstTypes.CharacterClassRange\n      )\n    )\n  ) {\n    // Remove unnecessary nesting; unwrap kids into the parent char class. Some basic char class\n    // optimization for intersection has already been done in the parser\n    return elements.map(gen).join('');\n  }\n  if (!state.useFlagV && parent.type === AstTypes.CharacterClass) {\n    throw new Error('Use of nested character class requires min target ES2024');\n  }\n  return genClass();\n}\n\nfunction genCharacterClassRange(node, state) {\n  const min = node.min.value;\n  const max = node.max.value;\n  const escOpts = {\n    isAfterBackref: false,\n    inCharClass: true,\n    useFlagV: state.useFlagV,\n  };\n  const minStr = getCharEscape(min, escOpts);\n  const maxStr = getCharEscape(max, escOpts);\n  const extraChars = new Set();\n  if (state.useAppliedIgnoreCase && state.currentFlags.ignoreCase) {\n    // [TODO] Avoid duplication by considering other chars in the parent char class when expanding\n    const charsOutsideRange = getCasesOutsideCharClassRange(node);\n    const ranges = getCodePointRangesFromChars(charsOutsideRange);\n    ranges.forEach(value => {\n      extraChars.add(\n        Array.isArray(value) ?\n          `${getCharEscape(value[0], escOpts)}-${getCharEscape(value[1], escOpts)}` :\n          getCharEscape(value, escOpts)\n      );\n    });\n  }\n  // Create the range without calling `gen` on the `min`/`max` kids\n  return `${minStr}-${maxStr}${[...extraChars].join('')}`;\n}\n\nfunction genCharacterSet({kind, negate, value, key}, state) {\n  if (kind === AstCharacterSetKinds.dot) {\n    return state.currentFlags.dotAll ?\n      ((state.appliedGlobalFlags.dotAll || state.useFlagMods) ? '.' : '[^]') :\n      // Onig's only line break char is line feed, unlike JS\n      r`[^\\n]`;\n  }\n  if (kind === AstCharacterSetKinds.digit) {\n    return negate ? r`\\D` : r`\\d`;\n  }\n  if (kind === AstCharacterSetKinds.property) {\n    if (\n      state.useAppliedIgnoreCase &&\n      state.currentFlags.ignoreCase &&\n      UnicodePropertiesWithSpecificCase.has(value)\n    ) {\n      // Support for this would require heavy Unicode data. Could change e.g. `\\p{Lu}` to `\\p{LC}`\n      // if not using strict `accuracy` (since it's close but not 100%), but this wouldn't work\n      // for e.g. `\\p{Lt}`, and in any case, it's probably user error if using these case-specific\n      // props case-insensitively\n      throw new Error(`Unicode property \"${value}\" can't be case-insensitive when other chars have specific case`);\n    }\n    return `${negate ? r`\\P` : r`\\p`}{${key ? `${key}=` : ''}${value}}`;\n  }\n  if (kind === AstCharacterSetKinds.word) {\n    return negate ? r`\\W` : r`\\w`;\n  }\n  // Kinds `hex`, `posix`, and `space` are never included in transformer output\n  throw new Error(`Unexpected character set kind \"${kind}\"`);\n}\n\nfunction genFlags(node, state) {\n  return (\n    // The transformer should never turn on the properties for flags d, g, and m since Onig doesn't\n    // have equivs. Flag m is never relied on since Onig uses different line break chars than JS\n    // (node.hasIndices ? 'd' : '') +\n    // (node.global ? 'g' : '') +\n    // (node.multiline ? 'm' : '') +\n    (state.appliedGlobalFlags.ignoreCase ? 'i' : '') +\n    (node.dotAll ? 's' : '') +\n    (node.sticky ? 'y' : '')\n    // Regex+ doesn't allow explicitly adding flags it handles implicitly, so there are no\n    // `unicode` (flag u) or `unicodeSets` (flag v) props; those flags are added separately\n  );\n}\n\nfunction genGroup({atomic, flags, parent, alternatives}, state, gen) {\n  const currentFlags = state.currentFlags;\n  if (flags) {\n    state.currentFlags = getNewCurrentFlags(currentFlags, flags);\n  }\n  const contents = alternatives.map(gen).join('|');\n  const result = (\n    !state.verbose &&\n    alternatives.length === 1 &&\n    parent.type !== AstTypes.Quantifier &&\n    !atomic &&\n    (!state.useFlagMods || !flags)\n   ) ? contents : `(?${getGroupPrefix(atomic, flags, state.useFlagMods)}${contents})`;\n  state.currentFlags = currentFlags;\n  return result;\n}\n\nfunction genRecursion({ref}, state) {\n  const limit = state.recursionLimit;\n  // Using the syntax supported by `regex-recursion`\n  return ref === 0 ? `(?R=${limit})` : r`\\g<${ref}&R=${limit}>`;\n}\n\n/**\nGiven a `CharacterClassRange` node, returns an array of chars that are a case variant of a char in\nthe range, and aren't already in the range.\n*/\nfunction getCasesOutsideCharClassRange(node, options) {\n  const firstOnly = !!options?.firstOnly;\n  const min = node.min.value;\n  const max = node.max.value;\n  const found = [];\n  // Avoid unneeded work. Assumptions (per Unicode 16):\n  // - No case variants cross the Basic Multilingual Plane boundary\n  // - No cased chars appear beyond the Supplementary Multilingual Plane\n  if ((min < 65 && (max === 0xFFFF || max >= 0x1FFFF)) || (min === 0x10000 && max >= 0x1FFFF)) {\n    return found;\n  }\n  for (let i = min; i <= max; i++) {\n    const char = cp(i);\n    if (!charHasCase(char)) {\n      continue;\n    }\n    const charsOutsideRange = getIgnoreCaseMatchChars(char).filter(caseOfChar => {\n      const num = caseOfChar.codePointAt(0);\n      return num < min || num > max;\n    });\n    if (charsOutsideRange.length) {\n      found.push(...charsOutsideRange);\n      if (firstOnly) {\n        break;\n      }\n    }\n  }\n  return found;\n}\n\n// This shouldn't modifiy any char that has case\nfunction getCharEscape(codePoint, {isAfterBackref, inCharClass, useFlagV}) {\n  if (CharCodeEscapeMap.has(codePoint)) {\n    return CharCodeEscapeMap.get(codePoint);\n  }\n  if (\n    // Control chars, etc.; condition modeled on the Chrome developer console's display for strings\n    codePoint < 32 || (codePoint > 126 && codePoint < 160) ||\n    // Unicode planes 4-16; unassigned, special purpose, and private use area\n    codePoint > 0x3FFFF ||\n    // Avoid corrupting a preceding backref by immediately following it with a literal digit\n    (isAfterBackref && isDigitCharCode(codePoint))\n  ) {\n    // Don't convert codePoint `0` to `\\0` since that's corruptible by following literal digits\n    return codePoint > 0xFF ?\n      `\\\\u{${codePoint.toString(16).toUpperCase()}}` :\n      `\\\\x${codePoint.toString(16).toUpperCase().padStart(2, '0')}`;\n  }\n  const escapeChars = inCharClass ?\n    (useFlagV ? CharClassEscapeCharsFlagV : CharClassEscapeChars) :\n    BaseEscapeChars;\n  const char = cp(codePoint);\n  return (escapeChars.has(char) ? '\\\\' : '') + char;\n}\n\nfunction getCodePointRangesFromChars(chars) {\n  const codePoints = chars.map(char => char.codePointAt(0)).sort((a, b) => a - b);\n  const values = [];\n  let start = null;\n  for (let i = 0; i < codePoints.length; i++) {\n    if (codePoints[i + 1] === codePoints[i] + 1) {\n      start ??= codePoints[i];\n    } else if (start === null) {\n      values.push(codePoints[i]);\n    } else {\n      values.push([start, codePoints[i]]);\n      start = null;\n    }\n  }\n  return values;\n}\n\nfunction getGroupPrefix(atomic, flagMods, useFlagMods) {\n  if (atomic) {\n    return '>';\n  }\n  let mods = '';\n  if (flagMods && useFlagMods) {\n    const {enable, disable} = flagMods;\n    mods =\n      (enable?.ignoreCase ? 'i' : '') +\n      (enable?.dotAll ? 's' : '') +\n      (disable ? '-' : '') +\n      (disable?.ignoreCase ? 'i' : '') +\n      (disable?.dotAll ? 's' : '');\n  }\n  return `${mods}:`;\n}\n\nfunction getQuantifierStr({min, max, greedy, possessive}) {\n  let base;\n  if (!min && max === 1) {\n    base = '?';\n  } else if (!min && max === Infinity) {\n    base = '*';\n  } else if (min === 1 && max === Infinity) {\n    base = '+';\n  } else if (min === max) {\n    base = `{${min}}`;\n  } else {\n    base = `{${min},${max === Infinity ? '' : max}}`;\n  }\n  return base + (possessive ? '+' : (greedy ? '' : '?'));\n}\n\nfunction isDigitCharCode(value) {\n  return value > 47 && value < 58;\n}\n\nfunction isLiteralHyphen({type, value}) {\n  return type === AstTypes.Character && value === 45;\n}\n\nexport {\n  generate,\n};\n", "import {getOrInsert, throwIfNot} from './utils.js';\n\n/**\n@typedef {{\n  hiddenCaptures?: Array<number>;\n  lazyCompile?: boolean;\n  strategy?: string?;\n  transfers?: Array<[number, Array<number>]>;\n}} EmulatedRegExpOptions\n*/\n\n/**\nWorks the same as JavaScript's native `RegExp` constructor in all contexts, but can be given\nresults from `toRegExpDetails` to produce the same result as `toRegExp`.\n*/\nclass EmulatedRegExp extends RegExp {\n  /**\n  @type {Map<number, {\n    hidden?: true;\n    transferTo?: number;\n  }>}\n  */\n  #captureMap = new Map();\n\n  /**\n  @type {RegExp | EmulatedRegExp | null}\n  */\n  #compiled = null;\n\n  /**\n  @type {string}\n  */\n  #pattern;\n\n  /**\n  @type {Map<number, string>?}\n  */\n  #nameMap = null;\n\n  /**\n  @type {string?}\n  */\n  #strategy = null;\n\n  /**\n  Can be used to serialize the instance.\n  @type {EmulatedRegExpOptions}\n  */\n  rawOptions = {};\n\n  // Override the getter with one that works with lazy-compiled regexes\n  get source() {\n    return this.#pattern || '(?:)';\n  }\n\n  /**\n  @overload\n  @param {string} pattern\n  @param {string} [flags]\n  @param {EmulatedRegExpOptions} [options]\n  */\n  /**\n  @overload\n  @param {EmulatedRegExp} pattern\n  @param {string} [flags]\n  */\n  constructor(pattern, flags, options) {\n    const lazyCompile = !!options?.lazyCompile;\n    if (pattern instanceof RegExp) {\n      // Argument `options` isn't provided when regexes are copied, including as part of the\n      // internal handling of string methods `matchAll` and `split`\n      if (options) {\n        throw new Error('Cannot provide options when copying a regexp');\n      }\n      const re = pattern; // Alias for readability\n      super(re, flags);\n      this.#pattern = re.source;\n      if (re instanceof EmulatedRegExp) {\n        this.#captureMap = re.#captureMap;\n        this.#nameMap = re.#nameMap;\n        this.#strategy = re.#strategy;\n        this.rawOptions = re.rawOptions;\n      }\n    } else {\n      const opts = {\n        hiddenCaptures: [],\n        strategy: null,\n        transfers: [],\n        ...options,\n      };\n      super(lazyCompile ? '' : pattern, flags);\n      this.#pattern = pattern;\n      this.#captureMap = createCaptureMap(opts.hiddenCaptures, opts.transfers);\n      this.#strategy = opts.strategy;\n      // Don't add default values from `opts` since this gets serialized\n      this.rawOptions = options ?? {};\n    }\n    if (!lazyCompile) {\n      this.#compiled = this;\n    }\n  }\n\n  /**\n  Called internally by all String/RegExp methods that use regexes.\n  @override\n  @param {string} str\n  @returns {RegExpExecArray?}\n  */\n  exec(str) {\n    // Lazy compilation\n    if (!this.#compiled) {\n      const {lazyCompile, ...rest} = this.rawOptions;\n      this.#compiled = new EmulatedRegExp(this.#pattern, this.flags, rest);\n    }\n\n    const useLastIndex = this.global || this.sticky;\n    const pos = this.lastIndex;\n\n    if (this.#strategy === 'clip_search' && useLastIndex && pos) {\n      // Reset since this tests on a sliced string that we want to match at the start of\n      this.lastIndex = 0;\n      // Slicing the string can lead to mismatches when three edge cases are stacked on each other:\n      // 1. An uncommon use of `\\G` that relies on `clip_search`, combined with...\n      // 2. Lookbehind that searches behind the search start (not match start) position...\n      // 3. During a search when the regex's `lastIndex` isn't `0`.\n      // The `clip_search` strategy is therefore only allowed when lookbehind isn't present, if\n      // using strict `accuracy`\n      const match = this.#execCore(str.slice(pos));\n      if (match) {\n        adjustMatchDetailsForOffset(match, pos, str, this.hasIndices);\n        this.lastIndex += pos;\n      }\n      return match;\n    }\n\n    return this.#execCore(str);\n  }\n\n  /**\n  Adds support for hidden and transfer captures.\n  @param {string} str\n  @returns\n  */\n  #execCore(str) {\n    // Support lazy compilation\n    this.#compiled.lastIndex = this.lastIndex;\n    const match = super.exec.call(this.#compiled, str);\n    this.lastIndex = this.#compiled.lastIndex;\n\n    if (!match || !this.#captureMap.size) {\n      return match;\n    }\n\n    const matchCopy = [...match];\n    // Empty all but the first value of the array while preserving its other properties\n    match.length = 1;\n    let indicesCopy;\n    if (this.hasIndices) {\n      indicesCopy = [...match.indices];\n      match.indices.length = 1;\n    }\n    const mappedNums = [0];\n    for (let i = 1; i < matchCopy.length; i++) {\n      const {hidden, transferTo} = this.#captureMap.get(i) ?? {};\n      if (hidden) {\n        mappedNums.push(null);\n      } else {\n        mappedNums.push(match.length);\n        match.push(matchCopy[i]);\n        if (this.hasIndices) {\n          match.indices.push(indicesCopy[i]);\n        }\n      }\n\n      // Only transfer if the capture participated in the match\n      if (transferTo && matchCopy[i] !== undefined) {\n        const to = throwIfNot(mappedNums[transferTo]);\n        match[to] = matchCopy[i];\n        if (this.hasIndices) {\n          match.indices[to] = indicesCopy[i];\n        }\n        if (match.groups) {\n          if (!this.#nameMap) {\n            // Generate and cache the first time it's needed\n            this.#nameMap = createNameMap(this.source);\n          }\n          const name = this.#nameMap.get(transferTo);\n          if (name) {\n            match.groups[name] = matchCopy[i];\n            if (this.hasIndices) {\n              match.indices.groups[name] = indicesCopy[i];\n            }\n          }\n        }\n      }\n    }\n\n    return match;\n  }\n}\n\nfunction adjustMatchDetailsForOffset(match, offset, input, hasIndices) {\n  match.index += offset;\n  match.input = input;\n  if (hasIndices) {\n    const indices = match.indices;\n    for (let i = 0; i < indices.length; i++) {\n      const arr = indices[i];\n      if (arr) {\n        // Replace the array rather than updating values since the keys of `match.indices` and\n        // `match.indices.groups` share their value arrays by reference. Need to be precise in case\n        // they were previously altered separately\n        indices[i] = [arr[0] + offset, arr[1] + offset];\n      }\n    }\n    const groupIndices = indices.groups;\n    if (groupIndices) {\n      Object.keys(groupIndices).forEach(key => {\n        const arr = groupIndices[key];\n        if (arr) {\n          groupIndices[key] = [arr[0] + offset, arr[1] + offset];\n        }\n      });\n    }\n  }\n}\n\n/**\nBuild the capturing group map, with hidden/transfer groups marked to indicate their submatches\nshould get special handling in match results.\n@param {Array<number>} hiddenCaptures\n@param {Array<[number, Array<number>]>} transfers\n@returns {Map<number, {\n  hidden?: true;\n  transferTo?: number;\n}>}\n*/\nfunction createCaptureMap(hiddenCaptures, transfers) {\n  const captureMap = new Map();\n  for (const num of hiddenCaptures) {\n    captureMap.set(num, {\n      hidden: true,\n    });\n  }\n  for (const [to, from] of transfers) {\n    for (const num of from) {\n      getOrInsert(captureMap, num, {}).transferTo = to;\n    }\n  }\n  return captureMap;\n}\n\n/**\n@param {string} pattern\n@returns {Map<number, string>}\n*/\nfunction createNameMap(pattern) {\n  const re = /(?<capture>\\((?:\\?<(?![=!])(?<name>[^>]+)>|(?!\\?)))|\\\\?./gsu;\n  const map = new Map();\n  let numCharClassesOpen = 0;\n  let numCaptures = 0;\n  let match;\n  while ((match = re.exec(pattern))) {\n    const {0: m, groups: {capture, name}} = match;\n    // Relies on no unescaped literal `[` in char classes (valid in JS if not using flag v), but\n    // this library's generator never produces unescaped literal `[` even with `target` ES2018 (see\n    // `CharClassEscapeChars`)\n    if (m === '[') {\n      numCharClassesOpen++;\n    } else if (!numCharClassesOpen) {\n      if (capture) {\n        numCaptures++;\n        if (name) {\n          map.set(numCaptures, name);\n        }\n      }\n    } else if (m === ']') {\n      numCharClassesOpen--;\n    }\n  }\n  return map;\n}\n\nexport {\n  EmulatedRegExp,\n};\n", "// 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      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 {incrementIfAtLeast, noncapturingDelim, spliceStr} from './utils-internals.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 {Required<import('./regex.js').PluginResult>}\n*/\nfunction atomic(expression, data) {\n  const hiddenCaptures = data?.hiddenCaptures ?? [];\n  // Capture transfer is used by <github.com/slevithan/oniguruma-to-es>\n  let captureTransfers = data?.captureTransfers ?? new Map();\n  if (!/\\(\\?>/.test(expression)) {\n    return {\n      pattern: expression,\n      captureTransfers,\n      hiddenCaptures,\n    };\n  }\n\n  const aGDelim = '(?>';\n  const emulatedAGDelim = '(?:(?=(';\n  const captureNumMap = [0];\n  const addedHiddenCaptures = [];\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            const addedCaptureNum = numCapturesBeforeAG + numAGs;\n            // Replace `expression` and use `<$$N>` as a temporary wrapper for the backref so it\n            // can avoid backref renumbering afterward. Wrap the whole substitution (including the\n            // lookahead and following backref) in a noncapturing group to handle following\n            // quantifiers and literal digits\n            expression = `${expression.slice(0, aGPos)}${emulatedAGDelim}${\n                expression.slice(aGPos + aGDelim.length, index)\n              }))<$$${addedCaptureNum}>)${expression.slice(index + 1)}`;\n            hasProcessedAG = true;\n            addedHiddenCaptures.push(addedCaptureNum);\n            incrementIfAtLeast(hiddenCaptures, addedCaptureNum);\n            if (captureTransfers.size) {\n              const newCaptureTransfers = new Map();\n              captureTransfers.forEach((from, to) => {\n                newCaptureTransfers.set(\n                  to >= addedCaptureNum ? to + 1 : to,\n                  from.map(f => f >= addedCaptureNum ? f + 1 : f)\n                );\n              });\n              captureTransfers = newCaptureTransfers;\n            }\n            break;\n          }\n          numGroupsOpenInAG--;\n        }\n\n      } else if (m === ']') {\n        numCharClassesOpen--;\n      }\n    }\n  // Start over from the beginning of the atomic group's contents, in case the processed group\n  // contains additional atomic groups\n  } while (hasProcessedAG);\n\n  hiddenCaptures.push(...addedHiddenCaptures);\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\n  return {\n    pattern: expression,\n    captureTransfers,\n    hiddenCaptures,\n  };\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 {import('./regex.js').PluginResult}\n*/\nfunction possessive(expression) {\n  if (!(new RegExp(`${baseQuantifier}\\\\+`).test(expression))) {\n    return {\n      pattern: expression,\n    };\n  }\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\n  return {\n    pattern: expression,\n  };\n}\n\nexport {\n  atomic,\n  possessive,\n};\n", "import {Context, forEachUnescaped, getGroupContents, hasUnescaped, replaceUnescaped} from 'regex-utilities';\n\nconst r = String.raw;\nconst gRToken = r`\\\\g<(?<gRNameOrNum>[^>&]+)&R=(?<gRDepth>[^>]+)>`;\nconst recursiveToken = r`\\(\\?R=(?<rDepth>[^\\)]+)\\)|${gRToken}`;\nconst namedCaptureDelim = r`\\(\\?<(?![=!])(?<captureName>[^>]+)>`;\nconst captureDelim = r`${namedCaptureDelim}|(?<unnamed>\\()(?!\\?)`;\nconst token = new RegExp(r`${namedCaptureDelim}|${recursiveToken}|\\(\\?|\\\\?.`, 'gsu');\nconst overlappingRecursionMsg = 'Cannot use multiple overlapping recursions';\n\n/**\n@param {string} pattern\n@param {{\n  flags?: string;\n  captureTransfers?: Map<number, Array<number>>;\n  hiddenCaptures?: Array<number>;\n  mode?: 'plugin' | 'external';\n}} [data]\n@returns {{\n  pattern: string;\n  captureTransfers: Map<number, Array<number>>;\n  hiddenCaptures: Array<number>;\n}}\n*/\nfunction recursion(pattern, data) {\n  const {hiddenCaptures, mode} = {\n    hiddenCaptures: [],\n    mode: 'plugin',\n    ...data,\n  };\n  // Capture transfer is used by <github.com/slevithan/oniguruma-to-es>\n  let captureTransfers = data?.captureTransfers ?? new Map();\n  // Keep the initial fail-check (which avoids unneeded processing) as fast as possible by testing\n  // without the accuracy improvement of using `hasUnescaped` with `Context.DEFAULT`\n  if (!(new RegExp(recursiveToken, 'su').test(pattern))) {\n    return {\n      pattern,\n      captureTransfers,\n      hiddenCaptures,\n    };\n  }\n  if (mode === 'plugin' && hasUnescaped(pattern, r`\\(\\?\\(DEFINE\\)`, Context.DEFAULT)) {\n    throw new Error('DEFINE groups cannot be used with recursion');\n  }\n\n  const addedHiddenCaptures = [];\n  const hasNumberedBackref = hasUnescaped(pattern, r`\\\\[1-9]`, Context.DEFAULT);\n  const groupContentsStartPos = new Map();\n  const openGroups = [];\n  let hasRecursed = false;\n  let numCharClassesOpen = 0;\n  let numCapturesPassed = 0;\n  let match;\n  token.lastIndex = 0;\n  while ((match = token.exec(pattern))) {\n    const {0: m, groups: {captureName, rDepth, gRNameOrNum, gRDepth}} = match;\n    if (m === '[') {\n      numCharClassesOpen++;\n    } else if (!numCharClassesOpen) {\n\n      // `(?R=N)`\n      if (rDepth) {\n        assertMaxInBounds(rDepth);\n        if (hasRecursed) {\n          throw new Error(overlappingRecursionMsg);\n        }\n        if (hasNumberedBackref) {\n          // Could add support for numbered backrefs with extra effort, but it's probably not worth\n          // it. To trigger this error, the regex must include recursion and one of the following:\n          // - An interpolated regex that contains a numbered backref (since other numbered\n          //   backrefs are prevented by implicit flag n).\n          // - A numbered backref, when flag n is explicitly disabled.\n          // Note that Regex+'s extended syntax (atomic groups and sometimes subroutines) can also\n          // add numbered backrefs, but those work fine because external plugins like this one run\n          // *before* the transformation of built-in syntax extensions\n          throw new Error(\n            // When used in `external` mode by transpilers other than Regex+, backrefs might have\n            // gone through conversion from named to numbered, so avoid a misleading error\n            `${mode === 'external' ? 'Backrefs' : 'Numbered backrefs'} cannot be used with global recursion`\n          );\n        }\n        const left = pattern.slice(0, match.index);\n        const right = pattern.slice(token.lastIndex);\n        if (hasUnescaped(right, recursiveToken, Context.DEFAULT)) {\n          throw new Error(overlappingRecursionMsg);\n        }\n        const reps = +rDepth - 1;\n        pattern = makeRecursive(\n          left,\n          right,\n          reps,\n          false,\n          hiddenCaptures,\n          addedHiddenCaptures,\n          numCapturesPassed\n        );\n        captureTransfers = mapCaptureTransfers(\n          captureTransfers,\n          left,\n          reps,\n          addedHiddenCaptures.length,\n          0,\n          numCapturesPassed\n        );\n        // No need to parse further\n        break;\n      // `\\g<name&R=N>`, `\\g<number&R=N>`\n      } else if (gRNameOrNum) {\n        assertMaxInBounds(gRDepth);\n        let isWithinReffedGroup = false;\n        for (const g of openGroups) {\n          if (g.name === gRNameOrNum || g.num === +gRNameOrNum) {\n            isWithinReffedGroup = true;\n            if (g.hasRecursedWithin) {\n              throw new Error(overlappingRecursionMsg);\n            }\n            break;\n          }\n        }\n        if (!isWithinReffedGroup) {\n          throw new Error(r`Recursive \\g cannot be used outside the referenced group \"${\n            mode === 'external' ? gRNameOrNum : r`\\g<${gRNameOrNum}&R=${gRDepth}>`\n          }\"`);\n        }\n        const startPos = groupContentsStartPos.get(gRNameOrNum);\n        const groupContents = getGroupContents(pattern, startPos);\n        if (\n          hasNumberedBackref &&\n          hasUnescaped(groupContents, r`${namedCaptureDelim}|\\((?!\\?)`, Context.DEFAULT)\n        ) {\n          throw new Error(\n            // When used in `external` mode by transpilers other than Regex+, backrefs might have\n            // gone through conversion from named to numbered, so avoid a misleading error\n            `${mode === 'external' ? 'Backrefs' : 'Numbered backrefs'} cannot be used with recursion of capturing groups`\n          );\n        }\n        const groupContentsLeft = pattern.slice(startPos, match.index);\n        const groupContentsRight = groupContents.slice(groupContentsLeft.length + m.length);\n        const numAddedHiddenCapturesPreExpansion = addedHiddenCaptures.length;\n        const reps = +gRDepth - 1;\n        const expansion = makeRecursive(\n          groupContentsLeft,\n          groupContentsRight,\n          reps,\n          true,\n          hiddenCaptures,\n          addedHiddenCaptures,\n          numCapturesPassed\n        );\n        captureTransfers = mapCaptureTransfers(\n          captureTransfers,\n          groupContentsLeft,\n          reps,\n          addedHiddenCaptures.length - numAddedHiddenCapturesPreExpansion,\n          numAddedHiddenCapturesPreExpansion,\n          numCapturesPassed\n        );\n        const pre = pattern.slice(0, startPos);\n        const post = pattern.slice(startPos + groupContents.length);\n        // Modify the string we're looping over\n        pattern = `${pre}${expansion}${post}`;\n        // Step forward for the next loop iteration\n        token.lastIndex += expansion.length - m.length - groupContentsLeft.length - groupContentsRight.length;\n        openGroups.forEach(g => g.hasRecursedWithin = true);\n        hasRecursed = true;\n      } else if (captureName) {\n        numCapturesPassed++;\n        groupContentsStartPos.set(String(numCapturesPassed), token.lastIndex);\n        groupContentsStartPos.set(captureName, token.lastIndex);\n        openGroups.push({\n          num: numCapturesPassed,\n          name: captureName,\n        });\n      } else if (m[0] === '(') {\n        const isUnnamedCapture = m === '(';\n        if (isUnnamedCapture) {\n          numCapturesPassed++;\n          groupContentsStartPos.set(String(numCapturesPassed), token.lastIndex);\n        }\n        openGroups.push(isUnnamedCapture ? {num: numCapturesPassed} : {});\n      } else if (m === ')') {\n        openGroups.pop();\n      }\n\n    } else if (m === ']') {\n      numCharClassesOpen--;\n    }\n  }\n\n  hiddenCaptures.push(...addedHiddenCaptures);\n\n  return {\n    pattern,\n    captureTransfers,\n    hiddenCaptures,\n  };\n}\n\n/**\n@param {string} max\n*/\nfunction assertMaxInBounds(max) {\n  const errMsg = `Max depth must be integer between 2 and 100; used ${max}`;\n  if (!/^[1-9]\\d*$/.test(max)) {\n    throw new Error(errMsg);\n  }\n  max = +max;\n  if (max < 2 || max > 100) {\n    throw new Error(errMsg);\n  }\n}\n\n/**\n@param {string} left\n@param {string} right\n@param {number} reps\n@param {boolean} isSubpattern\n@param {Array<number>} hiddenCaptures\n@param {Array<number>} addedHiddenCaptures\n@param {number} numCapturesPassed\n@returns {string}\n*/\nfunction makeRecursive(\n  left,\n  right,\n  reps,\n  isSubpattern,\n  hiddenCaptures,\n  addedHiddenCaptures,\n  numCapturesPassed\n) {\n  const namesInRecursed = new Set();\n  // Can skip this work if not needed\n  if (isSubpattern) {\n    forEachUnescaped(left + right, namedCaptureDelim, ({groups: {captureName}}) => {\n      namesInRecursed.add(captureName);\n    }, Context.DEFAULT);\n  }\n  const rest = [\n    reps,\n    isSubpattern ? namesInRecursed : null,\n    hiddenCaptures,\n    addedHiddenCaptures,\n    numCapturesPassed,\n  ];\n  // Depth 2: 'left(?:left(?:)right)right'\n  // Depth 3: 'left(?:left(?:left(?:)right)right)right'\n  // Empty group in the middle separates tokens and absorbs a following quantifier if present\n  return `${left}${\n    repeatWithDepth(`(?:${left}`, 'forward', ...rest)\n  }(?:)${\n    repeatWithDepth(`${right})`, 'backward', ...rest)\n  }${right}`;\n}\n\n/**\n@param {string} pattern\n@param {'forward' | 'backward'} direction\n@param {number} reps\n@param {Set<string> | null} namesInRecursed\n@param {Array<number>} hiddenCaptures\n@param {Array<number>} addedHiddenCaptures\n@param {number} numCapturesPassed\n@returns {string}\n*/\nfunction repeatWithDepth(\n  pattern,\n  direction,\n  reps,\n  namesInRecursed,\n  hiddenCaptures,\n  addedHiddenCaptures,\n  numCapturesPassed\n) {\n  const startNum = 2;\n  const getDepthNum = i => direction === 'forward' ? (i + startNum) : (reps - i + startNum - 1);\n  let result = '';\n  for (let i = 0; i < reps; i++) {\n    const depthNum = getDepthNum(i);\n    result += replaceUnescaped(\n      pattern,\n      r`${captureDelim}|\\\\k<(?<backref>[^>]+)>`,\n      ({0: m, groups: {captureName, unnamed, backref}}) => {\n        if (backref && namesInRecursed && !namesInRecursed.has(backref)) {\n          // Don't alter backrefs to groups outside the recursed subpattern\n          return m;\n        }\n        const suffix = `_$${depthNum}`;\n        if (unnamed || captureName) {\n          const addedCaptureNum = numCapturesPassed + addedHiddenCaptures.length + 1;\n          addedHiddenCaptures.push(addedCaptureNum);\n          incrementIfAtLeast(hiddenCaptures, addedCaptureNum);\n          return unnamed ? m : `(?<${captureName}${suffix}>`;\n        }\n        return r`\\k<${backref}${suffix}>`;\n      },\n      Context.DEFAULT\n    );\n  }\n  return result;\n}\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 {Map<number, Array<number>>} captureTransfers\n@param {string} left\n@param {number} reps\n@param {number} numCapturesAddedInExpansion\n@param {number} numAddedHiddenCapturesPreExpansion\n@param {number} numCapturesPassed\n@returns {Map<number, Array<number>>}\n*/\nfunction mapCaptureTransfers(captureTransfers, left, reps, numCapturesAddedInExpansion, numAddedHiddenCapturesPreExpansion, numCapturesPassed) {\n  if (captureTransfers.size && numCapturesAddedInExpansion) {\n    let numCapturesInLeft = 0;\n    forEachUnescaped(left, captureDelim, () => numCapturesInLeft++, Context.DEFAULT);\n    // Is 0 for global recursion\n    const recursionDelimCaptureNum = numCapturesPassed - numCapturesInLeft + numAddedHiddenCapturesPreExpansion;\n    const newCaptureTransfers = new Map();\n    captureTransfers.forEach((from, to) => {\n      const numCapturesInRight = (numCapturesAddedInExpansion - (numCapturesInLeft * reps)) / reps;\n      const numCapturesAddedInLeft = numCapturesInLeft * reps;\n      const newTo = to > (recursionDelimCaptureNum + numCapturesInLeft) ? to + numCapturesAddedInExpansion : to;\n      const newFrom = [];\n      for (const f of from) {\n        // Before the recursed subpattern\n        if (f <= recursionDelimCaptureNum) {\n          newFrom.push(f);\n        // After the recursed subpattern\n        } else if (f > (recursionDelimCaptureNum + numCapturesInLeft + numCapturesInRight)) {\n          newFrom.push(f + numCapturesAddedInExpansion);\n        // Within the recursed subpattern, on the left of the recursion token\n        } else if (f <= (recursionDelimCaptureNum + numCapturesInLeft)) {\n          for (let i = 0; i <= reps; i++) {\n            newFrom.push(f + (numCapturesInLeft * i));\n          }\n        // Within the recursed subpattern, on the right of the recursion token\n        } else {\n          for (let i = 0; i <= reps; i++) {\n            newFrom.push(f + numCapturesAddedInLeft + (numCapturesInRight * i));\n          }\n        }\n      }\n      newCaptureTransfers.set(newTo, newFrom);\n    });\n    return newCaptureTransfers;\n  }\n  return captureTransfers;\n}\n\nexport {\n  recursion,\n};\n"],
  "mappings": "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",
  "names": ["index_exports", "__export", "EmulatedRegExp", "toOnigurumaAst", "toRegExp", "toRegExpDetails", "cp", "r", "envFlags", "getNewCurrentFlags", "current", "enable", "disable", "getOrInsert", "map", "key", "defaultValue", "isMinTarget", "target", "min", "EsVersion", "throwIfNot", "value", "msg", "EsVersion", "Target", "getOptions", "options", "opts", "envFlags", "CharsWithoutIgnoreCaseExpansion", "cp", "getIgnoreCaseMatchChars", "char", "set", "lower", "upper", "title", "LowerToTitleCaseMap", "altLower", "LowerToAlternativeLowerCaseMap", "altUpper", "LowerToAlternativeUpperCaseMap", "JsUnicodeProperties", "JsUnicodePropertiesMap", "p", "slug", "JsUnicodePropertiesOfStrings", "JsUnicodePropertiesOfStringsMap", "titleEntry", "titleRange", "PosixClassesMap", "r", "PosixProperties", "range", "start", "end", "i", "name", "codePoint", "UnicodePropertiesWithSpecificCase", "TokenTypes", "TokenCharacterSetKinds", "TokenDirectiveKinds", "TokenGroupKinds", "EscapeCharCodes", "charClassOpenPattern", "r", "sharedEscapesPattern", "quantifierRe", "tokenRe", "charClassTokenRe", "tokenize", "pattern", "flags", "rules", "extended", "xStack", "context", "isXOn", "tokens", "match", "result", "getTokenWithDetails", "potentialUnnamedCaptureTokens", "numNamedAndOptInUnnamedCaptures", "t", "i", "numCaptures", "splitEscapedNumToken", "m", "lastIndex", "m0", "m1", "getAllTokensForCharClass", "createToken", "createTokenForSharedEscape", "createTokenForFlagMod", "token", "end", "re", "kind", "createTokenForQuantifier", "assertSingleCodePoint", "opener", "numCharClassesOpen", "createTokenForAnyTokenWithinCharClass", "raw", "posix", "PosixClassesMap", "inCharClass", "char1", "createTokenForControlChar", "createTokenForShorthandCharClass", "createTokenForUnicodeProperty", "bytes", "hex", "decoded", "encoder", "char", "byte", "getValidatedHexCharCode", "type", "data", "on", "off", "enabledFlags", "getFlagPropsForToken", "disabledFlags", "flagChanges", "min", "max", "limit", "lower", "p", "neg", "value", "negate", "obj", "matches", "hasOnlyChild", "alternatives", "kidFn", "isAlwaysZeroLength", "type", "AstTypes", "isAlwaysNonZeroLength", "node", "types", "isConsumptiveGroup", "isLookaround", "kind", "AstAssertionKinds", "traverse", "path", "state", "visitor", "ast", "traverseArray", "array", "parent", "i", "keyShift", "traverseNode", "node", "key", "container", "skipTraversingKidsOfPath", "throwIfNot", "shifted", "newNode", "setParent", "visitorKey", "getAstTypeAliases", "methods", "enterFn", "exitFn", "AstTypes", "isLookaround", "AstTypeAliases", "types", "isConsumptiveGroup", "AstTypes", "AstAbsentFunctionKinds", "AstAssertionKinds", "AstCharacterSetKinds", "TokenCharacterSetKinds", "AstDirectiveKinds", "TokenDirectiveKinds", "AstVariableLengthCharacterSetKinds", "parse", "tokens", "flags", "rules", "options", "opts", "context", "walk", "parent", "state", "token", "TokenTypes", "createAlternative", "createAssertionFromToken", "parseBackreference", "createCharacter", "parseCharacterClassHyphen", "parseCharacterClassOpen", "parseCharacterSet", "createDirectiveFromToken", "parseGroupOpen", "parseQuantifier", "parseSubroutine", "createVariableLengthCharacterSet", "ast", "createRegex", "createPattern", "createFlags", "top", "node", "capturingGroups", "hasNumberedRef", "namedGroupsByName", "subroutines", "ref", "r", "traverse", "raw", "hasKWrapper", "fromNum", "num", "isRelative", "numCapturesToLeft", "orphan", "createBackreference", "numberedRef", "prevSiblingNode", "nextToken", "nextNode", "createCharacterClassRange", "verbose", "firstClassToken", "createCharacterClass", "intersection", "throwIfUnclosedCharacterClass", "cc", "optimizeCharacterClassIntersection", "skipPropertyNameValidation", "kind", "negate", "value", "normalized", "slug", "PosixProperties", "createUnicodeProperty", "createCharacterSet", "skipLookbehindValidation", "createByGroupKind", "isAbsentFunction", "isLookbehind", "isNegLookbehind", "getOrInsert", "throwIfUnclosedGroup", "alt", "child", "msg", "getOptimizedGroup", "min", "max", "greedy", "possessive", "quantifiedNode", "createQuantifier", "createSubroutine", "createAbsentFunction", "createAssertion", "throwIfNot", "name", "number", "TokenGroupKinds", "createGroup", "createCapturingGroup", "createLookaround", "hasName", "isValidGroupNameOniguruma", "charCode", "hex", "createCharacterClassIntersection", "ignoreCase", "dotAll", "extended", "digitIsAscii", "spaceIsAscii", "wordIsAscii", "atomic", "element", "pattern", "getJsUnicodePropertyName", "slugged", "JsUnicodePropertiesOfStringsMap", "jsName", "JsUnicodePropertiesMap", "m", "firstAltFirstEl", "hasOnlyChild", "kid", "i", "firstChild", "r", "seq", "sTags", "emoji_regex_xs_default", "transform", "ast", "options", "opts", "firstPassState", "isMinTarget", "traverse", "FirstPassVisitor", "globalFlags", "secondPassState", "SecondPassVisitor", "thirdPassState", "ThirdPassVisitor", "node", "replaceWith", "group", "prepContainer", "createGroup", "adoptAndSwapKids", "createLookaround", "createUnicodeProperty", "quantifier", "createQuantifier", "parent", "key", "flagDirectivesByAlt", "flagDirectives", "el", "AstDirectiveKinds", "i", "forwardSiblingAlt", "getOrInsert", "flags", "getCombinedFlagModsFromFlagNodes", "flagGroup", "container", "remove", "state", "kind", "negate", "asciiWordBoundaries", "avoidSubclass", "supportedGNodes", "wordIsAscii", "AstAssertionKinds", "parseFragment", "r", "prev", "isAlwaysNonZeroLength", "createAssertion", "b", "defaultWordChar", "B", "jsGroupNameMap", "ref", "isValidGroupNameJs", "getAndStoreJsGroupName", "subroutineRefMap", "name", "accuracy", "minTargetEs2024", "digitIsAscii", "spaceIsAscii", "value", "AstCharacterSetKinds", "createCharacterSet", "setNegate", "asciiSpaceChar", "JsUnicodeProperties", "ascii", "cp", "PosixClassesMap", "path", "removeAllPrevSiblings", "removeAllNextSiblings", "traverseReplacement", "firstAltFirstEl", "topLevel", "hasOnlyChild", "kid", "AstTypes", "f", "enable", "disable", "leadingGs", "hasAltWithLeadG", "hasAltWithoutLeadG", "alt", "leadingG", "getLeadingG", "g", "_", "passedLookbehind", "strategy", "AstVariableLengthCharacterSetKinds", "emoji", "emoji_regex_xs_default", "multiplexCapturesToLeftByRef", "reffedNodesByReferencer", "orphan", "skip", "groupOriginByCopy", "groupsByName", "openRefs", "origin", "recursion", "createRecursion", "multiplexNodes", "multiplex", "groupsWithSameName", "hasDuplicateNameToRemove", "groupInfo", "getNewCurrentFlags", "reffed", "reffedGroupNode", "isGlobalRecursion", "expandedSubroutine", "cloneCapturingGroup", "replacement", "reffedGroupFlagMods", "getAllParents", "reffedGroupFlags", "areFlagsEqual", "getFlagModsFromFlags", "participants", "canParticipateWithNode", "alts", "createAlternative", "createBackreference", "numCapsNeeded", "emptyCapture", "createCapturingGroup", "kids", "getContainerAccessor", "a", "capture", "rightmostPoint", "kidsOfParent", "getKids", "hasDescendant", "obj", "originMap", "up", "up2", "store", "filterFn", "results", "map", "jsName", "accessor", "flagNodes", "flagProps", "combinedFlags", "prop", "dotAll", "ignoreCase", "mods", "els", "firstToConsider", "isLoneGLookaround", "isAlwaysZeroLength", "isLookaround", "isConsumptiveGroup", "gNodesForGroup", "descendant", "pattern", "parse", "tokenize", "visitor", "generate", "ast", "options", "opts", "getOptions", "minTargetEs2024", "isMinTarget", "minTargetEs2025", "recursionLimit", "hasCaseInsensitiveNode", "hasCaseSensitiveNode", "iStack", "traverse", "isIOn", "FlagModifierVisitor", "appliedGlobalFlags", "lastNode", "state", "gen", "node", "AstTypes", "genAssertion", "genBackreference", "genCapturingGroup", "genCharacter", "genCharacterClass", "genCharacterClassRange", "genCharacterSet", "genFlags", "genGroup", "getQuantifierStr", "genRecursion", "result", "value", "key", "getOrInsert", "currentModI", "getNewCurrentFlags", "_", "charHasCase", "cp", "skip", "getCasesOutsideCharClassRange", "AstCharacterSetKinds", "UnicodePropertiesWithSpecificCase", "BaseEscapeChars", "CharClassEscapeChars", "CharClassEscapeCharsFlagV", "CharCodeEscapeMap", "r", "casedRe", "char", "kind", "negate", "alternatives", "isLookaround", "AstAssertionKinds", "ref", "name", "number", "data", "origin", "escaped", "getCharEscape", "cases", "getIgnoreCaseMatchChars", "parent", "elements", "envFlags", "isLiteralHyphen", "createCharacter", "genClass", "firstType", "min", "max", "escOpts", "minStr", "maxStr", "extraChars", "charsOutsideRange", "getCodePointRangesFromChars", "atomic", "flags", "currentFlags", "contents", "getGroupPrefix", "limit", "firstOnly", "found", "caseOfChar", "num", "codePoint", "isAfterBackref", "inCharClass", "useFlagV", "isDigitCharCode", "escapeChars", "chars", "codePoints", "a", "b", "values", "start", "i", "flagMods", "useFlagMods", "mods", "enable", "disable", "greedy", "possessive", "base", "type", "EmulatedRegExp", "_EmulatedRegExp", "#captureMap", "#compiled", "#pattern", "#nameMap", "#strategy", "pattern", "flags", "options", "lazyCompile", "re", "opts", "createCaptureMap", "str", "rest", "useLastIndex", "pos", "match", "#execCore", "adjustMatchDetailsForOffset", "matchCopy", "indicesCopy", "mappedNums", "hidden", "transferTo", "to", "throwIfNot", "createNameMap", "name", "offset", "input", "hasIndices", "indices", "arr", "groupIndices", "key", "hiddenCaptures", "transfers", "captureMap", "num", "from", "getOrInsert", "map", "numCharClassesOpen", "numCaptures", "m", "capture", "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", "r", "gRToken", "recursiveToken", "namedCaptureDelim", "captureDelim", "token", "overlappingRecursionMsg", "recursion", "pattern", "data", "hiddenCaptures", "mode", "captureTransfers", "hasUnescaped", "Context", "addedHiddenCaptures", "hasNumberedBackref", "groupContentsStartPos", "openGroups", "hasRecursed", "numCharClassesOpen", "numCapturesPassed", "match", "m", "captureName", "rDepth", "gRNameOrNum", "gRDepth", "assertMaxInBounds", "left", "right", "reps", "makeRecursive", "mapCaptureTransfers", "isWithinReffedGroup", "g", "startPos", "groupContents", "getGroupContents", "groupContentsLeft", "groupContentsRight", "numAddedHiddenCapturesPreExpansion", "expansion", "pre", "post", "isUnnamedCapture", "max", "errMsg", "isSubpattern", "namesInRecursed", "forEachUnescaped", "rest", "repeatWithDepth", "direction", "getDepthNum", "i", "result", "depthNum", "replaceUnescaped", "unnamed", "backref", "suffix", "addedCaptureNum", "incrementIfAtLeast", "arr", "threshold", "numCapturesAddedInExpansion", "numCapturesInLeft", "recursionDelimCaptureNum", "newCaptureTransfers", "from", "to", "numCapturesInRight", "numCapturesAddedInLeft", "newTo", "newFrom", "f", "toOnigurumaAst", "pattern", "options", "opts", "parse", "tokenize", "toRegExp", "d", "toRegExpDetails", "EmulatedRegExp", "getOptions", "tokenized", "onigurumaAst", "regexAst", "transform", "generated", "generate", "recursionResult", "recursion", "possessiveResult", "possessive", "atomicResult", "atomic", "details", "hiddenCaptures", "a", "b", "transfers", "strategy", "lazyCompile"]
}