pi-panels 0.3.2

package/node_modules/oniguruma-parser/dist/optimizer/optimizations.d.ts

@@ -0,0 +1,5 @@
+import type { Visitor } from '../traverser/traverse.js';
+type OptimizationName = 'alternationToClass' | 'exposeAnchors' | 'extractPrefix' | 'extractPrefix2' | 'extractSuffix' | 'mergeRanges' | 'optionalize' | 'preventReDoS' | 'removeEmptyGroups' | 'removeUselessFlags' | 'simplifyCallouts' | 'unnestUselessClasses' | 'unwrapNegationWrappers' | 'unwrapUselessClasses' | 'unwrapUselessGroups' | 'useShorthands' | 'useUnicodeAliases' | 'useUnicodeProps';
+declare const optimizations: Map<OptimizationName, Visitor>;
+export { type OptimizationName, optimizations, };
+//# sourceMappingURL=optimizations.d.ts.map

package/node_modules/oniguruma-parser/dist/optimizer/optimizations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimizations.d.ts","sourceRoot":"","sources":["../../src/optimizer/optimizations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,0BAA0B,CAAC;AAoBtD,KAAK,gBAAgB,GACnB,oBAAoB,GACpB,eAAe,GACf,eAAe,GACf,gBAAgB,GAChB,eAAe,GACf,aAAa,GACb,aAAa,GACb,cAAc,GACd,mBAAmB,GACnB,oBAAoB,GACpB,kBAAkB,GAClB,sBAAsB,GACtB,wBAAwB,GACxB,sBAAsB,GACtB,qBAAqB,GACrB,eAAe,GACf,mBAAmB,GACnB,iBAAiB,CAAC;AAEpB,QAAA,MAAM,aAAa,gCAoBjB,CAAC;AAEH,OAAO,EACL,KAAK,gBAAgB,EACrB,aAAa,GACd,CAAC"}

package/node_modules/oniguruma-parser/dist/optimizer/optimizations.js

@@ -0,0 +1,2 @@
+"use strict";import{alternationToClass as e}from"./transforms/alternation-to-class.js";import{exposeAnchors as s}from"./transforms/expose-anchors.js";import{extractPrefix as r}from"./transforms/extract-prefix.js";import{extractPrefix2 as o}from"./transforms/extract-prefix-2.js";import{extractSuffix as t}from"./transforms/extract-suffix.js";import{mergeRanges as i}from"./transforms/merge-ranges.js";import{optionalize as a}from"./transforms/optionalize.js";import{preventReDoS as p}from"./transforms/prevent-redos.js";import{removeEmptyGroups as m}from"./transforms/remove-empty-groups.js";import{removeUselessFlags as n}from"./transforms/remove-useless-flags.js";import{simplifyCallouts as l}from"./transforms/simplify-callouts.js";import{unnestUselessClasses as f}from"./transforms/unnest-useless-classes.js";import{unwrapNegationWrappers as u}from"./transforms/unwrap-negation-wrappers.js";import{unwrapUselessClasses as x}from"./transforms/unwrap-useless-classes.js";import{unwrapUselessGroups as c}from"./transforms/unwrap-useless-groups.js";import{useShorthands as U}from"./transforms/use-shorthands.js";import{useUnicodeAliases as g}from"./transforms/use-unicode-aliases.js";import{useUnicodeProps as C}from"./transforms/use-unicode-props.js";const v=new Map([["alternationToClass",e],["exposeAnchors",s],["extractPrefix",r],["extractPrefix2",o],["extractSuffix",t],["optionalize",a],["preventReDoS",p],["removeEmptyGroups",m],["removeUselessFlags",n],["simplifyCallouts",l],["unnestUselessClasses",f],["unwrapNegationWrappers",u],["unwrapUselessClasses",x],["unwrapUselessGroups",c],["useShorthands",U],["useUnicodeAliases",g],["useUnicodeProps",C],["mergeRanges",i]]);export{v as optimizations};
+//# sourceMappingURL=optimizations.js.map

package/node_modules/oniguruma-parser/dist/optimizer/optimizations.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/optimizer/optimizations.ts"],
+  "sourcesContent": ["import type {Visitor} from '../traverser/traverse.js';\nimport {alternationToClass} from './transforms/alternation-to-class.js';\nimport {exposeAnchors} from './transforms/expose-anchors.js';\nimport {extractPrefix} from './transforms/extract-prefix.js';\nimport {extractPrefix2} from './transforms/extract-prefix-2.js';\nimport {extractSuffix} from './transforms/extract-suffix.js';\nimport {mergeRanges} from './transforms/merge-ranges.js';\nimport {optionalize} from './transforms/optionalize.js';\nimport {preventReDoS} from './transforms/prevent-redos.js';\nimport {removeEmptyGroups} from './transforms/remove-empty-groups.js';\nimport {removeUselessFlags} from './transforms/remove-useless-flags.js';\nimport {simplifyCallouts} from './transforms/simplify-callouts.js';\nimport {unnestUselessClasses} from './transforms/unnest-useless-classes.js';\nimport {unwrapNegationWrappers} from './transforms/unwrap-negation-wrappers.js';\nimport {unwrapUselessClasses} from './transforms/unwrap-useless-classes.js';\nimport {unwrapUselessGroups} from './transforms/unwrap-useless-groups.js';\nimport {useShorthands} from './transforms/use-shorthands.js';\nimport {useUnicodeAliases} from './transforms/use-unicode-aliases.js';\nimport {useUnicodeProps} from './transforms/use-unicode-props.js';\n\ntype OptimizationName =\n  'alternationToClass' |\n  'exposeAnchors' |\n  'extractPrefix' |\n  'extractPrefix2' |\n  'extractSuffix' |\n  'mergeRanges' |\n  'optionalize' |\n  'preventReDoS' |\n  'removeEmptyGroups' |\n  'removeUselessFlags' |\n  'simplifyCallouts' |\n  'unnestUselessClasses' |\n  'unwrapNegationWrappers' |\n  'unwrapUselessClasses' |\n  'unwrapUselessGroups' |\n  'useShorthands' |\n  'useUnicodeAliases' |\n  'useUnicodeProps';\n\nconst optimizations = new Map<OptimizationName, Visitor>([\n  ['alternationToClass', alternationToClass],\n  ['exposeAnchors', exposeAnchors],\n  ['extractPrefix', extractPrefix],\n  ['extractPrefix2', extractPrefix2],\n  ['extractSuffix', extractSuffix],\n  ['optionalize', optionalize],\n  ['preventReDoS', preventReDoS],\n  ['removeEmptyGroups', removeEmptyGroups],\n  ['removeUselessFlags', removeUselessFlags],\n  ['simplifyCallouts', simplifyCallouts],\n  ['unnestUselessClasses', unnestUselessClasses],\n  ['unwrapNegationWrappers', unwrapNegationWrappers],\n  ['unwrapUselessClasses', unwrapUselessClasses],\n  ['unwrapUselessGroups', unwrapUselessGroups],\n  ['useShorthands', useShorthands],\n  ['useUnicodeAliases', useUnicodeAliases],\n  ['useUnicodeProps', useUnicodeProps],\n  // Run last to let shorthands, etc. be found from ranges first\n  ['mergeRanges', mergeRanges],\n]);\n\nexport {\n  type OptimizationName,\n  optimizations,\n};\n"],
+  "mappings": "aACA,OAAQ,sBAAAA,MAAyB,uCACjC,OAAQ,iBAAAC,MAAoB,iCAC5B,OAAQ,iBAAAC,MAAoB,iCAC5B,OAAQ,kBAAAC,MAAqB,mCAC7B,OAAQ,iBAAAC,MAAoB,iCAC5B,OAAQ,eAAAC,MAAkB,+BAC1B,OAAQ,eAAAC,MAAkB,8BAC1B,OAAQ,gBAAAC,MAAmB,gCAC3B,OAAQ,qBAAAC,MAAwB,sCAChC,OAAQ,sBAAAC,MAAyB,uCACjC,OAAQ,oBAAAC,MAAuB,oCAC/B,OAAQ,wBAAAC,MAA2B,yCACnC,OAAQ,0BAAAC,MAA6B,2CACrC,OAAQ,wBAAAC,MAA2B,yCACnC,OAAQ,uBAAAC,MAA0B,wCAClC,OAAQ,iBAAAC,MAAoB,iCAC5B,OAAQ,qBAAAC,MAAwB,sCAChC,OAAQ,mBAAAC,MAAsB,oCAsB9B,MAAMC,EAAgB,IAAI,IAA+B,CACvD,CAAC,qBAAsBlB,CAAkB,EACzC,CAAC,gBAAiBC,CAAa,EAC/B,CAAC,gBAAiBC,CAAa,EAC/B,CAAC,iBAAkBC,CAAc,EACjC,CAAC,gBAAiBC,CAAa,EAC/B,CAAC,cAAeE,CAAW,EAC3B,CAAC,eAAgBC,CAAY,EAC7B,CAAC,oBAAqBC,CAAiB,EACvC,CAAC,qBAAsBC,CAAkB,EACzC,CAAC,mBAAoBC,CAAgB,EACrC,CAAC,uBAAwBC,CAAoB,EAC7C,CAAC,yBAA0BC,CAAsB,EACjD,CAAC,uBAAwBC,CAAoB,EAC7C,CAAC,sBAAuBC,CAAmB,EAC3C,CAAC,gBAAiBC,CAAa,EAC/B,CAAC,oBAAqBC,CAAiB,EACvC,CAAC,kBAAmBC,CAAe,EAEnC,CAAC,cAAeZ,CAAW,CAC7B,CAAC,EAED,OAEEa,KAAA",
+  "names": ["alternationToClass", "exposeAnchors", "extractPrefix", "extractPrefix2", "extractSuffix", "mergeRanges", "optionalize", "preventReDoS", "removeEmptyGroups", "removeUselessFlags", "simplifyCallouts", "unnestUselessClasses", "unwrapNegationWrappers", "unwrapUselessClasses", "unwrapUselessGroups", "useShorthands", "useUnicodeAliases", "useUnicodeProps", "optimizations"]
+}

package/node_modules/oniguruma-parser/dist/optimizer/optimize.d.ts

@@ -0,0 +1,23 @@
+import type { OnigurumaRegex } from '../generator/generate.js';
+import type { OptimizationName } from './optimizations.js';
+type OptimizationStates = {
+    [key in OptimizationName]: boolean;
+};
+type OptimizeOptions = {
+    flags?: string;
+    override?: Partial<OptimizationStates>;
+    rules?: {
+        allowOrphanBackrefs?: boolean;
+        captureGroup?: boolean;
+        singleline?: boolean;
+    };
+};
+/**
+Returns an optimized Oniguruma pattern and flags.
+*/
+declare function optimize(pattern: string, options?: OptimizeOptions): OnigurumaRegex;
+declare function getOptionalOptimizations(options?: {
+    disable?: boolean;
+}): OptimizationStates;
+export { type OptimizeOptions, getOptionalOptimizations, optimize, };
+//# sourceMappingURL=optimize.d.ts.map

package/node_modules/oniguruma-parser/dist/optimizer/optimize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimize.d.ts","sourceRoot":"","sources":["../../src/optimizer/optimize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAC;AAOzD,KAAK,kBAAkB,GAAG;KAAE,GAAG,IAAI,gBAAgB,GAAG,OAAO;CAAC,CAAC;AAE/D,KAAK,eAAe,GAAG;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACvC,KAAK,CAAC,EAAE;QACN,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,YAAY,CAAC,EAAE,OAAO,CAAC;QACvB,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB,CAAC;CACH,CAAC;AAEF;;EAEE;AACF,iBAAS,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,cAAc,CAkC5E;AA0BD,iBAAS,wBAAwB,CAAC,OAAO,GAAE;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAM,GAAG,kBAAkB,CAMvF;AAED,OAAO,EACL,KAAK,eAAe,EACpB,wBAAwB,EACxB,QAAQ,GACT,CAAC"}

package/node_modules/oniguruma-parser/dist/optimizer/optimize.js

@@ -0,0 +1,2 @@
+"use strict";import{generate as f}from"../generator/generate.js";import{parse as u}from"../parser/parse.js";import{traverse as O}from"../traverser/traverse.js";import{OnigUnicodePropertyMap as c}from"../unicode.js";import{optimizations as n}from"./optimizations.js";function g(e,t){const i=z(t),s=u(e,{flags:i.flags,rules:{captureGroup:i.rules.captureGroup,singleline:i.rules.singleline},skipBackrefValidation:i.rules.allowOrphanBackrefs,unicodePropertyMap:c}),a=Object.assign(p(),i.override);for(const r of n.keys())a[r]||delete a[r];const l=Object.keys(a);let o={pattern:e,flags:i.flags},m=0;do{if(++m>200)throw new Error("Optimization exceeded maximum iterations; possible infinite loop");e=o.pattern;for(const r of l)O(s,n.get(r));o=f(s)}while(e!==o.pattern);return o}function z(e={}){return{flags:"",override:{},...e,rules:{allowOrphanBackrefs:!1,captureGroup:!1,singleline:!1,...e.rules}}}function p(e={}){const t={};for(const i of n.keys())t[i]=!e.disable;return t}export{p as getOptionalOptimizations,g as optimize};
+//# sourceMappingURL=optimize.js.map

