pi-fileops 0.3.7

package/node_modules/oniguruma-parser/dist/parser/parse.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/parser/parse.ts"],
+  "sourcesContent": ["import type {AssertionToken, BackreferenceToken, CharacterClassHyphenToken, CharacterClassOpenToken, CharacterSetToken, FlagGroupModifiers, FlagProperties, GroupOpenToken, QuantifierToken, SubroutineToken, Token, TokenCharacterSetKind, TokenDirectiveKind, TokenNamedCalloutKind, TokenQuantifierKind} from '../tokenizer/tokenize.js';\nimport {tokenize} from '../tokenizer/tokenize.js';\nimport {cpOf, getOrInsert, PosixClassNames, r, throwIfNullish} from '../utils.js';\nimport {hasOnlyChild, isAlternativeContainer, isQuantifiable} from './node-utils.js';\n\n// Watch out for the DOM `Node` interface!\ntype Node =\n  AbsenceFunctionNode |\n  AlternativeNode |\n  AssertionNode |\n  BackreferenceNode |\n  CapturingGroupNode |\n  CharacterNode |\n  CharacterClassNode |\n  CharacterClassRangeNode |\n  CharacterSetNode |\n  DirectiveNode |\n  FlagsNode |\n  GroupNode |\n  LookaroundAssertionNode |\n  NamedCalloutNode |\n  QuantifierNode |\n  RegexNode |\n  SubroutineNode;\n\ntype OnigurumaAst = RegexNode;\n\ntype ParentNode =\n  AlternativeContainerNode |\n  AlternativeNode |\n  CharacterClassNode |\n  CharacterClassRangeNode |\n  QuantifierNode;\n\n// See also `isAlternativeContainer`\ntype AlternativeContainerNode =\n  AbsenceFunctionNode | // Some sub-kinds aren't alternative containers\n  CapturingGroupNode |\n  GroupNode |\n  LookaroundAssertionNode |\n  RegexNode;\n\ntype AlternativeElementNode =\n  AbsenceFunctionNode |\n  AssertionNode |\n  BackreferenceNode |\n  CapturingGroupNode |\n  CharacterNode |\n  CharacterClassNode |\n  CharacterSetNode |\n  DirectiveNode |\n  GroupNode |\n  LookaroundAssertionNode |\n  NamedCalloutNode |\n  QuantifierNode |\n  SubroutineNode;\n\ntype CharacterClassElementNode =\n  CharacterNode |\n  CharacterClassNode |\n  CharacterClassRangeNode |\n  CharacterSetNode;\n\n// See also `isQuantifiable`\ntype QuantifiableNode =\n  AbsenceFunctionNode |\n  BackreferenceNode |\n  CapturingGroupNode |\n  CharacterNode |\n  CharacterClassNode |\n  CharacterSetNode |\n  GroupNode |\n  QuantifierNode |\n  SubroutineNode;\n\n// TODO: Support remaining kinds; see <github.com/slevithan/oniguruma-to-es/issues/13>\ntype NodeAbsenceFunctionKind =\n  'repeater';\n\ntype NodeAssertionKind =\n  'line_end' |\n  'line_start' |\n  'search_start' |\n  'string_end' |\n  'string_end_newline' |\n  'string_start' |\n  'text_segment_boundary' |\n  'word_boundary';\n\ntype NodeCharacterClassKind =\n  'union' |\n  'intersection';\n\ntype NodeCharacterSetKind = TokenCharacterSetKind;\n\ntype NodeDirectiveKind = TokenDirectiveKind;\n\ntype NodeLookaroundAssertionKind =\n  'lookahead' |\n  'lookbehind';\n\ntype NodeNamedCalloutKind = TokenNamedCalloutKind;\n\ntype NodeQuantifierKind = TokenQuantifierKind;\n\ntype UnicodePropertyMap = Map<string, string>;\n\ntype Context = {\n  capturingGroups: Array<CapturingGroupNode>;\n  hasNumberedRef: boolean;\n  namedGroupsByName: Map<string, Array<CapturingGroupNode>>;\n  nextIndex: number;\n  normalizeUnknownPropertyNames: boolean;\n  parent: ParentNode;\n  skipBackrefValidation: boolean;\n  skipLookbehindValidation: boolean;\n  skipPropertyNameValidation: boolean;\n  subroutines: Array<SubroutineNode>;\n  tokens: Array<Token>;\n  unicodePropertyMap: UnicodePropertyMap | null;\n  walk: (parent: ParentNode, state: State) => Node;\n};\n\n// Top-level `walk` calls are given empty state; nested calls can add data specific to their `walk`\ntype State = {\n  isCheckingRangeEnd?: boolean;\n  isInAbsenceFunction?: boolean;\n  isInLookbehind?: boolean;\n  isInNegLookbehind?: boolean;\n};\n\ntype ParseOptions = {\n  flags?: string;\n  normalizeUnknownPropertyNames?: boolean;\n  rules?: {\n    captureGroup?: boolean;\n    singleline?: boolean;\n  };\n  skipBackrefValidation?: boolean;\n  skipLookbehindValidation?: boolean;\n  skipPropertyNameValidation?: boolean;\n  unicodePropertyMap?: UnicodePropertyMap | null;\n};\n\nfunction parse(pattern: string, options: ParseOptions = {}): OnigurumaAst {\n  const opts: Required<ParseOptions> = {\n    flags: '',\n    normalizeUnknownPropertyNames: false,\n    skipBackrefValidation: false,\n    skipLookbehindValidation: false,\n    skipPropertyNameValidation: false,\n    // `toOnigurumaAst` provides `OnigUnicodePropertyMap`, but it can be custom or `null`\n    unicodePropertyMap: null,\n    ...options,\n    rules: {\n      captureGroup: false, // `ONIG_OPTION_CAPTURE_GROUP`\n      singleline: false, // `ONIG_OPTION_SINGLELINE`\n      ...options.rules,\n    },\n  };\n  const tokenized = tokenize(pattern, {\n    // Limit to the tokenizer's options\n    flags: opts.flags,\n    rules: {\n      captureGroup: opts.rules.captureGroup,\n      singleline: opts.rules.singleline,\n    },\n  });\n  const walk: Context['walk'] = (parent, state) => {\n    const token = tokenized.tokens[context.nextIndex];\n    context.parent = parent;\n    // Advance for the next iteration\n    context.nextIndex++;\n    switch (token.type) {\n      case 'Alternator':\n        // Top-level only; groups handle their own alternators\n        return createAlternative();\n      case 'Assertion':\n        return parseAssertion(token);\n      case 'Backreference':\n        return parseBackreference(token, context);\n      case 'Character':\n        return createCharacter(token.value, {useLastValid: !!state.isCheckingRangeEnd});\n      case 'CharacterClassHyphen':\n        return parseCharacterClassHyphen(token, context, state);\n      case 'CharacterClassOpen':\n        return parseCharacterClassOpen(token, context, state);\n      case 'CharacterSet':\n        return parseCharacterSet(token, context);\n      case 'Directive':\n        return createDirective(token.kind, {flags: token.flags});\n      case 'GroupOpen':\n        return parseGroupOpen(token, context, state);\n      case 'NamedCallout':\n        return createNamedCallout(token.kind, token.tag, token.arguments);\n      case 'Quantifier':\n        return parseQuantifier(token, context);\n      case 'Subroutine':\n        return parseSubroutine(token, context);\n      default:\n        throw new Error(`Unexpected token type \"${token.type}\"`);\n    }\n  }\n  const context: Context = {\n    capturingGroups: [],\n    hasNumberedRef: false,\n    namedGroupsByName: new Map(),\n    nextIndex: 0,\n    normalizeUnknownPropertyNames: opts.normalizeUnknownPropertyNames,\n    parent: null!, // Assigned by `walk`\n    skipBackrefValidation: opts.skipBackrefValidation,\n    skipLookbehindValidation: opts.skipLookbehindValidation,\n    skipPropertyNameValidation: opts.skipPropertyNameValidation,\n    subroutines: [],\n    tokens: tokenized.tokens,\n    unicodePropertyMap: opts.unicodePropertyMap,\n    walk,\n  };\n\n  // ## AST construction from tokens\n  const ast = createRegex(createFlags(tokenized.flags));\n  let top = ast.body[0]; // First alt\n  while (context.nextIndex < tokenized.tokens.length) {\n    const node = walk(top, {});\n    if (node.type === 'Alternative') {\n      ast.body.push(node);\n      top = node;\n    } else {\n      top.body.push(node as AlternativeElementNode);\n    }\n  }\n\n  // ## Validation that requires knowledge about the complete pattern\n  // `context` updated by the preceding `walk` loop\n  const {capturingGroups, hasNumberedRef, namedGroupsByName, subroutines} = context;\n  if (hasNumberedRef && namedGroupsByName.size && !opts.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      if (ref) {\n        capturingGroups[ref - 1].isSubroutined = true;\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    } else {\n      namedGroupsByName.get(ref)![0].isSubroutined = true;\n    }\n  }\n\n  return ast;\n}\n\nfunction parseAssertion({kind}: AssertionToken): AssertionNode {\n  return createAssertion(\n    throwIfNullish({\n      '^': 'line_start',\n      '$': 'line_end',\n      '\\\\A': 'string_start',\n      '\\\\b': 'word_boundary',\n      '\\\\B': 'word_boundary',\n      '\\\\G': 'search_start',\n      '\\\\y': 'text_segment_boundary',\n      '\\\\Y': 'text_segment_boundary',\n      '\\\\z': 'string_end',\n      '\\\\Z': 'string_end_newline',\n    }[kind], `Unexpected assertion kind \"${kind}\"`) as NodeAssertionKind,\n    {negate: kind === r`\\B` || kind === r`\\Y`}\n  );\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({raw}: BackreferenceToken, context: Context): BackreferenceNode {\n  const hasKWrapper = /^\\\\k[<']/.test(raw);\n  const ref = hasKWrapper ? raw.slice(3, -1) : raw.slice(1);\n  const fromNum = (num: number, 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 it's currently an error in this library.\n    // - Most such placements are mistakes and can never match, due to Onig's behavior for backrefs\n    //   to nonparticipating groups.\n    //   - The edge cases where they're matchable rely on rules for backref resetting within\n    //     quantified groups that are different in JS (thus not emulatable in `oniguruma-to-es`).\n    // - Erroring matches the correct behavior of named backrefs.\n    // - For unenclosed backrefs, this only affects `\\1`-`\\9` since it's not a backref in the first\n    //   place if using `\\10` or higher and not as many capturing groups are defined to the left\n    //   (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 `oniguruma-to-es` transformer\n    if (num > numCapturesToLeft) {\n      // Skipping the error breaks assumptions and might create edge case issues, since backrefs\n      // are required to come after their captures; unfortunately this option is needed for\n      // 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(_: CharacterClassHyphenToken, context: Context, state: State): CharacterNode | CharacterClassRangeNode {\n  const {tokens, walk} = context;\n  const parent = context.parent as CharacterClassNode;\n  const prevSiblingNode = parent.body.at(-1);\n  const nextToken = tokens[context.nextIndex];\n  if (\n    !state.isCheckingRangeEnd &&\n    prevSiblingNode &&\n    prevSiblingNode.type !== 'CharacterClass' &&\n    prevSiblingNode.type !== 'CharacterClassRange' &&\n    nextToken &&\n    nextToken.type !== 'CharacterClassOpen' &&\n    nextToken.type !== 'CharacterClassClose' &&\n    nextToken.type !== 'CharacterClassIntersector'\n  ) {\n    const nextNode = walk(parent, {\n      ...state,\n      isCheckingRangeEnd: true,\n    });\n    if (prevSiblingNode.type === 'Character' && nextNode.type === 'Character') {\n      parent.body.pop();\n      return createCharacterClassRange(prevSiblingNode, nextNode);\n    }\n    throw new Error('Invalid character class range');\n  }\n  return createCharacter(cpOf('-'));\n}\n\nfunction parseCharacterClassOpen({negate}: CharacterClassOpenToken, context: Context, state: State): CharacterClassNode {\n  const {tokens, walk} = context;\n  const intersections = [createCharacterClass()];\n  const ccFirstToken = tokens[context.nextIndex];\n  let nextToken = throwIfUnclosedCharacterClass(ccFirstToken);\n  while (nextToken.type !== 'CharacterClassClose') {\n    if (nextToken.type === 'CharacterClassIntersector') {\n      intersections.push(createCharacterClass());\n      // Skip the intersector\n      context.nextIndex++;\n    } else {\n      const cc = intersections.at(-1)!; // Always at least one\n      cc.body.push(walk(cc, state) as CharacterClassElementNode);\n    }\n    nextToken = throwIfUnclosedCharacterClass(tokens[context.nextIndex], ccFirstToken);\n  }\n  const node = createCharacterClass({negate});\n  if (intersections.length === 1) {\n    node.body = intersections[0].body;\n  } else {\n    node.kind = 'intersection';\n    node.body = intersections.map(cc => cc.body.length === 1 ? cc.body[0] : cc);\n  }\n  // Skip the closing square bracket\n  context.nextIndex++;\n  return node;\n}\n\nfunction parseCharacterSet({kind, negate, value}: CharacterSetToken, context: Context): CharacterSetNode {\n  const {normalizeUnknownPropertyNames, skipPropertyNameValidation, unicodePropertyMap} = context;\n  if (kind === 'property') {\n    const normalized = slug(value!);\n    // Don't treat as POSIX if it's in the provided list of Unicode property names\n    if (PosixClassNames.has(normalized) && !unicodePropertyMap?.has(normalized)) {\n      kind = 'posix';\n      value = normalized;\n    } else {\n      return createUnicodeProperty(value!, {\n        negate,\n        normalizeUnknownPropertyNames,\n        skipPropertyNameValidation,\n        unicodePropertyMap,\n      });\n    }\n  }\n  if (kind === 'posix') {\n    return createPosixClass(value!, {negate});\n  }\n  return createCharacterSet(kind, {negate});\n}\n\nfunction parseGroupOpen(token: GroupOpenToken, context: Context, state: State): AbsenceFunctionNode | CapturingGroupNode | GroupNode | LookaroundAssertionNode {\n  const {tokens, capturingGroups, namedGroupsByName, skipLookbehindValidation, walk} = context;\n  const node = createByGroupKind(token);\n  const isThisAbsenceFunction = node.type === 'AbsenceFunction';\n  const isThisLookbehind = isLookbehind(node);\n  const isThisNegLookbehind = isThisLookbehind && 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 === 'CapturingGroup') {\n    capturingGroups.push(node);\n    if (node.name) {\n      getOrInsert(namedGroupsByName, node.name, []).push(node);\n    }\n  }\n  // Don't allow nested absence functions\n  if (isThisAbsenceFunction && state.isInAbsenceFunction) {\n    // Is officially unsupported in Onig but doesn't throw, gives strange results\n    throw new Error('Nested absence function not supported by Oniguruma');\n  }\n  let nextToken = throwIfUnclosedGroup(tokens[context.nextIndex]);\n  while (nextToken.type !== 'GroupClose') {\n    if (nextToken.type === 'Alternator') {\n      node.body.push(createAlternative());\n      // Skip the alternator\n      context.nextIndex++;\n    } else {\n      const alt = node.body.at(-1)!; // Always at least one\n      const child = walk(alt, {\n        ...state,\n        isInAbsenceFunction: state.isInAbsenceFunction || isThisAbsenceFunction,\n        isInLookbehind: state.isInLookbehind || isThisLookbehind,\n        isInNegLookbehind: state.isInNegLookbehind || isThisNegLookbehind,\n      }) as AlternativeElementNode;\n      alt.body.push(child);\n      // Centralized validation of lookbehind contents\n      if ((isThisLookbehind || state.isInLookbehind) && !skipLookbehindValidation) {\n        // JS supports all features within lookbehind, but Onig doesn't. Absence 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 (isThisNegLookbehind || state.isInNegLookbehind) {\n          // - Invalid: `(?=\u2026)`, `(?!\u2026)`, capturing groups\n          // - Valid: `(?<=\u2026)`, `(?<!\u2026)`\n          if (isLookahead(child) || child.type === 'CapturingGroup') {\n            throw new Error(msg);\n          }\n        } else {\n          // - Invalid: `(?=\u2026)`, `(?!\u2026)`, `(?<!\u2026)`\n          // - Valid: `(?<=\u2026)`, capturing groups\n          if (isLookahead(child) || (isLookbehind(child) && child.negate)) {\n            throw new Error(msg);\n          }\n        }\n      }\n    }\n    nextToken = throwIfUnclosedGroup(tokens[context.nextIndex]);\n  }\n  // Skip the closing parenthesis\n  context.nextIndex++;\n  return node;\n}\n\nfunction parseQuantifier({kind, min, max}: QuantifierToken, context: Context): QuantifierNode {\n  const parent = context.parent as AlternativeNode;\n  const quantifiedNode = parent.body.at(-1);\n  if (!quantifiedNode || !isQuantifiable(quantifiedNode)) {\n    throw new Error('Quantifier requires a repeatable token');\n  }\n  const node = createQuantifier(kind, min, max, quantifiedNode);\n  parent.body.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({raw}: SubroutineToken, context: Context): SubroutineNode {\n  const {capturingGroups, subroutines} = context;\n  let ref: string | number = 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\n// -------------------------------\n// --- Node creation and types ---\n// -------------------------------\n\ntype AbsenceFunctionNode = {\n  type: 'AbsenceFunction';\n  kind: NodeAbsenceFunctionKind;\n  body: Array<AlternativeNode>;\n};\nfunction createAbsenceFunction(kind: NodeAbsenceFunctionKind, options?: {\n  body?: Array<AlternativeNode>;\n}): AbsenceFunctionNode {\n  if (kind !== 'repeater') {\n    throw new Error(`Unexpected absence function kind \"${kind}\"`);\n  }\n  return {\n    type: 'AbsenceFunction',\n    kind,\n    body: getBodyForAlternativeContainer(options?.body),\n  };\n}\n\ntype AlternativeNode = {\n  type: 'Alternative';\n  body: Array<AlternativeElementNode>;\n};\nfunction createAlternative(options?: {\n  body?: Array<AlternativeElementNode>;\n}): AlternativeNode {\n  return {\n    type: 'Alternative',\n    body: getBodyForElementContainer(options?.body) as Array<AlternativeElementNode>,\n  };\n}\n\ntype AssertionNode = {\n  type: 'Assertion';\n  kind: NodeAssertionKind;\n  negate?: boolean;\n};\nfunction createAssertion(kind: NodeAssertionKind, options?: {\n  negate?: boolean;\n}): AssertionNode {\n  const node: AssertionNode = {\n    type: 'Assertion',\n    kind,\n  };\n  if (kind === 'word_boundary' || kind === 'text_segment_boundary') {\n    node.negate = !!options?.negate;\n  }\n  return node;\n}\n\ntype BackreferenceNode = {\n  type: 'Backreference';\n  ref: string | number;\n  orphan?: boolean;\n};\nfunction createBackreference(ref: string | number, options?: {\n  orphan?: boolean;\n}): BackreferenceNode {\n  const orphan = !!options?.orphan;\n  return {\n    type: 'Backreference',\n    ref,\n    ...(orphan && {orphan}),\n  };\n}\n\ntype CapturingGroupNode = {\n  type: 'CapturingGroup';\n  kind?: never;\n  number: number;\n  name?: string;\n  // One or more subroutines in the regex reference this group\n  isSubroutined?: boolean;\n  body: Array<AlternativeNode>;\n};\nfunction createCapturingGroup(number: number, options?: {\n  name?: string;\n  isSubroutined?: boolean;\n  body?: Array<AlternativeNode>;\n}): CapturingGroupNode {\n  const opts = {\n    name: undefined,\n    isSubroutined: false,\n    ...options,\n  };\n  if (opts.name !== undefined && !isValidGroupName(opts.name)) {\n    throw new Error(`Group name \"${opts.name}\" invalid in Oniguruma`);\n  }\n  return {\n    type: 'CapturingGroup',\n    number,\n    ...(opts.name && {name: opts.name}),\n    ...(opts.isSubroutined && {isSubroutined: opts.isSubroutined}),\n    body: getBodyForAlternativeContainer(options?.body),\n  };\n}\n\ntype CharacterNode = {\n  type: 'Character';\n  value: number;\n};\nfunction createCharacter(charCode: number, options?: {\n  useLastValid?: boolean;\n}): CharacterNode {\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: 'Character',\n    value: charCode,\n  };\n}\n\ntype CharacterClassNode = {\n  type: 'CharacterClass';\n  kind: NodeCharacterClassKind;\n  negate: boolean;\n  body: Array<CharacterClassElementNode>;\n};\nfunction createCharacterClass(options?: {\n  kind?: NodeCharacterClassKind;\n  negate?: boolean;\n  body?: Array<CharacterClassElementNode>;\n}): CharacterClassNode {\n  const opts = {\n    kind: 'union' as NodeCharacterClassKind,\n    negate: false,\n    ...options,\n  };\n  return {\n    type: 'CharacterClass',\n    kind: opts.kind,\n    negate: opts.negate,\n    body: getBodyForElementContainer(options?.body) as Array<CharacterClassElementNode>,\n  };\n}\n\ntype CharacterClassRangeNode = {\n  type: 'CharacterClassRange';\n  min: CharacterNode;\n  max: CharacterNode;\n};\nfunction createCharacterClassRange(min: CharacterNode, max: CharacterNode): CharacterClassRangeNode {\n  if (max.value < min.value) {\n    throw new Error('Character class range out of order');\n  }\n  return {\n    type: 'CharacterClassRange',\n    min,\n    max,\n  };\n}\n\ntype NamedCharacterSetNode = {\n  type: 'CharacterSet';\n  kind: 'posix' | 'property';\n  value: string;\n  negate: boolean;\n  variableLength?: never;\n};\ntype UnnamedCharacterSetNode = {\n  type: 'CharacterSet';\n  kind: Exclude<NodeCharacterSetKind, NamedCharacterSetNode['kind']>;\n  value?: never;\n  negate?: boolean;\n  variableLength?: boolean;\n};\ntype CharacterSetNode = NamedCharacterSetNode | UnnamedCharacterSetNode;\n/**\nUse `createUnicodeProperty` and `createPosixClass` for `kind` values `'property'` and `'posix'`.\n*/\nfunction createCharacterSet(kind: UnnamedCharacterSetNode['kind'], options?: {\n  negate?: boolean;\n}): UnnamedCharacterSetNode {\n  const negate = !!options?.negate;\n  const node: UnnamedCharacterSetNode = {\n    type: 'CharacterSet',\n    kind,\n  };\n  if (\n    kind === 'digit' ||\n    kind === 'hex' ||\n    kind === 'newline' ||\n    kind === 'space' ||\n    kind === 'word'\n  ) {\n    node.negate = negate;\n  }\n  if (\n    kind === 'text_segment' ||\n    (kind === 'newline' && !negate)\n  ) {\n    node.variableLength = true;\n  }\n  return node;\n}\n\ntype DirectiveNode = {\n  type: 'Directive';\n} & ({\n  kind: 'keep';\n  flags?: never;\n} | {\n  kind: 'flags';\n  flags: FlagGroupModifiers;\n});\nfunction createDirective(kind: NodeDirectiveKind, options: {flags?: FlagGroupModifiers} = {}): DirectiveNode {\n  if (kind === 'keep') {\n    return {\n      type: 'Directive',\n      kind,\n    };\n  }\n  if (kind === 'flags') {\n    // Note: Flag effects might extend across alternation; ex: `a(?i)b|c` is equivalent to\n    // `a(?i:b)|(?i:c)`, not `a(?i:b|c)`\n    return {\n      type: 'Directive',\n      kind,\n      flags: throwIfNullish(options.flags),\n    };\n  }\n  throw new Error(`Unexpected directive kind \"${kind}\"`);\n}\n\ntype FlagsNode = {\n  type: 'Flags';\n} & FlagProperties;\nfunction createFlags(flags: FlagProperties): FlagsNode {\n  return {\n    type: 'Flags',\n    ...flags,\n  };\n}\n\ntype GroupNode = {\n  type: 'Group';\n  kind?: never;\n  atomic?: boolean;\n  flags?: FlagGroupModifiers;\n  body: Array<AlternativeNode>;\n};\nfunction createGroup(options?: {\n  atomic?: boolean;\n  flags?: FlagGroupModifiers;\n  body?: Array<AlternativeNode>;\n}): GroupNode {\n  const atomic = options?.atomic;\n  const flags = options?.flags;\n  if (atomic && flags) {\n    throw new Error('Atomic group cannot have flags');\n  }\n  return {\n    type: 'Group',\n    ...(atomic && {atomic}),\n    ...(flags && {flags}),\n    body: getBodyForAlternativeContainer(options?.body),\n  };\n}\n\ntype LookaroundAssertionNode = {\n  type: 'LookaroundAssertion';\n  kind: NodeLookaroundAssertionKind;\n  negate: boolean;\n  body: Array<AlternativeNode>;\n};\nfunction createLookaroundAssertion(options?: {\n  behind?: boolean;\n  negate?: boolean;\n  body?: Array<AlternativeNode>;\n}): LookaroundAssertionNode {\n  const opts = {\n    behind: false,\n    negate: false,\n    ...options,\n  };\n  return {\n    type: 'LookaroundAssertion',\n    kind: opts.behind ? 'lookbehind' : 'lookahead',\n    negate: opts.negate,\n    body: getBodyForAlternativeContainer(options?.body),\n  };\n}\n\ntype NamedCalloutNode = {\n  type: 'NamedCallout';\n  kind: NodeNamedCalloutKind;\n  tag: string | null;\n  arguments: Array<string | number> | null;\n};\nfunction createNamedCallout(\n  kind: NodeNamedCalloutKind,\n  tag: string | null,\n  args: Array<string | number> | null\n): NamedCalloutNode {\n  return {\n    type: 'NamedCallout',\n    kind,\n    tag,\n    arguments: args,\n  };\n}\n\nfunction createPosixClass(name: string, options?: {\n  negate?: boolean;\n}): NamedCharacterSetNode & {kind: 'posix'} {\n  const negate = !!options?.negate;\n  if (!PosixClassNames.has(name)) {\n    throw new Error(`Invalid POSIX class \"${name}\"`);\n  }\n  return {\n    type: 'CharacterSet',\n    kind: 'posix',\n    value: name,\n    negate,\n  };\n}\n\ntype QuantifierNode = {\n  type: 'Quantifier';\n  kind: NodeQuantifierKind;\n  min: number;\n  max: number;\n  body: QuantifiableNode;\n};\nfunction createQuantifier(kind: NodeQuantifierKind, min: number, max: number, body: QuantifiableNode): QuantifierNode {\n  if (min > max) {\n    throw new Error('Invalid reversed quantifier range');\n  }\n  return {\n    type: 'Quantifier',\n    kind,\n    min,\n    max,\n    body,\n  };\n}\n\ntype RegexNode = {\n  type: 'Regex';\n  body: Array<AlternativeNode>;\n  flags: FlagsNode;\n};\nfunction createRegex(flags: FlagsNode, options?: {\n  body?: Array<AlternativeNode>;\n}): RegexNode {\n  return {\n    type: 'Regex',\n    body: getBodyForAlternativeContainer(options?.body),\n    flags,\n  };\n}\n\ntype SubroutineNode = {\n  type: 'Subroutine';\n  ref: string | number;\n};\nfunction createSubroutine(ref: string | number): SubroutineNode {\n  return {\n    type: 'Subroutine',\n    ref,\n  };\n}\n\ntype CreateUnicodePropertyOptions = {\n  negate?: boolean;\n  normalizeUnknownPropertyNames?: boolean;\n  skipPropertyNameValidation?: boolean;\n  unicodePropertyMap?: UnicodePropertyMap | null;\n};\nfunction createUnicodeProperty(name: string, options?: CreateUnicodePropertyOptions): NamedCharacterSetNode & {kind: 'property'} {\n  const opts: Required<CreateUnicodePropertyOptions> = {\n    negate: false,\n    normalizeUnknownPropertyNames: false,\n    skipPropertyNameValidation: false,\n    unicodePropertyMap: null,\n    ...options,\n  };\n  let normalized = opts.unicodePropertyMap?.get(slug(name));\n  if (!normalized) {\n    if (opts.normalizeUnknownPropertyNames) {\n      normalized = normalizeUnicodePropertyName(name);\n    // Let the name through as-is if no map provided and normalization not requested\n    } else if (opts.unicodePropertyMap && !opts.skipPropertyNameValidation) {\n      throw new Error(r`Invalid Unicode property \"\\p{${name}}\"`);\n    }\n  }\n  return {\n    type: 'CharacterSet',\n    kind: 'property',\n    value: normalized ?? name,\n    negate: opts.negate,\n  };\n}\n\n// ---------------\n// --- Helpers ---\n// ---------------\n\nfunction createByGroupKind({flags, kind, name, negate, number}: GroupOpenToken): AbsenceFunctionNode | CapturingGroupNode | GroupNode | LookaroundAssertionNode {\n  switch (kind) {\n    case 'absence_repeater':\n      return createAbsenceFunction('repeater');\n    case 'atomic':\n      return createGroup({atomic: true});\n    case 'capturing':\n      return createCapturingGroup(number!, {name});\n    case 'group':\n      return createGroup({flags});\n    case 'lookahead':\n    case 'lookbehind':\n      return createLookaroundAssertion({\n        behind: kind === 'lookbehind',\n        negate,\n      });\n    default:\n      throw new Error(`Unexpected group kind \"${kind}\"`);\n  }\n}\n\nfunction getBodyForAlternativeContainer(body: unknown): Array<AlternativeNode> {\n  if (body === undefined) {\n    body = [createAlternative()];\n  } else if (!Array.isArray(body) || !body.length || !body.every(node => (node as Node).type === 'Alternative')) {\n    throw new Error('Invalid body; expected array of one or more Alternative nodes');\n  }\n  return body as Array<AlternativeNode>;\n}\n\nfunction getBodyForElementContainer(body: unknown): Array<Node> {\n  if (body === undefined) {\n    body = [];\n  } else if (!Array.isArray(body) || !body.every(node => !!(node as Node).type)) {\n    throw new Error('Invalid body; expected array of nodes');\n  }\n  return body as Array<Node>;\n}\n\nfunction isLookahead(node: Node): node is (LookaroundAssertionNode & {kind: 'lookahead'}) {\n  return node.type === 'LookaroundAssertion' && node.kind === 'lookahead';\n}\n\nfunction isLookbehind(node: Node): node is (LookaroundAssertionNode & {kind: 'lookbehind'}) {\n  return node.type === 'LookaroundAssertion' && node.kind === 'lookbehind';\n}\n\nfunction isValidGroupName(name: string): boolean {\n  // Note that backrefs and subroutines might contextually use `-` and `+` to indicate relative\n  // index or recursion level\n  return /^[\\p{Alpha}\\p{Pc}][^)]*$/u.test(name);\n}\n\nfunction normalizeUnicodePropertyName(name: string): string {\n  // In Onig, Unicode property names ignore case, spaces, hyphens, and underscores. Use best effort\n  // to reformat the name to follow official values (covers a lot, but isn't able to map for all\n  // possible formatting differences)\n  return name.\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/**\nGenerates a Unicode property lookup name: lowercase, without spaces, hyphens, or underscores.\n*/\nfunction slug(name: string): string {\n  return name.replace(/[- _]+/g, '').toLowerCase();\n}\n\nfunction throwIfUnclosedCharacterClass<T>(token: T, ccFirstToken?: Token): NonNullable<T> {\n  const first = ccFirstToken;\n  return throwIfNullish(token, `Unclosed character class${\n    // Help avoid confusion since e.g. `[]abc` is unclosed but looks like it has an empty class\n    first?.type === 'Character' && first.value === 93 && first.raw === ']' ? ' (started with \"]\")' : ''\n  }`);\n}\n\nfunction throwIfUnclosedGroup<T>(token: T): NonNullable<T> {\n  return throwIfNullish(token, 'Unclosed group');\n}\n\nexport {\n  type AbsenceFunctionNode,\n  type AlternativeNode,\n  type AlternativeContainerNode,\n  type AlternativeElementNode,\n  type AssertionNode,\n  type BackreferenceNode,\n  type CapturingGroupNode,\n  type CharacterClassElementNode,\n  type CharacterClassNode,\n  type CharacterClassRangeNode,\n  type CharacterNode,\n  type CharacterSetNode,\n  type DirectiveNode,\n  type FlagsNode,\n  type GroupNode,\n  type LookaroundAssertionNode,\n  type NamedCalloutNode,\n  type Node,\n  type NodeAbsenceFunctionKind,\n  type NodeAssertionKind,\n  type NodeCharacterClassKind,\n  type NodeCharacterSetKind,\n  type NodeDirectiveKind,\n  type NodeLookaroundAssertionKind,\n  type NodeQuantifierKind,\n  type OnigurumaAst,\n  type ParentNode,\n  type ParseOptions,\n  type QuantifiableNode,\n  type QuantifierNode,\n  type RegexNode,\n  type SubroutineNode,\n  type UnicodePropertyMap,\n  createAbsenceFunction,\n  createAlternative,\n  createAssertion,\n  createBackreference,\n  createCapturingGroup,\n  createCharacter,\n  createCharacterClass,\n  createCharacterClassRange,\n  createCharacterSet,\n  createDirective,\n  createFlags,\n  createGroup,\n  createLookaroundAssertion,\n  createNamedCallout,\n  createPosixClass,\n  createQuantifier,\n  createRegex,\n  createSubroutine,\n  createUnicodeProperty,\n  hasOnlyChild,\n  isAlternativeContainer,\n  isQuantifiable,\n  parse,\n  slug,\n};\n"],
+  "mappings": "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",
+  "names": ["tokenize", "cpOf", "getOrInsert", "PosixClassNames", "r", "throwIfNullish", "hasOnlyChild", "isAlternativeContainer", "isQuantifiable", "parse", "pattern", "options", "opts", "tokenized", "walk", "parent", "state", "token", "context", "createAlternative", "parseAssertion", "parseBackreference", "createCharacter", "parseCharacterClassHyphen", "parseCharacterClassOpen", "parseCharacterSet", "createDirective", "parseGroupOpen", "createNamedCallout", "parseQuantifier", "parseSubroutine", "ast", "createRegex", "createFlags", "top", "node", "capturingGroups", "hasNumberedRef", "namedGroupsByName", "subroutines", "ref", "kind", "createAssertion", "raw", "hasKWrapper", "fromNum", "num", "isRelative", "numCapturesToLeft", "orphan", "createBackreference", "numberedRef", "_", "tokens", "prevSiblingNode", "nextToken", "nextNode", "createCharacterClassRange", "negate", "intersections", "createCharacterClass", "ccFirstToken", "throwIfUnclosedCharacterClass", "cc", "value", "normalizeUnknownPropertyNames", "skipPropertyNameValidation", "unicodePropertyMap", "normalized", "slug", "createUnicodeProperty", "createPosixClass", "createCharacterSet", "skipLookbehindValidation", "createByGroupKind", "isThisAbsenceFunction", "isThisLookbehind", "isLookbehind", "isThisNegLookbehind", "throwIfUnclosedGroup", "alt", "child", "msg", "isLookahead", "min", "max", "quantifiedNode", "createQuantifier", "createSubroutine", "createAbsenceFunction", "getBodyForAlternativeContainer", "getBodyForElementContainer", "createCapturingGroup", "number", "isValidGroupName", "charCode", "hex", "flags", "createGroup", "atomic", "createLookaroundAssertion", "tag", "args", "name", "body", "normalizeUnicodePropertyName", "m", "first"]
+}

