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

node_modules/oniguruma-to-es/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 Steven Levithan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/oniguruma-to-es/dist/cjs/generate.d.ts

@@ -0,0 +1,27 @@
+/**
+@import {ToRegExpOptions} from './index.js';
+@import {RegexPlusAst} from './transform.js';
+@import {AlternativeNode, AssertionNode, BackreferenceNode, CapturingGroupNode, CharacterClassNode, CharacterClassRangeNode, CharacterNode, CharacterSetNode, FlagsNode, GroupNode, LookaroundAssertionNode, Node, QuantifierNode, SubroutineNode} from 'oniguruma-parser/parser';
+@import {Visitor} from 'oniguruma-parser/traverser';
+*/
+/**
+Generates a Regex+ compatible `pattern`, `flags`, and `options` from a Regex+ AST.
+@param {RegexPlusAst} ast
+@param {ToRegExpOptions} [options]
+@returns {{
+  pattern: string;
+  flags: string;
+  options: Object;
+  _captureTransfers: Map<number, Array<number>>;
+  _hiddenCaptures: Array<number>;
+}}
+*/
+export function generate(ast: RegexPlusAst, options?: ToRegExpOptions): {
+    pattern: string;
+    flags: string;
+    options: Object;
+    _captureTransfers: Map<number, Array<number>>;
+    _hiddenCaptures: Array<number>;
+};
+import type { RegexPlusAst } from './transform.js';
+import type { ToRegExpOptions } from './index.js';

node_modules/oniguruma-to-es/dist/cjs/index.d.ts

@@ -0,0 +1,64 @@
+export type ToRegExpOptions = {
+    accuracy?: "default" | "strict";
+    avoidSubclass?: boolean;
+    flags?: string;
+    global?: boolean;
+    hasIndices?: boolean;
+    lazyCompileLength?: number;
+    rules?: {
+        allowOrphanBackrefs?: boolean;
+        asciiWordBoundaries?: boolean;
+        captureGroup?: boolean;
+        recursionLimit?: number;
+        singleline?: boolean;
+    };
+    target?: "auto" | "ES2025" | "ES2024" | "ES2018";
+    verbose?: boolean;
+};
+import { EmulatedRegExp } from './subclass.js';
+/**
+@import {EmulatedRegExpOptions} from './subclass.js';
+*/
+/**
+@typedef {{
+  accuracy?: keyof Accuracy;
+  avoidSubclass?: boolean;
+  flags?: string;
+  global?: boolean;
+  hasIndices?: boolean;
+  lazyCompileLength?: number;
+  rules?: {
+    allowOrphanBackrefs?: boolean;
+    asciiWordBoundaries?: boolean;
+    captureGroup?: boolean;
+    recursionLimit?: number;
+    singleline?: boolean;
+  };
+  target?: keyof Target;
+  verbose?: boolean;
+}} ToRegExpOptions
+*/
+/**
+Accepts an Oniguruma pattern and returns an equivalent JavaScript `RegExp`.
+@param {string} pattern Oniguruma regex pattern.
+@param {ToRegExpOptions} [options]
+@returns {RegExp | EmulatedRegExp}
+*/
+export function toRegExp(pattern: string, options?: ToRegExpOptions): RegExp | EmulatedRegExp;
+/**
+Accepts an Oniguruma pattern and returns the details for an equivalent JavaScript `RegExp`.
+@param {string} pattern Oniguruma regex pattern.
+@param {ToRegExpOptions} [options]
+@returns {{
+  pattern: string;
+  flags: string;
+  options?: EmulatedRegExpOptions;
+}}
+*/
+export function toRegExpDetails(pattern: string, options?: ToRegExpOptions): {
+    pattern: string;
+    flags: string;
+    options?: EmulatedRegExpOptions;
+};
+import type { EmulatedRegExpOptions } from './subclass.js';
+export { EmulatedRegExp };

node_modules/oniguruma-to-es/dist/cjs/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.js", "../../src/utils.js", "../../src/options.js", "../../node_modules/.pnpm/oniguruma-parser@0.12.2/node_modules/oniguruma-parser/src/utils.ts", "../../node_modules/.pnpm/oniguruma-parser@0.12.2/node_modules/oniguruma-parser/src/tokenizer/tokenize.ts", "../../node_modules/.pnpm/oniguruma-parser@0.12.2/node_modules/oniguruma-parser/src/parser/node-utils.ts", "../../node_modules/.pnpm/oniguruma-parser@0.12.2/node_modules/oniguruma-parser/src/parser/parse.ts", "../../src/unicode.js", "../../node_modules/.pnpm/oniguruma-parser@0.12.2/node_modules/oniguruma-parser/src/traverser/traverse.ts", "../../src/transform.js", "../../src/generate.js", "../../src/subclass.js", "../../node_modules/.pnpm/regex@6.1.0/node_modules/regex/src/utils-internals.js", "../../node_modules/.pnpm/regex-utilities@2.3.0/node_modules/regex-utilities/src/index.js", "../../node_modules/.pnpm/regex@6.1.0/node_modules/regex/src/atomic.js", "../../node_modules/.pnpm/regex-recursion@6.0.2/node_modules/regex-recursion/src/index.js"],
+  "sourcesContent": ["import {transform} from './transform.js';\nimport {generate} from './generate.js';\nimport {Accuracy, getOptions, Target} from './options.js';\nimport {EmulatedRegExp} from './subclass.js';\nimport {JsUnicodePropertyMap} from './unicode.js';\nimport {parse} from 'oniguruma-parser/parser';\nimport {atomic, possessive} from 'regex/internals';\nimport {recursion} from 'regex-recursion';\n/**\n@import {EmulatedRegExpOptions} from './subclass.js';\n*/\n\n// The validation and transformation for Oniguruma's unique syntax and behavior differences\n// compared to native JS RegExp is layered into all steps of the compilation process:\n// 1. Parser: Uses `oniguruma-parser` to build an Oniguruma AST, which accounts for many\n//    differences between Oniguruma and JS.\n// 2. Transformer: Converts the Oniguruma AST to a Regex+ AST that preserves all Oniguruma\n//    behavior. This is true even in cases of non-native-JS features that are supported by both\n//    Regex+ and Oniguruma but with subtly different behavior in each (subroutines, flag x).\n// 3. Generator: Converts the Regex+ AST to a Regex+ pattern, flags, and options.\n// 4. Postprocessing: Regex+ internals and plugins are used to transpile several remaining features\n//    (atomic groups, possessive quantifiers, recursion). Regex+ uses a strict superset of JS\n//    RegExp syntax, so using it allows this library to benefit from not reinventing the wheel for\n//    complex features that Regex+ already knows how to transpile to JS.\n\n/**\n@typedef {{\n  accuracy?: keyof Accuracy;\n  avoidSubclass?: boolean;\n  flags?: string;\n  global?: boolean;\n  hasIndices?: boolean;\n  lazyCompileLength?: number;\n  rules?: {\n    allowOrphanBackrefs?: boolean;\n    asciiWordBoundaries?: boolean;\n    captureGroup?: boolean;\n    recursionLimit?: number;\n    singleline?: boolean;\n  };\n  target?: keyof Target;\n  verbose?: boolean;\n}} ToRegExpOptions\n*/\n\n/**\nAccepts an Oniguruma pattern and returns an equivalent JavaScript `RegExp`.\n@param {string} pattern Oniguruma regex pattern.\n@param {ToRegExpOptions} [options]\n@returns {RegExp | EmulatedRegExp}\n*/\nfunction toRegExp(pattern, options) {\n  const d = toRegExpDetails(pattern, options);\n  if (d.options) {\n    return new EmulatedRegExp(d.pattern, d.flags, d.options);\n  }\n  return new RegExp(d.pattern, d.flags);\n}\n\n/**\nAccepts an Oniguruma pattern and returns the details for an equivalent JavaScript `RegExp`.\n@param {string} pattern Oniguruma regex pattern.\n@param {ToRegExpOptions} [options]\n@returns {{\n  pattern: string;\n  flags: string;\n  options?: EmulatedRegExpOptions;\n}}\n*/\nfunction toRegExpDetails(pattern, options) {\n  const opts = getOptions(options);\n  const onigurumaAst = parse(pattern, {\n    flags: opts.flags,\n    normalizeUnknownPropertyNames: true,\n    rules: {\n      captureGroup: opts.rules.captureGroup,\n      singleline: opts.rules.singleline,\n    },\n    skipBackrefValidation: opts.rules.allowOrphanBackrefs,\n    unicodePropertyMap: JsUnicodePropertyMap,\n  });\n  const regexPlusAst = transform(onigurumaAst, {\n    accuracy: opts.accuracy,\n    asciiWordBoundaries: opts.rules.asciiWordBoundaries,\n    avoidSubclass: opts.avoidSubclass,\n    bestEffortTarget: opts.target,\n  });\n  const generated = generate(regexPlusAst, opts);\n  const recursionResult = recursion(generated.pattern, {\n    captureTransfers: generated._captureTransfers,\n    hiddenCaptures: generated._hiddenCaptures,\n    mode: 'external',\n  });\n  const possessiveResult = possessive(recursionResult.pattern);\n  const atomicResult = atomic(possessiveResult.pattern, {\n    captureTransfers: recursionResult.captureTransfers,\n    hiddenCaptures: recursionResult.hiddenCaptures,\n  });\n  const details = {\n    pattern: atomicResult.pattern,\n    flags: `${opts.hasIndices ? 'd' : ''}${opts.global ? 'g' : ''}${generated.flags}${generated.options.disable.v ? 'u' : 'v'}`,\n  };\n  if (opts.avoidSubclass) {\n    if (opts.lazyCompileLength !== Infinity) {\n      throw new Error('Lazy compilation requires subclass');\n    }\n  } else {\n    // Sort isn't required; only for readability when serialized\n    const hiddenCaptures = atomicResult.hiddenCaptures.sort((a, b) => a - b);\n    // Change the map to the `EmulatedRegExp` format, serializable as JSON\n    const transfers = Array.from(atomicResult.captureTransfers);\n    const strategy = regexPlusAst._strategy;\n    const lazyCompile = details.pattern.length >= opts.lazyCompileLength;\n    if (hiddenCaptures.length || transfers.length || strategy || lazyCompile) {\n      details.options = {\n        ...(hiddenCaptures.length && {hiddenCaptures}),\n        ...(transfers.length && {transfers}),\n        ...(strategy && {strategy}),\n        ...(lazyCompile && {lazyCompile}),\n      };\n    }\n  }\n  return details;\n}\n\n// function toOnigurumaAst(pattern, options) {\n//   return parse(pattern, {\n//     flags: options?.flags ?? '',\n//     noLine truncated
+  "mappings": "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 truncated
+  "names": ["cpOf", "char", "getOrInsert", "map", "key", "defaultValue", "PosixClassNames", "r", "throwIfNullish", "value", "msg", "charClassOpenPattern", "r", "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", "cpOf", "opener", "createCharacterClassOpenToken", "numCharClassesOpen", "createCharacterClassCloseToken", "tokenizeAnyTokenWithinCharClass", "raw", "posix", "PosixClassNames", "createCharacterClassHyphenToken", "createCharacterClassIntersectorToken", "inCharClass", "char1", "tokenizeControlCharacter", "tokenizeShorthand", "tokenizeUnicodeProperty", "bytes", "hex", "decoded", "encoder", "char", "byte", "getValidatedHexCharCode", "EscapeCharCodes", "createEscapedNumberToken", "value", "negate", "throwIfNullish", "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", "hasOnlyChild", "node", "props", "kid", "key", "isQuantifiable", "node", "quantifiableTypes", "parse", "pattern", "options", "opts", "tokenized", "tokenize", "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", "r", "kind", "createAssertion", "throwIfNullish", "raw", "hasKWrapper", "fromNum", "num", "isRelative", "numCapturesToLeft", "orphan", "createBackreference", "numberedRef", "_", "tokens", "prevSiblingNode", "nextToken", "nextNode", "createCharacterClassRange", "cpOf", "negate", "intersections", "createCharacterClass", "ccFirstToken", "throwIfUnclosedCharacterClass", "cc", "value", "normalizeUnknownPropertyNames", "skipPropertyNameValidation", "unicodePropertyMap", "normalized", "slug", "PosixClassNames", "createUnicodeProperty", "createPosixClass", "createCharacterSet", "skipLookbehindValidation", "createByGroupKind", "isThisAbsenceFunction", "isThisLookbehind", "isLookbehind", "isThisNegLookbehind", "getOrInsert", "throwIfUnclosedGroup", "alt", "child", "msg", "isLookahead", "min", "max", "quantifiedNode", "isQuantifiable", "createQuantifier", "createSubroutine", "createAbsenceFunction", "getBodyForAlternativeContainer", "getBodyForElementContainer", "createCapturingGroup", "number", "isValidGroupName", "charCode", "hex", "flags", "createGroup", "atomic", "createLookaroundAssertion", "tag", "args", "name", "body", "normalizeUnicodePropertyName", "m", "first", "w", "range", "i", "traverse", "root", "visitor", "state", "traverseArray", "array", "parent", "i", "keyShift", "traverseNode", "node", "key", "container", "skipTraversingKidsOfPath", "path", "arrayContainer", "numericKey", "shifted", "newNode", "options", "traverseNew", "throwIfNullish", "newNodes", "keyShiftInLoop", "type", "anyTypeVisitor", "thisTypeVisitor", "enterAllFn", "enterThisFn", "value", "A", "K", "Q", "_", "i", "b", "F", "m", "B", "C", "E", "w", "o", "f", "node", "recursion", "k", "P", "a", "O", "J", "_", "m", "A", "b", "atomic", "i", "a", "re", "i", "m", "i", "re", "m", "token", "m", "f", "r", "m", "i", "incrementIfAtLeast", "f", "d", "J", "a", "b"]
+}