package/node_modules/oniguruma-parser/dist/optimizer/optimize.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/optimizer/optimize.ts"],
+  "sourcesContent": ["import type {OnigurumaRegex} from '../generator/generate.js';\nimport type {OptimizationName} from './optimizations.js';\nimport {generate} from '../generator/generate.js';\nimport {parse} from '../parser/parse.js';\nimport {traverse} from '../traverser/traverse.js';\nimport {OnigUnicodePropertyMap} from '../unicode.js';\nimport {optimizations} from './optimizations.js';\n\ntype OptimizationStates = {[key in OptimizationName]: boolean};\n\ntype OptimizeOptions = {\n  flags?: string;\n  override?: Partial<OptimizationStates>;\n  rules?: {\n    allowOrphanBackrefs?: boolean;\n    captureGroup?: boolean;\n    singleline?: boolean;\n  };\n};\n\n/**\nReturns an optimized Oniguruma pattern and flags.\n*/\nfunction optimize(pattern: string, options?: OptimizeOptions): OnigurumaRegex {\n  const opts = getOptions(options);\n  const ast = parse(pattern, {\n    flags: opts.flags,\n    rules: {\n      captureGroup: opts.rules.captureGroup,\n      singleline: opts.rules.singleline,\n    },\n    skipBackrefValidation: opts.rules.allowOrphanBackrefs,\n    unicodePropertyMap: OnigUnicodePropertyMap,\n  });\n  const active = Object.assign(getOptionalOptimizations(), opts.override);\n  for (const key of optimizations.keys()) {\n    if (!active[key]) {\n      delete active[key];\n    }\n  }\n  const names = Object.keys(active) as Array<OptimizationName>;\n  let optimized: OnigurumaRegex = {pattern, flags: opts.flags};\n  let counter = 0;\n  do {\n    if (++counter > 200) {\n      throw new Error('Optimization exceeded maximum iterations; possible infinite loop');\n    }\n    pattern = optimized.pattern;\n    for (const name of names) {\n      traverse(ast, optimizations.get(name)!);\n    }\n    optimized = generate(ast);\n  } while (\n    // Continue until no further optimization progress is made\n    pattern !== optimized.pattern\n  );\n  return optimized;\n}\n\nfunction getOptions(options: OptimizeOptions = {}): Required<OptimizeOptions> {\n  return {\n    // Oniguruma flags; a string with `imxDPSW` in any order (all optional). Oniguruma's `m` is\n    // equivalent to JavaScript's `s` (`dotAll`).\n    flags: '',\n    // Enable or disable individual, optional optimizations to change their default state.\n    override: {},\n    ...options,\n    rules: {\n      // Useful with TextMate grammars that merge backreferences across patterns. Maps to the\n      // parser's `skipBackrefValidation` option, but placed/named differently to match its use\n      // in `oniguruma-to-es`, which offers it for the same purpose that the optimizer does.\n      allowOrphanBackrefs: 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      // `^` as `\\A`; `$` as`\\Z`. This is Oniguruma option `ONIG_OPTION_SINGLELINE`.\n      singleline: false,\n      ...options.rules,\n    },\n  };\n}\n\nfunction getOptionalOptimizations(options: {disable?: boolean} = {}): OptimizationStates {\n  const obj = {} as OptimizationStates;\n  for (const key of optimizations.keys()) {\n    obj[key] = !options.disable;\n  }\n  return obj;\n}\n\nexport {\n  type OptimizeOptions,\n  getOptionalOptimizations,\n  optimize,\n};\n"],
+  "mappings": "aAEA,OAAQ,YAAAA,MAAe,2BACvB,OAAQ,SAAAC,MAAY,qBACpB,OAAQ,YAAAC,MAAe,2BACvB,OAAQ,0BAAAC,MAA6B,gBACrC,OAAQ,iBAAAC,MAAoB,qBAiB5B,SAASC,EAASC,EAAiBC,EAA2C,CAC5E,MAAMC,EAAOC,EAAWF,CAAO,EACzBG,EAAMT,EAAMK,EAAS,CACzB,MAAOE,EAAK,MACZ,MAAO,CACL,aAAcA,EAAK,MAAM,aACzB,WAAYA,EAAK,MAAM,UACzB,EACA,sBAAuBA,EAAK,MAAM,oBAClC,mBAAoBL,CACtB,CAAC,EACKQ,EAAS,OAAO,OAAOC,EAAyB,EAAGJ,EAAK,QAAQ,EACtE,UAAWK,KAAOT,EAAc,KAAK,EAC9BO,EAAOE,CAAG,GACb,OAAOF,EAAOE,CAAG,EAGrB,MAAMC,EAAQ,OAAO,KAAKH,CAAM,EAChC,IAAII,EAA4B,CAAC,QAAAT,EAAS,MAAOE,EAAK,KAAK,EACvDQ,EAAU,EACd,EAAG,CACD,GAAI,EAAEA,EAAU,IACd,MAAM,IAAI,MAAM,kEAAkE,EAEpFV,EAAUS,EAAU,QACpB,UAAWE,KAAQH,EACjBZ,EAASQ,EAAKN,EAAc,IAAIa,CAAI,CAAE,EAExCF,EAAYf,EAASU,CAAG,CAC1B,OAEEJ,IAAYS,EAAU,SAExB,OAAOA,CACT,CAEA,SAASN,EAAWF,EAA2B,CAAC,EAA8B,CAC5E,MAAO,CAGL,MAAO,GAEP,SAAU,CAAC,EACX,GAAGA,EACH,MAAO,CAIL,oBAAqB,GAIrB,aAAc,GAEd,WAAY,GACZ,GAAGA,EAAQ,KACb,CACF,CACF,CAEA,SAASK,EAAyBL,EAA+B,CAAC,EAAuB,CACvF,MAAMW,EAAM,CAAC,EACb,UAAWL,KAAOT,EAAc,KAAK,EACnCc,EAAIL,CAAG,EAAI,CAACN,EAAQ,QAEtB,OAAOW,CACT,CAEA,OAEEN,KAAA,yBACAP,KAAA",
+  "names": ["generate", "parse", "traverse", "OnigUnicodePropertyMap", "optimizations", "optimize", "pattern", "options", "opts", "getOptions", "ast", "active", "getOptionalOptimizations", "key", "names", "optimized", "counter", "name", "obj"]
+}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/alternation-to-class.d.ts

@@ -0,0 +1,7 @@
+import type { Visitor } from '../../traverser/traverse.js';
+/**
+Use character classes for adjacent alternatives with single-length values.
+*/
+declare const alternationToClass: Visitor;
+export { alternationToClass, };
+//# sourceMappingURL=alternation-to-class.d.ts.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/alternation-to-class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alternation-to-class.d.ts","sourceRoot":"","sources":["../../../src/optimizer/transforms/alternation-to-class.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,6BAA6B,CAAC;AAIzD;;EAEE;AACF,QAAA,MAAM,kBAAkB,EAAE,OA8BzB,CAAC;AAsBF,OAAO,EACL,kBAAkB,GACnB,CAAC"}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/alternation-to-class.js

@@ -0,0 +1,2 @@
+"use strict";import{isAlternativeContainer as i}from"../../parser/node-utils.js";import{createAlternative as n,createCharacterClass as c}from"../../parser/parse.js";const h={"*"({node:t}){if(!i(t)||t.body.length<2)return;const r=[];let e=[];for(const o of t.body){const a=o.body[0];o.body.length===1&&(a.type==="Character"||a.type==="CharacterClass"||a.type==="CharacterSet"&&d.has(a.kind))?e.push(a):(e.length&&(r.push(s(e)),e=[]),r.push(o))}e.length&&r.push(s(e)),t.body=r}};function s(t){const r=n(),e=t.length>1?c({body:t}):t[0];return e&&r.body.push(e),r}const d=new Set(["digit","hex","posix","property","space","word"]);export{h as alternationToClass};
+//# sourceMappingURL=alternation-to-class.js.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/alternation-to-class.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/optimizer/transforms/alternation-to-class.ts"],
+  "sourcesContent": ["import type {AlternativeNode, CharacterClassNode, CharacterNode, CharacterSetNode, NodeCharacterSetKind} from '../../parser/parse.js';\nimport type {Visitor} from '../../traverser/traverse.js';\nimport {isAlternativeContainer} from '../../parser/node-utils.js';\nimport {createAlternative, createCharacterClass} from '../../parser/parse.js';\n\n/**\nUse character classes for adjacent alternatives with single-length values.\n*/\nconst alternationToClass: Visitor = {\n  '*'({node}) {\n    if (!isAlternativeContainer(node) || node.body.length < 2) {\n      return;\n    }\n    const newAlts = [];\n    let ccNodes = [];\n    for (const alt of node.body) {\n      const kid = alt.body[0];\n      if (\n        alt.body.length === 1 &&\n        ( kid.type === 'Character' ||\n          kid.type === 'CharacterClass' ||\n          (kid.type === 'CharacterSet' && universalCharacterSetKinds.has(kid.kind))\n        )\n      ) {\n        ccNodes.push(kid);\n      } else {\n        if (ccNodes.length) {\n          newAlts.push(createAlternativeWithCombinedNodes(ccNodes));\n          ccNodes = [];\n        }\n        newAlts.push(alt);\n      }\n    }\n    if (ccNodes.length) {\n      newAlts.push(createAlternativeWithCombinedNodes(ccNodes));\n    }\n    node.body = newAlts;\n  },\n};\n\nfunction createAlternativeWithCombinedNodes(nodes: Array<CharacterNode | CharacterClassNode | CharacterSetNode>): AlternativeNode {\n  const alt = createAlternative();\n  const node = nodes.length > 1 ? createCharacterClass({body: nodes}) : nodes[0];\n  if (node) {\n    alt.body.push(node);\n  }\n  return alt;\n}\n\n// Character set kinds that can appear inside and outside of character classes, and can be inverted\n// by setting `negate`. Some but not all of those excluded use `variableLength: true`\nconst universalCharacterSetKinds = new Set<NodeCharacterSetKind>([\n  'digit',\n  'hex',\n  'posix',\n  'property',\n  'space',\n  'word',\n]);\n\nexport {\n  alternationToClass,\n};\n"],
+  "mappings": "aAEA,OAAQ,0BAAAA,MAA6B,6BACrC,OAAQ,qBAAAC,EAAmB,wBAAAC,MAA2B,wBAKtD,MAAMC,EAA8B,CAClC,IAAI,CAAC,KAAAC,CAAI,EAAG,CACV,GAAI,CAACJ,EAAuBI,CAAI,GAAKA,EAAK,KAAK,OAAS,EACtD,OAEF,MAAMC,EAAU,CAAC,EACjB,IAAIC,EAAU,CAAC,EACf,UAAWC,KAAOH,EAAK,KAAM,CAC3B,MAAMI,EAAMD,EAAI,KAAK,CAAC,EAEpBA,EAAI,KAAK,SAAW,IAClBC,EAAI,OAAS,aACbA,EAAI,OAAS,kBACZA,EAAI,OAAS,gBAAkBC,EAA2B,IAAID,EAAI,IAAI,GAGzEF,EAAQ,KAAKE,CAAG,GAEZF,EAAQ,SACVD,EAAQ,KAAKK,EAAmCJ,CAAO,CAAC,EACxDA,EAAU,CAAC,GAEbD,EAAQ,KAAKE,CAAG,EAEpB,CACID,EAAQ,QACVD,EAAQ,KAAKK,EAAmCJ,CAAO,CAAC,EAE1DF,EAAK,KAAOC,CACd,CACF,EAEA,SAASK,EAAmCC,EAAsF,CAChI,MAAMJ,EAAMN,EAAkB,EACxBG,EAAOO,EAAM,OAAS,EAAIT,EAAqB,CAAC,KAAMS,CAAK,CAAC,EAAIA,EAAM,CAAC,EAC7E,OAAIP,GACFG,EAAI,KAAK,KAAKH,CAAI,EAEbG,CACT,CAIA,MAAME,EAA6B,IAAI,IAA0B,CAC/D,QACA,MACA,QACA,WACA,QACA,MACF,CAAC,EAED,OACEN,KAAA",
+  "names": ["isAlternativeContainer", "createAlternative", "createCharacterClass", "alternationToClass", "node", "newAlts", "ccNodes", "alt", "kid", "universalCharacterSetKinds", "createAlternativeWithCombinedNodes", "nodes"]
+}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/expose-anchors.d.ts