package/node_modules/oniguruma-parser/dist/tokenizer/tokenize.d.ts

@@ -0,0 +1,122 @@
+type Token = AlternatorToken | AssertionToken | BackreferenceToken | CharacterToken | CharacterClassCloseToken | CharacterClassHyphenToken | CharacterClassIntersectorToken | CharacterClassOpenToken | CharacterSetToken | DirectiveToken | GroupCloseToken | GroupOpenToken | NamedCalloutToken | QuantifierToken | SubroutineToken;
+type TokenCharacterSetKind = 'any' | 'digit' | 'dot' | 'hex' | 'newline' | 'posix' | 'property' | 'space' | 'text_segment' | 'word';
+type TokenDirectiveKind = 'flags' | 'keep';
+type TokenGroupOpenKind = 'absence_repeater' | 'atomic' | 'capturing' | 'group' | 'lookahead' | 'lookbehind';
+type TokenQuantifierKind = 'greedy' | 'lazy' | 'possessive';
+type TokenNamedCalloutKind = 'count' | 'cmp' | 'error' | 'fail' | 'max' | 'mismatch' | 'skip' | 'total_count' | 'custom';
+type TokenizeOptions = {
+    flags?: string;
+    rules?: {
+        captureGroup?: boolean;
+        singleline?: boolean;
+    };
+};
+declare function tokenize(pattern: string, options?: TokenizeOptions): {
+    tokens: Array<Token>;
+    flags: FlagProperties;
+};
+type AlternatorToken = {
+    type: 'Alternator';
+    raw: '|';
+};
+type AssertionToken = {
+    type: 'Assertion';
+    kind: string;
+    raw: string;
+};
+type BackreferenceToken = {
+    type: 'Backreference';
+    raw: string;
+};
+type CharacterToken = {
+    type: 'Character';
+    value: number;
+    raw: string;
+};
+type CharacterClassCloseToken = {
+    type: 'CharacterClassClose';
+    raw: ']';
+};
+type CharacterClassHyphenToken = {
+    type: 'CharacterClassHyphen';
+    raw: '-';
+};
+type CharacterClassIntersectorToken = {
+    type: 'CharacterClassIntersector';
+    raw: '&&';
+};
+type CharacterClassOpenToken = {
+    type: 'CharacterClassOpen';
+    negate: boolean;
+    raw: CharacterClassOpener;
+};
+type CharacterClassOpener = '[' | '[^';
+type CharacterSetToken = {
+    type: 'CharacterSet';
+    kind: TokenCharacterSetKind;
+    value?: string;
+    negate?: boolean;
+    raw: string;
+};
+type DirectiveToken = {
+    type: 'Directive';
+    raw: string;
+} & ({
+    kind: 'keep';
+    flags?: never;
+} | {
+    kind: 'flags';
+    flags: FlagGroupModifiers;
+});
+type GroupCloseToken = {
+    type: 'GroupClose';
+    raw: ')';
+};
+type GroupOpenToken = {
+    type: 'GroupOpen';
+    kind: TokenGroupOpenKind;
+    flags?: FlagGroupModifiers;
+    name?: string;
+    number?: number;
+    negate?: boolean;
+    raw: string;
+};
+type NamedCalloutToken = {
+    type: 'NamedCallout';
+    kind: TokenNamedCalloutKind;
+    tag: string | null;
+    arguments: Array<string | number> | null;
+    raw: string;
+};
+type QuantifierToken = {
+    type: 'Quantifier';
+    kind: TokenQuantifierKind;
+    min: number;
+    max: number;
+    raw: string;
+};
+type SubroutineToken = {
+    type: 'Subroutine';
+    raw: string;
+};
+type FlagProperties = {
+    ignoreCase: boolean;
+    dotAll: boolean;
+    extended: boolean;
+    digitIsAscii: boolean;
+    posixIsAscii: boolean;
+    spaceIsAscii: boolean;
+    wordIsAscii: boolean;
+    textSegmentMode: 'grapheme' | 'word' | null;
+};
+type FlagGroupModifiers = {
+    enable?: FlagGroupSwitches;
+    disable?: FlagGroupSwitches;
+};
+type FlagGroupSwitches = {
+    ignoreCase?: true;
+    dotAll?: true;
+    extended?: true;
+};
+export { type AlternatorToken, type AssertionToken, type BackreferenceToken, type CharacterToken, type CharacterClassCloseToken, type CharacterClassHyphenToken, type CharacterClassIntersectorToken, type CharacterClassOpenToken, type CharacterSetToken, type DirectiveToken, type FlagGroupModifiers, type FlagProperties, type GroupCloseToken, type GroupOpenToken, type NamedCalloutToken, type QuantifierToken, type SubroutineToken, type Token, type TokenCharacterSetKind, type TokenDirectiveKind, type TokenNamedCalloutKind, type TokenQuantifierKind, tokenize, };
+//# sourceMappingURL=tokenize.d.ts.map

