playwright-smart-test 0.0.0-stage → 1.0.1

package/node_modules/@isaacs/nonrecursive-glob-match/dist/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { type Form, parseClass } from './parse-class.js'\n\nexport type { Form }\n\nexport type MatcherOptions = {\n  /** perform a case-insensitive match */\n  nocase?: boolean\n  /** do not treat strings starting with `.` specially */\n  dot?: boolean\n  /** do not match extglobs (treat them as normal strings) */\n  noext?: boolean\n  /**\n   * normalize unicode in the pattern and the tested strings, with\n   * this form. `true` means `'NFC'`.\n   */\n  normalize?: boolean | Form\n}\n\n// parsed pattern items\nexport type Item =\n  | { t: 'lit'; ch: string }\n  | { t: 'any' | 'star' }\n  | { t: 'class'; re: RegExp }\n  | { t: 'ext'; type: string; alts: Item[][] }\n\n// extglob syntax tokens become literals if they are not part of a\n// closed extglob\nexport type Token =\n  Item | { t: 'open'; type: string } | { t: 'bar' } | { t: 'close' }\n\n// state machine nodes\nexport type NegNode = { t: 'neg'; id: number; sub: Node; next: Node }\nexport type SplitNode = { t: 'split'; id: number; out: Node[] }\nexport type Node =\n  | ({ t: 'lit'; id: number; next: Node } & Lit)\n  | { t: 'any' | 'star'; id: number; next: Node }\n  | { t: 'class'; id: number; re: RegExp; next: Node }\n  | SplitNode\n  | NegNode\n  | { t: 'match'; id: number }\n\n// the end of the pattern, or of a negated sub-pattern\nconst MATCH: Node = { t: 'match', id: 0 }\n\nconst extTypes = '!?+*@'\n\nconst lit = (ch: string): Item => ({ t: 'lit', ch })\n\nconst reEscape = (s: string) => s.replace(/[\\\\^$.*+?()[\\]{}|/]/g, '\\\\$&')\n\n// a RegExp that only matches `s`, with unicode case folding\nconst newFoldRe = (s: string) => new RegExp(`^${reEscape(s)}$`, 'iu')\n\n// foldRe for one literal char. The same chars are in most patterns,\n// so keep them. A RegExp without the `g` or `y` flag has no state to\n// share.\nconst foldCache = new Map<string, RegExp>()\nconst foldRe = (ch: string) => {\n  let re = foldCache.get(ch)\n  if (!re) {\n    re = newFoldRe(ch)\n    if (foldCache.size >= 1000) foldCache.clear()\n    foldCache.set(ch, re)\n  }\n  return re\n}\n\n/**\n * A literal char. With `nocase:true`, `re` folds case, and `ascii`\n * holds its results for ASCII chars, by char code: 1 for a match,\n * and 2 for not.\n */\nexport type Lit = { ch: string; re?: RegExp; ascii?: Uint8Array }\n\nconst litMatch = (l: Lit, c: string) => {\n  if (c === l.ch) return true\n  if (!l.re) return false\n  const code = c.charCodeAt(0)\n  if (code >= 128) return l.re.test(c)\n  const ascii = (l.ascii ??= new Uint8Array(128))\n  ascii[code] ||= l.re.test(c) ? 1 : 2\n  return ascii[code] === 1\n}\n\nconst tokenize = (\n  p: string,\n  nocase: boolean,\n  noext: boolean,\n  form?: Form,\n) => {\n  const toks: Token[] = []\n  for (let i = 0; i < p.length;) {\n    const c = String.fromCodePoint(p.codePointAt(i)!)\n    if (c === '\\\\') {\n      // a trailing \\ is a literal \\\n      const e = p.codePointAt(i + 1)\n      const ch = e === undefined ? c : String.fromCodePoint(e)\n      toks.push(lit(ch))\n      i += 1 + ch.length\n      continue\n    }\n    if (c === '[') {\n      const [re, consumed] = parseClass(p, i, nocase, form)\n      if (consumed) {\n        toks.push({ t: 'class', re })\n        i += consumed\n        continue\n      }\n    }\n    if (!noext && extTypes.includes(c) && p[i + 1] === '(') {\n      toks.push({ t: 'open', type: c })\n      i += 2\n      continue\n    }\n    toks.push(\n      !noext && c === '|' ? { t: 'bar' }\n      : !noext && c === ')' ? { t: 'close' }\n      : c === '*' ? { t: 'star' }\n      : c === '?' ? { t: 'any' }\n      : lit(c),\n    )\n    i += c.length\n  }\n  return toks\n}\n\n// map each open token index to the index of its close token\nconst pair = (toks: Token[]) => {\n  const pairs = new Map<number, number>()\n  const stack: number[] = []\n  toks.forEach((tok, i) => {\n    if (tok.t === 'open') stack.push(i)\n    else if (tok.t === 'close' && stack.length) pairs.set(stack.pop()!, i)\n  })\n  return pairs\n}\n\n// build the alternatives between start and end. An open token that\n// is not closed is never inside a closed extglob, so bar and close\n// tokens are only literal at the top level.\nconst build = (\n  toks: Token[],\n  pairs: Map<number, number>,\n  start: number,\n  end: number,\n  top: boolean,\n): Item[][] => {\n  let seq: Item[] = []\n  const alts = [seq]\n  for (let i = start; i < end; i++) {\n    const tok = toks[i]!\n    const close = pairs.get(i)\n    if (tok.t === 'open' && close !== undefined) {\n      const sub = build(toks, pairs, i + 1, close, false)\n      seq.push({ t: 'ext', type: tok.type, alts: sub })\n      i = close\n    } else if (tok.t === 'bar' && !top) {\n      alts.push((seq = []))\n    } else if (tok.t === 'open') {\n      seq.push(lit(tok.type), lit('('))\n    } else if (tok.t === 'bar') {\n      seq.push(lit('|'))\n    } else if (tok.t === 'close') {\n      seq.push(lit(')'))\n    } else {\n      seq.push(tok)\n    }\n  }\n  return alts\n}\n\n// normalize each run of literal chars as one string, so that a char\n// and the combining marks after it compose (or decompose) together.\n// Syntax is already parsed, so a char that normalizes to a syntax\n// char (such as full-width `＊` in NFKC) stays a literal.\nconst normalize = (items: Item[], form: Form): Item[] => {\n  const out: Item[] = []\n  let run = ''\n  const flush = () => {\n    for (const ch of run.normalize(form)) out.push(lit(ch))\n    run = ''\n  }\n  for (const it of items) {\n    if (it.t === 'lit') {\n      run += it.ch\n      continue\n    }\n    flush()\n    out.push(\n      it.t === 'ext' ?\n        { ...it, alts: it.alts.map(a => normalize(a, form)) }\n      : it,\n    )\n  }\n  flush()\n  return out\n}\n\n// the start node, and the number of node ids. Ids are dense, from 0\n// for the match node.\nconst compile = (\n  items: Item[],\n  nocase: boolean,\n): [start: Node, size: number] => {\n  let id = 1\n  const split = (out: Node[]): SplitNode => ({ t: 'split', id: id++, out })\n  const seq = (items: Item[], next: Node): Node =>\n    items.reduceRight((next, it) => item(it, next), next)\n  const item = (it: Item, next: Node): Node => {\n    switch (it.t) {\n      case 'lit':\n        const re = nocase ? foldRe(it.ch) : undefined\n        return { t: 'lit', id: id++, ch: it.ch, re, next }\n      case 'any':\n      case 'star':\n        return { t: it.t, id: id++, next }\n      case 'class':\n        return { t: 'class', id: id++, re: it.re, next }\n    }\n    const alts = (next: Node) => it.alts.map(a => seq(a, next))\n    switch (it.type) {\n      case '@':\n        return split(alts(next))\n      case '?':\n        return split([next, ...alts(next)])\n      case '!':\n        return { t: 'neg', id: id++, sub: split(alts(MATCH)), next }\n    }\n    // * and +, loop back after each match\n    const after = split([])\n    const entry = split(alts(after))\n    after.out.push(next, entry)\n    return it.type === '*' ? after : entry\n  }\n  const start = seq(items, MATCH)\n  return [start, id]\n}\n\n// one line per node, in the order that a walk from the start\n// reaches them. Edges point to node ids. The nodes of a negated\n// sub-pattern are indented under their negation.\nconst show = (start: Node): string => {\n  const lines: string[] = []\n  const seen = new Set<Node>()\n  const ref = (n: Node) => (n.t === 'match' ? 'match' : String(n.id))\n  const walk = (n: Node, indent: string) => {\n    if (n.t === 'match' || seen.has(n)) return\n    seen.add(n)\n    const line = (desc: string) => lines.push(`${indent}${n.id}: ${desc}`)\n    switch (n.t) {\n      case 'split':\n        line(`split -> ${n.out.map(ref).join(', ')}`)\n        for (const o of n.out) walk(o, indent)\n        return\n      case 'neg':\n        line(`!(${ref(n.sub)}) -> ${ref(n.next)}`)\n        walk(n.sub, indent + '  ')\n        return walk(n.next, indent)\n      case 'lit':\n        line(`${JSON.stringify(n.ch)} -> ${ref(n.next)}`)\n        break\n      case 'class':\n        line(`${n.re} -> ${ref(n.next)}`)\n        break\n      default:\n        line(`${n.t === 'any' ? '?' : '*'} -> ${ref(n.next)}`)\n    }\n    walk(n.next, indent)\n  }\n  walk(start, '')\n  return [`start -> ${ref(start)}`, ...lines].join('\\n')\n}\n\n// A thread inside a !(...) negation. It holds the threads of the\n// negated sub-pattern, started where the negation started. The\n// negation matches the chars so far if the sub-pattern does not.\ntype Run = { t: 'run'; neg: NegNode; state: State }\n\n// The threads at one position in the string. Each node thread is\n// only kept once, and runs with the same state are only kept once,\n// so that identical threads merge. The match node is not in\n// `threads`, because it can not step. It sets `match` instead.\nclass State {\n  // set by the Sim, to mark the nodes that this state has\n  gen: number\n  threads: Node[] = []\n  match = false\n  runs: Run[] = []\n  // the sorted ids of the threads, with 0 for a match, once the\n  // state is done\n  ids: number[] = []\n\n  constructor(gen: number) {\n    this.gen = gen\n  }\n\n  // no threads, so nothing more can match\n  get dead() {\n    return !this.threads.length && !this.match && !this.runs.length\n  }\n}\n\n// true if the two states hold the same threads\nconst sameState = (a: State, b: State): boolean => {\n  if (a.ids.length !== b.ids.length) return false\n  if (a.runs.length !== b.runs.length) return false\n  if (a.ids.some((id, i) => id !== b.ids[i])) return false\n  return a.runs.every(r =>\n    b.runs.some(o => o.neg === r.neg && sameState(o.state, r.state)),\n  )\n}\n\n/**\n * For each node id, the gen of the last state that has the node as\n * a thread, and of the last state that walked through it. A state is\n * built to the end before the states around it go on, and the nodes\n * of a negated sub-pattern are only in its states (other than the\n * match node, which is never marked). So one mark for each node is\n * enough to know if the state being built has it. The Sims of a\n * matcher never run at the same time, so they share one Marks.\n */\nexport type Marks = { has: Float64Array; seen: Float64Array; gen: number }\n\nconst marks = (size: number): Marks => ({\n  has: new Float64Array(size),\n  seen: new Float64Array(size),\n  gen: 0,\n})\n\nclass Sim {\n  // `.` and `..` only match literal dots, even with `dot:true`\n  dots: boolean\n  // the string starts with `.`, and `dot:true` is not set\n  dotStart: boolean\n  #marks: Marks\n\n  constructor(dots: boolean, dotStart: boolean, marks: Marks) {\n    this.dots = dots\n    this.dotStart = dotStart\n    this.#marks = marks\n  }\n\n  state() {\n    return new State(++this.#marks.gen)\n  }\n\n  // sort the ids of a state, once it has all of its threads\n  done(state: State) {\n    state.ids = state.threads.map(n => n.id).sort((a, b) => a - b)\n    if (state.match) state.ids.unshift(MATCH.id)\n    return state\n  }\n\n  // true the first time that the state walks through the node, so\n  // that loops in the graph stop\n  #visit(state: State, node: Node) {\n    const { seen } = this.#marks\n    if (seen[node.id] === state.gen) return false\n    seen[node.id] = state.gen\n    return true\n  }\n\n  #addThread(state: State, node: Node) {\n    const { has } = this.#marks\n    if (has[node.id] === state.gen) return false\n    has[node.id] = state.gen\n    state.threads.push(node)\n    return true\n  }\n\n  // wildcards only match a leading dot if `dot:true`. In a negated\n  // sub-pattern, this does not apply, because the negation itself\n  // can not match a leading dot.\n  restricted(i: number, top: boolean) {\n    return top && (this.dots || (this.dotStart && i === 0))\n  }\n\n  add(state: State, node: Node, i: number, top: boolean): void {\n    switch (node.t) {\n      case 'split':\n        if (!this.#visit(state, node)) return\n        for (const o of node.out) this.add(state, o, i, top)\n        return\n      case 'neg':\n        if (!this.#visit(state, node)) return\n        const sub = this.state()\n        this.add(sub, node.sub, i, false)\n        this.done(sub)\n        return this.addRun(\n          state,\n          { t: 'run', neg: node, state: sub },\n          i,\n          top,\n        )\n      case 'star':\n        // a * can not start a dotfile, even if it matches nothing\n        if (this.restricted(i, top)) return\n        if (this.#addThread(state, node))\n          this.add(state, node.next, i, top)\n        return\n      case 'match':\n        state.match = true\n        return\n      default:\n        this.#addThread(state, node)\n    }\n  }\n\n  addRun(state: State, run: Run, i: number, top: boolean) {\n    for (const r of state.runs) {\n      if (r.neg === run.neg && sameState(r.state, run.state)) return\n    }\n    state.runs.push(run)\n    if (!run.state.match) {\n      this.add(state, run.neg.next, i, top)\n    }\n  }\n\n  // the threads after char `c`, at index `i`\n  step(state: State, c: string, i: number, top: boolean): State {\n    const next = this.state()\n    for (const th of state.threads) {\n      switch (th.t) {\n        case 'lit':\n          if (litMatch(th, c)) {\n            this.add(next, th.next, i + 1, top)\n          }\n          break\n        case 'any':\n          if (!this.restricted(i, top)) this.add(next, th.next, i + 1, top)\n          break\n        case 'class':\n          if (!this.restricted(i, top) && th.re.test(c)) {\n            this.add(next, th.next, i + 1, top)\n          }\n          break\n        case 'star':\n          if (!this.restricted(i, top)) this.add(next, th, i + 1, top)\n      }\n    }\n    if (!this.restricted(i, top)) {\n      for (const run of state.runs) {\n        // a sub-pattern with no threads can not match again, so the\n        // run stays the same\n        if (run.state.dead) {\n          this.addRun(next, run, i + 1, top)\n          continue\n        }\n        const sub = this.step(run.state, c, i, false)\n        this.addRun(\n          next,\n          { t: 'run', neg: run.neg, state: sub },\n          i + 1,\n          top,\n        )\n      }\n    }\n    return this.done(next)\n  }\n}\n\n// A canonical key for the threads in a state. States with the same\n// key hold the same threads, so they match the same strings.\nconst stateKey = (state: State): string => {\n  const ids = state.ids.join()\n  if (!state.runs.length) return ids\n  const runs = state.runs.map(r => `${r.neg.id}(${stateKey(r.state)})`)\n  return `${ids}|${runs.sort().join('|')}`\n}\n\n// A cached state of the simulation, and the states that each char\n// leads to.\ntype DState = {\n  state: State\n  match: boolean\n  // no threads, so nothing more can match\n  dead: boolean\n  // the next state for each ASCII char, by char code, and for the\n  // other chars\n  ascii?: (DState | undefined)[]\n  next: Map<string, DState>\n}\n\n// The cache can hold about this many chars of state keys and\n// transitions. When it is full, it is cleared, so that a pattern\n// can not use an unbounded amount of memory.\nconst DFA_BUDGET = 1 << 18\n\n// A cache of the states that the simulation reaches, built as the\n// matcher is used. Each char of a string is then one Map lookup,\n// once the states that it leads to are known.\n//\n// The dot rules only restrict the first char of a dotfile (strings\n// that are only `.` or `..` do not use the cache). So a dotfile\n// starts at its own state, which takes its first step with the\n// restriction, and every other state takes steps without it.\nclass Dfa {\n  #start: Node\n  #states = new Map<string, DState>()\n  #size = 0\n  #plain?: DState\n  #dotStart?: DState\n  #sim: Sim\n  #dotSim: Sim\n\n  constructor(start: Node, marks: Marks) {\n    this.#start = start\n    this.#sim = new Sim(false, false, marks)\n    this.#dotSim = new Sim(false, true, marks)\n  }\n\n  #make(state: State): DState {\n    return {\n      state,\n      match: state.match,\n      dead: state.dead,\n      next: new Map(),\n    }\n  }\n\n  #intern(state: State): DState {\n    const key = stateKey(state)\n    const found = this.#states.get(key)\n    if (found) return found\n    if (this.#size > DFA_BUDGET) this.#clear()\n    const d = this.#make(state)\n    this.#states.set(key, d)\n    this.#size += key.length + 1\n    return d\n  }\n\n  #clear() {\n    this.#states.clear()\n    this.#size = 0\n    this.#plain = undefined\n    this.#dotStart = undefined\n  }\n\n  start(dotStart: boolean): DState {\n    if (dotStart) {\n      if (this.#dotStart) return this.#dotStart\n      const state = this.#dotSim.state()\n      this.#dotSim.add(state, this.#start, 0, true)\n      return (this.#dotStart = this.#make(this.#dotSim.done(state)))\n    }\n    if (this.#plain) return this.#plain\n    const state = this.#sim.state()\n    this.#sim.add(state, this.#start, 0, true)\n    return (this.#plain = this.#intern(this.#sim.done(state)))\n  }\n\n  // the next state, after a miss in `d.ascii`\n  next(d: DState, c: string): DState {\n    const code = c.charCodeAt(0)\n    const found = code < 128 ? undefined : d.next.get(c)\n    if (found) return found\n    // the dotfile start is not in the cache, so it is never shared\n    const n =\n      d === this.#dotStart ?\n        this.#intern(this.#dotSim.step(d.state, c, 0, true))\n      : this.#intern(this.#sim.step(d.state, c, 1, true))\n    if (code < 128) {\n      if (!d.ascii) {\n        d.ascii = new Array(128)\n        this.#size += 128\n      }\n      d.ascii[code] = n\n    } else {\n      d.next.set(c, n)\n    }\n    this.#size++\n    return n\n  }\n}\n\n/**\n * A node in a graph with no splits or negations. Such a graph is a\n * chain of nodes that each match one char, or a `*`.\n */\nexport type LinearNode = Exclude<\n  Node,\n  SplitNode | NegNode | { t: 'match' }\n>\n\n// the nodes in order, if the graph is a single chain\nconst linear = (start: Node): LinearNode[] | undefined => {\n  const nodes: LinearNode[] = []\n  for (let n = start; n.t !== 'match'; n = n.next) {\n    if (n.t === 'split' || n.t === 'neg') return undefined\n    nodes.push(n)\n  }\n  return nodes\n}\n\n// Match a chain of nodes. Each node other than `*` matches exactly\n// one char, so on a failure it is enough to go back to the last `*`\n// and let it match one more char. This takes at most\n// nodes.length * chars.length steps.\nconst testLinear = (\n  nodes: LinearNode[],\n  chars: ArrayLike<string>,\n  start: number,\n  end: number,\n) => {\n  let ni = 0\n  let ci = start\n  let starNi = -1\n  let starCi = 0\n  while (ci < end) {\n    const n = nodes[ni]\n    if (n?.t === 'star') {\n      starNi = ni++\n      starCi = ci\n      continue\n    }\n    const c = chars[ci]!\n    if (\n      n &&\n      (n.t === 'any' ||\n        (n.t === 'lit' && litMatch(n, c)) ||\n        (n.t === 'class' && n.re.test(c)))\n    ) {\n      ni++\n      ci++\n      continue\n    }\n    if (starNi === -1) return false\n    ni = starNi + 1\n    ci = ++starCi\n  }\n  while (nodes[ni]?.t === 'star') ni++\n  return ni === nodes.length\n}\n\n// The least and most chars that the items can match. These are only\n// bounds: a negation can match a string of any length, so it counts\n// as 0 to Infinity.\nconst lengths = (items: Item[]): [min: number, max: number] => {\n  let min = 0\n  let max = 0\n  for (const it of items) {\n    const [lo, hi] = itemLengths(it)\n    min += lo\n    max += hi\n  }\n  return [min, max]\n}\n\nconst itemLengths = (it: Item): [min: number, max: number] => {\n  if (it.t === 'star') return [0, Infinity]\n  if (it.t !== 'ext') return [1, 1]\n  if (it.type === '!') return [0, Infinity]\n  const alts = it.alts.map(lengths)\n  const min = Math.min(...alts.map(a => a[0]))\n  const max = Math.max(...alts.map(a => a[1]))\n  // a loop of alternatives that only match the empty string is empty\n  const loop = max === 0 ? 0 : Infinity\n  return (\n    it.type === '@' ? [min, max]\n    : it.type === '?' ? [0, max]\n    : it.type === '*' ? [0, loop]\n    : [min, loop]\n  )\n}\n\n// true if the chars from `start` match the literals\nconst hasAffix = (\n  lits: Lit[],\n  chars: ArrayLike<string>,\n  start: number,\n) => {\n  for (let j = 0; j < lits.length; j++) {\n    if (!litMatch(lits[j]!, chars[start + j]!)) return false\n  }\n  return true\n}\n\n// a `/`, or half of a surrogate pair\nconst slashOrSurrogate = /[/\\ud800-\\udfff]/\nconst surrogate = /[\\ud800-\\udfff]/\n\n// a string can be indexed by code point, unless it has surrogate\n// pairs\nconst codePoints = (s: string): ArrayLike<string> =>\n  surrogate.test(s) ? [...s] : s\n\nconst noSlash = (s: string) => {\n  if (s.includes('/')) {\n    throw new Error('can only match a single path portion, got: ' + s)\n  }\n}\n\nexport class Matcher {\n  pattern: string\n  options: MatcherOptions\n  #start: Node\n  // the number of node ids\n  #size: number\n  #marks?: Marks\n  // the Sim for strings that are only `.` or `..`\n  #dotsSim?: Sim\n  // the string to compare, if the pattern has no magic. With\n  // `nocase:true`, the RegExp that folds case is made when it is\n  // first used.\n  #literal?: string\n  #literalFold = false\n  #literalRe?: RegExp\n  // the nodes between the prefix and suffix, if the graph is a\n  // single chain\n  #linear?: LinearNode[]\n  // the linear nodes are only `*` and `?`, so the length bounds and\n  // the prefix and suffix decide the match\n  #wild = false\n  // the least and most chars that a match can have\n  #min = 0\n  #max = Infinity\n  // the literals that a match must start and end with. Each one\n  // matches exactly one char, and they are distinct items in the\n  // pattern, so a string that does not have them can not match.\n  #prefix: Lit[] = []\n  #suffix: Lit[] = []\n  // the prefix and suffix as strings, if they do not fold case\n  #prefixStr?: string\n  #suffixStr?: string\n  // there is a prefix or suffix to check\n  #affix = false\n  #dfa?: Dfa\n  #form?: Form\n\n  constructor(pattern: string, options: MatcherOptions = {}) {\n    if (pattern.includes('/')) {\n      throw new Error(\n        'can only match a single path portion, got pattern: ' + pattern,\n      )\n    }\n    this.pattern = pattern\n    this.options = options\n    const { nocase = false, noext = false, normalize: n } = options\n    this.#form = n === true ? 'NFC' : n || undefined\n    // a pattern that is only an empty extglob is a literal string,\n    // except for `!()`, which matches any non-empty string\n    const literal = /^[?*+@]\\(\\)$/.test(pattern)\n    const toks = tokenize(pattern, nocase, noext || literal, this.#form)\n    let [items] = build(toks, pair(toks), 0, toks.length, true)\n    if (this.#form) items = normalize(items!, this.#form)\n    const [start, size] = compile(items!, nocase)\n    this.#start = start\n    this.#size = size\n    if (items!.every(it => it.t === 'lit')) {\n      this.#literal = items!.map(it => it.ch).join('')\n      this.#literalFold = nocase\n    } else {\n      const lit = (it: Item): Lit | undefined =>\n        it.t !== 'lit' ? undefined\n        : nocase ? { ch: it.ch, re: foldRe(it.ch) }\n        : { ch: it.ch }\n      for (const it of items!) {\n        const l = lit(it)\n        if (!l) break\n        this.#prefix.push(l)\n      }\n      for (let j = items!.length - 1; j >= 0; j--) {\n        const l = lit(items![j]!)\n        if (!l) break\n        this.#suffix.unshift(l)\n      }\n      this.#affix = !!(this.#prefix.length || this.#suffix.length)\n      if (!nocase) {\n        this.#prefixStr = this.#prefix.map(l => l.ch).join('')\n        this.#suffixStr = this.#suffix.map(l => l.ch).join('')\n      }\n      this.#linear = linear(this.#start)?.slice(\n        this.#prefix.length,\n        -this.#suffix.length || undefined,\n      )\n      this.#wild = !!this.#linear?.every(\n        n => n.t === 'star' || n.t === 'any',\n      )\n      const [min, max] = lengths(items!)\n      this.#min = min\n      this.#max = max\n    }\n  }\n\n  test(s: string): boolean {\n    // The `/` check uses the string as given, so with normalization it\n    // is a separate step. Otherwise, one scan finds both a `/` and the\n    // surrogate pairs that stop the string being indexed by code point.\n    if (this.#form) {\n      noSlash(s)\n      return this.#test(s.normalize(this.#form))\n    }\n    if (slashOrSurrogate.test(s)) {\n      noSlash(s)\n      return this.#test(s, [...s])\n    }\n    return this.#test(s, s)\n  }\n\n  /**\n   * The same as {@link Matcher#test}, but the string is not checked\n   * for `/` chars, so the result for a string that has one is not\n   * defined. Only use it for a string that is known to be one path\n   * portion, such as a part of a path that was split on `/`. It can\n   * be faster, because some patterns do not need to look at each char\n   * of the string.\n   */\n  testUnchecked(s: string): boolean {\n    return this.#test(this.#form ? s.normalize(this.#form) : s)\n  }\n\n  // Test a string that has no `/`. `chars` indexes it by code point.\n  // If it is not given, it is only found if a step needs it.\n  #test(s: string, chars?: ArrayLike<string>): boolean {\n    if (this.#literal !== undefined) {\n      return this.#literalFold ?\n          (this.#literalRe ??= newFoldRe(this.#literal)).test(s)\n        : s === this.#literal\n    }\n    // the length check means that the prefix and suffix do not\n    // overlap. Without the chars, the length in code points is from\n    // half of the UTF-16 length (if each one is a surrogate pair) to\n    // all of it, which is often enough to know.\n    const min = this.#min\n    const max = this.#max\n    if (chars === undefined) {\n      const most = s.length\n      const least = (most + 1) >> 1\n      if (most < min || least > max) return false\n      if (least < min || most > max) chars = codePoints(s)\n    }\n    if (\n      chars !== undefined &&\n      (chars.length < min || chars.length > max)\n    ) {\n      return false\n    }\n    const prefix = this.#prefix.length\n    if (this.#affix) {\n      if (this.#prefixStr !== undefined && this.#suffixStr !== undefined) {\n        if (\n          !s.startsWith(this.#prefixStr) ||\n          !s.endsWith(this.#suffixStr)\n        ) {\n          return false\n        }\n      } else {\n        chars ??= codePoints(s)\n        const end = chars.length - this.#suffix.length\n        if (\n          !hasAffix(this.#prefix, chars, 0) ||\n          !hasAffix(this.#suffix, chars, end)\n        ) {\n          return false\n        }\n      }\n    }\n    const dotStart = !this.options.dot && s.startsWith('.')\n    if (this.#linear) {\n      // `.` and `..` only match literal dots, even with `dot:true`\n      if (s === '.' || s === '..') return false\n      // only a literal can match the leading dot. A `*` can not\n      // start a dotfile, even if it matches nothing.\n      if (dotStart && !prefix) return false\n      if (this.#wild) return true\n      chars ??= codePoints(s)\n      const end = chars.length - this.#suffix.length\n      return testLinear(this.#linear, chars, prefix, end)\n    }\n    chars ??= codePoints(s)\n    if (s === '.' || s === '..') {\n      this.#marks ??= marks(this.#size)\n      const sim = (this.#dotsSim ??= new Sim(true, false, this.#marks))\n      const start = sim.state()\n      sim.add(start, this.#start, 0, true)\n      let state = sim.done(start)\n      for (let i = 0; i < chars.length; i++) {\n        state = sim.step(state, chars[i]!, i, true)\n      }\n      return state.match\n    }\n    this.#marks ??= marks(this.#size)\n    const dfa = (this.#dfa ??= new Dfa(this.#start, this.#marks))\n    let d = dfa.start(dotStart)\n    // read char codes from the string, so that a one-char string is\n    // only made for a cache miss\n    const str = chars === s\n    for (let i = 0; i < chars.length; i++) {\n      if (d.dead) return false\n      const code = str ? s.charCodeAt(i) : chars[i]!.charCodeAt(0)\n      d = d.ascii?.[code] ?? dfa.next(d, chars[i]!)\n    }\n    return d.match\n  }\n\n  /** a readable listing of the state machine */\n  toString(): string {\n    return show(this.#start)\n  }\n}\n"]}