@@ -0,0 +1,9 @@
+import type { Visitor } from '../../traverser/traverse.js';
+/**
+Pull leading and trailing assertions out of capturing groups when possible; helps group unwrapping.
+Ex: `(^abc$)` -> `^(abc)$`.
+Ex: `(\b(?:a|bc)\b)` -> `\b((?:a|bc))\b`. The inner group can subsequently be unwrapped.
+*/
+declare const exposeAnchors: Visitor;
+export { exposeAnchors, };
+//# sourceMappingURL=expose-anchors.d.ts.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/expose-anchors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expose-anchors.d.ts","sourceRoot":"","sources":["../../../src/optimizer/transforms/expose-anchors.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,6BAA6B,CAAC;AAEzD;;;;EAIE;AACF,QAAA,MAAM,aAAa,EAAE,OAwCpB,CAAC;AAEF,OAAO,EACL,aAAa,GACd,CAAC"}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/expose-anchors.js

@@ -0,0 +1,2 @@
+"use strict";const d={CapturingGroup({node:s,parent:a,replaceWithMultiple:c}){if(a.type==="Quantifier"||s.body.length>1||s.isSubroutined)return;const p=s.body[0],t=p.body,e=t[0],i=t.length>1?t.at(-1):null,o=e&&e.type==="Assertion",n=i&&i.type==="Assertion",l=o?1:0,u=t.length-(n?1:0);if(o||n){p.body=t.slice(l,u);const r=[];o&&r.push(e),r.push(s),n&&r.push(i),c(r,{traverse:!0})}}};export{d as exposeAnchors};
+//# sourceMappingURL=expose-anchors.js.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/expose-anchors.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/optimizer/transforms/expose-anchors.ts"],
+  "sourcesContent": ["import type {Node} from '../../parser/parse.js';\nimport type {Visitor} from '../../traverser/traverse.js';\n\n/**\nPull leading and trailing assertions out of capturing groups when possible; helps group unwrapping.\nEx: `(^abc$)` -> `^(abc)$`.\nEx: `(\\b(?:a|bc)\\b)` -> `\\b((?:a|bc))\\b`. The inner group can subsequently be unwrapped.\n*/\nconst exposeAnchors: Visitor = {\n  // Done for capturing groups only because they can't be unwrapped like noncapturing groups (done\n  // via `unwrapUselessGroups` combined with `removeUselessFlags`; the latter also avoids hazards\n  // from flags that modify word boundary and text segment boundary assertions that would need to\n  // be handled here since noncapturing groups can specify flags to change). Pulling anchors out\n  // can subsequently enable unwrapping multi-alternative noncapturing groups within the capturing\n  // group, and has the side benefit that exposed anchors also improve readability\n  CapturingGroup({node, parent, replaceWithMultiple}) {\n    if (\n      parent.type === 'Quantifier' ||\n      node.body.length > 1 || // Multiple alts\n      node.isSubroutined\n    ) {\n      return;\n    }\n    const firstAlt = node.body[0];\n    const firstAltEls = firstAlt.body;\n    // Despite only pulling one assertion at a time, multiple can be extracted through multiple\n    // rounds of running this optimization\n    const leading = firstAltEls[0];\n    const trailing = firstAltEls.length > 1 ? firstAltEls.at(-1)! : null;\n    const hasLeadingAssertion = leading && leading.type === 'Assertion';\n    const hasTrailingAssertion = trailing && trailing.type === 'Assertion';\n    const clippedStart = hasLeadingAssertion ? 1 : 0;\n    const clippedEnd = firstAltEls.length - (hasTrailingAssertion ? 1 : 0);\n    if (hasLeadingAssertion || hasTrailingAssertion) {\n      firstAlt.body = firstAltEls.slice(clippedStart, clippedEnd);\n      const nodes: Array<Node> = [];\n      if (hasLeadingAssertion) {\n        // Could use `insertBefore` if the traverser supported it\n        nodes.push(leading);\n      }\n      nodes.push(node);\n      if (hasTrailingAssertion) {\n        // Could use `insertAfter` if the traverser supported it\n        nodes.push(trailing);\n      }\n      replaceWithMultiple(nodes, {traverse: true});\n    }\n  },\n};\n\nexport {\n  exposeAnchors,\n};\n"],
+  "mappings": "aAQA,MAAMA,EAAyB,CAO7B,eAAe,CAAC,KAAAC,EAAM,OAAAC,EAAQ,oBAAAC,CAAmB,EAAG,CAClD,GACED,EAAO,OAAS,cAChBD,EAAK,KAAK,OAAS,GACnBA,EAAK,cAEL,OAEF,MAAMG,EAAWH,EAAK,KAAK,CAAC,EACtBI,EAAcD,EAAS,KAGvBE,EAAUD,EAAY,CAAC,EACvBE,EAAWF,EAAY,OAAS,EAAIA,EAAY,GAAG,EAAE,EAAK,KAC1DG,EAAsBF,GAAWA,EAAQ,OAAS,YAClDG,EAAuBF,GAAYA,EAAS,OAAS,YACrDG,EAAeF,EAAsB,EAAI,EACzCG,EAAaN,EAAY,QAAUI,EAAuB,EAAI,GACpE,GAAID,GAAuBC,EAAsB,CAC/CL,EAAS,KAAOC,EAAY,MAAMK,EAAcC,CAAU,EAC1D,MAAMC,EAAqB,CAAC,EACxBJ,GAEFI,EAAM,KAAKN,CAAO,EAEpBM,EAAM,KAAKX,CAAI,EACXQ,GAEFG,EAAM,KAAKL,CAAQ,EAErBJ,EAAoBS,EAAO,CAAC,SAAU,EAAI,CAAC,CAC7C,CACF,CACF,EAEA,OACEZ,KAAA",
+  "names": ["exposeAnchors", "node", "parent", "replaceWithMultiple", "firstAlt", "firstAltEls", "leading", "trailing", "hasLeadingAssertion", "hasTrailingAssertion", "clippedStart", "clippedEnd", "nodes"]
+}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/extract-prefix-2.d.ts

@@ -0,0 +1,9 @@
+import type { Visitor } from '../../traverser/traverse.js';
+/**
+Extract alternating prefixes if patterns are repeated for each prefix.
+Ex: `^a|!a|^bb|!bb|^c|!c` -> `(?:^|!)(?:a|bb|c)`.
+Also works within groups.
+*/
+declare const extractPrefix2: Visitor;
+export { extractPrefix2, };
+//# sourceMappingURL=extract-prefix-2.d.ts.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/extract-prefix-2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-prefix-2.d.ts","sourceRoot":"","sources":["../../../src/optimizer/transforms/extract-prefix-2.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,6BAA6B,CAAC;AAKzD;;;;EAIE;AACF,QAAA,MAAM,cAAc,EAAE,OAwErB,CAAC;AAmBF,OAAO,EACL,cAAc,GACf,CAAC"}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/extract-prefix-2.js

@@ -0,0 +1,2 @@
+"use strict";import{isAlternativeContainer as I}from"../../parser/node-utils.js";import{createAlternative as d,createGroup as x}from"../../parser/parse.js";import{isAllowedSimpleNode as g,isNodeEqual as v}from"./extract-prefix.js";const E={"*"({node:o}){if(!I(o))return;const t=2,i=o.body.length;if(i<t*2||i%t)return;const y=[...o.body.slice(0,t).map(e=>e.body)],s=Array.from({length:t},()=>[]),l=Array(t).fill(!1),p=Math.max(...y.map(e=>e.length));for(let e=0;e<p;e++)for(let r=0;r<t;r++)if(!l[r]){const n=y[r][e];!n||!g(n)||!j(n,o.body,r,e,t)?l[r]=!0:s[r].push(n)}if(!s.some(e=>e.length))return;const f=[];let a=0;for(let e=0;e<i;e++)f.push(d({body:o.body[e].body.slice(s[a].length)})),a=a<t-1?a+1:0;for(let e=0;e<i/t;e++){const r=f.slice(e*t,e*t+t);for(let n=1;n<r.length;n++){const h=r[n].body;if(h.length!==r[0].body.length||!h.every((A,N)=>g(A)&&v(A,r[0].body[N])))return}}const b=[];for(let e=0;e<t;e++)b.push(d({body:s[e]}));const c=x({body:b}),m=d({body:[c]}),u=x({body:f.filter((e,r)=>r%t)});u.body.every(e=>!e.body.length)?o.body=c.body:(m.body.push(u),o.body=[m])}};function j(o,t,i,y,s){for(let l=i;l<t.length;l+=s){const f=t[l].body[y];if(!f||!v(f,o))return!1}return!0}export{E as extractPrefix2};
+//# sourceMappingURL=extract-prefix-2.js.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/extract-prefix-2.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/optimizer/transforms/extract-prefix-2.ts"],
+  "sourcesContent": ["import type {AlternativeElementNode, AlternativeNode} from '../../parser/parse.js';\nimport type {Visitor} from '../../traverser/traverse.js';\nimport {isAlternativeContainer} from '../../parser/node-utils.js';\nimport {createAlternative, createGroup} from '../../parser/parse.js';\nimport {isAllowedSimpleNode, isNodeEqual} from './extract-prefix.js';\n\n/**\nExtract alternating prefixes if patterns are repeated for each prefix.\nEx: `^a|!a|^bb|!bb|^c|!c` -> `(?:^|!)(?:a|bb|c)`.\nAlso works within groups.\n*/\nconst extractPrefix2: Visitor = {\n  '*'({node}) {\n    if (!isAlternativeContainer(node)) {\n      return;\n    }\n    const numDiffPrefixes = 2;\n    const numAlts = node.body.length;\n    if (numAlts < (numDiffPrefixes * 2) || numAlts % numDiffPrefixes) {\n      return;\n    }\n    const prefixAltElsByI = [...node.body.slice(0, numDiffPrefixes).map(alt => alt.body)];\n    const prefixNodesByI = Array.from({length: numDiffPrefixes}, (): Array<AlternativeElementNode> => []);\n    const prefixIsFinishedByI = Array(numDiffPrefixes).fill(false);\n    const longestOf = Math.max(...prefixAltElsByI.map(els => els.length));\n    for (let nodeI = 0; nodeI < longestOf; nodeI++) {\n      for (let prefixI = 0; prefixI < numDiffPrefixes; prefixI++) {\n        if (!prefixIsFinishedByI[prefixI]) {\n          const nextNode = prefixAltElsByI[prefixI][nodeI];\n          if (\n            !nextNode ||\n            !isAllowedSimpleNode(nextNode) ||\n            !isPrefixNodeShared(nextNode, node.body, prefixI, nodeI, numDiffPrefixes)\n          ) {\n            prefixIsFinishedByI[prefixI] = true;\n          } else {\n            prefixNodesByI[prefixI].push(nextNode);\n          }\n        }\n      }\n    }\n    if (!prefixNodesByI.some(nodes => nodes.length)) {\n      return;\n    }\n    const strippedAlts = [];\n    let counter = 0;\n    for (let i = 0; i < numAlts; i++) {\n      strippedAlts.push(createAlternative({\n        body: node.body[i].body.slice(prefixNodesByI[counter].length),\n      }));\n      counter = counter < (numDiffPrefixes - 1) ? counter + 1 : 0;\n    }\n    // Check that each set of alts now use the same value after having had their prefixes removed\n    for (let i = 0; i < (numAlts / numDiffPrefixes); i++) {\n      const altComparisonSet = strippedAlts.slice(i * numDiffPrefixes, (i * numDiffPrefixes) + numDiffPrefixes);\n      for (let j = 1; j < altComparisonSet.length; j++) {\n        const els = altComparisonSet[j].body;\n        if (els.length !== altComparisonSet[0].body.length) {\n          return;\n        }\n        if (!els.every((el, k) => (\n          isAllowedSimpleNode(el) &&\n          isNodeEqual(el, altComparisonSet[0].body[k])\n        ))) {\n          return;\n        }\n      }\n    }\n    const prefixAlts = [];\n    for (let i = 0; i < numDiffPrefixes; i++) {\n      prefixAlts.push(createAlternative({body: prefixNodesByI[i]}));\n    }\n    const prefixGroup = createGroup({body: prefixAlts});\n    const newContentsAlt = createAlternative({body: [prefixGroup]});\n    // Only take one (unique) alt from each set of stripped alts\n    const suffixGroup = createGroup({body: strippedAlts.filter((_, i) => i % numDiffPrefixes)});\n    if (suffixGroup.body.every(alt => !alt.body.length)) {\n      node.body = prefixGroup.body;\n    } else {\n      newContentsAlt.body.push(suffixGroup);\n      node.body = [newContentsAlt];\n    }\n  },\n};\n\nfunction isPrefixNodeShared(\n  node: AlternativeElementNode,\n  alts: Array<AlternativeNode>,\n  prefixI: number,\n  nodeI: number,\n  numDiffPrefixes: number\n): boolean {\n  for (let i = prefixI; i < alts.length; i += numDiffPrefixes) {\n    const alt = alts[i];\n    const bNode = alt.body[nodeI];\n    if (!bNode || !isNodeEqual(bNode, node)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport {\n  extractPrefix2,\n};\n"],
+  "mappings": "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",
+  "names": ["isAlternativeContainer", "createAlternative", "createGroup", "isAllowedSimpleNode", "isNodeEqual", "extractPrefix2", "node", "numDiffPrefixes", "numAlts", "prefixAltElsByI", "alt", "prefixNodesByI", "prefixIsFinishedByI", "longestOf", "els", "nodeI", "prefixI", "nextNode", "isPrefixNodeShared", "nodes", "strippedAlts", "counter", "i", "altComparisonSet", "j", "el", "k", "prefixAlts", "prefixGroup", "newContentsAlt", "suffixGroup", "_", "alts", "bNode"]
+}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/extract-prefix.d.ts