package/node_modules/oniguruma-parser/dist/tokenizer/tokenize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenize.d.ts","sourceRoot":"","sources":["../../src/tokenizer/tokenize.ts"],"names":[],"mappings":"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"}

package/node_modules/oniguruma-parser/dist/tokenizer/tokenize.js

@@ -0,0 +1,34 @@
+"use strict";import{cpOf as h,PosixClassNames as G,r as p,throwIfNullish as N}from"../utils.js";const m=p`\[\^?`,b=`c.? | C(?:-.?)?|${p`[pP]\{(?:\^?[-\x20_]*[A-Za-z][-\x20\w]*\})?`}|${p`x[89A-Fa-f]\p{AHex}(?:\\x[89A-Fa-f]\p{AHex})*`}|${p`u(?:\p{AHex}{4})? | x\{[^\}]*\}? | x\p{AHex}{0,2}`}|${p`o\{[^\}]*\}?`}|${p`\d{1,3}`}`,y=/[?*+][?+]?|\{(?:\d+(?:,\d*)?|,\d+)\}\??/,C=new RegExp(p`
+  \\ (?:
+    ${b}
+    | [gk]<[^>]*>?
+    | [gk]'[^']*'?
+    | .
+  )
+  | \( (?:
+    \? (?:
+      [:=!>({]
+      | <[=!]
+      | <[^>]*>
+      | '[^']*'
+      | ~\|?
+      | #(?:[^)\\]|\\.?)*
+      | [^:)]*[:)]
+    )?
+    | \*[^\)]*\)?
+  )?
+  | (?:${y.source})+
+  | ${m}
+  | .
+`.replace(/\s+/g,""),"gsu"),T=new RegExp(p`
+  \\ (?:
+    ${b}
+    | .
+  )
+  | \[:(?:\^?\p{Alpha}+|\^):\]
+  | ${m}
+  | &&
+  | .
+`.replace(/\s+/g,""),"gsu");function M(e,n={}){const t={flags:"",...n,rules:{captureGroup:!1,singleline:!1,...n.rules}};if(typeof e!="string")throw new Error("String expected as pattern");const o=Y(t.flags),s=[o.extended],a={captureGroup:t.rules.captureGroup,getCurrentModX(){return s.at(-1)},numOpenGroups:0,popModX(){s.pop()},pushModX(u){s.push(u)},replaceCurrentModX(u){s[s.length-1]=u},singleline:t.rules.singleline};let r=[],i;for(C.lastIndex=0;i=C.exec(e);){const u=F(a,e,i[0],C.lastIndex);u.tokens?r.push(...u.tokens):u.token&&r.push(u.token),u.lastIndex!==void 0&&(C.lastIndex=u.lastIndex)}const l=[];let c=0;r.filter(u=>u.type==="GroupOpen").forEach(u=>{u.kind==="capturing"?u.number=++c:u.raw==="("&&l.push(u)}),c||l.forEach((u,S)=>{u.kind="capturing",u.number=S+1});const g=c||l.length;return{tokens:r.map(u=>u.type==="EscapedNumber"?ee(u,g):u).flat(),flags:o}}function F(e,n,t,o){const[s,a]=t;if(t==="["||t==="[^"){const r=K(n,t,o);return{tokens:r.tokens,lastIndex:r.lastIndex}}if(s==="\\"){if("AbBGyYzZ".includes(a))return{token:w(t,t)};if(/^\\g[<']/.test(t)){if(!/^\\g(?:<[^>]+>|'[^']+')$/.test(t))throw new Error(`Invalid group name "${t}"`);return{token:R(t)}}if(/^\\k[<']/.test(t)){if(!/^\\k(?:<[^>]+>|'[^']+')$/.test(t))throw new Error(`Invalid group name "${t}"`);return{token:A(t)}}if(a==="K")return{token:I("keep",t)};if(a==="N"||a==="R")return{token:k("newline",t,{negate:a==="N"})};if(a==="O")return{token:k("any",t)};if(a==="X")return{token:k("text_segment",t)};const r=x(t,{inCharClass:!1});return Array.isArray(r)?{tokens:r}:{token:r}}if(s==="("){if(a==="*")return{token:j(t)};if(t==="(?{")throw new Error(`Unsupported callout "${t}"`);if(t.startsWith("(?#")){if(n[o]!==")")throw new Error('Unclosed comment group "(?#"');return{lastIndex:o+1}}if(/^\(\?[-imx]+[:)]$/.test(t))return{token:L(t,e)};if(e.pushModX(e.getCurrentModX()),e.numOpenGroups++,t==="("&&!e.captureGroup||t==="(?:")return{token:f("group",t)};if(t==="(?>")return{token:f("atomic",t)};if(t==="(?="||t==="(?!"||t==="(?<="||t==="(?<!")return{token:f(t[2]==="<"?"lookbehind":"lookahead",t,{negate:t.endsWith("!")})};if(t==="("&&e.captureGroup||t.startsWith("(?<")&&t.endsWith(">")||t.startsWith("(?'")&&t.endsWith("'"))return{token:f("capturing",t,{...t!=="("&&{name:t.slice(3,-1)}})};if(t.startsWith("(?~")){if(t==="(?~|")throw new Error(`Unsupported absence function kind "${t}"`);return{token:f("absence_repeater",t)}}throw t==="(?("?new Error(`Unsupported conditional "${t}"`):new Error(`Invalid or unsupported group option "${t}"`)}if(t===")"){if(e.popModX(),e.numOpenGroups--,e.numOpenGroups<0)throw new Error('Unmatched ")"');return{token:Q(t)}}if(e.getCurrentModX()){if(t==="#"){const r=n.indexOf(`
+`,o);return{lastIndex:r===-1?n.length:r}}if(/^\s$/.test(t)){const r=/\s+/y;return r.lastIndex=o,{lastIndex:r.exec(n)?r.lastIndex:o}}}if(t===".")return{token:k("dot",t)};if(t==="^"||t==="$"){const r=e.singleline?{"^":p`\A`,$:p`\Z`}[t]:t;return{token:w(r,t)}}return t==="|"?{token:P(t)}:y.test(t)?{tokens:te(t)}:{token:d(h(t),t)}}function K(e,n,t){const o=[E(n[1]==="^",n)];let s=1,a;for(T.lastIndex=t;a=T.exec(e);){const r=a[0];if(r[0]==="["&&r[1]!==":")s++,o.push(E(r[1]==="^",r));else if(r==="]"){if(o.at(-1).type==="CharacterClassOpen")o.push(d(93,r));else if(s--,o.push(z(r)),!s)break}else{const i=X(r);Array.isArray(i)?o.push(...i):o.push(i)}}return{tokens:o,lastIndex:T.lastIndex||e.length}}function X(e){if(e[0]==="\\")return x(e,{inCharClass:!0});if(e[0]==="["){const n=/\[:(?<negate>\^?)(?<name>[a-z]+):\]/.exec(e);if(!n||!G.has(n.groups.name))throw new Error(`Invalid POSIX class "${e}"`);return k("posix",e,{value:n.groups.name,negate:!!n.groups.negate})}return e==="-"?U(e):e==="&&"?H(e):d(h(e),e)}function x(e,{inCharClass:n}){const t=e[1];if(t==="c"||t==="C")return Z(e);if("dDhHsSwW".includes(t))return q(e);if(e.startsWith(p`\o{`))throw new Error(`Incomplete, invalid, or unsupported octal code point "${e}"`);if(/^\\[pP]\{/.test(e)){if(e.length===3)throw new Error(`Incomplete or invalid Unicode property "${e}"`);return V(e)}if(/^\\x[89A-Fa-f]\p{AHex}/u.test(e))try{const o=e.split(/\\x/).slice(1).map(i=>parseInt(i,16)),s=new TextDecoder("utf-8",{ignoreBOM:!0,fatal:!0}).decode(new Uint8Array(o)),a=new TextEncoder;return[...s].map(i=>{const l=[...a.encode(i)].map(c=>`\\x${c.toString(16)}`).join("");return d(h(i),l)})}catch{throw new Error(`Multibyte code "${e}" incomplete or invalid in Oniguruma`)}if(t==="u"||t==="x")return d(J(e),e);if($.has(t))return d($.get(t),e);if(/\d/.test(t))return W(n,e);if(e==="\\")throw new Error(p`Incomplete escape "\"`);if(t==="M")throw new Error(`Unsupported meta "${e}"`);if([...e].length===2)return d(e.codePointAt(1),e);throw new Error(`Unexpected escape "${e}"`)}function P(e){return{type:"Alternator",raw:e}}function w(e,n){return{type:"Assertion",kind:e,raw:n}}function A(e){return{type:"Backreference",raw:e}}function d(e,n){return{type:"Character",value:e,raw:n}}function z(e){return{type:"CharacterClassClose",raw:e}}function U(e){return{type:"CharacterClassHyphen",raw:e}}function H(e){return{type:"CharacterClassIntersector",raw:e}}function E(e,n){return{type:"CharacterClassOpen",negate:e,raw:n}}function k(e,n,t={}){return{type:"CharacterSet",kind:e,...t,raw:n}}function I(e,n,t={}){return e==="keep"?{type:"Directive",kind:e,raw:n}:{type:"Directive",kind:e,flags:N(t.flags),raw:n}}function W(e,n){return{type:"EscapedNumber",inCharClass:e,raw:n}}function Q(e){return{type:"GroupClose",raw:e}}function f(e,n,t={}){return{type:"GroupOpen",kind:e,...t,raw:n}}function D(e,n,t,o){return{type:"NamedCallout",kind:e,tag:n,arguments:t,raw:o}}function _(e,n,t,o){return{type:"Quantifier",kind:e,min:n,max:t,raw:o}}function R(e){return{type:"Subroutine",raw:e}}const B=new Set(["COUNT","CMP","ERROR","FAIL","MAX","MISMATCH","SKIP","TOTAL_COUNT"]),$=new Map([["a",7],["b",8],["e",27],["f",12],["n",10],["r",13],["t",9],["v",11]]);function Z(e){const n=e[1]==="c"?e[2]:e[3];if(!n||!/[A-Za-z]/.test(n))throw new Error(`Unsupported control character "${e}"`);return d(h(n.toUpperCase())-64,e)}function L(e,n){let{on:t,off:o}=/^\(\?(?<on>[imx]*)(?:-(?<off>[-imx]*))?/.exec(e).groups;o??="";const s=(n.getCurrentModX()||t.includes("x"))&&!o.includes("x"),a=v(t),r=v(o),i={};if(a&&(i.enable=a),r&&(i.disable=r),e.endsWith(")"))return n.replaceCurrentModX(s),I("flags",e,{flags:i});if(e.endsWith(":"))return n.pushModX(s),n.numOpenGroups++,f("group",e,{...(a||r)&&{flags:i}});throw new Error(`Unexpected flag modifier "${e}"`)}function j(e){const n=/\(\*(?<name>[A-Za-z_]\w*)?(?:\[(?<tag>(?:[A-Za-z_]\w*)?)\])?(?:\{(?<args>[^}]*)\})?\)/.exec(e);if(!n)throw new Error(`Incomplete or invalid named callout "${e}"`);const{name:t,tag:o,args:s}=n.groups;if(!t)throw new Error(`Invalid named callout "${e}"`);if(o==="")throw new Error(`Named callout tag with empty value not allowed "${e}"`);const a=s?s.split(",").filter(g=>g!=="").map(g=>/^[+-]?\d+$/.test(g)?+g:g):[],[r,i,l]=a,c=B.has(t)?t.toLowerCase():"custom";switch(c){case"fail":case"mismatch":case"skip":if(a.length>0)throw new Error(`Named callout arguments not allowed "${a}"`);break;case"error":if(a.length>1)throw new Error(`Named callout allows only one argument "${a}"`);if(typeof r=="string")throw new Error(`Named callout argument must be a number "${r}"`);break;case"max":if(!a.length||a.length>2)throw new Error(`Named callout must have one or two arguments "${a}"`);if(typeof r=="string"&&!/^[A-Za-z_]\w*$/.test(r))throw new Error(`Named callout argument one must be a tag or number "${r}"`);if(a.length===2&&(typeof i=="number"||!/^[<>X]$/.test(i)))throw new Error(`Named callout optional argument two must be '<', '>', or 'X' "${i}"`);break;case"count":case"total_count":if(a.length>1)throw new Error(`Named callout allows only one argument "${a}"`);if(a.length===1&&(typeof r=="number"||!/^[<>X]$/.test(r)))throw new Error(`Named callout optional argument must be '<', '>', or 'X' "${r}"`);break;case"cmp":if(a.length!==3)throw new Error(`Named callout must have three arguments "${a}"`);if(typeof r=="string"&&!/^[A-Za-z_]\w*$/.test(r))throw new Error(`Named callout argument one must be a tag or number "${r}"`);if(typeof i=="number"||!/^(?:[<>!=]=|[<>])$/.test(i))throw new Error(`Named callout argument two must be '==', '!=', '>', '<', '>=', or '<=' "${i}"`);if(typeof l=="string"&&!/^[A-Za-z_]\w*$/.test(l))throw new Error(`Named callout argument three must be a tag or number "${l}"`);break;case"custom":throw new Error(`Undefined callout name "${t}"`);default:throw new Error(`Unexpected named callout kind "${c}"`)}return D(c,o??null,s?.split(",")??null,e)}function O(e){let n=null,t,o;if(e[0]==="{"){const{minStr:s,maxStr:a}=/^\{(?<minStr>\d*)(?:,(?<maxStr>\d*))?/.exec(e).groups,r=1e5;if(+s>r||a&&+a>r)throw new Error("Quantifier value unsupported in Oniguruma");if(t=+s,o=a===void 0?+s:a===""?1/0:+a,t>o&&(n="possessive",[t,o]=[o,t]),e.endsWith("?")){if(n==="possessive")throw new Error('Unsupported possessive interval quantifier chain with "?"');n="lazy"}else n||(n="greedy")}else t=e[0]==="+"?1:0,o=e[0]==="?"?1:1/0,n=e[1]==="+"?"possessive":e[1]==="?"?"lazy":"greedy";return _(n,t,o,e)}function q(e){const n=e[1].toLowerCase();return k({d:"digit",h:"hex",s:"space",w:"word"}[n],e,{negate:e[1]!==n})}function V(e){const{p:n,neg:t,value:o}=/^\\(?<p>[pP])\{(?<neg>\^?)(?<value>[^}]+)/.exec(e).groups;return k("property",e,{value:o,negate:n==="P"&&!t||n==="p"&&!!t})}function v(e){const n={};return e.includes("i")&&(n.ignoreCase=!0),e.includes("m")&&(n.dotAll=!0),e.includes("x")&&(n.extended=!0),Object.keys(n).length?n:null}function Y(e){const n={ignoreCase:!1,dotAll:!1,extended:!1,digitIsAscii:!1,posixIsAscii:!1,spaceIsAscii:!1,wordIsAscii:!1,textSegmentMode:null};for(let t=0;t<e.length;t++){const o=e[t];if(!"imxDPSWy".includes(o))throw new Error(`Invalid flag "${o}"`);if(o==="y"){if(!/^y{[gw]}/.test(e.slice(t)))throw new Error('Invalid or unspecified flag "y" mode');n.textSegmentMode=e[t+2]==="g"?"grapheme":"word",t+=3;continue}n[{i:"ignoreCase",m:"dotAll",x:"extended",D:"digitIsAscii",P:"posixIsAscii",S:"spaceIsAscii",W:"wordIsAscii"}[o]]=!0}return n}function J(e){if(/^(?:\\u(?!\p{AHex}{4})|\\x(?!\p{AHex}{1,2}|\{\p{AHex}{1,8}\}))/u.test(e))throw new Error(`Incomplete or invalid escape "${e}"`);const n=e[2]==="{"?/^\\x\{\s*(?<hex>\p{AHex}+)/u.exec(e).groups.hex:e.slice(2);return parseInt(n,16)}function ee(e,n){const{raw:t,inCharClass:o}=e,s=t.slice(1);if(!o&&(s!=="0"&&s.length===1||s[0]!=="0"&&+s<=n))return[A(t)];const a=[],r=s.match(/^[0-7]+|\d/g);for(let i=0;i<r.length;i++){const l=r[i];let c;if(i===0&&l!=="8"&&l!=="9"){if(c=parseInt(l,8),c>127)throw new Error(p`Octal encoded byte above 177 unsupported "${t}"`)}else c=h(l);a.push(d(c,(i===0?"\\":"")+l))}return a}function te(e){const n=[],t=new RegExp(y,"gy");let o;for(;o=t.exec(e);){const s=o[0];if(s[0]==="{"){const a=/^\{(?<min>\d+),(?<max>\d+)\}\??$/.exec(s);if(a){const{min:r,max:i}=a.groups;if(+r>+i&&s.endsWith("?")){t.lastIndex--,n.push(O(s.slice(0,-1)));continue}}}n.push(O(s))}return n}export{M as tokenize};
+//# sourceMappingURL=tokenize.js.map

package/node_modules/oniguruma-parser/dist/tokenizer/tokenize.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/tokenizer/tokenize.ts"],
+  "sourcesContent": ["import {cpOf, PosixClassNames, r, throwIfNullish} from '../utils.js';\n\ntype Token =\n  AlternatorToken |\n  AssertionToken |\n  BackreferenceToken |\n  CharacterToken |\n  CharacterClassCloseToken |\n  CharacterClassHyphenToken |\n  CharacterClassIntersectorToken |\n  CharacterClassOpenToken |\n  CharacterSetToken |\n  DirectiveToken |\n  GroupCloseToken |\n  GroupOpenToken |\n  NamedCalloutToken |\n  QuantifierToken |\n  SubroutineToken;\n\ntype IntermediateToken =\n  EscapedNumberToken;\n\ntype TokenCharacterSetKind =\n  'any' |\n  'digit' |\n  'dot' |\n  'hex' |\n  'newline' |\n  'posix' |\n  'property' |\n  'space' |\n  'text_segment' |\n  'word';\n\ntype TokenDirectiveKind =\n  'flags' |\n  'keep';\n\ntype TokenGroupOpenKind =\n  'absence_repeater' |\n  'atomic' |\n  'capturing' |\n  'group' |\n  'lookahead' |\n  'lookbehind';\n\ntype TokenQuantifierKind =\n  'greedy' |\n  'lazy' |\n  'possessive';\n\ntype TokenNamedCalloutKind =\n  'count' |\n  'cmp' |\n  'error' |\n  'fail' |\n  'max' |\n  'mismatch' |\n  'skip' |\n  'total_count' |\n  'custom';\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\ntype Context = {\n  captureGroup: boolean;\n  getCurrentModX(): boolean;\n  numOpenGroups: number;\n  popModX(): void;\n  pushModX(isXOn: boolean): void;\n  replaceCurrentModX(isXOn: boolean): void;\n  singleline: boolean;\n};\n\ntype TokenizeOptions = {\n  flags?: string;\n  rules?: {\n    captureGroup?: boolean;\n    singleline?: boolean;\n  };\n};\n\nfunction tokenize(pattern: string, options: TokenizeOptions = {}): {\n  tokens: Array<Token>;\n  flags: FlagProperties;\n} {\n  const opts = {\n    flags: '',\n    ...options,\n    rules: {\n      captureGroup: false, // `ONIG_OPTION_CAPTURE_GROUP`\n      singleline: false, // `ONIG_OPTION_SINGLELINE`\n      ...options.rules,\n    },\n  };\n  if (typeof pattern !== 'string') {\n    throw new Error('String expected as pattern');\n  }\n  const flagProperties = getFlagProperties(opts.flags);\n  const xStack = [flagProperties.extended];\n  const context: Context = {\n    captureGroup: opts.rules.captureGroup,\n    // Always at least has the top-level flag x\n    getCurrentModX() {return 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: opts.rules.singleline,\n  };\n  let tokens: Array<Token | IntermediateToken> = [];\n  let match: RegExpExecArray | null;\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: Array<GroupOpenToken> = [];\n  let numNamedAndOptInUnnamedCaptures = 0;\n  tokens.filter(t => t.type === 'GroupOpen').forEach(t => {\n    if (t.kind === 'capturing') {\n      t.number = ++numNamedAndOptInUnnamedCaptures;\n    } else if (t.raw === '(') {\n      potentialUnnamedCaptureTokens.push(t);\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 = '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  const tokensWithoutIntermediate = tokens.map(\n    t => t.type === 'EscapedNumber' ? splitEscapedNumberToken(t, numCaptures) : t\n  ).flat();\n\n  return {\n    tokens: tokensWithoutIntermediate,\n    flags: flagProperties,\n  };\n}\n\nfunction getTokenWithDetails(context: Context, pattern: string, m: string, lastIndex: number): {\n  token: Token | IntermediateToken;\n  tokens?: never;\n  lastIndex?: number;\n} | {\n  token?: never;\n  tokens: Array<Token | IntermediateToken>;\n  lastIndex?: number;\n} | {\n  token?: never;\n  tokens?: never;\n  lastIndex: number;\n} {\n  const [m0, m1] = m;\n\n  if (m === '[' || m === '[^') {\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 ('AbBGyYzZ'.includes(m1)) {\n      return {\n        token: createAssertionToken(m, m),\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: createSubroutineToken(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: createBackreferenceToken(m),\n      };\n    }\n    if (m1 === 'K') {\n      return {\n        token: createDirectiveToken('keep', m),\n      };\n    }\n    if (m1 === 'N' || m1 === 'R') {\n      return {\n        token: createCharacterSetToken('newline', m, {\n          // `\\N` and `\\R` are not actually opposites since the former only excludes `\\n`\n          negate: m1 === 'N',\n        }),\n      };\n    }\n    if (m1 === 'O') {\n      return {\n        token: createCharacterSetToken('any', m),\n      };\n    }\n    if (m1 === 'X') {\n      return {\n        token: createCharacterSetToken('text_segment', m),\n      };\n    }\n    // Run last since it assumes an identity escape as final condition\n    const result = tokenizeSharedEscape(m, {inCharClass: false});\n    return Array.isArray(result) ? {tokens: result} : {token: result};\n  }\n\n  if (m0 === '(') {\n    if (m1 === '*') {\n      return {\n        token: tokenizeNamedCallout(m),\n      };\n    }\n    if (m === '(?{') {\n      throw new Error(`Unsupported callout \"${m}\"`);\n    }\n    // Comment group\n    if (m.startsWith('(?#')) {\n      // Everything except the closing unescaped `)` is included in the match\n      if (pattern[lastIndex] !== ')') {\n        throw new Error('Unclosed comment group \"(?#\"');\n      }\n      return {\n        // Jump forward to after the closing paren\n        lastIndex: lastIndex + 1,\n      };\n    }\n    // Flag modifier (directive or group opener)\n    if (/^\\(\\?[-imx]+[:)]$/.test(m)) {\n      return {\n        token: tokenizeFlagModifier(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        // For `(`, will later change to `capturing` and add `number` prop if no named captures\n        token: createGroupOpenToken('group', m),\n      };\n    }\n    // Atomic group\n    if (m === '(?>') {\n      return {\n        token: createGroupOpenToken('atomic', m),\n      };\n    }\n    // Lookaround\n    if (m === '(?=' || m === '(?!' || m === '(?<=' || m === '(?<!') {\n      return {\n        token: createGroupOpenToken(m[2] === '<' ? 'lookbehind' : 'lookahead', m, {\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      return {\n        token: createGroupOpenToken('capturing', m, {\n          // Will add `number` prop in a second pass\n          ...(m !== '(' && {name: m.slice(3, -1)}),\n        }),\n      };\n    }\n    if (m.startsWith('(?~')) {\n      if (m === '(?~|') {\n        throw new Error(`Unsupported absence function kind \"${m}\"`);\n      }\n      return {\n        token: createGroupOpenToken('absence_repeater', m),\n      };\n    }\n    if (m === '(?(') {\n      // TODO: Add support\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: createGroupCloseToken(m),\n    };\n  }\n\n  if (context.getCurrentModX()) {\n    if (m === '#') {\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)) {\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\n  if (m === '.') {\n    return {\n      token: createCharacterSetToken('dot', m),\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: createAssertionToken(kind, m),\n    };\n  }\n\n  if (m === '|') {\n    return {\n      token: createAlternatorToken(m),\n    };\n  }\n\n  if (quantifierRe.test(m)) {\n    return {\n      tokens: splitQuantifierMatch(m),\n    };\n  }\n\n  // `cpOf` asserts that it's a single code point\n  return {\n    token: createCharacterToken(cpOf(m), m),\n  };\n}\n\nfunction getAllTokensForCharClass(pattern: string, opener: CharacterClassOpener, lastIndex: number): {\n  tokens: Array<Token | IntermediateToken>;\n  lastIndex: number;\n} {\n  const tokens: Array<Token | IntermediateToken> = [createCharacterClassOpenToken(opener[1] === '^', opener)];\n  let numCharClassesOpen = 1;\n  let match: RegExpExecArray | null;\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(createCharacterClassOpenToken(m[1] === '^', m as CharacterClassOpener));\n    } else if (m === ']') {\n      // Always at least includes the char class opener\n      if (tokens.at(-1)!.type === 'CharacterClassOpen') {\n        // Allow unescaped `]` as leading char\n        tokens.push(createCharacterToken(93, m));\n      } else {\n        numCharClassesOpen--;\n        tokens.push(createCharacterClassCloseToken(m));\n        if (!numCharClassesOpen) {\n          break;\n        }\n      }\n    } else {\n      const result = tokenizeAnyTokenWithinCharClass(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 tokenizeAnyTokenWithinCharClass(raw: string): Token | IntermediateToken | Array<Token> {\n  if (raw[0] === '\\\\') {\n    // Assumes an identity escape as final condition\n    return tokenizeSharedEscape(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 || !PosixClassNames.has(posix.groups!.name)) {\n      throw new Error(`Invalid POSIX class \"${raw}\"`);\n    }\n    return createCharacterSetToken('posix', raw, {\n      value: posix.groups!.name,\n      negate: !!posix.groups!.negate,\n    });\n  }\n  // Range (possibly invalid) or literal hyphen\n  if (raw === '-') {\n    return createCharacterClassHyphenToken(raw);\n  }\n  if (raw === '&&') {\n    return createCharacterClassIntersectorToken(raw);\n  }\n  // `cpOf` asserts that it's a single code point\n  return createCharacterToken(cpOf(raw), raw);\n}\n\n// Tokens shared by base syntax and char class syntax that start with `\\`\nfunction tokenizeSharedEscape(raw: string, {inCharClass}: {inCharClass: boolean}): Token | IntermediateToken | Array<Token> {\n  const char1 = raw[1];\n  if (char1 === 'c' || char1 === 'C') {\n    return tokenizeControlCharacter(raw);\n  }\n  if ('dDhHsSwW'.includes(char1)) {\n    return tokenizeShorthand(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 tokenizeUnicodeProperty(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 createCharacterToken(cpOf(char), raw);\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 createCharacterToken(getValidatedHexCharCode(raw), raw);\n  }\n  if (EscapeCharCodes.has(char1)) {\n    return createCharacterToken(EscapeCharCodes.get(char1)!, raw);\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 createEscapedNumberToken(inCharClass, raw);\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    // TODO: Add support. See:\n    // - <github.com/kkos/oniguruma/blob/master/doc/SYNTAX.md#12-onig_syn_op2_esc_capital_m_bar_meta-enable-m-x>\n    // - <github.com/kkos/oniguruma/blob/43a8c3f3daf263091f3a74019d4b32ebb6417093/src/regparse.c#L4695>\n    // - <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 createCharacterToken(raw.codePointAt(1)!, raw);\n  }\n  throw new Error(`Unexpected escape \"${raw}\"`);\n}\n\n// --------------------------------\n// --- Token creation and types ---\n// --------------------------------\n\ntype AlternatorToken = {\n  type: 'Alternator';\n  raw: '|';\n};\nfunction createAlternatorToken(raw: '|'): AlternatorToken {\n  return {\n    type: 'Alternator',\n    raw,\n  };\n}\n\ntype AssertionToken = {\n  type: 'Assertion';\n  kind: string;\n  raw: string;\n};\nfunction createAssertionToken(kind: string, raw: string): AssertionToken {\n  return {\n    type: 'Assertion',\n    kind,\n    raw,\n  };\n}\n\ntype BackreferenceToken = {\n  type: 'Backreference';\n  raw: string;\n};\nfunction createBackreferenceToken(raw: string): BackreferenceToken {\n  return {\n    type: 'Backreference',\n    raw,\n  };\n}\n\ntype CharacterToken = {\n  type: 'Character';\n  value: number;\n  raw: string;\n};\nfunction createCharacterToken(value: number, raw: string): CharacterToken {\n  return {\n    type: 'Character',\n    value,\n    raw,\n  };\n}\n\ntype CharacterClassCloseToken = {\n  type: 'CharacterClassClose';\n  raw: ']';\n};\nfunction createCharacterClassCloseToken(raw: ']'): CharacterClassCloseToken {\n  return {\n    type: 'CharacterClassClose',\n    raw,\n  };\n}\n\ntype CharacterClassHyphenToken = {\n  type: 'CharacterClassHyphen';\n  raw: '-';\n};\nfunction createCharacterClassHyphenToken(raw: '-'): CharacterClassHyphenToken {\n  return {\n    type: 'CharacterClassHyphen',\n    raw,\n  };\n}\n\ntype CharacterClassIntersectorToken = {\n  type: 'CharacterClassIntersector';\n  raw: '&&';\n};\nfunction createCharacterClassIntersectorToken(raw: '&&'): CharacterClassIntersectorToken {\n  return {\n    type: 'CharacterClassIntersector',\n    raw,\n  };\n}\n\ntype CharacterClassOpenToken = {\n  type: 'CharacterClassOpen';\n  negate: boolean;\n  raw: CharacterClassOpener;\n};\ntype CharacterClassOpener = '[' | '[^';\nfunction createCharacterClassOpenToken(negate: boolean, raw: CharacterClassOpener): CharacterClassOpenToken {\n  return {\n    type: 'CharacterClassOpen',\n    negate,\n    raw,\n  };\n}\n\ntype CharacterSetToken = {\n  type: 'CharacterSet';\n  kind: TokenCharacterSetKind;\n  value?: string;\n  negate?: boolean;\n  raw: string;\n};\nfunction createCharacterSetToken(\n  kind: TokenCharacterSetKind,\n  raw: string,\n  options: {\n    value?: string;\n    negate?: boolean;\n  } = {}\n): CharacterSetToken {\n  return {\n    type: 'CharacterSet',\n    kind,\n    ...options,\n    raw,\n  };\n}\n\ntype DirectiveToken = {\n  type: 'Directive';\n  raw: string;\n} & ({\n  kind: 'keep';\n  flags?: never;\n} | {\n  kind: 'flags';\n  flags: FlagGroupModifiers;\n});\nfunction createDirectiveToken(kind: TokenDirectiveKind, raw: string, options: {flags?: FlagGroupModifiers} = {}): DirectiveToken {\n  if (kind === 'keep') {\n    return {\n      type: 'Directive',\n      kind,\n      raw,\n    };\n  }\n  return {\n    type: 'Directive',\n    kind,\n    flags: throwIfNullish(options.flags),\n    raw,\n  };\n}\n\ntype EscapedNumberToken = {\n  type: 'EscapedNumber';\n  inCharClass: boolean;\n  raw: string;\n};\n/**\nIntermediate representation only; will become a `Backreference` or one or more `Character`s.\n*/\nfunction createEscapedNumberToken(inCharClass: boolean, raw: string): EscapedNumberToken {\n  return {\n    type: 'EscapedNumber',\n    inCharClass,\n    raw,\n  };\n}\n\ntype GroupCloseToken = {\n  type: 'GroupClose';\n  raw: ')';\n};\nfunction createGroupCloseToken(raw: ')'): GroupCloseToken {\n  return {\n    type: 'GroupClose',\n    raw,\n  };\n}\n\ntype GroupOpenToken = {\n  type: 'GroupOpen';\n  kind: TokenGroupOpenKind;\n  flags?: FlagGroupModifiers;\n  name?: string;\n  number?: number;\n  negate?: boolean;\n  raw: string;\n};\nfunction createGroupOpenToken(\n  kind: TokenGroupOpenKind,\n  raw: string,\n  options: {\n    flags?: FlagGroupModifiers;\n    name?: string;\n    number?: number;\n    negate?: boolean;\n  } = {}\n): GroupOpenToken {\n  return {\n    type: 'GroupOpen',\n    kind,\n    ...options,\n    raw,\n  };\n}\n\ntype NamedCalloutToken = {\n  type: 'NamedCallout';\n  kind: TokenNamedCalloutKind;\n  tag: string | null;\n  arguments: Array<string | number> | null;\n  raw: string;\n};\nfunction createNamedCalloutToken(\n  kind: TokenNamedCalloutKind,\n  tag: string | null,\n  args: Array<string | number> | null,\n  raw: string\n): NamedCalloutToken {\n  return {\n    type: 'NamedCallout',\n    kind,\n    tag,\n    arguments: args,\n    raw,\n  };\n};\n\ntype QuantifierToken = {\n  type: 'Quantifier';\n  kind: TokenQuantifierKind;\n  min: number;\n  max: number;\n  raw: string;\n};\nfunction createQuantifierToken(\n  kind: TokenQuantifierKind,\n  min: number,\n  max: number,\n  raw: string\n): QuantifierToken {\n  return {\n    type: 'Quantifier',\n    kind,\n    min,\n    max,\n    raw,\n  };\n}\n\ntype SubroutineToken = {\n  type: 'Subroutine';\n  raw: string;\n};\nfunction createSubroutineToken(raw: string): SubroutineToken {\n  return {\n    type: 'Subroutine',\n    raw,\n  };\n}\n\n// ---------------\n// --- Helpers ---\n// ---------------\n\ntype FlagProperties = {\n  ignoreCase: boolean;\n  dotAll: boolean;\n  extended: boolean;\n  digitIsAscii: boolean;\n  posixIsAscii: boolean;\n  spaceIsAscii: boolean;\n  wordIsAscii: boolean;\n  textSegmentMode: 'grapheme' | 'word' | null;\n};\n\ntype FlagGroupModifiers = {\n  enable?: FlagGroupSwitches;\n  disable?: FlagGroupSwitches;\n};\n\ntype FlagGroupSwitches = {\n  ignoreCase?: true;\n  dotAll?: true;\n  extended?: true;\n};\n\nconst CalloutNames = new Set<Uppercase<Exclude<TokenNamedCalloutKind, 'custom'>>>([\n  'COUNT',\n  'CMP',\n  'ERROR',\n  'FAIL',\n  'MAX',\n  'MISMATCH',\n  'SKIP',\n  'TOTAL_COUNT',\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\n// Expects `\\cx` or `\\C-x`\nfunction tokenizeControlCharacter(raw: string): CharacterToken {\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    // TODO: Add support. See:\n    // - <github.com/kkos/oniguruma/blob/master/doc/SYNTAX.md#11-onig_syn_op2_esc_capital_c_bar_control-enable-c-x>\n    // - <github.com/kkos/oniguruma/blob/43a8c3f3daf263091f3a74019d4b32ebb6417093/src/regparse.c#L4695>\n    throw new Error(`Unsupported control character \"${raw}\"`);\n  }\n  return createCharacterToken(cpOf(char.toUpperCase()) - 64, raw);\n}\n\nfunction tokenizeFlagModifier(raw: string, context: Context): DirectiveToken | GroupOpenToken {\n  // Allows multiple `-` and solo `-` without `on` or `off` flags\n  let {on, off} = /^\\(\\?(?<on>[imx]*)(?:-(?<off>[-imx]*))?/.exec(raw)!.groups as {on: string, off: string | undefined};\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 = getFlagGroupSwitches(on);\n  const disabledFlags = getFlagGroupSwitches(off);\n  const flagChanges: FlagGroupModifiers = {};\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 createDirectiveToken('flags', raw, {\n      flags: flagChanges,\n    });\n  }\n  // Flag group opener; ex: `(?im-x:`\n  if (raw.endsWith(':')) {\n    context.pushModX(isXOn);\n    context.numOpenGroups++;\n    return createGroupOpenToken('group', raw, {\n      ...((enabledFlags || disabledFlags) && {flags: flagChanges}),\n    });\n  }\n  throw new Error(`Unexpected flag modifier \"${raw}\"`);\n}\n\nfunction tokenizeNamedCallout(raw: string): NamedCalloutToken {\n  const callout = /\\(\\*(?<name>[A-Za-z_]\\w*)?(?:\\[(?<tag>(?:[A-Za-z_]\\w*)?)\\])?(?:\\{(?<args>[^}]*)\\})?\\)/.exec(raw);\n  if (!callout) {\n    throw new Error(`Incomplete or invalid named callout \"${raw}\"`);\n  }\n  const {name, tag, args} = callout.groups as Partial<{\n    name: string;\n    tag: string;\n    args: string;\n  }>;\n  if (!name) {\n    throw new Error(`Invalid named callout \"${raw}\"`);\n  }\n  if (tag === '') {\n    throw new Error(`Named callout tag with empty value not allowed \"${raw}\"`);\n  }\n  const argsArray: Array<string | number> = args ?\n    args.split(',').\n      // Onig skips over/ignores redundant/unnecessary commas\n      filter(arg => arg !== '').\n      map(arg => /^[+-]?\\d+$/.test(arg) ? +arg : arg) :\n    [];\n  const [arg0, arg1, arg2] = argsArray;\n  const kind: TokenNamedCalloutKind = CalloutNames.has(name as Uppercase<Exclude<TokenNamedCalloutKind, 'custom'>>) ?\n    name.toLowerCase() as TokenNamedCalloutKind :\n    'custom';\n  switch (kind) {\n    case 'fail':\n    case 'mismatch':\n    case 'skip':\n      if (argsArray.length > 0) {\n        throw new Error(`Named callout arguments not allowed \"${argsArray}\"`);\n      }\n      break;\n    case 'error':\n      if (argsArray.length > 1) {\n        throw new Error(`Named callout allows only one argument \"${argsArray}\"`);\n      }\n      if (typeof arg0 === 'string') {\n        throw new Error(`Named callout argument must be a number \"${arg0}\"`);\n      }\n      break;\n    case 'max':\n      if (!argsArray.length || argsArray.length > 2) {\n        throw new Error(`Named callout must have one or two arguments \"${argsArray}\"`);\n      }\n      if (typeof arg0 === 'string' && !/^[A-Za-z_]\\w*$/.test(arg0)) {\n        throw new Error(`Named callout argument one must be a tag or number \"${arg0}\"`);\n      }\n      if (argsArray.length === 2 && (typeof arg1 === 'number' || !/^[<>X]$/.test(arg1))) {\n        throw new Error(`Named callout optional argument two must be '<', '>', or 'X' \"${arg1}\"`);\n      }\n      break;\n    case 'count':\n    case 'total_count':\n      if (argsArray.length > 1) {\n        throw new Error(`Named callout allows only one argument \"${argsArray}\"`);\n      }\n      if (argsArray.length === 1 && (typeof arg0 === 'number' || !/^[<>X]$/.test(arg0))) {\n        throw new Error(`Named callout optional argument must be '<', '>', or 'X' \"${arg0}\"`);\n      }\n      break;\n    case 'cmp':\n      if (argsArray.length !== 3) {\n        throw new Error(`Named callout must have three arguments \"${argsArray}\"`);\n      }\n      if (typeof arg0 === 'string' && !/^[A-Za-z_]\\w*$/.test(arg0)) {\n        throw new Error(`Named callout argument one must be a tag or number \"${arg0}\"`);\n      }\n      if (typeof arg1 === 'number' || !/^(?:[<>!=]=|[<>])$/.test(arg1)) {\n        throw new Error(`Named callout argument two must be '==', '!=', '>', '<', '>=', or '<=' \"${arg1}\"`);\n      }\n      if (typeof arg2 === 'string' && !/^[A-Za-z_]\\w*$/.test(arg2)) {\n        throw new Error(`Named callout argument three must be a tag or number \"${arg2}\"`);\n      }\n      break;\n    case 'custom':\n      // TODO: Can support custom callout names via a new option that allows providing a list of\n      // allowed, non-built-in names\n      throw new Error(`Undefined callout name \"${name}\"`);\n    default:\n      throw new Error(`Unexpected named callout kind \"${kind}\"`);\n  }\n  // TODO: If supporting custom callout names in the future (with an added `name` property for\n  // `NamedCalloutToken`), will need to set `name` to `null` if `kind` isn't `'custom'`\n  return createNamedCalloutToken(kind, tag ?? null, args?.split(',') ?? null, raw);\n}\n\nfunction tokenizeQuantifier(raw: string): QuantifierToken {\n  let kind: TokenQuantifierKind = null!;\n  let min: number;\n  let max: number;\n  if (raw[0] === '{') {\n    const {minStr, maxStr} =\n      /^\\{(?<minStr>\\d*)(?:,(?<maxStr>\\d*))?/.exec(raw)!.groups as {minStr: string, maxStr: string | undefined};\n    const limit = 100_000;\n    if (+minStr > limit || (maxStr && +maxStr > limit)) {\n      throw new Error('Quantifier value unsupported in Oniguruma');\n    }\n    min = +minStr;\n    max = maxStr === undefined ? +minStr : (maxStr === '' ? Infinity : +maxStr);\n    // By default, Onig doesn't support making interval quantifiers possessive with a `+` suffix;\n    // uses reversed range instead\n    if (min > max) {\n      kind = 'possessive';\n      [min, max] = [max, min];\n    }\n    if (raw.endsWith('?')) {\n      if (kind === 'possessive') {\n        // TODO: <github.com/slevithan/oniguruma-parser/issues/10>\n        throw new Error('Unsupported possessive interval quantifier chain with \"?\"');\n      }\n      kind = 'lazy';\n    } else if (!kind) {\n      kind = 'greedy';\n    }\n  } else {\n    min = raw[0] === '+' ? 1 : 0;\n    max = raw[0] === '?' ? 1 : Infinity;\n    kind = raw[1] === '+' ? 'possessive' : (raw[1] === '?' ? 'lazy' : 'greedy');\n  }\n  return createQuantifierToken(kind, min, max, raw);\n}\n\nfunction tokenizeShorthand(raw: string): CharacterSetToken {\n  const lower = raw[1].toLowerCase();\n  return createCharacterSetToken({\n    'd': 'digit',\n    'h': 'hex',\n    's': 'space',\n    'w': 'word',\n  }[lower] as TokenCharacterSetKind, raw, {\n    negate: raw[1] !== lower,\n  });\n}\n\nfunction tokenizeUnicodeProperty(raw: string): CharacterSetToken {\n  const {p, neg, value} = /^\\\\(?<p>[pP])\\{(?<neg>\\^?)(?<value>[^}]+)/.exec(raw)!.groups!;\n  const negate = (p === 'P' && !neg) || (p === 'p' && !!neg);\n  return createCharacterSetToken('property', raw, {\n    value,\n    negate,\n  });\n}\n\nfunction getFlagGroupSwitches(flags: string): FlagGroupSwitches | null {\n  // Don't include `false` for flags that aren't included\n  const obj: FlagGroupSwitches = {};\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\nfunction getFlagProperties(flags: string): FlagProperties {\n  const flagProperties: FlagProperties = {\n    ignoreCase: false,\n    dotAll: false,\n    extended: false,\n    digitIsAscii: false,\n    posixIsAscii: false,\n    spaceIsAscii: false,\n    wordIsAscii: false,\n    textSegmentMode: null,\n  };\n  for (let i = 0; i < flags.length; i++) {\n    const char = flags[i];\n    if (!'imxDPSWy'.includes(char)) {\n      throw new Error(`Invalid flag \"${char}\"`);\n    }\n    // Flags y{g}, y{w} are currently only supported via the top-level `flags` option\n    if (char === 'y') {\n      if (!/^y{[gw]}/.test(flags.slice(i))) {\n        throw new Error('Invalid or unspecified flag \"y\" mode');\n      }\n      // If text segment mode flags appear multiple times, use the last one\n      flagProperties.textSegmentMode = flags[i + 2] === 'g' ? 'grapheme' : 'word';\n      i += 3;\n      continue;\n    }\n    flagProperties[{\n      i: 'ignoreCase',\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      m: 'dotAll',\n      // Flag x is fully handled during tokenization\n      x: 'extended',\n      // Flags D, P, S, W are currently only supported via the top-level `flags` option\n      D: 'digitIsAscii',\n      P: 'posixIsAscii',\n      S: 'spaceIsAscii',\n      W: 'wordIsAscii',\n    }[char] as Exclude<keyof FlagProperties, 'textSegmentMode'>] = true;\n  }\n  return flagProperties;\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: string): number {\n  // Note: Onig 6.9.10 and earlier have a bug where pattern-terminating `\\u` and `\\x` are treated\n  // as identity escapes; see <github.com/kkos/oniguruma/issues/343>. Don't emulate these bugs.\n  // Additionally, Onig treats bare `\\x` as equivalent to `\\0`, and treats incomplete `\\x{` (with\n  // the brace but not immediately followed by a hex digit) as an identity escape, so e.g. `\\x{`\n  // matches `x{` and `^\\x{,2}$` matches `xx`, but `\\x{2,}` and `\\x{0,2}` are errors. Currently,\n  // this library treats all such cases as errors\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  return parseInt(hex, 16);\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 splitEscapedNumberToken(token: EscapedNumberToken, numCaptures: number): Array<BackreferenceToken> | Array<CharacterToken> {\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 [createBackreferenceToken(raw)];\n  }\n  const tokens: Array<CharacterToken> = [];\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: number;\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 = cpOf(m);\n    }\n    tokens.push(createCharacterToken(value, (i === 0 ? '\\\\' : '') + m));\n  }\n  return tokens;\n}\n\nfunction splitQuantifierMatch(str: string): Array<QuantifierToken> {\n  const tokens: Array<QuantifierToken> = [];\n  // `str` is one or more quantifiers in a chain. It can't be split by a regex because of one edge\n  // case where we have to compare numeric values: although `{1,2}?` is a single, lazy quantifier,\n  // a reversed (possessive) interval quantifier like `{2,1}` can't be both possessive and lazy, so\n  // any following `?`, `??`, or `?+` is a second, chained quantifier (i.e., `{2,1}?` is equivalent\n  // to `{2,1}{0,1}` or `{2,0}`)\n  const withG = new RegExp(quantifierRe, 'gy');\n  let match: RegExpExecArray | null;\n  while ((match = withG.exec(str))) {\n    const m = match[0];\n    if (m[0] === '{') {\n      // Doesn't need to handle fixed `{n}`, infinite max `{n,}`, or implicit zero min `{,n}`\n      // since, according to Onig syntax rules, those can't be possessive\n      const parts = /^\\{(?<min>\\d+),(?<max>\\d+)\\}\\??$/.exec(m);\n      if (parts) {\n        const {min, max} = parts.groups as {min: string, max: string};\n        if (+min > +max && m.endsWith('?')) {\n          // Leave the trailing `?` for the next match\n          withG.lastIndex--;\n          tokens.push(tokenizeQuantifier(m.slice(0, -1)));\n          continue;\n        }\n      }\n    }\n    tokens.push(tokenizeQuantifier(m));\n  }\n  return tokens;\n}\n\nexport {\n  type AlternatorToken,\n  type AssertionToken,\n  type BackreferenceToken,\n  type CharacterToken,\n  type CharacterClassCloseToken,\n  type CharacterClassHyphenToken,\n  type CharacterClassIntersectorToken,\n  type CharacterClassOpenToken,\n  type CharacterSetToken,\n  type DirectiveToken,\n  type FlagGroupModifiers,\n  type FlagProperties,\n  type GroupCloseToken,\n  type GroupOpenToken,\n  type NamedCalloutToken,\n  type QuantifierToken,\n  type SubroutineToken,\n  type Token,\n  type TokenCharacterSetKind,\n  type TokenDirectiveKind,\n  type TokenNamedCalloutKind,\n  type TokenQuantifierKind,\n  tokenize,\n};\n"],
+  "mappings": "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",
+  "names": ["cpOf", "PosixClassNames", "r", "throwIfNullish", "charClassOpenPattern", "sharedEscapesPattern", "quantifierRe", "tokenRe", "charClassTokenRe", "tokenize", "pattern", "options", "opts", "flagProperties", "getFlagProperties", "xStack", "context", "isXOn", "tokens", "match", "result", "getTokenWithDetails", "potentialUnnamedCaptureTokens", "numNamedAndOptInUnnamedCaptures", "t", "i", "numCaptures", "splitEscapedNumberToken", "m", "lastIndex", "m0", "m1", "getAllTokensForCharClass", "createAssertionToken", "createSubroutineToken", "createBackreferenceToken", "createDirectiveToken", "createCharacterSetToken", "tokenizeSharedEscape", "tokenizeNamedCallout", "tokenizeFlagModifier", "createGroupOpenToken", "createGroupCloseToken", "end", "re", "kind", "createAlternatorToken", "splitQuantifierMatch", "createCharacterToken", "opener", "createCharacterClassOpenToken", "numCharClassesOpen", "createCharacterClassCloseToken", "tokenizeAnyTokenWithinCharClass", "raw", "posix", "createCharacterClassHyphenToken", "createCharacterClassIntersectorToken", "inCharClass", "char1", "tokenizeControlCharacter", "tokenizeShorthand", "tokenizeUnicodeProperty", "bytes", "hex", "decoded", "encoder", "char", "byte", "getValidatedHexCharCode", "EscapeCharCodes", "createEscapedNumberToken", "value", "negate", "createNamedCalloutToken", "tag", "args", "createQuantifierToken", "min", "max", "CalloutNames", "on", "off", "enabledFlags", "getFlagGroupSwitches", "disabledFlags", "flagChanges", "callout", "name", "argsArray", "arg", "arg0", "arg1", "arg2", "tokenizeQuantifier", "minStr", "maxStr", "limit", "lower", "p", "neg", "flags", "obj", "token", "matches", "str", "withG", "parts"]
+}

package/node_modules/oniguruma-parser/dist/traverser/traverse.d.ts

@@ -0,0 +1,49 @@
+import type { AlternativeElementNode, AlternativeNode, CharacterClassElementNode, Node, ParentNode, RegexNode } from '../parser/parse.js';
+type ContainerElementNode = AlternativeNode | AlternativeElementNode | CharacterClassElementNode;
+type Path<N = Node, Root = RegexNode> = {
+    node: N;
+    parent: N extends RegexNode ? null : ParentNode;
+    key: N extends RegexNode ? null : number | string;
+    container: N extends RegexNode ? null : Array<ContainerElementNode> | null;
+    root: Root;
+    remove: () => void;
+    removeAllNextSiblings: () => Array<Node>;
+    removeAllPrevSiblings: () => Array<Node>;
+    replaceWith: (newNode: Node, options?: {
+        traverse?: boolean;
+    }) => void;
+    replaceWithMultiple: (newNodes: Array<Node>, options?: {
+        traverse?: boolean;
+    }) => void;
+    skip: () => void;
+};
+type Visitor<State extends object | null = null, Root extends Node = RegexNode> = {
+    [N in Node as N['type']]?: VisitorNodeFn<Path<N, Root>, State> | {
+        enter?: VisitorNodeFn<Path<N, Root>, State>;
+        exit?: VisitorNodeFn<Path<N, Root>, State>;
+    };
+} & {
+    '*'?: VisitorNodeFn<Path<Node, Root>, State> | {
+        enter?: VisitorNodeFn<Path<Node, Root>, State>;
+        exit?: VisitorNodeFn<Path<Node, Root>, State>;
+    };
+};
+type VisitorNodeFn<P, State> = (path: P, state: State) => void;
+/**
+Traverses an AST and calls the provided `visitor`'s node function for each node. Returns the same
+object, possibly modified.
+
+Visitor node functions can modify the AST in place and use methods on the `path` (provided as their
+first argument) to help modify the AST. Provided `state` is passed through to all visitor node
+functions as their second argument.
+
+Visitor node functions are called in the following order:
+1. `enter` function of the `'*'` node type (if any)
+2. `enter` function of the given node's type (if any)
+3. [The node's kids (if any) are traversed recursively, unless `skip` is called]
+4. `exit` function of the given node's type (if any)
+5. `exit` function of the `'*'` node type (if any)
+*/
+declare function traverse<State extends object | null = null, Root extends Node = RegexNode>(root: Root, visitor: Visitor<State, Root>, state?: State | null): Root;
+export { type Path, type Visitor, traverse, };
+//# sourceMappingURL=traverse.d.ts.map

package/node_modules/oniguruma-parser/dist/traverser/traverse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traverse.d.ts","sourceRoot":"","sources":["../../src/traverser/traverse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,sBAAsB,EAAE,eAAe,EAAE,yBAAyB,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAC,MAAM,oBAAoB,CAAC;AAGxI,KAAK,oBAAoB,GAEvB,eAAe,GAEf,sBAAsB,GAEtB,yBAAyB,CAAC;AAE5B,KAAK,IAAI,CAAC,CAAC,GAAG,IAAI,EAAE,IAAI,GAAG,SAAS,IAAI;IAEtC,IAAI,EAAE,CAAC,CAAC;IAER,MAAM,EAAE,CAAC,SAAS,SAAS,GAAG,IAAI,GAAG,UAAU,CAAC;IAGhD,GAAG,EAAE,CAAC,SAAS,SAAS,GAAG,IAAI,GAAG,MAAM,GAAG,MAAM,CAAC;IAGlD,SAAS,EAAE,CAAC,SAAS,SAAS,GAAG,IAAI,GAAG,KAAK,CAAC,oBAAoB,CAAC,GAAG,IAAI,CAAC;IAG3E,IAAI,EAAE,IAAI,CAAC;IAEX,MAAM,EAAE,MAAM,IAAI,CAAC;IAGnB,qBAAqB,EAAE,MAAM,KAAK,CAAC,IAAI,CAAC,CAAC;IAGzC,qBAAqB,EAAE,MAAM,KAAK,CAAC,IAAI,CAAC,CAAC;IAGzC,WAAW,EAAE,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAC,KAAK,IAAI,CAAC;IAGrE,mBAAmB,EAAE,CAAC,QAAQ,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,EAAE;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAC,KAAK,IAAI,CAAC;IAErF,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB,CAAC;AAGF,KAAK,OAAO,CAAC,KAAK,SAAS,MAAM,GAAG,IAAI,GAAG,IAAI,EAAE,IAAI,SAAS,IAAI,GAAG,SAAS,IAAI;KAC/E,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,KAAK,CAAC,GAAG;QAC/D,KAAK,CAAC,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,KAAK,CAAC,CAAC;QAC5C,IAAI,CAAC,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,KAAK,CAAC,CAAC;KAC5C;CACF,GAAG;IACF,GAAG,CAAC,EAAE,aAAa,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,KAAK,CAAC,GAAG;QAC7C,KAAK,CAAC,EAAE,aAAa,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,KAAK,CAAC,CAAC;QAC/C,IAAI,CAAC,EAAE,aAAa,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,KAAK,CAAC,CAAC;KAC/C,CAAC;CACH,CAAC;AAEF,KAAK,aAAa,CAAC,CAAC,EAAE,KAAK,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;AAE/D;;;;;;;;;;;;;;EAcE;AACF,iBAAS,QAAQ,CAAC,KAAK,SAAS,MAAM,GAAG,IAAI,GAAG,IAAI,EAAE,IAAI,SAAS,IAAI,GAAG,SAAS,EACjF,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,EAC7B,KAAK,GAAE,KAAK,GAAG,IAAW,GACzB,IAAI,CA0HN;AAgBD,OAAO,EACL,KAAK,IAAI,EACT,KAAK,OAAO,EACZ,QAAQ,GACT,CAAC"}

package/node_modules/oniguruma-parser/dist/traverser/traverse.js

@@ -0,0 +1,2 @@
+"use strict";import{throwIfNullish as A}from"../utils.js";function S(a,v,N=null){function b(e,s){for(let t=0;t<e.length;t++){const r=n(e[t],s,t,e);t=Math.max(-1,t+r)}}function n(e,s=null,t=null,r=null){let i=0,c=!1;const d={node:e,parent:s,key:t,container:r,root:a,remove(){x(r).splice(Math.max(0,l(t)+i),1),i--,c=!0},removeAllNextSiblings(){return x(r).splice(l(t)+1)},removeAllPrevSiblings(){const o=l(t)+i;return i-=o,x(r).splice(0,Math.max(0,o))},replaceWith(o,m={}){const y=!!m.traverse;r?r[Math.max(0,l(t)+i)]=o:A(s,"Can't replace root node")[t]=o,y&&n(o,s,t,r),c=!0},replaceWithMultiple(o,m={}){const y=!!m.traverse;if(x(r).splice(Math.max(0,l(t)+i),1,...o),i+=o.length-1,y){let g=0;for(let p=0;p<o.length;p++)g+=n(o[p],s,l(t)+p+g,r)}c=!0},skip(){c=!0}},{type:f}=e,u=v["*"],h=v[f],R=typeof u=="function"?u:u?.enter,P=typeof h=="function"?h:h?.enter;if(R?.(d,N),P?.(d,N),!c)switch(f){case"AbsenceFunction":case"Alternative":case"CapturingGroup":case"CharacterClass":case"Group":case"LookaroundAssertion":b(e.body,e);break;case"Assertion":case"Backreference":case"Character":case"CharacterSet":case"Directive":case"Flags":case"NamedCallout":case"Subroutine":break;case"CharacterClassRange":n(e.min,e,"min"),n(e.max,e,"max");break;case"Quantifier":n(e.body,e,"body");break;case"Regex":b(e.body,e),n(e.flags,e,"flags");break;default:throw new Error(`Unexpected node type "${f}"`)}return h?.exit?.(d,N),u?.exit?.(d,N),i}return n(a),a}function x(a){if(!Array.isArray(a))throw new Error("Container expected");return a}function l(a){if(typeof a!="number")throw new Error("Numeric key expected");return a}export{S as traverse};
+//# sourceMappingURL=traverse.js.map

package/node_modules/oniguruma-parser/dist/traverser/traverse.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/traverser/traverse.ts"],
+  "sourcesContent": ["import type {AlternativeElementNode, AlternativeNode, CharacterClassElementNode, Node, ParentNode, RegexNode} from '../parser/parse.js';\nimport {throwIfNullish} from '../utils.js';\n\ntype ContainerElementNode =\n  // Used within the `body` container of any `AlternativeContainerNode`\n  AlternativeNode |\n  // Any node type used within the `body` container of an `AlternativeNode`\n  AlternativeElementNode |\n  // Any node type used within the `body` container of a `CharacterClassNode`\n  CharacterClassElementNode;\n\ntype Path<N = Node, Root = RegexNode> = {\n  // The current node being traversed\n  node: N;\n  // Parent node of the current node\n  parent: N extends RegexNode ? null : ParentNode;\n  // String property where the current node in held by the parent node, or numeric index in the\n  // parent's `container` array\n  key: N extends RegexNode ? null : number | string;\n  // Container array holding the current node in the parent node; `null` if the parent isn't a type\n  // that contains a list of nodes\n  container: N extends RegexNode ? null : Array<ContainerElementNode> | null;\n  // Starting node of the AST being traversed; usually a `RegexNode` but can be any node type if\n  // traversing from a midpoint\n  root: Root;\n  // Removes the current node; its kids won't be traversed\n  remove: () => void;\n  // Removes all siblings to the right of the current node, without traversing them; returns the\n  // removed nodes\n  removeAllNextSiblings: () => Array<Node>;\n  // Removes all siblings to the left of the current node, which have already been traversed;\n  // returns the removed nodes\n  removeAllPrevSiblings: () => Array<Node>;\n  // Replaces the current node with a new node; kids of the replaced node won't be traversed;\n  // optionally traverses the new node\n  replaceWith: (newNode: Node, options?: {traverse?: boolean}) => void;\n  // Replaces the current node with multiple new nodes; kids of the replaced node won't be\n  // traversed; optionally traverses the new nodes\n  replaceWithMultiple: (newNodes: Array<Node>, options?: {traverse?: boolean}) => void;\n  // Skips traversing kids of the current node\n  skip: () => void;\n};\n\n// `VisitorNodeFn() {\u2026}` is shorthand for `VisitorNodeFn: {enter() {\u2026}}`.\ntype Visitor<State extends object | null = null, Root extends Node = RegexNode> = {\n  [N in Node as N['type']]?: VisitorNodeFn<Path<N, Root>, State> | {\n    enter?: VisitorNodeFn<Path<N, Root>, State>;\n    exit?: VisitorNodeFn<Path<N, Root>, State>;\n  };\n} & {\n  '*'?: VisitorNodeFn<Path<Node, Root>, State> | {\n    enter?: VisitorNodeFn<Path<Node, Root>, State>;\n    exit?: VisitorNodeFn<Path<Node, Root>, State>;\n  };\n};\n\ntype VisitorNodeFn<P, State> = (path: P, state: State) => void;\n\n/**\nTraverses an AST and calls the provided `visitor`'s node function for each node. Returns the same\nobject, possibly modified.\n\nVisitor node functions can modify the AST in place and use methods on the `path` (provided as their\nfirst argument) to help modify the AST. Provided `state` is passed through to all visitor node\nfunctions as their second argument.\n\nVisitor node functions are called in the following order:\n1. `enter` function of the `'*'` node type (if any)\n2. `enter` function of the given node's type (if any)\n3. [The node's kids (if any) are traversed recursively, unless `skip` is called]\n4. `exit` function of the given node's type (if any)\n5. `exit` function of the `'*'` node type (if any)\n*/\nfunction traverse<State extends object | null = null, Root extends Node = RegexNode>(\n  root: Root,\n  visitor: Visitor<State, Root>,\n  state: State | null = null\n): Root {\n  function traverseArray(array: NonNullable<Path['container']>, parent: Path['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(\n    node: Path['node'],\n    parent: Path['parent'] = null,\n    key: Path['key'] = null,\n    container: Path['container'] = null\n  ): number {\n    let keyShift = 0;\n    let skipTraversingKidsOfPath = false;\n    const path: Path = {\n      node,\n      parent,\n      key,\n      container,\n      root: root as RegexNode,\n      remove() {\n        arrayContainer(container).splice(Math.max(0, numericKey(key) + keyShift), 1);\n        keyShift--;\n        skipTraversingKidsOfPath = true;\n      },\n      removeAllNextSiblings() {\n        return arrayContainer(container).splice(numericKey(key) + 1);\n      },\n      removeAllPrevSiblings() {\n        const shifted = numericKey(key) + keyShift;\n        keyShift -= shifted;\n        return arrayContainer(container).splice(0, Math.max(0, shifted));\n      },\n      replaceWith(newNode, options = {}) {\n        const traverseNew = !!options.traverse;\n        if (container) {\n          container[Math.max(0, numericKey(key) + keyShift)] = newNode as ContainerElementNode;\n        } else {\n          // `key` will be one of:\n          // - For `CharacterClassRangeNode`: 'min', 'max'\n          // - For `QuantifierNode`: 'body'\n          // - For `RegexNode`: 'flags'\n          // @ts-expect-error\n          throwIfNullish(parent, `Can't replace root node`)[key as string] = newNode;\n        }\n        if (traverseNew) {\n          traverseNode(newNode, parent, key, container);\n        }\n        skipTraversingKidsOfPath = true;\n      },\n      replaceWithMultiple(newNodes, options = {}) {\n        const traverseNew = !!options.traverse;\n        arrayContainer(container).splice(Math.max(0, numericKey(key) + keyShift), 1, ...newNodes);\n        keyShift += newNodes.length - 1;\n        if (traverseNew) {\n          let keyShiftInLoop = 0;\n          for (let i = 0; i < newNodes.length; i++) {\n            keyShiftInLoop += traverseNode(newNodes[i], parent, numericKey(key) + i + keyShiftInLoop, container);\n          }\n        }\n        skipTraversingKidsOfPath = true;\n      },\n      skip() {\n        skipTraversingKidsOfPath = true;\n      },\n    };\n\n    const {type} = node;\n    const anyTypeVisitor = visitor['*'];\n    const thisTypeVisitor = visitor[type];\n    const enterAllFn = typeof anyTypeVisitor === 'function' ? anyTypeVisitor : anyTypeVisitor?.enter;\n    const enterThisFn = typeof thisTypeVisitor === 'function' ? thisTypeVisitor : thisTypeVisitor?.enter;\n    // Type args are too complex to avoid TS errors here, but `VisitorNodeFn`s get correct types\n    // @ts-expect-error\n    enterAllFn?.(path, state);\n    // @ts-expect-error\n    enterThisFn?.(path, state);\n\n    if (!skipTraversingKidsOfPath) {\n      switch (type) {\n        case 'AbsenceFunction':\n        case 'Alternative':\n        case 'CapturingGroup':\n        case 'CharacterClass':\n        case 'Group':\n        case 'LookaroundAssertion':\n          traverseArray(node.body, node);\n          break;\n        case 'Assertion':\n        case 'Backreference':\n        case 'Character':\n        case 'CharacterSet':\n        case 'Directive':\n        case 'Flags':\n        case 'NamedCallout':\n        case 'Subroutine':\n          break;\n        case 'CharacterClassRange':\n          traverseNode(node.min, node, 'min');\n          traverseNode(node.max, node, 'max');\n          break;\n        case 'Quantifier':\n          traverseNode(node.body, node, 'body');\n          break;\n        case 'Regex':\n          traverseArray(node.body, node);\n          traverseNode(node.flags, node, 'flags');\n          break;\n        default:\n          throw new Error(`Unexpected node type \"${type}\"`);\n      }\n    }\n\n    // @ts-expect-error\n    (thisTypeVisitor as Exclude<typeof thisTypeVisitor, Function>)?.exit?.(path, state);\n    // @ts-expect-error\n    (anyTypeVisitor as Exclude<typeof anyTypeVisitor, Function>)?.exit?.(path, state);\n    return keyShift;\n  }\n  traverseNode(root);\n  return root;\n}\n\nfunction arrayContainer(value: unknown): Array<Node> {\n  if (!Array.isArray(value)) {\n    throw new Error('Container expected');\n  }\n  return value;\n}\n\nfunction numericKey(value: unknown): number {\n  if (typeof value !== 'number') {\n    throw new Error('Numeric key expected');\n  }\n  return value;\n}\n\nexport {\n  type Path,\n  type Visitor,\n  traverse,\n};\n"],
+  "mappings": "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",
+  "names": ["throwIfNullish", "traverse", "root", "visitor", "state", "traverseArray", "array", "parent", "i", "keyShift", "traverseNode", "node", "key", "container", "skipTraversingKidsOfPath", "path", "arrayContainer", "numericKey", "shifted", "newNode", "options", "traverseNew", "newNodes", "keyShiftInLoop", "type", "anyTypeVisitor", "thisTypeVisitor", "enterAllFn", "enterThisFn", "value"]
+}

package/node_modules/oniguruma-parser/dist/unicode.d.ts

@@ -0,0 +1,8 @@
+import type { UnicodePropertyMap } from "./parser/parse.js";
+/**
+All Unicode properties supported by Oniguruma 6.9.10 (Unicode 16.0.0).
+Copied from <github.com/kkos/oniguruma/blob/master/doc/UNICODE_PROPERTIES>
+*/
+declare const OnigUnicodePropertyMap: UnicodePropertyMap;
+export { OnigUnicodePropertyMap, };
+//# sourceMappingURL=unicode.d.ts.map

package/node_modules/oniguruma-parser/dist/unicode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unicode.d.ts","sourceRoot":"","sources":["../src/unicode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,mBAAmB,CAAC;AAG1D;;;EAGE;AACF,QAAA,MAAM,sBAAsB,EAAE,kBA02B7B,CAAC;AAEF,OAAO,EACL,sBAAsB,GACvB,CAAC"}