node_modules/oniguruma-to-es/dist/cjs/options.d.ts

@@ -0,0 +1,26 @@
+export namespace Accuracy {
+    let _default: "default";
+    export { _default as default };
+    export let strict: "strict";
+}
+export namespace EsVersion {
+    let ES2025: number;
+    let ES2024: number;
+    let ES2018: number;
+}
+/**
+Returns a complete set of options, with default values set for options that weren't provided.
+@param {ToRegExpOptions} [options]
+@returns {Required<ToRegExpOptions>}
+*/
+export function getOptions(options?: ToRegExpOptions): Required<ToRegExpOptions>;
+export namespace Target {
+    export let auto: "auto";
+    let ES2025_1: "ES2025";
+    export { ES2025_1 as ES2025 };
+    let ES2024_1: "ES2024";
+    export { ES2024_1 as ES2024 };
+    let ES2018_1: "ES2018";
+    export { ES2018_1 as ES2018 };
+}
+import type { ToRegExpOptions } from './index.js';

node_modules/oniguruma-to-es/dist/cjs/package.json

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

node_modules/oniguruma-to-es/dist/cjs/subclass.d.ts

@@ -0,0 +1,39 @@
+export type EmulatedRegExpOptions = {
+    hiddenCaptures?: Array<number>;
+    lazyCompile?: boolean;
+    strategy?: string | null;
+    transfers?: Array<[number, Array<number>]>;
+};
+/**
+@typedef {{
+  hiddenCaptures?: Array<number>;
+  lazyCompile?: boolean;
+  strategy?: string | null;
+  transfers?: Array<[number, Array<number>]>;
+}} EmulatedRegExpOptions
+*/
+/**
+Works the same as JavaScript's native `RegExp` constructor in all contexts, but can be given
+results from `toRegExpDetails` to produce the same result as `toRegExp`.
+*/
+export class EmulatedRegExp extends RegExp {
+    /**
+     @overload
+     @param {string} pattern
+     @param {string} [flags]
+     @param {EmulatedRegExpOptions} [options]
+     */
+    constructor(pattern: string, flags?: string | undefined, options?: EmulatedRegExpOptions | undefined);
+    /**
+     @overload
+     @param {EmulatedRegExp} pattern
+     @param {string} [flags]
+     */
+    constructor(pattern: EmulatedRegExp, flags?: string | undefined);
+    /**
+    Can be used to serialize the instance.
+    @type {EmulatedRegExpOptions}
+    */
+    rawOptions: EmulatedRegExpOptions;
+    #private;
+}

node_modules/oniguruma-to-es/dist/cjs/transform.d.ts

@@ -0,0 +1,54 @@
+export type RegexPlusAst = OnigurumaAst & {
+    options: {
+        disable: {
+            [key: string]: boolean;
+        };
+        force: {
+            [key: string]: boolean;
+        };
+    };
+    _originMap: Map<CapturingGroupNode, CapturingGroupNode>;
+    _strategy: string | null;
+};
+/**
+@import {CapturingGroupNode, OnigurumaAst, Node} from 'oniguruma-parser/parser';
+@import {Visitor} from 'oniguruma-parser/traverser';
+*/
+/**
+@typedef {
+  OnigurumaAst & {
+    options: {
+      disable: {[key: string]: boolean};
+      force: {[key: string]: boolean};
+    };
+    _originMap: Map<CapturingGroupNode, CapturingGroupNode>;
+    _strategy: string | null;
+  }
+} RegexPlusAst
+*/
+/**
+Transforms an Oniguruma AST in-place to a [Regex+](https://github.com/slevithan/regex) AST.
+Assumes target ES2025, expecting the generator to down-convert to the desired JS target version.
+
+Regex+'s syntax and behavior is a strict superset of native JavaScript, so the AST is very close
+to representing native ES2025 `RegExp` but with some added features (atomic groups, possessive
+quantifiers, recursion). The AST doesn't use some of Regex+'s extended features like flag x or
+subroutines because they follow PCRE behavior and work somewhat differently than in Oniguruma. The
+AST represents what's needed to precisely reproduce Oniguruma behavior using Regex+.
+@param {OnigurumaAst} ast
+@param {{
+  accuracy?: keyof Accuracy;
+  asciiWordBoundaries?: boolean;
+  avoidSubclass?: boolean;
+  bestEffortTarget?: keyof Target;
+}} [options]
+@returns {RegexPlusAst}
+*/
+export function transform(ast: OnigurumaAst, options?: {
+    accuracy?: "default" | "strict";
+    asciiWordBoundaries?: boolean;
+    avoidSubclass?: boolean;
+    bestEffortTarget?: "auto" | "ES2025" | "ES2024" | "ES2018";
+}): RegexPlusAst;
+import type { OnigurumaAst } from 'oniguruma-parser/parser';
+import type { CapturingGroupNode } from 'oniguruma-parser/parser';

node_modules/oniguruma-to-es/dist/cjs/unicode.d.ts

@@ -0,0 +1,6 @@
+export const asciiSpaceChar: "[\t-\r ]";
+export const defaultWordChar: string;
+export function getIgnoreCaseMatchChars(char: any): any[];
+export const JsUnicodePropertyMap: Map<string, string>;
+export const PosixClassMap: Map<string, string>;
+export const UnicodePropertiesWithSpecificCase: Set<string>;

node_modules/oniguruma-to-es/dist/cjs/utils.d.ts

@@ -0,0 +1,25 @@
+export const cp: (...codePoints: number[]) => string;
+export namespace envFlags {
+    let flagGroups: boolean;
+    let unicodeSets: boolean;
+    let bugFlagVLiteralHyphenIsRange: boolean;
+    let bugNestedClassIgnoresNegation: boolean;
+}
+export function getNewCurrentFlags(current: any, { enable, disable }: {
+    enable: any;
+    disable: any;
+}): {
+    dotAll: boolean;
+    ignoreCase: boolean;
+};
+export function getOrInsert(map: any, key: any, defaultValue: any): any;
+/**
+@param {keyof Target} target
+@param {keyof Target} min
+@returns {boolean}
+*/
+export function isMinTarget(target: "auto" | "ES2025" | "ES2024" | "ES2018", min: "auto" | "ES2025" | "ES2024" | "ES2018"): boolean;
+export const r: (template: {
+    raw: readonly string[] | ArrayLike<string>;
+}, ...substitutions: any[]) => string;
+export function throwIfNullish(value: any, msg: any): any;

node_modules/oniguruma-to-es/dist/esm/generate.d.ts

@@ -0,0 +1,27 @@
+/**
+@import {ToRegExpOptions} from './index.js';
+@import {RegexPlusAst} from './transform.js';
+@import {AlternativeNode, AssertionNode, BackreferenceNode, CapturingGroupNode, CharacterClassNode, CharacterClassRangeNode, CharacterNode, CharacterSetNode, FlagsNode, GroupNode, LookaroundAssertionNode, Node, QuantifierNode, SubroutineNode} from 'oniguruma-parser/parser';
+@import {Visitor} from 'oniguruma-parser/traverser';
+*/
+/**
+Generates a Regex+ compatible `pattern`, `flags`, and `options` from a Regex+ AST.
+@param {RegexPlusAst} ast
+@param {ToRegExpOptions} [options]
+@returns {{
+  pattern: string;
+  flags: string;
+  options: Object;
+  _captureTransfers: Map<number, Array<number>>;
+  _hiddenCaptures: Array<number>;
+}}
+*/
+export function generate(ast: RegexPlusAst, options?: ToRegExpOptions): {
+    pattern: string;
+    flags: string;
+    options: Object;
+    _captureTransfers: Map<number, Array<number>>;
+    _hiddenCaptures: Array<number>;
+};
+import type { RegexPlusAst } from './transform.js';
+import type { ToRegExpOptions } from './index.js';

node_modules/oniguruma-to-es/dist/esm/index.d.ts