@@ -0,0 +1,24 @@
+import type { AssertionNode, CharacterNode, Node } from '../../parser/parse.js';
+import type { Visitor } from '../../traverser/traverse.js';
+/**
+Extract nodes at the start of every alternative into a prefix.
+Ex: `^aa|^abb|^ac` -> `^a(?:a|bb|c)`.
+Also works within groups.
+*/
+declare const extractPrefix: Visitor;
+declare function isAllowedSimpleNode(node: Node): node is AssertionNode | CharacterNode | {
+    type: "CharacterSet";
+    kind: "posix" | "property";
+    value: string;
+    negate: boolean;
+    variableLength?: never;
+} | {
+    type: "CharacterSet";
+    kind: Exclude<import("../../parser/parse.js").NodeCharacterSetKind, "posix" | "property">;
+    value?: never;
+    negate?: boolean;
+    variableLength?: boolean;
+};
+declare function isNodeEqual(a: Node, b: Node): boolean;
+export { extractPrefix, isAllowedSimpleNode, isNodeEqual, };
+//# sourceMappingURL=extract-prefix.d.ts.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/extract-prefix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-prefix.d.ts","sourceRoot":"","sources":["../../../src/optimizer/transforms/extract-prefix.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAoB,IAAI,EAAC,MAAM,uBAAuB,CAAC;AAChG,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,6BAA6B,CAAC;AAIzD;;;;EAIE;AACF,QAAA,MAAM,aAAa,EAAE,OAkCpB,CAAC;AAEF,iBAAS,mBAAmB,CAAC,IAAI,EAAE,IAAI;;;;;;;;;;;;EAMtC;AAGD,iBAAS,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,OAAO,CAiB9C;AAED,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,WAAW,GACZ,CAAC"}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/extract-prefix.js

@@ -0,0 +1,2 @@
+"use strict";import{isAlternativeContainer as y}from"../../parser/node-utils.js";import{createAlternative as f,createGroup as c}from"../../parser/parse.js";const l={"*"({node:e}){if(!y(e)||e.body.length<2)return;const t=[];let i=!1,o=0;for(;!i;){t.push(e.body[0].body[o]);for(const r of e.body){const s=r.body[o];if(!s||!d(s)||!p(s,t[o])){i=!0;break}}o++}if(t.pop(),!t.length)return;for(const r of e.body)r.body=r.body.slice(t.length);const a=f({body:t}),n=c({body:e.body});n.body.every(r=>!r.body.length)||a.body.push(n),e.body=[a]}};function d(e){return e.type==="Assertion"||e.type==="Character"||e.type==="CharacterSet"}function p(e,t){if(e.type!==t.type)return!1;if(e.type==="Assertion"||e.type==="CharacterSet")return e.kind===t.kind&&e.negate===t.negate;if(e.type==="Character")return e.value===t.value;throw new Error(`Unexpected node type "${e.type}"`)}export{l as extractPrefix,d as isAllowedSimpleNode,p as isNodeEqual};
+//# sourceMappingURL=extract-prefix.js.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/extract-prefix.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/optimizer/transforms/extract-prefix.ts"],
+  "sourcesContent": ["import type {AssertionNode, CharacterNode, CharacterSetNode, Node} from '../../parser/parse.js';\nimport type {Visitor} from '../../traverser/traverse.js';\nimport {isAlternativeContainer} from '../../parser/node-utils.js';\nimport {createAlternative, createGroup} from '../../parser/parse.js';\n\n/**\nExtract nodes at the start of every alternative into a prefix.\nEx: `^aa|^abb|^ac` -> `^a(?:a|bb|c)`.\nAlso works within groups.\n*/\nconst extractPrefix: Visitor = {\n  '*'({node}) {\n    if (!isAlternativeContainer(node) || node.body.length < 2) {\n      return;\n    }\n    const prefixNodes = [];\n    let passedSharedPrefix = false;\n    let i = 0;\n    while (!passedSharedPrefix) {\n      prefixNodes.push(node.body[0].body[i]);\n      for (const alt of node.body) {\n        const kid = alt.body[i];\n        if (!kid || !isAllowedSimpleNode(kid) || !isNodeEqual(kid, prefixNodes[i])) {\n          passedSharedPrefix = true;\n          break;\n        }\n      }\n      i++;\n    }\n    prefixNodes.pop();\n    if (!prefixNodes.length) {\n      return;\n    }\n\n    for (const alt of node.body) {\n      alt.body = alt.body.slice(prefixNodes.length);\n    }\n    const newContentsAlt = createAlternative({body: prefixNodes});\n    const suffixGroup = createGroup({body: node.body});\n    if (!suffixGroup.body.every(alt => !alt.body.length)) {\n      newContentsAlt.body.push(suffixGroup);\n    }\n    node.body = [newContentsAlt];\n  },\n};\n\nfunction isAllowedSimpleNode(node: Node) {\n  return (\n    node.type === 'Assertion' ||\n    node.type === 'Character' ||\n    node.type === 'CharacterSet'\n  );\n}\n\n// TODO: Add support for more node types and move to `src/parser/node-utils.ts`\nfunction isNodeEqual(a: Node, b: Node): boolean {\n  if (a.type !== b.type) {\n    // TS doesn't understand that this makes `a` and `b` always have the same type, so we'll still\n    // need to cast, later\n    return false;\n  }\n  if (a.type === 'Assertion' || a.type === 'CharacterSet') {\n    return (\n      a.kind === (b as AssertionNode | CharacterSetNode).kind &&\n      a.negate === (b as AssertionNode | CharacterSetNode).negate\n    );\n  }\n  if (a.type === 'Character') {\n    return a.value === (b as CharacterNode).value;\n  }\n  // Only supports types from `isAllowedSimpleNode`\n  throw new Error(`Unexpected node type \"${a.type}\"`);\n}\n\nexport {\n  extractPrefix,\n  isAllowedSimpleNode,\n  isNodeEqual,\n};\n"],
+  "mappings": "aAEA,OAAQ,0BAAAA,MAA6B,6BACrC,OAAQ,qBAAAC,EAAmB,eAAAC,MAAkB,wBAO7C,MAAMC,EAAyB,CAC7B,IAAI,CAAC,KAAAC,CAAI,EAAG,CACV,GAAI,CAACJ,EAAuBI,CAAI,GAAKA,EAAK,KAAK,OAAS,EACtD,OAEF,MAAMC,EAAc,CAAC,EACrB,IAAIC,EAAqB,GACrBC,EAAI,EACR,KAAO,CAACD,GAAoB,CAC1BD,EAAY,KAAKD,EAAK,KAAK,CAAC,EAAE,KAAKG,CAAC,CAAC,EACrC,UAAWC,KAAOJ,EAAK,KAAM,CAC3B,MAAMK,EAAMD,EAAI,KAAKD,CAAC,EACtB,GAAI,CAACE,GAAO,CAACC,EAAoBD,CAAG,GAAK,CAACE,EAAYF,EAAKJ,EAAYE,CAAC,CAAC,EAAG,CAC1ED,EAAqB,GACrB,KACF,CACF,CACAC,GACF,CAEA,GADAF,EAAY,IAAI,EACZ,CAACA,EAAY,OACf,OAGF,UAAWG,KAAOJ,EAAK,KACrBI,EAAI,KAAOA,EAAI,KAAK,MAAMH,EAAY,MAAM,EAE9C,MAAMO,EAAiBX,EAAkB,CAAC,KAAMI,CAAW,CAAC,EACtDQ,EAAcX,EAAY,CAAC,KAAME,EAAK,IAAI,CAAC,EAC5CS,EAAY,KAAK,MAAML,GAAO,CAACA,EAAI,KAAK,MAAM,GACjDI,EAAe,KAAK,KAAKC,CAAW,EAEtCT,EAAK,KAAO,CAACQ,CAAc,CAC7B,CACF,EAEA,SAASF,EAAoBN,EAAY,CACvC,OACEA,EAAK,OAAS,aACdA,EAAK,OAAS,aACdA,EAAK,OAAS,cAElB,CAGA,SAASO,EAAYG,EAASC,EAAkB,CAC9C,GAAID,EAAE,OAASC,EAAE,KAGf,MAAO,GAET,GAAID,EAAE,OAAS,aAAeA,EAAE,OAAS,eACvC,OACEA,EAAE,OAAUC,EAAuC,MACnDD,EAAE,SAAYC,EAAuC,OAGzD,GAAID,EAAE,OAAS,YACb,OAAOA,EAAE,QAAWC,EAAoB,MAG1C,MAAM,IAAI,MAAM,yBAAyBD,EAAE,IAAI,GAAG,CACpD,CAEA,OACEX,KAAA,cACAO,KAAA,oBACAC,KAAA",
+  "names": ["isAlternativeContainer", "createAlternative", "createGroup", "extractPrefix", "node", "prefixNodes", "passedSharedPrefix", "i", "alt", "kid", "isAllowedSimpleNode", "isNodeEqual", "newContentsAlt", "suffixGroup", "a", "b"]
+}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/extract-suffix.d.ts

@@ -0,0 +1,9 @@
+import type { Visitor } from '../../traverser/traverse.js';
+/**
+Extract nodes at the end of every alternative into a suffix.
+Ex: `aa$|bba$|ca$` -> `(?:a|bb|c)a$`.
+Also works within groups.
+*/
+declare const extractSuffix: Visitor;
+export { extractSuffix, };
+//# sourceMappingURL=extract-suffix.d.ts.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/extract-suffix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-suffix.d.ts","sourceRoot":"","sources":["../../../src/optimizer/transforms/extract-suffix.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,6BAA6B,CAAC;AAKzD;;;;EAIE;AACF,QAAA,MAAM,aAAa,EAAE,OA2DpB,CAAC;AAEF,OAAO,EACL,aAAa,GACd,CAAC"}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/extract-suffix.js