package/node_modules/@isaacs/nonrecursive-glob-match/dist/commonjs/index.min.js

@@ -0,0 +1,3 @@
+"use strict";var D=(i,t)=>()=>{try{return t||i((t={exports:{}}).exports,t),t.exports}catch(e){throw t=0,e}};var E=D(S=>{"use strict";Object.defineProperty(S,"__esModule",{value:!0});S.parseClass=void 0;var G={"[:alnum:]":["\\p{L}\\p{Nl}\\p{Nd}"],"[:alpha:]":["\\p{L}\\p{Nl}"],"[:ascii:]":["\\x00-\\x7f"],"[:blank:]":["\\p{Zs}\\t"],"[:cntrl:]":["\\p{Cc}"],"[:digit:]":["\\p{Nd}"],"[:graph:]":["\\p{Z}\\p{C}",!0],"[:lower:]":["\\p{Ll}"],"[:print:]":["\\p{C}",!0],"[:punct:]":["\\p{P}\\p{S}"],"[:space:]":["\\p{Z}\\t\\r\\n\\v\\f"],"[:upper:]":["\\p{Lu}"],"[:word:]":["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}"],"[:xdigit:]":["A-Fa-f0-9"]},x=i=>i.replace(/[[\]\\-]/g,"\\$&"),A=/$./,H=(i,t,e=!1,s)=>{let h=p=>{let m=s?p.normalize(s):p;return[...m].length===1?m:p},n=t;if(i.charAt(n)!=="[")throw new Error("not in a brace expression");let o=[],a=[],r=n+1,l=!1,c=!1,u=!1,g=n,d="";t:for(;r<i.length;){let p=String.fromCodePoint(i.codePointAt(r));if((p==="!"||p==="^")&&r===n+1){u=!0,r++;continue}if(p==="]"&&l&&!c){g=r+1;break}if(l=!0,p==="\\"&&!c){c=!0,r++;continue}if(p==="["&&!c){for(let[R,[v,B]]of Object.entries(G))if(i.startsWith(R,r)){if(d)return[A,i.length-n];r+=R.length,B?a.push(v):o.push(v);continue t}}c=!1;let m=h(p);if(d){m.codePointAt(0)>d.codePointAt(0)?o.push(x(d)+"-"+x(m)):m===d&&o.push(x(m)),d="",r+=p.length;continue}if(i.startsWith("-]",r+p.length)){o.push(x(m+"-")),r+=p.length+1;continue}if(i.startsWith("-",r+p.length)){d=m,r+=p.length+1;continue}o.push(x(m)),r+=p.length}if(g<r)return[A,0];if(!o.length&&!a.length)return[A,i.length-n];let f="["+(u?"^":"")+o.join("")+"]",w="["+(u?"":"^")+a.join("")+"]",Z="^"+(o.length&&a.length?"("+f+"|"+w+")":o.length?f:w);return[new RegExp(Z,e?"iu":"u"),g-n]};S.parseClass=H});Object.defineProperty(exports,"__esModule",{value:!0});exports.Matcher=void 0;var J=E(),b={t:"match",id:0},K="!?+*@",y=i=>({t:"lit",ch:i}),Q=i=>i.replace(/[\\^$.*+?()[\]{}|/]/g,"\\$&"),L=i=>new RegExp(`^${Q(i)}$`,"iu"),C=new Map,W=i=>{let t=C.get(i);return t||(t=L(i),C.size>=1e3&&C.clear(),C.set(i,t)),t},z=(i,t)=>{if(t===i.ch)return!0;if(!i.re)return!1;let e=t.charCodeAt(0);if(e>=128)return i.re.test(t);let s=i.ascii??=new Uint8Array(128);return s[e]||=i.re.test(t)?1:2,s[e]===1},V=(i,t,e,s)=>{let h=[];for(let n=0;n<i.length;){let o=String.fromCodePoint(i.codePointAt(n));if(o==="\\"){let a=i.codePointAt(n+1),r=a===void 0?o:String.fromCodePoint(a);h.push(y(r)),n+=1+r.length;continue}if(o==="["){let[a,r]=(0,J.parseClass)(i,n,t,s);if(r){h.push({t:"class",re:a}),n+=r;continue}}if(!e&&K.includes(o)&&i[n+1]==="("){h.push({t:"open",type:o}),n+=2;continue}h.push(!e&&o==="|"?{t:"bar"}:!e&&o===")"?{t:"close"}:o==="*"?{t:"star"}:o==="?"?{t:"any"}:y(o)),n+=o.length}return h},X=i=>{let t=new Map,e=[];return i.forEach((s,h)=>{s.t==="open"?e.push(h):s.t==="close"&&e.length&&t.set(e.pop(),h)}),t},O=(i,t,e,s,h)=>{let n=[],o=[n];for(let a=e;a<s;a++){let r=i[a],l=t.get(a);if(r.t==="open"&&l!==void 0){let c=O(i,t,a+1,l,!1);n.push({t:"ext",type:r.type,alts:c}),a=l}else r.t==="bar"&&!h?o.push(n=[]):r.t==="open"?n.push(y(r.type),y("(")):r.t==="bar"?n.push(y("|")):r.t==="close"?n.push(y(")")):n.push(r)}return o},I=(i,t)=>{let e=[],s="",h=()=>{for(let n of s.normalize(t))e.push(y(n));s=""};for(let n of i){if(n.t==="lit"){s+=n.ch;continue}h(),e.push(n.t==="ext"?{...n,alts:n.alts.map(o=>I(o,t))}:n)}return h(),e},Y=(i,t)=>{let e=1,s=a=>({t:"split",id:e++,out:a}),h=(a,r)=>a.reduceRight((l,c)=>n(c,l),r),n=(a,r)=>{switch(a.t){case"lit":let g=t?W(a.ch):void 0;return{t:"lit",id:e++,ch:a.ch,re:g,next:r};case"any":case"star":return{t:a.t,id:e++,next:r};case"class":return{t:"class",id:e++,re:a.re,next:r}}let l=g=>a.alts.map(d=>h(d,g));switch(a.type){case"@":return s(l(r));case"?":return s([r,...l(r)]);case"!":return{t:"neg",id:e++,sub:s(l(b)),next:r}}let c=s([]),u=s(l(c));return c.out.push(r,u),a.type==="*"?c:u};return[h(i,b),e]},tt=i=>{let t=[],e=new Set,s=n=>n.t==="match"?"match":String(n.id),h=(n,o)=>{if(n.t==="match"||e.has(n))return;e.add(n);let a=r=>t.push(`${o}${n.id}: ${r}`);switch(n.t){case"split":a(`split -> ${n.out.map(s).join(", ")}`);for(let r of n.out)h(r,o);return;case"neg":return a(`!(${s(n.sub)}) -> ${s(n.next)}`),h(n.sub,o+"  "),h(n.next,o);case"lit":a(`${JSON.stringify(n.ch)} -> ${s(n.next)}`);break;case"class":a(`${n.re} -> ${s(n.next)}`);break;default:a(`${n.t==="any"?"?":"*"} -> ${s(n.next)}`)}h(n.next,o)};return h(i,""),[`start -> ${s(i)}`,...t].join(`
+`)},j=class{gen;threads=[];match=!1;runs=[];ids=[];constructor(t){this.gen=t}get dead(){return!this.threads.length&&!this.match&&!this.runs.length}},T=(i,t)=>i.ids.length!==t.ids.length||i.runs.length!==t.runs.length||i.ids.some((e,s)=>e!==t.ids[s])?!1:i.runs.every(e=>t.runs.some(s=>s.neg===e.neg&&T(s.state,e.state))),N=i=>({has:new Float64Array(i),seen:new Float64Array(i),gen:0}),$=class{dots;dotStart;#t;constructor(t,e,s){this.dots=t,this.dotStart=e,this.#t=s}state(){return new j(++this.#t.gen)}done(t){return t.ids=t.threads.map(e=>e.id).sort((e,s)=>e-s),t.match&&t.ids.unshift(b.id),t}#s(t,e){let{seen:s}=this.#t;return s[e.id]===t.gen?!1:(s[e.id]=t.gen,!0)}#e(t,e){let{has:s}=this.#t;return s[e.id]===t.gen?!1:(s[e.id]=t.gen,t.threads.push(e),!0)}restricted(t,e){return e&&(this.dots||this.dotStart&&t===0)}add(t,e,s,h){switch(e.t){case"split":if(!this.#s(t,e))return;for(let o of e.out)this.add(t,o,s,h);return;case"neg":if(!this.#s(t,e))return;let n=this.state();return this.add(n,e.sub,s,!1),this.done(n),this.addRun(t,{t:"run",neg:e,state:n},s,h);case"star":if(this.restricted(s,h))return;this.#e(t,e)&&this.add(t,e.next,s,h);return;case"match":t.match=!0;return;default:this.#e(t,e)}}addRun(t,e,s,h){for(let n of t.runs)if(n.neg===e.neg&&T(n.state,e.state))return;t.runs.push(e),e.state.match||this.add(t,e.neg.next,s,h)}step(t,e,s,h){let n=this.state();for(let o of t.threads)switch(o.t){case"lit":z(o,e)&&this.add(n,o.next,s+1,h);break;case"any":this.restricted(s,h)||this.add(n,o.next,s+1,h);break;case"class":!this.restricted(s,h)&&o.re.test(e)&&this.add(n,o.next,s+1,h);break;case"star":this.restricted(s,h)||this.add(n,o,s+1,h)}if(!this.restricted(s,h))for(let o of t.runs){if(o.state.dead){this.addRun(n,o,s+1,h);continue}let a=this.step(o.state,e,s,!1);this.addRun(n,{t:"run",neg:o.neg,state:a},s+1,h)}return this.done(n)}},q=i=>{let t=i.ids.join();if(!i.runs.length)return t;let e=i.runs.map(s=>`${s.neg.id}(${q(s.state)})`);return`${t}|${e.sort().join("|")}`},et=1<<18,P=class{#t;#s=new Map;#e=0;#c;#n;#i;#h;constructor(t,e){this.#t=t,this.#i=new $(!1,!1,e),this.#h=new $(!1,!0,e)}#o(t){return{state:t,match:t.match,dead:t.dead,next:new Map}}#u(t){let e=q(t),s=this.#s.get(e);if(s)return s;this.#e>et&&this.#f();let h=this.#o(t);return this.#s.set(e,h),this.#e+=e.length+1,h}#f(){this.#s.clear(),this.#e=0,this.#c=void 0,this.#n=void 0}start(t){if(t){if(this.#n)return this.#n;let s=this.#h.state();return this.#h.add(s,this.#t,0,!0),this.#n=this.#o(this.#h.done(s))}if(this.#c)return this.#c;let e=this.#i.state();return this.#i.add(e,this.#t,0,!0),this.#c=this.#u(this.#i.done(e))}next(t,e){let s=e.charCodeAt(0),h=s<128?void 0:t.next.get(e);if(h)return h;let n=t===this.#n?this.#u(this.#h.step(t.state,e,0,!0)):this.#u(this.#i.step(t.state,e,1,!0));return s<128?(t.ascii||(t.ascii=new Array(128),this.#e+=128),t.ascii[s]=n):t.next.set(e,n),this.#e++,n}},st=i=>{let t=[];for(let e=i;e.t!=="match";e=e.next){if(e.t==="split"||e.t==="neg")return;t.push(e)}return t},nt=(i,t,e,s)=>{let h=0,n=e,o=-1,a=0;for(;n<s;){let r=i[h];if(r?.t==="star"){o=h++,a=n;continue}let l=t[n];if(r&&(r.t==="any"||r.t==="lit"&&z(r,l)||r.t==="class"&&r.re.test(l))){h++,n++;continue}if(o===-1)return!1;h=o+1,n=++a}for(;i[h]?.t==="star";)h++;return h===i.length},U=i=>{let t=0,e=0;for(let s of i){let[h,n]=it(s);t+=h,e+=n}return[t,e]},it=i=>{if(i.t==="star")return[0,1/0];if(i.t!=="ext")return[1,1];if(i.type==="!")return[0,1/0];let t=i.alts.map(U),e=Math.min(...t.map(n=>n[0])),s=Math.max(...t.map(n=>n[1])),h=s===0?0:1/0;return i.type==="@"?[e,s]:i.type==="?"?[0,s]:i.type==="*"?[0,h]:[e,h]},_=(i,t,e)=>{for(let s=0;s<i.length;s++)if(!z(i[s],t[e+s]))return!1;return!0},rt=/[/\ud800-\udfff]/,ht=/[\ud800-\udfff]/,k=i=>ht.test(i)?[...i]:i,F=i=>{if(i.includes("/"))throw new Error("can only match a single path portion, got: "+i)},M=class{pattern;options;#t;#s;#e;#c;#n;#i=!1;#h;#o;#u=!1;#f=0;#m=1/0;#l=[];#a=[];#p;#g;#w=!1;#y;#r;constructor(t,e={}){if(t.includes("/"))throw new Error("can only match a single path portion, got pattern: "+t);this.pattern=t,this.options=e;let{nocase:s=!1,noext:h=!1,normalize:n}=e;this.#r=n===!0?"NFC":n||void 0;let o=/^[?*+@]\(\)$/.test(t),a=V(t,s,h||o,this.#r),[r]=O(a,X(a),0,a.length,!0);this.#r&&(r=I(r,this.#r));let[l,c]=Y(r,s);if(this.#t=l,this.#s=c,r.every(u=>u.t==="lit"))this.#n=r.map(u=>u.ch).join(""),this.#i=s;else{let u=f=>f.t!=="lit"?void 0:s?{ch:f.ch,re:W(f.ch)}:{ch:f.ch};for(let f of r){let w=u(f);if(!w)break;this.#l.push(w)}for(let f=r.length-1;f>=0;f--){let w=u(r[f]);if(!w)break;this.#a.unshift(w)}this.#w=!!(this.#l.length||this.#a.length),s||(this.#p=this.#l.map(f=>f.ch).join(""),this.#g=this.#a.map(f=>f.ch).join("")),this.#o=st(this.#t)?.slice(this.#l.length,-this.#a.length||void 0),this.#u=!!this.#o?.every(f=>f.t==="star"||f.t==="any");let[g,d]=U(r);this.#f=g,this.#m=d}}test(t){return this.#r?(F(t),this.#d(t.normalize(this.#r))):rt.test(t)?(F(t),this.#d(t,[...t])):this.#d(t,t)}testUnchecked(t){return this.#d(this.#r?t.normalize(this.#r):t)}#d(t,e){if(this.#n!==void 0)return this.#i?(this.#h??=L(this.#n)).test(t):t===this.#n;let s=this.#f,h=this.#m;if(e===void 0){let c=t.length,u=c+1>>1;if(c<s||u>h)return!1;(u<s||c>h)&&(e=k(t))}if(e!==void 0&&(e.length<s||e.length>h))return!1;let n=this.#l.length;if(this.#w)if(this.#p!==void 0&&this.#g!==void 0){if(!t.startsWith(this.#p)||!t.endsWith(this.#g))return!1}else{e??=k(t);let c=e.length-this.#a.length;if(!_(this.#l,e,0)||!_(this.#a,e,c))return!1}let o=!this.options.dot&&t.startsWith(".");if(this.#o){if(t==="."||t===".."||o&&!n)return!1;if(this.#u)return!0;e??=k(t);let c=e.length-this.#a.length;return nt(this.#o,e,n,c)}if(e??=k(t),t==="."||t===".."){this.#e??=N(this.#s);let c=this.#c??=new $(!0,!1,this.#e),u=c.state();c.add(u,this.#t,0,!0);let g=c.done(u);for(let d=0;d<e.length;d++)g=c.step(g,e[d],d,!0);return g.match}this.#e??=N(this.#s);let a=this.#y??=new P(this.#t,this.#e),r=a.start(o),l=e===t;for(let c=0;c<e.length;c++){if(r.dead)return!1;let u=l?t.charCodeAt(c):e[c].charCodeAt(0);r=r.ascii?.[u]??a.next(r,e[c])}return r.match}toString(){return tt(this.#t)}};exports.Matcher=M;
+//# sourceMappingURL=index.min.js.map

package/node_modules/@isaacs/nonrecursive-glob-match/dist/commonjs/index.min.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/parse-class.ts", "../../src/index.ts"],
+  "sourcesContent": ["// translate the various posix character classes into unicode properties\n// this works across all unicode locales\n\n// { <posix class>: [<translation>, negated]\nconst posixClasses: { [k: string]: [e: string, n?: boolean] } = {\n  '[:alnum:]': ['\\\\p{L}\\\\p{Nl}\\\\p{Nd}'],\n  '[:alpha:]': ['\\\\p{L}\\\\p{Nl}'],\n  '[:ascii:]': ['\\\\x' + '00-\\\\x' + '7f'],\n  '[:blank:]': ['\\\\p{Zs}\\\\t'],\n  '[:cntrl:]': ['\\\\p{Cc}'],\n  '[:digit:]': ['\\\\p{Nd}'],\n  '[:graph:]': ['\\\\p{Z}\\\\p{C}', true],\n  '[:lower:]': ['\\\\p{Ll}'],\n  '[:print:]': ['\\\\p{C}', true],\n  '[:punct:]': ['\\\\p{P}\\\\p{S}'],\n  '[:space:]': ['\\\\p{Z}\\\\t\\\\r\\\\n\\\\v\\\\f'],\n  '[:upper:]': ['\\\\p{Lu}'],\n  '[:word:]': ['\\\\p{L}\\\\p{Nl}\\\\p{Nd}\\\\p{Pc}'],\n  '[:xdigit:]': ['A-Fa-f0-9'],\n}\n\n// only need to escape a few things inside of brace expressions\n// escapes: [ \\ ] -\nconst braceEscape = (s: string) => s.replace(/[[\\]\\\\-]/g, '\\\\$&')\n\nexport type ParseClassResult = [re: RegExp, consumed: number]\n\nexport type Form = 'NFC' | 'NFD' | 'NFKC' | 'NFKD'\n\nconst noMatch = /$./\n\n// Takes a glob string at a posix brace expression. Returns a RegExp\n// that tests one character, and the number of glob chars consumed.\n// If the class is not closed, consumed is 0, and the `[` must be\n// treated as a literal character.\n// Out of order ranges are removed. If nothing is left, the RegExp\n// is `/$./`, and the rest of the glob is consumed, so that the\n// whole glob cannot match.\nexport const parseClass = (\n  glob: string,\n  position: number,\n  nocase: boolean = false,\n  form?: Form,\n): ParseClassResult => {\n  // normalize one class member, if it stays one code point\n  const norm = (c: string) => {\n    const n = form ? c.normalize(form) : c\n    return [...n].length === 1 ? n : c\n  }\n  const pos = position\n  /* c8 ignore start */\n  if (glob.charAt(pos) !== '[') {\n    throw new Error('not in a brace expression')\n  }\n  /* c8 ignore stop */\n  const ranges: string[] = []\n  const negs: string[] = []\n\n  let i = pos + 1\n  let sawStart = false\n  let escaping = false\n  let negate = false\n  let endPos = pos\n  let rangeStart = ''\n  WHILE: while (i < glob.length) {\n    const c = String.fromCodePoint(glob.codePointAt(i)!)\n    if ((c === '!' || c === '^') && i === pos + 1) {\n      negate = true\n      i++\n      continue\n    }\n\n    if (c === ']' && sawStart && !escaping) {\n      endPos = i + 1\n      break\n    }\n\n    sawStart = true\n    if (c === '\\\\') {\n      if (!escaping) {\n        escaping = true\n        i++\n        continue\n      }\n      // escaped \\ char, fall through and treat like normal char\n    }\n    if (c === '[' && !escaping) {\n      // either a posix class, a collation equivalent, or just a [\n      for (const [cls, [unip, neg]] of Object.entries(posixClasses)) {\n        if (glob.startsWith(cls, i)) {\n          // invalid, [a-[] is fine, but not [a-[:alpha]]\n          if (rangeStart) {\n            return [noMatch, glob.length - pos]\n          }\n          i += cls.length\n          if (neg) negs.push(unip)\n          else ranges.push(unip)\n          continue WHILE\n        }\n      }\n    }\n\n    // now it's just a normal character, effectively\n    escaping = false\n    const n = norm(c)\n    if (rangeStart) {\n      // throw this range away if it's not valid, but others\n      // can still match.\n      if (n.codePointAt(0)! > rangeStart.codePointAt(0)!) {\n        ranges.push(braceEscape(rangeStart) + '-' + braceEscape(n))\n      } else if (n === rangeStart) {\n        ranges.push(braceEscape(n))\n      }\n      rangeStart = ''\n      i += c.length\n      continue\n    }\n\n    // now might be the start of a range.\n    // can be either c-d or c-] or c<more...>] or c] at this point\n    if (glob.startsWith('-]', i + c.length)) {\n      ranges.push(braceEscape(n + '-'))\n      i += c.length + 1\n      continue\n    }\n    if (glob.startsWith('-', i + c.length)) {\n      rangeStart = n\n      i += c.length + 1\n      continue\n    }\n\n    // not the start of a range, just a single character\n    ranges.push(braceEscape(n))\n    i += c.length\n  }\n\n  if (endPos < i) {\n    // didn't see the end of the class, not a valid class,\n    // but might still be valid as a literal match.\n    return [noMatch, 0]\n  }\n\n  // if we got no ranges and no negates, then we have a range that\n  // cannot possibly match anything, and that poisons the whole glob\n  if (!ranges.length && !negs.length) {\n    return [noMatch, glob.length - pos]\n  }\n\n  const sranges = '[' + (negate ? '^' : '') + ranges.join('') + ']'\n  const snegs = '[' + (negate ? '' : '^') + negs.join('') + ']'\n  const comb =\n    '^' +\n    (ranges.length && negs.length ? '(' + sranges + '|' + snegs + ')'\n    : ranges.length ? sranges\n    : snegs)\n\n  return [new RegExp(comb, nocase ? 'iu' : 'u'), endPos - pos]\n}\n", "import { type Form, parseClass } from './parse-class.js'\n\nexport type { Form }\n\nexport type MatcherOptions = {\n  /** perform a case-insensitive match */\n  nocase?: boolean\n  /** do not treat strings starting with `.` specially */\n  dot?: boolean\n  /** do not match extglobs (treat them as normal strings) */\n  noext?: boolean\n  /**\n   * normalize unicode in the pattern and the tested strings, with\n   * this form. `true` means `'NFC'`.\n   */\n  normalize?: boolean | Form\n}\n\n// parsed pattern items\nexport type Item =\n  | { t: 'lit'; ch: string }\n  | { t: 'any' | 'star' }\n  | { t: 'class'; re: RegExp }\n  | { t: 'ext'; type: string; alts: Item[][] }\n\n// extglob syntax tokens become literals if they are not part of a\n// closed extglob\nexport type Token =\n  Item | { t: 'open'; type: string } | { t: 'bar' } | { t: 'close' }\n\n// state machine nodes\nexport type NegNode = { t: 'neg'; id: number; sub: Node; next: Node }\nexport type SplitNode = { t: 'split'; id: number; out: Node[] }\nexport type Node =\n  | ({ t: 'lit'; id: number; next: Node } & Lit)\n  | { t: 'any' | 'star'; id: number; next: Node }\n  | { t: 'class'; id: number; re: RegExp; next: Node }\n  | SplitNode\n  | NegNode\n  | { t: 'match'; id: number }\n\n// the end of the pattern, or of a negated sub-pattern\nconst MATCH: Node = { t: 'match', id: 0 }\n\nconst extTypes = '!?+*@'\n\nconst lit = (ch: string): Item => ({ t: 'lit', ch })\n\nconst reEscape = (s: string) => s.replace(/[\\\\^$.*+?()[\\]{}|/]/g, '\\\\$&')\n\n// a RegExp that only matches `s`, with unicode case folding\nconst newFoldRe = (s: string) => new RegExp(`^${reEscape(s)}$`, 'iu')\n\n// foldRe for one literal char. The same chars are in most patterns,\n// so keep them. A RegExp without the `g` or `y` flag has no state to\n// share.\nconst foldCache = new Map<string, RegExp>()\nconst foldRe = (ch: string) => {\n  let re = foldCache.get(ch)\n  if (!re) {\n    re = newFoldRe(ch)\n    if (foldCache.size >= 1000) foldCache.clear()\n    foldCache.set(ch, re)\n  }\n  return re\n}\n\n/**\n * A literal char. With `nocase:true`, `re` folds case, and `ascii`\n * holds its results for ASCII chars, by char code: 1 for a match,\n * and 2 for not.\n */\nexport type Lit = { ch: string; re?: RegExp; ascii?: Uint8Array }\n\nconst litMatch = (l: Lit, c: string) => {\n  if (c === l.ch) return true\n  if (!l.re) return false\n  const code = c.charCodeAt(0)\n  if (code >= 128) return l.re.test(c)\n  const ascii = (l.ascii ??= new Uint8Array(128))\n  ascii[code] ||= l.re.test(c) ? 1 : 2\n  return ascii[code] === 1\n}\n\nconst tokenize = (\n  p: string,\n  nocase: boolean,\n  noext: boolean,\n  form?: Form,\n) => {\n  const toks: Token[] = []\n  for (let i = 0; i < p.length;) {\n    const c = String.fromCodePoint(p.codePointAt(i)!)\n    if (c === '\\\\') {\n      // a trailing \\ is a literal \\\n      const e = p.codePointAt(i + 1)\n      const ch = e === undefined ? c : String.fromCodePoint(e)\n      toks.push(lit(ch))\n      i += 1 + ch.length\n      continue\n    }\n    if (c === '[') {\n      const [re, consumed] = parseClass(p, i, nocase, form)\n      if (consumed) {\n        toks.push({ t: 'class', re })\n        i += consumed\n        continue\n      }\n    }\n    if (!noext && extTypes.includes(c) && p[i + 1] === '(') {\n      toks.push({ t: 'open', type: c })\n      i += 2\n      continue\n    }\n    toks.push(\n      !noext && c === '|' ? { t: 'bar' }\n      : !noext && c === ')' ? { t: 'close' }\n      : c === '*' ? { t: 'star' }\n      : c === '?' ? { t: 'any' }\n      : lit(c),\n    )\n    i += c.length\n  }\n  return toks\n}\n\n// map each open token index to the index of its close token\nconst pair = (toks: Token[]) => {\n  const pairs = new Map<number, number>()\n  const stack: number[] = []\n  toks.forEach((tok, i) => {\n    if (tok.t === 'open') stack.push(i)\n    else if (tok.t === 'close' && stack.length) pairs.set(stack.pop()!, i)\n  })\n  return pairs\n}\n\n// build the alternatives between start and end. An open token that\n// is not closed is never inside a closed extglob, so bar and close\n// tokens are only literal at the top level.\nconst build = (\n  toks: Token[],\n  pairs: Map<number, number>,\n  start: number,\n  end: number,\n  top: boolean,\n): Item[][] => {\n  let seq: Item[] = []\n  const alts = [seq]\n  for (let i = start; i < end; i++) {\n    const tok = toks[i]!\n    const close = pairs.get(i)\n    if (tok.t === 'open' && close !== undefined) {\n      const sub = build(toks, pairs, i + 1, close, false)\n      seq.push({ t: 'ext', type: tok.type, alts: sub })\n      i = close\n    } else if (tok.t === 'bar' && !top) {\n      alts.push((seq = []))\n    } else if (tok.t === 'open') {\n      seq.push(lit(tok.type), lit('('))\n    } else if (tok.t === 'bar') {\n      seq.push(lit('|'))\n    } else if (tok.t === 'close') {\n      seq.push(lit(')'))\n    } else {\n      seq.push(tok)\n    }\n  }\n  return alts\n}\n\n// normalize each run of literal chars as one string, so that a char\n// and the combining marks after it compose (or decompose) together.\n// Syntax is already parsed, so a char that normalizes to a syntax\n// char (such as full-width `＊` in NFKC) stays a literal.\nconst normalize = (items: Item[], form: Form): Item[] => {\n  const out: Item[] = []\n  let run = ''\n  const flush = () => {\n    for (const ch of run.normalize(form)) out.push(lit(ch))\n    run = ''\n  }\n  for (const it of items) {\n    if (it.t === 'lit') {\n      run += it.ch\n      continue\n    }\n    flush()\n    out.push(\n      it.t === 'ext' ?\n        { ...it, alts: it.alts.map(a => normalize(a, form)) }\n      : it,\n    )\n  }\n  flush()\n  return out\n}\n\n// the start node, and the number of node ids. Ids are dense, from 0\n// for the match node.\nconst compile = (\n  items: Item[],\n  nocase: boolean,\n): [start: Node, size: number] => {\n  let id = 1\n  const split = (out: Node[]): SplitNode => ({ t: 'split', id: id++, out })\n  const seq = (items: Item[], next: Node): Node =>\n    items.reduceRight((next, it) => item(it, next), next)\n  const item = (it: Item, next: Node): Node => {\n    switch (it.t) {\n      case 'lit':\n        const re = nocase ? foldRe(it.ch) : undefined\n        return { t: 'lit', id: id++, ch: it.ch, re, next }\n      case 'any':\n      case 'star':\n        return { t: it.t, id: id++, next }\n      case 'class':\n        return { t: 'class', id: id++, re: it.re, next }\n    }\n    const alts = (next: Node) => it.alts.map(a => seq(a, next))\n    switch (it.type) {\n      case '@':\n        return split(alts(next))\n      case '?':\n        return split([next, ...alts(next)])\n      case '!':\n        return { t: 'neg', id: id++, sub: split(alts(MATCH)), next }\n    }\n    // * and +, loop back after each match\n    const after = split([])\n    const entry = split(alts(after))\n    after.out.push(next, entry)\n    return it.type === '*' ? after : entry\n  }\n  const start = seq(items, MATCH)\n  return [start, id]\n}\n\n// one line per node, in the order that a walk from the start\n// reaches them. Edges point to node ids. The nodes of a negated\n// sub-pattern are indented under their negation.\nconst show = (start: Node): string => {\n  const lines: string[] = []\n  const seen = new Set<Node>()\n  const ref = (n: Node) => (n.t === 'match' ? 'match' : String(n.id))\n  const walk = (n: Node, indent: string) => {\n    if (n.t === 'match' || seen.has(n)) return\n    seen.add(n)\n    const line = (desc: string) => lines.push(`${indent}${n.id}: ${desc}`)\n    switch (n.t) {\n      case 'split':\n        line(`split -> ${n.out.map(ref).join(', ')}`)\n        for (const o of n.out) walk(o, indent)\n        return\n      case 'neg':\n        line(`!(${ref(n.sub)}) -> ${ref(n.next)}`)\n        walk(n.sub, indent + '  ')\n        return walk(n.next, indent)\n      case 'lit':\n        line(`${JSON.stringify(n.ch)} -> ${ref(n.next)}`)\n        break\n      case 'class':\n        line(`${n.re} -> ${ref(n.next)}`)\n        break\n      default:\n        line(`${n.t === 'any' ? '?' : '*'} -> ${ref(n.next)}`)\n    }\n    walk(n.next, indent)\n  }\n  walk(start, '')\n  return [`start -> ${ref(start)}`, ...lines].join('\\n')\n}\n\n// A thread inside a !(...) negation. It holds the threads of the\n// negated sub-pattern, started where the negation started. The\n// negation matches the chars so far if the sub-pattern does not.\ntype Run = { t: 'run'; neg: NegNode; state: State }\n\n// The threads at one position in the string. Each node thread is\n// only kept once, and runs with the same state are only kept once,\n// so that identical threads merge. The match node is not in\n// `threads`, because it can not step. It sets `match` instead.\nclass State {\n  // set by the Sim, to mark the nodes that this state has\n  gen: number\n  threads: Node[] = []\n  match = false\n  runs: Run[] = []\n  // the sorted ids of the threads, with 0 for a match, once the\n  // state is done\n  ids: number[] = []\n\n  constructor(gen: number) {\n    this.gen = gen\n  }\n\n  // no threads, so nothing more can match\n  get dead() {\n    return !this.threads.length && !this.match && !this.runs.length\n  }\n}\n\n// true if the two states hold the same threads\nconst sameState = (a: State, b: State): boolean => {\n  if (a.ids.length !== b.ids.length) return false\n  if (a.runs.length !== b.runs.length) return false\n  if (a.ids.some((id, i) => id !== b.ids[i])) return false\n  return a.runs.every(r =>\n    b.runs.some(o => o.neg === r.neg && sameState(o.state, r.state)),\n  )\n}\n\n/**\n * For each node id, the gen of the last state that has the node as\n * a thread, and of the last state that walked through it. A state is\n * built to the end before the states around it go on, and the nodes\n * of a negated sub-pattern are only in its states (other than the\n * match node, which is never marked). So one mark for each node is\n * enough to know if the state being built has it. The Sims of a\n * matcher never run at the same time, so they share one Marks.\n */\nexport type Marks = { has: Float64Array; seen: Float64Array; gen: number }\n\nconst marks = (size: number): Marks => ({\n  has: new Float64Array(size),\n  seen: new Float64Array(size),\n  gen: 0,\n})\n\nclass Sim {\n  // `.` and `..` only match literal dots, even with `dot:true`\n  dots: boolean\n  // the string starts with `.`, and `dot:true` is not set\n  dotStart: boolean\n  #marks: Marks\n\n  constructor(dots: boolean, dotStart: boolean, marks: Marks) {\n    this.dots = dots\n    this.dotStart = dotStart\n    this.#marks = marks\n  }\n\n  state() {\n    return new State(++this.#marks.gen)\n  }\n\n  // sort the ids of a state, once it has all of its threads\n  done(state: State) {\n    state.ids = state.threads.map(n => n.id).sort((a, b) => a - b)\n    if (state.match) state.ids.unshift(MATCH.id)\n    return state\n  }\n\n  // true the first time that the state walks through the node, so\n  // that loops in the graph stop\n  #visit(state: State, node: Node) {\n    const { seen } = this.#marks\n    if (seen[node.id] === state.gen) return false\n    seen[node.id] = state.gen\n    return true\n  }\n\n  #addThread(state: State, node: Node) {\n    const { has } = this.#marks\n    if (has[node.id] === state.gen) return false\n    has[node.id] = state.gen\n    state.threads.push(node)\n    return true\n  }\n\n  // wildcards only match a leading dot if `dot:true`. In a negated\n  // sub-pattern, this does not apply, because the negation itself\n  // can not match a leading dot.\n  restricted(i: number, top: boolean) {\n    return top && (this.dots || (this.dotStart && i === 0))\n  }\n\n  add(state: State, node: Node, i: number, top: boolean): void {\n    switch (node.t) {\n      case 'split':\n        if (!this.#visit(state, node)) return\n        for (const o of node.out) this.add(state, o, i, top)\n        return\n      case 'neg':\n        if (!this.#visit(state, node)) return\n        const sub = this.state()\n        this.add(sub, node.sub, i, false)\n        this.done(sub)\n        return this.addRun(\n          state,\n          { t: 'run', neg: node, state: sub },\n          i,\n          top,\n        )\n      case 'star':\n        // a * can not start a dotfile, even if it matches nothing\n        if (this.restricted(i, top)) return\n        if (this.#addThread(state, node))\n          this.add(state, node.next, i, top)\n        return\n      case 'match':\n        state.match = true\n        return\n      default:\n        this.#addThread(state, node)\n    }\n  }\n\n  addRun(state: State, run: Run, i: number, top: boolean) {\n    for (const r of state.runs) {\n      if (r.neg === run.neg && sameState(r.state, run.state)) return\n    }\n    state.runs.push(run)\n    if (!run.state.match) {\n      this.add(state, run.neg.next, i, top)\n    }\n  }\n\n  // the threads after char `c`, at index `i`\n  step(state: State, c: string, i: number, top: boolean): State {\n    const next = this.state()\n    for (const th of state.threads) {\n      switch (th.t) {\n        case 'lit':\n          if (litMatch(th, c)) {\n            this.add(next, th.next, i + 1, top)\n          }\n          break\n        case 'any':\n          if (!this.restricted(i, top)) this.add(next, th.next, i + 1, top)\n          break\n        case 'class':\n          if (!this.restricted(i, top) && th.re.test(c)) {\n            this.add(next, th.next, i + 1, top)\n          }\n          break\n        case 'star':\n          if (!this.restricted(i, top)) this.add(next, th, i + 1, top)\n      }\n    }\n    if (!this.restricted(i, top)) {\n      for (const run of state.runs) {\n        // a sub-pattern with no threads can not match again, so the\n        // run stays the same\n        if (run.state.dead) {\n          this.addRun(next, run, i + 1, top)\n          continue\n        }\n        const sub = this.step(run.state, c, i, false)\n        this.addRun(\n          next,\n          { t: 'run', neg: run.neg, state: sub },\n          i + 1,\n          top,\n        )\n      }\n    }\n    return this.done(next)\n  }\n}\n\n// A canonical key for the threads in a state. States with the same\n// key hold the same threads, so they match the same strings.\nconst stateKey = (state: State): string => {\n  const ids = state.ids.join()\n  if (!state.runs.length) return ids\n  const runs = state.runs.map(r => `${r.neg.id}(${stateKey(r.state)})`)\n  return `${ids}|${runs.sort().join('|')}`\n}\n\n// A cached state of the simulation, and the states that each char\n// leads to.\ntype DState = {\n  state: State\n  match: boolean\n  // no threads, so nothing more can match\n  dead: boolean\n  // the next state for each ASCII char, by char code, and for the\n  // other chars\n  ascii?: (DState | undefined)[]\n  next: Map<string, DState>\n}\n\n// The cache can hold about this many chars of state keys and\n// transitions. When it is full, it is cleared, so that a pattern\n// can not use an unbounded amount of memory.\nconst DFA_BUDGET = 1 << 18\n\n// A cache of the states that the simulation reaches, built as the\n// matcher is used. Each char of a string is then one Map lookup,\n// once the states that it leads to are known.\n//\n// The dot rules only restrict the first char of a dotfile (strings\n// that are only `.` or `..` do not use the cache). So a dotfile\n// starts at its own state, which takes its first step with the\n// restriction, and every other state takes steps without it.\nclass Dfa {\n  #start: Node\n  #states = new Map<string, DState>()\n  #size = 0\n  #plain?: DState\n  #dotStart?: DState\n  #sim: Sim\n  #dotSim: Sim\n\n  constructor(start: Node, marks: Marks) {\n    this.#start = start\n    this.#sim = new Sim(false, false, marks)\n    this.#dotSim = new Sim(false, true, marks)\n  }\n\n  #make(state: State): DState {\n    return {\n      state,\n      match: state.match,\n      dead: state.dead,\n      next: new Map(),\n    }\n  }\n\n  #intern(state: State): DState {\n    const key = stateKey(state)\n    const found = this.#states.get(key)\n    if (found) return found\n    if (this.#size > DFA_BUDGET) this.#clear()\n    const d = this.#make(state)\n    this.#states.set(key, d)\n    this.#size += key.length + 1\n    return d\n  }\n\n  #clear() {\n    this.#states.clear()\n    this.#size = 0\n    this.#plain = undefined\n    this.#dotStart = undefined\n  }\n\n  start(dotStart: boolean): DState {\n    if (dotStart) {\n      if (this.#dotStart) return this.#dotStart\n      const state = this.#dotSim.state()\n      this.#dotSim.add(state, this.#start, 0, true)\n      return (this.#dotStart = this.#make(this.#dotSim.done(state)))\n    }\n    if (this.#plain) return this.#plain\n    const state = this.#sim.state()\n    this.#sim.add(state, this.#start, 0, true)\n    return (this.#plain = this.#intern(this.#sim.done(state)))\n  }\n\n  // the next state, after a miss in `d.ascii`\n  next(d: DState, c: string): DState {\n    const code = c.charCodeAt(0)\n    const found = code < 128 ? undefined : d.next.get(c)\n    if (found) return found\n    // the dotfile start is not in the cache, so it is never shared\n    const n =\n      d === this.#dotStart ?\n        this.#intern(this.#dotSim.step(d.state, c, 0, true))\n      : this.#intern(this.#sim.step(d.state, c, 1, true))\n    if (code < 128) {\n      if (!d.ascii) {\n        d.ascii = new Array(128)\n        this.#size += 128\n      }\n      d.ascii[code] = n\n    } else {\n      d.next.set(c, n)\n    }\n    this.#size++\n    return n\n  }\n}\n\n/**\n * A node in a graph with no splits or negations. Such a graph is a\n * chain of nodes that each match one char, or a `*`.\n */\nexport type LinearNode = Exclude<\n  Node,\n  SplitNode | NegNode | { t: 'match' }\n>\n\n// the nodes in order, if the graph is a single chain\nconst linear = (start: Node): LinearNode[] | undefined => {\n  const nodes: LinearNode[] = []\n  for (let n = start; n.t !== 'match'; n = n.next) {\n    if (n.t === 'split' || n.t === 'neg') return undefined\n    nodes.push(n)\n  }\n  return nodes\n}\n\n// Match a chain of nodes. Each node other than `*` matches exactly\n// one char, so on a failure it is enough to go back to the last `*`\n// and let it match one more char. This takes at most\n// nodes.length * chars.length steps.\nconst testLinear = (\n  nodes: LinearNode[],\n  chars: ArrayLike<string>,\n  start: number,\n  end: number,\n) => {\n  let ni = 0\n  let ci = start\n  let starNi = -1\n  let starCi = 0\n  while (ci < end) {\n    const n = nodes[ni]\n    if (n?.t === 'star') {\n      starNi = ni++\n      starCi = ci\n      continue\n    }\n    const c = chars[ci]!\n    if (\n      n &&\n      (n.t === 'any' ||\n        (n.t === 'lit' && litMatch(n, c)) ||\n        (n.t === 'class' && n.re.test(c)))\n    ) {\n      ni++\n      ci++\n      continue\n    }\n    if (starNi === -1) return false\n    ni = starNi + 1\n    ci = ++starCi\n  }\n  while (nodes[ni]?.t === 'star') ni++\n  return ni === nodes.length\n}\n\n// The least and most chars that the items can match. These are only\n// bounds: a negation can match a string of any length, so it counts\n// as 0 to Infinity.\nconst lengths = (items: Item[]): [min: number, max: number] => {\n  let min = 0\n  let max = 0\n  for (const it of items) {\n    const [lo, hi] = itemLengths(it)\n    min += lo\n    max += hi\n  }\n  return [min, max]\n}\n\nconst itemLengths = (it: Item): [min: number, max: number] => {\n  if (it.t === 'star') return [0, Infinity]\n  if (it.t !== 'ext') return [1, 1]\n  if (it.type === '!') return [0, Infinity]\n  const alts = it.alts.map(lengths)\n  const min = Math.min(...alts.map(a => a[0]))\n  const max = Math.max(...alts.map(a => a[1]))\n  // a loop of alternatives that only match the empty string is empty\n  const loop = max === 0 ? 0 : Infinity\n  return (\n    it.type === '@' ? [min, max]\n    : it.type === '?' ? [0, max]\n    : it.type === '*' ? [0, loop]\n    : [min, loop]\n  )\n}\n\n// true if the chars from `start` match the literals\nconst hasAffix = (\n  lits: Lit[],\n  chars: ArrayLike<string>,\n  start: number,\n) => {\n  for (let j = 0; j < lits.length; j++) {\n    if (!litMatch(lits[j]!, chars[start + j]!)) return false\n  }\n  return true\n}\n\n// a `/`, or half of a surrogate pair\nconst slashOrSurrogate = /[/\\ud800-\\udfff]/\nconst surrogate = /[\\ud800-\\udfff]/\n\n// a string can be indexed by code point, unless it has surrogate\n// pairs\nconst codePoints = (s: string): ArrayLike<string> =>\n  surrogate.test(s) ? [...s] : s\n\nconst noSlash = (s: string) => {\n  if (s.includes('/')) {\n    throw new Error('can only match a single path portion, got: ' + s)\n  }\n}\n\nexport class Matcher {\n  pattern: string\n  options: MatcherOptions\n  #start: Node\n  // the number of node ids\n  #size: number\n  #marks?: Marks\n  // the Sim for strings that are only `.` or `..`\n  #dotsSim?: Sim\n  // the string to compare, if the pattern has no magic. With\n  // `nocase:true`, the RegExp that folds case is made when it is\n  // first used.\n  #literal?: string\n  #literalFold = false\n  #literalRe?: RegExp\n  // the nodes between the prefix and suffix, if the graph is a\n  // single chain\n  #linear?: LinearNode[]\n  // the linear nodes are only `*` and `?`, so the length bounds and\n  // the prefix and suffix decide the match\n  #wild = false\n  // the least and most chars that a match can have\n  #min = 0\n  #max = Infinity\n  // the literals that a match must start and end with. Each one\n  // matches exactly one char, and they are distinct items in the\n  // pattern, so a string that does not have them can not match.\n  #prefix: Lit[] = []\n  #suffix: Lit[] = []\n  // the prefix and suffix as strings, if they do not fold case\n  #prefixStr?: string\n  #suffixStr?: string\n  // there is a prefix or suffix to check\n  #affix = false\n  #dfa?: Dfa\n  #form?: Form\n\n  constructor(pattern: string, options: MatcherOptions = {}) {\n    if (pattern.includes('/')) {\n      throw new Error(\n        'can only match a single path portion, got pattern: ' + pattern,\n      )\n    }\n    this.pattern = pattern\n    this.options = options\n    const { nocase = false, noext = false, normalize: n } = options\n    this.#form = n === true ? 'NFC' : n || undefined\n    // a pattern that is only an empty extglob is a literal string,\n    // except for `!()`, which matches any non-empty string\n    const literal = /^[?*+@]\\(\\)$/.test(pattern)\n    const toks = tokenize(pattern, nocase, noext || literal, this.#form)\n    let [items] = build(toks, pair(toks), 0, toks.length, true)\n    if (this.#form) items = normalize(items!, this.#form)\n    const [start, size] = compile(items!, nocase)\n    this.#start = start\n    this.#size = size\n    if (items!.every(it => it.t === 'lit')) {\n      this.#literal = items!.map(it => it.ch).join('')\n      this.#literalFold = nocase\n    } else {\n      const lit = (it: Item): Lit | undefined =>\n        it.t !== 'lit' ? undefined\n        : nocase ? { ch: it.ch, re: foldRe(it.ch) }\n        : { ch: it.ch }\n      for (const it of items!) {\n        const l = lit(it)\n        if (!l) break\n        this.#prefix.push(l)\n      }\n      for (let j = items!.length - 1; j >= 0; j--) {\n        const l = lit(items![j]!)\n        if (!l) break\n        this.#suffix.unshift(l)\n      }\n      this.#affix = !!(this.#prefix.length || this.#suffix.length)\n      if (!nocase) {\n        this.#prefixStr = this.#prefix.map(l => l.ch).join('')\n        this.#suffixStr = this.#suffix.map(l => l.ch).join('')\n      }\n      this.#linear = linear(this.#start)?.slice(\n        this.#prefix.length,\n        -this.#suffix.length || undefined,\n      )\n      this.#wild = !!this.#linear?.every(\n        n => n.t === 'star' || n.t === 'any',\n      )\n      const [min, max] = lengths(items!)\n      this.#min = min\n      this.#max = max\n    }\n  }\n\n  test(s: string): boolean {\n    // The `/` check uses the string as given, so with normalization it\n    // is a separate step. Otherwise, one scan finds both a `/` and the\n    // surrogate pairs that stop the string being indexed by code point.\n    if (this.#form) {\n      noSlash(s)\n      return this.#test(s.normalize(this.#form))\n    }\n    if (slashOrSurrogate.test(s)) {\n      noSlash(s)\n      return this.#test(s, [...s])\n    }\n    return this.#test(s, s)\n  }\n\n  /**\n   * The same as {@link Matcher#test}, but the string is not checked\n   * for `/` chars, so the result for a string that has one is not\n   * defined. Only use it for a string that is known to be one path\n   * portion, such as a part of a path that was split on `/`. It can\n   * be faster, because some patterns do not need to look at each char\n   * of the string.\n   */\n  testUnchecked(s: string): boolean {\n    return this.#test(this.#form ? s.normalize(this.#form) : s)\n  }\n\n  // Test a string that has no `/`. `chars` indexes it by code point.\n  // If it is not given, it is only found if a step needs it.\n  #test(s: string, chars?: ArrayLike<string>): boolean {\n    if (this.#literal !== undefined) {\n      return this.#literalFold ?\n          (this.#literalRe ??= newFoldRe(this.#literal)).test(s)\n        : s === this.#literal\n    }\n    // the length check means that the prefix and suffix do not\n    // overlap. Without the chars, the length in code points is from\n    // half of the UTF-16 length (if each one is a surrogate pair) to\n    // all of it, which is often enough to know.\n    const min = this.#min\n    const max = this.#max\n    if (chars === undefined) {\n      const most = s.length\n      const least = (most + 1) >> 1\n      if (most < min || least > max) return false\n      if (least < min || most > max) chars = codePoints(s)\n    }\n    if (\n      chars !== undefined &&\n      (chars.length < min || chars.length > max)\n    ) {\n      return false\n    }\n    const prefix = this.#prefix.length\n    if (this.#affix) {\n      if (this.#prefixStr !== undefined && this.#suffixStr !== undefined) {\n        if (\n          !s.startsWith(this.#prefixStr) ||\n          !s.endsWith(this.#suffixStr)\n        ) {\n          return false\n        }\n      } else {\n        chars ??= codePoints(s)\n        const end = chars.length - this.#suffix.length\n        if (\n          !hasAffix(this.#prefix, chars, 0) ||\n          !hasAffix(this.#suffix, chars, end)\n        ) {\n          return false\n        }\n      }\n    }\n    const dotStart = !this.options.dot && s.startsWith('.')\n    if (this.#linear) {\n      // `.` and `..` only match literal dots, even with `dot:true`\n      if (s === '.' || s === '..') return false\n      // only a literal can match the leading dot. A `*` can not\n      // start a dotfile, even if it matches nothing.\n      if (dotStart && !prefix) return false\n      if (this.#wild) return true\n      chars ??= codePoints(s)\n      const end = chars.length - this.#suffix.length\n      return testLinear(this.#linear, chars, prefix, end)\n    }\n    chars ??= codePoints(s)\n    if (s === '.' || s === '..') {\n      this.#marks ??= marks(this.#size)\n      const sim = (this.#dotsSim ??= new Sim(true, false, this.#marks))\n      const start = sim.state()\n      sim.add(start, this.#start, 0, true)\n      let state = sim.done(start)\n      for (let i = 0; i < chars.length; i++) {\n        state = sim.step(state, chars[i]!, i, true)\n      }\n      return state.match\n    }\n    this.#marks ??= marks(this.#size)\n    const dfa = (this.#dfa ??= new Dfa(this.#start, this.#marks))\n    let d = dfa.start(dotStart)\n    // read char codes from the string, so that a one-char string is\n    // only made for a cache miss\n    const str = chars === s\n    for (let i = 0; i < chars.length; i++) {\n      if (d.dead) return false\n      const code = str ? s.charCodeAt(i) : chars[i]!.charCodeAt(0)\n      d = d.ascii?.[code] ?? dfa.next(d, chars[i]!)\n    }\n    return d.match\n  }\n\n  /** a readable listing of the state machine */\n  toString(): string {\n    return show(this.#start)\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["posixClasses", "braceEscape", "s", "noMatch", "parseClass", "glob", "position", "nocase", "form", "norm", "c", "n", "pos", "ranges", "negs", "i", "sawStart", "escaping", "negate", "endPos", "rangeStart", "WHILE", "cls", "unip", "neg", "sranges", "snegs", "comb", "exports", "parse_class_js_1", "MATCH", "extTypes", "lit", "ch", "reEscape", "s", "newFoldRe", "foldCache", "foldRe", "re", "litMatch", "l", "c", "code", "ascii", "tokenize", "p", "nocase", "noext", "form", "toks", "i", "e", "consumed", "pair", "pairs", "stack", "tok", "build", "start", "end", "top", "seq", "alts", "close", "sub", "normalize", "items", "out", "run", "flush", "it", "a", "compile", "id", "split", "next", "item", "after", "entry", "show", "lines", "seen", "ref", "walk", "indent", "line", "desc", "o", "State", "gen", "sameState", "b", "r", "marks", "size", "Sim", "#marks", "dots", "dotStart", "state", "n", "#visit", "node", "#addThread", "has", "th", "stateKey", "ids", "runs", "DFA_BUDGET", "Dfa", "#start", "#states", "#size", "#plain", "#dotStart", "#sim", "#dotSim", "#make", "#intern", "key", "found", "#clear", "d", "linear", "nodes", "testLinear", "chars", "ni", "ci", "starNi", "starCi", "lengths", "min", "max", "lo", "hi", "itemLengths", "loop", "hasAffix", "lits", "j", "slashOrSurrogate", "surrogate", "codePoints", "noSlash", "Matcher", "#dotsSim", "#literal", "#literalFold", "#literalRe", "#linear", "#wild", "#min", "#max", "#prefix", "#suffix", "#prefixStr", "#suffixStr", "#affix", "#dfa", "#form", "pattern", "options", "literal", "#test", "most", "least", "prefix", "sim", "dfa", "str"]
+}

package/node_modules/@isaacs/nonrecursive-glob-match/dist/commonjs/package.json

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

package/node_modules/@isaacs/nonrecursive-glob-match/dist/commonjs/parse-class.d.ts

@@ -0,0 +1,4 @@
+export type ParseClassResult = [re: RegExp, consumed: number];
+export type Form = 'NFC' | 'NFD' | 'NFKC' | 'NFKD';
+export declare const parseClass: (glob: string, position: number, nocase?: boolean, form?: Form) => ParseClassResult;
+//# sourceMappingURL=parse-class.d.ts.map

package/node_modules/@isaacs/nonrecursive-glob-match/dist/commonjs/parse-class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-class.d.ts","sourceRoot":"","sources":["../../src/parse-class.ts"],"names":[],"mappings":"AAyBA,MAAM,MAAM,gBAAgB,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAA;AAE7D,MAAM,MAAM,IAAI,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAA;AAWlD,eAAO,MAAM,UAAU,GACrB,MAAM,MAAM,EACZ,UAAU,MAAM,EAChB,SAAQ,OAAe,EACvB,OAAO,IAAI,KACV,gBAkHF,CAAA"}

package/node_modules/@isaacs/nonrecursive-glob-match/dist/commonjs/parse-class.js

@@ -0,0 +1,142 @@
+"use strict";
+// translate the various posix character classes into unicode properties
+// this works across all unicode locales
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseClass = void 0;
+// { <posix class>: [<translation>, negated]
+const posixClasses = {
+    '[:alnum:]': ['\\p{L}\\p{Nl}\\p{Nd}'],
+    '[:alpha:]': ['\\p{L}\\p{Nl}'],
+    '[:ascii:]': ['\\x' + '00-\\x' + '7f'],
+    '[:blank:]': ['\\p{Zs}\\t'],
+    '[:cntrl:]': ['\\p{Cc}'],
+    '[:digit:]': ['\\p{Nd}'],
+    '[:graph:]': ['\\p{Z}\\p{C}', true],
+    '[:lower:]': ['\\p{Ll}'],
+    '[:print:]': ['\\p{C}', true],
+    '[:punct:]': ['\\p{P}\\p{S}'],
+    '[:space:]': ['\\p{Z}\\t\\r\\n\\v\\f'],
+    '[:upper:]': ['\\p{Lu}'],
+    '[:word:]': ['\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}'],
+    '[:xdigit:]': ['A-Fa-f0-9'],
+};
+// only need to escape a few things inside of brace expressions
+// escapes: [ \ ] -
+const braceEscape = (s) => s.replace(/[[\]\\-]/g, '\\$&');
+const noMatch = /$./;
+// Takes a glob string at a posix brace expression. Returns a RegExp
+// that tests one character, and the number of glob chars consumed.
+// If the class is not closed, consumed is 0, and the `[` must be
+// treated as a literal character.
+// Out of order ranges are removed. If nothing is left, the RegExp
+// is `/$./`, and the rest of the glob is consumed, so that the
+// whole glob cannot match.
+const parseClass = (glob, position, nocase = false, form) => {
+    // normalize one class member, if it stays one code point
+    const norm = (c) => {
+        const n = form ? c.normalize(form) : c;
+        return [...n].length === 1 ? n : c;
+    };
+    const pos = position;
+    /* c8 ignore start */
+    if (glob.charAt(pos) !== '[') {
+        throw new Error('not in a brace expression');
+    }
+    /* c8 ignore stop */
+    const ranges = [];
+    const negs = [];
+    let i = pos + 1;
+    let sawStart = false;
+    let escaping = false;
+    let negate = false;
+    let endPos = pos;
+    let rangeStart = '';
+    WHILE: while (i < glob.length) {
+        const c = String.fromCodePoint(glob.codePointAt(i));
+        if ((c === '!' || c === '^') && i === pos + 1) {
+            negate = true;
+            i++;
+            continue;
+        }
+        if (c === ']' && sawStart && !escaping) {
+            endPos = i + 1;
+            break;
+        }
+        sawStart = true;
+        if (c === '\\') {
+            if (!escaping) {
+                escaping = true;
+                i++;
+                continue;
+            }
+            // escaped \ char, fall through and treat like normal char
+        }
+        if (c === '[' && !escaping) {
+            // either a posix class, a collation equivalent, or just a [
+            for (const [cls, [unip, neg]] of Object.entries(posixClasses)) {
+                if (glob.startsWith(cls, i)) {
+                    // invalid, [a-[] is fine, but not [a-[:alpha]]
+                    if (rangeStart) {
+                        return [noMatch, glob.length - pos];
+                    }
+                    i += cls.length;
+                    if (neg)
+                        negs.push(unip);
+                    else
+                        ranges.push(unip);
+                    continue WHILE;
+                }
+            }
+        }
+        // now it's just a normal character, effectively
+        escaping = false;
+        const n = norm(c);
+        if (rangeStart) {
+            // throw this range away if it's not valid, but others
+            // can still match.
+            if (n.codePointAt(0) > rangeStart.codePointAt(0)) {
+                ranges.push(braceEscape(rangeStart) + '-' + braceEscape(n));
+            }
+            else if (n === rangeStart) {
+                ranges.push(braceEscape(n));
+            }
+            rangeStart = '';
+            i += c.length;
+            continue;
+        }
+        // now might be the start of a range.
+        // can be either c-d or c-] or c<more...>] or c] at this point
+        if (glob.startsWith('-]', i + c.length)) {
+            ranges.push(braceEscape(n + '-'));
+            i += c.length + 1;
+            continue;
+        }
+        if (glob.startsWith('-', i + c.length)) {
+            rangeStart = n;
+            i += c.length + 1;
+            continue;
+        }
+        // not the start of a range, just a single character
+        ranges.push(braceEscape(n));
+        i += c.length;
+    }
+    if (endPos < i) {
+        // didn't see the end of the class, not a valid class,
+        // but might still be valid as a literal match.
+        return [noMatch, 0];
+    }
+    // if we got no ranges and no negates, then we have a range that
+    // cannot possibly match anything, and that poisons the whole glob
+    if (!ranges.length && !negs.length) {
+        return [noMatch, glob.length - pos];
+    }
+    const sranges = '[' + (negate ? '^' : '') + ranges.join('') + ']';
+    const snegs = '[' + (negate ? '' : '^') + negs.join('') + ']';
+    const comb = '^' +
+        (ranges.length && negs.length ? '(' + sranges + '|' + snegs + ')'
+            : ranges.length ? sranges
+                : snegs);
+    return [new RegExp(comb, nocase ? 'iu' : 'u'), endPos - pos];
+};
+exports.parseClass = parseClass;
+//# sourceMappingURL=parse-class.js.map

package/node_modules/@isaacs/nonrecursive-glob-match/dist/commonjs/parse-class.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-class.js","sourceRoot":"","sources":["../../src/parse-class.ts"],"names":[],"mappings":"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","sourcesContent":["// translate the various posix character classes into unicode properties\n// this works across all unicode locales\n\n// { <posix class>: [<translation>, negated]\nconst posixClasses: { [k: string]: [e: string, n?: boolean] } = {\n  '[:alnum:]': ['\\\\p{L}\\\\p{Nl}\\\\p{Nd}'],\n  '[:alpha:]': ['\\\\p{L}\\\\p{Nl}'],\n  '[:ascii:]': ['\\\\x' + '00-\\\\x' + '7f'],\n  '[:blank:]': ['\\\\p{Zs}\\\\t'],\n  '[:cntrl:]': ['\\\\p{Cc}'],\n  '[:digit:]': ['\\\\p{Nd}'],\n  '[:graph:]': ['\\\\p{Z}\\\\p{C}', true],\n  '[:lower:]': ['\\\\p{Ll}'],\n  '[:print:]': ['\\\\p{C}', true],\n  '[:punct:]': ['\\\\p{P}\\\\p{S}'],\n  '[:space:]': ['\\\\p{Z}\\\\t\\\\r\\\\n\\\\v\\\\f'],\n  '[:upper:]': ['\\\\p{Lu}'],\n  '[:word:]': ['\\\\p{L}\\\\p{Nl}\\\\p{Nd}\\\\p{Pc}'],\n  '[:xdigit:]': ['A-Fa-f0-9'],\n}\n\n// only need to escape a few things inside of brace expressions\n// escapes: [ \\ ] -\nconst braceEscape = (s: string) => s.replace(/[[\\]\\\\-]/g, '\\\\$&')\n\nexport type ParseClassResult = [re: RegExp, consumed: number]\n\nexport type Form = 'NFC' | 'NFD' | 'NFKC' | 'NFKD'\n\nconst noMatch = /$./\n\n// Takes a glob string at a posix brace expression. Returns a RegExp\n// that tests one character, and the number of glob chars consumed.\n// If the class is not closed, consumed is 0, and the `[` must be\n// treated as a literal character.\n// Out of order ranges are removed. If nothing is left, the RegExp\n// is `/$./`, and the rest of the glob is consumed, so that the\n// whole glob cannot match.\nexport const parseClass = (\n  glob: string,\n  position: number,\n  nocase: boolean = false,\n  form?: Form,\n): ParseClassResult => {\n  // normalize one class member, if it stays one code point\n  const norm = (c: string) => {\n    const n = form ? c.normalize(form) : c\n    return [...n].length === 1 ? n : c\n  }\n  const pos = position\n  /* c8 ignore start */\n  if (glob.charAt(pos) !== '[') {\n    throw new Error('not in a brace expression')\n  }\n  /* c8 ignore stop */\n  const ranges: string[] = []\n  const negs: string[] = []\n\n  let i = pos + 1\n  let sawStart = false\n  let escaping = false\n  let negate = false\n  let endPos = pos\n  let rangeStart = ''\n  WHILE: while (i < glob.length) {\n    const c = String.fromCodePoint(glob.codePointAt(i)!)\n    if ((c === '!' || c === '^') && i === pos + 1) {\n      negate = true\n      i++\n      continue\n    }\n\n    if (c === ']' && sawStart && !escaping) {\n      endPos = i + 1\n      break\n    }\n\n    sawStart = true\n    if (c === '\\\\') {\n      if (!escaping) {\n        escaping = true\n        i++\n        continue\n      }\n      // escaped \\ char, fall through and treat like normal char\n    }\n    if (c === '[' && !escaping) {\n      // either a posix class, a collation equivalent, or just a [\n      for (const [cls, [unip, neg]] of Object.entries(posixClasses)) {\n        if (glob.startsWith(cls, i)) {\n          // invalid, [a-[] is fine, but not [a-[:alpha]]\n          if (rangeStart) {\n            return [noMatch, glob.length - pos]\n          }\n          i += cls.length\n          if (neg) negs.push(unip)\n          else ranges.push(unip)\n          continue WHILE\n        }\n      }\n    }\n\n    // now it's just a normal character, effectively\n    escaping = false\n    const n = norm(c)\n    if (rangeStart) {\n      // throw this range away if it's not valid, but others\n      // can still match.\n      if (n.codePointAt(0)! > rangeStart.codePointAt(0)!) {\n        ranges.push(braceEscape(rangeStart) + '-' + braceEscape(n))\n      } else if (n === rangeStart) {\n        ranges.push(braceEscape(n))\n      }\n      rangeStart = ''\n      i += c.length\n      continue\n    }\n\n    // now might be the start of a range.\n    // can be either c-d or c-] or c<more...>] or c] at this point\n    if (glob.startsWith('-]', i + c.length)) {\n      ranges.push(braceEscape(n + '-'))\n      i += c.length + 1\n      continue\n    }\n    if (glob.startsWith('-', i + c.length)) {\n      rangeStart = n\n      i += c.length + 1\n      continue\n    }\n\n    // not the start of a range, just a single character\n    ranges.push(braceEscape(n))\n    i += c.length\n  }\n\n  if (endPos < i) {\n    // didn't see the end of the class, not a valid class,\n    // but might still be valid as a literal match.\n    return [noMatch, 0]\n  }\n\n  // if we got no ranges and no negates, then we have a range that\n  // cannot possibly match anything, and that poisons the whole glob\n  if (!ranges.length && !negs.length) {\n    return [noMatch, glob.length - pos]\n  }\n\n  const sranges = '[' + (negate ? '^' : '') + ranges.join('') + ']'\n  const snegs = '[' + (negate ? '' : '^') + negs.join('') + ']'\n  const comb =\n    '^' +\n    (ranges.length && negs.length ? '(' + sranges + '|' + snegs + ')'\n    : ranges.length ? sranges\n    : snegs)\n\n  return [new RegExp(comb, nocase ? 'iu' : 'u'), endPos - pos]\n}\n"]}

package/node_modules/@isaacs/nonrecursive-glob-match/dist/esm/index.d.ts

@@ -0,0 +1,114 @@
+import { type Form } from './parse-class.js';
+export type { Form };
+export type MatcherOptions = {
+    /** perform a case-insensitive match */
+    nocase?: boolean;
+    /** do not treat strings starting with `.` specially */
+    dot?: boolean;
+    /** do not match extglobs (treat them as normal strings) */
+    noext?: boolean;
+    /**
+     * normalize unicode in the pattern and the tested strings, with
+     * this form. `true` means `'NFC'`.
+     */
+    normalize?: boolean | Form;
+};
+export type Item = {
+    t: 'lit';
+    ch: string;
+} | {
+    t: 'any' | 'star';
+} | {
+    t: 'class';
+    re: RegExp;
+} | {
+    t: 'ext';
+    type: string;
+    alts: Item[][];
+};
+export type Token = Item | {
+    t: 'open';
+    type: string;
+} | {
+    t: 'bar';
+} | {
+    t: 'close';
+};
+export type NegNode = {
+    t: 'neg';
+    id: number;
+    sub: Node;
+    next: Node;
+};
+export type SplitNode = {
+    t: 'split';
+    id: number;
+    out: Node[];
+};
+export type Node = ({
+    t: 'lit';
+    id: number;
+    next: Node;
+} & Lit) | {
+    t: 'any' | 'star';
+    id: number;
+    next: Node;
+} | {
+    t: 'class';
+    id: number;
+    re: RegExp;
+    next: Node;
+} | SplitNode | NegNode | {
+    t: 'match';
+    id: number;
+};
+/**
+ * A literal char. With `nocase:true`, `re` folds case, and `ascii`
+ * holds its results for ASCII chars, by char code: 1 for a match,
+ * and 2 for not.
+ */
+export type Lit = {
+    ch: string;
+    re?: RegExp;
+    ascii?: Uint8Array;
+};
+/**
+ * For each node id, the gen of the last state that has the node as
+ * a thread, and of the last state that walked through it. A state is
+ * built to the end before the states around it go on, and the nodes
+ * of a negated sub-pattern are only in its states (other than the
+ * match node, which is never marked). So one mark for each node is
+ * enough to know if the state being built has it. The Sims of a
+ * matcher never run at the same time, so they share one Marks.
+ */
+export type Marks = {
+    has: Float64Array;
+    seen: Float64Array;
+    gen: number;
+};
+/**
+ * A node in a graph with no splits or negations. Such a graph is a
+ * chain of nodes that each match one char, or a `*`.
+ */
+export type LinearNode = Exclude<Node, SplitNode | NegNode | {
+    t: 'match';
+}>;
+export declare class Matcher {
+    #private;
+    pattern: string;
+    options: MatcherOptions;
+    constructor(pattern: string, options?: MatcherOptions);
+    test(s: string): boolean;
+    /**
+     * The same as {@link Matcher#test}, but the string is not checked
+     * for `/` chars, so the result for a string that has one is not
+     * defined. Only use it for a string that is known to be one path
+     * portion, such as a part of a path that was split on `/`. It can
+     * be faster, because some patterns do not need to look at each char
+     * of the string.
+     */
+    testUnchecked(s: string): boolean;
+    /** a readable listing of the state machine */
+    toString(): string;
+}
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@isaacs/nonrecursive-glob-match/dist/esm/index.d.ts.map

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