@@ -0,0 +1,64 @@
+export type ToRegExpOptions = {
+    accuracy?: "default" | "strict";
+    avoidSubclass?: boolean;
+    flags?: string;
+    global?: boolean;
+    hasIndices?: boolean;
+    lazyCompileLength?: number;
+    rules?: {
+        allowOrphanBackrefs?: boolean;
+        asciiWordBoundaries?: boolean;
+        captureGroup?: boolean;
+        recursionLimit?: number;
+        singleline?: boolean;
+    };
+    target?: "auto" | "ES2025" | "ES2024" | "ES2018";
+    verbose?: boolean;
+};
+import { EmulatedRegExp } from './subclass.js';
+/**
+@import {EmulatedRegExpOptions} from './subclass.js';
+*/
+/**
+@typedef {{
+  accuracy?: keyof Accuracy;
+  avoidSubclass?: boolean;
+  flags?: string;
+  global?: boolean;
+  hasIndices?: boolean;
+  lazyCompileLength?: number;
+  rules?: {
+    allowOrphanBackrefs?: boolean;
+    asciiWordBoundaries?: boolean;
+    captureGroup?: boolean;
+    recursionLimit?: number;
+    singleline?: boolean;
+  };
+  target?: keyof Target;
+  verbose?: boolean;
+}} ToRegExpOptions
+*/
+/**
+Accepts an Oniguruma pattern and returns an equivalent JavaScript `RegExp`.
+@param {string} pattern Oniguruma regex pattern.
+@param {ToRegExpOptions} [options]
+@returns {RegExp | EmulatedRegExp}
+*/
+export function toRegExp(pattern: string, options?: ToRegExpOptions): RegExp | EmulatedRegExp;
+/**
+Accepts an Oniguruma pattern and returns the details for an equivalent JavaScript `RegExp`.
+@param {string} pattern Oniguruma regex pattern.
+@param {ToRegExpOptions} [options]
+@returns {{
+  pattern: string;
+  flags: string;
+  options?: EmulatedRegExpOptions;
+}}
+*/
+export function toRegExpDetails(pattern: string, options?: ToRegExpOptions): {
+    pattern: string;
+    flags: string;
+    options?: EmulatedRegExpOptions;
+};
+import type { EmulatedRegExpOptions } from './subclass.js';
+export { EmulatedRegExp };

node_modules/oniguruma-to-es/dist/esm/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils.js", "../../src/options.js", "../../src/unicode.js", "../../src/transform.js", "../../src/generate.js", "../../src/subclass.js", "../../src/index.js"],
+  "sourcesContent": ["import {EsVersion, Target} from './options.js';\n\nconst cp = String.fromCodePoint;\nconst r = String.raw;\n\nconst envFlags = {};\n// Use `globalThis` to prevent env-testing fns from being replaced with constants during bundling\n// with Rolldown; see <github.com/slevithan/oniguruma-to-es/issues/42>\nconst globalRegExp = globalThis.RegExp;\nenvFlags.flagGroups = (() => {\n  try {\n    new globalRegExp('(?i:)');\n  } catch {\n    return false;\n  }\n  return true;\n})();\nenvFlags.unicodeSets = (() => {\n  try {\n    // Check for flag v support and also that nested classes can be parsed\n    // See <github.com/slevithan/oniguruma-to-es/pull/41>\n    new globalRegExp('[[]]', 'v');\n  } catch {\n    return false;\n  }\n  return true;\n})();\n// Detect WebKit bug: <github.com/slevithan/oniguruma-to-es/issues/30>\nenvFlags.bugFlagVLiteralHyphenIsRange = envFlags.unicodeSets ? (() => {\n  try {\n    new globalRegExp(r`[\\d\\-a]`, 'v');\n  } catch {\n    return true;\n  }\n  return false;\n})() : false;\n// Detect WebKit bug: <github.com/slevithan/oniguruma-to-es/issues/38>\nenvFlags.bugNestedClassIgnoresNegation = envFlags.unicodeSets && new globalRegExp('[[^a]]', 'v').test('a');\n\nfunction getNewCurrentFlags(current, {enable, disable}) {\n  return {\n    dotAll: !disable?.dotAll && !!(enable?.dotAll || current.dotAll),\n    ignoreCase: !disable?.ignoreCase && !!(enable?.ignoreCase || current.ignoreCase),\n  };\n}\n\nfunction getOrInsert(map, key, defaultValue) {\n  if (!map.has(key)) {\n    map.set(key, defaultValue);\n  }\n  return map.get(key);\n}\n\n/**\n@param {keyof Target} target\n@param {keyof Target} min\n@returns {boolean}\n*/\nfunction isMinTarget(target, min) {\n  return EsVersion[target] >= EsVersion[min];\n}\n\nfunction throwIfNullish(value, msg) {\n  if (value == null) {\n    throw new Error(msg ?? 'Value expected');\n  }\n  return value;\n}\n\nexport {\n  cp,\n  envFlags,\n  getNewCurrentFlags,\n  getOrInsert,\n  isMinTarget,\n  r,\n  throwIfNullish,\n};\n", "import {envFlags} from './utils.js';\n/**\n@import {ToRegExpOptions} from './index.js';\n*/\n\nconst Accuracy = /** @type {const} */ ({\n  default: 'default',\n  strict: 'strict',\n});\n\nconst EsVersion = {\n  ES2025: 2025,\n  ES2024: 2024,\n  ES2018: 2018,\n};\n\nconst Target = /** @type {const} */ ({\n  auto: 'auto',\n  ES2025: 'ES2025',\n  ES2024: 'ES2024',\n  ES2018: 'ES2018',\n});\n\n/**\nReturns a complete set of options, with default values set for options that weren't provided.\n@param {ToRegExpOptions} [options]\n@returns {Required<ToRegExpOptions>}\n*/\nfunction getOptions(options = {}) {\n  if ({}.toString.call(options) !== '[object Object]') {\n    throw new Error('Unexpected options');\n  }\n  if (options.target !== undefined && !Target[options.target]) {\n    throw new Error(`Unexpected target \"${options.target}\"`)\n  }\n  // Set default values\n  const opts = {\n    // Sets the level of emulation rigor/strictness.\n    accuracy: 'default',\n    // Disables advanced emulation that relies on returning a `RegExp` subclass, resulting in\n    // certain patterns not being emulatable.\n    avoidSubclass: false,\n    // Oniguruma flags; a string with `i`, `m`, `x`, `D`, `S`, `W`, `y{g}` in any order (all\n    // optional). Oniguruma's `m` is equivalent to JavaScript's `s` (`dotAll`).\n    flags: '',\n    // Include JavaScript flag `g` (`global`) in the result.\n    global: false,\n    // Include JavaScript flag `d` (`hasIndices`) in the result.\n    hasIndices: false,\n    // Delay regex construction until first use if the transpiled pattern is at least this length.\n    lazyCompileLength: Infinity,\n    // JavaScript version used for generated regexes. Using `auto` detects the best value based on\n    // your environment. Later targets allow faster processing, simpler generated source, and\n    // support for additional features.\n    target: 'auto',\n    // Disables minifications that simplify the pattern without changing the meaning.\n    verbose: false,\n    ...options,\n    // Advanced options that override standard behavior, error checking, and flags when enabled.\n    rules: {\n      // Useful with TextMate grammars that merge backreferences across patterns.\n      allowOrphanBackrefs: false,\n      // Use ASCII `\\b` and `\\B`, which increases search performance of generated regexes.\n      asciiWordBoundaries: false,\n      // Allow unnamed captures and numbered calls (backreferences and subroutines) when using\n      // named capture. This is Oniguruma option `ONIG_OPTION_CAPTURE_GROUP`; on by default in\n      // `vscode-oniguruma`.\n      captureGroup: false,\n      // Change the recursion depth limit from Oniguruma's `20` to an integer `2`\u2013`20`.\n      recursionLimit: 20,\n      // `^` as `\\A`; `$` as`\\Z`. Improves search performance of generated regexes without changing\n      // the meaning if searching line by line. This is Oniguruma option `ONIG_OPTION_SINGLELINE`.\n      singleline:Line truncated
+  "mappings": "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 truncated
+  "names": ["range", "slug", "node", "recursion", "createAlternative", "createCharacter", "createGroup", "traverse", "atomic", "parse"]
+}

node_modules/oniguruma-to-es/dist/esm/options.d.ts

@@ -0,0 +1,26 @@
+export namespace Accuracy {
+    let _default: "default";
+    export { _default as default };
+    export let strict: "strict";
+}
+export namespace EsVersion {
+    let ES2025: number;
+    let ES2024: number;
+    let ES2018: number;
+}
+/**
+Returns a complete set of options, with default values set for options that weren't provided.
+@param {ToRegExpOptions} [options]
+@returns {Required<ToRegExpOptions>}
+*/
+export function getOptions(options?: ToRegExpOptions): Required<ToRegExpOptions>;
+export namespace Target {
+    export let auto: "auto";
+    let ES2025_1: "ES2025";
+    export { ES2025_1 as ES2025 };
+    let ES2024_1: "ES2024";
+    export { ES2024_1 as ES2024 };
+    let ES2018_1: "ES2018";
+    export { ES2018_1 as ES2018 };
+}
+import type { ToRegExpOptions } from './index.js';

node_modules/oniguruma-to-es/dist/esm/package.json

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

node_modules/oniguruma-to-es/dist/esm/subclass.d.ts

@@ -0,0 +1,39 @@
+export type EmulatedRegExpOptions = {
+    hiddenCaptures?: Array<number>;
+    lazyCompile?: boolean;
+    strategy?: string | null;
+    transfers?: Array<[number, Array<number>]>;
+};
+/**
+@typedef {{
+  hiddenCaptures?: Array<number>;
+  lazyCompile?: boolean;
+  strategy?: string | null;
+  transfers?: Array<[number, Array<number>]>;
+}} EmulatedRegExpOptions
+*/
+/**
+Works the same as JavaScript's native `RegExp` constructor in all contexts, but can be given
+results from `toRegExpDetails` to produce the same result as `toRegExp`.
+*/
+export class EmulatedRegExp extends RegExp {
+    /**
+     @overload
+     @param {string} pattern
+     @param {string} [flags]
+     @param {EmulatedRegExpOptions} [options]
+     */
+    constructor(pattern: string, flags?: string | undefined, options?: EmulatedRegExpOptions | undefined);
+    /**
+     @overload
+     @param {EmulatedRegExp} pattern
+     @param {string} [flags]
+     */
+    constructor(pattern: EmulatedRegExp, flags?: string | undefined);
+    /**
+    Can be used to serialize the instance.
+    @type {EmulatedRegExpOptions}
+    */
+    rawOptions: EmulatedRegExpOptions;
+    #private;
+}

node_modules/oniguruma-to-es/dist/esm/transform.d.ts