@@ -0,0 +1,2 @@
+"use strict";import{isAlternativeContainer as h}from"../../parser/node-utils.js";import{createAlternative as p,createGroup as a}from"../../parser/parse.js";import{isAllowedSimpleNode as c,isNodeEqual as u}from"./extract-prefix.js";const g={"*"({node:e}){if(!h(e)||e.body.length<2)return;const y=e.body[0].body,t=[];let f=!1,s=0;for(;!f;){const o=y.length-1-s;t.push(y[o]);for(const i of e.body){const n=i.body.length-1-s,r=i.body[n];if(!r||!c(r)||!u(r,t[s])){f=!0;break}}s++}if(t.pop(),!t.length||t.length<3&&t[0].type!=="Assertion"&&t.length*(e.body.length-1)<4&&!e.body.some((o,i,n)=>{const r=n[i-1],d=t.length;return o.body.length-d<2&&r&&r.body.length-d<2}))return;t.reverse();for(const o of e.body)o.body=o.body.slice(0,-t.length);const l=p(),b=a({body:e.body});b.body.every(o=>!o.body.length)||l.body.push(b),l.body.push(...t),e.body=[l]}};export{g as extractSuffix};
+//# sourceMappingURL=extract-suffix.js.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/extract-suffix.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/optimizer/transforms/extract-suffix.ts"],
+  "sourcesContent": ["import type {Visitor} from '../../traverser/traverse.js';\nimport {isAlternativeContainer} from '../../parser/node-utils.js';\nimport {createAlternative, createGroup} from '../../parser/parse.js';\nimport {isAllowedSimpleNode, isNodeEqual} from './extract-prefix.js';\n\n/**\nExtract nodes at the end of every alternative into a suffix.\nEx: `aa$|bba$|ca$` -> `(?:a|bb|c)a$`.\nAlso works within groups.\n*/\nconst extractSuffix: Visitor = {\n  '*'({node}) {\n    if (!isAlternativeContainer(node) || node.body.length < 2) {\n      return;\n    }\n    const firstAltEls = node.body[0].body;\n    const suffixNodes = [];\n    let passedSharedSuffix = false;\n    let i = 0;\n    while (!passedSharedSuffix) {\n      const inverseI = firstAltEls.length - 1 - i;\n      suffixNodes.push(firstAltEls[inverseI]);\n      for (const alt of node.body) {\n        const inverseIOfAlt = alt.body.length - 1 - i;\n        const kid = alt.body[inverseIOfAlt];\n        if (!kid || !isAllowedSimpleNode(kid) || !isNodeEqual(kid, suffixNodes[i])) {\n          passedSharedSuffix = true;\n          break;\n        }\n      }\n      i++;\n    }\n    suffixNodes.pop();\n    if (\n      !suffixNodes.length ||\n      // Avoid applying in cases when it would lengthen the pattern without any benefit; ex:\n      // `true|false` -> `(?:tru|fals)e`, or `if|elseif` -> `(?:|else)if`\n      ( suffixNodes.length < 3 &&\n        // Always extract the suffix if it ends with an assertion, since that provides a\n        // readability benefit and is more likely to trigger follow-on optimizations\n        suffixNodes[0].type !== 'Assertion' &&\n        // Four chars are added by the `(?:)` wrapper and one instance of the suffix is added back\n        // at the end, so avoid if the result could be longer\n        (suffixNodes.length * (node.body.length - 1)) < 4 &&\n        // Adjacent alts reduced to 0 or 1 node after extracting the suffix can possibly be\n        // collapsed in follow-on optimizations, providing a performance and/or minification\n        // benefit\n        !node.body.some((alt, i, arr) => {\n          const lastAlt = arr[i - 1];\n          const removed = suffixNodes.length;\n          return alt.body.length - removed < 2 && lastAlt && lastAlt.body.length - removed < 2;\n        })\n      )\n    ) {\n      return;\n    }\n    suffixNodes.reverse();\n\n    for (const alt of node.body) {\n      alt.body = alt.body.slice(0, -suffixNodes.length);\n    }\n    const newContentsAlt = createAlternative();\n    const prefixGroup = createGroup({body: node.body});\n    if (!prefixGroup.body.every(alt => !alt.body.length)) {\n      newContentsAlt.body.push(prefixGroup);\n    }\n    newContentsAlt.body.push(...suffixNodes);\n    node.body = [newContentsAlt];\n  },\n};\n\nexport {\n  extractSuffix,\n};\n"],
+  "mappings": "aACA,OAAQ,0BAAAA,MAA6B,6BACrC,OAAQ,qBAAAC,EAAmB,eAAAC,MAAkB,wBAC7C,OAAQ,uBAAAC,EAAqB,eAAAC,MAAkB,sBAO/C,MAAMC,EAAyB,CAC7B,IAAI,CAAC,KAAAC,CAAI,EAAG,CACV,GAAI,CAACN,EAAuBM,CAAI,GAAKA,EAAK,KAAK,OAAS,EACtD,OAEF,MAAMC,EAAcD,EAAK,KAAK,CAAC,EAAE,KAC3BE,EAAc,CAAC,EACrB,IAAIC,EAAqB,GACrBC,EAAI,EACR,KAAO,CAACD,GAAoB,CAC1B,MAAME,EAAWJ,EAAY,OAAS,EAAIG,EAC1CF,EAAY,KAAKD,EAAYI,CAAQ,CAAC,EACtC,UAAWC,KAAON,EAAK,KAAM,CAC3B,MAAMO,EAAgBD,EAAI,KAAK,OAAS,EAAIF,EACtCI,EAAMF,EAAI,KAAKC,CAAa,EAClC,GAAI,CAACC,GAAO,CAACX,EAAoBW,CAAG,GAAK,CAACV,EAAYU,EAAKN,EAAYE,CAAC,CAAC,EAAG,CAC1ED,EAAqB,GACrB,KACF,CACF,CACAC,GACF,CAEA,GADAF,EAAY,IAAI,EAEd,CAACA,EAAY,QAGXA,EAAY,OAAS,GAGrBA,EAAY,CAAC,EAAE,OAAS,aAGvBA,EAAY,QAAUF,EAAK,KAAK,OAAS,GAAM,GAIhD,CAACA,EAAK,KAAK,KAAK,CAACM,EAAK,EAAGG,IAAQ,CAC/B,MAAMC,EAAUD,EAAI,EAAI,CAAC,EACnBE,EAAUT,EAAY,OAC5B,OAAOI,EAAI,KAAK,OAASK,EAAU,GAAKD,GAAWA,EAAQ,KAAK,OAASC,EAAU,CACrF,CAAC,EAGH,OAEFT,EAAY,QAAQ,EAEpB,UAAWI,KAAON,EAAK,KACrBM,EAAI,KAAOA,EAAI,KAAK,MAAM,EAAG,CAACJ,EAAY,MAAM,EAElD,MAAMU,EAAiBjB,EAAkB,EACnCkB,EAAcjB,EAAY,CAAC,KAAMI,EAAK,IAAI,CAAC,EAC5Ca,EAAY,KAAK,MAAMP,GAAO,CAACA,EAAI,KAAK,MAAM,GACjDM,EAAe,KAAK,KAAKC,CAAW,EAEtCD,EAAe,KAAK,KAAK,GAAGV,CAAW,EACvCF,EAAK,KAAO,CAACY,CAAc,CAC7B,CACF,EAEA,OACEb,KAAA",
+  "names": ["isAlternativeContainer", "createAlternative", "createGroup", "isAllowedSimpleNode", "isNodeEqual", "extractSuffix", "node", "firstAltEls", "suffixNodes", "passedSharedSuffix", "i", "inverseI", "alt", "inverseIOfAlt", "kid", "arr", "lastAlt", "removed", "newContentsAlt", "prefixGroup"]
+}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/merge-ranges.d.ts

@@ -0,0 +1,7 @@
+import type { Visitor } from '../../traverser/traverse.js';
+/**
+Merge, dedupe, and sort ranges and characters in character classes.
+*/
+declare const mergeRanges: Visitor;
+export { mergeRanges, };
+//# sourceMappingURL=merge-ranges.d.ts.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/merge-ranges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-ranges.d.ts","sourceRoot":"","sources":["../../../src/optimizer/transforms/merge-ranges.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,6BAA6B,CAAC;AAGzD;;EAEE;AACF,QAAA,MAAM,WAAW,EAAE,OAgGlB,CAAC;AASF,OAAO,EACL,WAAW,GACZ,CAAC"}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/merge-ranges.js

@@ -0,0 +1,2 @@
+"use strict";import{createCharacter as u,createCharacterClassRange as h}from"../../parser/parse.js";const m={CharacterClass({node:t}){if(t.kind!=="union"||!t.body.length)return;const l=[];for(const e of t.body)e.type==="CharacterSet"&&l.some(a=>a.type===e.type&&a.kind===e.kind&&a.negate===e.negate&&a.value===e.value)||l.push(e);t.body=l;const o=[],n=[];for(const e of t.body)e.type==="Character"||e.type==="CharacterClassRange"?n.push(e):o.push(e);if(!n.length)return;n.sort((e,a)=>{const r=e.type==="Character"?e.value:e.min.value,c=a.type==="Character"?a.value:a.min.value;return r-c});const s=[n[0]];for(let e=1;e<n.length;e++){const a=n[e],r=s.at(-1),c=a.type==="Character"?a.value:a.min.value,p=r.type==="Character"?r.value:r.max.value;if(c<=p+1)if(r.type==="Character"&&a.type==="Character")r.value!==a.value&&(s[s.length-1]=h(r,a));else if(r.type==="Character"&&a.type==="CharacterClassRange")s[s.length-1]=h(u(r.value),a.max);else if(r.type==="CharacterClassRange"&&a.type==="Character")r.max.value=Math.max(a.value,r.max.value);else if(r.type==="CharacterClassRange"&&a.type==="CharacterClassRange")r.max.value=Math.max(a.max.value,r.max.value);else throw new Error("Unexpected merge case");else s.push(a)}const i=s.flatMap(e=>{if(e.type==="CharacterClassRange"){const a=e.max.value-e.min.value;if(e.min.value>262143&&a>1)return e;if(a){if(a===1)return[e.min,e.max];if(a===2)return[e.min,u(e.min.value+1),e.max]}else return e.min}return e});t.body=[...i.filter(e=>C(e)),...i.filter(e=>!C(e)),...o]}};function C(t){return t.type==="Character"&&(t.value===45||t.value===93)}export{m as mergeRanges};
+//# sourceMappingURL=merge-ranges.js.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/merge-ranges.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/optimizer/transforms/merge-ranges.ts"],
+  "sourcesContent": ["import type {CharacterClassElementNode, CharacterClassRangeNode, CharacterNode} from '../../parser/parse.js';\nimport type {Visitor} from '../../traverser/traverse.js';\nimport {createCharacter, createCharacterClassRange} from '../../parser/parse.js';\n\n/**\nMerge, dedupe, and sort ranges and characters in character classes.\n*/\nconst mergeRanges: Visitor = {\n  CharacterClass({node}) {\n    if (node.kind !== 'union' || !node.body.length) {\n      return;\n    }\n\n    // ## Since characters and ranges will be deduped by merging, might as well dedupe sets too\n    const withoutDupeSets: Array<CharacterClassElementNode> = [];\n    for (const el of node.body) {\n      if (\n        el.type === 'CharacterSet' &&\n        withoutDupeSets.some(k => (\n          k.type === el.type &&\n          k.kind === el.kind &&\n          k.negate === el.negate &&\n          k.value === el.value\n        ))\n      ) {\n        continue;\n      }\n      // Keep non-duplicate sets (first instance) and any non-set nodes\n      withoutDupeSets.push(el);\n    }\n    node.body = withoutDupeSets;\n\n    // ## Now merge characters and ranges\n    const keep: Array<Exclude<CharacterClassElementNode, HandledNode>> = [];\n    const candidates: Array<HandledNode> = [];\n    for (const el of node.body) {\n      if (el.type === 'Character' || el.type === 'CharacterClassRange') {\n        candidates.push(el);\n      } else {\n        keep.push(el);\n      }\n    }\n    if (!candidates.length) {\n      return;\n    }\n    candidates.sort((a, b) => {\n      const aValue = a.type === 'Character' ? a.value : a.min.value;\n      const bValue = b.type === 'Character' ? b.value : b.min.value;\n      return aValue - bValue;\n    });\n    const merged: Array<HandledNode> = [candidates[0]];\n    for (let i = 1; i < candidates.length; i++) {\n      const el = candidates[i];\n      const last = merged.at(-1)!;\n      const elMin = el.type === 'Character' ? el.value : el.min.value;\n      const lastMax = last.type === 'Character' ? last.value : last.max.value;\n      if (elMin <= lastMax + 1) {\n        if (last.type === 'Character' && el.type === 'Character') {\n          if (last.value !== el.value) {\n            merged[merged.length - 1] = createCharacterClassRange(last, el);\n          }\n        } else if (last.type === 'Character' && el.type === 'CharacterClassRange') {\n          merged[merged.length - 1] = createCharacterClassRange(createCharacter(last.value), el.max);\n        } else if (last.type === 'CharacterClassRange' && el.type === 'Character') {\n          last.max.value = Math.max(el.value, last.max.value);\n        } else if (last.type === 'CharacterClassRange' && el.type === 'CharacterClassRange') {\n          last.max.value = Math.max(el.max.value, last.max.value);\n        } else {\n          throw new Error('Unexpected merge case');\n        }\n      } else {\n        merged.push(el);\n      }\n    }\n    // Replace any ranges with fewer than four (sometimes three) chars with character nodes\n    const final = merged.flatMap(el => {\n      if (el.type === 'CharacterClassRange') {\n        const diff = el.max.value - el.min.value;\n        // More aggressively use ranges for U+40000+, since they're rendered in long form like\n        // `\\x{40000}` rather than as single-length characters\n        if (el.min.value > 0x3FFFF && diff > 1) {\n          return el;\n        } else if (!diff) {\n          return el.min;\n        } else if (diff === 1) {\n          return [el.min, el.max];\n        } else if (diff === 2) {\n          // Ex: `a-c` -> `abc`\n          return [el.min, createCharacter(el.min.value + 1), el.max];\n        }\n        // `diff > 2`\n      }\n      return el;\n    });\n    // Always replace `body` to avoid skipping things like `[a-a]` -> `[a]` where both classes\n    // contain the same number of nodes; means we always sort characters/ranges by their values\n    node.body = [\n      // Pull chars to the front that don't need to be escaped in first position\n      ...final.filter(el => firstPosChar(el)),\n      ...final.filter(el => !firstPosChar(el)),\n      ...keep\n    ];\n  },\n};\n\ntype HandledNode = CharacterNode | CharacterClassRangeNode;\n\nfunction firstPosChar(node: HandledNode): boolean {\n  // Is `-` or `]`\n  return node.type === 'Character' && (node.value === 45 || node.value === 93);\n}\n\nexport {\n  mergeRanges,\n};\n"],
+  "mappings": "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",
+  "names": ["createCharacter", "createCharacterClassRange", "mergeRanges", "node", "withoutDupeSets", "el", "k", "keep", "candidates", "a", "b", "aValue", "bValue", "merged", "i", "last", "elMin", "lastMax", "final", "diff", "firstPosChar"]
+}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/optionalize.d.ts