@@ -0,0 +1,54 @@
+export type RegexPlusAst = OnigurumaAst & {
+    options: {
+        disable: {
+            [key: string]: boolean;
+        };
+        force: {
+            [key: string]: boolean;
+        };
+    };
+    _originMap: Map<CapturingGroupNode, CapturingGroupNode>;
+    _strategy: string | null;
+};
+/**
+@import {CapturingGroupNode, OnigurumaAst, Node} from 'oniguruma-parser/parser';
+@import {Visitor} from 'oniguruma-parser/traverser';
+*/
+/**
+@typedef {
+  OnigurumaAst & {
+    options: {
+      disable: {[key: string]: boolean};
+      force: {[key: string]: boolean};
+    };
+    _originMap: Map<CapturingGroupNode, CapturingGroupNode>;
+    _strategy: string | null;
+  }
+} RegexPlusAst
+*/
+/**
+Transforms an Oniguruma AST in-place to a [Regex+](https://github.com/slevithan/regex) AST.
+Assumes target ES2025, expecting the generator to down-convert to the desired JS target version.
+
+Regex+'s syntax and behavior is a strict superset of native JavaScript, so the AST is very close
+to representing native ES2025 `RegExp` but with some added features (atomic groups, possessive
+quantifiers, recursion). The AST doesn't use some of Regex+'s extended features like flag x or
+subroutines because they follow PCRE behavior and work somewhat differently than in Oniguruma. The
+AST represents what's needed to precisely reproduce Oniguruma behavior using Regex+.
+@param {OnigurumaAst} ast
+@param {{
+  accuracy?: keyof Accuracy;
+  asciiWordBoundaries?: boolean;
+  avoidSubclass?: boolean;
+  bestEffortTarget?: keyof Target;
+}} [options]
+@returns {RegexPlusAst}
+*/
+export function transform(ast: OnigurumaAst, options?: {
+    accuracy?: "default" | "strict";
+    asciiWordBoundaries?: boolean;
+    avoidSubclass?: boolean;
+    bestEffortTarget?: "auto" | "ES2025" | "ES2024" | "ES2018";
+}): RegexPlusAst;
+import type { OnigurumaAst } from 'oniguruma-parser/parser';
+import type { CapturingGroupNode } from 'oniguruma-parser/parser';

node_modules/oniguruma-to-es/dist/esm/unicode.d.ts

@@ -0,0 +1,6 @@
+export const asciiSpaceChar: "[\t-\r ]";
+export const defaultWordChar: string;
+export function getIgnoreCaseMatchChars(char: any): any[];
+export const JsUnicodePropertyMap: Map<string, string>;
+export const PosixClassMap: Map<string, string>;
+export const UnicodePropertiesWithSpecificCase: Set<string>;

node_modules/oniguruma-to-es/dist/esm/utils.d.ts

@@ -0,0 +1,25 @@
+export const cp: (...codePoints: number[]) => string;
+export namespace envFlags {
+    let flagGroups: boolean;
+    let unicodeSets: boolean;
+    let bugFlagVLiteralHyphenIsRange: boolean;
+    let bugNestedClassIgnoresNegation: boolean;
+}
+export function getNewCurrentFlags(current: any, { enable, disable }: {
+    enable: any;
+    disable: any;
+}): {
+    dotAll: boolean;
+    ignoreCase: boolean;
+};
+export function getOrInsert(map: any, key: any, defaultValue: any): any;
+/**
+@param {keyof Target} target
+@param {keyof Target} min
+@returns {boolean}
+*/
+export function isMinTarget(target: "auto" | "ES2025" | "ES2024" | "ES2018", min: "auto" | "ES2025" | "ES2024" | "ES2018"): boolean;
+export const r: (template: {
+    raw: readonly string[] | ArrayLike<string>;
+}, ...substitutions: any[]) => string;
+export function throwIfNullish(value: any, msg: any): any;

node_modules/oniguruma-to-es/dist/index.min.js