@@ -0,0 +1,7 @@
+import type { Visitor } from '../../traverser/traverse.js';
+/**
+Combine adjacent alternatives with only an added last node as the difference.
+*/
+declare const optionalize: Visitor;
+export { optionalize, };
+//# sourceMappingURL=optionalize.d.ts.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/optionalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optionalize.d.ts","sourceRoot":"","sources":["../../../src/optimizer/transforms/optionalize.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,6BAA6B,CAAC;AAMzD;;EAEE;AACF,QAAA,MAAM,WAAW,EAAE,OA4ElB,CAAC;AAmBF,OAAO,EACL,WAAW,GACZ,CAAC"}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/optionalize.js

@@ -0,0 +1,2 @@
+"use strict";import{isAlternativeContainer as A,isQuantifiable as u}from"../../parser/node-utils.js";import{createQuantifier as m}from"../../parser/parse.js";import{throwIfNullish as c}from"../../utils.js";import{isAllowedSimpleNode as d,isNodeEqual as v}from"./extract-prefix.js";const K={"*"({node:i}){if(!A(i)||i.body.length<2)return;const{body:n}=i,r=[n[0]];let f=n[0];for(let o=1;o<n.length;o++){const s=n[o],l=s.body,t=f.body,p=Math.abs(l.length-t.length);if(p){if(p===1){const a=t.length>l.length,y=a?l:l.slice(0,-1),g=a?t.slice(0,-1):t;if(h(y,g)){if(a){const e=c(t.at(-1));if(u(e))if(e.type==="Quantifier")if(e.min){if(e.min===1&&e.kind!=="lazy"){e.min=0;continue}}else continue;else{t.pop(),t.push(m("greedy",0,1,e));continue}}else if(t.length>0||n.length===2){const e=c(l.at(-1));if(u(e))if(e.type==="Quantifier"){if(e.kind!=="possessive"){if(e.min<=1&&e.kind==="lazy"){e.min=0,t.push(e);continue}else if(!e.min&&e.max===1){e.kind="lazy",t.push(e);continue}}}else{t.push(m("lazy",0,1,e));continue}}}}}else if(h(l,t))continue;r.push(s),f=s}i.body=r}};function h(i,n){if(i.length!==n.length)return!1;for(let r=0;r<i.length;r++)if(!d(i[r])||!d(n[r])||!v(i[r],n[r]))return!1;return!0}export{K as optionalize};
+//# sourceMappingURL=optionalize.js.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/optionalize.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/optimizer/transforms/optionalize.ts"],
+  "sourcesContent": ["import type {AlternativeElementNode} from '../../parser/parse.js';\nimport type {Visitor} from '../../traverser/traverse.js';\nimport {isAlternativeContainer, isQuantifiable} from '../../parser/node-utils.js';\nimport {createQuantifier} from '../../parser/parse.js';\nimport {throwIfNullish} from '../../utils.js';\nimport {isAllowedSimpleNode, isNodeEqual} from './extract-prefix.js';\n\n/**\nCombine adjacent alternatives with only an added last node as the difference.\n*/\nconst optionalize: Visitor = {\n  '*'({node}) {\n    if (!isAlternativeContainer(node) || node.body.length < 2) {\n      return;\n    }\n    const {body} = node;\n    const newAlts = [body[0]];\n    let lastAltKept = body[0];\n    for (let i = 1; i < body.length; i++) {\n      // NOTE: Anytime we `continue` we don't keep this alt\n      const alt = body[i];\n      const altKids = alt.body;\n      const prevAltKids = lastAltKept.body;\n      const lengthDiff = Math.abs(altKids.length - prevAltKids.length);\n      if (!lengthDiff) {\n        if (isNodeArrayEqual(altKids, prevAltKids)) {\n          continue;\n        }\n      } else if (lengthDiff === 1) {\n        const isPrevAltLonger = !!(prevAltKids.length > altKids.length);\n        const altKidsToCompare = isPrevAltLonger ? altKids : altKids.slice(0, -1);\n        const prevAltKidsToCompare = isPrevAltLonger ? prevAltKids.slice(0, -1) : prevAltKids;\n        if (isNodeArrayEqual(altKidsToCompare, prevAltKidsToCompare)) {\n          if (isPrevAltLonger) {\n            const prevAltLastKid = throwIfNullish(prevAltKids.at(-1));\n            if (isQuantifiable(prevAltLastKid)) {\n              // Avoid chaining quantifiers since e.g. chained greedy `?` is `?{0,1}` and can\n              // lengthen the pattern\n              if (prevAltLastKid.type === 'Quantifier') {\n                if (!prevAltLastKid.min) {\n                  continue;\n                } else if (prevAltLastKid.min === 1 && prevAltLastKid.kind !== 'lazy') {\n                  prevAltLastKid.min = 0;\n                  continue;\n                }\n              } else {\n                // Put the prev alt's extra last node in a greedy `?`\n                prevAltKids.pop();\n                prevAltKids.push(createQuantifier('greedy', 0, 1, prevAltLastKid));\n                continue;\n              }\n            }\n          } else if (\n            // Don't apply if last alt empty since that would lengthen e.g. `(|a|b)` to `(a??|b)`\n            prevAltKids.length > 0 ||\n            // Unless there are two alts since e.g. `(?:|a)` to `(?:a??)` enables group unwrapping\n            body.length === 2\n          ) {\n            const altLastKid = throwIfNullish(altKids.at(-1));\n            if (isQuantifiable(altLastKid)) {\n              if (altLastKid.type === 'Quantifier') {\n                if (altLastKid.kind === 'possessive') {\n                  // No-op since possessive quantifiers can't also be lazy\n                } else if (altLastKid.min <= 1 && altLastKid.kind === 'lazy') {\n                  altLastKid.min = 0;\n                  prevAltKids.push(altLastKid);\n                  continue;\n                } else if (!altLastKid.min && altLastKid.max === 1) {\n                  altLastKid.kind = 'lazy';\n                  prevAltKids.push(altLastKid);\n                  continue;\n                }\n              } else {\n                // Put this alt's extra last node in a lazy `??` then add it to the prev alt\n                prevAltKids.push(createQuantifier('lazy', 0, 1, altLastKid));\n                continue;\n              }\n            }\n          }\n        }\n      }\n      newAlts.push(alt);\n      lastAltKept = alt;\n    }\n    node.body = newAlts;\n  },\n};\n\n// Returns `false` if the arrays contain a node type it doesn't know how to compare, or doesn't\n// want to compare (e.g. with capturing groups, which can't be removed)\nfunction isNodeArrayEqual(a: Array<AlternativeElementNode>, b: Array<AlternativeElementNode>) {\n  if (a.length !== b.length) {\n    return false;\n  }\n  for (let i = 0; i < a.length; i++) {\n    if (!isAllowedSimpleNode(a[i]) || !isAllowedSimpleNode(b[i])) {\n      return false;\n    }\n    if (!isNodeEqual(a[i], b[i])) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport {\n  optionalize,\n};\n"],
+  "mappings": "aAEA,OAAQ,0BAAAA,EAAwB,kBAAAC,MAAqB,6BACrD,OAAQ,oBAAAC,MAAuB,wBAC/B,OAAQ,kBAAAC,MAAqB,iBAC7B,OAAQ,uBAAAC,EAAqB,eAAAC,MAAkB,sBAK/C,MAAMC,EAAuB,CAC3B,IAAI,CAAC,KAAAC,CAAI,EAAG,CACV,GAAI,CAACP,EAAuBO,CAAI,GAAKA,EAAK,KAAK,OAAS,EACtD,OAEF,KAAM,CAAC,KAAAC,CAAI,EAAID,EACTE,EAAU,CAACD,EAAK,CAAC,CAAC,EACxB,IAAIE,EAAcF,EAAK,CAAC,EACxB,QAASG,EAAI,EAAGA,EAAIH,EAAK,OAAQG,IAAK,CAEpC,MAAMC,EAAMJ,EAAKG,CAAC,EACZE,EAAUD,EAAI,KACdE,EAAcJ,EAAY,KAC1BK,EAAa,KAAK,IAAIF,EAAQ,OAASC,EAAY,MAAM,EAC/D,GAAKC,GAIE,GAAIA,IAAe,EAAG,CAC3B,MAAMC,EAAqBF,EAAY,OAASD,EAAQ,OAClDI,EAAmBD,EAAkBH,EAAUA,EAAQ,MAAM,EAAG,EAAE,EAClEK,EAAuBF,EAAkBF,EAAY,MAAM,EAAG,EAAE,EAAIA,EAC1E,GAAIK,EAAiBF,EAAkBC,CAAoB,GACzD,GAAIF,EAAiB,CACnB,MAAMI,EAAiBjB,EAAeW,EAAY,GAAG,EAAE,CAAC,EACxD,GAAIb,EAAemB,CAAc,EAG/B,GAAIA,EAAe,OAAS,aAC1B,GAAKA,EAAe,KAEb,GAAIA,EAAe,MAAQ,GAAKA,EAAe,OAAS,OAAQ,CACrEA,EAAe,IAAM,EACrB,QACF,MAJE,cAKG,CAELN,EAAY,IAAI,EAChBA,EAAY,KAAKZ,EAAiB,SAAU,EAAG,EAAGkB,CAAc,CAAC,EACjE,QACF,CAEJ,SAEEN,EAAY,OAAS,GAErBN,EAAK,SAAW,EAChB,CACA,MAAMa,EAAalB,EAAeU,EAAQ,GAAG,EAAE,CAAC,EAChD,GAAIZ,EAAeoB,CAAU,EAC3B,GAAIA,EAAW,OAAS,cACtB,GAAIA,EAAW,OAAS,cAEjB,GAAIA,EAAW,KAAO,GAAKA,EAAW,OAAS,OAAQ,CAC5DA,EAAW,IAAM,EACjBP,EAAY,KAAKO,CAAU,EAC3B,QACF,SAAW,CAACA,EAAW,KAAOA,EAAW,MAAQ,EAAG,CAClDA,EAAW,KAAO,OAClBP,EAAY,KAAKO,CAAU,EAC3B,QACF,OACK,CAELP,EAAY,KAAKZ,EAAiB,OAAQ,EAAG,EAAGmB,CAAU,CAAC,EAC3D,QACF,CAEJ,EAEJ,UAvDMF,EAAiBN,EAASC,CAAW,EACvC,SAuDJL,EAAQ,KAAKG,CAAG,EAChBF,EAAcE,CAChB,CACAL,EAAK,KAAOE,CACd,CACF,EAIA,SAASU,EAAiBG,EAAkCC,EAAkC,CAC5F,GAAID,EAAE,SAAWC,EAAE,OACjB,MAAO,GAET,QAASZ,EAAI,EAAGA,EAAIW,EAAE,OAAQX,IAI5B,GAHI,CAACP,EAAoBkB,EAAEX,CAAC,CAAC,GAAK,CAACP,EAAoBmB,EAAEZ,CAAC,CAAC,GAGvD,CAACN,EAAYiB,EAAEX,CAAC,EAAGY,EAAEZ,CAAC,CAAC,EACzB,MAAO,GAGX,MAAO,EACT,CAEA,OACEL,KAAA",
+  "names": ["isAlternativeContainer", "isQuantifiable", "createQuantifier", "throwIfNullish", "isAllowedSimpleNode", "isNodeEqual", "optionalize", "node", "body", "newAlts", "lastAltKept", "i", "alt", "altKids", "prevAltKids", "lengthDiff", "isPrevAltLonger", "altKidsToCompare", "prevAltKidsToCompare", "isNodeArrayEqual", "prevAltLastKid", "altLastKid", "a", "b"]
+}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/prevent-redos.d.ts

@@ -0,0 +1,7 @@
+import type { Visitor } from '../../traverser/traverse.js';
+/**
+Remove identified ReDoS vulnerabilities without changing matches.
+*/
+declare const preventReDoS: Visitor;
+export { preventReDoS, };
+//# sourceMappingURL=prevent-redos.d.ts.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/prevent-redos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prevent-redos.d.ts","sourceRoot":"","sources":["../../../src/optimizer/transforms/prevent-redos.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,6BAA6B,CAAC;AAGzD;;EAEE;AACF,QAAA,MAAM,YAAY,EAAE,OAuCnB,CAAC;AAEF,OAAO,EACL,YAAY,GACb,CAAC"}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/prevent-redos.js

@@ -0,0 +1,2 @@
+"use strict";import{hasOnlyChild as n}from"../../parser/node-utils.js";const s={Quantifier({node:t}){const{body:r,max:o}=t;if(o!==1/0||r.type!=="Group"||r.atomic)return;const e=r.body[0];if(!n(e,{type:"Quantifier"}))return;const i=e.body[0];i.kind==="possessive"||i.min>1||i.max<2||(i.min?i.min===1&&(e.body[0]=i.body):i.max=1)}};export{s as preventReDoS};
+//# sourceMappingURL=prevent-redos.js.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/prevent-redos.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/optimizer/transforms/prevent-redos.ts"],
+  "sourcesContent": ["import type {QuantifierNode} from '../../parser/parse.js';\nimport type {Visitor} from '../../traverser/traverse.js';\nimport {hasOnlyChild} from '../../parser/node-utils.js';\n\n/**\nRemove identified ReDoS vulnerabilities without changing matches.\n*/\nconst preventReDoS: Visitor = {\n  Quantifier({node}) {\n    // Prevent a common cause of catastrophic backtracking by removing an unneeded nested\n    // quantifier from the first alternative of infinitely-quantified groups. Can't remove nested\n    // quantifiers from other alternatives or when the first alternative contains more than one\n    // node, because that might change the match\n    // TODO: It's safe to skip this transform if the quantified group is the last node in the\n    // pattern, since there's no backtracking trigger if there's no following node\n    const {body, max} = node;\n    if (\n      max !== Infinity ||\n      // Can't operate on capturing groups because that could change the captured value\n      body.type !== 'Group' ||\n      // No benefit with atomic groups\n      body.atomic\n    ) {\n      return;\n    }\n    const firstAlt = body.body[0];\n    if (!hasOnlyChild(firstAlt, {type: 'Quantifier'})) {\n      return;\n    }\n    const nestedQuantifier = firstAlt.body[0] as QuantifierNode;\n    if (\n      // No benefit with possessive quantifiers\n      nestedQuantifier.kind === 'possessive' ||\n      nestedQuantifier.min > 1 ||\n      nestedQuantifier.max < 2\n    ) {\n      return;\n    }\n    if (!nestedQuantifier.min) {\n      // Ex: Change `*` or `{0,2}` to `?`; preserve laziness\n      nestedQuantifier.max = 1;\n    } else if (nestedQuantifier.min === 1) {\n      // Ex: Remove `+` or `{1,2}`\n      firstAlt.body[0] = nestedQuantifier.body;\n    }\n  },\n};\n\nexport {\n  preventReDoS,\n};\n"],
+  "mappings": "aAEA,OAAQ,gBAAAA,MAAmB,6BAK3B,MAAMC,EAAwB,CAC5B,WAAW,CAAC,KAAAC,CAAI,EAAG,CAOjB,KAAM,CAAC,KAAAC,EAAM,IAAAC,CAAG,EAAIF,EACpB,GACEE,IAAQ,KAERD,EAAK,OAAS,SAEdA,EAAK,OAEL,OAEF,MAAME,EAAWF,EAAK,KAAK,CAAC,EAC5B,GAAI,CAACH,EAAaK,EAAU,CAAC,KAAM,YAAY,CAAC,EAC9C,OAEF,MAAMC,EAAmBD,EAAS,KAAK,CAAC,EAGtCC,EAAiB,OAAS,cAC1BA,EAAiB,IAAM,GACvBA,EAAiB,IAAM,IAIpBA,EAAiB,IAGXA,EAAiB,MAAQ,IAElCD,EAAS,KAAK,CAAC,EAAIC,EAAiB,MAHpCA,EAAiB,IAAM,EAK3B,CACF,EAEA,OACEL,KAAA",
+  "names": ["hasOnlyChild", "preventReDoS", "node", "body", "max", "firstAlt", "nestedQuantifier"]
+}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/remove-empty-groups.d.ts

@@ -0,0 +1,7 @@
+import type { Visitor } from '../../traverser/traverse.js';
+/**
+Remove empty noncapturing, atomic, and flag groups, even if quantified.
+*/
+declare const removeEmptyGroups: Visitor;
+export { removeEmptyGroups, };
+//# sourceMappingURL=remove-empty-groups.d.ts.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/remove-empty-groups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-empty-groups.d.ts","sourceRoot":"","sources":["../../../src/optimizer/transforms/remove-empty-groups.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,6BAA6B,CAAC;AAEzD;;EAEE;AACF,QAAA,MAAM,iBAAiB,EAAE,OA4BxB,CAAC;AAmBF,OAAO,EACL,iBAAiB,GAClB,CAAC"}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/remove-empty-groups.js

@@ -0,0 +1,2 @@
+"use strict";const n={AbsenceFunction({node:e,remove:r}){o(e)&&r()},Group({node:e,remove:r}){o(e)&&r()},LookaroundAssertion({node:e,remove:r}){o(e)&&r()},Quantifier({node:e,remove:r}){let t=e.body;for(;t.type==="Quantifier";)t=t.body;o(t)&&r()}};function i(e){return e.body.every(r=>!r.body.length)}function o(e){switch(e.type){case"AbsenceFunction":return e.kind==="repeater"&&i(e);case"Group":return i(e);case"LookaroundAssertion":return!e.negate&&i(e);default:return!1}}export{n as removeEmptyGroups};
+//# sourceMappingURL=remove-empty-groups.js.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/remove-empty-groups.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/optimizer/transforms/remove-empty-groups.ts"],
+  "sourcesContent": ["import type {AlternativeContainerNode, Node} from '../../parser/parse.js';\nimport type {Visitor} from '../../traverser/traverse.js';\n\n/**\nRemove empty noncapturing, atomic, and flag groups, even if quantified.\n*/\nconst removeEmptyGroups: Visitor = {\n  AbsenceFunction({node, remove}) {\n    if (isQualifiedAndEmpty(node)) {\n      remove();\n    }\n  },\n\n  Group({node, remove}) {\n    if (isQualifiedAndEmpty(node)) {\n      remove();\n    }\n  },\n\n  LookaroundAssertion({node, remove}) {\n    if (isQualifiedAndEmpty(node)) {\n      remove();\n    }\n  },\n\n  Quantifier({node, remove}) {\n    let kid = node.body;\n    while (kid.type === 'Quantifier') {\n      kid = kid.body;\n    }\n    if (isQualifiedAndEmpty(kid)) {\n      remove();\n    }\n  },\n};\n\nfunction hasOnlyEmptyAlts(node: AlternativeContainerNode): boolean {\n  return node.body.every(alt => !alt.body.length);\n}\n\nfunction isQualifiedAndEmpty(node: Node): boolean {\n  switch (node.type) {\n    case 'AbsenceFunction':\n      return node.kind === 'repeater' && hasOnlyEmptyAlts(node);\n    case 'Group':\n      return hasOnlyEmptyAlts(node);\n    case 'LookaroundAssertion':\n      return !node.negate && hasOnlyEmptyAlts(node);\n    default:\n      return false;\n  }\n}\n\nexport {\n  removeEmptyGroups,\n};\n"],
+  "mappings": "aAMA,MAAMA,EAA6B,CACjC,gBAAgB,CAAC,KAAAC,EAAM,OAAAC,CAAM,EAAG,CAC1BC,EAAoBF,CAAI,GAC1BC,EAAO,CAEX,EAEA,MAAM,CAAC,KAAAD,EAAM,OAAAC,CAAM,EAAG,CAChBC,EAAoBF,CAAI,GAC1BC,EAAO,CAEX,EAEA,oBAAoB,CAAC,KAAAD,EAAM,OAAAC,CAAM,EAAG,CAC9BC,EAAoBF,CAAI,GAC1BC,EAAO,CAEX,EAEA,WAAW,CAAC,KAAAD,EAAM,OAAAC,CAAM,EAAG,CACzB,IAAIE,EAAMH,EAAK,KACf,KAAOG,EAAI,OAAS,cAClBA,EAAMA,EAAI,KAERD,EAAoBC,CAAG,GACzBF,EAAO,CAEX,CACF,EAEA,SAASG,EAAiBJ,EAAyC,CACjE,OAAOA,EAAK,KAAK,MAAMK,GAAO,CAACA,EAAI,KAAK,MAAM,CAChD,CAEA,SAASH,EAAoBF,EAAqB,CAChD,OAAQA,EAAK,KAAM,CACjB,IAAK,kBACH,OAAOA,EAAK,OAAS,YAAcI,EAAiBJ,CAAI,EAC1D,IAAK,QACH,OAAOI,EAAiBJ,CAAI,EAC9B,IAAK,sBACH,MAAO,CAACA,EAAK,QAAUI,EAAiBJ,CAAI,EAC9C,QACE,MAAO,EACX,CACF,CAEA,OACED,KAAA",
+  "names": ["removeEmptyGroups", "node", "remove", "isQualifiedAndEmpty", "kid", "hasOnlyEmptyAlts", "alt"]
+}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/remove-useless-flags.d.ts

@@ -0,0 +1,7 @@
+import type { Visitor } from '../../traverser/traverse.js';
+/**
+Remove flags (from top-level and modifiers) that have no effect.
+*/
+declare const removeUselessFlags: Visitor;
+export { removeUselessFlags, };
+//# sourceMappingURL=remove-useless-flags.d.ts.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/remove-useless-flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-useless-flags.d.ts","sourceRoot":"","sources":["../../../src/optimizer/transforms/remove-useless-flags.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,6BAA6B,CAAC;AAEzD;;EAEE;AACF,QAAA,MAAM,kBAAkB,EAAE,OA6BzB,CAAC;AAyBF,OAAO,EACL,kBAAkB,GACnB,CAAC"}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/remove-useless-flags.js

@@ -0,0 +1,2 @@
+"use strict";const o={Flags({node:e}){e.extended=!1,e.textSegmentMode==="grapheme"&&(e.textSegmentMode=null)},Directive({node:e,remove:t}){e.kind==="flags"&&(i(e),r(e)&&t())},Group({node:e}){e.flags&&(i(e),r(e))}};function r(e){const{flags:t}=e;return t&&!t.enable&&!t.disable?(delete e.flags,!0):!1}function i({flags:e}){if(!e)throw new Error("Expected flags");e.enable&&delete e.enable.extended,e.disable&&delete e.disable.extended,l(e)}function l(e){e.enable&&!Object.keys(e.enable).length&&delete e.enable,e.disable&&!Object.keys(e.disable).length&&delete e.disable}export{o as removeUselessFlags};
+//# sourceMappingURL=remove-useless-flags.js.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/remove-useless-flags.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/optimizer/transforms/remove-useless-flags.ts"],
+  "sourcesContent": ["import type {DirectiveNode, GroupNode} from '../../parser/parse.js';\nimport type {FlagGroupModifiers} from '../../tokenizer/tokenize.js';\nimport type {Visitor} from '../../traverser/traverse.js';\n\n/**\nRemove flags (from top-level and modifiers) that have no effect.\n*/\nconst removeUselessFlags: Visitor = {\n  // TODO: Support removing additional flags\n\n  Flags({node}) {\n    // Effects of flag x are already applied during parsing\n    node.extended = false;\n    // Text segment handling uses grapheme mode by default, so it doesn't need to be set\n    if (node.textSegmentMode === 'grapheme') {\n      node.textSegmentMode = null;\n    }\n  },\n\n  Directive({node, remove}) {\n    if (node.kind !== 'flags') {\n      return;\n    }\n    removeFlagX(node);\n    if (removeEmptyFlagsObj(node)) {\n      remove();\n    }\n  },\n\n  Group({node}) {\n    if (!node.flags) {\n      return;\n    }\n    removeFlagX(node);\n    removeEmptyFlagsObj(node);\n  },\n};\n\nfunction removeEmptyFlagsObj(node: DirectiveNode | GroupNode): boolean {\n  const {flags} = node;\n  if (flags && !flags.enable && !flags.disable) {\n    delete node.flags;\n    return true;\n  }\n  return false;\n}\n\nfunction removeFlagX({flags}: DirectiveNode | GroupNode) {\n  if (!flags) {\n    throw new Error('Expected flags');\n  }\n  flags.enable && delete flags.enable.extended;\n  flags.disable && delete flags.disable.extended;\n  cleanupFlagsObj(flags);\n}\n\nfunction cleanupFlagsObj(flags: FlagGroupModifiers) {\n  flags.enable && !Object.keys(flags.enable).length && delete flags.enable;\n  flags.disable && !Object.keys(flags.disable).length && delete flags.disable;\n}\n\nexport {\n  removeUselessFlags,\n};\n"],
+  "mappings": "aAOA,MAAMA,EAA8B,CAGlC,MAAM,CAAC,KAAAC,CAAI,EAAG,CAEZA,EAAK,SAAW,GAEZA,EAAK,kBAAoB,aAC3BA,EAAK,gBAAkB,KAE3B,EAEA,UAAU,CAAC,KAAAA,EAAM,OAAAC,CAAM,EAAG,CACpBD,EAAK,OAAS,UAGlBE,EAAYF,CAAI,EACZG,EAAoBH,CAAI,GAC1BC,EAAO,EAEX,EAEA,MAAM,CAAC,KAAAD,CAAI,EAAG,CACPA,EAAK,QAGVE,EAAYF,CAAI,EAChBG,EAAoBH,CAAI,EAC1B,CACF,EAEA,SAASG,EAAoBH,EAA0C,CACrE,KAAM,CAAC,MAAAI,CAAK,EAAIJ,EAChB,OAAII,GAAS,CAACA,EAAM,QAAU,CAACA,EAAM,SACnC,OAAOJ,EAAK,MACL,IAEF,EACT,CAEA,SAASE,EAAY,CAAC,MAAAE,CAAK,EAA8B,CACvD,GAAI,CAACA,EACH,MAAM,IAAI,MAAM,gBAAgB,EAElCA,EAAM,QAAU,OAAOA,EAAM,OAAO,SACpCA,EAAM,SAAW,OAAOA,EAAM,QAAQ,SACtCC,EAAgBD,CAAK,CACvB,CAEA,SAASC,EAAgBD,EAA2B,CAClDA,EAAM,QAAU,CAAC,OAAO,KAAKA,EAAM,MAAM,EAAE,QAAU,OAAOA,EAAM,OAClEA,EAAM,SAAW,CAAC,OAAO,KAAKA,EAAM,OAAO,EAAE,QAAU,OAAOA,EAAM,OACtE,CAEA,OACEL,KAAA",
+  "names": ["removeUselessFlags", "node", "remove", "removeFlagX", "removeEmptyFlagsObj", "flags", "cleanupFlagsObj"]
+}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/simplify-callouts.d.ts