@@ -0,0 +1,142 @@
+var OnigurumaToEs=(()=>{var Ce=Object.defineProperty;var Pr=Object.getOwnPropertyDescriptor;var Gr=Object.getOwnPropertyNames;var Ur=Object.prototype.hasOwnProperty;var Or=(e,t)=>{for(var r in t)Ce(e,r,{get:t[r],enumerable:!0})},Rr=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let a of Gr(t))!Ur.call(e,a)&&a!==r&&Ce(e,a,{get:()=>t[a],enumerable:!(n=Pr(t,a))||n.enumerable});return e};var Dr=e=>Rr(Ce({},"__esModule",{value:!0}),e);var on={};Or(on,{EmulatedRegExp:()=>se,toRegExp:()=>an,toRegExpDetails:()=>Mr});var y=String.fromCodePoint,h=String.raw,$={},ue=globalThis.RegExp;$.flagGroups=(()=>{try{new ue("(?i:)")}catch{return!1}return!0})();$.unicodeSets=(()=>{try{new ue("[[]]","v")}catch{return!1}return!0})();$.bugFlagVLiteralHyphenIsRange=$.unicodeSets?(()=>{try{new ue(h`[\d\-a]`,"v")}catch{return!0}return!1})():!1;$.bugNestedClassIgnoresNegation=$.unicodeSets&&new ue("[[^a]]","v").test("a");function j(e,{enable:t,disable:r}){return{dotAll:!r?.dotAll&&!!(t?.dotAll||e.dotAll),ignoreCase:!r?.ignoreCase&&!!(t?.ignoreCase||e.ignoreCase)}}function G(e,t,r){return e.has(t)||e.set(t,r),e.get(t)}function Y(e,t){return ye[e]>=ye[t]}function De(e,t){if(e==null)throw new Error(t??"Value expected");return e}var ye={ES2025:2025,ES2024:2024,ES2018:2018},Tr={auto:"auto",ES2025:"ES2025",ES2024:"ES2024",ES2018:"ES2018"};function ce(e={}){if({}.toString.call(e)!=="[object Object]")throw new Error("Unexpected options");if(e.target!==void 0&&!Tr[e.target])throw new Error(`Unexpected target "${e.target}"`);let t={accuracy:"default",avoidSubclass:!1,flags:"",global:!1,hasIndices:!1,lazyCompileLength:1/0,target:"auto",verbose:!1,...e,rules:{allowOrphanBackrefs:!1,asciiWordBoundaries:!1,captureGroup:!1,recursionLimit:20,singleline:!1,...e.rules}};return t.target==="auto"&&(t.target=$.flagGroups?"ES2025":$.unicodeSets?"ES2024":"ES2018"),t}function U(e){if([...e].length!==1)throw new Error(`Expected "${e}" to be a single code point`);return e.codePointAt(0)}function Te(e,t,r){return e.has(t)||e.set(t,r),e.get(t)}var ee=new Set(["alnum","alpha","ascii","blank","cntrl","digit","graph","lower","print","punct","space","upper","word","xdigit"]),x=String.raw;function M(e,t){if(e==null)throw new Error(t??"Value expected");return e}var je=x`\[\^?`,Xe=`c.? | C(?:-.?)?|${x`[pP]\{(?:\^?[-\x20_]*[A-Za-z][-\x20\w]*\})?`}|${x`x[89A-Fa-f]\p{AHex}(?:\\x[89A-Fa-f]\p{AHex})*`}|${x`u(?:\p{AHex}{4})? | x\{[^\}]*\}? | x\p{AHex}{0,2}`}|${x`o\{[^\}]*\}?`}|${x`\d{1,3}`}`,xe=/[?*+][?+]?|\{(?:\d+(?:,\d*)?|,\d+)\}\??/,le=new RegExp(x`
+  \\ (?:
+    ${Xe}
+    | [gk]<[^>]*>?
+    | [gk]'[^']*'?
+    | .
+  )
+  | \( (?:
+    \? (?:
+      [:=!>({]
+      | <[=!]
+      | <[^>]*>
+      | '[^']*'
+      | ~\|?
+      | #(?:[^)\\]|\\.?)*
+      | [^:)]*[:)]
+    )?
+    | \*[^\)]*\)?
+  )?
+  | (?:${xe.source})+
+  | ${je}
+  | .
+`.replace(/\s+/g,""),"gsu"),be=new RegExp(x`
+  \\ (?:
+    ${Xe}
+    | .
+  )
+  | \[:(?:\^?\p{Alpha}+|\^):\]
+  | ${je}
+  | &&
+  | .
+`.replace(/\s+/g,""),"gsu");function Ze(e,t={}){let r={flags:"",...t,rules:{captureGroup:!1,singleline:!1,...t.rules}};if(typeof e!="string")throw new Error("String expected as pattern");let n=at(r.flags),a=[n.extended],s={captureGroup:r.rules.captureGroup,getCurrentModX(){return a.at(-1)},numOpenGroups:0,popModX(){a.pop()},pushModX(l){a.push(l)},replaceCurrentModX(l){a[a.length-1]=l},singleline:r.rules.singleline},o=[],i;for(le.lastIndex=0;i=le.exec(e);){let l=Br(s,e,i[0],le.lastIndex);l.tokens?o.push(...l.tokens):l.token&&o.push(l.token),l.lastIndex!==void 0&&(le.lastIndex=l.lastIndex)}let u=[],c=0;o.filter(l=>l.type==="GroupOpen").forEach(l=>{l.kind==="capturing"?l.number=++c:l.raw==="("&&u.push(l)}),c||u.forEach((l,f)=>{l.kind="capturing",l.number=f+1});let p=c||u.length;return{tokens:o.map(l=>l.type==="EscapedNumber"?it(l,p):l).flat(),flags:n}}function Br(e,t,r,n){let[a,s]=r;if(r==="["||r==="[^"){let o=Vr(t,r,n);return{tokens:o.tokens,lastIndex:o.lastIndex}}if(a==="\\"){if("AbBGyYzZ".includes(s))return{token:Be(r,r)};if(/^\\g[<']/.test(r)){if(!/^\\g(?:<[^>]+>|'[^']+')$/.test(r))throw new Error(`Invalid group name "${r}"`);return{token:Kr(r)}}if(/^\\k[<']/.test(r)){if(!/^\\k(?:<[^>]+>|'[^']+')$/.test(r))throw new Error(`Invalid group name "${r}"`);return{token:qe(r)}}if(s==="K")return{token:Je("keep",r)};if(s==="N"||s==="R")return{token:T("newline",r,{negate:s==="N"})};if(s==="O")return{token:T("any",r)};if(s==="X")return{token:T("text_segment",r)};let o=Qe(r,{inCharClass:!1});return Array.isArray(o)?{tokens:o}:{token:o}}if(a==="("){if(s==="*")return{token:tt(r)};if(r==="(?{")throw new Error(`Unsupported callout "${r}"`);if(r.startsWith("(?#")){if(t[n]!==")")throw new Error('Unclosed comment group "(?#"');return{lastIndex:n+1}}if(/^\(\?[-imx]+[:)]$/.test(r))return{token:rt(r,e)};if(e.pushModX(e.getCurrentModX()),e.numOpenGroups++,r==="("&&!e.captureGroup||r==="(?:")return{token:X("group",r)};if(r==="(?>")return{token:X("atomic",r)};if(r==="(?="||r==="(?!"||r==="(?<="||r==="(?<!")return{token:X(r[2]==="<"?"lookbehind":"lookahead",r,{negate:r.endsWith("!")})};if(r==="("&&e.captureGroup||r.startsWith("(?<")&&r.endsWith(">")||r.startsWith("(?'")&&r.endsWith("'"))return{token:X("capturing",r,{...r!=="("&&{name:r.slice(3,-1)}})};if(r.startsWith("(?~")){if(r==="(?~|")throw new Error(`Unsupported absence function kind "${r}"`);return{token:X("absence_repeater",r)}}throw r==="(?("?new Error(`Unsupported conditional "${r}"`):new Error(`Invalid or unsupported group option "${r}"`)}if(r===")"){if(e.popModX(),e.numOpenGroups--,e.numOpenGroups<0)throw new Error('Unmatched ")"');return{token:Qr(r)}}if(e.getCurrentModX()){if(r==="#"){let o=t.indexOf(`
+`,n);return{lastIndex:o===-1?t.length:o}}if(/^\s$/.test(r)){let o=/\s+/y;return o.lastIndex=n,{lastIndex:o.exec(t)?o.lastIndex:n}}}if(r===".")return{token:T("dot",r)};if(r==="^"||r==="$"){let o=e.singleline?{"^":x`\A`,$:x`\Z`}[r]:r;return{token:Be(o,r)}}return r==="|"?{token:Wr(r)}:xe.test(r)?{tokens:ut(r)}:{token:N(U(r),r)}}function Vr(e,t,r){let n=[Ve(t[1]==="^",t)],a=1,s;for(be.lastIndex=r;s=be.exec(e);){let o=s[0];if(o[0]==="["&&o[1]!==":")a++,n.push(Ve(o[1]==="^",o));else if(o==="]"){if(n.at(-1).type==="CharacterClassOpen")n.push(N(93,o));else if(a--,n.push(Hr(o)),!a)break}else{let i=zr(o);Array.isArray(i)?n.push(...i):n.push(i)}}return{tokens:n,lastIndex:be.lastIndex||e.length}}function zr(e){if(e[0]==="\\")return Qe(e,{inCharClass:!0});if(e[0]==="["){let t=/\[:(?<negate>\^?)(?<name>[a-z]+):\]/.exec(e);if(!t||!ee.has(t.groups.name))throw new Error(`Invalid POSIX class "${e}"`);return T("posix",e,{value:t.groups.name,negate:!!t.groups.negate})}return e==="-"?jr(e):e==="&&"?Xr(e):N(U(e),e)}function Qe(e,{inCharClass:t}){let r=e[1];if(r==="c"||r==="C")return et(e);if("dDhHsSwW".includes(r))return nt(e);if(e.startsWith(x`\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 st(e)}if(/^\\x[89A-Fa-f]\p{AHex}/u.test(e))try{let n=e.split(/\\x/).slice(1).map(o=>parseInt(o,16)),a=new TextDecoder("utf-8",{ignoreBOM:!0,fatal:!0}).decode(new Uint8Array(n)),s=new TextEncoder;return[...a].map(o=>{let i=[...s.encode(o)].map(u=>`\\x${u.toString(16)}`).join("");return N(U(o),i)})}catch{throw new Error(`Multibyte code "${e}" incomplete or invalid in Oniguruma`)}if(r==="u"||r==="x")return N(ot(e),e);if(ze.has(r))return N(ze.get(r),e);if(/\d/.test(r))return Zr(t,e);if(e==="\\")throw new Error(x`Incomplete escape "\"`);if(r==="M")throw new Error(`Unsupported meta "${e}"`);if([...e].length===2)return N(e.codePointAt(1),e);throw new Error(`Unexpected escape "${e}"`)}function Wr(e){return{type:"Alternator",raw:e}}function Be(e,t){return{type:"Assertion",kind:e,raw:t}}function qe(e){return{type:"Backreference",raw:e}}function N(e,t){return{type:"Character",value:e,raw:t}}function Hr(e){return{type:"CharacterClassClose",raw:e}}function jr(e){return{type:"CharacterClassHyphen",raw:e}}function Xr(e){return{type:"CharacterClassIntersector",raw:e}}function Ve(e,t){return{type:"CharacterClassOpen",negate:e,raw:t}}function T(e,t,r={}){return{type:"CharacterSet",kind:e,...r,raw:t}}function Je(e,t,r={}){return e==="keep"?{type:"Directive",kind:e,raw:t}:{type:"Directive",kind:e,flags:M(r.flags),raw:t}}function Zr(e,t){return{type:"EscapedNumber",inCharClass:e,raw:t}}function Qr(e){return{type:"GroupClose",raw:e}}function X(e,t,r={}){return{type:"GroupOpen",kind:e,...r,raw:t}}function qr(e,t,r,n){return{type:"NamedCallout",kind:e,tag:t,arguments:r,raw:n}}function Jr(e,t,r,n){return{type:"Quantifier",kind:e,min:t,max:r,raw:n}}function Kr(e){return{type:"Subroutine",raw:e}}var Yr=new Set(["COUNT","CMP","ERROR","FAIL","MAX","MISMATCH","SKIP","TOTAL_COUNT"]),ze=new Map([["a",7],["b",8],["e",27],["f",12],["n",10],["r",13],["t",9],["v",11]]);function et(e){let t=e[1]==="c"?e[2]:e[3];if(!t||!/[A-Za-z]/.test(t))throw new Error(`Unsupported control character "${e}"`);return N(U(t.toUpperCase())-64,e)}function rt(e,t){let{on:r,off:n}=/^\(\?(?<on>[imx]*)(?:-(?<off>[-imx]*))?/.exec(e).groups;n??="";let a=(t.getCurrentModX()||r.includes("x"))&&!n.includes("x"),s=He(r),o=He(n),i={};if(s&&(i.enable=s),o&&(i.disable=o),e.endsWith(")"))return t.replaceCurrentModX(a),Je("flags",e,{flags:i});if(e.endsWith(":"))return t.pushModX(a),t.numOpenGroups++,X("group",e,{...(s||o)&&{flags:i}});throw new Error(`Unexpected flag modifier "${e}"`)}function tt(e){let t=/\(\*(?<name>[A-Za-z_]\w*)?(?:\[(?<tag>(?:[A-Za-z_]\w*)?)\])?(?:\{(?<args>[^}]*)\})?\)/.exec(e);if(!t)throw new Error(`Incomplete or invalid named callout "${e}"`);let{name:r,tag:n,args:a}=t.groups;if(!r)throw new Error(`Invalid named callout "${e}"`);if(n==="")throw new Error(`Named callout tag with empty value not allowed "${e}"`);let s=a?a.split(",").filter(p=>p!=="").map(p=>/^[+-]?\d+$/.test(p)?+p:p):[],[o,i,u]=s,c=Yr.has(r)?r.toLowerCase():"custom";switch(c){case"fail":case"mismatch":case"skip":if(s.length>0)throw new Error(`Named callout arguments not allowed "${s}"`);break;case"error":if(s.length>1)throw new Error(`Named callout allows only one argument "${s}"`);if(typeof o=="string")throw new Error(`Named callout argument must be a number "${o}"`);break;case"max":if(!s.length||s.length>2)throw new Error(`Named callout must have one or two arguments "${s}"`);if(typeof o=="string"&&!/^[A-Za-z_]\w*$/.test(o))throw new Error(`Named callout argument one must be a tag or number "${o}"`);if(s.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_countLine truncated
+Cc Control cntrl
+Cf Format
+Cn Unassigned
+Co Private_Use
+Cs Surrogate
+L Letter
+LC Cased_Letter
+Ll Lowercase_Letter
+Lm Modifier_Letter
+Lo Other_Letter
+Lt Titlecase_Letter
+Lu Uppercase_Letter
+M Mark Combining_Mark
+Mc Spacing_Mark
+Me Enclosing_Mark
+Mn Nonspacing_Mark
+N Number
+Nd Decimal_Number digit
+Nl Letter_Number
+No Other_Number
+P Punctuation punct
+Pc Connector_Punctuation
+Pd Dash_Punctuation
+Pe Close_Punctuation
+Pf Final_Punctuation
+Pi Initial_Punctuation
+Po Other_Punctuation
+Ps Open_Punctuation
+S Symbol
+Sc Currency_Symbol
+Sk Modifier_Symbol
+Sm Math_Symbol
+So Other_Symbol
+Z Separator
+Zl Line_Separator
+Zp Paragraph_Separator
+Zs Space_Separator
+ASCII
+ASCII_Hex_Digit AHex
+Alphabetic Alpha
+Any
+Assigned
+Bidi_Control Bidi_C
+Bidi_Mirrored Bidi_M
+Case_Ignorable CI
+Cased
+Changes_When_Casefolded CWCF
+Changes_When_Casemapped CWCM
+Changes_When_Lowercased CWL
+Changes_When_NFKC_Casefolded CWKCF
+Changes_When_Titlecased CWT
+Changes_When_Uppercased CWU
+Dash
+Default_Ignorable_Code_Point DI
+Deprecated Dep
+Diacritic Dia
+Emoji
+Emoji_Component EComp
+Emoji_Modifier EMod
+Emoji_Modifier_Base EBase
+Emoji_Presentation EPres
+Extended_Pictographic ExtPict
+Extender Ext
+Grapheme_Base Gr_Base
+Grapheme_Extend Gr_Ext
+Hex_Digit Hex
+IDS_Binary_Operator IDSB
+IDS_Trinary_Operator IDST
+ID_Continue IDC
+ID_Start IDS
+Ideographic Ideo
+Join_Control Join_C
+Logical_Order_Exception LOE
+Lowercase Lower
+Math
+Noncharacter_Code_Point NChar
+Pattern_Syntax Pat_Syn
+Pattern_White_Space Pat_WS
+Quotation_Mark QMark
+Radical
+Regional_Indicator RI
+Sentence_Terminal STerm
+Soft_Dotted SD
+Terminal_Punctuation Term
+Unified_Ideograph UIdeo
+Uppercase Upper
+Variation_Selector VS
+White_Space space
+XID_Continue XIDC
+XID_Start XIDS`.split(/\s/).map(e=>[Q(e),e])),vt=new Map([["s",y(383)],[y(383),"s"]]),Ft=new Map([[y(223),y(7838)],[y(107),y(8490)],[y(229),y(8491)],[y(969),y(8486)]]),Mt=new Map([R(453),R(456),R(459),R(498),...Ie(8072,8079),...Ie(8088,8095),...Ie(8104,8111),R(8124),R(8140),R(8188)]),ar=new Map([["alnum",h`[\p{Alpha}\p{Nd}]`],["alpha",h`\p{Alpha}`],["ascii",h`\p{ASCII}`],["blank",h`[\p{Zs}\t]`],["cntrl",h`\p{Cc}`],["digit",h`\p{Nd}`],["graph",h`[\P{space}&&\P{Cc}&&\P{Cn}&&\P{Cs}]`],["lower",h`\p{Lower}`],["print",h`[[\P{space}&&\P{Cc}&&\P{Cn}&&\P{Cs}]\p{Zs}]`],["punct",h`[\p{P}\p{S}]`],["space",h`\p{space}`],["upper",h`\p{Upper}`],["word",h`[\p{Alpha}\p{M}\p{Nd}\p{Pc}]`],["xdigit",h`\p{AHex}`]]);function Nt(e,t){let r=[];for(let n=e;n<=t;n++)r.push(n);return r}function R(e){let t=y(e);return[t.toLowerCase(),t]}function Ie(e,t){return Nt(e,t).map(r=>R(r))}var Se=new Set(["Lower","Lowercase","Upper","Uppercase","Ll","Lowercase_Letter","Lt","Titlecase_Letter","Lu","Uppercase_Letter"]);function V(e,t,r=null){function n(s,o){for(let i=0;i<s.length;i++){let u=a(s[i],o,i,s);i=Math.max(-1,i+u)}}function a(s,o=null,i=null,u=null){let c=0,p=!1,l={node:s,parent:o,key:i,container:u,root:e,remove(){me(u).splice(Math.max(0,q(i)+c),1),c--,p=!0},removeAllNextSiblings(){return me(u).splice(q(i)+1)},removeAllPrevSiblings(){let C=q(i)+c;return c-=C,me(u).splice(0,Math.max(0,C))},replaceWith(C,E={}){let I=!!E.traverse;u?u[Math.max(0,q(i)+c)]=C:M(o,"Can't replace root node")[i]=C,I&&a(C,o,i,u),p=!0},replaceWithMultiple(C,E={}){let I=!!E.traverse;if(me(u).splice(Math.max(0,q(i)+c),1,...C),c+=C.length-1,I){let k=0;for(let _=0;_<C.length;_++)k+=a(C[_],o,q(i)+_+k,u)}p=!0},skip(){p=!0}},{type:f}=s,g=t["*"],d=t[f],m=typeof g=="function"?g:g?.enter,w=typeof d=="function"?d:d?.enter;if(m?.(l,r),w?.(l,r),!p)switch(f){case"AbsenceFunction":case"Alternative":case"CapturingGroup":case"CharacterClass":case"Group":case"LookaroundAssertion":n(s.body,s);break;case"Assertion":case"Backreference":case"Character":case"CharacterSet":case"Directive":case"Flags":case"NamedCallout":case"Subroutine":break;case"CharacterClassRange":a(s.min,s,"min"),a(s.max,s,"max");break;case"Quantifier":a(s.body,s,"body");break;case"Regex":n(s.body,s),a(s.flags,s,"flags");break;default:throw new Error(`Unexpected node type "${f}"`)}return d?.exit?.(l,r),g?.exit?.(l,r),c}return a(e),e}function me(e){if(!Array.isArray(e))throw new Error("Container expected");return e}function q(e){if(typeof e!="number")throw new Error("Numeric key expected");return e}function ir(e,t){let r={accuracy:"default",asciiWordBoundaries:!1,avoidSubclass:!1,bestEffortTarget:"ES2025",...t};ur(e);let n={accuracy:r.accuracy,asciiWordBoundaries:r.asciiWordBoundaries,avoidSubclass:r.avoidSubclass,flagDirectivesByAlt:new Map,jsGroupNameMap:new Map,minTargetEs2024:Y(r.bestEffortTarget,"ES2024"),passedLookbehind:!1,strategy:null,subroutineRefMap:new Map,supportedGNodes:new Set,digitIsAscii:e.flags.digitIsAscii,spaceIsAscii:e.flags.spaceIsAscii,wordIsAscii:e.flags.wordIsAscii};V(e,Lt,n);let a={dotAll:e.flags.dotAll,ignoreCase:e.flags.ignoreCase},s={currentFlags:a,prevFlags:null,globalFlags:a,groupOriginByCopy:new Map,groupsByName:new Map,multiplexCapturesToLeftByRef:new Map,openRefs:new Map,reffedNodesByReferencer:new Map,subroutineRefMap:n.subroutineRefMap};V(e,Pt,s);let o={groupsByName:s.groupsByName,highestOrphanBackref:0,numCapturesToLeft:0,reffedNodesByReferencer:s.reffedNodesByReferencer};return V(e,Gt,o),e._originMap=s.groupOriginByCopy,e._strategy=n.strategy,e}var Lt={AbsenceFunction({node:e,parent:t,replaceWith:r}){let{body:n,kind:a}=e;if(a==="repeater"){let s=S();s.body[0].body.push(O({negate:!0,body:n}),B("Any"));let o=S();o.body[0].body.push(Ee("greedy",0,1/0,s)),r(b(o,t),{traverse:!0})}else throw new Error('Unsupported absence function "(?~|"')},Alternative:{enter({node:e,parent:t,key:r},{flagDirectivesByAlt:n}){let a=e.body.filter(s=>s.kind==="flags");for(let s=r+1;s<t.body.length;s++){let o=t.body[s];G(n,o,[]).push(...a)}},exit({node:e},{flagDirectivesByAlt:t}){if(t.get(e)?.length){let r=lr(t.get(e));if(r){let n=S({flags:r});n.body[0].body=e.body,e.body=[b(n,e)]}}}},Assertion({node:e,parent:t,key:r,container:n,root:a,remove:s,replaceWith:o},i){let{kind:u,negate:c}=e,{asciiWordBoundaries:p,avoidSubclass:l,supportedGNodes:f,wordIsAscii:g}=i;if(u==="text_segment_boundary")throw new Error(`Unsupported text segment boundary "\\${c?"Y":"y"}"`);if(u==="line_end")o(b(O({body:[L({body:[ge("string_end")]}),L({body:[Z(10)]})]}),t));else if(u==="line_start")o(b(P(h`(?<=\A|\n(?!\z))`,{skipLookbehindValidation:!0}),t));else if(u==="search_start")if(f.has(e))a.flags.sticky=!0,s();else{let d=n[r-1];if(d&&Bt(d))o(b(O({negate:!0}),t));else{if(l)throw new Error(h`Uses "\G" in a way that requires a subclass`);o(D(ge("string_start"),t)),i.strategy="clip_search"}}else if(!(u==="string_end"||u==="string_start"))if(u==="string_end_newline")o(b(P(h`(?=\n?\z)`),t));else if(u==="word_boundary"){if(!g&&!p){let d=`(?Line truncated
+]`:`(?>\r
+?|[
+\v\f\x85\u2028\u2029])`),t));else if(u==="posix")if(!a&&(p==="graph"||p==="print")){if(n==="strict")throw new Error(`POSIX class "${p}" requires min target ES2024 or non-strict accuracy`);let l={graph:"!-~",print:" -~"}[p];c&&(l=`\0-${y(l.codePointAt(0)-1)}${y(l.codePointAt(2)+1)}-\u{10FFFF}`),r(b(P(`[${l}]`),t))}else r(b(Fe(P(ar.get(p)),c),t));else if(u==="property")ne.has(Q(p))||(e.key="sc");else if(u==="space")r(D(B("space",{negate:c}),t));else if(u==="word")r(b(Fe(P(F),c),t));else throw new Error(`Unexpected character set kind "${u}"`)},Directive({node:e,parent:t,root:r,remove:n,replaceWith:a,removeAllPrevSiblings:s,removeAllNextSiblings:o}){let{kind:i,flags:u}=e;if(i==="flags")if(!u.enable&&!u.disable)n();else{let c=S({flags:u});c.body[0].body=o(),a(b(c,t),{traverse:!0})}else if(i==="keep"){let c=r.body[0],l=r.body.length===1&&pe(c,{type:"Group"})&&c.body[0].body.length===1?c.body[0]:r;if(t.parent!==l||l.body.length>1)throw new Error(h`Uses "\K" in a way that's unsupported`);let f=O({behind:!0});f.body[0].body=s(),a(b(f,t))}else throw new Error(`Unexpected directive kind "${i}"`)},Flags({node:e,parent:t}){if(e.posixIsAscii)throw new Error('Unsupported flag "P"');if(e.textSegmentMode==="word")throw new Error('Unsupported flag "y{w}"');["digitIsAscii","extended","posixIsAscii","spaceIsAscii","wordIsAscii","textSegmentMode"].forEach(r=>delete e[r]),Object.assign(e,{global:!1,hasIndices:!1,multiline:!1,sticky:e.sticky??!1}),t.options={disable:{x:!0,n:!0},force:{v:!0}}},Group({node:e}){if(!e.flags)return;let{enable:t,disable:r}=e.flags;t?.extended&&delete t.extended,r?.extended&&delete r.extended,t?.dotAll&&r?.dotAll&&delete t.dotAll,t?.ignoreCase&&r?.ignoreCase&&delete t.ignoreCase,t&&!Object.keys(t).length&&delete e.flags.enable,r&&!Object.keys(r).length&&delete e.flags.disable,!e.flags.enable&&!e.flags.disable&&delete e.flags},LookaroundAssertion({node:e},t){let{kind:r}=e;r==="lookbehind"&&(t.passedLookbehind=!0)},NamedCallout({node:e,parent:t,replaceWith:r}){let{kind:n}=e;if(n==="fail")r(b(O({negate:!0}),t));else throw new Error(`Unsupported named callout "(*${n.toUpperCase()}"`)},Quantifier({node:e}){if(e.body.type==="Quantifier"){let t=S();t.body[0].body.push(e.body),e.body=b(t,e)}},Regex:{enter({node:e},{supportedGNodes:t}){let r=[],n=!1,a=!1;for(let s of e.body)if(s.body.length===1&&s.body[0].kind==="search_start")s.body.pop();else{let o=fr(s.body);o?(n=!0,Array.isArray(o)?r.push(...o):r.push(o)):a=!0}n&&!a&&r.forEach(s=>t.add(s))},exit(e,{accuracy:t,passedLookbehind:r,strategy:n}){if(t==="strict"&&r&&n)throw new Error(h`Uses "\G" in a way that requires non-strict accuracy`)}},Subroutine({node:e},{jsGroupNameMap:t}){let{ref:r}=e;typeof r=="string"&&!ve(r)&&(r=_e(r,t),e.ref=r)}},Pt={Backreference({node:e},{multiplexCapturesToLeftByRef:t,reffedNodesByReferencer:r}){let{orphan:n,ref:a}=e;n||r.set(e,[...t.get(a).map(({node:s})=>s)])},CapturingGroup:{enter({node:e,parent:t,replaceWith:r,skip:n},{groupOriginByCopy:a,groupsByName:s,multiplexCapturesToLeftByRef:o,openRefs:i,reffedNodesByReferencer:u}){let c=a.get(e);if(c&&i.has(e.number)){let l=D(or(e.number),t);u.set(l,i.get(e.number)),r(l);return}i.set(e.number,e),o.set(e.number,[]),e.name&&G(o,e.name,[]);let p=o.get(e.name??e.number);for(let l=0;l<p.length;l++){let f=p[l];if(c===f.node||c&&c===f.origin||e===f.origin){p.splice(l,1);break}}if(o.get(e.number).push({node:e,origin:c}),e.name&&o.get(e.name).push({node:e,origin:c}),e.name){let l=G(s,e.name,new Map),f=!1;if(c)f=!0;else for(let g of l.values())if(!g.hasDuplicateNameToRemove){f=!0;break}s.get(e.name).set(e,{node:e,hasDuplicateNameToRemove:f})}},exit({node:e},{openRefs:t}){t.get(e.number)===e&&t.delete(e.number)}},Group:{enter({node:e},t){t.prevFlags=t.currentFlags,e.flags&&(t.currentFlags=j(t.currentFlags,e.flags))},exit(e,t){t.currentFlags=t.prevFlags}},Subroutine({node:e,parent:t,replaceWith:r},n){let{isRecursive:a,ref:s}=e;if(a){let p=t;for(;(p=p.parent)&&!(p.type==="CapturingGroup"&&(p.name===s||p.number===s)););n.reffedNodesByReferencer.set(e,p);return}let o=n.subroutineRefMap.get(s),i=s===0,u=i?or(0):cr(o,n.groupOriginByCopy,null),c=u;if(!i){let p=lr(Rt(o,f=>f.type==="Group"&&!!f.flags)),l=p?j(n.globalFlags,p):n.globalFlags;Ut(l,n.currentFlags)||(c=S({flags:Dt(l)}),c.body[0].body.push(u))}r(b(c,t),{traverse:!i})}},Gt={Backreference({node:e,parent:t,replaceWith:r},n){if(e.orphan){n.highestOrphanBackref=Math.max(n.highestOrphanBackref,e.ref);return}let s=n.reffedNodesByReferencer.get(e).filter(o=>Ot(o,e));if(!s.length)r(b(O({negate:!0}),t));else if(s.length>1){let o=S({atomic:!0,body:s.reverse().map(i=>L({body:[fe(i.number)]}))});r(b(o,t))}else e.ref=s[0].number},CapturingGroup({node:e},t){e.number=++t.numCapturesToLeft,e.name&&t.groupsByName.get(e.name).get(e).hasDuplicateNameToRemove&&delete e.name},Regex:{exit({node:e},t){let r=Math.max(t.highestOrphanBackref-t.numCapturesToLeft,0);for(let n=0;n<r;n++){let a=ke();e.body.at(-1).body.push(a)}}},Subroutine({node:e},t){!e.isRecursive||e.ref===Line truncated
+\\(?: \d+
+  | c[A-Za-z]
+  | [gk]<[^>]+>
+  | [pPu]\{[^\}]+\}
+  | u[A-Fa-f\d]{4}
+  | x[A-Fa-f\d]{2}
+  )
+| \((?: \? (?: [:=!>]
+  | <(?:[=!]|[^>]+>)
+  | [A-Za-z\-]+:
+  | \(DEFINE\)
+  ))?
+| (?<qBase>${Ar})(?<qMod>[?+]?)(?<invalidQ>[?*+\{]?)
+| \\?.
+`.replace(/\s+/g,""),"gsu");function Ge(e){if(!new RegExp(`${Ar}\\+`).test(e))return{pattern:e};let t=[],r=null,n=null,a="",s=0,o;for(Le.lastIndex=0;o=Le.exec(e);){let{0:i,index:u,groups:{qBase:c,qMod:p,invalidQ:l}}=o;if(i==="[")s||(n=u),s++;else if(i==="]")s?s--:n=null;else if(!s)if(p==="+"&&a&&!a.startsWith("(")){if(l)throw new Error(`Invalid quantifier "${i}"`);let f=-1;if(/^\{\d+\}$/.test(c))e=xr(e,u+c.length,p,"");else{if(a===")"||a==="]"){let g=a===")"?r:n;if(g===null)throw new Error(`Invalid unmatched "${a}"`);e=`${e.slice(0,g)}(?>${e.slice(g,u)}${c})${e.slice(u+i.length)}`}else e=`${e.slice(0,u-a.length)}(?>${a}${c})${e.slice(u+i.length)}`;f+=4}Le.lastIndex+=f}else i[0]==="("?t.push(u):i===")"&&(r=t.length?t.pop():null);a=i}return{pattern:e}}var v=String.raw,nn=v`\\g<(?<gRNameOrNum>[^>&]+)&R=(?<gRDepth>[^>]+)>`,Oe=v`\(\?R=(?<rDepth>[^\)]+)\)|${nn}`,we=v`\(\?<(?![=!])(?<captureName>[^>]+)>`,vr=v`${we}|(?<unnamed>\()(?!\?)`,z=new RegExp(v`${we}|${Oe}|\(\?|\\?.`,"gsu"),Ue="Cannot use multiple overlapping recursions";function Fr(e,t){let{hiddenCaptures:r,mode:n}={hiddenCaptures:[],mode:"plugin",...t},a=t?.captureTransfers??new Map;if(!new RegExp(Oe,"su").test(e))return{pattern:e,captureTransfers:a,hiddenCaptures:r};if(n==="plugin"&&oe(e,v`\(\?\(DEFINE\)`,A.DEFAULT))throw new Error("DEFINE groups cannot be used with recursion");let s=[],o=oe(e,v`\\[1-9]`,A.DEFAULT),i=new Map,u=[],c=!1,p=0,l=0,f;for(z.lastIndex=0;f=z.exec(e);){let{0:g,groups:{captureName:d,rDepth:m,gRNameOrNum:w,gRDepth:C}}=f;if(g==="[")p++;else if(p)g==="]"&&p--;else if(m){if(Ir(m),c)throw new Error(Ue);if(o)throw new Error(`${n==="external"?"Backrefs":"Numbered backrefs"} cannot be used with global recursion`);let E=e.slice(0,f.index),I=e.slice(z.lastIndex);if(oe(I,Oe,A.DEFAULT))throw new Error(Ue);let k=+m-1;e=$r(E,I,k,!1,r,s,l),a=_r(a,E,k,s.length,0,l);break}else if(w){Ir(C);let E=!1;for(let K of u)if(K.name===w||K.num===+w){if(E=!0,K.hasRecursedWithin)throw new Error(Ue);break}if(!E)throw new Error(v`Recursive \g cannot be used outside the referenced group "${n==="external"?w:v`\g<${w}&R=${C}>`}"`);let I=i.get(w),k=kr(e,I);if(o&&oe(k,v`${we}|\((?!\?)`,A.DEFAULT))throw new Error(`${n==="external"?"Backrefs":"Numbered backrefs"} cannot be used with recursion of capturing groups`);let _=e.slice(I,f.index),ie=k.slice(_.length+g.length),W=s.length,H=+C-1,Re=$r(_,ie,H,!0,r,s,l);a=_r(a,_,H,s.length-W,W,l);let Nr=e.slice(0,I),Lr=e.slice(I+k.length);e=`${Nr}${Re}${Lr}`,z.lastIndex+=Re.length-g.length-_.length-ie.length,u.forEach(K=>K.hasRecursedWithin=!0),c=!0}else if(d)l++,i.set(String(l),z.lastIndex),i.set(d,z.lastIndex),u.push({num:l,name:d});else if(g[0]==="("){let E=g==="(";E&&(l++,i.set(String(l),z.lastIndex)),u.push(E?{num:l}:{})}else g===")"&&u.pop()}return r.push(...s),{pattern:e,captureTransfers:a,hiddenCaptures:r}}function Ir(e){let t=`Max depth must be integer between 2 and 100; used ${e}`;if(!/^[1-9]\d*$/.test(e))throw new Error(t);if(e=+e,e<2||e>100)throw new Error(t)}function $r(e,t,r,n,a,s,o){let i=new Set;n&&Ne(e+t,we,({groups:{captureName:c}})=>{i.add(c)},A.DEFAULT);let u=[r,n?i:null,a,s,o];return`${e}${Sr(`(?:${e}`,"forward",...u)}(?:)${Sr(`${t})`,"backward",...u)}${t}`}function Sr(e,t,r,n,a,s,o){let u=p=>t==="forward"?p+2:r-p+2-1,c="";for(let p=0;p<r;p++){let l=u(p);c+=ae(e,v`${vr}|\\k<(?<backref>[^>]+)>`,({0:f,groups:{captureName:g,unnamed:d,backref:m}})=>{if(m&&n&&!n.has(m))return f;let w=`_$${l}`;if(d||g){let C=o+s.length+1;return s.push(C),sn(a,C),d?f:`(?<${g}${w}>`}return v`\k<${m}${w}>`},A.DEFAULT)}return c}function sn(e,t){for(let r=0;r<e.length;r++)e[r]>=t&&e[r]++}function _r(e,t,r,n,a,s){if(e.size&&n){let o=0;Ne(t,vr,()=>o++,A.DEFAULT);let i=s-o+a,u=new Map;return e.forEach((c,p)=>{let l=(n-o*r)/r,f=o*r,g=p>i+o?p+n:p,d=[];for(let m of c)if(m<=i)d.push(m);else if(m>i+o+l)d.push(m+n);else if(m<=i+o)for(let w=0;w<=r;w++)d.push(m+o*w);else for(let w=0;w<=r;w++)d.push(m+f+l*w);u.set(g,d)}),u}return e}function an(e,t){let r=Mr(e,t);return r.options?new se(r.pattern,r.flags,r.options):new RegExp(r.pattern,r.flags)}function Mr(e,t){let r=ce(t),n=de(e,{flags:r.flags,normalizeUnknownPropertyNames:!0,rules:{captureGroup:r.rules.captureGroup,singleline:r.rules.singleline},skipBackrefValidation:r.rules.allowOrphanBackrefs,unicodePropertyMap:ne}),a=ir(n,{accuracy:r.accuracy,asciiWordBoundaries:r.rules.asciiWordBoundaries,avoidSubclass:r.avoidSubclass,bestEffortTarget:r.target}),s=wr(a,r),o=Fr(s.pattern,{captureTransfers:s._captureTransfers,hiddenCaptures:s._hiddenCaptures,mode:"external"}),i=Ge(o.pattern),u=Pe(i.pattern,{captureTransfers:o.captureTransfers,hiddenCaptures:o.hiddenCaptures}),c={pattern:u.pattern,flags:`${r.hasIndices?"d":""}${r.global?"g":""}${s.flags}${s.options.disable.v?"u":"v"}`};if(r.avoidSubclass){if(r.lazyCompileLength!==1/0)throw new Error("Lazy compilation requires subclass")}else{let p=u.hiddenCaptures.sort((d,m)=>d-m),l=Array.from(u.captureTransfers),f=a._strategy,g=c.pattern.length>=r.lazyCompileLeng
Line truncated
+//# sourceMappingURL=index.min.js.map

node_modules/oniguruma-to-es/dist/index.min.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/index.js", "../src/utils.js", "../src/options.js", "../node_modules/.pnpm/oniguruma-parser@0.12.2/node_modules/oniguruma-parser/src/utils.ts", "../node_modules/.pnpm/oniguruma-parser@0.12.2/node_modules/oniguruma-parser/src/tokenizer/tokenize.ts", "../node_modules/.pnpm/oniguruma-parser@0.12.2/node_modules/oniguruma-parser/src/parser/node-utils.ts", "../node_modules/.pnpm/oniguruma-parser@0.12.2/node_modules/oniguruma-parser/src/parser/parse.ts", "../src/unicode.js", "../node_modules/.pnpm/oniguruma-parser@0.12.2/node_modules/oniguruma-parser/src/traverser/traverse.ts", "../src/transform.js", "../src/generate.js", "../src/subclass.js", "../node_modules/.pnpm/regex@6.1.0/node_modules/regex/src/utils-internals.js", "../node_modules/.pnpm/regex-utilities@2.3.0/node_modules/regex-utilities/src/index.js", "../node_modules/.pnpm/regex@6.1.0/node_modules/regex/src/atomic.js", "../node_modules/.pnpm/regex-recursion@6.0.2/node_modules/regex-recursion/src/index.js"],
+  "sourcesContent": ["import {transform} from './transform.js';\nimport {generate} from './generate.js';\nimport {Accuracy, getOptions, Target} from './options.js';\nimport {EmulatedRegExp} from './subclass.js';\nimport {JsUnicodePropertyMap} from './unicode.js';\nimport {parse} from 'oniguruma-parser/parser';\nimport {atomic, possessive} from 'regex/internals';\nimport {recursion} from 'regex-recursion';\n/**\n@import {EmulatedRegExpOptions} from './subclass.js';\n*/\n\n// The validation and transformation for Oniguruma's unique syntax and behavior differences\n// compared to native JS RegExp is layered into all steps of the compilation process:\n// 1. Parser: Uses `oniguruma-parser` to build an Oniguruma AST, which accounts for many\n//    differences between Oniguruma and JS.\n// 2. Transformer: Converts the Oniguruma AST to a Regex+ AST that preserves all Oniguruma\n//    behavior. This is true even in cases of non-native-JS features that are supported by both\n//    Regex+ and Oniguruma but with subtly different behavior in each (subroutines, flag x).\n// 3. Generator: Converts the Regex+ AST to a Regex+ pattern, flags, and options.\n// 4. Postprocessing: Regex+ internals and plugins are used to transpile several remaining features\n//    (atomic groups, possessive quantifiers, recursion). Regex+ uses a strict superset of JS\n//    RegExp syntax, so using it allows this library to benefit from not reinventing the wheel for\n//    complex features that Regex+ already knows how to transpile to JS.\n\n/**\n@typedef {{\n  accuracy?: keyof Accuracy;\n  avoidSubclass?: boolean;\n  flags?: string;\n  global?: boolean;\n  hasIndices?: boolean;\n  lazyCompileLength?: number;\n  rules?: {\n    allowOrphanBackrefs?: boolean;\n    asciiWordBoundaries?: boolean;\n    captureGroup?: boolean;\n    recursionLimit?: number;\n    singleline?: boolean;\n  };\n  target?: keyof Target;\n  verbose?: boolean;\n}} ToRegExpOptions\n*/\n\n/**\nAccepts an Oniguruma pattern and returns an equivalent JavaScript `RegExp`.\n@param {string} pattern Oniguruma regex pattern.\n@param {ToRegExpOptions} [options]\n@returns {RegExp | EmulatedRegExp}\n*/\nfunction toRegExp(pattern, options) {\n  const d = toRegExpDetails(pattern, options);\n  if (d.options) {\n    return new EmulatedRegExp(d.pattern, d.flags, d.options);\n  }\n  return new RegExp(d.pattern, d.flags);\n}\n\n/**\nAccepts an Oniguruma pattern and returns the details for an equivalent JavaScript `RegExp`.\n@param {string} pattern Oniguruma regex pattern.\n@param {ToRegExpOptions} [options]\n@returns {{\n  pattern: string;\n  flags: string;\n  options?: EmulatedRegExpOptions;\n}}\n*/\nfunction toRegExpDetails(pattern, options) {\n  const opts = getOptions(options);\n  const onigurumaAst = parse(pattern, {\n    flags: opts.flags,\n    normalizeUnknownPropertyNames: true,\n    rules: {\n      captureGroup: opts.rules.captureGroup,\n      singleline: opts.rules.singleline,\n    },\n    skipBackrefValidation: opts.rules.allowOrphanBackrefs,\n    unicodePropertyMap: JsUnicodePropertyMap,\n  });\n  const regexPlusAst = transform(onigurumaAst, {\n    accuracy: opts.accuracy,\n    asciiWordBoundaries: opts.rules.asciiWordBoundaries,\n    avoidSubclass: opts.avoidSubclass,\n    bestEffortTarget: opts.target,\n  });\n  const generated = generate(regexPlusAst, opts);\n  const recursionResult = recursion(generated.pattern, {\n    captureTransfers: generated._captureTransfers,\n    hiddenCaptures: generated._hiddenCaptures,\n    mode: 'external',\n  });\n  const possessiveResult = possessive(recursionResult.pattern);\n  const atomicResult = atomic(possessiveResult.pattern, {\n    captureTransfers: recursionResult.captureTransfers,\n    hiddenCaptures: recursionResult.hiddenCaptures,\n  });\n  const details = {\n    pattern: atomicResult.pattern,\n    flags: `${opts.hasIndices ? 'd' : ''}${opts.global ? 'g' : ''}${generated.flags}${generated.options.disable.v ? 'u' : 'v'}`,\n  };\n  if (opts.avoidSubclass) {\n    if (opts.lazyCompileLength !== Infinity) {\n      throw new Error('Lazy compilation requires subclass');\n    }\n  } else {\n    // Sort isn't required; only for readability when serialized\n    const hiddenCaptures = atomicResult.hiddenCaptures.sort((a, b) => a - b);\n    // Change the map to the `EmulatedRegExp` format, serializable as JSON\n    const transfers = Array.from(atomicResult.captureTransfers);\n    const strategy = regexPlusAst._strategy;\n    const lazyCompile = details.pattern.length >= opts.lazyCompileLength;\n    if (hiddenCaptures.length || transfers.length || strategy || lazyCompile) {\n      details.options = {\n        ...(hiddenCaptures.length && {hiddenCaptures}),\n        ...(transfers.length && {transfers}),\n        ...(strategy && {strategy}),\n        ...(lazyCompile && {lazyCompile}),\n      };\n    }\n  }\n  return details;\n}\n\n// function toOnigurumaAst(pattern, options) {\n//   return parse(pattern, {\n//     flags: options?.flags ?? '',\n//     noLine truncated
+  "mappings": "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 truncated
+  "names": ["index_exports", "__export", "EmulatedRegExp", "toRegExp", "toRegExpDetails", "cp", "r", "envFlags", "globalRegExp", "getNewCurrentFlags", "current", "enable", "disable", "getOrInsert", "map", "key", "defaultValue", "isMinTarget", "target", "min", "EsVersion", "throwIfNullish", "value", "msg", "EsVersion", "Target", "getOptions", "options", "opts", "envFlags", "cpOf", "char", "getOrInsert", "map", "key", "defaultValue", "PosixClassNames", "r", "throwIfNullish", "value", "msg", "charClassOpenPattern", "r", "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", "cpOf", "opener", "createCharacterClassOpenToken", "numCharClassesOpen", "createCharacterClassCloseToken", "tokenizeAnyTokenWithinCharClass", "raw", "posix", "PosixClassNames", "createCharacterClassHyphenToken", "createCharacterClassIntersectorToken", "inCharClass", "char1", "tokenizeControlCharacter", "tokenizeShorthand", "tokenizeUnicodeProperty", "bytes", "hex", "decoded", "encoder", "char", "byte", "getValidatedHexCharCode", "EscapeCharCodes", "createEscapedNumberToken", "value", "negate", "throwIfNullish", "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", "hasOnlyChild", "node", "props", "kid", "key", "isQuantifiable", "node", "quantifiableTypes", "parse", "pattern", "options", "opts", "tokenized", "tokenize", "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", "r", "kind", "createAssertion", "throwIfNullish", "raw", "hasKWrapper", "fromNum", "num", "isRelative", "numCapturesToLeft", "orphan", "createBackreference", "numberedRef", "_", "tokens", "prevSiblingNode", "nextToken", "nextNode", "createCharacterClassRange", "cpOf", "negate", "intersections", "createCharacterClass", "ccFirstToken", "throwIfUnclosedCharacterClass", "cc", "value", "normalizeUnknownPropertyNames", "skipPropertyNameValidation", "unicodePropertyMap", "normalized", "slug", "PosixClassNames", "createUnicodeProperty", "createPosixClass", "createCharacterSet", "skipLookbehindValidation", "createByGroupKind", "isThisAbsenceFunction", "isThisLookbehind", "isLookbehind", "isThisNegLookbehind", "getOrInsert", "throwIfUnclosedGroup", "alt", "child", "msg", "isLookahead", "min", "max", "quantifiedNode", "isQuantifiable", "createQuantifier", "createSubroutine", "createAbsenceFunction", "getBodyForAlternativeContainer", "getBodyForElementContainer", "createCapturingGroup", "number", "isValidGroupName", "charCode", "hex", "flags", "createGroup", "atomic", "createLookaroundAssertion", "tag", "args", "name", "body", "normalizeUnicodePropertyName", "m", "first", "asciiSpaceChar", "CharsWithoutIgnoreCaseExpansion", "cp", "defaultWordChar", "r", "getIgnoreCaseMatchChars", "char", "set", "lower", "upper", "title", "LowerToTitleCaseMap", "altLower", "LowerToAlternativeLowerCaseMap", "altUpper", "LowerToAlternativeUpperCaseMap", "JsUnicodePropertyMap", "p", "w", "titleEntry", "titleRange", "PosixClassMap", "range", "start", "end", "i", "codePoint", "UnicodePropertiesWithSpecificCase", "traverse", "root", "visitor", "state", "traverseArray", "array", "parent", "i", "keyShift", "traverseNode", "node", "key", "container", "skipTraversingKidsOfPath", "path", "arrayContainer", "numericKey", "shifted", "newNode", "options", "traverseNew", "throwIfNullish", "newNodes", "keyShiftInLoop", "type", "anyTypeVisitor", "thisTypeVisitor", "enterAllFn", "enterThisFn", "value", "transform", "ast", "options", "opts", "addParentProperties", "firstPassState", "isMinTarget", "S", "FirstPassVisitor", "globalFlags", "secondPassState", "SecondPassVisitor", "thirdPassState", "ThirdPassVisitor", "node", "parent", "replaceWith", Line truncated
+}

node_modules/oniguruma-to-es/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "oniguruma-to-es",
+  "version": "4.3.6",
+  "description": "Convert Oniguruma patterns to native JavaScript RegExp",
+  "author": "Steven Levithan",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    }
+  },
+  "browser": "./dist/index.min.js",
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/cjs/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/slevithan/oniguruma-to-es.git"
+  },
+  "keywords": [
+    "regex",
+    "regexp",
+    "oniguruma",
+    "textmate-grammar",
+    "transpiler"
+  ],
+  "dependencies": {
+    "oniguruma-parser": "^0.12.2",
+    "regex": "^6.1.0",
+    "regex-recursion": "^6.0.2"
+  },
+  "devDependencies": {
+    "esbuild": "^0.28.0",
+    "jasmine": "^6.2.0",
+    "typescript": "^6.0.3",
+    "vscode-oniguruma": "^2.0.1"
+  },
+  "scripts": {
+    "bundle:global": "esbuild src/index.js --global-name=OnigurumaToEs --bundle --minify --sourcemap --outfile=dist/index.min.js",
+    "bundle:esm": "esbuild src/index.js --format=esm --bundle --sourcemap --external:oniguruma-parser --external:regex --external:regex-recursion --outfile=dist/esm/index.js",
+    "bundle:cjs": "esbuild src/index.js --format=cjs --bundle --sourcemap --outfile=dist/cjs/index.js",
+    "types": "tsc src/index.js --rootDir src --declaration --allowJs --emitDeclarationOnly --outDir types --lib ESNext",
+    "prebuild": "rm -rf dist/* types/*",
+    "build": "pnpm bundle:global && pnpm bundle:esm && pnpm bundle:cjs && pnpm types",
+    "postbuild": "node scripts/postbuild.js",
+    "pretest": "pnpm build",
+    "test": "jasmine",
+    "onig:match": "node scripts/onig-match.js"
+  }
+}