@@ -0,0 +1,7 @@
+import type { Visitor } from '../../traverser/traverse.js';
+/**
+Cleanup callout arguments, removing redundant commas, leading zeros, and empty braces.
+*/
+declare const simplifyCallouts: Visitor;
+export { simplifyCallouts, };
+//# sourceMappingURL=simplify-callouts.d.ts.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/simplify-callouts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simplify-callouts.d.ts","sourceRoot":"","sources":["../../../src/optimizer/transforms/simplify-callouts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,6BAA6B,CAAC;AAGzD;;EAEE;AACF,QAAA,MAAM,gBAAgB,EAAE,OAoBvB,CAAC;AAEF,OAAO,EACL,gBAAgB,GACjB,CAAC"}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/simplify-callouts.js

@@ -0,0 +1,2 @@
+"use strict";import{createLookaroundAssertion as o}from"../../parser/parse.js";const a={NamedCallout({node:r,replaceWith:i}){const{arguments:e,kind:n}=r;if(n==="fail"){i(o({negate:!0}));return}if(!e)return;const s=e.filter(t=>t!=="").map(t=>typeof t=="string"&&/^[+-]?\d+$/.test(t)?+t:t);r.arguments=s.length?s:null}};export{a as simplifyCallouts};
+//# sourceMappingURL=simplify-callouts.js.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/simplify-callouts.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/optimizer/transforms/simplify-callouts.ts"],
+  "sourcesContent": ["import type {Visitor} from '../../traverser/traverse.js';\nimport {createLookaroundAssertion} from '../../parser/parse.js';\n\n/**\nCleanup callout arguments, removing redundant commas, leading zeros, and empty braces.\n*/\nconst simplifyCallouts: Visitor = {\n  NamedCallout({node, replaceWith}) {\n    const {arguments: args, kind} = node;\n\n    // Special case: `(*FAIL)` -> `(?!)`\n    if (kind === 'fail') {\n      replaceWith(createLookaroundAssertion({negate: true}));\n      return;\n    }\n\n    if (!args) {\n      return;\n    }\n    const newArgs: Array<string | number> = args.\n      filter(arg => arg !== '').\n      // TODO: If supporting custom callout names in the future, add `kind !== 'custom'` to this\n      // condition, since custom named callouts might treat e.g. `+05` as a string\n      map(arg => (typeof arg === 'string' && /^[+-]?\\d+$/.test(arg)) ? +arg : arg);\n    node.arguments = newArgs.length ? newArgs : null;\n  },\n};\n\nexport {\n  simplifyCallouts,\n};\n"],
+  "mappings": "aACA,OAAQ,6BAAAA,MAAgC,wBAKxC,MAAMC,EAA4B,CAChC,aAAa,CAAC,KAAAC,EAAM,YAAAC,CAAW,EAAG,CAChC,KAAM,CAAC,UAAWC,EAAM,KAAAC,CAAI,EAAIH,EAGhC,GAAIG,IAAS,OAAQ,CACnBF,EAAYH,EAA0B,CAAC,OAAQ,EAAI,CAAC,CAAC,EACrD,MACF,CAEA,GAAI,CAACI,EACH,OAEF,MAAME,EAAkCF,EACtC,OAAOG,GAAOA,IAAQ,EAAE,EAGxB,IAAIA,GAAQ,OAAOA,GAAQ,UAAY,aAAa,KAAKA,CAAG,EAAK,CAACA,EAAMA,CAAG,EAC7EL,EAAK,UAAYI,EAAQ,OAASA,EAAU,IAC9C,CACF,EAEA,OACEL,KAAA",
+  "names": ["createLookaroundAssertion", "simplifyCallouts", "node", "replaceWith", "args", "kind", "newArgs", "arg"]
+}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/unnest-useless-classes.d.ts

@@ -0,0 +1,8 @@
+import type { Visitor } from '../../traverser/traverse.js';
+/**
+Unnest character classes when possible.
+See also `unwrapNegationWrappers`.
+*/
+declare const unnestUselessClasses: Visitor;
+export { unnestUselessClasses, };
+//# sourceMappingURL=unnest-useless-classes.d.ts.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/unnest-useless-classes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unnest-useless-classes.d.ts","sourceRoot":"","sources":["../../../src/optimizer/transforms/unnest-useless-classes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,6BAA6B,CAAC;AAGzD;;;EAGE;AACF,QAAA,MAAM,oBAAoB,EAAE,OAsC3B,CAAC;AAEF,OAAO,EACL,oBAAoB,GACrB,CAAC"}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/unnest-useless-classes.js

@@ -0,0 +1,2 @@
+"use strict";import{hasOnlyChild as i}from"../../parser/node-utils.js";const f={CharacterClass({node:s,parent:r,replaceWith:n,replaceWithMultiple:t}){const{body:e,kind:o,negate:a}=s;if(r.type!=="CharacterClass"||o!=="union"||!e.length)return;const C=e[0];if(i(r,{type:"CharacterClass",kind:"union"})){r.negate=r.negate!==a,t(e,{traverse:!0});return}a||(r.kind==="union"?t(e,{traverse:!0}):i(s)&&n(C,{traverse:!0}))}};export{f as unnestUselessClasses};
+//# sourceMappingURL=unnest-useless-classes.js.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/unnest-useless-classes.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/optimizer/transforms/unnest-useless-classes.ts"],
+  "sourcesContent": ["import type {CharacterClassNode} from '../../parser/parse.js';\nimport type {Visitor} from '../../traverser/traverse.js';\nimport {hasOnlyChild} from '../../parser/node-utils.js';\n\n/**\nUnnest character classes when possible.\nSee also `unwrapNegationWrappers`.\n*/\nconst unnestUselessClasses: Visitor = {\n  CharacterClass({node, parent, replaceWith, replaceWithMultiple}) {\n    const {body, kind, negate} = node;\n    if (\n      // Don't use this to unwrap outermost classes; see `unwrapUselessClasses` for that\n      parent.type !== 'CharacterClass' ||\n      kind !== 'union' ||\n      !body.length\n    ) {\n      return;\n    }\n    const firstEl = body[0];\n    // Special case to unnest classes that are an only-kid of their parent, since it might flip\n    // `negate` on the parent; ex:\n    // `[[a]]` -> `[a]`; `[[^a]]` -> `[^a]`; `[^[a]]` -> `[^a]`; `[^[^a]]` -> `[a]`\n    if (hasOnlyChild(parent, {\n      type: 'CharacterClass',\n      kind: 'union',\n    })) {\n      parent.negate = parent.negate !== negate;\n      replaceWithMultiple(body, {traverse: true});\n      return;\n    }\n    // Remainder of options apply only if the class is non-negated\n    if (negate) {\n      return;\n    }\n    // Unnest all kids into a union class\n    if (parent.kind === 'union') {\n      replaceWithMultiple(body, {traverse: true});\n    // Can unnest any one kid into an intersection class\n    // TODO: After supporting `format` for classes (see <github.com/slevithan/oniguruma-parser/issues/1>),\n    // can visually unnest any number of kids into intersection by flipping this class's `format`\n    // from `'explicit'` to `'implicit'`, rather than replacing it\n    } else if (hasOnlyChild(node)) {\n      replaceWith(firstEl, {traverse: true});\n    }\n  },\n};\n\nexport {\n  unnestUselessClasses,\n};\n"],
+  "mappings": "aAEA,OAAQ,gBAAAA,MAAmB,6BAM3B,MAAMC,EAAgC,CACpC,eAAe,CAAC,KAAAC,EAAM,OAAAC,EAAQ,YAAAC,EAAa,oBAAAC,CAAmB,EAAG,CAC/D,KAAM,CAAC,KAAAC,EAAM,KAAAC,EAAM,OAAAC,CAAM,EAAIN,EAC7B,GAEEC,EAAO,OAAS,kBAChBI,IAAS,SACT,CAACD,EAAK,OAEN,OAEF,MAAMG,EAAUH,EAAK,CAAC,EAItB,GAAIN,EAAaG,EAAQ,CACvB,KAAM,iBACN,KAAM,OACR,CAAC,EAAG,CACFA,EAAO,OAASA,EAAO,SAAWK,EAClCH,EAAoBC,EAAM,CAAC,SAAU,EAAI,CAAC,EAC1C,MACF,CAEIE,IAIAL,EAAO,OAAS,QAClBE,EAAoBC,EAAM,CAAC,SAAU,EAAI,CAAC,EAKjCN,EAAaE,CAAI,GAC1BE,EAAYK,EAAS,CAAC,SAAU,EAAI,CAAC,EAEzC,CACF,EAEA,OACER,KAAA",
+  "names": ["hasOnlyChild", "unnestUselessClasses", "node", "parent", "replaceWith", "replaceWithMultiple", "body", "kind", "negate", "firstEl"]
+}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/unwrap-negation-wrappers.d.ts

@@ -0,0 +1,9 @@
+import type { Visitor } from '../../traverser/traverse.js';
+/**
+Unwrap negated classes used to negate an individual character set.
+Allows independently controlling this behavior, and avoids logic duplication in
+`unwrapUselessClasses` and `unnestUselessClasses`.
+*/
+declare const unwrapNegationWrappers: Visitor;
+export { unwrapNegationWrappers, };
+//# sourceMappingURL=unwrap-negation-wrappers.d.ts.map

package/node_modules/oniguruma-parser/dist/optimizer/transforms/unwrap-negation-wrappers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unwrap-negation-wrappers.d.ts","sourceRoot":"","sources":["../../../src/optimizer/transforms/unwrap-negation-wrappers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,6BAA6B,CAAC;AAGzD;;;;EAIE;AACF,QAAA,MAAM,sBAAsB,EAAE,OA0B7B,CAAC;AAEF,OAAO,EACL,sBAAsB,GACvB,CAAC"}

package/node_modules/oniguruma-parser/dist/optimizer/transforms/unwrap-negation-wrappers.js

@@ -0,0 +1,2 @@
+"use strict";import{createCharacterSet as o}from"../../parser/parse.js";const c={CharacterClass({node:i,parent:t,replaceWith:r}){const{body:a,kind:n,negate:s}=i;if(!s||n!=="union"||a.length!==1)return;const e=a[0];if(e.type==="CharacterSet")e.negate=!e.negate,r(e);else if(t.type!=="CharacterClass"&&e.type==="Character"&&e.value===10){if(t.type==="Quantifier"&&t.kind!=="lazy")return;r(o("newline",{negate:!0}))}}};export{c as unwrapNegationWrappers};
+//# sourceMappingURL=unwrap-negation-wrappers.js.map