playwright-smart-test 0.0.0-stage → 1.0.1

package/node_modules/glob/dist/esm/index.min.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../node_modules/balanced-match/src/index.ts", "../../node_modules/brace-expansion/src/index.ts", "../../node_modules/@isaacs/nonrecursive-glob-match/src/parse-class.ts", "../../node_modules/@isaacs/nonrecursive-glob-match/src/index.ts", "../../node_modules/minimatch/src/assert-valid-pattern.ts", "../../node_modules/minimatch/src/escape.ts", "../../node_modules/minimatch/src/unescape.ts", "../../node_modules/minimatch/src/index.ts", "../../src/glob.ts", "../../node_modules/lru-cache/src/diagnostics-channel-node.ts", "../../node_modules/lru-cache/src/perf.ts", "../../node_modules/lru-cache/src/index.ts", "../../node_modules/path-scurry/src/index.ts", "../../node_modules/minipass/src/index.ts", "../../src/pattern.ts", "../../src/ignore.ts", "../../src/processor.ts", "../../src/walker.ts", "../../src/has-magic.ts", "../../src/index.ts"],
+  "sourcesContent": ["export const balanced = (\n  a: string | RegExp,\n  b: string | RegExp,\n  str: string,\n) => {\n  const ma = a instanceof RegExp ? maybeMatch(a, str) : a\n  const mb = b instanceof RegExp ? maybeMatch(b, str) : b\n\n  const r = ma !== null && mb != null && range(ma, mb, str)\n\n  return (\n    r && {\n      start: r[0],\n      end: r[1],\n      pre: str.slice(0, r[0]),\n      body: str.slice(r[0] + ma.length, r[1]),\n      post: str.slice(r[1] + mb.length),\n    }\n  )\n}\n\nconst maybeMatch = (reg: RegExp, str: string) => {\n  const m = str.match(reg)\n  return m ? m[0] : null\n}\n\nexport const range = (\n  a: string,\n  b: string,\n  str: string,\n): undefined | [number, number] => {\n  let begs: number[],\n    beg: number | undefined,\n    left: number,\n    right: number | undefined = undefined,\n    result: undefined | [number, number]\n  let ai = str.indexOf(a)\n  let bi = str.indexOf(b, ai + 1)\n  let i = ai\n\n  if (ai >= 0 && bi > 0) {\n    if (a === b) {\n      return [ai, bi]\n    }\n    begs = []\n    left = str.length\n\n    while (i >= 0 && !result) {\n      if (i === ai) {\n        begs.push(i)\n        ai = str.indexOf(a, i + 1)\n      } else if (begs.length === 1) {\n        const r = begs.pop()\n        if (r !== undefined) result = [r, bi]\n      } else {\n        beg = begs.pop()\n        if (beg !== undefined && beg < left) {\n          left = beg\n          right = bi\n        }\n\n        bi = str.indexOf(b, i + 1)\n      }\n\n      i = ai < bi && ai >= 0 ? ai : bi\n    }\n\n    if (begs.length && right !== undefined) {\n      result = [left, right]\n    }\n  }\n\n  return result\n}\n", "import { balanced } from 'balanced-match'\n\nconst escSlash = '\\0SLASH' + Math.random() + '\\0'\nconst escOpen = '\\0OPEN' + Math.random() + '\\0'\nconst escClose = '\\0CLOSE' + Math.random() + '\\0'\nconst escComma = '\\0COMMA' + Math.random() + '\\0'\nconst escPeriod = '\\0PERIOD' + Math.random() + '\\0'\nconst escSlashPattern = new RegExp(escSlash, 'g')\nconst escOpenPattern = new RegExp(escOpen, 'g')\nconst escClosePattern = new RegExp(escClose, 'g')\nconst escCommaPattern = new RegExp(escComma, 'g')\nconst escPeriodPattern = new RegExp(escPeriod, 'g')\nconst slashPattern = /\\\\\\\\/g\nconst openPattern = /\\\\{/g\nconst closePattern = /\\\\}/g\nconst commaPattern = /\\\\,/g\nconst periodPattern = /\\\\\\./g\n\nexport const EXPANSION_MAX = 100_000\n\n// `EXPANSION_MAX` caps the *number* of expansions, but not their length. An\n// input like `'{a,b}'.repeat(1500)` stays under that count - its output is\n// truncated to 100k results - while making every result ~1500 characters\n// long. The result set, and the intermediate arrays built while combining\n// brace sets, then grow large enough to exhaust memory and crash the process\n// (CVE-2026-14257). `EXPANSION_MAX_LENGTH` bounds the total number of\n// characters the accumulator may hold at any point, so memory stays flat no\n// matter how many brace groups are chained. The limit sits well above any\n// realistic expansion (100k results hitting `EXPANSION_MAX` measure ~1M\n// characters) so legitimate input is unaffected.\nexport const EXPANSION_MAX_LENGTH = 4_000_000\n\n// `expand_` recurses once per level of brace *nesting* - both when expanding a\n// set's comma members and when re-wrapping a set whose body is a single part.\n// The CVE-2026-14257 fix made the *tail* iterative (recursion on `m.post`, one\n// level per chained group), which left nesting depth unbounded: about 3,100\n// levels of `{{{...a,b...}}}` - only ~6KB of input - exhausted the native stack\n// and crashed the process. `EXPANSION_MAX_DEPTH` bounds how deep the parser\n// will follow nesting. It sits far above any realistic pattern and well below\n// the depth at which the stack runs out.\nexport const EXPANSION_MAX_DEPTH = 1_000\n\n// Bash keeps a quirk where a brace group followed by a comma set still expands\n// (`{a},b}`). The parser implements it by rewriting the string and restarting\n// the scan, absorbing one `}` per pass. `n` trailing braces therefore cost `n`\n// full passes over a string that itself grows by one `escClose` sentinel each\n// time - quadratic in `n`, with a ~26x constant from the sentinel's length.\n// 128KB of `'{a}' + '}'.repeat(n) + ',z}'` blocked the event loop for 27\n// seconds to produce two results. `EXPANSION_MAX_REWRITES` bounds how many\n// times the scan may restart. Real `{a},b}` input needs a handful.\nexport const EXPANSION_MAX_REWRITES = 1_000\n\nfunction numeric(str: string) {\n  return !isNaN(str as any) ? parseInt(str, 10) : str.charCodeAt(0)\n}\n\nfunction escapeBraces(str: string) {\n  return str\n    .replace(slashPattern, escSlash)\n    .replace(openPattern, escOpen)\n    .replace(closePattern, escClose)\n    .replace(commaPattern, escComma)\n    .replace(periodPattern, escPeriod)\n}\n\nfunction unescapeBraces(str: string) {\n  return str\n    .replace(escSlashPattern, '\\\\')\n    .replace(escOpenPattern, '{')\n    .replace(escClosePattern, '}')\n    .replace(escCommaPattern, ',')\n    .replace(escPeriodPattern, '.')\n}\n\n// Like `target.push(...items)` but doesn't overflow the stack\nfunction pushAll(target: string[], items: string[]) {\n  for (let i = 0; i < items.length; i++) {\n    target.push(items[i] as string)\n  }\n}\n\n/**\n * Basically just str.split(\",\"), but handling cases\n * where we have nested braced sections, which should be\n * treated as individual members, like {a,{b,c},d}\n */\nfunction parseCommaParts(str: string) {\n  const parts: string[] = []\n\n  // Walk the brace groups iteratively. Recursing on `post` once per group let a\n  // chain of them exhaust the stack - the parsing-side counterpart to\n  // the `expand_` overflow fixed for CVE-2026-14257, and not something `max` or\n  // `maxLength` can bound, since it happens before expansion.\n  //\n  // The part the next chunk continues\n  let carry = ''\n\n  for (;;) {\n    const m = balanced('{', '}', str)\n\n    if (!m) {\n      const tail = str.split(',')\n      tail[0] = carry + (tail[0] as string)\n      pushAll(parts, tail)\n      return parts\n    }\n\n    const { pre, body, post } = m\n    const p = pre.split(',')\n    p[0] = carry + (p[0] as string)\n    p[p.length - 1] += '{' + body + '}'\n\n    if (!post.length) {\n      pushAll(parts, p)\n      return parts\n    }\n\n    carry = p.pop() as string\n    pushAll(parts, p)\n    str = post\n  }\n}\n\nexport type BraceExpansionOptions = {\n  max?: number\n  maxLength?: number\n  maxDepth?: number\n  maxRewrites?: number\n}\n\nexport function expand(str: string, options: BraceExpansionOptions = {}) {\n  if (!str) {\n    return []\n  }\n\n  const {\n    max = EXPANSION_MAX,\n    maxLength = EXPANSION_MAX_LENGTH,\n    maxDepth = EXPANSION_MAX_DEPTH,\n    maxRewrites = EXPANSION_MAX_REWRITES,\n  } = options\n\n  // I don't know why Bash 4.3 does this, but it does.\n  // Anything starting with {} will have the first two bytes preserved\n  // but *only* at the top level, so {},a}b will not expand to anything,\n  // but a{},b}c will be expanded to [a}c,abc].\n  // One could argue that this is a bug in Bash, but since the goal of\n  // this module is to match Bash's rules, we escape a leading {}\n  if (str.slice(0, 2) === '{}') {\n    str = '\\\\{\\\\}' + str.slice(2)\n  }\n\n  return expand_(\n    escapeBraces(str),\n    max,\n    maxLength,\n    maxDepth,\n    0,\n    maxRewrites,\n    true,\n  ).map(unescapeBraces)\n}\n\nfunction embrace(str: string) {\n  return '{' + str + '}'\n}\n\nfunction isPadded(el: string) {\n  return /^-?0\\d/.test(el)\n}\n\nfunction lte(i: number, y: number) {\n  return i <= y\n}\n\nfunction gte(i: number, y: number) {\n  return i >= y\n}\n\n// Build `{ acc[a] + pre + values[v] }` for every combination, capping the\n// number of results at `max` and the total number of characters at `maxLength`.\n// This is the one place output grows, so bounding it here keeps the single\n// accumulator - and therefore memory - flat regardless of how many brace groups\n// are combined (CVE-2026-14257).\nfunction combine(\n  acc: string[],\n  pre: string,\n  values: string[],\n  max: number,\n  maxLength: number,\n  dropEmpties: boolean,\n): string[] {\n  const out: string[] = []\n  let length = 0\n  for (let a = 0; a < acc.length; a++) {\n    for (let v = 0; v < values.length; v++) {\n      if (out.length >= max) return out\n      const expansion = (acc[a] as string) + pre + values[v]\n      // Bash drops empty results at the top level. Skip them before they count\n      // against `max`, so `max` bounds the number of *kept* results.\n      if (dropEmpties && !expansion) continue\n      if (length + expansion.length > maxLength) return out\n      out.push(expansion)\n      length += expansion.length\n    }\n  }\n  return out\n}\n\n// The expansion values of a single numeric (`1..5`) or alphabetic (`a..e..2`)\n// sequence body.\nfunction expandSequence(\n  body: string,\n  isAlphaSequence: boolean,\n  max: number,\n  maxLength: number,\n): string[] {\n  const n = body.split(/\\.\\./)\n  const N: string[] = []\n  // A sequence body always splits into two or three parts, but the compiler\n  // can't know that.\n  /* c8 ignore start */\n  if (n[0] === undefined || n[1] === undefined) {\n    return N\n  }\n  /* c8 ignore stop */\n  const x = numeric(n[0])\n  const y = numeric(n[1])\n  const width = Math.max(n[0].length, n[1].length)\n  let incr =\n    n.length === 3 && n[2] !== undefined ?\n      Math.max(Math.abs(numeric(n[2])), 1)\n    : 1\n  let test = lte\n  const reverse = y < x\n  if (reverse) {\n    incr *= -1\n    test = gte\n  }\n  const pad = n.some(isPadded)\n\n  let length = 0\n  for (let i = x; test(i, y) && N.length < max; i += incr) {\n    let c\n    if (isAlphaSequence) {\n      c = String.fromCharCode(i)\n      if (c === '\\\\') {\n        c = ''\n      }\n    } else {\n      c = String(i)\n      if (pad) {\n        const need = width - c.length\n        if (need > 0) {\n          const z = new Array(need + 1).join('0')\n          if (i < 0) {\n            c = '-' + z + c.slice(1)\n          } else {\n            c = z + c\n          }\n        }\n      }\n    }\n    if (length + c.length > maxLength) break\n    N.push(c)\n    length += c.length\n  }\n  return N\n}\n\nfunction expand_(\n  str: string,\n  max: number,\n  maxLength: number,\n  maxDepth: number,\n  depth: number,\n  maxRewrites: number,\n  isTop: boolean,\n): string[] {\n  // Too deeply nested to keep following: treat the rest as literal, the same\n  // way a group that cannot expand is already handled. Truncating rather than\n  // throwing keeps `expand` total, matching `max` and `maxLength`.\n  if (depth > maxDepth) {\n    return [str]\n  }\n\n  // Consume the string's top-level brace groups left to right, threading a\n  // running set of combined prefixes (`acc`). Expanding the tail iteratively -\n  // rather than recursing on `m.post` once per group - keeps the native stack\n  // depth constant, so deeply chained input (`'{a,b}'.repeat(3000)`) can no\n  // longer overflow the stack, and leaves a single accumulator whose size\n  // `maxLength` bounds directly (CVE-2026-14257).\n  let acc: string[] = ['']\n\n  // Bash drops empty results, but only when the *first* top-level group is a\n  // comma set - a sequence like `{a..\\}` may legitimately yield ''. The drop\n  // is on the final strings, so it is applied to whichever `combine` produces\n  // them (the one with no brace set left in the tail).\n  // How many times the `{a},b}` rewrite below has restarted the scan. Each pass\n  // re-reads the whole string, so leaving this unbounded is quadratic.\n  let rewrites = 0\n  let dropEmpties = false\n  let firstGroup = true\n\n  for (;;) {\n    const m = balanced('{', '}', str)\n\n    // No brace set left: the rest of the string is literal.\n    if (!m) {\n      return combine(acc, str, [''], max, maxLength, dropEmpties)\n    }\n\n    // no need to expand pre, since it is guaranteed to be free of brace-sets\n    const pre = m.pre\n\n    if (/\\$$/.test(pre)) {\n      acc = combine(\n        acc,\n        pre + '{' + m.body + '}',\n        [''],\n        max,\n        maxLength,\n        dropEmpties && !m.post.length,\n      )\n      firstGroup = false\n      if (!m.post.length) break\n      str = m.post\n      continue\n    }\n\n    const isNumericSequence = /^-?\\d+\\.\\.-?\\d+(?:\\.\\.-?\\d+)?$/.test(m.body)\n    const isAlphaSequence = /^[a-zA-Z]\\.\\.[a-zA-Z](?:\\.\\.-?\\d+)?$/.test(\n      m.body,\n    )\n    const isSequence = isNumericSequence || isAlphaSequence\n    const isOptions = m.body.indexOf(',') >= 0\n    if (!isSequence && !isOptions) {\n      // {a},b}\n      if (rewrites < maxRewrites && m.post.match(/,(?!,).*\\}/)) {\n        rewrites++\n        str = m.pre + '{' + m.body + escClose + m.post\n        isTop = true\n        continue\n      }\n      // Nothing here expands, so the whole remaining string is literal.\n      return combine(\n        acc,\n        pre + '{' + m.body + '}' + m.post,\n        [''],\n        max,\n        maxLength,\n        dropEmpties,\n      )\n    }\n\n    if (firstGroup) {\n      dropEmpties = isTop && !isSequence\n      firstGroup = false\n    }\n\n    let values: string[]\n    if (isSequence) {\n      values = expandSequence(m.body, isAlphaSequence, max, maxLength)\n    } else {\n      let n = parseCommaParts(m.body)\n      if (n.length === 1 && n[0] !== undefined) {\n        // x{{a,b}}y ==> x{a}y x{b}y\n        n = expand_(\n          n[0],\n          max,\n          maxLength,\n          maxDepth,\n          depth + 1,\n          maxRewrites,\n          false,\n        ).map(embrace)\n        //XXX is this necessary? Can't seem to hit it in tests.\n        /* c8 ignore start */\n        if (n.length === 1) {\n          acc = combine(\n            acc,\n            pre + n[0],\n            [''],\n            max,\n            maxLength,\n            dropEmpties && !m.post.length,\n          )\n          if (!m.post.length) break\n          str = m.post\n          continue\n        }\n        /* c8 ignore stop */\n      }\n\n      // Values that `combine` is going to drop as empty produce no result, so\n      // they must not count against `max` - otherwise `{a,,b}` with `max: 2`\n      // would stop at `['a', '']` and yield one result instead of two. Skipping\n      // them outright keeps `values` bounded while leaving `max` a bound on\n      // *kept* results.\n      let dropsEmpties = dropEmpties && !m.post.length && !pre\n      for (let d = 0; dropsEmpties && d < acc.length; d++) {\n        if (acc[d]) {\n          dropsEmpties = false\n        }\n      }\n\n      values = []\n      let valuesLength = 0\n      outer: for (let j = 0; j < n.length; j++) {\n        const expanded = expand_(\n          n[j] as string,\n          max,\n          maxLength,\n          maxDepth,\n          depth + 1,\n          maxRewrites,\n          false,\n        )\n        for (let k = 0; k < expanded.length; k++) {\n          const v = expanded[k] as string\n          if (dropsEmpties && !v) continue\n          if (\n            values.length >= max ||\n            valuesLength + v.length > maxLength\n          ) {\n            break outer\n          }\n          values.push(v)\n          valuesLength += v.length\n        }\n      }\n    }\n\n    acc = combine(\n      acc,\n      pre,\n      values,\n      max,\n      maxLength,\n      dropEmpties && !m.post.length,\n    )\n    if (!m.post.length) break\n    str = m.post\n  }\n\n  return acc\n}\n", "// 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 foldRe = (s: string) => new RegExp(`^${reEscape(s)}$`, 'iu')\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. The RegExp\n  // folds case, if `nocase:true`.\n  #literal?: string\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      if (nocase) this.#literalRe = foldRe(this.#literal)\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.#literalRe ?\n          this.#literalRe.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", "const MAX_PATTERN_LENGTH = 1024 * 64\nexport const assertValidPattern: (pattern: unknown) => void = (\n  pattern: unknown,\n): asserts pattern is string => {\n  if (typeof pattern !== 'string') {\n    throw new TypeError('invalid pattern')\n  }\n\n  if (pattern.length > MAX_PATTERN_LENGTH) {\n    throw new TypeError('pattern is too long')\n  }\n}\n", "import type { MinimatchOptions } from './index.js'\n\n/**\n * Escape all magic characters in a glob pattern.\n *\n * If the {@link MinimatchOptions.windowsPathsNoEscape}\n * option is used, then characters are escaped by wrapping in `[]`, because\n * a magic character wrapped in a character class can only be satisfied by\n * that exact character.  In this mode, `\\` is _not_ escaped, because it is\n * not interpreted as a magic character, but instead as a path separator.\n *\n * If the {@link MinimatchOptions.magicalBraces} option is used,\n * then braces (`{` and `}`) will be escaped.\n */\nexport const escape = (\n  s: string,\n  {\n    windowsPathsNoEscape = false,\n    magicalBraces = false,\n  }: Pick<MinimatchOptions, 'windowsPathsNoEscape' | 'magicalBraces'> = {},\n) => {\n  // don't need to escape +@! because we escape the parens\n  // that make those magic, and escaping ! as [!] isn't valid,\n  // because [!]] is a valid glob class meaning not ']'.\n  if (magicalBraces) {\n    return windowsPathsNoEscape ?\n        s.replace(/[?*()[\\]{}]/g, '[$&]')\n      : s.replace(/[?*()[\\]\\\\{}]/g, '\\\\$&')\n  }\n  return windowsPathsNoEscape ?\n      s.replace(/[?*()[\\]]/g, '[$&]')\n    : s.replace(/[?*()[\\]\\\\]/g, '\\\\$&')\n}\n", "import type { MinimatchOptions } from './index.js'\n\n/**\n * Un-escape a string that has been escaped with {@link escape}.\n *\n * If the {@link MinimatchOptions.windowsPathsNoEscape} option is used, then\n * square-bracket escapes are removed, but not backslash escapes.\n *\n * For example, it will turn the string `'[*]'` into `*`, but it will not\n * turn `'\\\\*'` into `'*'`, because `\\` is a path separator in\n * `windowsPathsNoEscape` mode.\n *\n * When `windowsPathsNoEscape` is not set, then both square-bracket escapes and\n * backslash escapes are removed.\n *\n * Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot be escaped\n * or unescaped.\n *\n * When `magicalBraces` is not set, escapes of braces (`{` and `}`) will not be\n * unescaped.\n */\n\nexport const unescape = (\n  s: string,\n  {\n    windowsPathsNoEscape = false,\n    magicalBraces = true,\n  }: Pick<MinimatchOptions, 'windowsPathsNoEscape' | 'magicalBraces'> = {},\n) => {\n  if (magicalBraces) {\n    return windowsPathsNoEscape ?\n        s.replace(/\\[([^/\\\\])\\]/g, '$1')\n      : s\n          .replace(/((?!\\\\).|^)\\[([^/\\\\])\\]/g, '$1$2')\n          .replace(/\\\\([^/])/g, '$1')\n  }\n  return windowsPathsNoEscape ?\n      s.replace(/\\[([^/\\\\{}])\\]/g, '$1')\n    : s\n        .replace(/((?!\\\\).|^)\\[([^/\\\\{}])\\]/g, '$1$2')\n        .replace(/\\\\([^/{}])/g, '$1')\n}\n", "import { expand } from 'brace-expansion'\nimport { Matcher, type Form } from '@isaacs/nonrecursive-glob-match'\nimport { assertValidPattern } from './assert-valid-pattern.js'\nimport { escape } from './escape.js'\nimport { unescape } from './unescape.js'\n\nexport type Platform =\n  | 'aix'\n  | 'android'\n  | 'darwin'\n  | 'freebsd'\n  | 'haiku'\n  | 'linux'\n  | 'openbsd'\n  | 'sunos'\n  | 'win32'\n  | 'cygwin'\n  | 'netbsd'\n\nexport interface MinimatchOptions {\n  /** do not expand `{x,y}` style braces */\n  nobrace?: boolean\n  /** do not treat patterns starting with `#` as a comment */\n  nocomment?: boolean\n  /** do not treat patterns starting with `!` as a negation */\n  nonegate?: boolean\n  /** treat `**` the same as `*` */\n  noglobstar?: boolean\n  /** do not expand extglobs like `+(a|b)` */\n  noext?: boolean\n  /** return the pattern if nothing matches */\n  nonull?: boolean\n  /** treat `\\\\` as a path separator, not an escape character */\n  windowsPathsNoEscape?: boolean\n  /**\n   * inverse of {@link MinimatchOptions.windowsPathsNoEscape}\n   * @deprecated\n   */\n  allowWindowsEscape?: boolean\n  /**\n   * Compare a partial path to a pattern. As long as the parts\n   * of the path that are present are not contradicted by the\n   * pattern, it will be treated as a match. This is useful in\n   * applications where you're walking through a folder structure,\n   * and don't yet have the full path, but want to ensure that you\n   * do not walk down paths that can never be a match.\n   */\n  partial?: boolean\n  /** allow matches that start with `.` even if the pattern does not */\n  dot?: boolean\n  /** ignore case */\n  nocase?: boolean\n  /** ignore case only in wildcard patterns */\n  nocaseMagicOnly?: boolean\n  /**\n   * Normalize unicode in the pattern and in each portion of the\n   * tested paths, with this form. `true` means `'NFC'`.\n   */\n  normalize?: boolean | Form\n  /** consider braces to be \"magic\" for the purpose of `hasMagic` */\n  magicalBraces?: boolean\n  /**\n   * If set, then patterns without slashes will be matched\n   * against the basename of the path if it contains slashes.\n   * For example, `a?b` would match the path `/xyz/123/acb`, but\n   * not `/xyz/acb/123`.\n   */\n  matchBase?: boolean\n  /** invert the results of negated matches */\n  flipNegate?: boolean\n  /** do not collapse multiple `/` into a single `/` */\n  preserveMultipleSlashes?: boolean\n  /**\n   * A number indicating the level of optimization that should be done\n   * to the pattern prior to parsing and using it for matches.\n   */\n  optimizationLevel?: number\n  /** operating system platform */\n  platform?: Platform\n  /**\n   * When a pattern starts with a UNC path or drive letter, and in\n   * `nocase:true` mode, do not convert the root portions of the\n   * pattern into a case-insensitive regular expression, and instead\n   * leave them as strings.\n   *\n   * This is the default when the platform is `win32` and\n   * `nocase:true` is set.\n   */\n  windowsNoMagicRoot?: boolean\n  /**\n   * max number of `{...}` patterns to expand. Default 100_000.\n   *\n   * At `optimizationLevel` 2 or higher, this also limits the\n   * patterns made when `**` is followed by `..`.\n   */\n  braceExpandMax?: number\n  /**\n   * Max number of non-adjacent `**` patterns to recursively walk down.\n   *\n   * The default of 200 is almost certainly high enough for most purposes,\n   * and can handle absurdly excessive patterns.\n   */\n  maxGlobstarRecursion?: number\n}\n\nexport const minimatch = (\n  p: string,\n  pattern: string,\n  options: MinimatchOptions = {},\n) => {\n  assertValidPattern(pattern)\n\n  // shortcut: comments match nothing.\n  if (!options.nocomment && pattern.charAt(0) === '#') {\n    return false\n  }\n\n  return new Minimatch(pattern, options).match(p)\n}\n\n/* c8 ignore start */\nconst defaultPlatform: Platform = (\n  typeof process === 'object' && process ?\n    process.env?.__MINIMATCH_TESTING_PLATFORM__ || process.platform\n  : 'posix') as Platform\n\nexport type Sep = '\\\\' | '/'\n\nconst path: { [k: string]: { sep: Sep } } = {\n  win32: { sep: '\\\\' },\n  posix: { sep: '/' },\n}\n/* c8 ignore stop */\n\nexport const sep =\n  defaultPlatform === 'win32' ? path.win32.sep : path.posix.sep\nminimatch.sep = sep\n\nexport const GLOBSTAR = Symbol('globstar **')\nminimatch.GLOBSTAR = GLOBSTAR\n\nexport const filter =\n  (pattern: string, options: MinimatchOptions = {}) =>\n  (p: string) =>\n    minimatch(p, pattern, options)\nminimatch.filter = filter\n\nconst ext = (a: MinimatchOptions, b: MinimatchOptions = {}) =>\n  Object.assign({}, a, b)\n\nexport const defaults = (def: MinimatchOptions): typeof minimatch => {\n  if (!def || typeof def !== 'object' || !Object.keys(def).length) {\n    return minimatch\n  }\n\n  const orig = minimatch\n\n  const m = (p: string, pattern: string, options: MinimatchOptions = {}) =>\n    orig(p, pattern, ext(def, options))\n\n  return Object.assign(m, {\n    Minimatch: class Minimatch extends orig.Minimatch {\n      constructor(pattern: string, options: MinimatchOptions = {}) {\n        super(pattern, ext(def, options))\n      }\n      static defaults(options: MinimatchOptions) {\n        return orig.defaults(ext(def, options)).Minimatch\n      }\n    },\n\n    unescape: (\n      s: string,\n      options: Pick<\n        MinimatchOptions,\n        'windowsPathsNoEscape' | 'magicalBraces'\n      > = {},\n    ) => orig.unescape(s, ext(def, options)),\n\n    escape: (\n      s: string,\n      options: Pick<\n        MinimatchOptions,\n        'windowsPathsNoEscape' | 'magicalBraces'\n      > = {},\n    ) => orig.escape(s, ext(def, options)),\n\n    filter: (pattern: string, options: MinimatchOptions = {}) =>\n      orig.filter(pattern, ext(def, options)),\n\n    defaults: (options: MinimatchOptions) =>\n      orig.defaults(ext(def, options)),\n\n    braceExpand: (pattern: string, options: MinimatchOptions = {}) =>\n      orig.braceExpand(pattern, ext(def, options)),\n\n    match: (\n      list: string[],\n      pattern: string,\n      options: MinimatchOptions = {},\n    ) => orig.match(list, pattern, ext(def, options)),\n\n    sep: orig.sep,\n    GLOBSTAR: GLOBSTAR as typeof GLOBSTAR,\n  })\n}\nminimatch.defaults = defaults\n\n// Brace expansion:\n// a{b,c}d -> abd acd\n// a{b,}c -> abc ac\n// a{0..3}d -> a0d a1d a2d a3d\n// a{b,c{d,e}f}g -> abg acdfg acefg\n// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg\n//\n// Invalid sets are not expanded.\n// a{2..}b -> a{2..}b\n// a{b}c -> a{b}c\nexport const braceExpand = (\n  pattern: string,\n  options: MinimatchOptions = {},\n) => {\n  assertValidPattern(pattern)\n\n  // Thanks to Yeting Li <https://github.com/yetingli> for\n  // improving this regexp to avoid a ReDOS vulnerability.\n  if (options.nobrace || !/\\{(?:(?!\\{).)*\\}/.test(pattern)) {\n    // shortcut. no need to expand.\n    return [pattern]\n  }\n\n  return expand(pattern, { max: options.braceExpandMax })\n}\nminimatch.braceExpand = braceExpand\n\nexport const match = (\n  list: string[],\n  pattern: string,\n  options: MinimatchOptions = {},\n) => {\n  const mm = new Minimatch(pattern, options)\n  list = list.filter(f => mm.match(f))\n  if (mm.options.nonull && !list.length) {\n    list.push(pattern)\n  }\n  return list\n}\nminimatch.match = match\n\nconst globMagic = /[?*]|[+@!]\\(.*?\\)|\\[|\\]/\n\n// Index of the `]` that closes the class that starts at `start`,\n// or -1 if it is not closed. Posix classes such as `[:alpha:]` are\n// not skipped, so this can find a `]` before the real end. That\n// only makes a class look less like a literal.\nconst classEnd = (pattern: string, start: number) => {\n  let i = start + 1\n  if (pattern.charAt(i) === '!' || pattern.charAt(i) === '^') i++\n  let sawStart = false\n  for (; i < pattern.length; i++) {\n    const c = pattern.charAt(i)\n    if (c === ']' && sawStart) return i\n    sawStart = true\n    if (c === '\\\\') i++\n  }\n  return -1\n}\n\n// If a path portion pattern has no magic, return the string it\n// matches. Otherwise, return undefined. This can report magic for\n// a pattern that is in fact literal (eg, `[]`), but never the\n// reverse, so a string result is always safe to compare directly.\nconst literal = (pattern: string, noext: boolean): string | undefined => {\n  if (!noext && (pattern === '+()' || pattern === '@()')) return pattern\n  let lit = ''\n  for (let i = 0; i < pattern.length; i++) {\n    const c = pattern.charAt(i)\n    if (c === '\\\\') {\n      // a trailing \\ is a literal \\\n      lit += pattern.charAt(++i) || c\n    } else if (c === '*' || c === '?') {\n      return undefined\n    } else if (c === '[') {\n      const close = classEnd(pattern, i)\n      if (close === -1) {\n        // not closed, so the [ is a literal\n        lit += c\n        continue\n      }\n      // a class of one char, such as `[*]` or `[\\b]`, is a literal\n      let body = pattern.slice(i + 1, close)\n      if (body.startsWith('\\\\')) body = body.slice(1)\n      if ([...body].length !== 1 || '!^'.includes(pattern.charAt(i + 1))) {\n        return undefined\n      }\n      lit += body\n      i = close\n    } else if (\n      !noext &&\n      '+@!'.includes(c) &&\n      pattern.charAt(i + 1) === '(' &&\n      pattern.includes(')', i + 2)\n    ) {\n      return undefined\n    } else {\n      lit += c\n    }\n  }\n  return lit\n}\n\n// True if the portion pattern has the same meaning as an alternative\n// inside `@(...)`. It must not have a `|` or `)` that is not in a\n// closed extglob (those are literal at the top level), an extglob\n// that is not closed (the `)` of the `@(...)` would close it), or a\n// trailing `\\` (it would escape the next `|`). A pattern that is\n// only an empty extglob, such as `?()`, is literal on its own, but\n// not in `@(...)`. Posix classes such as `[:alpha:]` can hide a `]`\n// from classEnd, so patterns with them are not merged.\nconst extSafe = (pattern: string) => {\n  if (/^[?*+@]\\(\\)$/.test(pattern) || pattern.includes('[:')) return false\n  let depth = 0\n  for (let i = 0; i < pattern.length; i++) {\n    const c = pattern.charAt(i)\n    if (c === '\\\\') {\n      if (++i === pattern.length) return false\n    } else if (c === '[') {\n      const close = classEnd(pattern, i)\n      if (close !== -1) i = close\n    } else if ('+@!?*'.includes(c) && pattern.charAt(i + 1) === '(') {\n      depth++\n      i++\n    } else if (c === ')') {\n      if (!depth--) return false\n    } else if (c === '|' && !depth) {\n      return false\n    }\n  }\n  return !depth\n}\n\n// The last path that Minimatch#match split, and its parts. A path is\n// often tested against many patterns in a row (such as a list of\n// ignore patterns), so this saves splitting it again. The parts are\n// never changed, so they can be shared.\nlet lastSplit: SplitPath | undefined\n\n/**\n * A path that Minimatch#match split, with the settings that the split\n * depends on. `resolved` is the parts after optimizationLevel 2 has\n * resolved `.` and `..` in them, which only depends on the same\n * settings, once a level 2 Minimatch has needed them.\n */\nexport type SplitPath = {\n  f: string\n  isWindows: boolean\n  preserveMultipleSlashes: boolean\n  normalize: Form | undefined\n  parts: string[]\n  resolved?: string[]\n}\n\n// The last path that Minimatch#match checked before splitting it. If\n// the same path is checked again, it is being tested against many\n// patterns, so it is split and the parts are kept for the others.\nlet lastChecked: string | undefined\n\nexport type ParseReturnFiltered = string | Matcher | typeof GLOBSTAR\n\n/**\n * The rows that Minimatch#match can match without splitting the path:\n * `**` and one more portion (`tail`), a portion with `**` on each side\n * of it (`mid`), a portion and then `**` (`head`), or one portion that\n * matches the basename of the path, with matchBase (`base`).\n */\nexport type RowShape = 'tail' | 'mid' | 'head' | 'base'\n\n// true if a pattern portion that is not ** matches a path portion.\n// An empty path portion only matches an empty pattern portion. A path\n// portion never has a `/`, so the Matcher does not need to check it.\nconst portionMatch = (p: string | Matcher, f: string) =>\n  typeof p === 'string' ? f === p : f !== '' && p.testUnchecked(f)\n\n// Where the last portion of a row matches in a path: the start of the\n// last portion of the path, or of the one before a trailing `/`. -1 if\n// it matches neither.\nconst endIndex = (\n  p: string | Matcher,\n  last: string,\n  lastStart: number,\n  prev: string | undefined,\n  prevStart: number,\n) =>\n  portionMatch(p, last) ? lastStart\n  : prev !== undefined && portionMatch(p, prev) ? prevStart\n  : -1\n\nconst isDots = (p: string) => p === '.' || p === '..'\n\n// a Windows drive letter portion, like `c:`\nconst isDrive = (p: ParseReturn | undefined) =>\n  typeof p === 'string' && /^[a-z]:$/i.test(p)\n\n// true for the `UNC` portion of a long UNC root, //?/UNC/host/share\nconst isLongUNC = (p: ParseReturn | undefined) =>\n  typeof p === 'string' && /^unc$/i.test(p)\n\n// The index of the host in a row or split path that starts with a\n// Windows UNC root: 2 for `//host/share`, and 4 for\n// `//?/UNC/host/share`. Otherwise -1. `//?/c:` is not one.\nconst uncHost = (p: ParseReturn[]) => {\n  if (p[0] !== '' || p[1] !== '') return -1\n  const h =\n    p[2] !== '?' ? 2\n    : isLongUNC(p[3]) ? 4\n    : -1\n  const host = p[h]\n  const share = p[h + 1]\n  return (\n      h !== -1 &&\n        host !== undefined &&\n        host !== '' &&\n        host !== GLOBSTAR &&\n        share !== undefined &&\n        share !== '' &&\n        share !== GLOBSTAR\n    ) ?\n      h\n    : -1\n}\n\n// true if ** can walk the path portion: not `.` or `..`, and not a\n// dotfile unless `dot` is set\nconst walkable = (p: string, dot: boolean) =>\n  !isDots(p) && (dot || !p.startsWith('.'))\n\n// True if a portion of the path from `start` to `end` can not be\n// walked by **: one that starts with `.`, or with `dot`, one that is\n// `.` or `..`. `start` is the start of a portion, and `end` is the end\n// of the path, or just after a separator.\nconst dotPortion = (\n  f: string,\n  start: number,\n  end: number,\n  dot: boolean,\n  sep: PathSeps,\n) => {\n  for (let k = start; k < end;) {\n    if (f.charCodeAt(k) === 46) {\n      if (!dot) return true\n      const n = f.charCodeAt(k + 1) === 46 ? k + 2 : k + 1\n      if (n >= end || isSep(f.charCodeAt(n), sep)) return true\n    }\n    // the start of the next portion, after any run of separators\n    const s = nextSep(f, k, sep)\n    if (s === -1) return false\n    k = s + 1\n    while (k < end && isSep(f.charCodeAt(k), sep)) k++\n  }\n  return false\n}\n\n/**\n * The separators that a path has: only `/`, only `\\` (a Windows path\n * with no `/`), or both. Scanning for the ones it has is faster.\n */\nexport type PathSeps = '/' | '\\\\' | 'both'\n\nconst isSep = (c: number, sep: PathSeps) =>\n  sep === '/' ? c === 47\n  : sep === '\\\\' ? c === 92\n  : c === 47 || c === 92\n\n// the index of the first separator at or after `from`, or -1\nconst nextSep = (f: string, from: number, sep: PathSeps) => {\n  if (sep !== 'both') return f.indexOf(sep, from)\n  const s = f.indexOf('/', from)\n  const b = f.indexOf('\\\\', from)\n  return (\n    s === -1 ? b\n    : b === -1 ? s\n    : Math.min(s, b)\n  )\n}\n\n// the index of the last separator at or before `from`, or -1\nconst lastSep = (f: string, from: number, sep: PathSeps) =>\n  sep !== 'both' ?\n    f.lastIndexOf(sep, from)\n  : Math.max(f.lastIndexOf('/', from), f.lastIndexOf('\\\\', from))\n\n/**\n * A pattern row split on its first and last `**`, from a start\n * index. Each body segment has the number of path portions that it\n * and the ones after it need, to find the last index where it can\n * start in a path.\n */\nexport type GlobstarParts = {\n  head: ParseReturn[]\n  body: ParseReturn[]\n  tail: ParseReturn[]\n  segments: [segment: ParseReturn[], need: number][]\n}\nexport type ParseReturn = ParseReturnFiltered | false\n\nexport class Minimatch {\n  options: MinimatchOptions\n  set: ParseReturnFiltered[][]\n  pattern: string\n\n  windowsPathsNoEscape: boolean\n  nonegate: boolean\n  negate: boolean\n  comment: boolean\n  empty: boolean\n  preserveMultipleSlashes: boolean\n  partial: boolean\n  globSet: string[]\n  globParts: string[][]\n  nocase: boolean\n\n  isWindows: boolean\n  platform: Platform\n  windowsNoMagicRoot: boolean\n  maxGlobstarRecursion: number\n  // the path can be checked against the last portion, and the string\n  // portions, of each row before it is split. See #canMatch.\n  #endCheck: boolean\n  #literalCheck: boolean\n  // level 2 resolves `.` and `..` portions in the path\n  #level2: boolean\n  // the unicode normalization form, if any\n  #form: Form | undefined\n  // the string portions of each row in the set\n  #literals: string[][] = []\n  // the rows that #canMatch can match without splitting the path\n  #shapes: (RowShape | undefined)[] = []\n  // the rows whose last portion can be checked against the path's\n  #endRows: boolean[] = []\n  // brace expansion can make the same portion in many rows, so they\n  // share one Matcher, and the states that it caches\n  #matchers = new Map<string, Matcher>()\n  // the GlobstarParts of each pattern row, by start index and partial\n  #globstarParts = new WeakMap<ParseReturn[], GlobstarParts[]>()\n\n  constructor(pattern: string, options: MinimatchOptions = {}) {\n    assertValidPattern(pattern)\n\n    options = options || {}\n    this.options = options\n    this.maxGlobstarRecursion = options.maxGlobstarRecursion ?? 200\n    this.pattern = pattern\n    this.platform = options.platform || defaultPlatform\n    this.isWindows = this.platform === 'win32'\n    // avoid the annoying deprecation flag lol\n    const awe = ('allowWindow' + 'sEscape') as keyof MinimatchOptions\n    this.windowsPathsNoEscape =\n      !!options.windowsPathsNoEscape || options[awe] === false\n    if (this.windowsPathsNoEscape) {\n      this.pattern = this.pattern.replace(/\\\\/g, '/')\n    }\n    this.preserveMultipleSlashes = !!options.preserveMultipleSlashes\n    this.negate = false\n    this.nonegate = !!options.nonegate\n    this.comment = false\n    this.empty = false\n    this.partial = !!options.partial\n    this.nocase = !!this.options.nocase\n    this.windowsNoMagicRoot =\n      options.windowsNoMagicRoot !== undefined ?\n        options.windowsNoMagicRoot\n      : !!(this.isWindows && this.nocase)\n\n    this.globSet = []\n    this.globParts = []\n    this.set = []\n    this.#endCheck = !this.preserveMultipleSlashes\n    this.#level2 = (options.optimizationLevel ?? 1) >= 2\n    const n = options.normalize\n    this.#form = n === true ? 'NFC' : n || undefined\n\n    // make the set of Matchers etc.\n    this.make()\n\n    // On Windows, the portions of a row up to its drive letter or UNC\n    // share are skipped or compared without case, if the path has one\n    // too. So the checks only use the portions after it.\n    const drives = this.set.map(row => this.#rootIndex(row))\n    this.#endRows = this.set.map(\n      (row, r) => this.#endCheck && row.length - 1 > drives[r]!,\n    )\n    // with the end check, the last portion is already checked\n    this.#literals = this.set.map((row, r) => {\n      const end = this.#endRows[r] ? row.length - 1 : row.length\n      const lits = row\n        .slice(drives[r]! + 1, end)\n        .filter((p): p is string => typeof p === 'string' && !!p)\n      return [...new Set(lits)]\n    })\n    this.#literalCheck = this.#literals.some(l => l.length)\n    this.#shapes = this.set.map((row, r) => {\n      const [p0, p1, p2] = row\n      if (this.#endRows[r] && row.length === 2) {\n        if (p0 === GLOBSTAR && p1 !== GLOBSTAR) return 'tail'\n      }\n      // the basename of a path that is split on / is its last portion,\n      // or the one before a trailing /, the same as the end check\n      if (\n        this.#endRows[r] &&\n        options.matchBase &&\n        row.length === 1 &&\n        p0 !== GLOBSTAR &&\n        p0 !== ''\n      ) {\n        return 'base'\n      }\n      // the portion must not be a root, or '', which can be a\n      // different portion on Windows (where //x paths get an extra '')\n      if (!this.#endCheck || drives[r] !== -1) return undefined\n      if (\n        row.length === 3 &&\n        p0 === GLOBSTAR &&\n        p2 === GLOBSTAR &&\n        p1 !== GLOBSTAR &&\n        p1 !== '' &&\n        // the portion between is only matched below this limit\n        this.maxGlobstarRecursion > 0\n      ) {\n        return 'mid'\n      }\n      if (\n        row.length === 2 &&\n        p1 === GLOBSTAR &&\n        p0 !== GLOBSTAR &&\n        p0 !== ''\n      ) {\n        return 'head'\n      }\n      return undefined\n    })\n  }\n\n  // a string portion of a pattern, normalized if the option is set\n  #norm(p: string) {\n    return this.#form ? p.normalize(this.#form) : p\n  }\n\n  // On Windows, the index of the last root portion of a row, as\n  // #matchRow finds it: 0 for `c:/...`, 3 for `//?/c:/...` and\n  // `//host/share/...`, and 5 for `//?/UNC/host/share/...`. Otherwise\n  // -1.\n  #rootIndex(row: ParseReturn[]) {\n    if (!this.isWindows) return -1\n    if (isDrive(row[0])) return 0\n    const uncDrive =\n      row[0] === '' && row[1] === '' && row[2] === '?' && isDrive(row[3])\n    if (uncDrive) return 3\n    const h = uncHost(row)\n    return h === -1 ? -1 : h + 1\n  }\n\n  hasMagic(): boolean {\n    if (this.options.magicalBraces && this.set.length > 1) {\n      return true\n    }\n    for (const pattern of this.set) {\n      for (const part of pattern) {\n        if (typeof part !== 'string') return true\n      }\n    }\n    return false\n  }\n\n  make() {\n    const pattern = this.pattern\n    const options = this.options\n\n    // empty patterns and comments match nothing.\n    if (!options.nocomment && pattern.charAt(0) === '#') {\n      this.comment = true\n      return\n    }\n\n    if (!pattern) {\n      this.empty = true\n      return\n    }\n\n    // step 1: figure out negation, etc.\n    this.parseNegate()\n\n    // step 2: expand braces\n    this.globSet = [...new Set(this.braceExpand())]\n\n    // step 3: now we have a set, so turn each one into a series of\n    // path-portion matching patterns.\n    // These will be Matchers, except in the case of \"**\", which is\n    // set to the GLOBSTAR object for globstar behavior,\n    // and will not contain any / characters\n    //\n    // First, we preprocess to make the glob pattern sets a bit simpler\n    // and deduped.  There are some perf-killing patterns that can cause\n    // problems with a glob walk, but we can simplify them down a bit.\n    const rawGlobParts = this.globSet.map(s => this.#slashSplit(s))\n    this.globParts = this.preprocess(rawGlobParts)\n\n    // glob --> Matchers\n    let set = this.globParts.map((s, _, __) => {\n      if (this.isWindows && this.windowsNoMagicRoot) {\n        // check if it's a drive or unc path. The root of a long UNC\n        // path, //?/UNC/host/share, is 6 portions.\n        const n = s[2] === '?' && isLongUNC(s[3]) ? 6 : 4\n        const isUNC =\n          s[0] === '' &&\n          s[1] === '' &&\n          (s[2] === '?' || !globMagic.test(s[2])) &&\n          s.slice(3, n).every(p => !globMagic.test(p))\n        const isDrive = /^[a-z]:/i.test(s[0])\n        if (isUNC) {\n          return [\n            ...s.slice(0, n).map(p => this.#norm(p)),\n            ...s.slice(n).map(ss => this.parse(ss)),\n          ]\n        } else if (isDrive) {\n          return [\n            this.#norm(s[0]!),\n            ...s.slice(1).map(ss => this.parse(ss)),\n          ]\n        }\n      }\n      return s.map(ss => this.parse(ss))\n    })\n\n    // filter out everything that didn't compile properly.\n    this.set = set.filter(\n      s => s.indexOf(false) === -1,\n    ) as ParseReturnFiltered[][]\n\n    // do not treat the ? in UNC paths as magic\n    if (this.isWindows) {\n      for (let i = 0; i < this.set.length; i++) {\n        const p = this.set[i]\n        if (\n          p[0] === '' &&\n          p[1] === '' &&\n          this.globParts[i][2] === '?' &&\n          (isDrive(p[3]) || isLongUNC(this.globParts[i][3]))\n        ) {\n          if (isLongUNC(this.globParts[i][3])) p[3] = 'UNC'\n          p[2] = '?'\n        }\n      }\n    }\n\n    // with noext, `@(...)` would be literal\n    if (!options.noext) this.mergeRows()\n  }\n\n  // Merge rows that only differ in one portion, where each of them\n  // is a Matcher, into one row that matches any of them with\n  // `@(a|b|...)`. Then a path is only walked once for all of them,\n  // for example with `**/*.{js,ts}`.\n  mergeRows() {\n    let merged = true\n    while (merged) {\n      merged = false\n      const len = Math.max(0, ...this.set.map(r => r.length))\n      for (let k = 0; k < len; k++) {\n        // the rows that are the same other than at portion k\n        const groups = new Map<string, number[]>()\n        this.set.forEach((row, i) => {\n          if (\n            !(row[k] instanceof Matcher) ||\n            !extSafe(this.globParts[i]![k]!)\n          ) {\n            return\n          }\n          const parts = [...this.globParts[i]!]\n          parts[k] = ''\n          const key = `${row.length}/${parts.join('/')}`\n          const g = groups.get(key)\n          if (g) g.push(i)\n          else groups.set(key, [i])\n        })\n        const drop = new Set<number>()\n        for (const g of groups.values()) {\n          if (g.length < 2) continue\n          const [first, ...rest] = g as [number, ...number[]]\n          const alts = g.map(i => this.globParts[i]![k]!)\n          const glob = `@(${alts.join('|')})`\n          this.globParts[first]![k] = glob\n          this.set[first]![k] = this.parse(glob) as Matcher\n          for (const i of rest) drop.add(i)\n        }\n        if (drop.size) {\n          merged = true\n          this.set = this.set.filter((_, i) => !drop.has(i))\n          this.globParts = this.globParts.filter((_, i) => !drop.has(i))\n        }\n      }\n    }\n  }\n\n  // various transforms to equivalent pattern sets that are\n  // faster to process in a filesystem walk.  The goal is to\n  // eliminate what we can, and push all ** patterns as far\n  // to the right as possible, even if it increases the number\n  // of patterns that we have to process.\n  preprocess(globParts: string[][]) {\n    // if we're not in globstar mode, then turn ** into *\n    if (this.options.noglobstar) {\n      for (const partset of globParts) {\n        for (let j = 0; j < partset.length; j++) {\n          if (partset[j] === '**') {\n            partset[j] = '*'\n          }\n        }\n      }\n    }\n\n    const { optimizationLevel = 1 } = this.options\n\n    if (optimizationLevel >= 2) {\n      // aggressive optimization for the purpose of fs walking\n      globParts = this.firstPhasePreProcess(globParts)\n      globParts = this.secondPhasePreProcess(globParts)\n    } else if (optimizationLevel >= 1) {\n      // just basic optimizations to remove some .. parts\n      globParts = this.levelOneOptimize(globParts)\n    } else {\n      // just collapse multiple ** portions into one\n      globParts = this.adjascentGlobstarOptimize(globParts)\n    }\n\n    return globParts\n  }\n\n  // just get rid of adjascent ** portions\n  adjascentGlobstarOptimize(globParts: string[][]) {\n    return globParts.map(parts => {\n      let gs: number = -1\n      while (-1 !== (gs = parts.indexOf('**', gs + 1))) {\n        let i = gs\n        while (parts[i + 1] === '**') {\n          i++\n        }\n        if (i !== gs) {\n          parts.splice(gs, i - gs)\n        }\n      }\n      return parts\n    })\n  }\n\n  // get rid of adjascent ** and resolve .. portions\n  levelOneOptimize(globParts: string[][]) {\n    return globParts.map(parts => {\n      // .. can not remove the root of a Windows path\n      const root = this.#rootIndex(parts) + 1\n      parts = parts.reduce((set: string[], part) => {\n        const prev = set[set.length - 1]\n        if (part === '**' && prev === '**') {\n          return set\n        }\n        if (part === '..') {\n          if (\n            set.length > root &&\n            prev &&\n            prev !== '..' &&\n            prev !== '.' &&\n            prev !== '**'\n          ) {\n            set.pop()\n            return set\n          }\n        }\n        set.push(part)\n        return set\n      }, [])\n      return parts.length === 0 ? [''] : parts\n    })\n  }\n\n  // Check the path against each row before it is split. 'no' if no\n  // row can match, so it does not need to be split. 'yes' if a row of\n  // `**` and one more portion matches. 'maybe' if it must be split to\n  // know. None of this applies with partial, where the path can end\n  // before the row does.\n  //\n  // On Windows, `\\` is a separator in the path too, and the portions of\n  // a row up to its drive letter or UNC share are not checked (see\n  // #rootIndex).\n  //\n  // Each string portion of a row must be a portion of the path, so the\n  // path must contain it. Level 2 can only take portions out of the\n  // path, so this is still true then.\n  //\n  // The last portion of a row must match the last portion of the path,\n  // or the one before a trailing `/` (as a/* and a/**/* match a/b/).\n  // This does not apply to rows that end in **, rows that end in a\n  // root, or preserveMultipleSlashes (which can leave more\n  // than one '' at the end). At level 2, it does not apply if that\n  // portion is `.` or `..`, which can be\n  // resolved away. Level 2 only takes other portions out of the\n  // middle of the path.\n  //\n  // A row of `**/x` then matches if the ** can walk the portions\n  // before the one that x matches, the same as #matchGlobstar. At\n  // level 2, this is only known if none of them are `.` or `..`, so\n  // that the path does not change when it is resolved.\n  #canMatch(f: string): 'no' | 'yes' | 'maybe' {\n    const sep: PathSeps =\n      !this.isWindows || !f.includes('\\\\') ? '/'\n      : f.includes('/') ? 'both'\n      : '\\\\'\n    // the portions that f.split(/\\/+/) would end with, and where they\n    // start in f, found when a row needs them. `ends` is 0 until they\n    // are found, then 1, or -1 if they can not be used.\n    let ends = this.#endCheck ? 0 : -1\n    let last = ''\n    let lastStart = 0\n    let prev: string | undefined\n    let prevStart = 0\n    const dot = !!this.options.dot\n    // A string compare is cheaper than includes(), and a Matcher test\n    // costs more, so the cheaper check goes first.\n    ROWS: for (let r = 0; r < this.set.length; r++) {\n      const row = this.set[r]!\n      const p = row[row.length - 1]\n      let end = ends !== -1 && this.#endRows[r]! && p !== GLOBSTAR\n      if (end && ends === 0) {\n        const i = lastSep(f, f.length, sep)\n        lastStart = i + 1\n        last = f.slice(lastStart)\n        if (last === '' && i >= 0) {\n          let j = i\n          while (j > 0 && isSep(f.charCodeAt(j - 1), sep)) j--\n          prevStart = j === 0 ? 0 : lastSep(f, j - 1, sep) + 1\n          prev = f.slice(prevStart, j)\n        }\n        const resolves =\n          this.#level2 &&\n          (isDots(last) ||\n            (last === '' && prev !== undefined && isDots(prev)))\n        ends = resolves ? -1 : 1\n        end = !resolves\n      }\n      let tailStart = -1\n      if (end && typeof p === 'string') {\n        tailStart = endIndex(p, last, lastStart, prev, prevStart)\n        if (tailStart === -1) continue\n      }\n      if (this.#literalCheck) {\n        for (const l of this.#literals[r]!) {\n          if (!f.includes(l)) continue ROWS\n        }\n      }\n      if (end && typeof p === 'object') {\n        tailStart = endIndex(p, last, lastStart, prev, prevStart)\n        if (tailStart === -1) continue\n      }\n      const shape = this.#shapes[r]\n      if (shape === 'base' && end) return 'yes'\n      if (shape === 'tail' && end) {\n        if (this.#level2 && dotPortion(f, 0, tailStart, true, sep)) {\n          return 'maybe'\n        }\n        if (!dotPortion(f, 0, tailStart, dot, sep)) return 'yes'\n        continue\n      }\n      if (shape === 'mid' || shape === 'head') {\n        const m = this.#walk(f, row, shape === 'head', dot, sep)\n        if (m !== 'no') return m\n        continue\n      }\n      return 'maybe'\n    }\n    return 'no'\n  }\n\n  // Match a row of a known shape against the split path, the same as\n  // #matchGlobstar and #matchGlobStarBodySections do. None of these\n  // rows have a drive letter, so they start at the first portion.\n  #matchShape(\n    file: string[],\n    row: ParseReturnFiltered[],\n    shape: 'tail' | 'mid' | 'head',\n  ): boolean {\n    const dot = !!this.options.dot\n    const n = file.length\n    if (shape === 'head') {\n      // x, then at least one portion that ** can walk\n      if (n < 2 || !portionMatch(row[0] as string | Matcher, file[0]!)) {\n        return false\n      }\n      for (let i = 1; i < n; i++)\n        if (!walkable(file[i]!, dot)) return false\n      return true\n    }\n    const x = row[1] as string | Matcher\n    if (shape === 'tail') {\n      // x is the last portion, or the one before a trailing ''\n      let t = n - 1\n      if (!portionMatch(x, file[t]!)) {\n        if (file[t] !== '' || n === 1 || !portionMatch(x, file[--t]!)) {\n          return false\n        }\n      }\n      for (let i = 0; i < t; i++)\n        if (!walkable(file[i]!, dot)) return false\n      return true\n    }\n    // mid: the first x that ** can walk to, with a portion after it,\n    // and ** can walk all of those\n    for (let k = 0; k < n; k++) {\n      if (portionMatch(x, file[k]!) && k + 1 < n) {\n        let i = k + 1\n        while (i < n && walkable(file[i]!, dot)) i++\n        if (i === n) return true\n      }\n      if (!walkable(file[k]!, dot)) return false\n    }\n    return false\n  }\n\n  // Match a row of `**/x/**` or `x/**` against the path, the same as\n  // #matchGlobstar and #matchGlobStarBodySections do once it is split.\n  // x must match a portion (the first one, for `x/**`), the ** before\n  // it must be able to walk the portions before that one, and there\n  // must be a portion after it, which the ** after it can walk. At\n  // level 2, this is only known if no portion is `.` or `..`.\n  #walk(\n    f: string,\n    row: ParseReturnFiltered[],\n    head: boolean,\n    dot: boolean,\n    sep: PathSeps,\n  ): 'yes' | 'no' | 'maybe' {\n    if (this.#level2 && dotPortion(f, 0, f.length, true, sep))\n      return 'maybe'\n    const x = row[head ? 0 : 1] as string | Matcher\n    // the last portion has none after it, so it can not be x\n    let s = 0\n    for (let e = nextSep(f, s, sep); e !== -1; e = nextSep(f, s, sep)) {\n      // the start of the next portion\n      let next = e + 1\n      while (next < f.length && isSep(f.charCodeAt(next), sep)) next++\n      const hit =\n        typeof x === 'string' ?\n          e - s === x.length && f.startsWith(x, s)\n        : e > s && x.testUnchecked(f.slice(s, e))\n      if (hit && !dotPortion(f, next, f.length, dot, sep)) return 'yes'\n      if (head || dotPortion(f, s, next, dot, sep)) return 'no'\n      s = next\n    }\n    return 'no'\n  }\n\n  // the last split, if it was the same path with the same split\n  // settings\n  #cachedSplit(f: string) {\n    const last = lastSplit\n    return (\n        last?.f === f &&\n          last.isWindows === this.isWindows &&\n          last.preserveMultipleSlashes === this.preserveMultipleSlashes &&\n          last.normalize === this.#form\n      ) ?\n        last\n      : undefined\n  }\n\n  // split a path for match(), and keep the parts for the next call\n  #split(f: string) {\n    const { isWindows, preserveMultipleSlashes } = this\n    // windows: need to use /, not \\\n    let parts = this.#slashSplit(isWindows ? f.split('\\\\').join('/') : f)\n    // normalize each portion, so that a char that normalizes to `/`\n    // does not make a new portion\n    const normalize = this.#form\n    if (normalize) parts = parts.map(p => p.normalize(normalize))\n    lastSplit = {\n      f,\n      isWindows,\n      preserveMultipleSlashes,\n      normalize,\n      parts,\n    }\n    return lastSplit\n  }\n\n  // resolve `.` and `..` portions of a path, for level 2\n  #levelTwoFileOptimize(file: string[]) {\n    // work on a copy, so that the cached parts do not change\n    const parts = [...file]\n    let didSomething: boolean = false\n\n    do {\n      didSomething = false\n      // <pre>/<e>/<rest> -> <pre>/<rest>\n      if (!this.preserveMultipleSlashes) {\n        for (let i = 1; i < parts.length - 1; i++) {\n          const p = parts[i]\n          // don't squeeze out UNC patterns\n          if (i === 1 && p === '' && parts[0] === '') continue\n          if (p === '.' || p === '') {\n            didSomething = true\n            parts.splice(i, 1)\n            i--\n          }\n        }\n        if (\n          parts[0] === '.' &&\n          parts.length === 2 &&\n          (parts[1] === '.' || parts[1] === '')\n        ) {\n          didSomething = true\n          parts.pop()\n        }\n      }\n\n      // <pre>/<p>/../<rest> -> <pre>/<rest>\n      // .. can not remove the root of a Windows path\n      const root = this.#rootIndex(parts) + 1\n      let dd: number = root\n      while (-1 !== (dd = parts.indexOf('..', dd + 1))) {\n        const p = parts[dd - 1]\n        if (p && p !== '.' && p !== '..' && p !== '**') {\n          didSomething = true\n          parts.splice(dd - 1, 2)\n          dd = Math.max(dd - 2, root)\n        }\n      }\n    } while (didSomething)\n    return parts.length === 0 ? [''] : parts\n  }\n\n  // First phase: single-pattern processing\n  // <pre> is 1 or more portions\n  // <rest> is 1 or more portions\n  // <p> is any portion other than ., .., '', or **\n  // <e> is . or ''\n  //\n  // **/.. is *brutal* for filesystem walking performance, because\n  // it effectively resets the recursive walk each time it occurs,\n  // and ** cannot be reduced out by a .. pattern part like a regexp\n  // or most strings (other than .., ., and '') can be.\n  //\n  // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}\n  // <pre>/<e>/<rest> -> <pre>/<rest>\n  // <pre>/<p>/../<rest> -> <pre>/<rest>\n  // **/**/<rest> -> **/<rest>\n  //\n  // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow\n  // this WOULD be allowed if ** did follow symlinks, or * didn't\n  firstPhasePreProcess(globParts: string[][]) {\n    // each **/.. split doubles the patterns, so stop at the brace max\n    const { braceExpandMax = 100_000 } = this.options\n    let didSomething = false\n    do {\n      didSomething = false\n      // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}\n      for (let parts of globParts) {\n        let gs: number = -1\n        while (-1 !== (gs = parts.indexOf('**', gs + 1))) {\n          let gss: number = gs\n          while (parts[gss + 1] === '**') {\n            // <pre>/**/**/<rest> -> <pre>/**/<rest>\n            gss++\n          }\n          // eg, if gs is 2 and gss is 4, that means we have 3 **\n          // parts, and can remove 2 of them.\n          if (gss > gs) {\n            parts.splice(gs + 1, gss - gs)\n          }\n\n          let next = parts[gs + 1]\n          const p = parts[gs + 2]\n          const p2 = parts[gs + 3]\n          if (next !== '..') continue\n          if (\n            !p ||\n            p === '.' ||\n            p === '..' ||\n            !p2 ||\n            p2 === '.' ||\n            p2 === '..' ||\n            globParts.length >= braceExpandMax\n          ) {\n            continue\n          }\n          didSomething = true\n          // edit parts in place, and push the new one\n          parts.splice(gs, 1)\n          const other = parts.slice(0)\n          other[gs] = '**'\n          globParts.push(other)\n          gs--\n        }\n\n        // <pre>/<e>/<rest> -> <pre>/<rest>\n        if (!this.preserveMultipleSlashes) {\n          for (let i = 1; i < parts.length - 1; i++) {\n            const p = parts[i]\n            // don't squeeze out UNC patterns\n            if (i === 1 && p === '' && parts[0] === '') continue\n            if (p === '.' || p === '') {\n              didSomething = true\n              parts.splice(i, 1)\n              i--\n            }\n          }\n          if (\n            parts[0] === '.' &&\n            parts.length === 2 &&\n            (parts[1] === '.' || parts[1] === '')\n          ) {\n            didSomething = true\n            parts.pop()\n          }\n        }\n\n        // <pre>/<p>/../<rest> -> <pre>/<rest>\n        // .. can not remove the root of a Windows path\n        const root = this.#rootIndex(parts) + 1\n        let dd: number = root\n        while (-1 !== (dd = parts.indexOf('..', dd + 1))) {\n          const p = parts[dd - 1]\n          if (p && p !== '.' && p !== '..' && p !== '**') {\n            didSomething = true\n            const needDot = dd === 1 && parts[dd + 1] === '**'\n            const splin = needDot ? ['.'] : []\n            parts.splice(dd - 1, 2, ...splin)\n            if (parts.length === 0) parts.push('')\n            dd = Math.max(dd - 2, root)\n          }\n        }\n      }\n    } while (didSomething)\n\n    return globParts\n  }\n\n  // second phase: multi-pattern dedupes\n  // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>\n  // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>\n  // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>\n  //\n  // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>\n  // ^-- not valid because ** doens't follow symlinks\n  secondPhasePreProcess(globParts: string[][]): string[][] {\n    // each pattern is compared to each other one, so skip this for\n    // large sets. The patterns match the same paths either way.\n    if (globParts.length > 1000) return globParts\n    for (let i = 0; i < globParts.length - 1; i++) {\n      for (let j = i + 1; j < globParts.length; j++) {\n        const matched = this.partsMatch(\n          globParts[i],\n          globParts[j],\n          !this.preserveMultipleSlashes,\n        )\n        if (matched) {\n          globParts[i] = []\n          globParts[j] = matched\n          break\n        }\n      }\n    }\n    return globParts.filter(gs => gs.length)\n  }\n\n  partsMatch(\n    a: string[],\n    b: string[],\n    emptyGSMatch: boolean = false,\n  ): false | string[] {\n    let ai = 0\n    let bi = 0\n    let result: string[] = []\n    let which: string = ''\n    while (ai < a.length && bi < b.length) {\n      if (a[ai] === b[bi]) {\n        result.push(which === 'b' ? b[bi] : a[ai])\n        ai++\n        bi++\n      } else if (emptyGSMatch && a[ai] === '**' && b[bi] === a[ai + 1]) {\n        result.push(a[ai])\n        ai++\n      } else if (emptyGSMatch && b[bi] === '**' && a[ai] === b[bi + 1]) {\n        result.push(b[bi])\n        bi++\n      } else if (\n        a[ai] === '*' &&\n        b[bi] &&\n        (this.options.dot || !b[bi].startsWith('.')) &&\n        b[bi] !== '**'\n      ) {\n        if (which === 'b') return false\n        which = 'a'\n        result.push(a[ai])\n        ai++\n        bi++\n      } else if (\n        b[bi] === '*' &&\n        a[ai] &&\n        (this.options.dot || !a[ai].startsWith('.')) &&\n        a[ai] !== '**'\n      ) {\n        if (which === 'a') return false\n        which = 'b'\n        result.push(b[bi])\n        ai++\n        bi++\n      } else {\n        return false\n      }\n    }\n    // if we fall out of the loop, it means they two are identical\n    // as long as their lengths match\n    return a.length === b.length && result\n  }\n\n  parseNegate() {\n    if (this.nonegate) return\n\n    const pattern = this.pattern\n    let negate = false\n    let negateOffset = 0\n\n    for (let i = 0; i < pattern.length && pattern.charAt(i) === '!'; i++) {\n      negate = !negate\n      negateOffset++\n    }\n\n    if (negateOffset) this.pattern = pattern.slice(negateOffset)\n    this.negate = negate\n  }\n\n  // Match the parts of a path against one row of the set. `resolved`\n  // is the parts after level 2 resolves `.` and `..` in them, or the\n  // same parts below level 2. Set partial to true to test if, for\n  // example, \"/a/b\" matches the start of \"/*/b/*/d\". Partial means, if\n  // you run out of file before you run out of pattern, then that's\n  // fine, as long as all the parts match.\n  #matchRow(\n    file: string[],\n    resolved: string[],\n    pattern: ParseReturn[],\n    partial: boolean,\n  ) {\n    let fileStartIndex = 0\n    let patternStartIndex = 0\n\n    // UNC paths like //?/X:/... can match X:/... and vice versa, and\n    // //?/UNC/host/share/... can match //host/share/... and vice versa.\n    // Drive letters in absolute drive or unc paths, and the host and\n    // share of UNC paths, are always compared case-insensitively.\n    const fh = this.isWindows ? uncHost(resolved) : -1\n    const ph = fh === -1 ? -1 : uncHost(pattern)\n    if (ph !== -1) {\n      const host = pattern[ph]\n      const share = pattern[ph + 1]\n      if (typeof host !== 'string' || typeof share !== 'string') {\n        // a host or share with magic is matched as usual\n        fileStartIndex = fh\n        patternStartIndex = ph\n      } else if (\n        resolved[fh]!.toLowerCase() === host.toLowerCase() &&\n        resolved[fh + 1]!.toLowerCase() === share.toLowerCase()\n      ) {\n        fileStartIndex = fh + 2\n        patternStartIndex = ph + 2\n      }\n    } else if (this.isWindows) {\n      const fileDrive =\n        typeof file[0] === 'string' && /^[a-z]:$/i.test(file[0])\n      const fileUNC =\n        !fileDrive &&\n        file[0] === '' &&\n        file[1] === '' &&\n        file[2] === '?' &&\n        /^[a-z]:$/i.test(file[3])\n\n      const patternDrive =\n        typeof pattern[0] === 'string' && /^[a-z]:$/i.test(pattern[0])\n      const patternUNC =\n        !patternDrive &&\n        pattern[0] === '' &&\n        pattern[1] === '' &&\n        pattern[2] === '?' &&\n        typeof pattern[3] === 'string' &&\n        /^[a-z]:$/i.test(pattern[3])\n\n      const fdi =\n        fileUNC ? 3\n        : fileDrive ? 0\n        : undefined\n      const pdi =\n        patternUNC ? 3\n        : patternDrive ? 0\n        : undefined\n      if (typeof fdi === 'number' && typeof pdi === 'number') {\n        const [fd, pd]: [string, string] = [\n          file[fdi],\n          pattern[pdi] as string,\n        ]\n        // the drives match, so start matching after them\n        if (fd.toLowerCase() === pd.toLowerCase()) {\n          patternStartIndex = pdi + 1\n          fileStartIndex = fdi + 1\n        }\n      }\n    }\n\n    // the drive letters are found in the parts before level 2 resolves\n    // them, and the match uses the resolved parts\n    file = resolved\n\n    if (pattern.includes(GLOBSTAR)) {\n      return this.#matchGlobstar(\n        file,\n        pattern,\n        partial,\n        fileStartIndex,\n        patternStartIndex,\n      )\n    }\n\n    return this.#matchOne(\n      file,\n      pattern,\n      partial,\n      fileStartIndex,\n      patternStartIndex,\n    )\n  }\n\n  #matchGlobstar(\n    file: string[],\n    pattern: ParseReturn[],\n    partial: boolean,\n    fileIndex: number,\n    patternIndex: number,\n  ) {\n    const { head, body, tail, segments } = this.#getGlobstarParts(\n      pattern,\n      partial,\n      patternIndex,\n    )\n\n    // check the head, from the current file/pattern index.\n    if (head.length) {\n      const headEnd = fileIndex + head.length\n      if (!this.#matchOne(file, head, partial, fileIndex, 0, headEnd)) {\n        return false\n      }\n      fileIndex += head.length\n      patternIndex += head.length\n    }\n    // now we know the head matches!\n\n    // if the last portion is not empty, it MUST match the end\n    // check the tail\n    let fileTailMatch: number = 0\n    if (tail.length) {\n      // if head + tail > file, then we cannot possibly match\n      if (tail.length + fileIndex > file.length) return false\n\n      // try to match the tail\n      let tailStart = file.length - tail.length\n      if (this.#matchOne(file, tail, partial, tailStart, 0)) {\n        fileTailMatch = tail.length\n      } else {\n        // affordance for stuff like a/**/* matching a/b/\n        // if the last file portion is '', and there's more to the pattern\n        // then try without the '' bit.\n        if (\n          file[file.length - 1] !== '' ||\n          fileIndex + tail.length === file.length\n        ) {\n          return false\n        }\n        tailStart--\n        if (!this.#matchOne(file, tail, partial, tailStart, 0)) {\n          return false\n        }\n        fileTailMatch = tail.length + 1\n      }\n    }\n\n    // now we know the tail matches!\n\n    // the middle is zero or more portions wrapped in **, possibly\n    // containing more ** sections.\n    // so a/**/b/**/c/**/d has become **/b/**/c/**\n    // if it's empty, it means a/**/b, just verify we have no bad dots\n    // if there's no tail, so it ends on /**, then we must have *something*\n    // after the head, or it's not a matc\n    if (!body.length) {\n      let sawSome = !!fileTailMatch\n      for (let i = fileIndex; i < file.length - fileTailMatch; i++) {\n        const f = String(file[i])\n        sawSome = true\n        if (\n          f === '.' ||\n          f === '..' ||\n          (!this.options.dot && f.startsWith('.'))\n        ) {\n          return false\n        }\n      }\n      // in partial mode, we just need to get past all file parts\n      return partial || sawSome\n    }\n\n    // now we know that there's one or more body sections, which can\n    // be matched anywhere from the 0 index (because the head was pruned)\n    // through to the length-fileTailMatch index.\n    return !!this.#matchGlobStarBodySections(\n      file,\n      segments,\n      file.length - fileTailMatch,\n      fileIndex,\n      0,\n      partial,\n      0,\n      !!fileTailMatch,\n      new Set(),\n    )\n  }\n\n  // Split the pattern into head, tail, and middle of ** delimited\n  // parts. The tail has to be at the end, and the others just have to\n  // be found in order from the head. These only depend on the pattern\n  // row, so they are kept for the next path.\n  #getGlobstarParts(\n    pattern: ParseReturn[],\n    partial: boolean,\n    patternIndex: number,\n  ): GlobstarParts {\n    let byStart = this.#globstarParts.get(pattern)\n    if (!byStart) {\n      byStart = []\n      this.#globstarParts.set(pattern, byStart)\n    }\n    const key = patternIndex * 2 + (partial ? 1 : 0)\n    const found = byStart[key]\n    if (found) return found\n\n    const firstgs = pattern.indexOf(GLOBSTAR, patternIndex)\n    const lastgs = pattern.lastIndexOf(GLOBSTAR)\n    const head = pattern.slice(patternIndex, firstgs)\n    const body = pattern.slice(firstgs + 1, partial ? undefined : lastgs)\n    const tail = partial ? [] : pattern.slice(lastgs + 1)\n\n    // split the body up into sections, and note the number of\n    // portions that must come after the start of each one\n    const segments: [ParseReturn[], number][] = [[[], 0]]\n    let current = segments[0]!\n    let nonGsParts = 0\n    const nonGsPartsSums: number[] = [0]\n    for (const b of body) {\n      if (b === GLOBSTAR) {\n        nonGsPartsSums.push(nonGsParts)\n        current = [[], 0]\n        segments.push(current)\n      } else {\n        current[0].push(b)\n        nonGsParts++\n      }\n    }\n    // the portions in this section and the ones after it\n    segments.forEach((b, i) => {\n      b[1] = nonGsParts - (nonGsPartsSums[i] as number)\n    })\n\n    const parts = { head, body, tail, segments }\n    byStart[key] = parts\n    return parts\n  }\n\n  // return false for \"nope, not matching\"\n  // return null for \"not matching, cannot keep trying\"\n  #matchGlobStarBodySections(\n    file: string[],\n    // pattern section, and the portions that it and the rest need\n    bodySegments: [ParseReturn[], number][],\n    // the end of the file portions that the body can match\n    fileLength: number,\n    fileIndex: number,\n    bodyIndex: number,\n    partial: boolean,\n    globStarDepth: number,\n    sawTail: boolean,\n    // the places that a walk has already tried, as\n    // bodyIndex * (file.length + 1) + fileIndex. A walk from a place\n    // does the same no matter how it got there, and it only comes back\n    // if it found no match, so a walk that gets to one stops.\n    tried: Set<number>,\n  ): boolean | null {\n    // take the first body segment, and walk from fileIndex to its \"after\"\n    // value at the end\n    // If it doesn't match at that position, we increment, until we hit\n    // that final possible position, and give up.\n    // If it does match, then advance and try to rest.\n    // If any of them fail we keep walking forward.\n    // this is still a bit recursively painful, but it's more constrained\n    // than previous implementations, because we never test something that\n    // can't possibly be a valid matching condition.\n    const bs = bodySegments[bodyIndex]\n    if (!bs) {\n      // with partial, the body is the rest of the pattern, so it\n      // matches if no portions are left, or only the '' of a trailing\n      // / (as a/* matches a/b/). A ** at the end walks them as its own\n      // empty section.\n      if (partial) {\n        return (\n          fileIndex >= fileLength ||\n          (fileIndex === fileLength - 1 && file[fileIndex] === '')\n        )\n      }\n      // just make sure that there's no bad dots before the tail\n      for (let i = fileIndex; i < fileLength; i++) {\n        sawTail = true\n        const f = file[i]\n        if (\n          f === '.' ||\n          f === '..' ||\n          (!this.options.dot && f.startsWith('.'))\n        ) {\n          return false\n        }\n      }\n      return sawTail\n    }\n\n    // have a non-globstar body section to test, up to the last index\n    // where it can start\n    const [body, need] = bs\n    // with partial, the path can end before the body does\n    const after = partial ? fileLength : fileLength - need\n    while (fileIndex <= after) {\n      const key = bodyIndex * (file.length + 1) + fileIndex\n      if (tried.has(key)) return false\n      tried.add(key)\n      const m = this.#matchOne(\n        file,\n        body,\n        partial,\n        fileIndex,\n        0,\n        fileIndex + body.length,\n      )\n      // if limit exceeded, no match. intentional false negative,\n      // acceptable break in correctness for security.\n      if (m && globStarDepth < this.maxGlobstarRecursion) {\n        // match! see if the rest match. if so, we're done!\n        const sub = this.#matchGlobStarBodySections(\n          file,\n          bodySegments,\n          fileLength,\n          fileIndex + body.length,\n          bodyIndex + 1,\n          partial,\n          globStarDepth + 1,\n          sawTail,\n          tried,\n        )\n        if (sub !== false) {\n          return sub\n        }\n      }\n      // the ** does not walk past the last place the body can start\n      if (fileIndex === after) break\n      const f = file[fileIndex]!\n      if (\n        f === '.' ||\n        f === '..' ||\n        (!this.options.dot && f.startsWith('.'))\n      ) {\n        return false\n      }\n\n      fileIndex++\n    }\n    // walked off. no point continuing\n    return partial || null\n  }\n\n  #matchOne(\n    file: string[],\n    pattern: ParseReturn[],\n    partial: boolean,\n    fileIndex: number,\n    patternIndex: number,\n    // only match the file portions before this index\n    fileEnd: number = file.length,\n  ) {\n    let fi: number\n    let pi: number\n    let pl: number\n    let fl: number\n    for (\n      fi = fileIndex,\n        pi = patternIndex,\n        fl = Math.min(fileEnd, file.length),\n        pl = pattern.length;\n      fi < fl && pi < pl;\n      fi++, pi++\n    ) {\n      let p = pattern[pi]\n      let f = file[fi]\n\n      // should be impossible.\n      /* c8 ignore start */\n      if (p === false || p === GLOBSTAR) {\n        return false\n      }\n      /* c8 ignore stop */\n\n      // something other than **\n      // non-magic patterns just have to match exactly\n      // patterns with magic have been turned into Matchers.\n      if (!portionMatch(p, f)) return false\n    }\n\n    // Note: ending in / means that we'll get a final \"\"\n    // at the end of the pattern.  This can only match a\n    // corresponding \"\" at the end of the file.\n    // If the file ends in /, then it can only match a\n    // a pattern that ends in /, unless the pattern just\n    // doesn't have any more for it. But, a/b/ should *not*\n    // match \"a/b/*\", even though * can match \"\", except in\n    // partial mode, where it might simply not be reached yet.\n    // However, a/b/ should still satisfy a/*\n\n    // now either we fell off the end of the pattern, or we're done.\n    if (fi === fl && pi === pl) {\n      // ran out of pattern and filename at the same time.\n      // an exact hit!\n      return true\n    } else if (fi === fl) {\n      // ran out of file, but still had pattern left.\n      // this is ok if we're doing the match as part of\n      // a glob fs traversal.\n      return partial\n    } else if (pi === pl) {\n      // ran out of pattern, still have file left.\n      // this is only acceptable if we're on the very last\n      // empty segment of a file with a trailing slash.\n      // a/* should match a/b/\n      return fi === fl - 1 && file[fi] === ''\n\n      /* c8 ignore start */\n    } else {\n      // should be unreachable.\n      throw new Error('wtf?')\n    }\n    /* c8 ignore stop */\n  }\n\n  braceExpand() {\n    return braceExpand(this.pattern, this.options)\n  }\n\n  parse(pattern: string): ParseReturn {\n    assertValidPattern(pattern)\n\n    const options = this.options\n\n    // shortcuts\n    if (pattern === '**') return GLOBSTAR\n    if (pattern === '') return ''\n\n    const {\n      nocase,\n      nocaseMagicOnly,\n      noext = false,\n      dot,\n      normalize,\n    } = options\n    const lit = literal(pattern, noext)\n    // in nocase mode, a literal with cased chars still needs a\n    // Matcher, unless nocaseMagicOnly is set.\n    if (\n      lit !== undefined &&\n      !(\n        nocase &&\n        !nocaseMagicOnly &&\n        pattern.toUpperCase() !== pattern.toLowerCase()\n      )\n    ) {\n      return this.#norm(lit)\n    }\n\n    let m = this.#matchers.get(pattern)\n    if (!m) {\n      m = new Matcher(pattern, { nocase, noext, dot, normalize })\n      this.#matchers.set(pattern, m)\n    }\n    return m\n  }\n\n  #slashSplit(p: string) {\n    // if p starts with // on windows, we preserve that\n    // so that UNC paths aren't broken.  Otherwise, any number of\n    // / characters are coalesced into one, unless\n    // preserveMultipleSlashes is set to true.\n    if (this.preserveMultipleSlashes) {\n      return p.split('/')\n    } else if (this.isWindows && /^\\/\\/[^/]+/.test(p)) {\n      // add an extra '' for the one we lose\n      return ['', ...p.split(/\\/+/)]\n    } else {\n      return p.split(/\\/+/)\n    }\n  }\n\n  match(f: string, partial = this.partial) {\n    // short-circuit in the case of busted things.\n    // comments, etc.\n    if (this.comment) {\n      return false\n    }\n    if (this.empty) {\n      return f === ''\n    }\n\n    if (f === '/' && partial) {\n      return true\n    }\n\n    const options = this.options\n\n    // treat the test path as a set of pathparts. If it was not just\n    // split or checked, check that it can match before splitting it.\n    let split = this.#cachedSplit(f)\n    if (!split) {\n      // the checks look at the path as given, so not if it is\n      // normalized\n      if (\n        !partial &&\n        !this.#form &&\n        (this.#endCheck || this.#literalCheck) &&\n        lastChecked !== f\n      ) {\n        lastChecked = f\n        const can = this.#canMatch(f)\n        if (can === 'no') return options.flipNegate ? false : this.negate\n        if (can === 'yes') return options.flipNegate ? true : !this.negate\n      }\n      split = this.#split(f)\n    }\n    const ff = split.parts\n    // the parts after level 2 resolves them, kept for the next pattern\n    // that tests the same path\n    const resolved =\n      this.#level2 ?\n        (split.resolved ??= this.#levelTwoFileOptimize(ff))\n      : ff\n\n    // just ONE of the pattern sets in this.set needs to match\n    // in order for it to be valid.  If negating, then just one\n    // match means that we have failed.\n    // Either way, return on the first hit.\n\n    const set = this.set\n\n    // Find the basename of the path by looking for the last non-empty segment\n    let filename: string = ff[ff.length - 1]\n    if (!filename) {\n      for (let i = ff.length - 2; !filename && i >= 0; i--) {\n        filename = ff[i]\n      }\n    }\n\n    for (let r = 0; r < set.length; r++) {\n      const pattern = set[r]!\n      const shape = partial ? undefined : this.#shapes[r]\n      // level 2 does not change a path of one portion\n      const hit =\n        shape === 'base' ?\n          portionMatch(pattern[0] as string | Matcher, filename)\n        : shape ? this.#matchShape(resolved, pattern, shape)\n        : options.matchBase && pattern.length === 1 ?\n          this.#matchRow([filename], [filename], pattern, partial)\n        : this.#matchRow(ff, resolved, pattern, partial)\n      if (hit) {\n        if (options.flipNegate) {\n          return true\n        }\n        return !this.negate\n      }\n    }\n\n    // didn't get any hits.  this is success if it's a negative\n    // pattern, failure otherwise.\n    if (options.flipNegate) {\n      return false\n    }\n    return this.negate\n  }\n\n  static defaults(def: MinimatchOptions) {\n    return minimatch.defaults(def).Minimatch\n  }\n}\n/* c8 ignore start */\nexport { escape } from './escape.js'\nexport { unescape } from './unescape.js'\nexport type { Form }\n/* c8 ignore stop */\nminimatch.Minimatch = Minimatch\nminimatch.escape = escape\nminimatch.unescape = unescape\n", "import type { Form, MinimatchOptions } from 'minimatch'\nimport { Minimatch } from 'minimatch'\nimport type { Minipass } from 'minipass'\nimport { fileURLToPath } from 'node:url'\nimport type { FSOption, Path } from 'path-scurry'\nimport {\n  PathScurry,\n  PathScurryDarwin,\n  PathScurryPosix,\n  PathScurryWin32,\n} from 'path-scurry'\nimport type { IgnoreLike } from './ignore.js'\nimport { Pattern } from './pattern.js'\nimport { GlobStream, GlobWalker } from './walker.js'\n\nexport type MatchSet = Minimatch['set']\nexport type GlobParts = Exclude<Minimatch['globParts'], undefined>\n\n// if no process global, just call it linux.\n// so we default to case-sensitive, / separators\nconst defaultPlatform: NodeJS.Platform =\n  (\n    typeof process === 'object' &&\n    process &&\n    typeof process.platform === 'string'\n  ) ?\n    process.platform\n  : 'linux'\n\n/**\n * A `GlobOptions` object may be provided to any of the exported methods, and\n * must be provided to the `Glob` constructor.\n *\n * All options are optional, boolean, and false by default, unless otherwise\n * noted.\n *\n * All resolved options are added to the Glob object as properties.\n *\n * If you are running many `glob` operations, you can pass a Glob object as the\n * `options` argument to a subsequent operation to share the previously loaded\n * cache.\n */\nexport interface GlobOptions {\n  /**\n   * Set to `true` to always receive absolute paths for\n   * matched files. Set to `false` to always return relative paths.\n   *\n   * When this option is not set, absolute paths are returned for patterns\n   * that are absolute, and otherwise paths are returned that are relative\n   * to the `cwd` setting.\n   *\n   * This does _not_ make an extra system call to get\n   * the realpath, it only does string path resolution.\n   *\n   * Conflicts with {@link withFileTypes}\n   */\n  absolute?: boolean\n\n  /**\n   * Set to false to enable {@link windowsPathsNoEscape}\n   *\n   * @deprecated\n   */\n  allowWindowsEscape?: boolean\n\n  /**\n   * The current working directory in which to search. Defaults to\n   * `process.cwd()`.\n   *\n   * May be eiher a string path or a `file://` URL object or string.\n   */\n  cwd?: string | URL\n\n  /**\n   * Include `.dot` files in normal matches and `globstar`\n   * matches. Note that an explicit dot in a portion of the pattern\n   * will always match dot files.\n   */\n  dot?: boolean\n\n  /**\n   * Prepend all relative path strings with `./` (or `.\\` on Windows).\n   *\n   * Without this option, returned relative paths are \"bare\", so instead of\n   * returning `'./foo/bar'`, they are returned as `'foo/bar'`.\n   *\n   * Relative patterns starting with `'../'` are not prepended with `./`, even\n   * if this option is set.\n   */\n  dotRelative?: boolean\n\n  /**\n   * Follow symlinked directories when expanding `**`\n   * patterns. This can result in a lot of duplicate references in\n   * the presence of cyclic links, and make performance quite bad.\n   *\n   * By default, a `**` in a pattern will follow 1 symbolic link if\n   * it is not the first item in the pattern, or none if it is the\n   * first item in the pattern, following the same behavior as Bash.\n   */\n  follow?: boolean\n\n  /**\n   * string or string[], or an object with `ignored` and `childrenIgnored`\n   * methods.\n   *\n   * If a string or string[] is provided, then this is treated as a glob\n   * pattern or array of glob patterns to exclude from matches. To ignore all\n   * children within a directory, as well as the entry itself, append `'/**'`\n   * to the ignore pattern.\n   *\n   * **Note** `ignore` patterns are _always_ in `dot:true` mode, regardless of\n   * any other settings.\n   *\n   * If an object is provided that has `ignored(path)` and/or\n   * `childrenIgnored(path)` methods, then these methods will be called to\n   * determine whether any Path is a match or if its children should be\n   * traversed, respectively.\n   */\n  readonly ignore?: string | string[] | IgnoreLike | ReadonlyArray<string>\n\n  /**\n   * Treat brace expansion like `{a,b}` as a \"magic\" pattern. Has no\n   * effect if {@link nobrace} is set.\n   *\n   * Only has effect on the {@link hasMagic} function.\n   */\n  magicalBraces?: boolean\n\n  /**\n   * Add a `/` character to directory matches. Note that this requires\n   * additional stat calls in some cases.\n   */\n  mark?: boolean\n\n  /**\n   * Perform a basename-only match if the pattern does not contain any slash\n   * characters. That is, `*.js` would be treated as equivalent to\n   * `**\\/*.js`, matching all js files in all directories.\n   */\n  matchBase?: boolean\n\n  /**\n   * Limit the directory traversal to a given depth below the cwd.\n   * Note that this does NOT prevent traversal to sibling folders,\n   * root patterns, and so on. It only limits the maximum folder depth\n   * that the walk will descend, relative to the cwd.\n   */\n  maxDepth?: number\n\n  /**\n   * Do not expand `{a,b}` and `{1..3}` brace sets.\n   */\n  nobrace?: boolean\n\n  /**\n   * Perform a case-insensitive match. This defaults to `true` on macOS and\n   * Windows systems, and `false` on all others.\n   *\n   * **Note** `nocase` should only be explicitly set when it is\n   * known that the filesystem's case sensitivity differs from the\n   * platform default. If set `true` on case-sensitive file\n   * systems, or `false` on case-insensitive file systems, then the\n   * walk may return more or less results than expected.\n   */\n  nocase?: boolean\n\n  /**\n   * Do not match directories, only files. (Note: to match\n   * _only_ directories, put a `/` at the end of the pattern.)\n   */\n  nodir?: boolean\n\n  /**\n   * Do not match \"extglob\" patterns such as `+(a|b)`.\n   */\n  noext?: boolean\n\n  /**\n   * Normalize unicode in the pattern, and in the file names that it is\n   * matched against, with this form: `'NFC'`, `'NFD'`, `'NFKC'`, or\n   * `'NFKD'`. `true` means `'NFC'`. This is passed to minimatch, so it\n   * applies to the portions of the pattern with magic, and to the\n   * `ignore` patterns.\n   *\n   * The portions of the pattern without magic are looked up with\n   * path-scurry, which already compares the names of the entries\n   * that it knows in their `'NFKD'` form.\n   */\n  normalize?: boolean | Form\n\n  /**\n   * Do not match `**` against multiple filenames. (Ie, treat it as a normal\n   * `*` instead.)\n   *\n   * Conflicts with {@link matchBase}\n   */\n  noglobstar?: boolean\n\n  /**\n   * Defaults to value of `process.platform` if available, or `'linux'` if\n   * not. Setting `platform:'win32'` on non-Windows systems may cause strange\n   * behavior.\n   */\n  platform?: NodeJS.Platform\n\n  /**\n   * Set to true to call `fs.realpath` on all of the\n   * results. In the case of an entry that cannot be resolved, the\n   * entry is omitted. This incurs a slight performance penalty, of\n   * course, because of the added system calls.\n   */\n  realpath?: boolean\n\n  /**\n   *\n   * A string path resolved against the `cwd` option, which\n   * is used as the starting point for absolute patterns that start\n   * with `/`, (but not drive letters or UNC paths on Windows).\n   *\n   * Note that this _doesn't_ necessarily limit the walk to the\n   * `root` directory, and doesn't affect the cwd starting point for\n   * non-absolute patterns. A pattern containing `..` will still be\n   * able to traverse out of the root directory, if it is not an\n   * actual root directory on the filesystem, and any non-absolute\n   * patterns will be matched in the `cwd`. For example, the\n   * pattern `/../*` with `{root:'/some/path'}` will return all\n   * files in `/some`, not all files in `/some/path`. The pattern\n   * `*` with `{root:'/some/path'}` will return all the entries in\n   * the cwd, not the entries in `/some/path`.\n   *\n   * To start absolute and non-absolute patterns in the same\n   * path, you can use `{root:''}`. However, be aware that on\n   * Windows systems, a pattern like `x:/*` or `//host/share/*` will\n   * _always_ start in the `x:/` or `//host/share` directory,\n   * regardless of the `root` setting.\n   */\n  root?: string\n\n  /**\n   * A [PathScurry](http://npm.im/path-scurry) object used\n   * to traverse the file system. If the `nocase` option is set\n   * explicitly, then any provided `scurry` object must match this\n   * setting.\n   */\n  scurry?: PathScurry\n\n  /**\n   * Call `lstat()` on all entries, whether required or not to determine\n   * if it's a valid match. When used with {@link withFileTypes}, this means\n   * that matches will include data such as modified time, permissions, and\n   * so on.  Note that this will incur a performance cost due to the added\n   * system calls.\n   */\n  stat?: boolean\n\n  /**\n   * An AbortSignal which will cancel the Glob walk when\n   * triggered.\n   */\n  signal?: AbortSignal\n\n  /**\n   * Use `\\\\` as a path separator _only_, and\n   *  _never_ as an escape character. If set, all `\\\\` characters are\n   *  replaced with `/` in the pattern.\n   *\n   *  Note that this makes it **impossible** to match against paths\n   *  containing literal glob pattern characters, but allows matching\n   *  with patterns constructed using `path.join()` and\n   *  `path.resolve()` on Windows platforms, mimicking the (buggy!)\n   *  behavior of Glob v7 and before on Windows. Please use with\n   *  caution, and be mindful of [the caveat below about Windows\n   *  paths](#windows). (For legacy reasons, this is also set if\n   *  `allowWindowsEscape` is set to the exact value `false`.)\n   */\n  windowsPathsNoEscape?: boolean\n\n  /**\n   * Return [PathScurry](http://npm.im/path-scurry)\n   * `Path` objects instead of strings. These are similar to a\n   * NodeJS `Dirent` object, but with additional methods and\n   * properties.\n   *\n   * Conflicts with {@link absolute}\n   */\n  withFileTypes?: boolean\n\n  /**\n   * An fs implementation to override some or all of the defaults.  See\n   * http://npm.im/path-scurry for details about what can be overridden.\n   */\n  fs?: FSOption\n\n  /**\n   * Return `/` delimited paths, even on Windows.\n   *\n   * On posix systems, this has no effect.  But, on Windows, it means that\n   * paths will be `/` delimited, and absolute paths will be their full\n   * resolved UNC forms, eg instead of `'C:\\\\foo\\\\bar'`, it would return\n   * `'//?/C:/foo/bar'`\n   */\n  posix?: boolean\n\n  /**\n   * Do not match any children of any matches. For example, the pattern\n   * `**\\/foo` would match `a/foo`, but not `a/foo/b/foo` in this mode.\n   *\n   * This is especially useful for cases like \"find all `node_modules`\n   * folders, but not the ones in `node_modules`\".\n   *\n   * In order to support this, the `Ignore` implementation must support an\n   * `add(pattern: string)` method. If using the default `Ignore` class, then\n   * this is fine, but if this is set to `false`, and a custom `Ignore` is\n   * provided that does not have an `add()` method, then it will throw an\n   * error.\n   *\n   * **Caveat** It *only* ignores matches that would be a descendant of a\n   * previous match, and only if that descendant is matched *after* the\n   * ancestor is encountered. Since the file system walk happens in\n   * indeterminate order, it's possible that a match will already be added\n   * before its ancestor, if multiple or braced patterns are used.\n   *\n   * For example:\n   *\n   * ```ts\n   * const results = await glob([\n   *   // likely to match first, since it's just a stat\n   *   'a/b/c/d/e/f',\n   *\n   *   // this pattern is more complicated! It must to various readdir()\n   *   // calls and test the results against a regular expression, and that\n   *   // is certainly going to take a little bit longer.\n   *   //\n   *   // So, later on, it encounters a match at 'a/b/c/d/e', but it's too\n   *   // late to ignore a/b/c/d/e/f, because it's already been emitted.\n   *   'a/[bdf]/?/[a-z]/*',\n   * ], { includeChildMatches: false })\n   * ```\n   *\n   * It's best to only set this to `false` if you can be reasonably sure that\n   * no components of the pattern will potentially match one another's file\n   * system descendants, or if the occasional included child entry will not\n   * cause problems.\n   *\n   * @default true\n   */\n  includeChildMatches?: boolean\n\n  /**\n   * max number of `{...}` patterns to expand. Default `1_000`.\n   *\n   * Note: this is much less than minimatch's default of `100_000`,\n   * because Glob has higher memory requirements due to walking\n   * the file system tree.\n   */\n  braceExpandMax?: number\n}\n\nexport type GlobOptionsWithFileTypesTrue = GlobOptions & {\n  withFileTypes: true\n  // string options not relevant if returning Path objects.\n  absolute?: undefined\n  mark?: undefined\n  posix?: undefined\n}\n\nexport type GlobOptionsWithFileTypesFalse = GlobOptions & {\n  withFileTypes?: false\n}\n\nexport type GlobOptionsWithFileTypesUnset = GlobOptions & {\n  withFileTypes?: undefined\n}\n\nexport type Result<Opts> =\n  Opts extends GlobOptionsWithFileTypesTrue ? Path\n  : Opts extends GlobOptionsWithFileTypesFalse ? string\n  : Opts extends GlobOptionsWithFileTypesUnset ? string\n  : string | Path\nexport type Results<Opts> = Result<Opts>[]\n\nexport type FileTypes<Opts> =\n  Opts extends GlobOptionsWithFileTypesTrue ? true\n  : Opts extends GlobOptionsWithFileTypesFalse ? false\n  : Opts extends GlobOptionsWithFileTypesUnset ? false\n  : boolean\n\n/**\n * An object that can perform glob pattern traversals.\n */\nexport class Glob<Opts extends GlobOptions> implements GlobOptions {\n  absolute?: boolean\n  cwd: string\n  root?: string\n  dot: boolean\n  dotRelative: boolean\n  follow: boolean\n  ignore?: string | string[] | IgnoreLike | ReadonlyArray<string>\n  magicalBraces: boolean\n  mark?: boolean\n  matchBase: boolean\n  maxDepth: number\n  nobrace: boolean\n  nocase: boolean\n  nodir: boolean\n  noext: boolean\n  noglobstar: boolean\n  pattern: string[] | ReadonlyArray<string>\n  platform: NodeJS.Platform\n  realpath: boolean\n  scurry: PathScurry\n  stat: boolean\n  signal?: AbortSignal\n  windowsPathsNoEscape: boolean\n  withFileTypes: FileTypes<Opts>\n  includeChildMatches: boolean\n\n  /**\n   * The options provided to the constructor.\n   */\n  opts: Opts\n\n  /**\n   * An array of parsed immutable {@link Pattern} objects.\n   */\n  patterns: Pattern[]\n\n  /**\n   * All options are stored as properties on the `Glob` object.\n   *\n   * See {@link GlobOptions} for full options descriptions.\n   *\n   * Note that a previous `Glob` object can be passed as the\n   * `GlobOptions` to another `Glob` instantiation to re-use settings\n   * and caches with a new pattern.\n   *\n   * Traversal functions can be called multiple times to run the walk\n   * again.\n   */\n  constructor(pattern: string | string[], opts: Opts) {\n    /* c8 ignore start */\n    if (!opts) throw new TypeError('glob options required')\n    /* c8 ignore stop */\n    this.withFileTypes = !!opts.withFileTypes as FileTypes<Opts>\n    this.signal = opts.signal\n    this.follow = !!opts.follow\n    this.dot = !!opts.dot\n    this.dotRelative = !!opts.dotRelative\n    this.nodir = !!opts.nodir\n    this.mark = !!opts.mark\n    if (!opts.cwd) {\n      this.cwd = ''\n    } else if (opts.cwd instanceof URL || opts.cwd.startsWith('file://')) {\n      opts.cwd = fileURLToPath(opts.cwd)\n    }\n    this.cwd = opts.cwd || ''\n    this.root = opts.root\n    this.magicalBraces = !!opts.magicalBraces\n    this.nobrace = !!opts.nobrace\n    this.noext = !!opts.noext\n    this.realpath = !!opts.realpath\n    this.absolute = opts.absolute\n    this.includeChildMatches = opts.includeChildMatches !== false\n\n    this.noglobstar = !!opts.noglobstar\n    this.matchBase = !!opts.matchBase\n    this.maxDepth =\n      typeof opts.maxDepth === 'number' ? opts.maxDepth : Infinity\n    this.stat = !!opts.stat\n    this.ignore = opts.ignore\n\n    if (this.withFileTypes && this.absolute !== undefined) {\n      throw new Error('cannot set absolute and withFileTypes:true')\n    }\n\n    let p: string[] = typeof pattern === 'string' ? [pattern] : pattern\n\n    this.windowsPathsNoEscape =\n      !!opts.windowsPathsNoEscape ||\n      (opts as { allowWindowsEscape?: boolean }).allowWindowsEscape ===\n        false\n\n    if (this.windowsPathsNoEscape) {\n      p = p.map(p => p.replace(/\\\\/g, '/'))\n    }\n\n    if (this.matchBase) {\n      if (opts.noglobstar) {\n        throw new TypeError('base matching requires globstar')\n      }\n      p = p.map(p => (p.includes('/') ? p : `./**/${p}`))\n    }\n\n    this.pattern = p\n\n    this.platform = opts.platform || defaultPlatform\n    this.opts = { ...opts, platform: this.platform }\n    if (opts.scurry) {\n      this.scurry = opts.scurry\n      if (\n        opts.nocase !== undefined &&\n        opts.nocase !== opts.scurry.nocase\n      ) {\n        throw new Error('nocase option contradicts provided scurry option')\n      }\n    } else {\n      const Scurry =\n        opts.platform === 'win32' ? PathScurryWin32\n        : opts.platform === 'darwin' ? PathScurryDarwin\n        : opts.platform ? PathScurryPosix\n        : PathScurry\n      this.scurry = new Scurry(this.cwd, {\n        nocase: opts.nocase,\n        fs: opts.fs,\n      })\n    }\n    this.nocase = this.scurry.nocase\n\n    // If you do nocase:true on a case-sensitive file system, then\n    // we need to use regexps instead of strings for non-magic\n    // path portions, because statting `aBc` won't return results\n    // for the file `AbC` for example.\n    const nocaseMagicOnly =\n      this.platform === 'darwin' || this.platform === 'win32'\n\n    const mmo: MinimatchOptions = {\n      braceExpandMax: 10_000,\n      ...opts,\n      dot: this.dot,\n      matchBase: this.matchBase,\n      nobrace: this.nobrace,\n      // default nocase based on platform\n      nocase: this.nocase,\n      nocaseMagicOnly,\n      nocomment: true,\n      noext: this.noext,\n      nonegate: true,\n      optimizationLevel: 2,\n      platform: this.platform,\n      windowsPathsNoEscape: this.windowsPathsNoEscape,\n    }\n\n    const mms = this.pattern.map(p => new Minimatch(p, mmo))\n    const [matchSet, globParts] = mms.reduce(\n      (set: [MatchSet, GlobParts], m) => {\n        set[0].push(...m.set)\n        set[1].push(...m.globParts)\n        return set\n      },\n      [[], []],\n    )\n    this.patterns = matchSet.map((set, i) => {\n      const g = globParts[i]\n      /* c8 ignore start */\n      if (!g) throw new Error('invalid pattern object')\n      /* c8 ignore stop */\n      return new Pattern(set, g, 0, this.platform)\n    })\n  }\n\n  /**\n   * Returns a Promise that resolves to the results array.\n   */\n  async walk(): Promise<Results<Opts>>\n  async walk(): Promise<(string | Path)[]> {\n    // Walkers always return array of Path objects, so we just have to\n    // coerce them into the right shape.  It will have already called\n    // realpath() if the option was set to do so, so we know that's cached.\n    // start out knowing the cwd, at least\n    return await new GlobWalker(this.patterns, this.scurry.cwd, {\n      ...this.opts,\n      maxDepth:\n        this.maxDepth !== Infinity ?\n          this.maxDepth + this.scurry.cwd.depth()\n        : Infinity,\n      platform: this.platform,\n      nocase: this.nocase,\n      includeChildMatches: this.includeChildMatches,\n    }).walk()\n  }\n\n  /**\n   * synchronous {@link Glob.walk}\n   */\n  walkSync(): Results<Opts>\n  walkSync(): (string | Path)[] {\n    return new GlobWalker(this.patterns, this.scurry.cwd, {\n      ...this.opts,\n      maxDepth:\n        this.maxDepth !== Infinity ?\n          this.maxDepth + this.scurry.cwd.depth()\n        : Infinity,\n      platform: this.platform,\n      nocase: this.nocase,\n      includeChildMatches: this.includeChildMatches,\n    }).walkSync()\n  }\n\n  /**\n   * Stream results asynchronously.\n   */\n  stream(): Minipass<Result<Opts>, Result<Opts>>\n  stream(): Minipass<string | Path, string | Path> {\n    return new GlobStream(this.patterns, this.scurry.cwd, {\n      ...this.opts,\n      maxDepth:\n        this.maxDepth !== Infinity ?\n          this.maxDepth + this.scurry.cwd.depth()\n        : Infinity,\n      platform: this.platform,\n      nocase: this.nocase,\n      includeChildMatches: this.includeChildMatches,\n    }).stream()\n  }\n\n  /**\n   * Stream results synchronously.\n   */\n  streamSync(): Minipass<Result<Opts>, Result<Opts>>\n  streamSync(): Minipass<string | Path, string | Path> {\n    return new GlobStream(this.patterns, this.scurry.cwd, {\n      ...this.opts,\n      maxDepth:\n        this.maxDepth !== Infinity ?\n          this.maxDepth + this.scurry.cwd.depth()\n        : Infinity,\n      platform: this.platform,\n      nocase: this.nocase,\n      includeChildMatches: this.includeChildMatches,\n    }).streamSync()\n  }\n\n  /**\n   * Default sync iteration function. Returns a Generator that\n   * iterates over the results.\n   */\n  iterateSync(): Generator<Result<Opts>, void, void> {\n    return this.streamSync()[Symbol.iterator]()\n  }\n  [Symbol.iterator]() {\n    return this.iterateSync()\n  }\n\n  /**\n   * Default async iteration function. Returns an AsyncGenerator that\n   * iterates over the results.\n   */\n  iterate(): AsyncGenerator<Result<Opts>, void, void> {\n    return this.stream()[Symbol.asyncIterator]()\n  }\n  [Symbol.asyncIterator]() {\n    return this.iterate()\n  }\n}\n", "// simple node version that imports from node builtin\n// this is built to both ESM and CommonJS on the 'node' import path\nimport { tracingChannel, channel } from 'node:diagnostics_channel'\nimport type { TracingChannel, Channel } from 'node:diagnostics_channel'\nexport type { TracingChannel, Channel }\nexport const metrics: Channel<unknown> = channel('lru-cache:metrics')\nexport const tracing: TracingChannel<unknown> = tracingChannel('lru-cache')\n", "/**\n * this provides the default Perf object source, either the\n * `performance` global, or the `Date` constructor.\n *\n * it can be passed in via configuration to override it\n * for a single LRU object.\n */\nexport type Perf = { now: () => number }\nexport const defaultPerf: Perf =\n  (\n    typeof performance === 'object' &&\n    performance &&\n    typeof performance.now === 'function'\n  ) ?\n    /* c8 ignore start - this gets covered, but c8 gets confused */\n    performance\n  : /* c8 ignore stop */ Date\n", "/**\n * @module LRUCache\n */\n\nimport { metrics, tracing } from './diagnostics-channel.js'\nimport { defaultPerf } from './perf.js'\nimport type { Perf } from './perf.js'\nexport type { Perf } from './perf.js'\n\nconst hasSubscribers = () =>\n  metrics.hasSubscribers || tracing.hasSubscribers\n\nconst warned = new Set<string>()\n\n// either a function or a class\n// oxlint-disable-next-line no-explicit-any\ntype ForC = ((...a: any[]) => any) | { new (...a: any[]): any }\n\n/* c8 ignore start */\nconst PROCESS = (\n  typeof process === 'object' && !!process ?\n    process\n  : {}) as { [k: string]: unknown }\n/* c8 ignore stop */\n\nconst emitWarning = (\n  msg: string,\n  type: string,\n  code: string,\n  fn: ForC,\n) => {\n  if (typeof PROCESS.emitWarning === 'function') {\n    PROCESS.emitWarning(msg, type, code, fn)\n  } else {\n    //oxlint-disable-next-line no-console\n    console.error(`[${code}] ${type}: ${msg}`)\n  }\n}\nconst shouldWarn = (code: string) => !warned.has(code)\n\nconst TYPE = Symbol('type')\nexport type PosInt = number & { [TYPE]: 'Positive Integer' }\nexport type Index = number & { [TYPE]: 'LRUCache Index' }\n\nconst isPosInt = (n: unknown): n is PosInt =>\n  !!n && n === Math.floor(n as number) && n > 0 && isFinite(n)\n\nexport type UintArray = Uint8Array | Uint16Array | Uint32Array\nexport type NumberArray = UintArray | number[]\n\n// This is a little bit ridiculous, tbh.\n// The maximum array length is 2^32-1 or thereabouts on most JS impls.\n// And well before that point, you're caching the entire world, I mean,\n// that's ~32GB of just integers for the next/prev links, plus whatever\n// else to hold that many keys and values.  Just filling the memory with\n// zeroes at init time is brutal when you get that big.\n// But why not be complete?\n// Maybe in the future, these limits will have expanded.\n/* c8 ignore start */\nconst getUintArray = (max: number) =>\n  !isPosInt(max) ? null\n  : max <= Math.pow(2, 8) ? Uint8Array\n  : max <= Math.pow(2, 16) ? Uint16Array\n  : max <= Math.pow(2, 32) ? Uint32Array\n  : max <= Number.MAX_SAFE_INTEGER ? ZeroArray\n  : null\n/* c8 ignore stop */\n\nclass ZeroArray extends Array<number> {\n  constructor(size: number) {\n    super(size)\n    this.fill(0)\n  }\n}\nexport type { ZeroArray }\nexport type { Stack }\n\nexport type StackLike = Stack | Index[]\nclass Stack {\n  /* c8 ignore start - not sure why this is showing up uncovered?? */\n  heap: NumberArray\n  /* c8 ignore stop */\n  length: number\n  // private constructor\n  static #constructing: boolean = false\n  static create(max: number): StackLike {\n    const HeapCls = getUintArray(max)\n    if (!HeapCls) return []\n    Stack.#constructing = true\n    const s = new Stack(max, HeapCls)\n    Stack.#constructing = false\n    return s\n  }\n  constructor(max: number, HeapCls: { new (n: number): NumberArray }) {\n    /* c8 ignore start */\n    if (!Stack.#constructing) {\n      throw new TypeError('instantiate Stack using Stack.create(n)')\n    }\n    /* c8 ignore stop */\n    this.heap = new HeapCls(max)\n    this.length = 0\n  }\n  push(n: Index) {\n    this.heap[this.length++] = n\n  }\n  pop(): Index {\n    return this.heap[--this.length] as Index\n  }\n}\n\n/**\n * Promise representing an in-progress {@link LRUCache#fetch} call\n */\nexport type BackgroundFetch<V> = Promise<V | undefined> & {\n  __returned: BackgroundFetch<V> | undefined\n  __abortController: AbortController\n  __staleWhileFetching: V | undefined\n}\n\nexport type DisposeTask<K, V> = [\n  value: V,\n  key: K,\n  reason: LRUCache.DisposeReason,\n]\n\nexport namespace LRUCache {\n  /**\n   * An integer greater than 0, reflecting the calculated size of items\n   */\n  export type Size = number\n\n  /**\n   * Integer greater than 0, representing some number of milliseconds, or the\n   * time at which a TTL started counting from.\n   */\n  export type Milliseconds = number\n\n  /**\n   * An integer greater than 0, reflecting a number of items\n   */\n  export type Count = number\n\n  /**\n   * The reason why an item was removed from the cache, passed\n   * to the {@link Disposer} methods.\n   *\n   * - `evict`: The item was evicted because it is the least recently used,\n   *   and the cache is full.\n   * - `set`: A new value was set, overwriting the old value being disposed.\n   * - `delete`: The item was explicitly deleted, either by calling\n   *   {@link LRUCache#delete}, {@link LRUCache#clear}, or\n   *   {@link LRUCache#set} with an undefined value.\n   * - `expire`: The item was removed due to exceeding its TTL.\n   * - `fetch`: A {@link OptionsBase#fetchMethod} operation returned\n   *   `undefined` or was aborted, causing the item to be deleted.\n   */\n  export type DisposeReason =\n    | 'evict'\n    | 'set'\n    | 'delete'\n    | 'expire'\n    | 'fetch'\n  /**\n   * A method called upon item removal, passed as the\n   * {@link OptionsBase.dispose} and/or\n   * {@link OptionsBase.disposeAfter} options.\n   */\n  export type Disposer<K, V> = (\n    value: V,\n    key: K,\n    reason: DisposeReason,\n  ) => void\n\n  /**\n   * The reason why an item was added to the cache, passed\n   * to the {@link Inserter} methods.\n   *\n   * - `add`: the item was not found in the cache, and was added\n   * - `update`: the item was in the cache, with the same value provided\n   * - `replace`: the item was in the cache, and replaced\n   */\n  export type InsertReason = 'add' | 'update' | 'replace'\n\n  /**\n   * A method called upon item insertion, passed as the\n   * {@link OptionsBase.insert}\n   */\n  export type Inserter<K, V> = (\n    value: V,\n    key: K,\n    reason: InsertReason,\n  ) => void\n\n  /**\n   * A function that returns the effective calculated size\n   * of an entry in the cache.\n   */\n  export type SizeCalculator<K, V> = (value: V, key: K) => Size\n\n  /**\n   * Options provided to the\n   * {@link OptionsBase.fetchMethod} function.\n   */\n  export interface FetcherOptions<K, V, FC = unknown> {\n    signal: AbortSignal\n    options: FetcherFetchOptions<K, V, FC>\n    /**\n     * Object provided in the {@link FetchOptions.context} option to\n     * {@link LRUCache#fetch}\n     */\n    context: FC\n  }\n\n  /**\n   * Occasionally, it may be useful to track the internal behavior of the\n   * cache, particularly for logging, debugging, or for behavior within the\n   * `fetchMethod`. To do this, you can pass a `status` object to the\n   * {@link LRUCache#fetch}, {@link LRUCache#get}, {@link LRUCache#set},\n   * {@link LRUCache#memo}, and {@link LRUCache#has} methods.\n   *\n   * The `status` option should be a plain JavaScript object. The following\n   * fields will be set on it appropriately, depending on the situation.\n   *\n   * These objects are also the context objects passed to listeners on the\n   * `lru-cache:metrics` diagnostic channel, and the `lru-cache` tracing\n   * channels, in platforms that support them.\n   */\n  export interface Status<K, V, FC = unknown> {\n    /**\n     * The operation being performed\n     */\n    op?: 'get' | 'set' | 'memo' | 'fetch' | 'delete' | 'has' | 'peek'\n    /**\n     * The status of a set() operation.\n     *\n     * - add: the item was not found in the cache, and was added\n     * - update: the item was in the cache, with the same value provided\n     * - replace: the item was in the cache, and replaced\n     * - miss: the item was not added to the cache for some reason\n     */\n    set?: 'add' | 'update' | 'replace' | 'miss' | 'deleted'\n\n    /**\n     * The status of a delete() operation.\n     */\n    delete?: LRUCache.DisposeReason\n\n    /**\n     * The result of a peek() operation\n     *\n     * - hit: the item was found and returned\n     * - stale: the item is in the cache, but past its ttl and not returned\n     * - miss: item not in the cache\n     */\n    peek?: 'hit' | 'miss' | 'stale'\n\n    /**\n     * The status of a memo() operation.\n     *\n     * - 'hit': the item was found in the cache and returned\n     * - 'miss': the `memoMethod` function was called\n     */\n    memo?: 'hit' | 'miss'\n\n    /**\n     * The `context` option provided to a memo or fetch operation\n     *\n     * In practice, of course, this will be the same type as the `FC`\n     * fetch context param used to instantiate the LRUCache, but the\n     * convolutions of threading that through would get quite complicated,\n     * and preclude forcing/forbidding the passing of a `context` param\n     * where it is/isn't expected, which is more valuable for error\n     * prevention.\n     */\n    context?: unknown\n\n    /**\n     * the ttl stored for the item, or undefined if ttls are not used.\n     */\n    ttl?: Milliseconds\n\n    /**\n     * the start time for the item, or undefined if ttls are not used.\n     */\n    start?: Milliseconds\n\n    /**\n     * The timestamp used for TTL calculation\n     */\n    now?: Milliseconds\n\n    /**\n     * the remaining ttl for the item, or undefined if ttls are not used.\n     */\n    remainingTTL?: Milliseconds\n\n    /**\n     * The calculated size for the item, if sizes are used.\n     */\n    entrySize?: Size\n\n    /**\n     * The total calculated size of the cache, if sizes are used.\n     */\n    totalCalculatedSize?: Size\n\n    /**\n     * A flag indicating that the item was not stored, due to exceeding the\n     * {@link OptionsBase.maxEntrySize}\n     */\n    maxEntrySizeExceeded?: true\n\n    /**\n     * The key that was set or retrieved\n     */\n    key?: K\n\n    /**\n     * The value that was set\n     */\n    value?: V\n\n    /**\n     * The old value, specified in the case of `set:'replace'`\n     */\n    oldValue?: V\n\n    /**\n     * The results of a {@link LRUCache#has} operation\n     *\n     * - hit: the item was found in the cache\n     * - stale: the item was found in the cache, but is stale\n     * - miss: the item was not found in the cache\n     */\n    has?: 'hit' | 'stale' | 'miss'\n\n    /**\n     * The status of a {@link LRUCache#fetch} operation.\n     * Note that this can change as the underlying fetch() moves through\n     * various states.\n     *\n     * - inflight: there is another fetch() for this key which is in process\n     * - get: there is no {@link OptionsBase.fetchMethod}, so\n     *   {@link LRUCache#get} was called.\n     * - miss: the item is not in cache, and will be fetched.\n     * - hit: the item is in the cache, and was resolved immediately.\n     * - stale: the item is in the cache, but stale.\n     * - refresh: the item is in the cache, and not stale, but\n     *   {@link FetchOptions.forceRefresh} was specified.\n     */\n    fetch?: 'get' | 'inflight' | 'miss' | 'hit' | 'stale' | 'refresh'\n\n    /**\n     * `forceRefresh` option was used for either a fetch or memo operation\n     */\n    forceRefresh?: boolean\n\n    /**\n     * The {@link OptionsBase.fetchMethod} was called\n     */\n    fetchDispatched?: true\n\n    /**\n     * The cached value was updated after a successful call to\n     * {@link OptionsBase.fetchMethod}\n     */\n    fetchUpdated?: true\n\n    /**\n     * The reason for a fetch() rejection.  Either the error raised by the\n     * {@link OptionsBase.fetchMethod}, or the reason for an\n     * AbortSignal.\n     */\n    fetchError?: Error\n\n    /**\n     * The fetch received an abort signal\n     */\n    fetchAborted?: true\n\n    /**\n     * The abort signal received was ignored, and the fetch was allowed to\n     * continue in the background.\n     */\n    fetchAbortIgnored?: true\n\n    /**\n     * The fetchMethod promise resolved successfully\n     */\n    fetchResolved?: true\n\n    /**\n     * The fetchMethod promise was rejected\n     */\n    fetchRejected?: true\n\n    /**\n     * The status of a {@link LRUCache#get} operation.\n     *\n     * - fetching: The item is currently being fetched.  If a previous value\n     *   is present and allowed, that will be returned.\n     * - stale: The item is in the cache, and is stale. If it was returned,\n     *   then the `returnedStale` flag will be set.\n     * - stale-fetching: The value is being fetched in the background, but is\n     *   currently stale. If the stale value was returned, then the\n     *   `returnedStale` flag will be set.\n     * - hit: the item is in the cache\n     * - miss: the item is not in the cache\n     */\n    get?: 'stale' | 'hit' | 'miss' | 'fetching' | 'stale-fetching'\n\n    /**\n     * A fetch or get operation returned a stale value.\n     */\n    returnedStale?: true\n\n    /**\n     * A tracingChannel trace was started for this operation\n     */\n    trace?: boolean\n\n    /**\n     * A reference to the cache instance associated with this operation\n     */\n    cache?: LRUCache<K & {}, V & {}, FC>\n  }\n\n  /**\n   * options which override the options set in the LRUCache constructor\n   * when calling {@link LRUCache#fetch}.\n   *\n   * This is the union of {@link GetOptions} and {@link SetOptions}, plus\n   * {@link OptionsBase.noDeleteOnFetchRejection},\n   * {@link OptionsBase.allowStaleOnFetchRejection},\n   * {@link FetchOptions.forceRefresh}, and\n   * {@link FetcherOptions.context}\n   *\n   * Any of these may be modified in the {@link OptionsBase.fetchMethod}\n   * function, but the {@link GetOptions} fields will of course have no\n   * effect, as the {@link LRUCache#get} call already happened by the time\n   * the fetchMethod is called.\n   */\n  export interface FetcherFetchOptions<K, V, FC = unknown> extends Pick<\n    OptionsBase<K, V, FC>,\n    | 'allowStale'\n    | 'updateAgeOnGet'\n    | 'noDeleteOnStaleGet'\n    | 'sizeCalculation'\n    | 'ttl'\n    | 'noDisposeOnSet'\n    | 'noUpdateTTL'\n    | 'noDeleteOnFetchRejection'\n    | 'allowStaleOnFetchRejection'\n    | 'ignoreFetchAbort'\n    | 'allowStaleOnFetchAbort'\n  > {\n    status?: Status<K, V, FC>\n    size?: Size\n  }\n\n  /**\n   * Options that may be passed to the {@link LRUCache#fetch} method.\n   */\n  export interface FetchOptions<K, V, FC> extends FetcherFetchOptions<\n    K,\n    V,\n    FC\n  > {\n    /**\n     * Set to true to force a re-load of the existing data, even if it\n     * is not yet stale.\n     */\n    forceRefresh?: boolean\n    /**\n     * Context provided to the {@link OptionsBase.fetchMethod} as\n     * the {@link FetcherOptions.context} param.\n     *\n     * If the FC type is specified as unknown (the default),\n     * undefined or void, then this is optional.  Otherwise, it will\n     * be required.\n     */\n    context?: FC\n    signal?: AbortSignal\n    status?: Status<K, V, FC>\n  }\n  /**\n   * Options provided to {@link LRUCache#fetch} when the FC type is something\n   * other than `unknown`, `undefined`, or `void`\n   */\n  export interface FetchOptionsWithContext<K, V, FC> extends FetchOptions<\n    K,\n    V,\n    FC\n  > {\n    context: FC\n  }\n  /**\n   * Options provided to {@link LRUCache#fetch} when the FC type is\n   * `undefined` or `void`\n   */\n  export interface FetchOptionsNoContext<\n    K,\n    V,\n    FC extends undefined | void = undefined,\n  > extends FetchOptions<K, V, FC> {\n    context?: FC\n  }\n\n  export interface MemoOptions<K, V, FC = unknown> extends Pick<\n    OptionsBase<K, V, FC>,\n    | 'allowStale'\n    | 'updateAgeOnGet'\n    | 'noDeleteOnStaleGet'\n    | 'sizeCalculation'\n    | 'ttl'\n    | 'noDisposeOnSet'\n    | 'noUpdateTTL'\n    | 'noDeleteOnFetchRejection'\n    | 'allowStaleOnFetchRejection'\n    | 'ignoreFetchAbort'\n    | 'allowStaleOnFetchAbort'\n  > {\n    /**\n     * Set to true to force a re-load of the existing data, even if it\n     * is not yet stale.\n     */\n    forceRefresh?: boolean\n    /**\n     * Context provided to the {@link OptionsBase.memoMethod} as\n     * the {@link MemoizerOptions.context} param.\n     *\n     * If the FC type is specified as unknown (the default),\n     * undefined or void, then this is optional.  Otherwise, it will\n     * be required.\n     */\n    context?: FC\n    status?: Status<K, V, FC>\n  }\n  /**\n   * Options provided to {@link LRUCache#memo} when the FC type is something\n   * other than `unknown`, `undefined`, or `void`\n   */\n  export interface MemoOptionsWithContext<K, V, FC> extends MemoOptions<\n    K,\n    V,\n    FC\n  > {\n    context: FC\n  }\n  /**\n   * Options provided to {@link LRUCache#memo} when the FC type is\n   * `undefined` or `void`\n   */\n  export interface MemoOptionsNoContext<\n    K,\n    V,\n    FC extends undefined | void = undefined,\n  > extends MemoOptions<K, V, FC> {\n    context?: FC\n  }\n\n  /**\n   * Options provided to the\n   * {@link OptionsBase.memoMethod} function.\n   */\n  export interface MemoizerOptions<K, V, FC = unknown> {\n    options: MemoizerMemoOptions<K, V, FC>\n    /**\n     * Object provided in the {@link MemoOptions.context} option to\n     * {@link LRUCache#memo}\n     */\n    context: FC\n  }\n\n  /**\n   * options which override the options set in the LRUCache constructor\n   * when calling {@link LRUCache#memo}.\n   *\n   * This is the union of {@link GetOptions} and {@link SetOptions}, plus\n   * {@link MemoOptions.forceRefresh}, and\n   * {@link MemoOptions.context}\n   *\n   * Any of these may be modified in the {@link OptionsBase.memoMethod}\n   * function, but the {@link GetOptions} fields will of course have no\n   * effect, as the {@link LRUCache#get} call already happened by the time\n   * the memoMethod is called.\n   */\n  export interface MemoizerMemoOptions<K, V, FC = unknown> extends Pick<\n    OptionsBase<K, V, FC>,\n    | 'allowStale'\n    | 'updateAgeOnGet'\n    | 'noDeleteOnStaleGet'\n    | 'sizeCalculation'\n    | 'ttl'\n    | 'noDisposeOnSet'\n    | 'noUpdateTTL'\n  > {\n    status?: Status<K, V, FC>\n    size?: Size\n    start?: Milliseconds\n  }\n\n  /**\n   * Options that may be passed to the {@link LRUCache#has} method.\n   */\n  export interface HasOptions<K, V, FC> extends Pick<\n    OptionsBase<K, V, FC>,\n    'updateAgeOnHas'\n  > {\n    status?: Status<K, V, FC>\n  }\n\n  /**\n   * Options that may be passed to the {@link LRUCache#get} method.\n   */\n  export interface GetOptions<K, V, FC> extends Pick<\n    OptionsBase<K, V, FC>,\n    'allowStale' | 'updateAgeOnGet' | 'noDeleteOnStaleGet'\n  > {\n    status?: Status<K, V, FC>\n  }\n\n  /**\n   * Options that may be passed to the {@link LRUCache#peek} method.\n   */\n  export interface PeekOptions<K, V, FC> extends Pick<\n    OptionsBase<K, V, FC>,\n    'allowStale'\n  > {\n    status?: Status<K, V, FC>\n  }\n\n  /**\n   * Options that may be passed to the {@link LRUCache#set} method.\n   */\n  export interface SetOptions<K, V, FC> extends Pick<\n    OptionsBase<K, V, FC>,\n    'sizeCalculation' | 'ttl' | 'noDisposeOnSet' | 'noUpdateTTL'\n  > {\n    /**\n     * If size tracking is enabled, then setting an explicit size\n     * in the {@link LRUCache#set} call will prevent calling the\n     * {@link OptionsBase.sizeCalculation} function.\n     */\n    size?: Size\n    /**\n     * If TTL tracking is enabled, then setting an explicit start\n     * time in the {@link LRUCache#set} call will override the\n     * default time from `performance.now()` or `Date.now()`.\n     *\n     * Note that it must be a valid value for whichever time-tracking\n     * method is in use.\n     */\n    start?: Milliseconds\n    status?: Status<K, V, FC>\n  }\n\n  /**\n   * The type signature for the {@link OptionsBase.fetchMethod} option.\n   */\n  export type Fetcher<K, V, FC = unknown> = (\n    key: K,\n    staleValue: V | undefined,\n    options: FetcherOptions<K, V, FC>,\n  ) => Promise<V | undefined | void> | V | undefined | void\n\n  /**\n   * the type signature for the {@link OptionsBase.memoMethod} option.\n   */\n  export type Memoizer<K, V, FC = unknown> = (\n    key: K,\n    staleValue: V | undefined,\n    options: MemoizerOptions<K, V, FC>,\n  ) => V\n\n  /**\n   * Options which may be passed to the {@link LRUCache} constructor.\n   *\n   * Most of these may be overridden in the various options that use\n   * them.\n   *\n   * Despite all being technically optional, the constructor requires that\n   * a cache is at minimum limited by one or more of {@link OptionsBase.max},\n   * {@link OptionsBase.ttl}, or {@link OptionsBase.maxSize}.\n   *\n   * If {@link OptionsBase.ttl} is used alone, then it is strongly advised\n   * (and in fact required by the type definitions here) that the cache\n   * also set {@link OptionsBase.ttlAutopurge}, to prevent potentially\n   * unbounded storage.\n   *\n   * All options are also available on the {@link LRUCache} instance, making\n   * it safe to pass an LRUCache instance as the options argumemnt to\n   * make another empty cache of the same type.\n   *\n   * Some options are marked as read-only, because changing them after\n   * instantiation is not safe. Changing any of the other options will of\n   * course only have an effect on subsequent method calls.\n   */\n  export interface OptionsBase<K, V, FC> {\n    /**\n     * The maximum number of items to store in the cache before evicting\n     * old entries. This is read-only on the {@link LRUCache} instance,\n     * and may not be overridden.\n     *\n     * If set, then storage space will be pre-allocated at construction\n     * time, and the cache will perform significantly faster.\n     *\n     * Note that significantly fewer items may be stored, if\n     * {@link OptionsBase.maxSize} and/or {@link OptionsBase.ttl} are also\n     * set.\n     *\n     * **It is strongly recommended to set a `max` to prevent unbounded growth\n     * of the cache.**\n     */\n    max?: Count\n\n    /**\n     * Max time in milliseconds for items to live in cache before they are\n     * considered stale.  Note that stale items are NOT preemptively removed by\n     * default, and MAY live in the cache, contributing to its LRU max, long\n     * after they have expired, unless {@link OptionsBase.ttlAutopurge} is\n     * set.\n     *\n     * If set to `0` (the default value), then that means \"do not track\n     * TTL\", not \"expire immediately\".\n     *\n     * Also, as this cache is optimized for LRU/MRU operations, some of\n     * the staleness/TTL checks will reduce performance, as they will incur\n     * overhead by deleting items.\n     *\n     * This is not primarily a TTL cache, and does not make strong TTL\n     * guarantees. There is no pre-emptive pruning of expired items, but you\n     * _may_ set a TTL on the cache, and it will treat expired items as missing\n     * when they are fetched, and delete them.\n     *\n     * Optional, but must be a non-negative integer in ms if specified.\n     *\n     * This may be overridden by passing an options object to `cache.set()`.\n     *\n     * At least one of `max`, `maxSize`, or `TTL` is required. This must be a\n     * positive integer if set.\n     *\n     * Even if ttl tracking is enabled, **it is strongly recommended to set a\n     * `max` to prevent unbounded growth of the cache.**\n     *\n     * If ttl tracking is enabled, and `max` and `maxSize` are not set,\n     * and `ttlAutopurge` is not set, then a warning will be emitted\n     * cautioning about the potential for unbounded memory consumption.\n     * (The TypeScript definitions will also discourage this.)\n     */\n    ttl?: Milliseconds\n\n    /**\n     * Minimum amount of time in ms in which to check for staleness.\n     * Defaults to 1, which means that the current time is checked\n     * at most once per millisecond.\n     *\n     * Set to 0 to check the current time every time staleness is tested.\n     * (This reduces performance, and is theoretically unnecessary.)\n     *\n     * Setting this to a higher value will improve performance somewhat\n     * while using ttl tracking, albeit at the expense of keeping stale\n     * items around a bit longer than their TTLs would indicate.\n     *\n     * @default 1\n     */\n    ttlResolution?: Milliseconds\n\n    /**\n     * Preemptively remove stale items from the cache.\n     *\n     * Note that this may *significantly* degrade performance, especially if\n     * the cache is storing a large number of items. It is almost always best\n     * to just leave the stale items in the cache, and let them fall out as new\n     * items are added.\n     *\n     * Note that this means that {@link OptionsBase.allowStale} is a bit\n     * pointless, as stale items will be deleted almost as soon as they\n     * expire.\n     *\n     * Use with caution!\n     */\n    ttlAutopurge?: boolean\n\n    /**\n     * When using time-expiring entries with `ttl`, setting this to `true` will\n     * make each item's age reset to 0 whenever it is retrieved from cache with\n     * {@link LRUCache#get}, causing it to not expire. (It can still fall out\n     * of cache based on recency of use, of course.)\n     *\n     * Has no effect if {@link OptionsBase.ttl} is not set.\n     *\n     * This may be overridden by passing an options object to `cache.get()`.\n     */\n    updateAgeOnGet?: boolean\n\n    /**\n     * When using time-expiring entries with `ttl`, setting this to `true` will\n     * make each item's age reset to 0 whenever its presence in the cache is\n     * checked with {@link LRUCache#has}, causing it to not expire. (It can\n     * still fall out of cache based on recency of use, of course.)\n     *\n     * Has no effect if {@link OptionsBase.ttl} is not set.\n     */\n    updateAgeOnHas?: boolean\n\n    /**\n     * Allow {@link LRUCache#get} and {@link LRUCache#fetch} calls to return\n     * stale data, if available.\n     *\n     * By default, if you set `ttl`, stale items will only be deleted from the\n     * cache when you `get(key)`. That is, it's not preemptively pruning items,\n     * unless {@link OptionsBase.ttlAutopurge} is set.\n     *\n     * If you set `allowStale:true`, it'll return the stale value *as well as*\n     * deleting it. If you don't set this, then it'll return `undefined` when\n     * you try to get a stale entry.\n     *\n     * Note that when a stale entry is fetched, _even if it is returned due to\n     * `allowStale` being set_, it is removed from the cache immediately. You\n     * can suppress this behavior by setting\n     * {@link OptionsBase.noDeleteOnStaleGet}, either in the constructor, or in\n     * the options provided to {@link LRUCache#get}.\n     *\n     * This may be overridden by passing an options object to `cache.get()`.\n     * The `cache.has()` method will always return `false` for stale items.\n     *\n     * Only relevant if a ttl is set.\n     */\n    allowStale?: boolean\n\n    /**\n     * Function that is called on items when they are dropped from the\n     * cache, as `dispose(value, key, reason)`.\n     *\n     * This can be handy if you want to close file descriptors or do\n     * other cleanup tasks when items are no longer stored in the cache.\n     *\n     * **NOTE**: It is called _before_ the item has been fully removed\n     * from the cache, so if you want to put it right back in, you need\n     * to wait until the next tick. If you try to add it back in during\n     * the `dispose()` function call, it will break things in subtle and\n     * weird ways.\n     *\n     * Unlike several other options, this may _not_ be overridden by\n     * passing an option to `set()`, for performance reasons.\n     *\n     * The `reason` will be one of the following strings, corresponding\n     * to the reason for the item's deletion:\n     *\n     * - `evict` Item was evicted to make space for a new addition\n     * - `set` Item was overwritten by a new value\n     * - `expire` Item expired its TTL\n     * - `fetch` Item was deleted due to a failed or aborted fetch, or a\n     *   fetchMethod returning `undefined.\n     * - `delete` Item was removed by explicit `cache.delete(key)`,\n     *   `cache.clear()`, or `cache.set(key, undefined)`.\n     */\n    dispose?: Disposer<K, V>\n\n    /**\n     * Function that is called when new items are inserted into the cache,\n     * as `onInsert(value, key, reason)`.\n     *\n     * This can be useful if you need to perform actions when an item is\n     * added, such as logging or tracking insertions.\n     *\n     * Unlike some other options, this may _not_ be overridden by passing\n     * an option to `set()`, for performance and consistency reasons.\n     */\n    onInsert?: Inserter<K, V>\n\n    /**\n     * The same as {@link OptionsBase.dispose}, but called *after* the entry\n     * is completely removed and the cache is once again in a clean state.\n     *\n     * It is safe to add an item right back into the cache at this point.\n     * However, note that it is *very* easy to inadvertently create infinite\n     * recursion this way.\n     */\n    disposeAfter?: Disposer<K, V>\n\n    /**\n     * Set to true to suppress calling the\n     * {@link OptionsBase.dispose} function if the entry key is\n     * still accessible within the cache.\n     *\n     * This may be overridden by passing an options object to\n     * {@link LRUCache#set}.\n     *\n     * Only relevant if `dispose` or `disposeAfter` are set.\n     */\n    noDisposeOnSet?: boolean\n\n    /**\n     * Boolean flag to tell the cache to not update the TTL when setting a new\n     * value for an existing key (ie, when updating a value rather than\n     * inserting a new value).  Note that the TTL value is _always_ set (if\n     * provided) when adding a new entry into the cache.\n     *\n     * Has no effect if a {@link OptionsBase.ttl} is not set.\n     *\n     * May be passed as an option to {@link LRUCache#set}.\n     */\n    noUpdateTTL?: boolean\n\n    /**\n     * Set to a positive integer to track the sizes of items added to the\n     * cache, and automatically evict items in order to stay below this size.\n     * Note that this may result in fewer than `max` items being stored.\n     *\n     * Attempting to add an item to the cache whose calculated size is greater\n     * that this amount will be a no-op. The item will not be cached, and no\n     * other items will be evicted.\n     *\n     * Optional, must be a positive integer if provided.\n     *\n     * Sets `maxEntrySize` to the same value, unless a different value is\n     * provided for `maxEntrySize`.\n     *\n     * At least one of `max`, `maxSize`, or `TTL` is required. This must be a\n     * positive integer if set.\n     *\n     * Even if size tracking is enabled, **it is strongly recommended to set a\n     * `max` to prevent unbounded growth of the cache.**\n     *\n     * Note also that size tracking can negatively impact performance,\n     * though for most cases, only minimally.\n     */\n    maxSize?: Size\n\n    /**\n     * The effective size for background fetch promises.\n     *\n     * This has no effect unless `maxSize` and `sizeCalculation` are used,\n     * and a {@link LRUCache.OptionsBase.fetchMethod} is provided to\n     * support {@link LRUCache#fetch}.\n     *\n     * If a stale value is present in the cache, then the effective size of\n     * the background fetch is the size of the stale item it will eventually\n     * replace. If not, then this value is used as its effective size.\n     *\n     * @default 1\n     */\n    backgroundFetchSize?: number\n\n    /**\n     * The maximum allowed size for any single item in the cache.\n     *\n     * If a larger item is passed to {@link LRUCache#set} or returned by a\n     * {@link OptionsBase.fetchMethod} or {@link OptionsBase.memoMethod}, then\n     * it will not be stored in the cache.\n     *\n     * Attempting to add an item whose calculated size is greater than\n     * this amount will not cache the item or evict any old items, but\n     * WILL delete an existing value if one is already present.\n     *\n     * Optional, must be a positive integer if provided. Defaults to\n     * the value of `maxSize` if provided.\n     */\n    maxEntrySize?: Size\n\n    /**\n     * A function that returns a number indicating the item's size.\n     *\n     * Requires {@link OptionsBase.maxSize} to be set.\n     *\n     * If not provided, and {@link OptionsBase.maxSize} or\n     * {@link OptionsBase.maxEntrySize} are set, then all\n     * {@link LRUCache#set} calls **must** provide an explicit\n     * {@link SetOptions.size} or sizeCalculation param.\n     */\n    sizeCalculation?: SizeCalculator<K, V>\n\n    /**\n     * Method that provides the implementation for {@link LRUCache#fetch}\n     *\n     * ```ts\n     * fetchMethod(key, staleValue, { signal, options, context })\n     * ```\n     *\n     * If `fetchMethod` is not provided, then `cache.fetch(key)` is equivalent\n     * to `Promise.resolve(cache.get(key))`.\n     *\n     * If at any time, `signal.aborted` is set to `true`, or if the\n     * `signal.onabort` method is called, or if it emits an `'abort'` event\n     * which you can listen to with `addEventListener`, then that means that\n     * the fetch should be abandoned. This may be passed along to async\n     * functions aware of AbortController/AbortSignal behavior.\n     *\n     * The `fetchMethod` should **only** return `undefined` or a Promise\n     * resolving to `undefined` if the AbortController signaled an `abort`\n     * event. In all other cases, it should return or resolve to a value\n     * suitable for adding to the cache.\n     *\n     * The `options` object is a union of the options that may be provided to\n     * `set()` and `get()`. If they are modified, then that will result in\n     * modifying the settings to `cache.set()` when the value is resolved, and\n     * in the case of\n     * {@link OptionsBase.noDeleteOnFetchRejection} and\n     * {@link OptionsBase.allowStaleOnFetchRejection}, the handling of\n     * `fetchMethod` failures.\n     *\n     * For example, a DNS cache may update the TTL based on the value returned\n     * from a remote DNS server by changing `options.ttl` in the `fetchMethod`.\n     */\n    fetchMethod?: Fetcher<K, V, FC>\n\n    /**\n     * Method that provides the implementation for {@link LRUCache#memo}\n     */\n    memoMethod?: Memoizer<K, V, FC>\n\n    /**\n     * Set to true to suppress the deletion of stale data when a\n     * {@link OptionsBase.fetchMethod} returns a rejected promise.\n     */\n    noDeleteOnFetchRejection?: boolean\n\n    /**\n     * Do not delete stale items when they are retrieved with\n     * {@link LRUCache#get}.\n     *\n     * Note that the `get` return value will still be `undefined`\n     * unless {@link OptionsBase.allowStale} is true.\n     *\n     * When using time-expiring entries with `ttl`, by default stale\n     * items will be removed from the cache when the key is accessed\n     * with `cache.get()`.\n     *\n     * Setting this option will cause stale items to remain in the cache, until\n     * they are explicitly deleted with `cache.delete(key)`, or retrieved with\n     * `noDeleteOnStaleGet` set to `false`.\n     *\n     * This may be overridden by passing an options object to `cache.get()`.\n     *\n     * Only relevant if a ttl is used.\n     */\n    noDeleteOnStaleGet?: boolean\n\n    /**\n     * Set to true to allow returning stale data when a\n     * {@link OptionsBase.fetchMethod} throws an error or returns a rejected\n     * promise.\n     *\n     * This differs from using {@link OptionsBase.allowStale} in that stale\n     * data will ONLY be returned in the case that the {@link LRUCache#fetch}\n     * fails, not any other times.\n     *\n     * If a `fetchMethod` fails, and there is no stale value available, the\n     * `fetch()` will resolve to `undefined`. Ie, all `fetchMethod` errors are\n     * suppressed.\n     *\n     * Implies `noDeleteOnFetchRejection`.\n     *\n     * This may be set in calls to `fetch()`, or defaulted on the constructor,\n     * or overridden by modifying the options object in the `fetchMethod`.\n     */\n    allowStaleOnFetchRejection?: boolean\n\n    /**\n     * Set to true to return a stale value from the cache when the\n     * `AbortSignal` passed to the {@link OptionsBase.fetchMethod} dispatches\n     * an `'abort'` event, whether user-triggered, or due to internal cache\n     * behavior.\n     *\n     * Unless {@link OptionsBase.ignoreFetchAbort} is also set, the underlying\n     * {@link OptionsBase.fetchMethod} will still be considered canceled, and\n     * any value it returns will be ignored and not cached.\n     *\n     * Caveat: since fetches are aborted when a new value is explicitly\n     * set in the cache, this can lead to fetch returning a stale value,\n     * since that was the fallback value _at the moment the `fetch()` was\n     * initiated_, even though the new updated value is now present in\n     * the cache.\n     *\n     * For example:\n     *\n     * ```ts\n     * const cache = new LRUCache<string, any>({\n     *   ttl: 100,\n     *   fetchMethod: async (url, oldValue, { signal }) =>  {\n     *     const res = await fetch(url, { signal })\n     *     return await res.json()\n     *   }\n     * })\n     * cache.set('https://example.com/', { some: 'data' })\n     * // 100ms go by...\n     * const result = cache.fetch('https://example.com/')\n     * cache.set('https://example.com/', { other: 'thing' })\n     * console.log(await result) // { some: 'data' }\n     * console.log(cache.get('https://example.com/')) // { other: 'thing' }\n     * ```\n     */\n    allowStaleOnFetchAbort?: boolean\n\n    /**\n     * Set to true to ignore the `abort` event emitted by the `AbortSignal`\n     * object passed to {@link OptionsBase.fetchMethod}, and still cache the\n     * resulting resolution value, as long as it is not `undefined`.\n     *\n     * When used on its own, this means aborted {@link LRUCache#fetch} calls\n     * are not immediately resolved or rejected when they are aborted, and\n     * instead take the full time to await.\n     *\n     * When used with {@link OptionsBase.allowStaleOnFetchAbort}, aborted\n     * {@link LRUCache#fetch} calls will resolve immediately to their stale\n     * cached value or `undefined`, and will continue to process and eventually\n     * update the cache when they resolve, as long as the resulting value is\n     * not `undefined`, thus supporting a \"return stale on timeout while\n     * refreshing\" mechanism by passing `AbortSignal.timeout(n)` as the signal.\n     *\n     * For example:\n     *\n     * ```ts\n     * const c = new LRUCache({\n     *   ttl: 100,\n     *   ignoreFetchAbort: true,\n     *   allowStaleOnFetchAbort: true,\n     *   fetchMethod: async (key, oldValue, { signal }) => {\n     *     // note: do NOT pass the signal to fetch()!\n     *     // let's say this fetch can take a long time.\n     *     const res = await fetch(`https://slow-backend-server/${key}`)\n     *     return await res.json()\n     *   },\n     * })\n     *\n     * // this will return the stale value after 100ms, while still\n     * // updating in the background for next time.\n     * const val = await c.fetch('key', { signal: AbortSignal.timeout(100) })\n     * ```\n     *\n     * **Note**: regardless of this setting, an `abort` event _is still\n     * emitted on the `AbortSignal` object_, so may result in invalid results\n     * when passed to other underlying APIs that use AbortSignals.\n     *\n     * This may be overridden in the {@link OptionsBase.fetchMethod} or the\n     * call to {@link LRUCache#fetch}.\n     */\n    ignoreFetchAbort?: boolean\n\n    /**\n     * In some cases, you may want to swap out the performance/Date object\n     * used for TTL tracking. This should almost certainly NOT be done in\n     * production environments!\n     *\n     * This value defaults to `global.performance` if it has a `now()` method,\n     * or the `global.Date` object otherwise.\n     */\n    perf?: Perf\n  }\n\n  export interface OptionsMaxLimit<K, V, FC> extends OptionsBase<\n    K,\n    V,\n    FC\n  > {\n    max: Count\n  }\n  export interface OptionsTTLLimit<K, V, FC> extends OptionsBase<\n    K,\n    V,\n    FC\n  > {\n    ttl: Milliseconds\n    ttlAutopurge: boolean\n  }\n  export interface OptionsSizeLimit<K, V, FC> extends OptionsBase<\n    K,\n    V,\n    FC\n  > {\n    maxSize: Size\n  }\n\n  /**\n   * The valid safe options for the {@link LRUCache} constructor\n   */\n  export type Options<K, V, FC> =\n    | OptionsMaxLimit<K, V, FC>\n    | OptionsSizeLimit<K, V, FC>\n    | OptionsTTLLimit<K, V, FC>\n\n  /**\n   * Entry objects used by {@link LRUCache#load} and {@link LRUCache#dump},\n   * and returned by {@link LRUCache#info}.\n   */\n  export interface Entry<V> {\n    value: V\n    ttl?: Milliseconds\n    size?: Size\n    start?: Milliseconds\n  }\n}\n\n/**\n * Default export, the thing you're using this module to get.\n *\n * The `K` and `V` types define the key and value types, respectively. The\n * optional `FC` type defines the type of the `context` object passed to\n * `cache.fetch()` and `cache.memo()`.\n *\n * Keys and values **must not** be `null` or `undefined`.\n *\n * All properties from the options object (with the exception of `max`,\n * `maxSize`, `fetchMethod`, `memoMethod`, `dispose` and `disposeAfter`) are\n * added as normal public members. (The listed options are read-only getters.)\n *\n * Changing any of these will alter the defaults for subsequent method calls.\n */\nexport class LRUCache<K extends {}, V extends {}, FC = unknown> {\n  // options that cannot be changed without disaster\n  readonly #max: LRUCache.Count\n  readonly #maxSize: LRUCache.Size\n  readonly #dispose?: LRUCache.Disposer<K, V>\n  readonly #onInsert?: LRUCache.Inserter<K, V>\n  readonly #disposeAfter?: LRUCache.Disposer<K, V>\n  readonly #fetchMethod?: LRUCache.Fetcher<K, V, FC>\n  readonly #memoMethod?: LRUCache.Memoizer<K, V, FC>\n  readonly #perf: Perf\n\n  /**\n   * {@link LRUCache.OptionsBase.perf}\n   */\n  get perf() {\n    return this.#perf\n  }\n\n  /**\n   * {@link LRUCache.OptionsBase.ttl}\n   */\n  ttl: LRUCache.Milliseconds\n\n  /**\n   * {@link LRUCache.OptionsBase.ttlResolution}\n   */\n  ttlResolution: LRUCache.Milliseconds\n  /**\n   * {@link LRUCache.OptionsBase.ttlAutopurge}\n   */\n  ttlAutopurge: boolean\n  /**\n   * {@link LRUCache.OptionsBase.updateAgeOnGet}\n   */\n  updateAgeOnGet: boolean\n  /**\n   * {@link LRUCache.OptionsBase.updateAgeOnHas}\n   */\n  updateAgeOnHas: boolean\n  /**\n   * {@link LRUCache.OptionsBase.allowStale}\n   */\n  allowStale: boolean\n\n  /**\n   * {@link LRUCache.OptionsBase.noDisposeOnSet}\n   */\n  noDisposeOnSet: boolean\n  /**\n   * {@link LRUCache.OptionsBase.noUpdateTTL}\n   */\n  noUpdateTTL: boolean\n  /**\n   * {@link LRUCache.OptionsBase.maxEntrySize}\n   */\n  maxEntrySize: LRUCache.Size\n  /**\n   * {@link LRUCache.OptionsBase.sizeCalculation}\n   */\n  sizeCalculation?: LRUCache.SizeCalculator<K, V>\n  /**\n   * {@link LRUCache.OptionsBase.noDeleteOnFetchRejection}\n   */\n  noDeleteOnFetchRejection: boolean\n  /**\n   * {@link LRUCache.OptionsBase.noDeleteOnStaleGet}\n   */\n  noDeleteOnStaleGet: boolean\n  /**\n   * {@link LRUCache.OptionsBase.allowStaleOnFetchAbort}\n   */\n  allowStaleOnFetchAbort: boolean\n  /**\n   * {@link LRUCache.OptionsBase.allowStaleOnFetchRejection}\n   */\n  allowStaleOnFetchRejection: boolean\n  /**\n   * {@link LRUCache.OptionsBase.ignoreFetchAbort}\n   */\n  ignoreFetchAbort: boolean\n\n  /** {@link LRUCache.OptionsBase.backgroundFetchSize} */\n  backgroundFetchSize: number\n\n  // computed properties\n  #size: LRUCache.Count\n  #calculatedSize: LRUCache.Size\n  #keyMap: Map<K, Index>\n  #keyList: (K | undefined)[]\n  #valList: (V | BackgroundFetch<V> | undefined)[]\n  #next: NumberArray\n  #prev: NumberArray\n  #head: Index\n  #tail: Index\n  #free: StackLike\n  #disposed?: DisposeTask<K, V>[]\n  #sizes?: ZeroArray\n  #starts?: ZeroArray\n  #ttls?: ZeroArray\n  #autopurgeTimers?: (undefined | ReturnType<typeof setTimeout>)[]\n\n  #hasDispose: boolean\n  #hasFetchMethod: boolean\n  #hasDisposeAfter: boolean\n  #hasOnInsert: boolean\n\n  /**\n   * Do not call this method unless you need to inspect the\n   * inner workings of the cache.  If anything returned by this\n   * object is modified in any way, strange breakage may occur.\n   *\n   * These fields are private for a reason!\n   *\n   * @internal\n   */\n  static unsafeExposeInternals<\n    K extends {},\n    V extends {},\n    FC extends unknown = unknown,\n  >(c: LRUCache<K, V, FC>) {\n    return {\n      // properties\n      starts: c.#starts,\n      ttls: c.#ttls,\n      autopurgeTimers: c.#autopurgeTimers,\n      sizes: c.#sizes,\n      keyMap: c.#keyMap as Map<K, number>,\n      keyList: c.#keyList,\n      valList: c.#valList,\n      next: c.#next,\n      prev: c.#prev,\n      get head() {\n        return c.#head\n      },\n      get tail() {\n        return c.#tail\n      },\n      free: c.#free,\n      // methods\n      isBackgroundFetch: (p: unknown) => c.#isBackgroundFetch(p),\n      backgroundFetch: (\n        k: K,\n        index: number | undefined,\n        options: LRUCache.FetchOptions<K, V, FC>,\n        context: unknown,\n      ): BackgroundFetch<V> =>\n        c.#backgroundFetch(\n          k,\n          index as Index | undefined,\n          options,\n          context as FC,\n        ),\n      moveToTail: (index: number): void => c.#moveToTail(index as Index),\n      indexes: (options?: { allowStale: boolean }) => c.#indexes(options),\n      rindexes: (options?: { allowStale: boolean }) =>\n        c.#rindexes(options),\n      isStale: (index: number | undefined) => c.#isStale(index as Index),\n    }\n  }\n\n  // Protected read-only members\n\n  /**\n   * {@link LRUCache.OptionsBase.max} (read-only)\n   */\n  get max(): LRUCache.Count {\n    return this.#max\n  }\n  /**\n   * {@link LRUCache.OptionsBase.maxSize} (read-only)\n   */\n  get maxSize(): LRUCache.Count {\n    return this.#maxSize\n  }\n  /**\n   * The total computed size of items in the cache (read-only)\n   */\n  get calculatedSize(): LRUCache.Size {\n    return this.#calculatedSize\n  }\n  /**\n   * The number of items stored in the cache (read-only)\n   */\n  get size(): LRUCache.Count {\n    return this.#size\n  }\n  /**\n   * {@link LRUCache.OptionsBase.fetchMethod} (read-only)\n   */\n  get fetchMethod(): LRUCache.Fetcher<K, V, FC> | undefined {\n    return this.#fetchMethod\n  }\n  get memoMethod(): LRUCache.Memoizer<K, V, FC> | undefined {\n    return this.#memoMethod\n  }\n  /**\n   * {@link LRUCache.OptionsBase.dispose} (read-only)\n   */\n  get dispose() {\n    return this.#dispose\n  }\n  /**\n   * {@link LRUCache.OptionsBase.onInsert} (read-only)\n   */\n  get onInsert() {\n    return this.#onInsert\n  }\n  /**\n   * {@link LRUCache.OptionsBase.disposeAfter} (read-only)\n   */\n  get disposeAfter() {\n    return this.#disposeAfter\n  }\n\n  constructor(options: LRUCache.Options<K, V, FC> | LRUCache<K, V, FC>) {\n    const {\n      max = 0,\n      ttl,\n      ttlResolution = 1,\n      ttlAutopurge,\n      updateAgeOnGet,\n      updateAgeOnHas,\n      allowStale,\n      dispose,\n      onInsert,\n      disposeAfter,\n      noDisposeOnSet,\n      noUpdateTTL,\n      maxSize = 0,\n      maxEntrySize = 0,\n      sizeCalculation,\n      fetchMethod,\n      memoMethod,\n      noDeleteOnFetchRejection,\n      noDeleteOnStaleGet,\n      allowStaleOnFetchRejection,\n      allowStaleOnFetchAbort,\n      ignoreFetchAbort,\n      backgroundFetchSize = 1,\n      perf,\n    } = options\n\n    this.backgroundFetchSize = backgroundFetchSize\n\n    if (perf !== undefined) {\n      if (typeof perf?.now !== 'function') {\n        throw new TypeError(\n          'perf option must have a now() method if specified',\n        )\n      }\n    }\n\n    this.#perf = perf ?? defaultPerf\n\n    if (max !== 0 && !isPosInt(max)) {\n      throw new TypeError('max option must be a nonnegative integer')\n    }\n\n    const UintArray = max ? getUintArray(max) : Array\n    if (!UintArray) {\n      throw new Error('invalid max value: ' + max)\n    }\n\n    this.#max = max\n    this.#maxSize = maxSize\n    this.maxEntrySize = maxEntrySize || this.#maxSize\n    this.sizeCalculation = sizeCalculation\n    if (this.sizeCalculation) {\n      if (!this.#maxSize && !this.maxEntrySize) {\n        throw new TypeError(\n          'cannot set sizeCalculation without setting maxSize or maxEntrySize',\n        )\n      }\n      if (typeof this.sizeCalculation !== 'function') {\n        throw new TypeError('sizeCalculation set to non-function')\n      }\n    }\n\n    if (memoMethod !== undefined && typeof memoMethod !== 'function') {\n      throw new TypeError('memoMethod must be a function if defined')\n    }\n    this.#memoMethod = memoMethod\n\n    if (fetchMethod !== undefined && typeof fetchMethod !== 'function') {\n      throw new TypeError('fetchMethod must be a function if specified')\n    }\n    this.#fetchMethod = fetchMethod\n    this.#hasFetchMethod = !!fetchMethod\n\n    this.#keyMap = new Map()\n    this.#keyList = Array.from({ length: max }).fill(undefined) as (\n      | K\n      | undefined\n    )[]\n    this.#valList = Array.from({ length: max }).fill(undefined) as (\n      | V\n      | undefined\n    )[]\n    this.#next = new UintArray(max)\n    this.#prev = new UintArray(max)\n    this.#head = 0 as Index\n    this.#tail = 0 as Index\n    this.#free = Stack.create(max)\n    this.#size = 0\n    this.#calculatedSize = 0\n\n    if (typeof dispose === 'function') {\n      this.#dispose = dispose\n    }\n    if (typeof onInsert === 'function') {\n      this.#onInsert = onInsert\n    }\n    if (typeof disposeAfter === 'function') {\n      this.#disposeAfter = disposeAfter\n      this.#disposed = []\n    } else {\n      this.#disposeAfter = undefined\n      this.#disposed = undefined\n    }\n    this.#hasDispose = !!this.#dispose\n    this.#hasOnInsert = !!this.#onInsert\n    this.#hasDisposeAfter = !!this.#disposeAfter\n\n    this.noDisposeOnSet = !!noDisposeOnSet\n    this.noUpdateTTL = !!noUpdateTTL\n    this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection\n    this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection\n    this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort\n    this.ignoreFetchAbort = !!ignoreFetchAbort\n\n    // NB: maxEntrySize is set to maxSize if it's set\n    if (this.maxEntrySize !== 0) {\n      if (this.#maxSize !== 0) {\n        if (!isPosInt(this.#maxSize)) {\n          throw new TypeError(\n            'maxSize must be a positive integer if specified',\n          )\n        }\n      }\n      if (!isPosInt(this.maxEntrySize)) {\n        throw new TypeError(\n          'maxEntrySize must be a positive integer if specified',\n        )\n      }\n      this.#initializeSizeTracking()\n    }\n\n    this.allowStale = !!allowStale\n    this.noDeleteOnStaleGet = !!noDeleteOnStaleGet\n    this.updateAgeOnGet = !!updateAgeOnGet\n    this.updateAgeOnHas = !!updateAgeOnHas\n    this.ttlResolution =\n      isPosInt(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1\n    this.ttlAutopurge = !!ttlAutopurge\n    this.ttl = ttl || 0\n    if (this.ttl) {\n      if (!isPosInt(this.ttl)) {\n        throw new TypeError('ttl must be a positive integer if specified')\n      }\n      this.#initializeTTLTracking()\n    }\n\n    // do not allow completely unbounded caches\n    if (this.#max === 0 && this.ttl === 0 && this.#maxSize === 0) {\n      throw new TypeError(\n        'At least one of max, maxSize, or ttl is required',\n      )\n    }\n    if (!this.ttlAutopurge && !this.#max && !this.#maxSize) {\n      const code = 'LRU_CACHE_UNBOUNDED'\n      if (shouldWarn(code)) {\n        warned.add(code)\n        const msg =\n          'TTL caching without ttlAutopurge, max, or maxSize can ' +\n          'result in unbounded memory consumption.'\n        emitWarning(msg, 'UnboundedCacheWarning', code, LRUCache)\n      }\n    }\n  }\n\n  /**\n   * Return the number of ms left in the item's TTL. If item is not in cache,\n   * returns `0`. Returns `Infinity` if item is in cache without a defined TTL.\n   */\n  getRemainingTTL(key: K) {\n    return this.#keyMap.has(key) ? Infinity : 0\n  }\n\n  #initializeTTLTracking() {\n    const ttls = new ZeroArray(this.#max)\n    const starts = new ZeroArray(this.#max)\n    this.#ttls = ttls\n    this.#starts = starts\n    const purgeTimers =\n      this.ttlAutopurge ?\n        Array.from<undefined | ReturnType<typeof setTimeout>>({\n          length: this.#max,\n        })\n      : undefined\n    this.#autopurgeTimers = purgeTimers\n\n    this.#setItemTTL = (index, ttl, start = this.#perf.now()) => {\n      starts[index] = ttl !== 0 ? start : 0\n      ttls[index] = ttl\n      setPurgeTimer(index, ttl)\n    }\n\n    this.#updateItemAge = index => {\n      starts[index] = ttls[index] !== 0 ? this.#perf.now() : 0\n      setPurgeTimer(index, ttls[index])\n    }\n\n    // clear out the purge timer if we're setting TTL to 0, and\n    // previously had a ttl purge timer running, so it doesn't\n    // fire unnecessarily. Don't need to do this if we're not doing\n    // autopurge.\n    const setPurgeTimer =\n      !this.ttlAutopurge ?\n        () => {}\n      : (index: Index, ttl?: number) => {\n          if (purgeTimers?.[index]) {\n            clearTimeout(purgeTimers[index])\n            purgeTimers[index] = undefined\n          }\n          if (ttl && ttl !== 0 && purgeTimers) {\n            const t = setTimeout(() => {\n              if (this.#isStale(index)) {\n                this.#delete(this.#keyList[index] as K, 'expire')\n                purgeTimers[index] = undefined\n              } else {\n                setPurgeTimer(index, getRemainingTTL(index))\n              }\n            }, ttl + 1)\n            // unref() not supported on all platforms\n            /* c8 ignore start */\n            if (t.unref) {\n              t.unref()\n            }\n            /* c8 ignore stop */\n            purgeTimers[index] = t\n          }\n        }\n\n    this.#statusTTL = (status, index) => {\n      if (ttls[index]) {\n        const ttl = ttls[index]\n        const start = starts[index]\n        /* c8 ignore start */\n        if (!ttl || !start) {\n          return\n        }\n        /* c8 ignore stop */\n        status.ttl = ttl\n        status.start = start\n        status.now = cachedNow || getNow()\n        const age = status.now - start\n        status.remainingTTL = ttl - age\n      }\n    }\n\n    // debounce calls to perf.now() to 1s so we're not hitting\n    // that costly call repeatedly.\n    let cachedNow = 0\n    const getNow = () => {\n      const n = this.#perf.now()\n      if (this.ttlResolution > 0) {\n        cachedNow = n\n        const t = setTimeout(() => (cachedNow = 0), this.ttlResolution)\n        // not available on all platforms\n        /* c8 ignore start */\n        if (t.unref) {\n          t.unref()\n        }\n        /* c8 ignore stop */\n      }\n      return n\n    }\n\n    this.getRemainingTTL = key => {\n      const index = this.#keyMap.get(key)\n      if (index === undefined) {\n        return 0\n      }\n      return getRemainingTTL(index)\n    }\n    const getRemainingTTL = (index: Index) => {\n      const ttl = ttls[index]\n      const start = starts[index]\n      if (!ttl || !start) {\n        return Infinity\n      }\n      const age = (cachedNow || getNow()) - start\n      return ttl - age\n    }\n\n    this.#isStale = index => {\n      const s = starts[index]\n      const t = ttls[index]\n      return !!t && !!s && (cachedNow || getNow()) - s > t\n    }\n  }\n\n  // conditionally set private methods related to TTL\n  #updateItemAge: (index: Index) => void = () => {}\n  #statusTTL: (status: LRUCache.Status<K, V, FC>, index: Index) => void =\n    () => {}\n  #setItemTTL: (\n    index: Index,\n    ttl: LRUCache.Milliseconds,\n    start?: LRUCache.Milliseconds,\n    // ignore because we never call this if we're not already in TTL mode\n    /* c8 ignore start */\n  ) => void = () => {}\n  /* c8 ignore stop */\n\n  #isStale: (index: Index) => boolean = () => false\n\n  #initializeSizeTracking() {\n    const sizes = new ZeroArray(this.#max)\n    this.#calculatedSize = 0\n    this.#sizes = sizes\n    this.#removeItemSize = index => {\n      this.#calculatedSize -= sizes[index] as number\n      sizes[index] = 0\n    }\n    this.#requireSize = (k, v, size, sizeCalculation) => {\n      if (!isPosInt(size)) {\n        // provisionally accept background fetches.\n        // actual value size will be checked when they return.\n        if (this.#isBackgroundFetch(v)) {\n          // NB: this cannot occur if v.__staleWhileFetching is set,\n          // because in that case, it would take on the size of the\n          // existing entry that it temporarily replaces.\n          return this.backgroundFetchSize\n        }\n        if (sizeCalculation) {\n          if (typeof sizeCalculation !== 'function') {\n            throw new TypeError('sizeCalculation must be a function')\n          }\n          size = sizeCalculation(v, k)\n          if (!isPosInt(size)) {\n            throw new TypeError(\n              'sizeCalculation return invalid (expect positive integer)',\n            )\n          }\n        } else {\n          throw new TypeError(\n            'invalid size value (must be positive integer). ' +\n              'When maxSize or maxEntrySize is used, sizeCalculation ' +\n              'or size must be set.',\n          )\n        }\n      }\n      return size\n    }\n\n    this.#addItemSize = (\n      index: Index,\n      size: LRUCache.Size,\n      status?: LRUCache.Status<K, V, FC>,\n    ) => {\n      sizes[index] = size\n      if (this.#maxSize) {\n        const maxSize = this.#maxSize - sizes[index]\n        while (this.#calculatedSize > maxSize) {\n          this.#evict(true)\n        }\n      }\n      this.#calculatedSize += sizes[index]\n      if (status) {\n        status.entrySize = size\n        status.totalCalculatedSize = this.#calculatedSize\n      }\n    }\n  }\n\n  #removeItemSize: (index: Index) => void = _i => {}\n\n  #addItemSize: (\n    index: Index,\n    size: LRUCache.Size,\n    status?: LRUCache.Status<K, V, FC>,\n  ) => void = (_i, _s, _st) => {}\n\n  #requireSize: (\n    k: K,\n    v: V | BackgroundFetch<V>,\n    size?: LRUCache.Size,\n    sizeCalculation?: LRUCache.SizeCalculator<K, V>,\n    status?: LRUCache.Status<K, V, FC>,\n  ) => LRUCache.Size = (\n    _k: K,\n    _v: V | BackgroundFetch<V>,\n    size?: LRUCache.Size,\n    sizeCalculation?: LRUCache.SizeCalculator<K, V>,\n  ) => {\n    if (size || sizeCalculation) {\n      throw new TypeError(\n        'cannot set size without setting maxSize or maxEntrySize on cache',\n      )\n    }\n    return 0\n  };\n\n  *#indexes({ allowStale = this.allowStale } = {}) {\n    if (this.#size) {\n      for (let i = this.#tail; this.#isValidIndex(i); ) {\n        if (allowStale || !this.#isStale(i)) {\n          yield i\n        }\n        if (i === this.#head) {\n          break\n        } else {\n          i = this.#prev[i] as Index\n        }\n      }\n    }\n  }\n\n  *#rindexes({ allowStale = this.allowStale } = {}) {\n    if (this.#size) {\n      for (let i = this.#head; this.#isValidIndex(i); ) {\n        if (allowStale || !this.#isStale(i)) {\n          yield i\n        }\n        if (i === this.#tail) {\n          break\n        } else {\n          i = this.#next[i] as Index\n        }\n      }\n    }\n  }\n\n  #isValidIndex(index: Index) {\n    return (\n      index !== undefined &&\n      this.#keyMap.get(this.#keyList[index] as K) === index\n    )\n  }\n\n  /**\n   * Return a generator yielding `[key, value]` pairs,\n   * in order from most recently used to least recently used.\n   */\n  *entries() {\n    for (const i of this.#indexes()) {\n      if (\n        this.#valList[i] !== undefined &&\n        this.#keyList[i] !== undefined &&\n        !this.#isBackgroundFetch(this.#valList[i])\n      ) {\n        yield [this.#keyList[i], this.#valList[i]] as [K, V]\n      }\n    }\n  }\n\n  /**\n   * Inverse order version of {@link LRUCache.entries}\n   *\n   * Return a generator yielding `[key, value]` pairs,\n   * in order from least recently used to most recently used.\n   */\n  *rentries() {\n    for (const i of this.#rindexes()) {\n      if (\n        this.#valList[i] !== undefined &&\n        this.#keyList[i] !== undefined &&\n        !this.#isBackgroundFetch(this.#valList[i])\n      ) {\n        yield [this.#keyList[i], this.#valList[i]]\n      }\n    }\n  }\n\n  /**\n   * Return a generator yielding the keys in the cache,\n   * in order from most recently used to least recently used.\n   */\n  *keys() {\n    for (const i of this.#indexes()) {\n      const k = this.#keyList[i]\n      if (k !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {\n        yield k\n      }\n    }\n  }\n\n  /**\n   * Inverse order version of {@link LRUCache.keys}\n   *\n   * Return a generator yielding the keys in the cache,\n   * in order from least recently used to most recently used.\n   */\n  *rkeys() {\n    for (const i of this.#rindexes()) {\n      const k = this.#keyList[i]\n      if (k !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {\n        yield k\n      }\n    }\n  }\n\n  /**\n   * Return a generator yielding the values in the cache,\n   * in order from most recently used to least recently used.\n   */\n  *values() {\n    for (const i of this.#indexes()) {\n      const v = this.#valList[i]\n      if (v !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {\n        yield this.#valList[i] as V\n      }\n    }\n  }\n\n  /**\n   * Inverse order version of {@link LRUCache.values}\n   *\n   * Return a generator yielding the values in the cache,\n   * in order from least recently used to most recently used.\n   */\n  *rvalues() {\n    for (const i of this.#rindexes()) {\n      const v = this.#valList[i]\n      if (v !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {\n        yield this.#valList[i]\n      }\n    }\n  }\n\n  /**\n   * Iterating over the cache itself yields the same results as\n   * {@link LRUCache.entries}\n   */\n  [Symbol.iterator]() {\n    return this.entries()\n  }\n\n  /**\n   * A String value that is used in the creation of the default string\n   * description of an object. Called by the built-in method\n   * `Object.prototype.toString`.\n   */\n  [Symbol.toStringTag] = 'LRUCache'\n\n  /**\n   * Find a value for which the supplied fn method returns a truthy value,\n   * similar to `Array.find()`. fn is called as `fn(value, key, cache)`.\n   */\n  find(\n    fn: (v: V, k: K, self: LRUCache<K, V, FC>) => boolean,\n    getOptions: LRUCache.GetOptions<K, V, FC> = {},\n  ) {\n    for (const i of this.#indexes()) {\n      const v = this.#valList[i]\n      const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v\n      if (value === undefined) continue\n      if (fn(value, this.#keyList[i] as K, this)) {\n        return this.#get(this.#keyList[i] as K, getOptions)\n      }\n    }\n  }\n\n  /**\n   * Call the supplied function on each item in the cache, in order from most\n   * recently used to least recently used.\n   *\n   * `fn` is called as `fn(value, key, cache)`.\n   *\n   * If `thisp` is provided, function will be called in the `this`-context of\n   * the provided object, or the cache if no `thisp` object is provided.\n   *\n   * Does not update age or recenty of use, or iterate over stale values.\n   */\n  forEach(\n    fn: (v: V, k: K, self: LRUCache<K, V, FC>) => unknown,\n    thisp: unknown = this,\n  ) {\n    for (const i of this.#indexes()) {\n      const v = this.#valList[i]\n      const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v\n      if (value === undefined) continue\n      fn.call(thisp, value, this.#keyList[i] as K, this)\n    }\n  }\n\n  /**\n   * The same as {@link LRUCache.forEach} but items are iterated over in\n   * reverse order.  (ie, less recently used items are iterated over first.)\n   */\n  rforEach(\n    fn: (v: V, k: K, self: LRUCache<K, V, FC>) => unknown,\n    thisp: unknown = this,\n  ) {\n    for (const i of this.#rindexes()) {\n      const v = this.#valList[i]\n      const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v\n      if (value === undefined) continue\n      fn.call(thisp, value, this.#keyList[i] as K, this)\n    }\n  }\n\n  /**\n   * Delete any stale entries. Returns true if anything was removed,\n   * false otherwise.\n   */\n  purgeStale() {\n    let deleted = false\n    for (const i of this.#rindexes({ allowStale: true })) {\n      if (this.#isStale(i)) {\n        this.#delete(this.#keyList[i] as K, 'expire')\n        deleted = true\n      }\n    }\n    return deleted\n  }\n\n  /**\n   * Get the extended info about a given entry, to get its value, size, and\n   * TTL info simultaneously. Returns `undefined` if the key is not present.\n   *\n   * Unlike {@link LRUCache#dump}, which is designed to be portable and survive\n   * serialization, the `start` value is always the current timestamp, and the\n   * `ttl` is a calculated remaining time to live (negative if expired).\n   *\n   * Always returns stale values, if their info is found in the cache, so be\n   * sure to check for expirations (ie, a negative {@link LRUCache.Entry#ttl})\n   * if relevant.\n   */\n  info(key: K): LRUCache.Entry<V> | undefined {\n    const i = this.#keyMap.get(key)\n    if (i === undefined) return undefined\n    const v = this.#valList[i]\n    /* c8 ignore start - this isn't tested for the info function,\n     * but it's the same logic as found in other places. */\n    const value: V | undefined =\n      this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v\n    if (value === undefined) return undefined\n    /* c8 ignore stop */\n    const entry: LRUCache.Entry<V> = { value }\n    if (this.#ttls && this.#starts) {\n      const ttl = this.#ttls[i]\n      const start = this.#starts[i]\n      if (ttl && start) {\n        const remain = ttl - (this.#perf.now() - start)\n        entry.ttl = remain\n        entry.start = Date.now()\n      }\n    }\n    if (this.#sizes) {\n      entry.size = this.#sizes[i]\n    }\n    return entry\n  }\n\n  /**\n   * Return an array of [key, {@link LRUCache.Entry}] tuples which can be\n   * passed to {@link LRUCache#load}.\n   *\n   * The `start` fields are calculated relative to a portable `Date.now()`\n   * timestamp, even if `performance.now()` is available.\n   *\n   * Stale entries are always included in the `dump`, even if\n   * {@link LRUCache.OptionsBase.allowStale} is false.\n   *\n   * Note: this returns an actual array, not a generator, so it can be more\n   * easily passed around.\n   */\n  dump() {\n    const arr: [K, LRUCache.Entry<V>][] = []\n    for (const i of this.#indexes({ allowStale: true })) {\n      const key = this.#keyList[i]\n      const v = this.#valList[i]\n      const value: V | undefined =\n        this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v\n      if (value === undefined || key === undefined) continue\n      const entry: LRUCache.Entry<V> = { value }\n      if (this.#ttls && this.#starts) {\n        entry.ttl = this.#ttls[i]\n        // always dump the start relative to a portable timestamp\n        // it's ok for this to be a bit slow, it's a rare operation.\n        const age = this.#perf.now() - (this.#starts[i] as number)\n        entry.start = Math.floor(Date.now() - age)\n      }\n      if (this.#sizes) {\n        entry.size = this.#sizes[i]\n      }\n      arr.unshift([key, entry])\n    }\n    return arr\n  }\n\n  /**\n   * Reset the cache and load in the items in entries in the order listed.\n   *\n   * The shape of the resulting cache may be different if the same options are\n   * not used in both caches.\n   *\n   * The `start` fields are assumed to be calculated relative to a portable\n   * `Date.now()` timestamp, even if `performance.now()` is available.\n   */\n  load(arr: [K, LRUCache.Entry<V>][]) {\n    this.clear()\n    for (const [key, entry] of arr) {\n      if (entry.start) {\n        // entry.start is a portable timestamp, but we may be using\n        // node's performance.now(), so calculate the offset, so that\n        // we get the intended remaining TTL, no matter how long it's\n        // been on ice.\n        //\n        // it's ok for this to be a bit slow, it's a rare operation.\n        const age = Date.now() - entry.start\n        entry.start = this.#perf.now() - age\n      }\n      this.#set(key, entry.value, entry)\n    }\n  }\n\n  /**\n   * Add a value to the cache.\n   *\n   * Note: if `undefined` is specified as a value, this is an alias for\n   * {@link LRUCache#delete}\n   *\n   * Fields on the {@link LRUCache.SetOptions} options param will override\n   * their corresponding values in the constructor options for the scope\n   * of this single `set()` operation.\n   *\n   * If `start` is provided, then that will set the effective start\n   * time for the TTL calculation. Note that this must be a previous\n   * value of `performance.now()` if supported, or a previous value of\n   * `Date.now()` if not.\n   *\n   * Options object may also include `size`, which will prevent\n   * calling the `sizeCalculation` function and just use the specified\n   * number if it is a positive integer, and `noDisposeOnSet` which\n   * will prevent calling a `dispose` function in the case of\n   * overwrites.\n   *\n   * If the `size` (or return value of `sizeCalculation`) for a given\n   * entry is greater than `maxEntrySize`, then the item will not be\n   * added to the cache.\n   *\n   * Will update the recency of the entry.\n   *\n   * If the value is `undefined`, then this is an alias for\n   * `cache.delete(key)`. `undefined` is never stored in the cache.\n   */\n  set(\n    k: K,\n    v: V | undefined,\n    setOptions: LRUCache.SetOptions<K, V, FC> = {},\n  ) {\n    const { status = metrics.hasSubscribers ? {} : undefined } = setOptions\n    setOptions.status = status\n    if (status) {\n      status.op = 'set'\n      status.key = k\n      if (v !== undefined) status.value = v\n      status.cache = this\n    }\n    const result = this.#set(k, v, setOptions)\n    if (status && metrics.hasSubscribers) {\n      metrics.publish(status)\n    }\n    return result\n  }\n\n  #set(\n    k: K,\n    v: V | BackgroundFetch<V> | undefined,\n    setOptions: LRUCache.SetOptions<K, V, FC>,\n    bf?: BackgroundFetch<V>,\n  ) {\n    const {\n      ttl = this.ttl,\n      start,\n      noDisposeOnSet = this.noDisposeOnSet,\n      sizeCalculation = this.sizeCalculation,\n      status,\n    } = setOptions\n\n    const isBF = this.#isBackgroundFetch(v)\n    if (v === undefined) {\n      if (status) status.set = 'deleted'\n      this.delete(k)\n      return this\n    }\n    let { noUpdateTTL = this.noUpdateTTL } = setOptions\n\n    if (status && !isBF) status.value = v\n\n    const size = this.#requireSize(\n      k,\n      v,\n      setOptions.size || 0,\n      sizeCalculation,\n      status,\n    )\n    // if the item doesn't fit, don't do anything\n    // NB: maxEntrySize set to maxSize by default\n    if (this.maxEntrySize && size > this.maxEntrySize) {\n      // have to delete, in case something is there already.\n      this.#delete(k, 'set')\n      if (status) {\n        status.set = 'miss'\n        status.maxEntrySizeExceeded = true\n      }\n      return this\n    }\n    let index = this.#size === 0 ? undefined : this.#keyMap.get(k)\n    if (index === undefined) {\n      // addition\n      index = (\n        this.#size === 0 ? this.#tail\n        : this.#free.length !== 0 ? this.#free.pop()\n        : this.#size === this.#max ? this.#evict(false)\n        : this.#size) as Index\n      this.#keyList[index] = k\n      this.#valList[index] = v\n      this.#keyMap.set(k, index)\n      this.#next[this.#tail] = index\n      this.#prev[index] = this.#tail\n      this.#tail = index\n      this.#size++\n      this.#addItemSize(index, size, status)\n      if (status) status.set = 'add'\n      noUpdateTTL = false\n      if (this.#hasOnInsert && !isBF) {\n        this.#onInsert?.(v, k, 'add')\n      }\n    } else {\n      // update\n      // might be updating a background fetch!\n      this.#moveToTail(index)\n      const oldVal = this.#valList[index]!\n      if (v !== oldVal) {\n        if (!noDisposeOnSet) {\n          if (this.#isBackgroundFetch(oldVal)) {\n            if (oldVal !== bf) {\n              // setting over a background fetch, not merely resolving it.\n              oldVal.__abortController.abort(new Error('replaced'))\n            }\n            const { __staleWhileFetching: s } = oldVal\n            if (s !== undefined && s !== v) {\n              if (this.#hasDispose) {\n                this.#dispose?.(s, k, 'set')\n              }\n              if (this.#hasDisposeAfter) {\n                this.#disposed?.push([s, k, 'set'])\n              }\n            }\n          } else {\n            if (this.#hasDispose) {\n              this.#dispose?.(oldVal, k, 'set')\n            }\n            if (this.#hasDisposeAfter) {\n              this.#disposed?.push([oldVal, k, 'set'])\n            }\n          }\n        }\n        this.#removeItemSize(index)\n        this.#addItemSize(index, size, status)\n        this.#valList[index] = v\n        if (!isBF) {\n          const oldValue =\n            oldVal && this.#isBackgroundFetch(oldVal) ?\n              oldVal.__staleWhileFetching\n            : oldVal\n          const setType =\n            oldValue === undefined ? 'add'\n            : v !== oldValue ? 'replace'\n            : 'update'\n          if (status) {\n            status.set = setType\n            if (oldValue !== undefined) status.oldValue = oldValue\n          }\n          if (this.#hasOnInsert) {\n            this.onInsert?.(v, k, setType)\n          }\n        }\n      } else if (!isBF) {\n        if (status) {\n          status.set = 'update'\n        }\n        if (this.#hasOnInsert) {\n          this.onInsert?.(v, k, 'update')\n        }\n      }\n    }\n    if (ttl !== 0 && !this.#ttls) {\n      this.#initializeTTLTracking()\n    }\n    if (this.#ttls) {\n      if (!noUpdateTTL) {\n        this.#setItemTTL(index, ttl, start)\n      }\n      if (status) this.#statusTTL(status, index)\n    }\n    if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {\n      const dt = this.#disposed\n      let task: DisposeTask<K, V> | undefined\n      while ((task = dt?.shift())) {\n        this.#disposeAfter?.(...task)\n      }\n    }\n    return this\n  }\n\n  /**\n   * Evict the least recently used item, returning its value or\n   * `undefined` if cache is empty.\n   */\n  pop(): V | undefined {\n    try {\n      while (this.#size) {\n        const val = this.#valList[this.#head]\n        this.#evict(true)\n        if (this.#isBackgroundFetch(val)) {\n          if (val.__staleWhileFetching) {\n            return val.__staleWhileFetching\n          }\n        } else if (val !== undefined) {\n          return val\n        }\n      }\n    } finally {\n      if (this.#hasDisposeAfter && this.#disposed) {\n        const dt = this.#disposed\n        let task: DisposeTask<K, V> | undefined\n        while ((task = dt?.shift())) {\n          this.#disposeAfter?.(...task)\n        }\n      }\n    }\n  }\n\n  #evict(free: boolean) {\n    const head = this.#head\n    const k = this.#keyList[head]!\n    const v = this.#valList[head]!\n    const isBF = this.#isBackgroundFetch(v)\n    if (isBF) {\n      v.__abortController.abort(new Error('evicted'))\n    }\n    const oldValue = isBF ? v.__staleWhileFetching : v\n    if (\n      (this.#hasDispose || this.#hasDisposeAfter) &&\n      oldValue !== undefined\n    ) {\n      if (this.#hasDispose) {\n        this.#dispose?.(oldValue, k, 'evict')\n      }\n      if (this.#hasDisposeAfter) {\n        this.#disposed?.push([oldValue, k, 'evict'])\n      }\n    }\n    this.#removeItemSize(head)\n    if (this.#autopurgeTimers?.[head]) {\n      clearTimeout(this.#autopurgeTimers[head])\n      this.#autopurgeTimers[head] = undefined\n    }\n    // if we aren't about to use the index, then null these out\n    if (free) {\n      this.#keyList[head] = undefined\n      this.#valList[head] = undefined\n      this.#free.push(head)\n    }\n    if (this.#size === 1) {\n      this.#head = this.#tail = 0 as Index\n      this.#free.length = 0\n    } else {\n      this.#head = this.#next[head] as Index\n    }\n    this.#keyMap.delete(k)\n    this.#size--\n    return head\n  }\n\n  /**\n   * Check if a key is in the cache, without updating the recency of use.\n   * Will return false if the item is stale, even though it is technically\n   * in the cache.\n   *\n   * Check if a key is in the cache, without updating the recency of\n   * use. Age is updated if {@link LRUCache.OptionsBase.updateAgeOnHas} is set\n   * to `true` in either the options or the constructor.\n   *\n   * Will return `false` if the item is stale, even though it is technically in\n   * the cache. The difference can be determined (if it matters) by using a\n   * `status` argument, and inspecting the `has` field.\n   *\n   * Will not update item age unless\n   * {@link LRUCache.OptionsBase.updateAgeOnHas} is set.\n   */\n  has(k: K, hasOptions: LRUCache.HasOptions<K, V, FC> = {}) {\n    const { status = metrics.hasSubscribers ? {} : undefined } = hasOptions\n    hasOptions.status = status\n    if (status) {\n      status.op = 'has'\n      status.key = k\n      status.cache = this\n    }\n    const result = this.#has(k, hasOptions)\n    if (metrics.hasSubscribers) metrics.publish(status)\n    return result\n  }\n  #has(k: K, hasOptions: LRUCache.HasOptions<K, V, FC> = {}) {\n    const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions\n    const index = this.#keyMap.get(k)\n    if (index !== undefined) {\n      const v = this.#valList[index]\n      if (\n        this.#isBackgroundFetch(v) &&\n        v.__staleWhileFetching === undefined\n      ) {\n        return false\n      }\n      if (!this.#isStale(index)) {\n        if (updateAgeOnHas) {\n          this.#updateItemAge(index)\n        }\n        if (status) {\n          status.has = 'hit'\n          this.#statusTTL(status, index)\n        }\n        return true\n      } else if (status) {\n        status.has = 'stale'\n        this.#statusTTL(status, index)\n      }\n    } else if (status) {\n      status.has = 'miss'\n    }\n    return false\n  }\n\n  /**\n   * Like {@link LRUCache#get} but doesn't update recency or delete stale\n   * items.\n   *\n   * Returns `undefined` if the item is stale, unless\n   * {@link LRUCache.OptionsBase.allowStale} is set.\n   */\n  peek(k: K, peekOptions: LRUCache.PeekOptions<K, V, FC> = {}) {\n    const { status = hasSubscribers() ? {} : undefined } = peekOptions\n    if (status) {\n      status.op = 'peek'\n      status.key = k\n      status.cache = this\n    }\n    peekOptions.status = status\n    const result = this.#peek(k, peekOptions)\n    if (metrics.hasSubscribers) {\n      metrics.publish(status)\n    }\n    return result\n  }\n  #peek(k: K, peekOptions: LRUCache.PeekOptions<K, V, FC>) {\n    const { status, allowStale = this.allowStale } = peekOptions\n    const index = this.#keyMap.get(k)\n    if (index === undefined || (!allowStale && this.#isStale(index))) {\n      if (status) status.peek = index === undefined ? 'miss' : 'stale'\n      return undefined\n    }\n    const v = this.#valList[index]\n    const val = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v\n    if (status) {\n      if (val !== undefined) {\n        status.peek = 'hit'\n        status.value = val\n      } else {\n        status.peek = 'miss'\n      }\n    }\n    return val\n  }\n\n  #backgroundFetch(\n    k: K,\n    index: Index | undefined,\n    options: LRUCache.FetchOptions<K, V, FC>,\n    context: FC,\n  ): BackgroundFetch<V> {\n    const v = index === undefined ? undefined : this.#valList[index]\n    if (this.#isBackgroundFetch(v)) {\n      return v\n    }\n\n    const ac = new AbortController()\n    const { signal } = options\n    // when/if our AC signals, then stop listening to theirs.\n    signal?.addEventListener('abort', () => ac.abort(signal.reason), {\n      signal: ac.signal,\n    })\n\n    const fetchOpts = {\n      signal: ac.signal,\n      options,\n      context,\n    }\n\n    const cb = (v: V | undefined, updateCache = false): V | undefined => {\n      const { aborted } = ac.signal\n      const ignoreAbort = options.ignoreFetchAbort && v !== undefined\n      const proceed =\n        options.ignoreFetchAbort ||\n        !!(options.allowStaleOnFetchAbort && v !== undefined)\n      if (options.status) {\n        if (aborted && !updateCache) {\n          options.status.fetchAborted = true\n          options.status.fetchError = ac.signal.reason\n          if (ignoreAbort) options.status.fetchAbortIgnored = true\n        } else {\n          options.status.fetchResolved = true\n        }\n      }\n      if (aborted && !ignoreAbort && !updateCache) {\n        return fetchFail(ac.signal.reason, proceed)\n      }\n      // either we didn't abort, and are still here, or we did, and ignored\n      const bf = p as BackgroundFetch<V>\n      // if nothing else has been written there but we're set to update the\n      // cache and ignore the abort, or if it's still pending on this specific\n      // background request, then write it to the cache.\n      const vl = this.#valList[index as Index]\n      if (vl === p || (vl === undefined && ignoreAbort && updateCache)) {\n        if (v === undefined) {\n          if (bf.__staleWhileFetching !== undefined) {\n            this.#valList[index as Index] = bf.__staleWhileFetching\n          } else {\n            this.#delete(k, 'fetch')\n          }\n        } else {\n          if (options.status) options.status.fetchUpdated = true\n          this.#set(k, v, fetchOpts.options, bf)\n        }\n      }\n      return v\n    }\n\n    const eb = (er: unknown) => {\n      if (options.status) {\n        options.status.fetchRejected = true\n        options.status.fetchError = er as Error\n      }\n      // do not pass go, do not collect $200\n      return fetchFail(er, false)\n    }\n\n    const fetchFail = (er: unknown, proceed: boolean): V | undefined => {\n      const { aborted } = ac.signal\n      const allowStaleAborted = aborted && options.allowStaleOnFetchAbort\n      const allowStale =\n        allowStaleAborted || options.allowStaleOnFetchRejection\n      const noDelete = allowStale || options.noDeleteOnFetchRejection\n      const bf = p as BackgroundFetch<V>\n      if (this.#valList[index as Index] === p) {\n        // if we allow stale on fetch rejections, then we need to ensure that\n        // the stale value is not removed from the cache when the fetch fails.\n        const del =\n          !noDelete || (!proceed && bf.__staleWhileFetching === undefined)\n        if (del) {\n          this.#delete(k, 'fetch')\n        } else if (!allowStaleAborted) {\n          // still replace the *promise* with the stale value,\n          // since we are done with the promise at this point.\n          // leave it untouched if we're still waiting for an\n          // aborted background fetch that hasn't yet returned.\n          this.#valList[index as Index] = bf.__staleWhileFetching\n        }\n      }\n      if (allowStale) {\n        if (options.status && bf.__staleWhileFetching !== undefined) {\n          options.status.returnedStale = true\n        }\n        return bf.__staleWhileFetching\n      } else if (bf.__returned === bf) {\n        throw er\n      }\n    }\n\n    const pcall = (\n      res: (v: V | undefined) => void,\n      rej: (e: unknown) => void,\n    ) => {\n      const fmp = this.#fetchMethod?.(k, v, fetchOpts)\n      // ignored, we go until we finish, regardless.\n      // defer check until we are actually aborting,\n      // so fetchMethod can override.\n      ac.signal.addEventListener('abort', () => {\n        if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {\n          res(undefined)\n          // when it eventually resolves, update the cache.\n          if (options.allowStaleOnFetchAbort) {\n            res = v => cb(v, true)\n          }\n        }\n      })\n      if (fmp && fmp instanceof Promise) {\n        fmp.then(v => res(v === undefined ? undefined : v), rej)\n      } else if (fmp !== undefined) {\n        res(fmp)\n      }\n    }\n\n    if (options.status) options.status.fetchDispatched = true\n    const p = new Promise(pcall).then(cb, eb)\n    const bf: BackgroundFetch<V> = Object.assign(p, {\n      __abortController: ac,\n      __staleWhileFetching: v,\n      __returned: undefined,\n    })\n\n    if (index === undefined) {\n      // internal, don't expose status.\n      this.#set(k, bf, { ...fetchOpts.options, status: undefined })\n      index = this.#keyMap.get(k)\n    } else {\n      // do not call #set, because we do not want to adjust its place\n      // in the lru queue, as it has not yet been \"used\". Also, we don't\n      // need to worry about evicting for size, because a background fetch\n      // over a stale value is treated as the same size as its stale value.\n      this.#valList[index] = bf\n    }\n    return bf\n  }\n\n  #isBackgroundFetch(p: unknown): p is BackgroundFetch<V> {\n    if (!this.#hasFetchMethod) return false\n    const b = p as BackgroundFetch<V>\n    return (\n      !!b &&\n      b instanceof Promise &&\n      b.hasOwnProperty('__staleWhileFetching') &&\n      b.__abortController instanceof AbortController\n    )\n  }\n\n  /**\n   * Make an asynchronous cached fetch using the\n   * {@link LRUCache.OptionsBase.fetchMethod} function.\n   *\n   * If the value is in the cache and not stale, then the returned\n   * Promise resolves to the value.\n   *\n   * If not in the cache, or beyond its TTL staleness, then\n   * `fetchMethod(key, staleValue, { options, signal, context })` is\n   * called, and the value returned will be added to the cache once\n   * resolved.\n   *\n   * If called with `allowStale`, and an asynchronous fetch is\n   * currently in progress to reload a stale value, then the former\n   * stale value will be returned.\n   *\n   * If called with `forceRefresh`, then the cached item will be\n   * re-fetched, even if it is not stale. However, if `allowStale` is also\n   * set, then the old value will still be returned. This is useful\n   * in cases where you want to force a reload of a cached value. If\n   * a background fetch is already in progress, then `forceRefresh`\n   * has no effect.\n   *\n   * If multiple fetches for the same key are issued, then they will all be\n   * coalesced into a single call to fetchMethod.\n   *\n   * Note that this means that handling options such as\n   * {@link LRUCache.OptionsBase.allowStaleOnFetchAbort},\n   * {@link LRUCache.FetchOptions.signal},\n   * and {@link LRUCache.OptionsBase.allowStaleOnFetchRejection} will be\n   * determined by the FIRST fetch() call for a given key.\n   *\n   * This is a known (fixable) shortcoming which will be addresed on when\n   * someone complains about it, as the fix would involve added complexity and\n   * may not be worth the costs for this edge case.\n   *\n   * If {@link LRUCache.OptionsBase.fetchMethod} is not specified, then this is\n   * effectively an alias for `Promise.resolve(cache.get(key))`.\n   *\n   * When the fetch method resolves to a value, if the fetch has not\n   * been aborted due to deletion, eviction, or being overwritten,\n   * then it is added to the cache using the options provided.\n   *\n   * If the key is evicted or deleted before the `fetchMethod`\n   * resolves, then the AbortSignal passed to the `fetchMethod` will\n   * receive an `abort` event, and the promise returned by `fetch()`\n   * will reject with the reason for the abort.\n   *\n   * If a `signal` is passed to the `fetch()` call, then aborting the\n   * signal will abort the fetch and cause the `fetch()` promise to\n   * reject with the reason provided.\n   *\n   * **Setting `context`**\n   *\n   * If an `FC` type is set to a type other than `unknown`, `void`, or\n   * `undefined` in the {@link LRUCache} constructor, then all\n   * calls to `cache.fetch()` _must_ provide a `context` option. If\n   * set to `undefined` or `void`, then calls to fetch _must not_\n   * provide a `context` option.\n   *\n   * The `context` param allows you to provide arbitrary data that\n   * might be relevant in the course of fetching the data. It is only\n   * relevant for the course of a single `fetch()` operation, and\n   * discarded afterwards.\n   *\n   * **Note: `fetch()` calls are inflight-unique**\n   *\n   * If you call `fetch()` multiple times with the same key value,\n   * then every call after the first will resolve on the same\n   * promise<sup>1</sup>,\n   * _even if they have different settings that would otherwise change\n   * the behavior of the fetch_, such as `noDeleteOnFetchRejection`\n   * or `ignoreFetchAbort`.\n   *\n   * In most cases, this is not a problem (in fact, only fetching\n   * something once is what you probably want, if you're caching in\n   * the first place). If you are changing the fetch() options\n   * dramatically between runs, there's a good chance that you might\n   * be trying to fit divergent semantics into a single object, and\n   * would be better off with multiple cache instances.\n   *\n   * **1**: Ie, they're not the \"same Promise\", but they resolve at\n   * the same time, because they're both waiting on the same\n   * underlying fetchMethod response.\n   */\n\n  fetch(\n    k: K,\n    fetchOptions: unknown extends FC ? LRUCache.FetchOptions<K, V, FC>\n    : FC extends undefined | void ?\n      LRUCache.FetchOptionsNoContext<K, V, FC>\n    : LRUCache.FetchOptionsWithContext<K, V, FC>,\n  ): Promise<undefined | V>\n\n  // this overload not allowed if context is required\n  fetch(\n    k: unknown extends FC ? K\n    : FC extends undefined | void ? K\n    : never,\n    fetchOptions?: unknown extends FC ? LRUCache.FetchOptions<K, V, FC>\n    : FC extends undefined | void ?\n      LRUCache.FetchOptionsNoContext<K, V, FC>\n    : never,\n  ): Promise<undefined | V>\n  fetch(\n    k: K,\n    fetchOptions: LRUCache.FetchOptions<K, V, FC> = {},\n  ): Promise<undefined | V> {\n    const ths = tracing.hasSubscribers\n    const { status = hasSubscribers() ? {} : undefined } = fetchOptions\n    fetchOptions.status = status\n    if (status && fetchOptions.context) {\n      status.context = fetchOptions.context\n    }\n    const p = this.#fetch(k, fetchOptions)\n    if (status && ths) {\n      status.trace = true\n      tracing.tracePromise(() => p, status).catch(() => {})\n    }\n    return p\n  }\n\n  async #fetch(\n    k: K,\n    fetchOptions: LRUCache.FetchOptions<K, V, FC> = {},\n  ): Promise<undefined | V> {\n    const {\n      // get options\n      allowStale = this.allowStale,\n      updateAgeOnGet = this.updateAgeOnGet,\n      noDeleteOnStaleGet = this.noDeleteOnStaleGet,\n      // set options\n      ttl = this.ttl,\n      noDisposeOnSet = this.noDisposeOnSet,\n      size = 0,\n      sizeCalculation = this.sizeCalculation,\n      noUpdateTTL = this.noUpdateTTL,\n      // fetch exclusive options\n      noDeleteOnFetchRejection = this.noDeleteOnFetchRejection,\n      allowStaleOnFetchRejection = this.allowStaleOnFetchRejection,\n      ignoreFetchAbort = this.ignoreFetchAbort,\n      allowStaleOnFetchAbort = this.allowStaleOnFetchAbort,\n      context,\n      forceRefresh = false,\n      status,\n      signal,\n    } = fetchOptions\n    if (status) {\n      status.op = 'fetch'\n      status.key = k\n      if (forceRefresh) status.forceRefresh = true\n      status.cache = this\n    }\n\n    if (!this.#hasFetchMethod) {\n      if (status) status.fetch = 'get'\n      return this.#get(k, {\n        allowStale,\n        updateAgeOnGet,\n        noDeleteOnStaleGet,\n        status,\n      })\n    }\n\n    const options = {\n      allowStale,\n      updateAgeOnGet,\n      noDeleteOnStaleGet,\n      ttl,\n      noDisposeOnSet,\n      size,\n      sizeCalculation,\n      noUpdateTTL,\n      noDeleteOnFetchRejection,\n      allowStaleOnFetchRejection,\n      allowStaleOnFetchAbort,\n      ignoreFetchAbort,\n      status,\n      signal,\n    }\n\n    let index = this.#keyMap.get(k)\n    if (index === undefined) {\n      if (status) status.fetch = 'miss'\n      const p = this.#backgroundFetch(k, index, options, context as FC)\n      return (p.__returned = p)\n    } else {\n      // in cache, maybe already fetching\n      const v = this.#valList[index]\n      if (this.#isBackgroundFetch(v)) {\n        const stale = allowStale && v.__staleWhileFetching !== undefined\n        if (status) {\n          status.fetch = 'inflight'\n          if (stale) status.returnedStale = true\n        }\n        return stale ? v.__staleWhileFetching : (v.__returned = v)\n      }\n\n      // if we force a refresh, that means do NOT serve the cached value,\n      // unless we are already in the process of refreshing the cache.\n      const isStale = this.#isStale(index)\n      if (!forceRefresh && !isStale) {\n        if (status) status.fetch = 'hit'\n        this.#moveToTail(index)\n        if (updateAgeOnGet) {\n          this.#updateItemAge(index)\n        }\n        if (status) this.#statusTTL(status, index)\n        return v\n      }\n\n      // ok, it is stale or a forced refresh, and not already fetching.\n      // refresh the cache.\n      const p = this.#backgroundFetch(k, index, options, context as FC)\n      const hasStale = p.__staleWhileFetching !== undefined\n      const staleVal = hasStale && allowStale\n      if (status) {\n        status.fetch = isStale ? 'stale' : 'refresh'\n        if (staleVal && isStale) status.returnedStale = true\n      }\n      return staleVal ? p.__staleWhileFetching : (p.__returned = p)\n    }\n  }\n\n  /**\n   * In some cases, `cache.fetch()` may resolve to `undefined`, either because\n   * a {@link LRUCache.OptionsBase#fetchMethod} was not provided (turning\n   * `cache.fetch(k)` into just an async wrapper around `cache.get(k)`) or\n   * because `ignoreFetchAbort` was specified (either to the constructor or\n   * in the {@link LRUCache.FetchOptions}). Also, the\n   * {@link LRUCache.OptionsBase.fetchMethod} may return `undefined` or `void`, making\n   * the test even more complicated.\n   *\n   * Because inferring the cases where `undefined` might be returned are so\n   * cumbersome, but testing for `undefined` can also be annoying, this method\n   * can be used, which will reject if `this.fetch()` resolves to undefined.\n   */\n  forceFetch(\n    k: K,\n    fetchOptions: unknown extends FC ? LRUCache.FetchOptions<K, V, FC>\n    : FC extends undefined | void ?\n      LRUCache.FetchOptionsNoContext<K, V, FC>\n    : LRUCache.FetchOptionsWithContext<K, V, FC>,\n  ): Promise<V>\n  // this overload not allowed if context is required\n  forceFetch(\n    k: unknown extends FC ? K\n    : FC extends undefined | void ? K\n    : never,\n    fetchOptions?: unknown extends FC ? LRUCache.FetchOptions<K, V, FC>\n    : FC extends undefined | void ?\n      LRUCache.FetchOptionsNoContext<K, V, FC>\n    : never,\n  ): Promise<V>\n  forceFetch(\n    k: K,\n    fetchOptions: LRUCache.FetchOptions<K, V, FC> = {},\n  ): Promise<V> {\n    const ths = tracing.hasSubscribers\n    const { status = hasSubscribers() ? {} : undefined } = fetchOptions\n    fetchOptions.status = status\n    if (status && fetchOptions.context) {\n      status.context = fetchOptions.context\n    }\n    const p = this.#forceFetch(k, fetchOptions)\n    if (status && ths) {\n      status.trace = true\n      tracing.tracePromise(() => p, status).catch(() => {})\n    }\n    return p\n  }\n\n  async #forceFetch(\n    k: K,\n    fetchOptions: LRUCache.FetchOptions<K, V, FC> = {},\n  ) {\n    const v = await this.#fetch(k, fetchOptions)\n    if (v === undefined) throw new Error('fetch() returned undefined')\n    return v\n  }\n\n  /**\n   * If the key is found in the cache, then this is equivalent to\n   * {@link LRUCache#get}. If not, in the cache, then calculate the value using\n   * the {@link LRUCache.OptionsBase.memoMethod}, and add it to the cache.\n   *\n   * If an `FC` type is set to a type other than `unknown`, `void`, or\n   * `undefined` in the LRUCache constructor, then all calls to `cache.memo()`\n   * _must_ provide a `context` option. If set to `undefined` or `void`, then\n   * calls to memo _must not_ provide a `context` option.\n   *\n   * The `context` param allows you to provide arbitrary data that might be\n   * relevant in the course of fetching the data. It is only relevant for the\n   * course of a single `memo()` operation, and discarded afterwards.\n   */\n  memo(\n    k: K,\n    memoOptions: unknown extends FC ? LRUCache.MemoOptions<K, V, FC>\n    : FC extends undefined | void ? LRUCache.MemoOptionsNoContext<K, V, FC>\n    : LRUCache.MemoOptionsWithContext<K, V, FC>,\n  ): V\n  // this overload not allowed if context is required\n  memo(\n    k: unknown extends FC ? K\n    : FC extends undefined | void ? K\n    : never,\n    memoOptions?: unknown extends FC ? LRUCache.MemoOptions<K, V, FC>\n    : FC extends undefined | void ? LRUCache.MemoOptionsNoContext<K, V, FC>\n    : never,\n  ): V\n  memo(k: K, memoOptions: LRUCache.MemoOptions<K, V, FC> = {}) {\n    const { status = metrics.hasSubscribers ? {} : undefined } =\n      memoOptions\n    memoOptions.status = status\n    if (status) {\n      status.op = 'memo'\n      status.key = k\n      if (memoOptions.context) {\n        status.context = memoOptions.context\n      }\n      status.cache = this\n    }\n    const result = this.#memo(k, memoOptions)\n    if (status) status.value = result\n    if (metrics.hasSubscribers) metrics.publish(status)\n    return result\n  }\n  #memo(k: K, memoOptions: LRUCache.MemoOptions<K, V, FC> = {}) {\n    const memoMethod = this.#memoMethod\n    if (!memoMethod) {\n      throw new Error('no memoMethod provided to constructor')\n    }\n    const { context, status, forceRefresh, ...options } = memoOptions\n    if (status && forceRefresh) status.forceRefresh = true\n    const v = this.#get(k, options)\n    const refresh = forceRefresh || v === undefined\n    if (status) {\n      status.memo = refresh ? 'miss' : 'hit'\n      if (!refresh) status.value = v\n    }\n    if (!refresh) return v\n    const vv = memoMethod(k, v, {\n      options,\n      context,\n    } as LRUCache.MemoizerOptions<K, V, FC>)\n    if (status) status.value = vv\n    this.#set(k, vv, options)\n    return vv\n  }\n\n  /**\n   * Return a value from the cache. Will update the recency of the cache\n   * entry found.\n   *\n   * If the key is not found, get() will return `undefined`.\n   */\n  get(k: K, getOptions: LRUCache.GetOptions<K, V, FC> = {}) {\n    const { status = metrics.hasSubscribers ? {} : undefined } = getOptions\n    getOptions.status = status\n    if (status) {\n      status.op = 'get'\n      status.key = k\n      status.cache = this\n    }\n    const result = this.#get(k, getOptions)\n    if (status) {\n      if (result !== undefined) status.value = result\n      if (metrics.hasSubscribers) metrics.publish(status)\n    }\n    return result\n  }\n\n  #get(k: K, getOptions: LRUCache.GetOptions<K, V, FC> = {}) {\n    const {\n      allowStale = this.allowStale,\n      updateAgeOnGet = this.updateAgeOnGet,\n      noDeleteOnStaleGet = this.noDeleteOnStaleGet,\n      status,\n    } = getOptions\n    const index = this.#keyMap.get(k)\n    if (index === undefined) {\n      if (status) status.get = 'miss'\n      return undefined\n    }\n    const value = this.#valList[index]\n    const fetching = this.#isBackgroundFetch(value)\n    if (status) this.#statusTTL(status, index)\n    if (this.#isStale(index)) {\n      // delete only if not an in-flight background fetch\n      if (!fetching) {\n        if (!noDeleteOnStaleGet) {\n          this.#delete(k, 'expire')\n        }\n        if (status) status.get = 'stale'\n        if (allowStale) {\n          if (status) status.returnedStale = true\n          return value\n        }\n        return undefined\n      }\n      if (status) status.get = 'stale-fetching'\n      if (allowStale && value.__staleWhileFetching !== undefined) {\n        if (status) status.returnedStale = true\n        return value.__staleWhileFetching\n      }\n      return undefined\n    }\n    // not stale\n    if (status) status.get = fetching ? 'fetching' : 'hit'\n    // if we're currently fetching it, we don't actually have it yet\n    // it's not stale, which means this isn't a staleWhileRefetching.\n    // If it's not stale, and fetching, AND has a __staleWhileFetching\n    // value, then that means the user fetched with {forceRefresh:true},\n    // so it's safe to return that value.\n    this.#moveToTail(index)\n    if (updateAgeOnGet) {\n      this.#updateItemAge(index)\n    }\n    return fetching ? value.__staleWhileFetching : value\n  }\n\n  #connect(p: Index, n: Index) {\n    this.#prev[n] = p\n    this.#next[p] = n\n  }\n\n  #moveToTail(index: Index): void {\n    // if tail already, nothing to do\n    // if head, move head to next[index]\n    // else\n    //   move next[prev[index]] to next[index] (head has no prev)\n    //   move prev[next[index]] to prev[index]\n    // prev[index] = tail\n    // next[tail] = index\n    // tail = index\n    if (index !== this.#tail) {\n      if (index === this.#head) {\n        this.#head = this.#next[index] as Index\n      } else {\n        this.#connect(\n          this.#prev[index] as Index,\n          this.#next[index] as Index,\n        )\n      }\n      this.#connect(this.#tail, index)\n      this.#tail = index\n    }\n  }\n\n  /**\n   * Deletes a key out of the cache.\n   *\n   * Returns true if the key was deleted, false otherwise.\n   */\n  delete(k: K) {\n    return this.#delete(k, 'delete')\n  }\n\n  #delete(k: K, reason: LRUCache.DisposeReason) {\n    if (metrics.hasSubscribers) {\n      metrics.publish({\n        op: 'delete',\n        delete: reason,\n        key: k,\n        cache: this,\n      })\n    }\n    let deleted = false\n    if (this.#size !== 0) {\n      const index = this.#keyMap.get(k)\n      if (index !== undefined) {\n        if (this.#autopurgeTimers?.[index]) {\n          clearTimeout(this.#autopurgeTimers[index])\n          this.#autopurgeTimers[index] = undefined\n        }\n        deleted = true\n        if (this.#size === 1) {\n          this.#clear(reason)\n        } else {\n          this.#removeItemSize(index)\n          const v = this.#valList[index]\n          if (this.#isBackgroundFetch(v)) {\n            v.__abortController.abort(new Error('deleted'))\n          } else if (this.#hasDispose || this.#hasDisposeAfter) {\n            if (this.#hasDispose) {\n              this.#dispose?.(v as V, k, reason)\n            }\n            if (this.#hasDisposeAfter) {\n              this.#disposed?.push([v as V, k, reason])\n            }\n          }\n          this.#keyMap.delete(k)\n          this.#keyList[index] = undefined\n          this.#valList[index] = undefined\n          if (index === this.#tail) {\n            this.#tail = this.#prev[index] as Index\n          } else if (index === this.#head) {\n            this.#head = this.#next[index] as Index\n          } else {\n            const pi = this.#prev[index] as number\n            this.#next[pi] = this.#next[index] as number\n            const ni = this.#next[index] as number\n            this.#prev[ni] = this.#prev[index] as number\n          }\n          this.#size--\n          this.#free.push(index)\n        }\n      }\n    }\n    if (this.#hasDisposeAfter && this.#disposed?.length) {\n      const dt = this.#disposed\n      let task: DisposeTask<K, V> | undefined\n      while ((task = dt?.shift())) {\n        this.#disposeAfter?.(...task)\n      }\n    }\n    return deleted\n  }\n\n  /**\n   * Clear the cache entirely, throwing away all values.\n   */\n  clear() {\n    return this.#clear('delete')\n  }\n  #clear(reason: LRUCache.DisposeReason) {\n    for (const index of this.#rindexes({ allowStale: true })) {\n      const v = this.#valList[index]\n      if (this.#isBackgroundFetch(v)) {\n        v.__abortController.abort(new Error('deleted'))\n      } else {\n        const k = this.#keyList[index]\n        if (this.#hasDispose) {\n          this.#dispose?.(v as V, k as K, reason)\n        }\n        if (this.#hasDisposeAfter) {\n          this.#disposed?.push([v as V, k as K, reason])\n        }\n      }\n    }\n\n    this.#keyMap.clear()\n    void this.#valList.fill(undefined)\n    this.#keyList.fill(undefined)\n    if (this.#ttls && this.#starts) {\n      this.#ttls.fill(0)\n      this.#starts.fill(0)\n      for (const t of this.#autopurgeTimers ?? []) {\n        if (t !== undefined) clearTimeout(t)\n      }\n      this.#autopurgeTimers?.fill(undefined)\n    }\n    if (this.#sizes) {\n      this.#sizes.fill(0)\n    }\n    this.#head = 0 as Index\n    this.#tail = 0 as Index\n    this.#free.length = 0\n    this.#calculatedSize = 0\n    this.#size = 0\n    if (this.#hasDisposeAfter && this.#disposed) {\n      const dt = this.#disposed\n      let task: DisposeTask<K, V> | undefined\n      while ((task = dt?.shift())) {\n        this.#disposeAfter?.(...task)\n      }\n    }\n  }\n}\n", "import { LRUCache } from 'lru-cache'\nimport { posix, win32 } from 'node:path'\n\nimport { fileURLToPath } from 'node:url'\n\nimport {\n  lstatSync,\n  readdir as readdirCB,\n  readdirSync,\n  readlinkSync,\n  realpathSync as rps,\n} from 'fs'\nimport * as actualFS from 'node:fs'\n\nconst realpathSync = rps.native\n// TODO: test perf of fs/promises realpath vs realpathCB,\n// since the promises one uses realpath.native\n\nimport { lstat, readdir, readlink, realpath } from 'node:fs/promises'\n\nimport { Minipass } from 'minipass'\nimport type { Dirent, Stats } from 'node:fs'\n\n/**\n * An object that will be used to override the default `fs`\n * methods.  Any methods that are not overridden will use Node's\n * built-in implementations.\n *\n * - lstatSync\n * - readdir (callback `withFileTypes` Dirent variant, used for\n *   readdirCB and most walks)\n * - readdirSync\n * - readlinkSync\n * - realpathSync\n * - promises: Object containing the following async methods:\n *   - lstat\n *   - readdir (Dirent variant only)\n *   - readlink\n *   - realpath\n */\nexport interface FSOption {\n  lstatSync?: (path: string) => Stats\n  readdir?: (\n    path: string,\n    options: { withFileTypes: true },\n    cb: (er: NodeJS.ErrnoException | null, entries?: Dirent[]) => any,\n  ) => void\n  readdirSync?: (\n    path: string,\n    options: { withFileTypes: true },\n  ) => Dirent[]\n  readlinkSync?: (path: string) => string\n  realpathSync?: (path: string) => string\n  promises?: {\n    lstat?: (path: string) => Promise<Stats>\n    readdir?: (\n      path: string,\n      options: { withFileTypes: true },\n    ) => Promise<Dirent[]>\n    readlink?: (path: string) => Promise<string>\n    realpath?: (path: string) => Promise<string>\n    [k: string]: any\n  }\n  [k: string]: any\n}\n\ninterface FSValue {\n  lstatSync: (path: string) => Stats\n  readdir: (\n    path: string,\n    options: { withFileTypes: true },\n    cb: (er: NodeJS.ErrnoException | null, entries?: Dirent[]) => any,\n  ) => void\n  readdirSync: (path: string, options: { withFileTypes: true }) => Dirent[]\n  readlinkSync: (path: string) => string\n  realpathSync: (path: string) => string\n  promises: {\n    lstat: (path: string) => Promise<Stats>\n    readdir: (\n      path: string,\n      options: { withFileTypes: true },\n    ) => Promise<Dirent[]>\n    readlink: (path: string) => Promise<string>\n    realpath: (path: string) => Promise<string>\n    [k: string]: any\n  }\n  [k: string]: any\n}\n\nconst defaultFS: FSValue = {\n  lstatSync,\n  readdir: readdirCB,\n  readdirSync,\n  readlinkSync,\n  realpathSync,\n  promises: {\n    lstat,\n    readdir,\n    readlink,\n    realpath,\n  },\n}\n\n// if they just gave us require('fs') then use our default\nconst fsFromOption = (fsOption?: FSOption): FSValue =>\n  !fsOption || fsOption === defaultFS || fsOption === actualFS ?\n    defaultFS\n  : {\n      ...defaultFS,\n      ...fsOption,\n      promises: {\n        ...defaultFS.promises,\n        ...(fsOption.promises),\n      },\n    }\n\n// turn something like //?/c:/ into c:\\, and //?/UNC/host/share/ or\n// //host/share into \\\\host\\share\\\nconst uncDriveRegexp = /^\\\\\\\\\\?\\\\([a-z]:)\\\\?$/i\nconst uncLongRegexp = /^\\\\\\\\\\?\\\\UNC\\\\([^\\\\]+\\\\[^\\\\]+)\\\\?$/i\nconst uncShareRegexp = /^\\\\\\\\[^\\\\?]+\\\\[^\\\\]+$/\nconst uncToDrive = (rootPath: string): string =>\n  rootPath\n    .replace(/\\//g, '\\\\')\n    .replace(uncDriveRegexp, '$1\\\\')\n    .replace(uncLongRegexp, '\\\\\\\\$1\\\\')\n    .replace(uncShareRegexp, '$&\\\\')\n\n// path.win32.parse() only finds the //?/UNC/ of a long UNC root\nconst longUncRoot =\n  /^[\\\\/]{2}\\?[\\\\/]unc[\\\\/][^\\\\/]+[\\\\/][^\\\\/]+(?:[\\\\/]|$)/i\n\n// //?/c:/x is the same path as c:/x\nconst longDrivePrefix = /^[\\\\/]{2}\\?[\\\\/](?=[a-z]:)/i\n// //?/UNC/host/share/x is the same path as //host/share/x. This\n// matches up to the / after UNC, which with a \\ in front of it is\n// the // in front of the host.\nconst longUncPrefix = /^[\\\\/]{2}\\?[\\\\/]unc(?=[\\\\/][^\\\\/]+[\\\\/][^\\\\/])/i\n\n// windows paths are separated by either / or \\\nconst eitherSep = /[\\\\/]/\n\nconst UNKNOWN = 0 // may not even exist, for all we know\nconst IFIFO = 0b0001\nconst IFCHR = 0b0010\nconst IFDIR = 0b0100\nconst IFBLK = 0b0110\nconst IFREG = 0b1000\nconst IFLNK = 0b1010\nconst IFSOCK = 0b1100\nconst IFMT = 0b1111\n\nexport type Type =\n  | 'Unknown'\n  | 'FIFO'\n  | 'CharacterDevice'\n  | 'Directory'\n  | 'BlockDevice'\n  | 'File'\n  | 'SymbolicLink'\n  | 'Socket'\n\n// mask to unset low 4 bits\nconst IFMT_UNKNOWN = ~IFMT\n\n// set after successfully calling readdir() and getting entries.\nconst READDIR_CALLED = 0b0000_0001_0000\n// set after a successful lstat()\nconst LSTAT_CALLED = 0b0000_0010_0000\n// set if an entry (or one of its parents) is definitely not a dir\nconst ENOTDIR = 0b0000_0100_0000\n// set if an entry (or one of its parents) does not exist\n// (can also be set on lstat errors like EACCES or ENAMETOOLONG)\nconst ENOENT = 0b0000_1000_0000\n// cannot have child entries -- also verify &IFMT is either IFDIR or IFLNK\n// set if we fail to readlink\nconst ENOREADLINK = 0b0001_0000_0000\n// set if we know realpath() will fail\nconst ENOREALPATH = 0b0010_0000_0000\n\nconst ENOCHILD = ENOTDIR | ENOENT | ENOREALPATH\nconst TYPEMASK = 0b0011_1111_1111\n\nconst entToType = (s: Dirent | Stats) =>\n  s.isFile() ? IFREG\n  : s.isDirectory() ? IFDIR\n  : s.isSymbolicLink() ? IFLNK\n  : s.isCharacterDevice() ? IFCHR\n  : s.isBlockDevice() ? IFBLK\n  : s.isSocket() ? IFSOCK\n  : s.isFIFO() ? IFIFO\n  : UNKNOWN\n\n// normalize unicode path names\nconst normalizeCache = new LRUCache<string, string>({ max: 2 ** 12 })\nconst normalize = (s: string) => {\n  const c = normalizeCache.get(s)\n  if (c) return c\n  const n = s.normalize('NFKD')\n  normalizeCache.set(s, n)\n  return n\n}\n\nconst normalizeNocaseCache = new LRUCache<string, string>({ max: 2 ** 12 })\nconst normalizeNocase = (s: string) => {\n  const c = normalizeNocaseCache.get(s)\n  if (c) return c\n  const n = normalize(s.toLowerCase())\n  normalizeNocaseCache.set(s, n)\n  return n\n}\n\n/**\n * Options that may be provided to the Path constructor\n */\nexport interface PathOpts {\n  fullpath?: string\n  relative?: string\n  relativePosix?: string\n  parent?: PathBase\n  /**\n   * See {@link FSOption}\n   */\n  fs?: FSOption\n}\n\n/**\n * An LRUCache for storing resolved path strings or Path objects.\n * @internal\n */\nexport class ResolveCache extends LRUCache<string, string> {\n  constructor() {\n    super({ max: 256 })\n  }\n}\n\n// In order to prevent blowing out the js heap by allocating hundreds of\n// thousands of Path entries when walking extremely large trees, the \"children\"\n// in this tree are represented by storing an array of Path entries in an\n// LRUCache, indexed by the parent.  At any time, Path.children() may return an\n// empty array, indicating that it doesn't know about any of its children, and\n// thus has to rebuild that cache.  This is fine, it just means that we don't\n// benefit as much from having the cached entries, but huge directory walks\n// don't blow out the stack, and smaller ones are still as fast as possible.\n//\n//It does impose some complexity when building up the readdir data, because we\n//need to pass a reference to the children array that we started with.\n\n/**\n * an LRUCache for storing child entries.\n * @internal\n */\nexport class ChildrenCache extends LRUCache<PathBase, Children> {\n  constructor(maxSize: number = 16 * 1024) {\n    super({\n      maxSize,\n      // parent + children\n      sizeCalculation: a => a.length + 1,\n    })\n  }\n}\n\n/**\n * Array of Path objects, plus a marker indicating the first provisional entry\n *\n * @internal\n */\nexport type Children = PathBase[] & { provisional: number }\n\nconst setAsCwd = Symbol('PathScurry setAsCwd')\n\n/**\n * Path objects are sort of like a super-powered\n * {@link https://nodejs.org/docs/latest/api/fs.html#class-fsdirent fs.Dirent}\n *\n * Each one represents a single filesystem entry on disk, which may or may not\n * exist. It includes methods for reading various types of information via\n * lstat, readlink, and readdir, and caches all information to the greatest\n * degree possible.\n *\n * Note that fs operations that would normally throw will instead return an\n * \"empty\" value. This is in order to prevent excessive overhead from error\n * stack traces.\n */\nexport abstract class PathBase implements Dirent {\n  /**\n   * the basename of this path\n   *\n   * **Important**: *always* test the path name against any test string\n   * usingthe {@link isNamed} method, and not by directly comparing this\n   * string. Otherwise, unicode path strings that the system sees as identical\n   * will not be properly treated as the same path, leading to incorrect\n   * behavior and possible security issues.\n   */\n  name: string\n  /**\n   * the Path entry corresponding to the path root.\n   *\n   * @internal\n   */\n  root: PathBase\n  /**\n   * All roots found within the current PathScurry family\n   *\n   * @internal\n   */\n  roots: { [k: string]: PathBase }\n  /**\n   * a reference to the parent path, or undefined in the case of root entries\n   *\n   * @internal\n   */\n  parent?: PathBase\n  /**\n   * boolean indicating whether paths are compared case-insensitively\n   * @internal\n   */\n  nocase: boolean\n\n  /**\n   * boolean indicating that this path is the current working directory\n   * of the PathScurry collection that contains it.\n   */\n  isCWD: boolean = false\n\n  /**\n   * the string or regexp used to split paths. On posix, it is `'/'`, and on\n   * windows it is a RegExp matching either `'/'` or `'\\\\'`\n   */\n  abstract splitSep: string | RegExp\n  /**\n   * The path separator string to use when joining paths\n   */\n  abstract sep: string\n\n  // potential default fs override\n  #fs: FSValue\n\n  // Stats fields\n  #dev?: number\n  get dev() {\n    return this.#dev\n  }\n  #mode?: number\n  get mode() {\n    return this.#mode\n  }\n  #nlink?: number\n  get nlink() {\n    return this.#nlink\n  }\n  #uid?: number\n  get uid() {\n    return this.#uid\n  }\n  #gid?: number\n  get gid() {\n    return this.#gid\n  }\n  #rdev?: number\n  get rdev() {\n    return this.#rdev\n  }\n  #blksize?: number\n  get blksize() {\n    return this.#blksize\n  }\n  #ino?: number\n  get ino() {\n    return this.#ino\n  }\n  #size?: number\n  get size() {\n    return this.#size\n  }\n  #blocks?: number\n  get blocks() {\n    return this.#blocks\n  }\n  #atimeMs?: number\n  get atimeMs() {\n    return this.#atimeMs\n  }\n  #mtimeMs?: number\n  get mtimeMs() {\n    return this.#mtimeMs\n  }\n  #ctimeMs?: number\n  get ctimeMs() {\n    return this.#ctimeMs\n  }\n  #birthtimeMs?: number\n  get birthtimeMs() {\n    return this.#birthtimeMs\n  }\n  #atime?: Date\n  get atime() {\n    return this.#atime\n  }\n  #mtime?: Date\n  get mtime() {\n    return this.#mtime\n  }\n  #ctime?: Date\n  get ctime() {\n    return this.#ctime\n  }\n  #birthtime?: Date\n  get birthtime() {\n    return this.#birthtime\n  }\n\n  #matchName: string\n  #depth?: number\n  #fullpath?: string\n  #fullpathPosix?: string\n  #relative?: string\n  #relativePosix?: string\n  #type: number\n  #children: ChildrenCache\n  #linkTarget?: PathBase\n  #realpath?: PathBase\n\n  /**\n   * This property is for compatibility with the Dirent class as of\n   * Node v20, where Dirent['parentPath'] refers to the path of the\n   * directory that was passed to readdir. For root entries, it's the path\n   * to the entry itself.\n   */\n  get parentPath(): string {\n    return (this.parent || this).fullpath()\n  }\n\n  /* c8 ignore start */\n  /**\n   * Deprecated alias for Dirent['parentPath'] Somewhat counterintuitively,\n   * this property refers to the *parent* path, not the path object itself.\n   *\n   * @deprecated\n   */\n  get path(): string {\n    return this.parentPath\n  }\n  /* c8 ignore stop */\n\n  /**\n   * Do not create new Path objects directly.  They should always be accessed\n   * via the PathScurry class or other methods on the Path class.\n   *\n   * @internal\n   */\n  constructor(\n    name: string,\n    type: number = UNKNOWN,\n    root: PathBase | undefined,\n    roots: { [k: string]: PathBase },\n    nocase: boolean,\n    children: ChildrenCache,\n    opts: PathOpts,\n  ) {\n    this.name = name\n    this.#matchName = nocase ? normalizeNocase(name) : normalize(name)\n    this.#type = type & TYPEMASK\n    this.nocase = nocase\n    this.roots = roots\n    this.root = root || this\n    this.#children = children\n    this.#fullpath = opts.fullpath\n    this.#relative = opts.relative\n    this.#relativePosix = opts.relativePosix\n    this.parent = opts.parent\n    if (this.parent) {\n      this.#fs = this.parent.#fs\n    } else {\n      this.#fs = fsFromOption(opts.fs)\n    }\n  }\n\n  /**\n   * The file system methods that this Path uses, for a new root on\n   * another drive or UNC share.\n   *\n   * @internal\n   */\n  get fs(): FSOption {\n    return this.#fs\n  }\n\n  /**\n   * Returns the depth of the Path object from its root.\n   *\n   * For example, a path at `/foo/bar` would have a depth of 2.\n   */\n  depth(): number {\n    if (this.#depth !== undefined) return this.#depth\n    if (!this.parent) return (this.#depth = 0)\n    return (this.#depth = this.parent.depth() + 1)\n  }\n\n  /**\n   * @internal\n   */\n  abstract getRootString(path: string): string\n  /**\n   * @internal\n   */\n  abstract getRoot(rootPath: string): PathBase\n  /**\n   * @internal\n   */\n  abstract newChild(name: string, type?: number, opts?: PathOpts): PathBase\n\n  /**\n   * @internal\n   */\n  childrenCache() {\n    return this.#children\n  }\n\n  /**\n   * Get the Path object referenced by the string path, resolved from this Path\n   */\n  resolve(path?: string): PathBase {\n    if (!path) {\n      return this\n    }\n    const rootPath = this.getRootString(path)\n    const dir = path.substring(rootPath.length)\n    const dirParts = dir.split(this.splitSep)\n    const result: PathBase =\n      rootPath ?\n        this.getRoot(rootPath).#resolveParts(dirParts)\n      : this.#resolveParts(dirParts)\n    return result\n  }\n\n  #resolveParts(dirParts: string[]) {\n    let p: PathBase = this\n    for (const part of dirParts) {\n      p = p.child(part)\n    }\n    return p\n  }\n\n  /**\n   * Returns the cached children Path objects, if still available.  If they\n   * have fallen out of the cache, then returns an empty array, and resets the\n   * READDIR_CALLED bit, so that future calls to readdir() will require an fs\n   * lookup.\n   *\n   * @internal\n   */\n  children(): Children {\n    const cached = this.#children.get(this)\n    if (cached) {\n      return cached\n    }\n    const children: Children = Object.assign([], { provisional: 0 })\n    this.#children.set(this, children)\n    this.#type &= ~READDIR_CALLED\n    return children\n  }\n\n  /**\n   * Resolves a path portion and returns or creates the child Path.\n   *\n   * Returns `this` if pathPart is `''` or `'.'`, or `parent` if pathPart is\n   * `'..'`.\n   *\n   * This should not be called directly.  If `pathPart` contains any path\n   * separators, it will lead to unsafe undefined behavior.\n   *\n   * Use `Path.resolve()` instead.\n   *\n   * @internal\n   */\n  child(pathPart: string, opts?: PathOpts): PathBase {\n    if (pathPart === '' || pathPart === '.') {\n      return this\n    }\n    if (pathPart === '..') {\n      return this.parent || this\n    }\n\n    // find the child\n    const children = this.children()\n    const name =\n      this.nocase ? normalizeNocase(pathPart) : normalize(pathPart)\n    for (const p of children) {\n      if (p.#matchName === name) {\n        return p\n      }\n    }\n\n    // didn't find it, create provisional child, since it might not\n    // actually exist.  If we know the parent isn't a dir, then\n    // in fact it CAN'T exist.\n    const s = this.parent ? this.sep : ''\n    const fullpath =\n      this.#fullpath ? this.#fullpath + s + pathPart : undefined\n    const pchild = this.newChild(pathPart, UNKNOWN, {\n      ...opts,\n      parent: this,\n      fullpath,\n    })\n\n    if (!this.canReaddir()) {\n      pchild.#type |= ENOENT\n    }\n\n    // don't have to update provisional, because if we have real children,\n    // then provisional is set to children.length, otherwise a lower number\n    children.push(pchild)\n    return pchild\n  }\n\n  /**\n   * The relative path from the cwd. If it does not share an ancestor with\n   * the cwd, then this ends up being equivalent to the fullpath()\n   */\n  relative(): string {\n    if (this.isCWD) return ''\n    if (this.#relative !== undefined) {\n      return this.#relative\n    }\n    const name = this.name\n    const p = this.parent\n    if (!p) {\n      return (this.#relative = this.name)\n    }\n    const pv = p.relative()\n    return pv + (!pv || !p.parent ? '' : this.sep) + name\n  }\n\n  /**\n   * The relative path from the cwd, using / as the path separator.\n   * If it does not share an ancestor with\n   * the cwd, then this ends up being equivalent to the fullpathPosix()\n   * On posix systems, this is identical to relative().\n   */\n  relativePosix(): string {\n    if (this.sep === '/') return this.relative()\n    if (this.isCWD) return ''\n    if (this.#relativePosix !== undefined) return this.#relativePosix\n    const name = this.name\n    const p = this.parent\n    if (!p) {\n      return (this.#relativePosix = this.fullpathPosix())\n    }\n    const pv = p.relativePosix()\n    return pv + (!pv || !p.parent ? '' : '/') + name\n  }\n\n  /**\n   * The fully resolved path string for this Path entry\n   */\n  fullpath(): string {\n    if (this.#fullpath !== undefined) {\n      return this.#fullpath\n    }\n    const name = this.name\n    const p = this.parent\n    if (!p) {\n      return (this.#fullpath = this.name)\n    }\n    const pv = p.fullpath()\n    const fp = pv + (!p.parent ? '' : this.sep) + name\n    return (this.#fullpath = fp)\n  }\n\n  /**\n   * On platforms other than windows, this is identical to fullpath.\n   *\n   * On windows, this is overridden to return the forward-slash form of the\n   * full UNC path.\n   */\n  fullpathPosix(): string {\n    if (this.#fullpathPosix !== undefined) return this.#fullpathPosix\n    if (this.sep === '/') return (this.#fullpathPosix = this.fullpath())\n    if (!this.parent) {\n      const p = this.fullpath().replace(/\\\\/g, '/')\n      if (/^[a-z]:\\//i.test(p)) {\n        return (this.#fullpathPosix = `//?/${p}`)\n      } else {\n        return (this.#fullpathPosix = p)\n      }\n    }\n    const p = this.parent\n    const pfpp = p.fullpathPosix()\n    const fpp = pfpp + (!pfpp || !p.parent ? '' : '/') + this.name\n    return (this.#fullpathPosix = fpp)\n  }\n\n  /**\n   * Is the Path of an unknown type?\n   *\n   * Note that we might know *something* about it if there has been a previous\n   * filesystem operation, for example that it does not exist, or is not a\n   * link, or whether it has child entries.\n   */\n  isUnknown(): boolean {\n    return (this.#type & IFMT) === UNKNOWN\n  }\n\n  isType(type: Type): boolean {\n    return this[`is${type}`]()\n  }\n\n  getType(): Type {\n    return (\n      this.isUnknown() ? 'Unknown'\n      : this.isDirectory() ? 'Directory'\n      : this.isFile() ? 'File'\n      : this.isSymbolicLink() ? 'SymbolicLink'\n      : this.isFIFO() ? 'FIFO'\n      : this.isCharacterDevice() ? 'CharacterDevice'\n      : this.isBlockDevice() ? 'BlockDevice'\n      : /* c8 ignore start */ this.isSocket() ? 'Socket'\n      : 'Unknown'\n    )\n    /* c8 ignore stop */\n  }\n\n  /**\n   * Is the Path a regular file?\n   */\n  isFile(): boolean {\n    return (this.#type & IFMT) === IFREG\n  }\n\n  /**\n   * Is the Path a directory?\n   */\n  isDirectory(): boolean {\n    return (this.#type & IFMT) === IFDIR\n  }\n\n  /**\n   * Is the path a character device?\n   */\n  isCharacterDevice(): boolean {\n    return (this.#type & IFMT) === IFCHR\n  }\n\n  /**\n   * Is the path a block device?\n   */\n  isBlockDevice(): boolean {\n    return (this.#type & IFMT) === IFBLK\n  }\n\n  /**\n   * Is the path a FIFO pipe?\n   */\n  isFIFO(): boolean {\n    return (this.#type & IFMT) === IFIFO\n  }\n\n  /**\n   * Is the path a socket?\n   */\n  isSocket(): boolean {\n    return (this.#type & IFMT) === IFSOCK\n  }\n\n  /**\n   * Is the path a symbolic link?\n   */\n  isSymbolicLink(): boolean {\n    return (this.#type & IFLNK) === IFLNK\n  }\n\n  /**\n   * Return the entry if it has been subject of a successful lstat, or\n   * undefined otherwise.\n   *\n   * Does not read the filesystem, so an undefined result *could* simply\n   * mean that we haven't called lstat on it.\n   */\n  lstatCached(): PathBase | undefined {\n    return this.#type & LSTAT_CALLED ? this : undefined\n  }\n\n  /**\n   * Return the cached link target if the entry has been the subject of a\n   * successful readlink, or undefined otherwise.\n   *\n   * Does not read the filesystem, so an undefined result *could* just mean we\n   * don't have any cached data. Only use it if you are very sure that a\n   * readlink() has been called at some point.\n   */\n  readlinkCached(): PathBase | undefined {\n    return this.#linkTarget\n  }\n\n  /**\n   * Returns the cached realpath target if the entry has been the subject\n   * of a successful realpath, or undefined otherwise.\n   *\n   * Does not read the filesystem, so an undefined result *could* just mean we\n   * don't have any cached data. Only use it if you are very sure that a\n   * realpath() has been called at some point.\n   */\n  realpathCached(): PathBase | undefined {\n    return this.#realpath\n  }\n\n  /**\n   * Returns the cached child Path entries array if the entry has been the\n   * subject of a successful readdir(), or [] otherwise.\n   *\n   * Does not read the filesystem, so an empty array *could* just mean we\n   * don't have any cached data. Only use it if you are very sure that a\n   * readdir() has been called recently enough to still be valid.\n   */\n  readdirCached(): PathBase[] {\n    const children = this.children()\n    return children.slice(0, children.provisional)\n  }\n\n  /**\n   * Return true if it's worth trying to readlink.  Ie, we don't (yet) have\n   * any indication that readlink will definitely fail.\n   *\n   * Returns false if the path is known to not be a symlink, if a previous\n   * readlink failed, or if the entry does not exist.\n   */\n  canReadlink(): boolean {\n    if (this.#linkTarget) return true\n    if (!this.parent) return false\n    // cases where it cannot possibly succeed\n    const ifmt = this.#type & IFMT\n    return !(\n      (ifmt !== UNKNOWN && ifmt !== IFLNK) ||\n      this.#type & ENOREADLINK ||\n      this.#type & ENOENT\n    )\n  }\n\n  /**\n   * Return true if readdir has previously been successfully called on this\n   * path, indicating that cachedReaddir() is likely valid.\n   */\n  calledReaddir(): boolean {\n    return !!(this.#type & READDIR_CALLED)\n  }\n\n  /**\n   * Returns true if the path is known to not exist. That is, a previous lstat\n   * or readdir failed to verify its existence when that would have been\n   * expected, or a parent entry was marked either enoent or enotdir.\n   */\n  isENOENT(): boolean {\n    return !!(this.#type & ENOENT)\n  }\n\n  /**\n   * Return true if the path is a match for the given path name.  This handles\n   * case sensitivity and unicode normalization.\n   *\n   * Note: even on case-sensitive systems, it is **not** safe to test the\n   * equality of the `.name` property to determine whether a given pathname\n   * matches, due to unicode normalization mismatches.\n   *\n   * Always use this method instead of testing the `path.name` property\n   * directly.\n   */\n  isNamed(n: string): boolean {\n    return !this.nocase ?\n        this.#matchName === normalize(n)\n      : this.#matchName === normalizeNocase(n)\n  }\n\n  /**\n   * Return the Path object corresponding to the target of a symbolic link.\n   *\n   * If the Path is not a symbolic link, or if the readlink call fails for any\n   * reason, `undefined` is returned.\n   *\n   * Result is cached, and thus may be outdated if the filesystem is mutated.\n   */\n  async readlink(): Promise<PathBase | undefined> {\n    const target = this.#linkTarget\n    if (target) {\n      return target\n    }\n    if (!this.canReadlink()) {\n      return undefined\n    }\n    /* c8 ignore start */\n    // already covered by the canReadlink test, here for ts grumples\n    if (!this.parent) {\n      return undefined\n    }\n    /* c8 ignore stop */\n    try {\n      const read = await this.#fs.promises.readlink(this.fullpath())\n      const linkTarget = (await this.parent.realpath())?.resolve(read)\n      if (linkTarget) {\n        return (this.#linkTarget = linkTarget)\n      }\n    } catch (er) {\n      this.#readlinkFail((er as NodeJS.ErrnoException).code)\n      return undefined\n    }\n  }\n\n  /**\n   * Synchronous {@link PathBase.readlink}\n   */\n  readlinkSync(): PathBase | undefined {\n    const target = this.#linkTarget\n    if (target) {\n      return target\n    }\n    if (!this.canReadlink()) {\n      return undefined\n    }\n    /* c8 ignore start */\n    // already covered by the canReadlink test, here for ts grumples\n    if (!this.parent) {\n      return undefined\n    }\n    /* c8 ignore stop */\n    try {\n      const read = this.#fs.readlinkSync(this.fullpath())\n      const linkTarget = this.parent.realpathSync()?.resolve(read)\n      if (linkTarget) {\n        return (this.#linkTarget = linkTarget)\n      }\n    } catch (er) {\n      this.#readlinkFail((er as NodeJS.ErrnoException).code)\n      return undefined\n    }\n  }\n\n  #readdirSuccess(children: Children) {\n    // succeeded, mark readdir called bit\n    this.#type |= READDIR_CALLED\n    // mark all remaining provisional children as ENOENT\n    for (let p = children.provisional; p < children.length; p++) {\n      const c = children[p]\n      if (c) c.#markENOENT()\n    }\n  }\n\n  #markENOENT() {\n    // mark as UNKNOWN and ENOENT\n    if (this.#type & ENOENT) return\n    this.#type = (this.#type | ENOENT) & IFMT_UNKNOWN\n    this.#markChildrenENOENT()\n  }\n\n  #markChildrenENOENT() {\n    // all children are provisional and do not exist\n    const children = this.children()\n    children.provisional = 0\n    for (const p of children) {\n      p.#markENOENT()\n    }\n  }\n\n  #markENOREALPATH() {\n    this.#type |= ENOREALPATH\n    this.#markENOTDIR()\n  }\n\n  // save the information when we know the entry is not a dir\n  #markENOTDIR() {\n    // entry is not a directory, so any children can't exist.\n    // this *should* be impossible, since any children created\n    // after it's been marked ENOTDIR should be marked ENOENT,\n    // so it won't even get to this point.\n    /* c8 ignore start */\n    if (this.#type & ENOTDIR) return\n    /* c8 ignore stop */\n    let t = this.#type\n    // this could happen if we stat a dir, then delete it,\n    // then try to read it or one of its children.\n    if ((t & IFMT) === IFDIR) t &= IFMT_UNKNOWN\n    this.#type = t | ENOTDIR\n    this.#markChildrenENOENT()\n  }\n\n  #readdirFail(code: string = '') {\n    // markENOTDIR and markENOENT also set provisional=0\n    if (code === 'ENOTDIR' || code === 'EPERM') {\n      this.#markENOTDIR()\n    } else if (code === 'ENOENT') {\n      this.#markENOENT()\n    } else {\n      this.children().provisional = 0\n    }\n  }\n\n  #lstatFail(code: string = '') {\n    // Windows just raises ENOENT in this case, disable for win CI\n    /* c8 ignore start */\n    if (code === 'ENOTDIR') {\n      // already know it has a parent by this point\n      const p = this.parent as PathBase\n      p.#markENOTDIR()\n    } else if (code === 'ENOENT') {\n      /* c8 ignore stop */\n      this.#markENOENT()\n    }\n  }\n\n  #readlinkFail(code: string = '') {\n    let ter = this.#type\n    ter |= ENOREADLINK\n    if (code === 'ENOENT') ter |= ENOENT\n    // windows gets a weird error when you try to readlink a file\n    if (code === 'EINVAL' || code === 'UNKNOWN') {\n      // exists, but not a symlink, we don't know WHAT it is, so remove\n      // all IFMT bits.\n      ter &= IFMT_UNKNOWN\n    }\n    this.#type = ter\n    // windows just gets ENOENT in this case.  We do cover the case,\n    // just disabled because it's impossible on Windows CI\n    /* c8 ignore start */\n    if (code === 'ENOTDIR' && this.parent) {\n      this.parent.#markENOTDIR()\n    }\n    /* c8 ignore stop */\n  }\n\n  #readdirAddChild(e: Dirent, c: Children) {\n    return (\n      this.#readdirMaybePromoteChild(e, c) ||\n      this.#readdirAddNewChild(e, c)\n    )\n  }\n\n  #readdirAddNewChild(e: Dirent, c: Children): PathBase {\n    // alloc new entry at head, so it's never provisional\n    const type = entToType(e)\n    const child = this.newChild(e.name, type, { parent: this })\n    const ifmt = child.#type & IFMT\n    if (ifmt !== IFDIR && ifmt !== IFLNK && ifmt !== UNKNOWN) {\n      child.#type |= ENOTDIR\n    }\n    c.unshift(child)\n    c.provisional++\n    return child\n  }\n\n  #readdirMaybePromoteChild(e: Dirent, c: Children): PathBase | undefined {\n    for (let p = c.provisional; p < c.length; p++) {\n      const pchild = c[p]\n      const name =\n        this.nocase ? normalizeNocase(e.name) : normalize(e.name)\n      if (name !== pchild!.#matchName) {\n        continue\n      }\n\n      return this.#readdirPromoteChild(e, pchild!, p, c)\n    }\n  }\n\n  #readdirPromoteChild(\n    e: Dirent,\n    p: PathBase,\n    index: number,\n    c: Children,\n  ): PathBase {\n    const v = p.name\n    // retain any other flags, but set ifmt from dirent\n    p.#type = (p.#type & IFMT_UNKNOWN) | entToType(e)\n    // case sensitivity fixing when we learn the true name.\n    if (v !== e.name) p.name = e.name\n\n    // just advance provisional index (potentially off the list),\n    // otherwise we have to splice/pop it out and re-insert at head\n    if (index !== c.provisional) {\n      if (index === c.length - 1) c.pop()\n      else c.splice(index, 1)\n      c.unshift(p)\n    }\n    c.provisional++\n    return p\n  }\n\n  /**\n   * Call lstat() on this Path, and update all known information that can be\n   * determined.\n   *\n   * Note that unlike `fs.lstat()`, the returned value does not contain some\n   * information, such as `mode`, `dev`, `nlink`, and `ino`.  If that\n   * information is required, you will need to call `fs.lstat` yourself.\n   *\n   * If the Path refers to a nonexistent file, or if the lstat call fails for\n   * any reason, `undefined` is returned.  Otherwise the updated Path object is\n   * returned.\n   *\n   * Results are cached, and thus may be out of date if the filesystem is\n   * mutated.\n   */\n  async lstat(): Promise<PathBase | undefined> {\n    if ((this.#type & ENOENT) === 0) {\n      try {\n        this.#applyStat(await this.#fs.promises.lstat(this.fullpath()))\n        return this\n      } catch (er) {\n        this.#lstatFail((er as NodeJS.ErrnoException).code)\n      }\n    }\n  }\n\n  /**\n   * synchronous {@link PathBase.lstat}\n   */\n  lstatSync(): PathBase | undefined {\n    if ((this.#type & ENOENT) === 0) {\n      try {\n        this.#applyStat(this.#fs.lstatSync(this.fullpath()))\n        return this\n      } catch (er) {\n        this.#lstatFail((er as NodeJS.ErrnoException).code)\n      }\n    }\n  }\n\n  #applyStat(st: Stats) {\n    const {\n      atime,\n      atimeMs,\n      birthtime,\n      birthtimeMs,\n      blksize,\n      blocks,\n      ctime,\n      ctimeMs,\n      dev,\n      gid,\n      ino,\n      mode,\n      mtime,\n      mtimeMs,\n      nlink,\n      rdev,\n      size,\n      uid,\n    } = st\n    this.#atime = atime\n    this.#atimeMs = atimeMs\n    this.#birthtime = birthtime\n    this.#birthtimeMs = birthtimeMs\n    this.#blksize = blksize\n    this.#blocks = blocks\n    this.#ctime = ctime\n    this.#ctimeMs = ctimeMs\n    this.#dev = dev\n    this.#gid = gid\n    this.#ino = ino\n    this.#mode = mode\n    this.#mtime = mtime\n    this.#mtimeMs = mtimeMs\n    this.#nlink = nlink\n    this.#rdev = rdev\n    this.#size = size\n    this.#uid = uid\n    const ifmt = entToType(st)\n    // retain any other flags, but set the ifmt\n    this.#type = (this.#type & IFMT_UNKNOWN) | ifmt | LSTAT_CALLED\n    if (ifmt !== UNKNOWN && ifmt !== IFDIR && ifmt !== IFLNK) {\n      this.#type |= ENOTDIR\n    }\n  }\n\n  #onReaddirCB: ((\n    er: NodeJS.ErrnoException | null,\n    entries: Path[],\n  ) => any)[] = []\n  #readdirCBInFlight: boolean = false\n  #callOnReaddirCB(children: Path[]) {\n    this.#readdirCBInFlight = false\n    const cbs = this.#onReaddirCB.slice()\n    this.#onReaddirCB.length = 0\n    cbs.forEach(cb => cb(null, children))\n  }\n\n  /**\n   * Standard node-style callback interface to get list of directory entries.\n   *\n   * If the Path cannot or does not contain any children, then an empty array\n   * is returned.\n   *\n   * Results are cached, and thus may be out of date if the filesystem is\n   * mutated.\n   *\n   * @param cb The callback called with (er, entries).  Note that the `er`\n   * param is somewhat extraneous, as all readdir() errors are handled and\n   * simply result in an empty set of entries being returned.\n   * @param allowZalgo Boolean indicating that immediately known results should\n   * *not* be deferred with `queueMicrotask`. Defaults to `false`. Release\n   * zalgo at your peril, the dark pony lord is devious and unforgiving.\n   */\n  readdirCB(\n    cb: (er: NodeJS.ErrnoException | null, entries: PathBase[]) => any,\n    allowZalgo: boolean = false,\n  ): void {\n    if (!this.canReaddir()) {\n      if (allowZalgo) cb(null, [])\n      else queueMicrotask(() => cb(null, []))\n      return\n    }\n\n    const children = this.children()\n    if (this.calledReaddir()) {\n      const c = children.slice(0, children.provisional)\n      if (allowZalgo) cb(null, c)\n      else queueMicrotask(() => cb(null, c))\n      return\n    }\n\n    // don't have to worry about zalgo at this point.\n    this.#onReaddirCB.push(cb)\n    if (this.#readdirCBInFlight) {\n      return\n    }\n    this.#readdirCBInFlight = true\n\n    // else read the directory, fill up children\n    // de-provisionalize any provisional children.\n    const fullpath = this.fullpath()\n    this.#fs.readdir(fullpath, { withFileTypes: true }, (er, entries) => {\n      if (er) {\n        this.#readdirFail((er as NodeJS.ErrnoException).code)\n        children.provisional = 0\n      } else {\n        // if we didn't get an error, we always get entries.\n        //@ts-ignore\n        for (const e of entries) {\n          this.#readdirAddChild(e, children)\n        }\n        this.#readdirSuccess(children)\n      }\n      this.#callOnReaddirCB(children.slice(0, children.provisional))\n      return\n    })\n  }\n\n  #asyncReaddirInFlight?: Promise<void>\n\n  /**\n   * Return an array of known child entries.\n   *\n   * If the Path cannot or does not contain any children, then an empty array\n   * is returned.\n   *\n   * Results are cached, and thus may be out of date if the filesystem is\n   * mutated.\n   */\n  async readdir(): Promise<PathBase[]> {\n    if (!this.canReaddir()) {\n      return []\n    }\n\n    const children = this.children()\n    if (this.calledReaddir()) {\n      return children.slice(0, children.provisional)\n    }\n\n    // else read the directory, fill up children\n    // de-provisionalize any provisional children.\n    const fullpath = this.fullpath()\n    if (this.#asyncReaddirInFlight) {\n      await this.#asyncReaddirInFlight\n    } else {\n      /* c8 ignore start */\n      let resolve: () => void = () => {}\n      /* c8 ignore stop */\n      this.#asyncReaddirInFlight = new Promise<void>(\n        res => (resolve = res),\n      )\n      try {\n        for (const e of await this.#fs.promises.readdir(fullpath, {\n          withFileTypes: true,\n        })) {\n          this.#readdirAddChild(e, children)\n        }\n        this.#readdirSuccess(children)\n      } catch (er) {\n        this.#readdirFail((er as NodeJS.ErrnoException).code)\n        children.provisional = 0\n      }\n      this.#asyncReaddirInFlight = undefined\n      resolve()\n    }\n    return children.slice(0, children.provisional)\n  }\n\n  /**\n   * synchronous {@link PathBase.readdir}\n   */\n  readdirSync(): PathBase[] {\n    if (!this.canReaddir()) {\n      return []\n    }\n\n    const children = this.children()\n    if (this.calledReaddir()) {\n      return children.slice(0, children.provisional)\n    }\n\n    // else read the directory, fill up children\n    // de-provisionalize any provisional children.\n    const fullpath = this.fullpath()\n    try {\n      for (const e of this.#fs.readdirSync(fullpath, {\n        withFileTypes: true,\n      })) {\n        this.#readdirAddChild(e, children)\n      }\n      this.#readdirSuccess(children)\n    } catch (er) {\n      this.#readdirFail((er as NodeJS.ErrnoException).code)\n      children.provisional = 0\n    }\n    return children.slice(0, children.provisional)\n  }\n\n  canReaddir() {\n    if (this.#type & ENOCHILD) return false\n    const ifmt = IFMT & this.#type\n    // we always set ENOTDIR when setting IFMT, so should be impossible\n    /* c8 ignore start */\n    if (!(ifmt === UNKNOWN || ifmt === IFDIR || ifmt === IFLNK)) {\n      return false\n    }\n    /* c8 ignore stop */\n    return true\n  }\n\n  shouldWalk(\n    dirs: Set<PathBase | undefined>,\n    walkFilter?: (e: PathBase) => boolean,\n  ): boolean {\n    return (\n      (this.#type & IFDIR) === IFDIR &&\n      !(this.#type & ENOCHILD) &&\n      !dirs.has(this) &&\n      (!walkFilter || walkFilter(this))\n    )\n  }\n\n  /**\n   * Return the Path object corresponding to path as resolved\n   * by realpath(3).\n   *\n   * If the realpath call fails for any reason, `undefined` is returned.\n   *\n   * Result is cached, and thus may be outdated if the filesystem is mutated.\n   * On success, returns a Path object.\n   */\n  async realpath(): Promise<PathBase | undefined> {\n    if (this.#realpath) return this.#realpath\n    if ((ENOREALPATH | ENOREADLINK | ENOENT) & this.#type) return undefined\n    try {\n      const rp = await this.#fs.promises.realpath(this.fullpath())\n      return (this.#realpath = this.resolve(rp))\n    } catch {\n      this.#markENOREALPATH()\n    }\n  }\n\n  /**\n   * Synchronous {@link realpath}\n   */\n  realpathSync(): PathBase | undefined {\n    if (this.#realpath) return this.#realpath\n    if ((ENOREALPATH | ENOREADLINK | ENOENT) & this.#type) return undefined\n    try {\n      const rp = this.#fs.realpathSync(this.fullpath())\n      return (this.#realpath = this.resolve(rp))\n    } catch {\n      this.#markENOREALPATH()\n    }\n  }\n\n  /**\n   * Internal method to mark this Path object as the scurry cwd,\n   * called by {@link PathScurry#chdir}\n   *\n   * @internal\n   */\n  [setAsCwd](oldCwd: PathBase): void {\n    if (oldCwd === this) return\n    oldCwd.isCWD = false\n    this.isCWD = true\n\n    const changed = new Set<PathBase>([])\n    let rp = []\n    let p: PathBase = this\n    while (p && p.parent) {\n      changed.add(p)\n      p.#relative = rp.join(this.sep)\n      p.#relativePosix = rp.join('/')\n      p = p.parent\n      rp.push('..')\n    }\n    // now un-memoize parents of old cwd\n    p = oldCwd\n    while (p && p.parent && !changed.has(p)) {\n      p.#relative = undefined\n      p.#relativePosix = undefined\n      p = p.parent\n    }\n  }\n}\n\n/**\n * Path class used on win32 systems\n *\n * Uses `'\\\\'` as the path separator for returned paths, either `'\\\\'` or `'/'`\n * as the path separator for parsing paths.\n */\nexport class PathWin32 extends PathBase {\n  /**\n   * Separator for generating path strings.\n   */\n  sep: '\\\\' = '\\\\'\n  /**\n   * Separator for parsing path strings.\n   */\n  splitSep: RegExp = eitherSep\n\n  /**\n   * Do not create new Path objects directly.  They should always be accessed\n   * via the PathScurry class or other methods on the Path class.\n   *\n   * @internal\n   */\n  constructor(\n    name: string,\n    type: number = UNKNOWN,\n    root: PathBase | undefined,\n    roots: { [k: string]: PathBase },\n    nocase: boolean,\n    children: ChildrenCache,\n    opts: PathOpts,\n  ) {\n    super(name, type, root, roots, nocase, children, opts)\n  }\n\n  /**\n   * @internal\n   */\n  newChild(name: string, type: number = UNKNOWN, opts: PathOpts = {}) {\n    return new PathWin32(\n      name,\n      type,\n      this.root,\n      this.roots,\n      this.nocase,\n      this.childrenCache(),\n      opts,\n    )\n  }\n\n  /**\n   * @internal\n   */\n  getRootString(path: string): string {\n    return longUncRoot.exec(path)?.[0] ?? win32.parse(path).root\n  }\n\n  /**\n   * @internal\n   */\n  getRoot(rootPath: string): PathBase {\n    rootPath = uncToDrive(rootPath.toUpperCase())\n    // a root with no drive or UNC host is the root of this path\n    if (rootPath === this.root.name || /^[\\\\/]$/.test(rootPath)) {\n      return this.root\n    }\n    // ok, not that one, check if it matches another we know about\n    for (const [compare, root] of Object.entries(this.roots)) {\n      if (this.sameRoot(rootPath, compare)) {\n        return (this.roots[rootPath] = root)\n      }\n    }\n    // otherwise, have to create a new one.\n    return (this.roots[rootPath] = new PathScurryWin32(rootPath, {\n      nocase: this.nocase,\n      fs: this.fs,\n    }).root)\n  }\n\n  /**\n   * @internal\n   */\n  sameRoot(rootPath: string, compare: string = this.root.name): boolean {\n    // windows can (rarely) have case-sensitive filesystem, but\n    // UNC and drive letters are always case-insensitive, and canonically\n    // represented uppercase.\n    return uncToDrive(rootPath.toUpperCase()) === compare\n  }\n}\n\n/**\n * Path class used on all posix systems.\n *\n * Uses `'/'` as the path separator.\n */\nexport class PathPosix extends PathBase {\n  /**\n   * separator for parsing path strings\n   */\n  splitSep: '/' = '/'\n  /**\n   * separator for generating path strings\n   */\n  sep: '/' = '/'\n\n  /**\n   * Do not create new Path objects directly.  They should always be accessed\n   * via the PathScurry class or other methods on the Path class.\n   *\n   * @internal\n   */\n  constructor(\n    name: string,\n    type: number = UNKNOWN,\n    root: PathBase | undefined,\n    roots: { [k: string]: PathBase },\n    nocase: boolean,\n    children: ChildrenCache,\n    opts: PathOpts,\n  ) {\n    super(name, type, root, roots, nocase, children, opts)\n  }\n\n  /**\n   * @internal\n   */\n  getRootString(path: string): string {\n    return path.startsWith('/') ? '/' : ''\n  }\n\n  /**\n   * @internal\n   */\n  getRoot(_rootPath: string): PathBase {\n    return this.root\n  }\n\n  /**\n   * @internal\n   */\n  newChild(name: string, type: number = UNKNOWN, opts: PathOpts = {}) {\n    return new PathPosix(\n      name,\n      type,\n      this.root,\n      this.roots,\n      this.nocase,\n      this.childrenCache(),\n      opts,\n    )\n  }\n}\n\n/**\n * Options that may be provided to the PathScurry constructor\n */\nexport interface PathScurryOpts {\n  /**\n   * perform case-insensitive path matching. Default based on platform\n   * subclass.\n   */\n  nocase?: boolean\n  /**\n   * Number of Path entries to keep in the cache of Path child references.\n   *\n   * Setting this higher than 65536 will dramatically increase the data\n   * consumption and construction time overhead of each PathScurry.\n   *\n   * Setting this value to 256 or lower will significantly reduce the data\n   * consumption and construction time overhead, but may also reduce resolve()\n   * and readdir() performance on large filesystems.\n   *\n   * Default `16384`.\n   */\n  childrenCacheSize?: number\n  /**\n   * An object that overrides the built-in functions from the fs and\n   * fs/promises modules.\n   *\n   * See {@link FSOption}\n   */\n  fs?: FSOption\n}\n\n/**\n * The base class for all PathScurry classes, providing the interface for path\n * resolution and filesystem operations.\n *\n * Typically, you should *not* instantiate this class directly, but rather one\n * of the platform-specific classes, or the exported {@link PathScurry} which\n * defaults to the current platform.\n */\nexport abstract class PathScurryBase {\n  /**\n   * The root Path entry for the current working directory of this Scurry\n   */\n  root: PathBase\n  /**\n   * The string path for the root of this Scurry's current working directory\n   */\n  rootPath: string\n  /**\n   * A collection of all roots encountered, referenced by rootPath\n   */\n  roots: { [k: string]: PathBase }\n  /**\n   * The Path entry corresponding to this PathScurry's current working directory.\n   */\n  cwd: PathBase\n  #resolveCache: ResolveCache\n  #resolvePosixCache: ResolveCache\n  #children: ChildrenCache\n  /**\n   * Perform path comparisons case-insensitively.\n   *\n   * Defaults true on Darwin and Windows systems, false elsewhere.\n   */\n  nocase: boolean\n\n  /**\n   * The path separator used for parsing paths\n   *\n   * `'/'` on Posix systems, either `'/'` or `'\\\\'` on Windows\n   */\n  abstract sep: string | RegExp\n\n  #fs: FSValue\n\n  /**\n   * This class should not be instantiated directly.\n   *\n   * Use PathScurryWin32, PathScurryDarwin, PathScurryPosix, or PathScurry\n   *\n   * @internal\n   */\n  constructor(\n    cwd: URL | string = process.cwd(),\n    pathImpl: typeof win32 | typeof posix,\n    sep: string | RegExp,\n    {\n      nocase,\n      childrenCacheSize = 16 * 1024,\n      fs = defaultFS,\n    }: PathScurryOpts = {},\n  ) {\n    this.#fs = fsFromOption(fs)\n    if (cwd instanceof URL || cwd.startsWith('file://')) {\n      cwd = fileURLToPath(cwd)\n    }\n    // resolve and split root, and then add to the store.\n    // this is the only time we call path.resolve()\n    const cwdPath = pathImpl.resolve(cwd)\n    this.roots = Object.create(null)\n    this.rootPath = this.parseRootPath(cwdPath)\n    this.#resolveCache = new ResolveCache()\n    this.#resolvePosixCache = new ResolveCache()\n    this.#children = new ChildrenCache(childrenCacheSize)\n\n    const split = cwdPath.substring(this.rootPath.length).split(sep)\n    // resolve('/') leaves '', splits to [''], we don't want that.\n    if (split.length === 1 && !split[0]) {\n      split.pop()\n    }\n    /* c8 ignore start */\n    if (nocase === undefined) {\n      throw new TypeError(\n        'must provide nocase setting to PathScurryBase ctor',\n      )\n    }\n    /* c8 ignore stop */\n    this.nocase = nocase\n    this.root = this.newRoot(this.#fs)\n    this.roots[this.rootPath] = this.root\n    let prev: PathBase = this.root\n    let len = split.length - 1\n    const joinSep = pathImpl.sep\n    let abs = this.rootPath\n    let sawFirst = false\n    for (const part of split) {\n      const l = len--\n      prev = prev.child(part, {\n        relative: new Array(l).fill('..').join(joinSep),\n        relativePosix: new Array(l).fill('..').join('/'),\n        fullpath: (abs += (sawFirst ? '' : joinSep) + part),\n      })\n      sawFirst = true\n    }\n    this.cwd = prev\n  }\n\n  /**\n   * Get the depth of a provided path, string, or the cwd\n   */\n  depth(path: Path | string = this.cwd): number {\n    if (typeof path === 'string') {\n      path = this.cwd.resolve(path)\n    }\n    return path.depth()\n  }\n\n  /**\n   * Parse the root portion of a path string\n   *\n   * @internal\n   */\n  abstract parseRootPath(dir: string): string\n  /**\n   * create a new Path to use as root during construction.\n   *\n   * @internal\n   */\n  abstract newRoot(fs: FSValue): PathBase\n  /**\n   * Determine whether a given path string is absolute\n   */\n  abstract isAbsolute(p: string): boolean\n\n  /**\n   * Return the cache of child entries.  Exposed so subclasses can create\n   * child Path objects in a platform-specific way.\n   *\n   * @internal\n   */\n  childrenCache() {\n    return this.#children\n  }\n\n  /**\n   * Resolve one or more path strings to a resolved string\n   *\n   * Same interface as require('path').resolve.\n   *\n   * Much faster than path.resolve() when called multiple times for the same\n   * path, because the resolved Path objects are cached.  Much slower\n   * otherwise.\n   */\n  resolve(...paths: string[]): string {\n    // first figure out the minimum number of paths we have to test\n    // we always start at cwd, but any absolutes will bump the start\n    let r = ''\n    for (let i = paths.length - 1; i >= 0; i--) {\n      const p = paths[i]\n      if (!p || p === '.') continue\n      r = r ? `${p}/${r}` : p\n      if (this.isAbsolute(p)) {\n        break\n      }\n    }\n    const cached = this.#resolveCache.get(r)\n    if (cached !== undefined) {\n      return cached\n    }\n    const result = this.cwd.resolve(r).fullpath()\n    this.#resolveCache.set(r, result)\n    return result\n  }\n\n  /**\n   * Resolve one or more path strings to a resolved string, returning\n   * the posix path.  Identical to .resolve() on posix systems, but on\n   * windows will return a forward-slash separated UNC path.\n   *\n   * Same interface as require('path').resolve.\n   *\n   * Much faster than path.resolve() when called multiple times for the same\n   * path, because the resolved Path objects are cached.  Much slower\n   * otherwise.\n   */\n  resolvePosix(...paths: string[]): string {\n    // first figure out the minimum number of paths we have to test\n    // we always start at cwd, but any absolutes will bump the start\n    let r = ''\n    for (let i = paths.length - 1; i >= 0; i--) {\n      const p = paths[i]\n      if (!p || p === '.') continue\n      r = r ? `${p}/${r}` : p\n      if (this.isAbsolute(p)) {\n        break\n      }\n    }\n    const cached = this.#resolvePosixCache.get(r)\n    if (cached !== undefined) {\n      return cached\n    }\n    const result = this.cwd.resolve(r).fullpathPosix()\n    this.#resolvePosixCache.set(r, result)\n    return result\n  }\n\n  /**\n   * find the relative path from the cwd to the supplied path string or entry\n   */\n  relative(entry: PathBase | string = this.cwd): string {\n    if (typeof entry === 'string') {\n      entry = this.cwd.resolve(entry)\n    }\n    return entry.relative()\n  }\n\n  /**\n   * find the relative path from the cwd to the supplied path string or\n   * entry, using / as the path delimiter, even on Windows.\n   */\n  relativePosix(entry: PathBase | string = this.cwd): string {\n    if (typeof entry === 'string') {\n      entry = this.cwd.resolve(entry)\n    }\n    return entry.relativePosix()\n  }\n\n  /**\n   * Return the basename for the provided string or Path object\n   */\n  basename(entry: PathBase | string = this.cwd): string {\n    if (typeof entry === 'string') {\n      entry = this.cwd.resolve(entry)\n    }\n    return entry.name\n  }\n\n  /**\n   * Return the dirname for the provided string or Path object\n   */\n  dirname(entry: PathBase | string = this.cwd): string {\n    if (typeof entry === 'string') {\n      entry = this.cwd.resolve(entry)\n    }\n    return (entry.parent || entry).fullpath()\n  }\n\n  /**\n   * Return an array of known child entries.\n   *\n   * First argument may be either a string, or a Path object.\n   *\n   * If the Path cannot or does not contain any children, then an empty array\n   * is returned.\n   *\n   * Results are cached, and thus may be out of date if the filesystem is\n   * mutated.\n   *\n   * Unlike `fs.readdir()`, the `withFileTypes` option defaults to `true`. Set\n   * `{ withFileTypes: false }` to return strings.\n   */\n\n  readdir(): Promise<PathBase[]>\n  readdir(opts: { withFileTypes: true }): Promise<PathBase[]>\n  readdir(opts: { withFileTypes: false }): Promise<string[]>\n  readdir(opts: { withFileTypes: boolean }): Promise<PathBase[] | string[]>\n  readdir(entry: PathBase | string): Promise<PathBase[]>\n  readdir(\n    entry: PathBase | string,\n    opts: { withFileTypes: true },\n  ): Promise<PathBase[]>\n  readdir(\n    entry: PathBase | string,\n    opts: { withFileTypes: false },\n  ): Promise<string[]>\n  readdir(\n    entry: PathBase | string,\n    opts: { withFileTypes: boolean },\n  ): Promise<PathBase[] | string[]>\n  async readdir(\n    entry: PathBase | string | { withFileTypes: boolean } = this.cwd,\n    opts: { withFileTypes: boolean } = {\n      withFileTypes: true,\n    },\n  ): Promise<PathBase[] | string[]> {\n    if (typeof entry === 'string') {\n      entry = this.cwd.resolve(entry)\n    } else if (!(entry instanceof PathBase)) {\n      opts = entry\n      entry = this.cwd\n    }\n    const { withFileTypes } = opts\n    if (!entry.canReaddir()) {\n      return []\n    } else {\n      const p = await entry.readdir()\n      return withFileTypes ? p : p.map(e => e.name)\n    }\n  }\n\n  /**\n   * synchronous {@link PathScurryBase.readdir}\n   */\n  readdirSync(): PathBase[]\n  readdirSync(opts: { withFileTypes: true }): PathBase[]\n  readdirSync(opts: { withFileTypes: false }): string[]\n  readdirSync(opts: { withFileTypes: boolean }): PathBase[] | string[]\n  readdirSync(entry: PathBase | string): PathBase[]\n  readdirSync(\n    entry: PathBase | string,\n    opts: { withFileTypes: true },\n  ): PathBase[]\n  readdirSync(\n    entry: PathBase | string,\n    opts: { withFileTypes: false },\n  ): string[]\n  readdirSync(\n    entry: PathBase | string,\n    opts: { withFileTypes: boolean },\n  ): PathBase[] | string[]\n  readdirSync(\n    entry: PathBase | string | { withFileTypes: boolean } = this.cwd,\n    opts: { withFileTypes: boolean } = {\n      withFileTypes: true,\n    },\n  ): PathBase[] | string[] {\n    if (typeof entry === 'string') {\n      entry = this.cwd.resolve(entry)\n    } else if (!(entry instanceof PathBase)) {\n      opts = entry\n      entry = this.cwd\n    }\n    const { withFileTypes = true } = opts\n    if (!entry.canReaddir()) {\n      return []\n    } else if (withFileTypes) {\n      return entry.readdirSync()\n    } else {\n      return entry.readdirSync().map(e => e.name)\n    }\n  }\n\n  /**\n   * Call lstat() on the string or Path object, and update all known\n   * information that can be determined.\n   *\n   * Note that unlike `fs.lstat()`, the returned value does not contain some\n   * information, such as `mode`, `dev`, `nlink`, and `ino`.  If that\n   * information is required, you will need to call `fs.lstat` yourself.\n   *\n   * If the Path refers to a nonexistent file, or if the lstat call fails for\n   * any reason, `undefined` is returned.  Otherwise the updated Path object is\n   * returned.\n   *\n   * Results are cached, and thus may be out of date if the filesystem is\n   * mutated.\n   */\n  async lstat(\n    entry: string | PathBase = this.cwd,\n  ): Promise<PathBase | undefined> {\n    if (typeof entry === 'string') {\n      entry = this.cwd.resolve(entry)\n    }\n    return entry.lstat()\n  }\n\n  /**\n   * synchronous {@link PathScurryBase.lstat}\n   */\n  lstatSync(entry: string | PathBase = this.cwd): PathBase | undefined {\n    if (typeof entry === 'string') {\n      entry = this.cwd.resolve(entry)\n    }\n    return entry.lstatSync()\n  }\n\n  /**\n   * Return the Path object or string path corresponding to the target of a\n   * symbolic link.\n   *\n   * If the path is not a symbolic link, or if the readlink call fails for any\n   * reason, `undefined` is returned.\n   *\n   * Result is cached, and thus may be outdated if the filesystem is mutated.\n   *\n   * `{withFileTypes}` option defaults to `false`.\n   *\n   * On success, returns a Path object if `withFileTypes` option is true,\n   * otherwise a string.\n   */\n  readlink(): Promise<string | undefined>\n  readlink(opt: { withFileTypes: false }): Promise<string | undefined>\n  readlink(opt: { withFileTypes: true }): Promise<PathBase | undefined>\n  readlink(opt: {\n    withFileTypes: boolean\n  }): Promise<PathBase | string | undefined>\n  readlink(\n    entry: string | PathBase,\n    opt?: { withFileTypes: false },\n  ): Promise<string | undefined>\n  readlink(\n    entry: string | PathBase,\n    opt: { withFileTypes: true },\n  ): Promise<PathBase | undefined>\n  readlink(\n    entry: string | PathBase,\n    opt: { withFileTypes: boolean },\n  ): Promise<string | PathBase | undefined>\n  async readlink(\n    entry: string | PathBase | { withFileTypes: boolean } = this.cwd,\n    { withFileTypes }: { withFileTypes: boolean } = {\n      withFileTypes: false,\n    },\n  ): Promise<string | PathBase | undefined> {\n    if (typeof entry === 'string') {\n      entry = this.cwd.resolve(entry)\n    } else if (!(entry instanceof PathBase)) {\n      withFileTypes = entry.withFileTypes\n      entry = this.cwd\n    }\n    const e = await entry.readlink()\n    return withFileTypes ? e : e?.fullpath()\n  }\n\n  /**\n   * synchronous {@link PathScurryBase.readlink}\n   */\n  readlinkSync(): string | undefined\n  readlinkSync(opt: { withFileTypes: false }): string | undefined\n  readlinkSync(opt: { withFileTypes: true }): PathBase | undefined\n  readlinkSync(opt: {\n    withFileTypes: boolean\n  }): PathBase | string | undefined\n  readlinkSync(\n    entry: string | PathBase,\n    opt?: { withFileTypes: false },\n  ): string | undefined\n  readlinkSync(\n    entry: string | PathBase,\n    opt: { withFileTypes: true },\n  ): PathBase | undefined\n  readlinkSync(\n    entry: string | PathBase,\n    opt: { withFileTypes: boolean },\n  ): string | PathBase | undefined\n  readlinkSync(\n    entry: string | PathBase | { withFileTypes: boolean } = this.cwd,\n    { withFileTypes }: { withFileTypes: boolean } = {\n      withFileTypes: false,\n    },\n  ): string | PathBase | undefined {\n    if (typeof entry === 'string') {\n      entry = this.cwd.resolve(entry)\n    } else if (!(entry instanceof PathBase)) {\n      withFileTypes = entry.withFileTypes\n      entry = this.cwd\n    }\n    const e = entry.readlinkSync()\n    return withFileTypes ? e : e?.fullpath()\n  }\n\n  /**\n   * Return the Path object or string path corresponding to path as resolved\n   * by realpath(3).\n   *\n   * If the realpath call fails for any reason, `undefined` is returned.\n   *\n   * Result is cached, and thus may be outdated if the filesystem is mutated.\n   *\n   * `{withFileTypes}` option defaults to `false`.\n   *\n   * On success, returns a Path object if `withFileTypes` option is true,\n   * otherwise a string.\n   */\n  realpath(): Promise<string | undefined>\n  realpath(opt: { withFileTypes: false }): Promise<string | undefined>\n  realpath(opt: { withFileTypes: true }): Promise<PathBase | undefined>\n  realpath(opt: {\n    withFileTypes: boolean\n  }): Promise<PathBase | string | undefined>\n  realpath(\n    entry: string | PathBase,\n    opt?: { withFileTypes: false },\n  ): Promise<string | undefined>\n  realpath(\n    entry: string | PathBase,\n    opt: { withFileTypes: true },\n  ): Promise<PathBase | undefined>\n  realpath(\n    entry: string | PathBase,\n    opt: { withFileTypes: boolean },\n  ): Promise<string | PathBase | undefined>\n  async realpath(\n    entry: string | PathBase | { withFileTypes: boolean } = this.cwd,\n    { withFileTypes }: { withFileTypes: boolean } = {\n      withFileTypes: false,\n    },\n  ): Promise<string | PathBase | undefined> {\n    if (typeof entry === 'string') {\n      entry = this.cwd.resolve(entry)\n    } else if (!(entry instanceof PathBase)) {\n      withFileTypes = entry.withFileTypes\n      entry = this.cwd\n    }\n    const e = await entry.realpath()\n    return withFileTypes ? e : e?.fullpath()\n  }\n\n  realpathSync(): string | undefined\n  realpathSync(opt: { withFileTypes: false }): string | undefined\n  realpathSync(opt: { withFileTypes: true }): PathBase | undefined\n  realpathSync(opt: {\n    withFileTypes: boolean\n  }): PathBase | string | undefined\n  realpathSync(\n    entry: string | PathBase,\n    opt?: { withFileTypes: false },\n  ): string | undefined\n  realpathSync(\n    entry: string | PathBase,\n    opt: { withFileTypes: true },\n  ): PathBase | undefined\n  realpathSync(\n    entry: string | PathBase,\n    opt: { withFileTypes: boolean },\n  ): string | PathBase | undefined\n  realpathSync(\n    entry: string | PathBase | { withFileTypes: boolean } = this.cwd,\n    { withFileTypes }: { withFileTypes: boolean } = {\n      withFileTypes: false,\n    },\n  ): string | PathBase | undefined {\n    if (typeof entry === 'string') {\n      entry = this.cwd.resolve(entry)\n    } else if (!(entry instanceof PathBase)) {\n      withFileTypes = entry.withFileTypes\n      entry = this.cwd\n    }\n    const e = entry.realpathSync()\n    return withFileTypes ? e : e?.fullpath()\n  }\n\n  /**\n   * Asynchronously walk the directory tree, returning an array of\n   * all path strings or Path objects found.\n   *\n   * Note that this will be extremely memory-hungry on large filesystems.\n   * In such cases, it may be better to use the stream or async iterator\n   * walk implementation.\n   */\n  walk(): Promise<PathBase[]>\n  walk(\n    opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset,\n  ): Promise<PathBase[]>\n  walk(opts: WalkOptionsWithFileTypesFalse): Promise<string[]>\n  walk(opts: WalkOptions): Promise<string[] | PathBase[]>\n  walk(entry: string | PathBase): Promise<PathBase[]>\n  walk(\n    entry: string | PathBase,\n    opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset,\n  ): Promise<PathBase[]>\n  walk(\n    entry: string | PathBase,\n    opts: WalkOptionsWithFileTypesFalse,\n  ): Promise<string[]>\n  walk(\n    entry: string | PathBase,\n    opts: WalkOptions,\n  ): Promise<PathBase[] | string[]>\n  async walk(\n    entry: string | PathBase | WalkOptions = this.cwd,\n    opts: WalkOptions = {},\n  ): Promise<PathBase[] | string[]> {\n    if (typeof entry === 'string') {\n      entry = this.cwd.resolve(entry)\n    } else if (!(entry instanceof PathBase)) {\n      opts = entry\n      entry = this.cwd\n    }\n    const {\n      withFileTypes = true,\n      follow = false,\n      filter,\n      walkFilter,\n    } = opts\n    const results: (string | PathBase)[] = []\n    if (!filter || filter(entry)) {\n      results.push(withFileTypes ? entry : entry.fullpath())\n    }\n    const dirs = new Set<PathBase>()\n    const walk = (\n      dir: PathBase,\n      cb: (er?: NodeJS.ErrnoException) => void,\n    ) => {\n      dirs.add(dir)\n      dir.readdirCB((er, entries) => {\n        /* c8 ignore start */\n        if (er) {\n          return cb(er)\n        }\n        /* c8 ignore stop */\n        let len = entries.length\n        if (!len) return cb()\n        const next = () => {\n          if (--len === 0) {\n            cb()\n          }\n        }\n        for (const e of entries) {\n          if (!filter || filter(e)) {\n            results.push(withFileTypes ? e : e.fullpath())\n          }\n          if (follow && e.isSymbolicLink()) {\n            e.realpath()\n              .then(r => (r?.isUnknown() ? r.lstat() : r))\n              .then(r =>\n                r?.shouldWalk(dirs, walkFilter) ? walk(r, next) : next(),\n              )\n          } else {\n            if (e.shouldWalk(dirs, walkFilter)) {\n              walk(e, next)\n            } else {\n              next()\n            }\n          }\n        }\n      }, true) // zalgooooooo\n    }\n\n    const start = entry\n    return new Promise<PathBase[] | string[]>((res, rej) => {\n      walk(start, er => {\n        /* c8 ignore start */\n        if (er) return rej(er)\n        /* c8 ignore stop */\n        res(results as PathBase[] | string[])\n      })\n    })\n  }\n\n  /**\n   * Synchronously walk the directory tree, returning an array of\n   * all path strings or Path objects found.\n   *\n   * Note that this will be extremely memory-hungry on large filesystems.\n   * In such cases, it may be better to use the stream or async iterator\n   * walk implementation.\n   */\n  walkSync(): PathBase[]\n  walkSync(\n    opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset,\n  ): PathBase[]\n  walkSync(opts: WalkOptionsWithFileTypesFalse): string[]\n  walkSync(opts: WalkOptions): string[] | PathBase[]\n  walkSync(entry: string | PathBase): PathBase[]\n  walkSync(\n    entry: string | PathBase,\n    opts: WalkOptionsWithFileTypesUnset | WalkOptionsWithFileTypesTrue,\n  ): PathBase[]\n  walkSync(\n    entry: string | PathBase,\n    opts: WalkOptionsWithFileTypesFalse,\n  ): string[]\n  walkSync(\n    entry: string | PathBase,\n    opts: WalkOptions,\n  ): PathBase[] | string[]\n  walkSync(\n    entry: string | PathBase | WalkOptions = this.cwd,\n    opts: WalkOptions = {},\n  ): PathBase[] | string[] {\n    if (typeof entry === 'string') {\n      entry = this.cwd.resolve(entry)\n    } else if (!(entry instanceof PathBase)) {\n      opts = entry\n      entry = this.cwd\n    }\n    const {\n      withFileTypes = true,\n      follow = false,\n      filter,\n      walkFilter,\n    } = opts\n    const results: (string | PathBase)[] = []\n    if (!filter || filter(entry)) {\n      results.push(withFileTypes ? entry : entry.fullpath())\n    }\n    const dirs = new Set<PathBase>([entry])\n    for (const dir of dirs) {\n      const entries = dir.readdirSync()\n      for (const e of entries) {\n        if (!filter || filter(e)) {\n          results.push(withFileTypes ? e : e.fullpath())\n        }\n        let r: PathBase | undefined = e\n        if (e.isSymbolicLink()) {\n          if (!(follow && (r = e.realpathSync()))) continue\n          if (r.isUnknown()) r.lstatSync()\n        }\n        if (r.shouldWalk(dirs, walkFilter)) {\n          dirs.add(r)\n        }\n      }\n    }\n    return results as string[] | PathBase[]\n  }\n\n  /**\n   * Support for `for await`\n   *\n   * Alias for {@link PathScurryBase.iterate}\n   *\n   * Note: As of Node 19, this is very slow, compared to other methods of\n   * walking.  Consider using {@link PathScurryBase.stream} if memory overhead\n   * and backpressure are concerns, or {@link PathScurryBase.walk} if not.\n   */\n  [Symbol.asyncIterator]() {\n    return this.iterate()\n  }\n\n  /**\n   * Async generator form of {@link PathScurryBase.walk}\n   *\n   * Note: As of Node 19, this is very slow, compared to other methods of\n   * walking, especially if most/all of the directory tree has been previously\n   * walked.  Consider using {@link PathScurryBase.stream} if memory overhead\n   * and backpressure are concerns, or {@link PathScurryBase.walk} if not.\n   */\n  iterate(): AsyncGenerator<PathBase, void, void>\n  iterate(\n    opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset,\n  ): AsyncGenerator<PathBase, void, void>\n  iterate(\n    opts: WalkOptionsWithFileTypesFalse,\n  ): AsyncGenerator<string, void, void>\n  iterate(opts: WalkOptions): AsyncGenerator<string | PathBase, void, void>\n  iterate(entry: string | PathBase): AsyncGenerator<PathBase, void, void>\n  iterate(\n    entry: string | PathBase,\n    opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset,\n  ): AsyncGenerator<PathBase, void, void>\n  iterate(\n    entry: string | PathBase,\n    opts: WalkOptionsWithFileTypesFalse,\n  ): AsyncGenerator<string, void, void>\n  iterate(\n    entry: string | PathBase,\n    opts: WalkOptions,\n  ): AsyncGenerator<PathBase | string, void, void>\n  iterate(\n    entry: string | PathBase | WalkOptions = this.cwd,\n    options: WalkOptions = {},\n  ): AsyncGenerator<PathBase | string, void, void> {\n    // iterating async over the stream is significantly more performant,\n    // especially in the warm-cache scenario, because it buffers up directory\n    // entries in the background instead of waiting for a yield for each one.\n    if (typeof entry === 'string') {\n      entry = this.cwd.resolve(entry)\n    } else if (!(entry instanceof PathBase)) {\n      options = entry\n      entry = this.cwd\n    }\n    return this.stream(entry, options)[Symbol.asyncIterator]()\n  }\n\n  /**\n   * Iterating over a PathScurry performs a synchronous walk.\n   *\n   * Alias for {@link PathScurryBase.iterateSync}\n   */\n  [Symbol.iterator]() {\n    return this.iterateSync()\n  }\n\n  iterateSync(): Generator<PathBase, void, void>\n  iterateSync(\n    opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset,\n  ): Generator<PathBase, void, void>\n  iterateSync(\n    opts: WalkOptionsWithFileTypesFalse,\n  ): Generator<string, void, void>\n  iterateSync(opts: WalkOptions): Generator<string | PathBase, void, void>\n  iterateSync(entry: string | PathBase): Generator<PathBase, void, void>\n  iterateSync(\n    entry: string | PathBase,\n    opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset,\n  ): Generator<PathBase, void, void>\n  iterateSync(\n    entry: string | PathBase,\n    opts: WalkOptionsWithFileTypesFalse,\n  ): Generator<string, void, void>\n  iterateSync(\n    entry: string | PathBase,\n    opts: WalkOptions,\n  ): Generator<PathBase | string, void, void>\n  *iterateSync(\n    entry: string | PathBase | WalkOptions = this.cwd,\n    opts: WalkOptions = {},\n  ): Generator<PathBase | string, void, void> {\n    if (typeof entry === 'string') {\n      entry = this.cwd.resolve(entry)\n    } else if (!(entry instanceof PathBase)) {\n      opts = entry\n      entry = this.cwd\n    }\n    const {\n      withFileTypes = true,\n      follow = false,\n      filter,\n      walkFilter,\n    } = opts\n    if (!filter || filter(entry)) {\n      yield withFileTypes ? entry : entry.fullpath()\n    }\n    const dirs = new Set<PathBase>([entry])\n    for (const dir of dirs) {\n      const entries = dir.readdirSync()\n      for (const e of entries) {\n        if (!filter || filter(e)) {\n          yield withFileTypes ? e : e.fullpath()\n        }\n        let r: PathBase | undefined = e\n        if (e.isSymbolicLink()) {\n          if (!(follow && (r = e.realpathSync()))) continue\n          if (r.isUnknown()) r.lstatSync()\n        }\n        if (r.shouldWalk(dirs, walkFilter)) {\n          dirs.add(r)\n        }\n      }\n    }\n  }\n\n  /**\n   * Stream form of {@link PathScurryBase.walk}\n   *\n   * Returns a Minipass stream that emits {@link PathBase} objects by default,\n   * or strings if `{ withFileTypes: false }` is set in the options.\n   */\n  stream(): Minipass<PathBase>\n  stream(\n    opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset,\n  ): Minipass<PathBase>\n  stream(opts: WalkOptionsWithFileTypesFalse): Minipass<string>\n  stream(opts: WalkOptions): Minipass<string | PathBase>\n  stream(entry: string | PathBase): Minipass<PathBase>\n  stream(\n    entry: string | PathBase,\n    opts: WalkOptionsWithFileTypesUnset | WalkOptionsWithFileTypesTrue,\n  ): Minipass<PathBase>\n  stream(\n    entry: string | PathBase,\n    opts: WalkOptionsWithFileTypesFalse,\n  ): Minipass<string>\n  stream(\n    entry: string | PathBase,\n    opts: WalkOptions,\n  ): Minipass<string> | Minipass<PathBase>\n  stream(\n    entry: string | PathBase | WalkOptions = this.cwd,\n    opts: WalkOptions = {},\n  ): Minipass<string> | Minipass<PathBase> {\n    if (typeof entry === 'string') {\n      entry = this.cwd.resolve(entry)\n    } else if (!(entry instanceof PathBase)) {\n      opts = entry\n      entry = this.cwd\n    }\n    const {\n      withFileTypes = true,\n      follow = false,\n      filter,\n      walkFilter,\n    } = opts\n    const results = new Minipass<string | PathBase>({ objectMode: true })\n    if (!filter || filter(entry)) {\n      results.write(withFileTypes ? entry : entry.fullpath())\n    }\n    const dirs = new Set<PathBase>()\n    const queue: PathBase[] = [entry]\n    let processing = 0\n    const process = () => {\n      let paused = false\n      while (!paused) {\n        const dir = queue.shift()\n        if (!dir) {\n          if (processing === 0) results.end()\n          return\n        }\n\n        processing++\n        dirs.add(dir)\n\n        const onReaddir = (\n          er: null | NodeJS.ErrnoException,\n          entries: PathBase[],\n          didRealpaths: boolean = false,\n        ) => {\n          /* c8 ignore start */\n          if (er) return results.emit('error', er)\n          /* c8 ignore stop */\n          if (follow && !didRealpaths) {\n            const promises: Promise<PathBase | undefined>[] = []\n            for (const e of entries) {\n              if (e.isSymbolicLink()) {\n                promises.push(\n                  e\n                    .realpath()\n                    .then((r: PathBase | undefined) =>\n                      r?.isUnknown() ? r.lstat() : r,\n                    ),\n                )\n              }\n            }\n            if (promises.length) {\n              Promise.all(promises).then(() =>\n                onReaddir(null, entries, true),\n              )\n              return\n            }\n          }\n\n          for (const e of entries) {\n            if (e && (!filter || filter(e))) {\n              if (!results.write(withFileTypes ? e : e.fullpath())) {\n                paused = true\n              }\n            }\n          }\n\n          processing--\n          for (const e of entries) {\n            const r = e.realpathCached() || e\n            if (r.shouldWalk(dirs, walkFilter)) {\n              queue.push(r)\n            }\n          }\n          if (paused && !results.flowing) {\n            results.once('drain', process)\n          } else if (!sync) {\n            process()\n          }\n        }\n\n        // zalgo containment\n        let sync = true\n        dir.readdirCB(onReaddir, true)\n        sync = false\n      }\n    }\n    process()\n    return results as Minipass<string> | Minipass<PathBase>\n  }\n\n  /**\n   * Synchronous form of {@link PathScurryBase.stream}\n   *\n   * Returns a Minipass stream that emits {@link PathBase} objects by default,\n   * or strings if `{ withFileTypes: false }` is set in the options.\n   *\n   * Will complete the walk in a single tick if the stream is consumed fully.\n   * Otherwise, will pause as needed for stream backpressure.\n   */\n  streamSync(): Minipass<PathBase>\n  streamSync(\n    opts: WalkOptionsWithFileTypesTrue | WalkOptionsWithFileTypesUnset,\n  ): Minipass<PathBase>\n  streamSync(opts: WalkOptionsWithFileTypesFalse): Minipass<string>\n  streamSync(opts: WalkOptions): Minipass<string | PathBase>\n  streamSync(entry: string | PathBase): Minipass<PathBase>\n  streamSync(\n    entry: string | PathBase,\n    opts: WalkOptionsWithFileTypesUnset | WalkOptionsWithFileTypesTrue,\n  ): Minipass<PathBase>\n  streamSync(\n    entry: string | PathBase,\n    opts: WalkOptionsWithFileTypesFalse,\n  ): Minipass<string>\n  streamSync(\n    entry: string | PathBase,\n    opts: WalkOptions,\n  ): Minipass<string> | Minipass<PathBase>\n  streamSync(\n    entry: string | PathBase | WalkOptions = this.cwd,\n    opts: WalkOptions = {},\n  ): Minipass<string> | Minipass<PathBase> {\n    if (typeof entry === 'string') {\n      entry = this.cwd.resolve(entry)\n    } else if (!(entry instanceof PathBase)) {\n      opts = entry\n      entry = this.cwd\n    }\n    const {\n      withFileTypes = true,\n      follow = false,\n      filter,\n      walkFilter,\n    } = opts\n    const results = new Minipass<string | PathBase>({ objectMode: true })\n    const dirs = new Set<PathBase>()\n    if (!filter || filter(entry)) {\n      results.write(withFileTypes ? entry : entry.fullpath())\n    }\n    const queue: PathBase[] = [entry]\n    let processing = 0\n    const process = () => {\n      let paused = false\n      while (!paused) {\n        const dir = queue.shift()\n        if (!dir) {\n          if (processing === 0) results.end()\n          return\n        }\n        processing++\n        dirs.add(dir)\n\n        const entries = dir.readdirSync()\n        for (const e of entries) {\n          if (!filter || filter(e)) {\n            if (!results.write(withFileTypes ? e : e.fullpath())) {\n              paused = true\n            }\n          }\n        }\n        processing--\n        for (const e of entries) {\n          let r: PathBase | undefined = e\n          if (e.isSymbolicLink()) {\n            if (!(follow && (r = e.realpathSync()))) continue\n            if (r.isUnknown()) r.lstatSync()\n          }\n          if (r.shouldWalk(dirs, walkFilter)) {\n            queue.push(r)\n          }\n        }\n      }\n      if (paused && !results.flowing) results.once('drain', process)\n    }\n    process()\n    return results as Minipass<string> | Minipass<PathBase>\n  }\n\n  chdir(path: string | Path = this.cwd) {\n    const oldCwd = this.cwd\n    this.cwd = typeof path === 'string' ? this.cwd.resolve(path) : path\n    this.cwd[setAsCwd](oldCwd)\n  }\n}\n\n/**\n * Options provided to all walk methods.\n */\nexport interface WalkOptions {\n  /**\n   * Return results as {@link PathBase} objects rather than strings.\n   * When set to false, results are fully resolved paths, as returned by\n   * {@link PathBase.fullpath}.\n   * @default true\n   */\n  withFileTypes?: boolean\n\n  /**\n   *  Attempt to read directory entries from symbolic links. Otherwise, only\n   *  actual directories are traversed. Regardless of this setting, a given\n   *  target path will only ever be walked once, meaning that a symbolic link\n   *  to a previously traversed directory will never be followed.\n   *\n   *  Setting this imposes a slight performance penalty, because `readlink`\n   *  must be called on all symbolic links encountered, in order to avoid\n   *  infinite cycles.\n   * @default false\n   */\n  follow?: boolean\n\n  /**\n   * Only return entries where the provided function returns true.\n   *\n   * This will not prevent directories from being traversed, even if they do\n   * not pass the filter, though it will prevent directories themselves from\n   * being included in the result set.  See {@link walkFilter}\n   *\n   * Asynchronous functions are not supported here.\n   *\n   * By default, if no filter is provided, all entries and traversed\n   * directories are included.\n   */\n  filter?: (entry: PathBase) => boolean\n\n  /**\n   * Only traverse directories (and in the case of {@link follow} being set to\n   * true, symbolic links to directories) if the provided function returns\n   * true.\n   *\n   * This will not prevent directories from being included in the result set,\n   * even if they do not pass the supplied filter function.  See {@link filter}\n   * to do that.\n   *\n   * Asynchronous functions are not supported here.\n   */\n  walkFilter?: (entry: PathBase) => boolean\n}\n\nexport type WalkOptionsWithFileTypesUnset = WalkOptions & {\n  withFileTypes?: undefined\n}\nexport type WalkOptionsWithFileTypesTrue = WalkOptions & {\n  withFileTypes: true\n}\nexport type WalkOptionsWithFileTypesFalse = WalkOptions & {\n  withFileTypes: false\n}\n\n/**\n * Windows implementation of {@link PathScurryBase}\n *\n * Defaults to case insensitve, uses `'\\\\'` to generate path strings.  Uses\n * {@link PathWin32} for Path objects.\n */\nexport class PathScurryWin32 extends PathScurryBase {\n  /**\n   * separator for generating path strings\n   */\n  sep: '\\\\' = '\\\\'\n\n  constructor(\n    cwd: URL | string = process.cwd(),\n    opts: PathScurryOpts = {},\n  ) {\n    const { nocase = true } = opts\n    // use the same root as resolve() does for these paths\n    if (typeof cwd === 'string' && !cwd.startsWith('file://')) {\n      cwd = cwd.replace(longDrivePrefix, '').replace(longUncPrefix, '\\\\')\n    }\n    super(cwd, win32, '\\\\', { ...opts, nocase })\n    this.nocase = nocase\n    for (let p: PathBase | undefined = this.cwd; p; p = p.parent) {\n      p.nocase = this.nocase\n    }\n  }\n\n  /**\n   * @internal\n   */\n  parseRootPath(dir: string): string {\n    // if the path starts with a single separator, it's not a UNC, and we'll\n    // just get separator as the root, and driveFromUNC will return \\\n    // In that case, mount \\ on the root from the cwd.\n    return win32.parse(dir).root.toUpperCase()\n  }\n\n  /**\n   * @internal\n   */\n  newRoot(fs: FSValue) {\n    return new PathWin32(\n      this.rootPath,\n      IFDIR,\n      undefined,\n      this.roots,\n      this.nocase,\n      this.childrenCache(),\n      { fs },\n    )\n  }\n\n  /**\n   * Return true if the provided path string is an absolute path\n   */\n  isAbsolute(p: string): boolean {\n    return (\n      p.startsWith('/') || p.startsWith('\\\\') || /^[a-z]:(\\/|\\\\)/i.test(p)\n    )\n  }\n}\n\n/**\n * {@link PathScurryBase} implementation for all posix systems other than Darwin.\n *\n * Defaults to case-sensitive matching, uses `'/'` to generate path strings.\n *\n * Uses {@link PathPosix} for Path objects.\n */\nexport class PathScurryPosix extends PathScurryBase {\n  /**\n   * separator for generating path strings\n   */\n  sep: '/' = '/'\n  constructor(\n    cwd: URL | string = process.cwd(),\n    opts: PathScurryOpts = {},\n  ) {\n    const { nocase = false } = opts\n    super(cwd, posix, '/', { ...opts, nocase })\n    this.nocase = nocase\n  }\n\n  /**\n   * @internal\n   */\n  parseRootPath(_dir: string): string {\n    return '/'\n  }\n\n  /**\n   * @internal\n   */\n  newRoot(fs: FSValue) {\n    return new PathPosix(\n      this.rootPath,\n      IFDIR,\n      undefined,\n      this.roots,\n      this.nocase,\n      this.childrenCache(),\n      { fs },\n    )\n  }\n\n  /**\n   * Return true if the provided path string is an absolute path\n   */\n  isAbsolute(p: string): boolean {\n    return p.startsWith('/')\n  }\n}\n\n/**\n * {@link PathScurryBase} implementation for Darwin (macOS) systems.\n *\n * Defaults to case-insensitive matching, uses `'/'` for generating path\n * strings.\n *\n * Uses {@link PathPosix} for Path objects.\n */\nexport class PathScurryDarwin extends PathScurryPosix {\n  constructor(\n    cwd: URL | string = process.cwd(),\n    opts: PathScurryOpts = {},\n  ) {\n    const { nocase = true } = opts\n    super(cwd, { ...opts, nocase })\n  }\n}\n\n/**\n * Default {@link PathBase} implementation for the current platform.\n *\n * {@link PathWin32} on Windows systems, {@link PathPosix} on all others.\n */\nexport const Path = process.platform === 'win32' ? PathWin32 : PathPosix\nexport type Path = PathBase | InstanceType<typeof Path>\n\n/**\n * Default {@link PathScurryBase} implementation for the current platform.\n *\n * {@link PathScurryWin32} on Windows systems, {@link PathScurryDarwin} on\n * Darwin (macOS) systems, {@link PathScurryPosix} on all others.\n */\nexport const PathScurry:\n  | typeof PathScurryWin32\n  | typeof PathScurryDarwin\n  | typeof PathScurryPosix =\n  process.platform === 'win32' ? PathScurryWin32\n  : process.platform === 'darwin' ? PathScurryDarwin\n  : PathScurryPosix\nexport type PathScurry = PathScurryBase | InstanceType<typeof PathScurry>\n", "const proc =\n  typeof process === 'object' && process\n    ? process\n    : {\n        stdout: null,\n        stderr: null,\n      }\nimport { EventEmitter } from 'node:events'\nimport Stream from 'node:stream'\nimport { StringDecoder } from 'node:string_decoder'\n\n/**\n * Same as StringDecoder, but exposing the `lastNeed` flag on the type\n */\ntype SD = StringDecoder & { lastNeed: boolean }\n\nexport type { SD, Pipe, PipeProxyErrors }\n\n/**\n * Return true if the argument is a Minipass stream, Node stream, or something\n * else that Minipass can interact with.\n */\nexport const isStream = (\n  s: any\n): s is Minipass.Readable | Minipass.Writable =>\n  !!s &&\n  typeof s === 'object' &&\n  (s instanceof Minipass ||\n    s instanceof Stream ||\n    isReadable(s) ||\n    isWritable(s))\n\n/**\n * Return true if the argument is a valid {@link Minipass.Readable}\n */\nexport const isReadable = (s: any): s is Minipass.Readable =>\n  !!s &&\n  typeof s === 'object' &&\n  s instanceof EventEmitter &&\n  typeof (s as Minipass.Readable).pipe === 'function' &&\n  // node core Writable streams have a pipe() method, but it throws\n  (s as Minipass.Readable).pipe !== Stream.Writable.prototype.pipe\n\n/**\n * Return true if the argument is a valid {@link Minipass.Writable}\n */\nexport const isWritable = (s: any): s is Minipass.Readable =>\n  !!s &&\n  typeof s === 'object' &&\n  s instanceof EventEmitter &&\n  typeof (s as Minipass.Writable).write === 'function' &&\n  typeof (s as Minipass.Writable).end === 'function'\n\nconst EOF = Symbol('EOF')\nconst MAYBE_EMIT_END = Symbol('maybeEmitEnd')\nconst EMITTED_END = Symbol('emittedEnd')\nconst EMITTING_END = Symbol('emittingEnd')\nconst EMITTED_ERROR = Symbol('emittedError')\nconst CLOSED = Symbol('closed')\nconst READ = Symbol('read')\nconst FLUSH = Symbol('flush')\nconst FLUSHCHUNK = Symbol('flushChunk')\nconst ENCODING = Symbol('encoding')\nconst DECODER = Symbol('decoder')\nconst FLOWING = Symbol('flowing')\nconst PAUSED = Symbol('paused')\nconst RESUME = Symbol('resume')\nconst BUFFER = Symbol('buffer')\nconst PIPES = Symbol('pipes')\nconst BUFFERLENGTH = Symbol('bufferLength')\nconst BUFFERPUSH = Symbol('bufferPush')\nconst BUFFERSHIFT = Symbol('bufferShift')\nconst OBJECTMODE = Symbol('objectMode')\n// internal event when stream is destroyed\nconst DESTROYED = Symbol('destroyed')\n// internal event when stream has an error\nconst ERROR = Symbol('error')\nconst EMITDATA = Symbol('emitData')\nconst EMITEND = Symbol('emitEnd')\nconst EMITEND2 = Symbol('emitEnd2')\nconst ASYNC = Symbol('async')\nconst ABORT = Symbol('abort')\nconst ABORTED = Symbol('aborted')\nconst SIGNAL = Symbol('signal')\nconst DATALISTENERS = Symbol('dataListeners')\nconst DISCARDED = Symbol('discarded')\n\nconst defer = (fn: (...a: any[]) => any) => Promise.resolve().then(fn)\nconst nodefer = (fn: (...a: any[]) => any) => fn()\n\n// events that mean 'the stream is over'\n// these are treated specially, and re-emitted\n// if they are listened for after emitting.\ntype EndishEvent = 'end' | 'finish' | 'prefinish'\nconst isEndish = (ev: any): ev is EndishEvent =>\n  ev === 'end' || ev === 'finish' || ev === 'prefinish'\n\nconst isArrayBufferLike = (b: any): b is ArrayBufferLike =>\n  b instanceof ArrayBuffer ||\n  (!!b &&\n    typeof b === 'object' &&\n    b.constructor &&\n    b.constructor.name === 'ArrayBuffer' &&\n    b.byteLength >= 0)\n\nconst isArrayBufferView = (b: any): b is ArrayBufferView =>\n  !Buffer.isBuffer(b) && ArrayBuffer.isView(b)\n\n/**\n * Options that may be passed to stream.pipe()\n */\nexport interface PipeOptions {\n  /**\n   * end the destination stream when the source stream ends\n   */\n  end?: boolean\n  /**\n   * proxy errors from the source stream to the destination stream\n   */\n  proxyErrors?: boolean\n}\n\n/**\n * Internal class representing a pipe to a destination stream.\n *\n * @internal\n */\nclass Pipe<T extends unknown> {\n  src: Minipass<T>\n  dest: Minipass<any, T>\n  opts: PipeOptions\n  ondrain: () => any\n  constructor(\n    src: Minipass<T>,\n    dest: Minipass.Writable,\n    opts: PipeOptions\n  ) {\n    this.src = src\n    this.dest = dest as Minipass<any, T>\n    this.opts = opts\n    this.ondrain = () => src[RESUME]()\n    this.dest.on('drain', this.ondrain)\n  }\n  unpipe() {\n    this.dest.removeListener('drain', this.ondrain)\n  }\n  // only here for the prototype\n  /* c8 ignore start */\n  proxyErrors(_er: any) {}\n  /* c8 ignore stop */\n  end() {\n    this.unpipe()\n    if (this.opts.end) this.dest.end()\n  }\n}\n\n/**\n * Internal class representing a pipe to a destination stream where\n * errors are proxied.\n *\n * @internal\n */\nclass PipeProxyErrors<T> extends Pipe<T> {\n  unpipe() {\n    this.src.removeListener('error', this.proxyErrors)\n    super.unpipe()\n  }\n  constructor(\n    src: Minipass<T>,\n    dest: Minipass.Writable,\n    opts: PipeOptions\n  ) {\n    super(src, dest, opts)\n    this.proxyErrors = (er: Error) => this.dest.emit('error', er)\n    src.on('error', this.proxyErrors)\n  }\n}\n\nexport namespace Minipass {\n  /**\n   * Encoding used to create a stream that outputs strings rather than\n   * Buffer objects.\n   */\n  export type Encoding = BufferEncoding | 'buffer' | null\n\n  /**\n   * Any stream that Minipass can pipe into\n   */\n  export type Writable =\n    | Minipass<any, any, any>\n    | NodeJS.WriteStream\n    | (NodeJS.WriteStream & { fd: number })\n    | (EventEmitter & {\n        end(): any\n        write(chunk: any, ...args: any[]): any\n      })\n\n  /**\n   * Any stream that can be read from\n   */\n  export type Readable =\n    | Minipass<any, any, any>\n    | NodeJS.ReadStream\n    | (NodeJS.ReadStream & { fd: number })\n    | (EventEmitter & {\n        pause(): any\n        resume(): any\n        pipe(...destArgs: any[]): any\n      })\n\n  /**\n   * Utility type that can be iterated sync or async\n   */\n  export type DualIterable<T> = Iterable<T> & AsyncIterable<T>\n\n  type EventArguments = Record<string | symbol, unknown[]>\n\n  /**\n   * The listing of events that a Minipass class can emit.\n   * Extend this when extending the Minipass class, and pass as\n   * the third template argument.  The key is the name of the event,\n   * and the value is the argument list.\n   *\n   * Any undeclared events will still be allowed, but the handler will get\n   * arguments as `unknown[]`.\n   */\n  export interface Events<RType extends any = Buffer>\n    extends EventArguments {\n    readable: []\n    data: [chunk: RType]\n    error: [er: unknown]\n    abort: [reason: unknown]\n    drain: []\n    resume: []\n    end: []\n    finish: []\n    prefinish: []\n    close: []\n    [DESTROYED]: [er?: unknown]\n    [ERROR]: [er: unknown]\n  }\n\n  /**\n   * String or buffer-like data that can be joined and sliced\n   */\n  export type ContiguousData =\n    | Buffer\n    | ArrayBufferLike\n    | ArrayBufferView\n    | string\n  export type BufferOrString = Buffer | string\n\n  /**\n   * Options passed to the Minipass constructor.\n   */\n  export type SharedOptions = {\n    /**\n     * Defer all data emission and other events until the end of the\n     * current tick, similar to Node core streams\n     */\n    async?: boolean\n    /**\n     * A signal which will abort the stream\n     */\n    signal?: AbortSignal\n    /**\n     * Output string encoding. Set to `null` or `'buffer'` (or omit) to\n     * emit Buffer objects rather than strings.\n     *\n     * Conflicts with `objectMode`\n     */\n    encoding?: BufferEncoding | null | 'buffer'\n    /**\n     * Output data exactly as it was written, supporting non-buffer/string\n     * data (such as arbitrary objects, falsey values, etc.)\n     *\n     * Conflicts with `encoding`\n     */\n    objectMode?: boolean\n  }\n\n  /**\n   * Options for a string encoded output\n   */\n  export type EncodingOptions = SharedOptions & {\n    encoding: BufferEncoding\n    objectMode?: false\n  }\n\n  /**\n   * Options for contiguous data buffer output\n   */\n  export type BufferOptions = SharedOptions & {\n    encoding?: null | 'buffer'\n    objectMode?: false\n  }\n\n  /**\n   * Options for objectMode arbitrary output\n   */\n  export type ObjectModeOptions = SharedOptions & {\n    objectMode: true\n    encoding?: null\n  }\n\n  /**\n   * Utility type to determine allowed options based on read type\n   */\n  export type Options<T> =\n    | ObjectModeOptions\n    | (T extends string\n        ? EncodingOptions\n        : T extends Buffer\n        ? BufferOptions\n        : SharedOptions)\n}\n\nconst isObjectModeOptions = (\n  o: Minipass.SharedOptions\n): o is Minipass.ObjectModeOptions => !!o.objectMode\n\nconst isEncodingOptions = (\n  o: Minipass.SharedOptions\n): o is Minipass.EncodingOptions =>\n  !o.objectMode && !!o.encoding && o.encoding !== 'buffer'\n\n/**\n * Main export, the Minipass class\n *\n * `RType` is the type of data emitted, defaults to Buffer\n *\n * `WType` is the type of data to be written, if RType is buffer or string,\n * then any {@link Minipass.ContiguousData} is allowed.\n *\n * `Events` is the set of event handler signatures that this object\n * will emit, see {@link Minipass.Events}\n */\nexport class Minipass<\n    RType extends unknown = Buffer,\n    WType extends unknown = RType extends Minipass.BufferOrString\n      ? Minipass.ContiguousData\n      : RType,\n    Events extends Minipass.Events<RType> = Minipass.Events<RType>\n  >\n  extends EventEmitter\n  implements Minipass.DualIterable<RType>\n{\n  [FLOWING]: boolean = false;\n  [PAUSED]: boolean = false;\n  [PIPES]: Pipe<RType>[] = [];\n  [BUFFER]: RType[] = [];\n  [OBJECTMODE]: boolean;\n  [ENCODING]: BufferEncoding | null;\n  [ASYNC]: boolean;\n  [DECODER]: SD | null;\n  [EOF]: boolean = false;\n  [EMITTED_END]: boolean = false;\n  [EMITTING_END]: boolean = false;\n  [CLOSED]: boolean = false;\n  [EMITTED_ERROR]: unknown = null;\n  [BUFFERLENGTH]: number = 0;\n  [DESTROYED]: boolean = false;\n  [SIGNAL]?: AbortSignal;\n  [ABORTED]: boolean = false;\n  [DATALISTENERS]: number = 0;\n  [DISCARDED]: boolean = false\n\n  /**\n   * true if the stream can be written\n   */\n  writable: boolean = true\n  /**\n   * true if the stream can be read\n   */\n  readable: boolean = true\n\n  /**\n   * If `RType` is Buffer, then options do not need to be provided.\n   * Otherwise, an options object must be provided to specify either\n   * {@link Minipass.SharedOptions.objectMode} or\n   * {@link Minipass.SharedOptions.encoding}, as appropriate.\n   */\n  constructor(\n    ...args:\n      | [Minipass.ObjectModeOptions]\n      | (RType extends Buffer\n          ? [] | [Minipass.Options<RType>]\n          : [Minipass.Options<RType>])\n  ) {\n    const options: Minipass.Options<RType> = (args[0] ||\n      {}) as Minipass.Options<RType>\n    super()\n    if (options.objectMode && typeof options.encoding === 'string') {\n      throw new TypeError(\n        'Encoding and objectMode may not be used together'\n      )\n    }\n    if (isObjectModeOptions(options)) {\n      this[OBJECTMODE] = true\n      this[ENCODING] = null\n    } else if (isEncodingOptions(options)) {\n      this[ENCODING] = options.encoding\n      this[OBJECTMODE] = false\n    } else {\n      this[OBJECTMODE] = false\n      this[ENCODING] = null\n    }\n    this[ASYNC] = !!options.async\n    this[DECODER] = this[ENCODING]\n      ? (new StringDecoder(this[ENCODING]) as SD)\n      : null\n\n    //@ts-ignore - private option for debugging and testing\n    if (options && options.debugExposeBuffer === true) {\n      Object.defineProperty(this, 'buffer', { get: () => this[BUFFER] })\n    }\n    //@ts-ignore - private option for debugging and testing\n    if (options && options.debugExposePipes === true) {\n      Object.defineProperty(this, 'pipes', { get: () => this[PIPES] })\n    }\n\n    const { signal } = options\n    if (signal) {\n      this[SIGNAL] = signal\n      if (signal.aborted) {\n        this[ABORT]()\n      } else {\n        signal.addEventListener('abort', () => this[ABORT]())\n      }\n    }\n  }\n\n  /**\n   * The amount of data stored in the buffer waiting to be read.\n   *\n   * For Buffer strings, this will be the total byte length.\n   * For string encoding streams, this will be the string character length,\n   * according to JavaScript's `string.length` logic.\n   * For objectMode streams, this is a count of the items waiting to be\n   * emitted.\n   */\n  get bufferLength() {\n    return this[BUFFERLENGTH]\n  }\n\n  /**\n   * The `BufferEncoding` currently in use, or `null`\n   */\n  get encoding() {\n    return this[ENCODING]\n  }\n\n  /**\n   * @deprecated - This is a read only property\n   */\n  set encoding(_enc) {\n    throw new Error('Encoding must be set at instantiation time')\n  }\n\n  /**\n   * @deprecated - Encoding may only be set at instantiation time\n   */\n  setEncoding(_enc: Minipass.Encoding) {\n    throw new Error('Encoding must be set at instantiation time')\n  }\n\n  /**\n   * True if this is an objectMode stream\n   */\n  get objectMode() {\n    return this[OBJECTMODE]\n  }\n\n  /**\n   * @deprecated - This is a read-only property\n   */\n  set objectMode(_om) {\n    throw new Error('objectMode must be set at instantiation time')\n  }\n\n  /**\n   * true if this is an async stream\n   */\n  get ['async'](): boolean {\n    return this[ASYNC]\n  }\n  /**\n   * Set to true to make this stream async.\n   *\n   * Once set, it cannot be unset, as this would potentially cause incorrect\n   * behavior.  Ie, a sync stream can be made async, but an async stream\n   * cannot be safely made sync.\n   */\n  set ['async'](a: boolean) {\n    this[ASYNC] = this[ASYNC] || !!a\n  }\n\n  // drop everything and get out of the flow completely\n  [ABORT]() {\n    this[ABORTED] = true\n    this.emit('abort', this[SIGNAL]?.reason)\n    this.destroy(this[SIGNAL]?.reason)\n  }\n\n  /**\n   * True if the stream has been aborted.\n   */\n  get aborted() {\n    return this[ABORTED]\n  }\n  /**\n   * No-op setter. Stream aborted status is set via the AbortSignal provided\n   * in the constructor options.\n   */\n  set aborted(_) {}\n\n  /**\n   * Write data into the stream\n   *\n   * If the chunk written is a string, and encoding is not specified, then\n   * `utf8` will be assumed. If the stream encoding matches the encoding of\n   * a written string, and the state of the string decoder allows it, then\n   * the string will be passed through to either the output or the internal\n   * buffer without any processing. Otherwise, it will be turned into a\n   * Buffer object for processing into the desired encoding.\n   *\n   * If provided, `cb` function is called immediately before return for\n   * sync streams, or on next tick for async streams, because for this\n   * base class, a chunk is considered \"processed\" once it is accepted\n   * and either emitted or buffered. That is, the callback does not indicate\n   * that the chunk has been eventually emitted, though of course child\n   * classes can override this function to do whatever processing is required\n   * and call `super.write(...)` only once processing is completed.\n   */\n  write(chunk: WType, cb?: () => void): boolean\n  write(\n    chunk: WType,\n    encoding?: Minipass.Encoding,\n    cb?: () => void\n  ): boolean\n  write(\n    chunk: WType,\n    encoding?: Minipass.Encoding | (() => void),\n    cb?: () => void\n  ): boolean {\n    if (this[ABORTED]) return false\n    if (this[EOF]) throw new Error('write after end')\n\n    if (this[DESTROYED]) {\n      this.emit(\n        'error',\n        Object.assign(\n          new Error('Cannot call write after a stream was destroyed'),\n          { code: 'ERR_STREAM_DESTROYED' }\n        )\n      )\n      return true\n    }\n\n    if (typeof encoding === 'function') {\n      cb = encoding\n      encoding = 'utf8'\n    }\n\n    if (!encoding) encoding = 'utf8'\n\n    const fn = this[ASYNC] ? defer : nodefer\n\n    // convert array buffers and typed array views into buffers\n    // at some point in the future, we may want to do the opposite!\n    // leave strings and buffers as-is\n    // anything is only allowed if in object mode, so throw\n    if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {\n      if (isArrayBufferView(chunk)) {\n        //@ts-ignore - sinful unsafe type changing\n        chunk = Buffer.from(\n          chunk.buffer,\n          chunk.byteOffset,\n          chunk.byteLength\n        )\n      } else if (isArrayBufferLike(chunk)) {\n        //@ts-ignore - sinful unsafe type changing\n        chunk = Buffer.from(chunk)\n      } else if (typeof chunk !== 'string') {\n        throw new Error(\n          'Non-contiguous data written to non-objectMode stream'\n        )\n      }\n    }\n\n    // handle object mode up front, since it's simpler\n    // this yields better performance, fewer checks later.\n    if (this[OBJECTMODE]) {\n      // maybe impossible?\n      /* c8 ignore start */\n      if (this[FLOWING] && this[BUFFERLENGTH] !== 0) this[FLUSH](true)\n      /* c8 ignore stop */\n\n      if (this[FLOWING]) this.emit('data', chunk as unknown as RType)\n      else this[BUFFERPUSH](chunk as unknown as RType)\n\n      if (this[BUFFERLENGTH] !== 0) this.emit('readable')\n\n      if (cb) fn(cb)\n\n      return this[FLOWING]\n    }\n\n    // at this point the chunk is a buffer or string\n    // don't buffer it up or send it to the decoder\n    if (!(chunk as Minipass.BufferOrString).length) {\n      if (this[BUFFERLENGTH] !== 0) this.emit('readable')\n      if (cb) fn(cb)\n      return this[FLOWING]\n    }\n\n    // fast-path writing strings of same encoding to a stream with\n    // an empty buffer, skipping the buffer/decoder dance\n    if (\n      typeof chunk === 'string' &&\n      // unless it is a string already ready for us to use\n      !(encoding === this[ENCODING] && !this[DECODER]?.lastNeed)\n    ) {\n      //@ts-ignore - sinful unsafe type change\n      chunk = Buffer.from(chunk, encoding)\n    }\n\n    if (Buffer.isBuffer(chunk) && this[ENCODING]) {\n      //@ts-ignore - sinful unsafe type change\n      chunk = this[DECODER].write(chunk)\n    }\n\n    // Note: flushing CAN potentially switch us into not-flowing mode\n    if (this[FLOWING] && this[BUFFERLENGTH] !== 0) this[FLUSH](true)\n\n    if (this[FLOWING]) this.emit('data', chunk as unknown as RType)\n    else this[BUFFERPUSH](chunk as unknown as RType)\n\n    if (this[BUFFERLENGTH] !== 0) this.emit('readable')\n\n    if (cb) fn(cb)\n\n    return this[FLOWING]\n  }\n\n  /**\n   * Low-level explicit read method.\n   *\n   * In objectMode, the argument is ignored, and one item is returned if\n   * available.\n   *\n   * `n` is the number of bytes (or in the case of encoding streams,\n   * characters) to consume. If `n` is not provided, then the entire buffer\n   * is returned, or `null` is returned if no data is available.\n   *\n   * If `n` is greater that the amount of data in the internal buffer,\n   * then `null` is returned.\n   */\n  read(n?: number | null): RType | null {\n    if (this[DESTROYED]) return null\n    this[DISCARDED] = false\n\n    if (\n      this[BUFFERLENGTH] === 0 ||\n      n === 0 ||\n      (n && n > this[BUFFERLENGTH])\n    ) {\n      this[MAYBE_EMIT_END]()\n      return null\n    }\n\n    if (this[OBJECTMODE]) n = null\n\n    if (this[BUFFER].length > 1 && !this[OBJECTMODE]) {\n      // not object mode, so if we have an encoding, then RType is string\n      // otherwise, must be Buffer\n      this[BUFFER] = [\n        (this[ENCODING]\n          ? this[BUFFER].join('')\n          : Buffer.concat(\n              this[BUFFER] as Buffer[],\n              this[BUFFERLENGTH]\n            )) as RType,\n      ]\n    }\n\n    const ret = this[READ](n || null, this[BUFFER][0] as RType)\n    this[MAYBE_EMIT_END]()\n    return ret\n  }\n\n  [READ](n: number | null, chunk: RType) {\n    if (this[OBJECTMODE]) this[BUFFERSHIFT]()\n    else {\n      const c = chunk as Minipass.BufferOrString\n      if (n === c.length || n === null) this[BUFFERSHIFT]()\n      else if (typeof c === 'string') {\n        this[BUFFER][0] = c.slice(n) as RType\n        chunk = c.slice(0, n) as RType\n        this[BUFFERLENGTH] -= n\n      } else {\n        this[BUFFER][0] = c.subarray(n) as RType\n        chunk = c.subarray(0, n) as RType\n        this[BUFFERLENGTH] -= n\n      }\n    }\n\n    this.emit('data', chunk)\n\n    if (!this[BUFFER].length && !this[EOF]) this.emit('drain')\n\n    return chunk\n  }\n\n  /**\n   * End the stream, optionally providing a final write.\n   *\n   * See {@link Minipass#write} for argument descriptions\n   */\n  end(cb?: () => void): this\n  end(chunk: WType, cb?: () => void): this\n  end(chunk: WType, encoding?: Minipass.Encoding, cb?: () => void): this\n  end(\n    chunk?: WType | (() => void),\n    encoding?: Minipass.Encoding | (() => void),\n    cb?: () => void\n  ): this {\n    if (typeof chunk === 'function') {\n      cb = chunk as () => void\n      chunk = undefined\n    }\n    if (typeof encoding === 'function') {\n      cb = encoding\n      encoding = 'utf8'\n    }\n    if (chunk !== undefined) this.write(chunk, encoding)\n    if (cb) this.once('end', cb)\n    this[EOF] = true\n    this.writable = false\n\n    // if we haven't written anything, then go ahead and emit,\n    // even if we're not reading.\n    // we'll re-emit if a new 'end' listener is added anyway.\n    // This makes MP more suitable to write-only use cases.\n    if (this[FLOWING] || !this[PAUSED]) this[MAYBE_EMIT_END]()\n    return this\n  }\n\n  // don't let the internal resume be overwritten\n  [RESUME]() {\n    if (this[DESTROYED]) return\n\n    if (!this[DATALISTENERS] && !this[PIPES].length) {\n      this[DISCARDED] = true\n    }\n    this[PAUSED] = false\n    this[FLOWING] = true\n    this.emit('resume')\n    if (this[BUFFER].length) this[FLUSH]()\n    else if (this[EOF]) this[MAYBE_EMIT_END]()\n    else this.emit('drain')\n  }\n\n  /**\n   * Resume the stream if it is currently in a paused state\n   *\n   * If called when there are no pipe destinations or `data` event listeners,\n   * this will place the stream in a \"discarded\" state, where all data will\n   * be thrown away. The discarded state is removed if a pipe destination or\n   * data handler is added, if pause() is called, or if any synchronous or\n   * asynchronous iteration is started.\n   */\n  resume() {\n    return this[RESUME]()\n  }\n\n  /**\n   * Pause the stream\n   */\n  pause() {\n    this[FLOWING] = false\n    this[PAUSED] = true\n    this[DISCARDED] = false\n  }\n\n  /**\n   * true if the stream has been forcibly destroyed\n   */\n  get destroyed() {\n    return this[DESTROYED]\n  }\n\n  /**\n   * true if the stream is currently in a flowing state, meaning that\n   * any writes will be immediately emitted.\n   */\n  get flowing() {\n    return this[FLOWING]\n  }\n\n  /**\n   * true if the stream is currently in a paused state\n   */\n  get paused() {\n    return this[PAUSED]\n  }\n\n  [BUFFERPUSH](chunk: RType) {\n    if (this[OBJECTMODE]) this[BUFFERLENGTH] += 1\n    else this[BUFFERLENGTH] += (chunk as Minipass.BufferOrString).length\n    this[BUFFER].push(chunk)\n  }\n\n  [BUFFERSHIFT](): RType {\n    if (this[OBJECTMODE]) this[BUFFERLENGTH] -= 1\n    else\n      this[BUFFERLENGTH] -= (\n        this[BUFFER][0] as Minipass.BufferOrString\n      ).length\n    return this[BUFFER].shift() as RType\n  }\n\n  [FLUSH](noDrain: boolean = false) {\n    do {} while (\n      this[FLUSHCHUNK](this[BUFFERSHIFT]()) &&\n      this[BUFFER].length\n    )\n\n    if (!noDrain && !this[BUFFER].length && !this[EOF]) this.emit('drain')\n  }\n\n  [FLUSHCHUNK](chunk: RType) {\n    this.emit('data', chunk)\n    return this[FLOWING]\n  }\n\n  /**\n   * Pipe all data emitted by this stream into the destination provided.\n   *\n   * Triggers the flow of data.\n   */\n  pipe<W extends Minipass.Writable>(dest: W, opts?: PipeOptions): W {\n    if (this[DESTROYED]) return dest\n    this[DISCARDED] = false\n\n    const ended = this[EMITTED_END]\n    opts = opts || {}\n    if (dest === proc.stdout || dest === proc.stderr) opts.end = false\n    else opts.end = opts.end !== false\n    opts.proxyErrors = !!opts.proxyErrors\n\n    // piping an ended stream ends immediately\n    if (ended) {\n      if (opts.end) dest.end()\n    } else {\n      // \"as\" here just ignores the WType, which pipes don't care about,\n      // since they're only consuming from us, and writing to the dest\n      this[PIPES].push(\n        !opts.proxyErrors\n          ? new Pipe<RType>(this as Minipass<RType>, dest, opts)\n          : new PipeProxyErrors<RType>(this as Minipass<RType>, dest, opts)\n      )\n      if (this[ASYNC]) defer(() => this[RESUME]())\n      else this[RESUME]()\n    }\n\n    return dest\n  }\n\n  /**\n   * Fully unhook a piped destination stream.\n   *\n   * If the destination stream was the only consumer of this stream (ie,\n   * there are no other piped destinations or `'data'` event listeners)\n   * then the flow of data will stop until there is another consumer or\n   * {@link Minipass#resume} is explicitly called.\n   */\n  unpipe<W extends Minipass.Writable>(dest: W) {\n    const p = this[PIPES].find(p => p.dest === dest)\n    if (p) {\n      if (this[PIPES].length === 1) {\n        if (this[FLOWING] && this[DATALISTENERS] === 0) {\n          this[FLOWING] = false\n        }\n        this[PIPES] = []\n      } else this[PIPES].splice(this[PIPES].indexOf(p), 1)\n      p.unpipe()\n    }\n  }\n\n  /**\n   * Alias for {@link Minipass#on}\n   */\n  addListener<Event extends keyof Events>(\n    ev: Event,\n    handler: (...args: Events[Event]) => any\n  ): this {\n    return this.on(ev, handler)\n  }\n\n  /**\n   * Mostly identical to `EventEmitter.on`, with the following\n   * behavior differences to prevent data loss and unnecessary hangs:\n   *\n   * - Adding a 'data' event handler will trigger the flow of data\n   *\n   * - Adding a 'readable' event handler when there is data waiting to be read\n   *   will cause 'readable' to be emitted immediately.\n   *\n   * - Adding an 'endish' event handler ('end', 'finish', etc.) which has\n   *   already passed will cause the event to be emitted immediately and all\n   *   handlers removed.\n   *\n   * - Adding an 'error' event handler after an error has been emitted will\n   *   cause the event to be re-emitted immediately with the error previously\n   *   raised.\n   */\n  on<Event extends keyof Events>(\n    ev: Event,\n    handler: (...args: Events[Event]) => any\n  ): this {\n    const ret = super.on(\n      ev as string | symbol,\n      handler as (...a: any[]) => any\n    )\n    if (ev === 'data') {\n      this[DISCARDED] = false\n      this[DATALISTENERS]++\n      if (!this[PIPES].length && !this[FLOWING]) {\n        this[RESUME]()\n      }\n    } else if (ev === 'readable' && this[BUFFERLENGTH] !== 0) {\n      super.emit('readable')\n    } else if (isEndish(ev) && this[EMITTED_END]) {\n      super.emit(ev)\n      this.removeAllListeners(ev)\n    } else if (ev === 'error' && this[EMITTED_ERROR]) {\n      const h = handler as (...a: Events['error']) => any\n      if (this[ASYNC]) defer(() => h.call(this, this[EMITTED_ERROR]))\n      else h.call(this, this[EMITTED_ERROR])\n    }\n    return ret\n  }\n\n  /**\n   * Alias for {@link Minipass#off}\n   */\n  removeListener<Event extends keyof Events>(\n    ev: Event,\n    handler: (...args: Events[Event]) => any\n  ) {\n    return this.off(ev, handler)\n  }\n\n  /**\n   * Mostly identical to `EventEmitter.off`\n   *\n   * If a 'data' event handler is removed, and it was the last consumer\n   * (ie, there are no pipe destinations or other 'data' event listeners),\n   * then the flow of data will stop until there is another consumer or\n   * {@link Minipass#resume} is explicitly called.\n   */\n  off<Event extends keyof Events>(\n    ev: Event,\n    handler: (...args: Events[Event]) => any\n  ) {\n    const ret = super.off(\n      ev as string | symbol,\n      handler as (...a: any[]) => any\n    )\n    // if we previously had listeners, and now we don't, and we don't\n    // have any pipes, then stop the flow, unless it's been explicitly\n    // put in a discarded flowing state via stream.resume().\n    if (ev === 'data') {\n      this[DATALISTENERS] = this.listeners('data').length\n      if (\n        this[DATALISTENERS] === 0 &&\n        !this[DISCARDED] &&\n        !this[PIPES].length\n      ) {\n        this[FLOWING] = false\n      }\n    }\n    return ret\n  }\n\n  /**\n   * Mostly identical to `EventEmitter.removeAllListeners`\n   *\n   * If all 'data' event handlers are removed, and they were the last consumer\n   * (ie, there are no pipe destinations), then the flow of data will stop\n   * until there is another consumer or {@link Minipass#resume} is explicitly\n   * called.\n   */\n  removeAllListeners<Event extends keyof Events>(ev?: Event) {\n    const ret = super.removeAllListeners(ev as string | symbol | undefined)\n    if (ev === 'data' || ev === undefined) {\n      this[DATALISTENERS] = 0\n      if (!this[DISCARDED] && !this[PIPES].length) {\n        this[FLOWING] = false\n      }\n    }\n    return ret\n  }\n\n  /**\n   * true if the 'end' event has been emitted\n   */\n  get emittedEnd() {\n    return this[EMITTED_END]\n  }\n\n  [MAYBE_EMIT_END]() {\n    if (\n      !this[EMITTING_END] &&\n      !this[EMITTED_END] &&\n      !this[DESTROYED] &&\n      this[BUFFER].length === 0 &&\n      this[EOF]\n    ) {\n      this[EMITTING_END] = true\n      this.emit('end')\n      this.emit('prefinish')\n      this.emit('finish')\n      if (this[CLOSED]) this.emit('close')\n      this[EMITTING_END] = false\n    }\n  }\n\n  /**\n   * Mostly identical to `EventEmitter.emit`, with the following\n   * behavior differences to prevent data loss and unnecessary hangs:\n   *\n   * If the stream has been destroyed, and the event is something other\n   * than 'close' or 'error', then `false` is returned and no handlers\n   * are called.\n   *\n   * If the event is 'end', and has already been emitted, then the event\n   * is ignored. If the stream is in a paused or non-flowing state, then\n   * the event will be deferred until data flow resumes. If the stream is\n   * async, then handlers will be called on the next tick rather than\n   * immediately.\n   *\n   * If the event is 'close', and 'end' has not yet been emitted, then\n   * the event will be deferred until after 'end' is emitted.\n   *\n   * If the event is 'error', and an AbortSignal was provided for the stream,\n   * and there are no listeners, then the event is ignored, matching the\n   * behavior of node core streams in the presense of an AbortSignal.\n   *\n   * If the event is 'finish' or 'prefinish', then all listeners will be\n   * removed after emitting the event, to prevent double-firing.\n   */\n  emit<Event extends keyof Events>(\n    ev: Event,\n    ...args: Events[Event]\n  ): boolean {\n    const data = args[0]\n    // error and close are only events allowed after calling destroy()\n    if (\n      ev !== 'error' &&\n      ev !== 'close' &&\n      ev !== DESTROYED &&\n      this[DESTROYED]\n    ) {\n      return false\n    } else if (ev === 'data') {\n      return !this[OBJECTMODE] && !data\n        ? false\n        : this[ASYNC]\n        ? (defer(() => this[EMITDATA](data as RType)), true)\n        : this[EMITDATA](data as RType)\n    } else if (ev === 'end') {\n      return this[EMITEND]()\n    } else if (ev === 'close') {\n      this[CLOSED] = true\n      // don't emit close before 'end' and 'finish'\n      if (!this[EMITTED_END] && !this[DESTROYED]) return false\n      const ret = super.emit('close')\n      this.removeAllListeners('close')\n      return ret\n    } else if (ev === 'error') {\n      this[EMITTED_ERROR] = data\n      super.emit(ERROR, data)\n      const ret =\n        !this[SIGNAL] || this.listeners('error').length\n          ? super.emit('error', data)\n          : false\n      this[MAYBE_EMIT_END]()\n      return ret\n    } else if (ev === 'resume') {\n      const ret = super.emit('resume')\n      this[MAYBE_EMIT_END]()\n      return ret\n    } else if (ev === 'finish' || ev === 'prefinish') {\n      const ret = super.emit(ev)\n      this.removeAllListeners(ev)\n      return ret\n    }\n\n    // Some other unknown event\n    const ret = super.emit(ev as string, ...args)\n    this[MAYBE_EMIT_END]()\n    return ret\n  }\n\n  [EMITDATA](data: RType) {\n    for (const p of this[PIPES]) {\n      if (p.dest.write(data as RType) === false) this.pause()\n    }\n    const ret = this[DISCARDED] ? false : super.emit('data', data)\n    this[MAYBE_EMIT_END]()\n    return ret\n  }\n\n  [EMITEND]() {\n    if (this[EMITTED_END]) return false\n\n    this[EMITTED_END] = true\n    this.readable = false\n    return this[ASYNC]\n      ? (defer(() => this[EMITEND2]()), true)\n      : this[EMITEND2]()\n  }\n\n  [EMITEND2]() {\n    if (this[DECODER]) {\n      const data = this[DECODER].end()\n      if (data) {\n        for (const p of this[PIPES]) {\n          p.dest.write(data as RType)\n        }\n        if (!this[DISCARDED]) super.emit('data', data)\n      }\n    }\n\n    for (const p of this[PIPES]) {\n      p.end()\n    }\n    const ret = super.emit('end')\n    this.removeAllListeners('end')\n    return ret\n  }\n\n  /**\n   * Return a Promise that resolves to an array of all emitted data once\n   * the stream ends.\n   */\n  async collect(): Promise<RType[] & { dataLength: number }> {\n    const buf: RType[] & { dataLength: number } = Object.assign([], {\n      dataLength: 0,\n    })\n    if (!this[OBJECTMODE]) buf.dataLength = 0\n    // set the promise first, in case an error is raised\n    // by triggering the flow here.\n    const p = this.promise()\n    this.on('data', c => {\n      buf.push(c)\n      if (!this[OBJECTMODE])\n        buf.dataLength += (c as Minipass.BufferOrString).length\n    })\n    await p\n    return buf\n  }\n\n  /**\n   * Return a Promise that resolves to the concatenation of all emitted data\n   * once the stream ends.\n   *\n   * Not allowed on objectMode streams.\n   */\n  async concat(): Promise<RType> {\n    if (this[OBJECTMODE]) {\n      throw new Error('cannot concat in objectMode')\n    }\n    const buf = await this.collect()\n    return (\n      this[ENCODING]\n        ? buf.join('')\n        : Buffer.concat(buf as Buffer[], buf.dataLength)\n    ) as RType\n  }\n\n  /**\n   * Return a void Promise that resolves once the stream ends.\n   */\n  async promise(): Promise<void> {\n    return new Promise<void>((resolve, reject) => {\n      this.on(DESTROYED, () => reject(new Error('stream destroyed')))\n      this.on('error', er => reject(er))\n      this.on('end', () => resolve())\n    })\n  }\n\n  /**\n   * Asynchronous `for await of` iteration.\n   *\n   * This will continue emitting all chunks until the stream terminates.\n   */\n  [Symbol.asyncIterator](): AsyncGenerator<RType, void, void> {\n    // set this up front, in case the consumer doesn't call next()\n    // right away.\n    this[DISCARDED] = false\n    let stopped = false\n    const stop = async (): Promise<IteratorReturnResult<void>> => {\n      this.pause()\n      stopped = true\n      return { value: undefined, done: true }\n    }\n    const next = (): Promise<IteratorResult<RType, void>> => {\n      if (stopped) return stop()\n      const res = this.read()\n      if (res !== null) return Promise.resolve({ done: false, value: res })\n\n      if (this[EOF]) return stop()\n\n      let resolve!: (res: IteratorResult<RType>) => void\n      let reject!: (er: unknown) => void\n      const onerr = (er: unknown) => {\n        this.off('data', ondata)\n        this.off('end', onend)\n        this.off(DESTROYED, ondestroy)\n        stop()\n        reject(er)\n      }\n      const ondata = (value: RType) => {\n        this.off('error', onerr)\n        this.off('end', onend)\n        this.off(DESTROYED, ondestroy)\n        this.pause()\n        resolve({ value, done: !!this[EOF] })\n      }\n      const onend = () => {\n        this.off('error', onerr)\n        this.off('data', ondata)\n        this.off(DESTROYED, ondestroy)\n        stop()\n        resolve({ done: true, value: undefined })\n      }\n      const ondestroy = () => onerr(new Error('stream destroyed'))\n      return new Promise<IteratorResult<RType>>((res, rej) => {\n        reject = rej\n        resolve = res\n        this.once(DESTROYED, ondestroy)\n        this.once('error', onerr)\n        this.once('end', onend)\n        this.once('data', ondata)\n      })\n    }\n\n    return {\n      next,\n      throw: stop,\n      return: stop,\n      [Symbol.asyncIterator]() {\n        return this\n      },\n      [Symbol.asyncDispose]: async () => {},\n    }\n  }\n\n  /**\n   * Synchronous `for of` iteration.\n   *\n   * The iteration will terminate when the internal buffer runs out, even\n   * if the stream has not yet terminated.\n   */\n  [Symbol.iterator](): Generator<RType, void, void> {\n    // set this up front, in case the consumer doesn't call next()\n    // right away.\n    this[DISCARDED] = false\n    let stopped = false\n    const stop = (): IteratorReturnResult<void> => {\n      this.pause()\n      this.off(ERROR, stop)\n      this.off(DESTROYED, stop)\n      this.off('end', stop)\n      stopped = true\n      return { done: true, value: undefined }\n    }\n\n    const next = (): IteratorResult<RType, void> => {\n      if (stopped) return stop()\n      const value = this.read()\n      return value === null ? stop() : { done: false, value }\n    }\n\n    this.once('end', stop)\n    this.once(ERROR, stop)\n    this.once(DESTROYED, stop)\n\n    return {\n      next,\n      throw: stop,\n      return: stop,\n      [Symbol.iterator]() {\n        return this\n      },\n      [Symbol.dispose]: () => {},\n    }\n  }\n\n  /**\n   * Destroy a stream, preventing it from being used for any further purpose.\n   *\n   * If the stream has a `close()` method, then it will be called on\n   * destruction.\n   *\n   * After destruction, any attempt to write data, read data, or emit most\n   * events will be ignored.\n   *\n   * If an error argument is provided, then it will be emitted in an\n   * 'error' event.\n   */\n  destroy(er?: unknown) {\n    if (this[DESTROYED]) {\n      if (er) this.emit('error', er)\n      else this.emit(DESTROYED)\n      return this\n    }\n\n    this[DESTROYED] = true\n    this[DISCARDED] = true\n\n    // throw away all buffered data, it's never coming out\n    this[BUFFER].length = 0\n    this[BUFFERLENGTH] = 0\n\n    const wc = this as Minipass<RType, WType, Events> & {\n      close?: () => void\n    }\n    if (typeof wc.close === 'function' && !this[CLOSED]) wc.close()\n\n    if (er) this.emit('error', er)\n    // if no error to emit, still reject pending promises\n    else this.emit(DESTROYED)\n\n    return this\n  }\n\n  /**\n   * Alias for {@link isStream}\n   *\n   * Former export location, maintained for backwards compatibility.\n   *\n   * @deprecated\n   */\n  static get isStream() {\n    return isStream\n  }\n}\n", "// this is just a very light wrapper around 2 arrays with an offset index\n\nimport type { ParseReturnFiltered } from 'minimatch'\nimport { GLOBSTAR } from 'minimatch'\n\n/**\n * One portion of a parsed minimatch pattern: a string, a Matcher for\n * a portion with magic, or GLOBSTAR for `**`.\n */\nexport type MMPattern = ParseReturnFiltered\n\n/** The Matcher that minimatch makes for a portion with magic. */\nexport type MMMatcher = Exclude<MMPattern, string | typeof GLOBSTAR>\n\n// an array of length >= 1\nexport type PatternList = [p: MMPattern, ...rest: MMPattern[]]\nexport type UNCPatternList = [\n  p0: '',\n  p1: '',\n  p2: string,\n  p3: string,\n  ...rest: MMPattern[],\n]\nexport type DrivePatternList = [p0: string, ...rest: MMPattern[]]\nexport type AbsolutePatternList = [p0: '', ...rest: MMPattern[]]\nexport type GlobList = [p: string, ...rest: string[]]\n\nconst isPatternList = (pl: MMPattern[]): pl is PatternList =>\n  pl.length >= 1\nconst isGlobList = (gl: string[]): gl is GlobList => gl.length >= 1\n\nconst customInspect = Symbol.for('nodejs.util.inspect.custom')\n\n/**\n * An immutable-ish view on an array of glob parts and their parsed\n * results\n */\nexport class Pattern {\n  readonly #patternList: PatternList\n  readonly #globList: GlobList\n  readonly #index: number\n  readonly length: number\n  readonly #platform: NodeJS.Platform\n  #rest?: Pattern | null\n  #globString?: string\n  #isDrive?: boolean\n  #isUNC?: boolean\n  #isAbsolute?: boolean\n  #followGlobstar: boolean = true\n\n  constructor(\n    patternList: MMPattern[],\n    globList: string[],\n    index: number,\n    platform: NodeJS.Platform,\n  ) {\n    if (!isPatternList(patternList)) {\n      throw new TypeError('empty pattern list')\n    }\n    if (!isGlobList(globList)) {\n      throw new TypeError('empty glob list')\n    }\n    if (globList.length !== patternList.length) {\n      throw new TypeError('mismatched pattern list and glob list lengths')\n    }\n    this.length = patternList.length\n    if (index < 0 || index >= this.length) {\n      throw new TypeError('index out of range')\n    }\n    this.#patternList = patternList\n    this.#globList = globList\n    this.#index = index\n    this.#platform = platform\n\n    // normalize root entries of absolute patterns on initial creation.\n    if (this.#index === 0) {\n      // c: => ['c:/']\n      // C:/ => ['C:/']\n      // C:/x => ['C:/', 'x']\n      // //host/share => ['//host/share/']\n      // //host/share/ => ['//host/share/']\n      // //host/share/x => ['//host/share/', 'x']\n      // //?/UNC/host/share/x => ['//?/UNC/host/share/', 'x']\n      // /etc => ['/', 'etc']\n      // / => ['/']\n      if (this.isUNC()) {\n        // '' / '' / 'host' / 'share', or\n        // '' / '' / '?' / 'UNC' / 'host' / 'share'\n        const n = this.#isLongUNC() ? 6 : 4\n        const proot = this.#patternList.slice(0, n)\n        const groot = this.#globList.slice(0, n)\n        const prest = this.#patternList.slice(n)\n        const grest = this.#globList.slice(n)\n        if (prest[0] === '') {\n          // ends in /\n          prest.shift()\n          grest.shift()\n        }\n        const p = [...proot, ''].join('/')\n        const g = [...groot, ''].join('/')\n        this.#patternList = [p, ...prest]\n        this.#globList = [g, ...grest]\n        this.length = this.#patternList.length\n      } else if (this.isDrive() || this.isAbsolute()) {\n        const [p1, ...prest] = this.#patternList\n        const [g1, ...grest] = this.#globList\n        if (prest[0] === '') {\n          // ends in /\n          prest.shift()\n          grest.shift()\n        }\n        const p = `${p1 as string}/`\n        const g = `${g1}/`\n        this.#patternList = [p, ...prest]\n        this.#globList = [g, ...grest]\n        this.length = this.#patternList.length\n      }\n    }\n  }\n\n  [customInspect]() {\n    return `Pattern <${this.#globList.slice(this.#index).join('/')}>`\n  }\n\n  /**\n   * The first entry in the parsed list of patterns\n   */\n  pattern(): MMPattern {\n    return this.#patternList[this.#index] as MMPattern\n  }\n\n  /**\n   * true of if pattern() returns a string\n   */\n  isString(): boolean {\n    return typeof this.#patternList[this.#index] === 'string'\n  }\n  /**\n   * true of if pattern() returns GLOBSTAR\n   */\n  isGlobstar(): boolean {\n    return this.#patternList[this.#index] === GLOBSTAR\n  }\n  /**\n   * true if pattern() returns a Matcher, for a portion with magic\n   */\n  isMatcher(): boolean {\n    return typeof this.#patternList[this.#index] === 'object'\n  }\n\n  /**\n   * The /-joined set of glob parts that make up this pattern\n   */\n  globString(): string {\n    return (this.#globString =\n      this.#globString ||\n      (this.#index === 0 ?\n        this.isAbsolute() ?\n          this.#globList[0] + this.#globList.slice(1).join('/')\n        : this.#globList.join('/')\n      : this.#globList.slice(this.#index).join('/')))\n  }\n\n  /**\n   * true if there are more pattern parts after this one\n   */\n  hasMore(): boolean {\n    return this.length > this.#index + 1\n  }\n\n  /**\n   * The rest of the pattern after this part, or null if this is the end\n   */\n  rest(): Pattern | null {\n    if (this.#rest !== undefined) return this.#rest\n    if (!this.hasMore()) return (this.#rest = null)\n    this.#rest = new Pattern(\n      this.#patternList,\n      this.#globList,\n      this.#index + 1,\n      this.#platform,\n    )\n    this.#rest.#isAbsolute = this.#isAbsolute\n    this.#rest.#isUNC = this.#isUNC\n    this.#rest.#isDrive = this.#isDrive\n    return this.#rest\n  }\n\n  // the root is //?/UNC/host/share, the same as //host/share\n  #isLongUNC(): boolean {\n    const pl = this.#patternList\n    return (\n      pl[2] === '?' && typeof pl[3] === 'string' && /^unc$/i.test(pl[3])\n    )\n  }\n\n  /**\n   * true if the pattern represents a //unc/path/ on windows\n   */\n  isUNC(): boolean {\n    const pl = this.#patternList\n    // the host and share, after //?/UNC/ in a long UNC path\n    const h = this.#isLongUNC() ? 4 : 2\n    return this.#isUNC !== undefined ?\n        this.#isUNC\n      : (this.#isUNC =\n          this.#platform === 'win32' &&\n          this.#index === 0 &&\n          pl[0] === '' &&\n          pl[1] === '' &&\n          typeof pl[h] === 'string' &&\n          !!pl[h] &&\n          typeof pl[h + 1] === 'string' &&\n          !!pl[h + 1])\n  }\n\n  // pattern like C:/...\n  // split = ['C:', ...]\n  // XXX: would be nice to handle patterns like `c:*` to test the cwd\n  // in c: for *, but I don't know of a way to even figure out what that\n  // cwd is without actually chdir'ing into it?\n  /**\n   * True if the pattern starts with a drive letter on Windows\n   */\n  isDrive(): boolean {\n    const pl = this.#patternList\n    return this.#isDrive !== undefined ?\n        this.#isDrive\n      : (this.#isDrive =\n          this.#platform === 'win32' &&\n          this.#index === 0 &&\n          this.length > 1 &&\n          typeof pl[0] === 'string' &&\n          /^[a-z]:$/i.test(pl[0]))\n  }\n\n  // pattern = '/' or '/...' or '/x/...'\n  // split = ['', ''] or ['', ...] or ['', 'x', ...]\n  // Drive and UNC both considered absolute on windows\n  /**\n   * True if the pattern is rooted on an absolute path\n   */\n  isAbsolute(): boolean {\n    const pl = this.#patternList\n    return this.#isAbsolute !== undefined ?\n        this.#isAbsolute\n      : (this.#isAbsolute =\n          (pl[0] === '' && pl.length > 1) ||\n          this.isDrive() ||\n          this.isUNC())\n  }\n\n  /**\n   * consume the root of the pattern, and return it\n   */\n  root(): string {\n    const p = this.#patternList[0]\n    return (\n        typeof p === 'string' && this.isAbsolute() && this.#index === 0\n      ) ?\n        p\n      : ''\n  }\n\n  /**\n   * Check to see if the current globstar pattern is allowed to follow\n   * a symbolic link.\n   */\n  checkFollowGlobstar(): boolean {\n    return !(\n      this.#index === 0 ||\n      !this.isGlobstar() ||\n      !this.#followGlobstar\n    )\n  }\n\n  /**\n   * Mark that the current globstar pattern is following a symbolic link\n   */\n  markFollowGlobstar(): boolean {\n    if (this.#index === 0 || !this.isGlobstar() || !this.#followGlobstar)\n      return false\n    this.#followGlobstar = false\n    return true\n  }\n}\n", "// give it a pattern, and it'll be able to tell you if\n// a given path should be ignored.\n// Ignoring a path ignores its children if the pattern ends in /**\n// Ignores are always parsed in dot:true mode\n\nimport type { MinimatchOptions } from 'minimatch'\nimport { escape, Minimatch } from 'minimatch'\nimport type { Path } from 'path-scurry'\nimport { Pattern } from './pattern.js'\nimport type { GlobWalkerOpts } from './walker.js'\n\nexport interface IgnoreLike {\n  ignored?: (p: Path) => boolean\n  childrenIgnored?: (p: Path) => boolean\n  add?: (ignore: string) => void\n}\n\nconst defaultPlatform: NodeJS.Platform =\n  (\n    typeof process === 'object' &&\n    process &&\n    typeof process.platform === 'string'\n  ) ?\n    process.platform\n  : 'linux'\n\n/**\n * Class used to process ignored patterns\n */\nexport class Ignore implements IgnoreLike {\n  relative: Minimatch[]\n  relativeChildren: Minimatch[]\n  absolute: Minimatch[]\n  absoluteChildren: Minimatch[]\n  platform: NodeJS.Platform\n  mmopts: MinimatchOptions\n  /**\n   * The escaped glob for the directory that a pattern starting with\n   * `/` is rooted at, with no trailing `/`.\n   */\n  slashRoot: string\n\n  /**\n   * Patterns that start with `/` (but not drive letters or UNC paths\n   * on Windows) start at the `root` option if it is set, or else at\n   * the root of `cwd`, the same as non-ignored patterns. If `cwd` is\n   * not provided, they start at `/`.\n   */\n  constructor(\n    ignored: string[],\n    {\n      nobrace,\n      nocase,\n      noext,\n      noglobstar,\n      normalize,\n      platform = defaultPlatform,\n      root,\n      windowsPathsNoEscape,\n      allowWindowsEscape,\n    }: GlobWalkerOpts,\n    cwd?: Path,\n  ) {\n    this.relative = []\n    this.absolute = []\n    this.relativeChildren = []\n    this.absoluteChildren = []\n    this.platform = platform\n    windowsPathsNoEscape =\n      !!windowsPathsNoEscape || allowWindowsEscape === false\n    this.mmopts = {\n      dot: true,\n      nobrace,\n      nocase,\n      noext,\n      noglobstar,\n      normalize,\n      optimizationLevel: 2,\n      platform,\n      nocomment: true,\n      nonegate: true,\n      windowsPathsNoEscape,\n    }\n    const slashRoot = cwd?.resolve(root ?? '/').fullpath() ?? '/'\n    this.slashRoot = escape(\n      slashRoot.replace(/\\\\/g, '/').replace(/\\/$/, ''),\n      { windowsPathsNoEscape },\n    )\n    for (const ign of ignored) this.add(ign)\n  }\n\n  add(ign: string) {\n    // this is a little weird, but it gives us a clean set of optimized\n    // minimatch matchers, without getting tripped up if one of them\n    // ends in /** inside a brace section, and it's only inefficient at\n    // the start of the walk, not along it.\n    // It'd be nice if the Pattern class just had a .test() method, but\n    // handling globstars is a bit of a pita, and that code already lives\n    // in minimatch anyway.\n    // Another way would be if maybe Minimatch could take its set/globParts\n    // as an option, and then we could at least just use Pattern to test\n    // for absolute-ness.\n    // Yet another way, Minimatch could take an array of glob strings, and\n    // a cwd option, and do the right thing.\n    const mm = new Minimatch(ign, this.mmopts)\n    for (let i = 0; i < mm.set.length; i++) {\n      const parsed = mm.set[i]\n      const globParts = mm.globParts[i]\n      /* c8 ignore start */\n      if (!parsed || !globParts) {\n        throw new Error('invalid pattern object')\n      }\n      // strip off leading ./ portions\n      // https://github.com/isaacs/node-glob/issues/570\n      while (parsed[0] === '.' && globParts[0] === '.') {\n        parsed.shift()\n        globParts.shift()\n      }\n      /* c8 ignore stop */\n      const p = new Pattern(parsed, globParts, 0, this.platform)\n      const glob =\n        p.root() === '/' ?\n          `${this.slashRoot}/${p.rest()?.globString() ?? ''}`\n        : p.globString()\n      const m = new Minimatch(glob, this.mmopts)\n      const children = globParts[globParts.length - 1] === '**'\n      const absolute = p.isAbsolute()\n      if (absolute) this.absolute.push(m)\n      else this.relative.push(m)\n      if (children) {\n        if (absolute) this.absoluteChildren.push(m)\n        else this.relativeChildren.push(m)\n      }\n    }\n  }\n\n  ignored(p: Path): boolean {\n    const fullpath = p.fullpath()\n    const fullpaths = `${fullpath}/`\n    const relative = p.relative() || '.'\n    const relatives = `${relative}/`\n    for (const m of this.relative) {\n      if (m.match(relative) || m.match(relatives)) return true\n    }\n    for (const m of this.absolute) {\n      if (m.match(fullpath) || m.match(fullpaths)) return true\n    }\n    return false\n  }\n\n  childrenIgnored(p: Path): boolean {\n    const fullpath = `${p.fullpath()}/`\n    const relative = `${p.relative() || '.'}/`\n    for (const m of this.relativeChildren) {\n      if (m.match(relative)) return true\n    }\n    for (const m of this.absoluteChildren) {\n      if (m.match(fullpath)) return true\n    }\n    return false\n  }\n}\n", "// synchronous utility for filtering entries and calculating subwalks\n\nimport { GLOBSTAR } from 'minimatch'\nimport type { Path } from 'path-scurry'\nimport type { MMMatcher, MMPattern, Pattern } from './pattern.js'\nimport type { GlobWalkerOpts } from './walker.js'\n\n/**\n * A cache of which patterns have been processed for a given Path, in\n * this walk step and the steps that led to it.\n *\n * A step only adds to it before it makes the caches for the next\n * steps, so a copy can look up the chain of caches before it, in\n * place of copying their entries. A pattern for a path that a cache\n * up the chain has already seen is added to that cache's set, so that\n * the other steps that share it see it too. Paths are keyed by their\n * full path, because path-scurry can make a new Path object for the\n * same path once its cache of children is full.\n */\nexport class HasWalkedCache {\n  parent?: HasWalkedCache\n  store?: Map<string, Set<string>>\n  constructor(parent?: HasWalkedCache) {\n    this.parent = parent\n  }\n  copy() {\n    return new HasWalkedCache(this)\n  }\n  // the set for the path in this cache, or the closest one before it\n  #find(fullpath: string): Set<string> | undefined {\n    const set = this.store?.get(fullpath)\n    return set || !this.parent ? set : this.parent.#find(fullpath)\n  }\n\n  hasWalked(target: Path, pattern: Pattern) {\n    return !!this.#find(target.fullpath())?.has(pattern.globString())\n  }\n  storeWalked(target: Path, pattern: Pattern) {\n    const fullpath = target.fullpath()\n    const cached = this.#find(fullpath)\n    if (cached) cached.add(pattern.globString())\n    else\n      (this.store ??= new Map()).set(\n        fullpath,\n        new Set([pattern.globString()]),\n      )\n  }\n}\n\n/**\n * A record of which paths have been matched in a given walk step,\n * and whether they only are considered a match if they are a directory,\n * and whether their absolute or relative path should be returned.\n * The store maps each path to {@link MatchRecord.ABSOLUTE} and\n * {@link MatchRecord.IF_DIR} flags.\n */\nexport class MatchRecord {\n  static readonly ABSOLUTE = 2\n  static readonly IF_DIR = 1\n  store: Map<Path, number> = new Map()\n  add(target: Path, absolute: boolean, ifDir: boolean) {\n    const n =\n      (absolute ? MatchRecord.ABSOLUTE : 0) |\n      (ifDir ? MatchRecord.IF_DIR : 0)\n    const current = this.store.get(target)\n    this.store.set(target, current === undefined ? n : n & current)\n  }\n}\n\n/**\n * A collection of patterns that must be processed in a subsequent step\n * for a given path.\n */\nexport class SubWalks {\n  store: Map<Path, Pattern[]> = new Map()\n  add(target: Path, pattern: Pattern) {\n    if (!target.canReaddir()) {\n      return\n    }\n    const subs = this.store.get(target)\n    if (subs) {\n      if (!subs.find(p => p.globString() === pattern.globString())) {\n        subs.push(pattern)\n      }\n    } else this.store.set(target, [pattern])\n  }\n  get(target: Path): Pattern[] {\n    const subs = this.store.get(target)\n    /* c8 ignore start */\n    if (!subs) {\n      throw new Error('attempting to walk unknown path')\n    }\n    /* c8 ignore stop */\n    return subs\n  }\n  entries(): [Path, Pattern[]][] {\n    return this.keys().map(k => [k, this.store.get(k) as Pattern[]])\n  }\n  keys(): Path[] {\n    return [...this.store.keys()].filter(t => t.canReaddir())\n  }\n}\n\n/**\n * The class that processes patterns for a given path.\n *\n * Handles child entry filtering, and determining whether a path's\n * directory contents must be read.\n */\nexport class Processor {\n  hasWalkedCache: HasWalkedCache\n  matches = new MatchRecord()\n  subwalks = new SubWalks()\n  patterns?: Pattern[]\n  follow: boolean\n  dot: boolean\n  opts: GlobWalkerOpts\n\n  constructor(opts: GlobWalkerOpts, hasWalkedCache?: HasWalkedCache) {\n    this.opts = opts\n    this.follow = !!opts.follow\n    this.dot = !!opts.dot\n    this.hasWalkedCache =\n      hasWalkedCache ? hasWalkedCache.copy() : new HasWalkedCache()\n  }\n\n  processPatterns(target: Path, patterns: Pattern[]) {\n    this.patterns = patterns\n    const processingSet: [Path, Pattern][] = patterns.map(p => [target, p])\n\n    // map of paths to the magic-starting subwalks they need to walk\n    // first item in patterns is the filter\n\n    for (let [t, pattern] of processingSet) {\n      this.hasWalkedCache.storeWalked(t, pattern)\n\n      const root = pattern.root()\n      const absolute = pattern.isAbsolute() && this.opts.absolute !== false\n\n      // start absolute patterns at root\n      if (root) {\n        t = t.resolve(\n          root === '/' && this.opts.root !== undefined ?\n            this.opts.root\n          : root,\n        )\n        const rest = pattern.rest()\n        if (!rest) {\n          this.matches.add(t, true, false)\n          continue\n        } else {\n          pattern = rest\n        }\n      }\n\n      if (t.isENOENT()) continue\n\n      let p: MMPattern\n      let rest: Pattern | null\n      let changed = false\n      while (\n        typeof (p = pattern.pattern()) === 'string' &&\n        (rest = pattern.rest())\n      ) {\n        const c = t.resolve(p)\n        t = c\n        pattern = rest\n        changed = true\n      }\n      p = pattern.pattern()\n      rest = pattern.rest()\n      if (changed) {\n        if (this.hasWalkedCache.hasWalked(t, pattern)) continue\n        this.hasWalkedCache.storeWalked(t, pattern)\n      }\n\n      // now we have either a final string for a known entry,\n      // more strings for an unknown entry,\n      // or a pattern starting with magic, mounted on t.\n      if (typeof p === 'string') {\n        // must not be final entry, otherwise we would have\n        // concatenated it earlier.\n        const ifDir = p === '..' || p === '' || p === '.'\n        this.matches.add(t.resolve(p), absolute, ifDir)\n        continue\n      } else if (p === GLOBSTAR) {\n        // if no rest, match and subwalk pattern\n        // if rest, process rest and subwalk pattern\n        // if it's a symlink, but we didn't get here by way of a\n        // globstar match (meaning it's the first time THIS globstar\n        // has traversed a symlink), then we follow it. Otherwise, stop.\n        if (\n          !t.isSymbolicLink() ||\n          this.follow ||\n          pattern.checkFollowGlobstar()\n        ) {\n          this.subwalks.add(t, pattern)\n        }\n        const rp = rest?.pattern()\n        const rrest = rest?.rest()\n        if (!rest || ((rp === '' || rp === '.') && !rrest)) {\n          // only HAS to be a dir if it ends in **/ or **/.\n          // but ending in ** will match files as well.\n          this.matches.add(t, absolute, rp === '' || rp === '.')\n        } else {\n          if (rp === '..') {\n            // this would mean you're matching **/.. at the fs root,\n            // and no thanks, I'm not gonna test that specific case.\n            /* c8 ignore start */\n            const tp = t.parent || t\n            /* c8 ignore stop */\n            if (!rrest) this.matches.add(tp, absolute, true)\n            else if (!this.hasWalkedCache.hasWalked(tp, rrest)) {\n              this.subwalks.add(tp, rrest)\n            }\n          }\n        }\n      } else if (typeof p === 'object') {\n        this.subwalks.add(t, pattern)\n      }\n    }\n\n    return this\n  }\n\n  subwalkTargets(): Path[] {\n    return this.subwalks.keys()\n  }\n\n  child() {\n    return new Processor(this.opts, this.hasWalkedCache)\n  }\n\n  // return a new Processor containing the subwalks for each\n  // child entry, and a set of matches, and\n  // a hasWalkedCache that's a copy of this one\n  // then we're going to call\n  filterEntries(parent: Path, entries: Path[]): Processor {\n    const patterns = this.subwalks.get(parent)\n    // put matches and entry walks into the results processor\n    const results = this.child()\n    for (const e of entries) {\n      for (const pattern of patterns) {\n        const absolute = pattern.isAbsolute()\n        const p = pattern.pattern()\n        const rest = pattern.rest()\n        if (p === GLOBSTAR) {\n          results.testGlobstar(e, pattern, rest, absolute)\n        } else if (typeof p === 'object') {\n          results.testMatcher(e, p, rest, absolute)\n        } else {\n          results.testString(e, p, rest, absolute)\n        }\n      }\n    }\n    return results\n  }\n\n  testGlobstar(\n    e: Path,\n    pattern: Pattern,\n    rest: Pattern | null,\n    absolute: boolean,\n  ) {\n    if (this.dot || !e.name.startsWith('.')) {\n      if (!pattern.hasMore()) {\n        this.matches.add(e, absolute, false)\n      }\n      if (e.canReaddir()) {\n        // if we're in follow mode or it's not a symlink, just keep\n        // testing the same pattern. If there's more after the globstar,\n        // then this symlink consumes the globstar. If not, then we can\n        // follow at most ONE symlink along the way, so we mark it, which\n        // also checks to ensure that it wasn't already marked.\n        if (this.follow || !e.isSymbolicLink()) {\n          this.subwalks.add(e, pattern)\n        } else if (e.isSymbolicLink()) {\n          if (rest && pattern.checkFollowGlobstar()) {\n            this.subwalks.add(e, rest)\n          } else if (pattern.markFollowGlobstar()) {\n            this.subwalks.add(e, pattern)\n          }\n        }\n      }\n    }\n    // if the NEXT thing matches this entry, then also add\n    // the rest.\n    if (rest) {\n      const rp = rest.pattern()\n      if (\n        typeof rp === 'string' &&\n        // dots and empty were handled already\n        rp !== '..' &&\n        rp !== '' &&\n        rp !== '.'\n      ) {\n        this.testString(e, rp, rest.rest(), absolute)\n      } else if (rp === '..') {\n        /* c8 ignore start */\n        const ep = e.parent || e\n        /* c8 ignore stop */\n        this.subwalks.add(ep, rest)\n      } else if (typeof rp === 'object') {\n        this.testMatcher(e, rp, rest.rest(), absolute)\n      }\n    }\n  }\n\n  testMatcher(\n    e: Path,\n    p: MMMatcher,\n    rest: Pattern | null,\n    absolute: boolean,\n  ) {\n    // an entry name is one path portion, with no `/`\n    if (!p.testUnchecked(e.name)) return\n    if (!rest) {\n      this.matches.add(e, absolute, false)\n    } else {\n      this.subwalks.add(e, rest)\n    }\n  }\n\n  testString(e: Path, p: string, rest: Pattern | null, absolute: boolean) {\n    // should never happen?\n    if (!e.isNamed(p)) return\n    if (!rest) {\n      this.matches.add(e, absolute, false)\n    } else {\n      this.subwalks.add(e, rest)\n    }\n  }\n}\n", "/**\n * Single-use utility classes to provide functionality to the {@link Glob}\n * methods.\n *\n * @module\n */\nimport { Minipass } from 'minipass'\nimport type { Form } from 'minimatch'\nimport type { Path } from 'path-scurry'\nimport type { IgnoreLike } from './ignore.js'\nimport { Ignore } from './ignore.js'\n\n// XXX can we somehow make it so that it NEVER processes a given path more than\n// once, enough that the match set tracking is no longer needed?  that'd speed\n// things up a lot.  Or maybe bring back nounique, and skip it in that case?\n\n// a single minimatch set entry with 1 or more parts\nimport type { Pattern } from './pattern.js'\nimport { MatchRecord, Processor } from './processor.js'\n\nconst { ABSOLUTE, IF_DIR } = MatchRecord\n\nexport interface GlobWalkerOpts {\n  absolute?: boolean\n  allowWindowsEscape?: boolean\n  cwd?: string | URL\n  dot?: boolean\n  dotRelative?: boolean\n  follow?: boolean\n  ignore?: string | string[] | IgnoreLike | ReadonlyArray<string>\n  mark?: boolean\n  matchBase?: boolean\n  // Note: maxDepth here means \"maximum actual Path.depth()\",\n  // not \"maximum depth beyond cwd\"\n  maxDepth?: number\n  nobrace?: boolean\n  nocase?: boolean\n  nodir?: boolean\n  noext?: boolean\n  noglobstar?: boolean\n  normalize?: boolean | Form\n  platform?: NodeJS.Platform\n  posix?: boolean\n  realpath?: boolean\n  root?: string\n  stat?: boolean\n  signal?: AbortSignal\n  windowsPathsNoEscape?: boolean\n  withFileTypes?: boolean\n  includeChildMatches?: boolean\n}\n\nexport type GWOFileTypesTrue = GlobWalkerOpts & {\n  withFileTypes: true\n}\nexport type GWOFileTypesFalse = GlobWalkerOpts & {\n  withFileTypes: false\n}\nexport type GWOFileTypesUnset = GlobWalkerOpts & {\n  withFileTypes?: undefined\n}\n\nexport type Result<O extends GlobWalkerOpts> =\n  O extends GWOFileTypesTrue ? Path\n  : O extends GWOFileTypesFalse ? string\n  : O extends GWOFileTypesUnset ? string\n  : Path | string\n\nexport type Matches<O extends GlobWalkerOpts> =\n  O extends GWOFileTypesTrue ? Path[]\n  : O extends GWOFileTypesFalse ? string[]\n  : O extends GWOFileTypesUnset ? string[]\n  : (Path | string)[]\n\nexport type MatchStream<O extends GlobWalkerOpts> = Minipass<\n  Result<O>,\n  Result<O>\n>\n\nconst makeIgnore = (\n  ignore: string | string[] | IgnoreLike | ReadonlyArray<string>,\n  opts: GlobWalkerOpts,\n  cwd: Path,\n): IgnoreLike =>\n  typeof ignore === 'string' ? new Ignore([ignore], opts, cwd)\n  : Array.isArray(ignore) ? new Ignore(ignore, opts, cwd)\n  : (ignore as IgnoreLike)\n\n/**\n * basic walking utilities that all the glob walker types use\n */\nexport abstract class GlobUtil<O extends GlobWalkerOpts = GlobWalkerOpts> {\n  path: Path\n  patterns: Pattern[]\n  opts: O\n  seen: Set<Path> = new Set<Path>()\n  paused: boolean = false\n  aborted: boolean = false\n  #onResume: (() => unknown)[] = []\n  #ignore?: IgnoreLike\n  #sep: '\\\\' | '/'\n  signal?: AbortSignal\n  maxDepth: number\n  includeChildMatches: boolean\n\n  constructor(patterns: Pattern[], path: Path, opts: O)\n  constructor(patterns: Pattern[], path: Path, opts: O) {\n    this.patterns = patterns\n    this.path = path\n    this.opts = opts\n    this.#sep = !opts.posix && opts.platform === 'win32' ? '\\\\' : '/'\n    this.includeChildMatches = opts.includeChildMatches !== false\n    if (opts.ignore || !this.includeChildMatches) {\n      this.#ignore = makeIgnore(opts.ignore ?? [], opts, path)\n      if (\n        !this.includeChildMatches &&\n        typeof this.#ignore.add !== 'function'\n      ) {\n        const m = 'cannot ignore child matches, ignore lacks add() method.'\n        throw new Error(m)\n      }\n    }\n    // ignore, always set with maxDepth, but it's optional on the\n    // GlobOptions type\n    /* c8 ignore start */\n    this.maxDepth = opts.maxDepth || Infinity\n    /* c8 ignore stop */\n    if (opts.signal) {\n      this.signal = opts.signal\n      this.signal.addEventListener('abort', () => {\n        this.#onResume.length = 0\n      })\n    }\n  }\n\n  #ignored(path: Path): boolean {\n    return this.seen.has(path) || !!this.#ignore?.ignored?.(path)\n  }\n  #childrenIgnored(path: Path): boolean {\n    return !!this.#ignore?.childrenIgnored?.(path)\n  }\n\n  // backpressure mechanism\n  pause() {\n    this.paused = true\n  }\n  resume() {\n    /* c8 ignore start */\n    if (this.signal?.aborted) return\n    /* c8 ignore stop */\n    this.paused = false\n    let fn: (() => unknown) | undefined = undefined\n    while (!this.paused && (fn = this.#onResume.shift())) {\n      fn()\n    }\n  }\n  onResume(fn: () => unknown) {\n    /* c8 ignore start */\n    if (!this.paused) {\n      fn()\n    } else {\n      /* c8 ignore stop */\n      this.#onResume.push(fn)\n    }\n  }\n\n  // do the requisite realpath/stat checking, and return the path\n  // to add or undefined to filter it out.\n  async matchCheck(\n    inPath: Path,\n    ifDir: boolean,\n  ): Promise<Path | undefined> {\n    if (ifDir && this.opts.nodir) return undefined\n    let rpc: Path | undefined\n    let e: Path\n    if (this.opts.realpath) {\n      rpc = inPath.realpathCached() || (await inPath.realpath())\n      if (!rpc) return undefined\n      e = rpc\n    } else {\n      e = inPath\n    }\n    const needStat = e.isUnknown() || this.opts.stat\n    const s = needStat ? await e.lstat() : e\n    if (this.opts.follow && this.opts.nodir && s?.isSymbolicLink()) {\n      const target = await s.realpath()\n      /* c8 ignore start */\n      if (target && (target.isUnknown() || this.opts.stat)) {\n        await target.lstat()\n      }\n      /* c8 ignore stop */\n    }\n    return this.matchCheckTest(s, ifDir)\n  }\n\n  matchCheckTest(e: Path | undefined, ifDir: boolean): Path | undefined {\n    return (\n        e &&\n          (this.maxDepth === Infinity || e.depth() <= this.maxDepth) &&\n          (!ifDir || e.canReaddir()) &&\n          (!this.opts.nodir || !e.isDirectory()) &&\n          (!this.opts.nodir ||\n            !this.opts.follow ||\n            !e.isSymbolicLink() ||\n            !e.realpathCached()?.isDirectory()) &&\n          !this.#ignored(e)\n      ) ?\n        e\n      : undefined\n  }\n\n  matchCheckSync(inPath: Path, ifDir: boolean): Path | undefined {\n    if (ifDir && this.opts.nodir) return undefined\n    let rpc: Path | undefined\n    let e: Path\n    if (this.opts.realpath) {\n      rpc = inPath.realpathCached() || inPath.realpathSync()\n      if (!rpc) return undefined\n      e = rpc\n    } else {\n      e = inPath\n    }\n    const needStat = e.isUnknown() || this.opts.stat\n    const s = needStat ? e.lstatSync() : e\n    if (this.opts.follow && this.opts.nodir && s?.isSymbolicLink()) {\n      const target = s.realpathSync()\n      if (target && (target?.isUnknown() || this.opts.stat)) {\n        target.lstatSync()\n      }\n    }\n    return this.matchCheckTest(s, ifDir)\n  }\n\n  abstract matchEmit(p: Result<O>): void\n  abstract matchEmit(p: string | Path): void\n\n  matchFinish(e: Path, absolute: boolean) {\n    if (this.#ignored(e)) return\n    this.#matchEmitChecked(e, absolute)\n  }\n\n  // emit a match that is known to not be seen or ignored yet\n  #matchEmitChecked(e: Path, absolute: boolean) {\n    // we know we have an ignore if this is false, but TS doesn't\n    if (!this.includeChildMatches && this.#ignore?.add) {\n      const ign = `${e.relativePosix()}/**`\n      this.#ignore.add(ign)\n    }\n    const abs =\n      this.opts.absolute === undefined ? absolute : this.opts.absolute\n    this.seen.add(e)\n    const mark = this.opts.mark && e.isDirectory() ? this.#sep : ''\n    // ok, we have what we need!\n    if (this.opts.withFileTypes) {\n      this.matchEmit(e)\n    } else if (abs) {\n      const abs = this.opts.posix ? e.fullpathPosix() : e.fullpath()\n      this.matchEmit(abs + mark)\n    } else {\n      const rel = this.opts.posix ? e.relativePosix() : e.relative()\n      const pre =\n        this.opts.dotRelative && !rel.startsWith(`..${this.#sep}`) ?\n          `.${this.#sep}`\n        : ''\n      this.matchEmit(!rel ? `.${mark}` : pre + rel + mark)\n    }\n  }\n\n  async match(e: Path, absolute: boolean, ifDir: boolean): Promise<void> {\n    const p = await this.matchCheck(e, ifDir)\n    if (p) this.matchFinish(p, absolute)\n  }\n\n  matchSync(e: Path, absolute: boolean, ifDir: boolean): void {\n    // matchCheckSync just checked that it is not seen or ignored, and\n    // nothing can have changed since\n    const p = this.matchCheckSync(e, ifDir)\n    if (p) this.#matchEmitChecked(p, absolute)\n  }\n\n  walkCB(target: Path, patterns: Pattern[], cb: () => unknown) {\n    /* c8 ignore start */\n    if (this.signal?.aborted) return cb()\n    /* c8 ignore stop */\n    this.walkCB2(target, patterns, new Processor(this.opts), cb)\n  }\n\n  walkCB2(\n    target: Path,\n    patterns: Pattern[],\n    processor: Processor,\n    cb: () => unknown,\n  ) {\n    if (this.#childrenIgnored(target)) return cb()\n    if (this.signal?.aborted) return cb()\n    if (this.paused) {\n      this.onResume(() => this.walkCB2(target, patterns, processor, cb))\n      return\n    }\n    processor.processPatterns(target, patterns)\n\n    // done processing.  all of the above is sync, can be abstracted out.\n    // subwalks is a map of paths to the entry filters they need\n    // matches is a map of paths to [absolute, ifDir] tuples.\n    let tasks = 1\n    const next = () => {\n      if (--tasks === 0) cb()\n    }\n\n    for (const [m, n] of processor.matches.store) {\n      if (this.#ignored(m)) continue\n      tasks++\n      void this.match(m, !!(n & ABSOLUTE), !!(n & IF_DIR)).then(() =>\n        next(),\n      )\n    }\n\n    for (const t of processor.subwalkTargets()) {\n      if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {\n        continue\n      }\n      tasks++\n      const childrenCached = t.readdirCached()\n      if (t.calledReaddir())\n        this.walkCB3(t, childrenCached, processor, next)\n      else {\n        t.readdirCB(\n          (_, entries) => this.walkCB3(t, entries, processor, next),\n          true,\n        )\n      }\n    }\n\n    next()\n  }\n\n  walkCB3(\n    target: Path,\n    entries: Path[],\n    processorx: Processor,\n    cb: () => unknown,\n  ) {\n    const proc = processorx.filterEntries(target, entries)\n\n    let tasks = 1\n    const next = () => {\n      if (--tasks === 0) cb()\n    }\n\n    for (const [m, n] of proc.matches.store) {\n      if (this.#ignored(m)) continue\n      tasks++\n      void this.match(m, !!(n & ABSOLUTE), !!(n & IF_DIR)).then(() =>\n        next(),\n      )\n    }\n    for (const [target, patterns] of proc.subwalks.entries()) {\n      tasks++\n      this.walkCB2(target, patterns, proc.child(), next)\n    }\n\n    next()\n  }\n\n  walkCBSync(target: Path, patterns: Pattern[], cb: () => unknown) {\n    /* c8 ignore start */\n    if (this.signal?.aborted) return cb()\n    /* c8 ignore stop */\n    this.walkCB2Sync(target, patterns, new Processor(this.opts), cb)\n  }\n\n  walkCB2Sync(\n    target: Path,\n    patterns: Pattern[],\n    processor: Processor,\n    cb: () => unknown,\n  ) {\n    if (this.#childrenIgnored(target)) return cb()\n    if (this.signal?.aborted) return cb()\n    if (this.paused) {\n      this.onResume(() =>\n        this.walkCB2Sync(target, patterns, processor, cb),\n      )\n      return\n    }\n    processor.processPatterns(target, patterns)\n\n    // done processing.  all of the above is sync, can be abstracted out.\n    // subwalks is a map of paths to the entry filters they need\n    // matches is a map of paths to [absolute, ifDir] tuples.\n    let tasks = 1\n    const next = () => {\n      if (--tasks === 0) cb()\n    }\n\n    for (const [m, n] of processor.matches.store) {\n      if (this.#ignored(m)) continue\n      this.matchSync(m, !!(n & ABSOLUTE), !!(n & IF_DIR))\n    }\n\n    for (const t of processor.subwalkTargets()) {\n      if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {\n        continue\n      }\n      tasks++\n      const children = t.readdirSync()\n      this.walkCB3Sync(t, children, processor, next)\n    }\n\n    next()\n  }\n\n  walkCB3Sync(\n    target: Path,\n    entries: Path[],\n    processor: Processor,\n    cb: () => unknown,\n  ) {\n    const proc = processor.filterEntries(target, entries)\n\n    let tasks = 1\n    const next = () => {\n      if (--tasks === 0) cb()\n    }\n\n    for (const [m, n] of proc.matches.store) {\n      if (this.#ignored(m)) continue\n      this.matchSync(m, !!(n & ABSOLUTE), !!(n & IF_DIR))\n    }\n    for (const [target, patterns] of proc.subwalks.entries()) {\n      tasks++\n      this.walkCB2Sync(target, patterns, proc.child(), next)\n    }\n\n    next()\n  }\n}\n\nexport class GlobWalker<\n  O extends GlobWalkerOpts = GlobWalkerOpts,\n> extends GlobUtil<O> {\n  // each Path is only emitted once (see GlobUtil.seen), so the results\n  // do not need to be deduped\n  matches: Result<O>[] = []\n\n  constructor(patterns: Pattern[], path: Path, opts: O) {\n    super(patterns, path, opts)\n  }\n\n  matchEmit(e: Result<O>): void {\n    this.matches.push(e)\n  }\n\n  async walk(): Promise<Result<O>[]> {\n    if (this.signal?.aborted) throw this.signal.reason\n    if (this.path.isUnknown()) {\n      await this.path.lstat()\n    }\n    await new Promise((res, rej) => {\n      this.walkCB(this.path, this.patterns, () => {\n        if (this.signal?.aborted) {\n          rej(this.signal.reason)\n        } else {\n          res(this.matches)\n        }\n      })\n    })\n    return this.matches\n  }\n\n  walkSync(): Result<O>[] {\n    if (this.signal?.aborted) throw this.signal.reason\n    if (this.path.isUnknown()) {\n      this.path.lstatSync()\n    }\n    // nothing for the callback to do, because this never pauses\n    this.walkCBSync(this.path, this.patterns, () => {\n      if (this.signal?.aborted) throw this.signal.reason\n    })\n    return this.matches\n  }\n}\n\nexport class GlobStream<\n  O extends GlobWalkerOpts = GlobWalkerOpts,\n> extends GlobUtil<O> {\n  results: Minipass<Result<O>, Result<O>>\n\n  constructor(patterns: Pattern[], path: Path, opts: O) {\n    super(patterns, path, opts)\n    this.results = new Minipass<Result<O>, Result<O>>({\n      signal: this.signal,\n      objectMode: true,\n    })\n    this.results.on('drain', () => this.resume())\n    this.results.on('resume', () => this.resume())\n  }\n\n  matchEmit(e: Result<O>): void {\n    this.results.write(e)\n    if (!this.results.flowing) this.pause()\n  }\n\n  stream(): MatchStream<O> {\n    const target = this.path\n    if (target.isUnknown()) {\n      void target.lstat().then(() => {\n        this.walkCB(target, this.patterns, () => this.results.end())\n      })\n    } else {\n      this.walkCB(target, this.patterns, () => this.results.end())\n    }\n    return this.results\n  }\n\n  streamSync(): MatchStream<O> {\n    if (this.path.isUnknown()) {\n      this.path.lstatSync()\n    }\n    this.walkCBSync(this.path, this.patterns, () => this.results.end())\n    return this.results\n  }\n}\n", "import { Minimatch } from 'minimatch'\nimport type { GlobOptions } from './glob.js'\n\n/**\n * Return true if the patterns provided contain any magic glob characters,\n * given the options provided.\n *\n * Brace expansion is not considered \"magic\" unless the `magicalBraces` option\n * is set, as brace expansion just turns one string into an array of strings.\n * So a pattern like `'x{a,b}y'` would return `false`, because `'xay'` and\n * `'xby'` both do not contain any magic glob characters, and it's treated the\n * same as if you had called it on `['xay', 'xby']`. When `magicalBraces:true`\n * is in the options, brace expansion _is_ treated as a pattern having magic.\n */\nexport const hasMagic = (\n  pattern: string | string[],\n  options: GlobOptions = {},\n): boolean => {\n  for (const p of Array.isArray(pattern) ? pattern : [pattern]) {\n    if (new Minimatch(p, options).hasMagic()) return true\n  }\n  return false\n}\n", "import { escape, unescape } from 'minimatch'\nimport type { Minipass } from 'minipass'\nimport type { Path } from 'path-scurry'\nimport type {\n  GlobOptions,\n  GlobOptionsWithFileTypesFalse,\n  GlobOptionsWithFileTypesTrue,\n  GlobOptionsWithFileTypesUnset,\n} from './glob.js'\nimport { Glob } from './glob.js'\nimport { hasMagic } from './has-magic.js'\n\nexport { escape, unescape } from 'minimatch'\nexport type { Form } from 'minimatch'\nexport type {\n  FSOption,\n  Path,\n  WalkOptions,\n  WalkOptionsWithFileTypesTrue,\n  WalkOptionsWithFileTypesUnset,\n} from 'path-scurry'\nexport { Glob } from './glob.js'\nexport type {\n  GlobOptions,\n  GlobOptionsWithFileTypesFalse,\n  GlobOptionsWithFileTypesTrue,\n  GlobOptionsWithFileTypesUnset,\n} from './glob.js'\nexport { hasMagic } from './has-magic.js'\nexport { Ignore } from './ignore.js'\nexport type { IgnoreLike } from './ignore.js'\nexport type { MatchStream } from './walker.js'\n\n/**\n * Syncronous form of {@link globStream}. Will read all the matches as fast as\n * you consume them, even all in a single tick if you consume them immediately,\n * but will still respond to backpressure if they're not consumed immediately.\n */\nexport function globStreamSync(\n  pattern: string | string[],\n  options: GlobOptionsWithFileTypesTrue,\n): Minipass<Path, Path>\nexport function globStreamSync(\n  pattern: string | string[],\n  options: GlobOptionsWithFileTypesFalse,\n): Minipass<string, string>\nexport function globStreamSync(\n  pattern: string | string[],\n  options: GlobOptionsWithFileTypesUnset,\n): Minipass<string, string>\nexport function globStreamSync(\n  pattern: string | string[],\n  options: GlobOptions,\n): Minipass<Path, Path> | Minipass<string, string>\nexport function globStreamSync(\n  pattern: string | string[],\n  options: GlobOptions = {},\n) {\n  return new Glob(pattern, options).streamSync()\n}\n\n/**\n * Return a stream that emits all the strings or `Path` objects and\n * then emits `end` when completed.\n */\nexport function globStream(\n  pattern: string | string[],\n  options: GlobOptionsWithFileTypesFalse,\n): Minipass<string, string>\nexport function globStream(\n  pattern: string | string[],\n  options: GlobOptionsWithFileTypesTrue,\n): Minipass<Path, Path>\nexport function globStream(\n  pattern: string | string[],\n  options?: GlobOptionsWithFileTypesUnset | undefined,\n): Minipass<string, string>\nexport function globStream(\n  pattern: string | string[],\n  options: GlobOptions,\n): Minipass<Path, Path> | Minipass<string, string>\nexport function globStream(\n  pattern: string | string[],\n  options: GlobOptions = {},\n) {\n  return new Glob(pattern, options).stream()\n}\n\n/**\n * Synchronous form of {@link glob}\n */\nexport function globSync(\n  pattern: string | string[],\n  options: GlobOptionsWithFileTypesFalse,\n): string[]\nexport function globSync(\n  pattern: string | string[],\n  options: GlobOptionsWithFileTypesTrue,\n): Path[]\nexport function globSync(\n  pattern: string | string[],\n  options?: GlobOptionsWithFileTypesUnset | undefined,\n): string[]\nexport function globSync(\n  pattern: string | string[],\n  options: GlobOptions,\n): Path[] | string[]\nexport function globSync(\n  pattern: string | string[],\n  options: GlobOptions = {},\n) {\n  return new Glob(pattern, options).walkSync()\n}\n\n/**\n * Perform an asynchronous glob search for the pattern(s) specified. Returns\n * [Path](https://isaacs.github.io/path-scurry/classes/PathBase) objects if the\n * {@link withFileTypes} option is set to `true`. See {@link GlobOptions} for\n * full option descriptions.\n */\nasync function glob_(\n  pattern: string | string[],\n  options?: GlobOptionsWithFileTypesUnset | undefined,\n): Promise<string[]>\nasync function glob_(\n  pattern: string | string[],\n  options: GlobOptionsWithFileTypesTrue,\n): Promise<Path[]>\nasync function glob_(\n  pattern: string | string[],\n  options: GlobOptionsWithFileTypesFalse,\n): Promise<string[]>\nasync function glob_(\n  pattern: string | string[],\n  options: GlobOptions,\n): Promise<Path[] | string[]>\nasync function glob_(\n  pattern: string | string[],\n  options: GlobOptions = {},\n) {\n  return new Glob(pattern, options).walk()\n}\n\n/**\n * Return a sync iterator for walking glob pattern matches.\n */\nexport function globIterateSync(\n  pattern: string | string[],\n  options?: GlobOptionsWithFileTypesUnset | undefined,\n): Generator<string, void, void>\nexport function globIterateSync(\n  pattern: string | string[],\n  options: GlobOptionsWithFileTypesTrue,\n): Generator<Path, void, void>\nexport function globIterateSync(\n  pattern: string | string[],\n  options: GlobOptionsWithFileTypesFalse,\n): Generator<string, void, void>\nexport function globIterateSync(\n  pattern: string | string[],\n  options: GlobOptions,\n): Generator<Path, void, void> | Generator<string, void, void>\nexport function globIterateSync(\n  pattern: string | string[],\n  options: GlobOptions = {},\n) {\n  return new Glob(pattern, options).iterateSync()\n}\n\n/**\n * Return an async iterator for walking glob pattern matches.\n */\nexport function globIterate(\n  pattern: string | string[],\n  options?: GlobOptionsWithFileTypesUnset | undefined,\n): AsyncGenerator<string, void, void>\nexport function globIterate(\n  pattern: string | string[],\n  options: GlobOptionsWithFileTypesTrue,\n): AsyncGenerator<Path, void, void>\nexport function globIterate(\n  pattern: string | string[],\n  options: GlobOptionsWithFileTypesFalse,\n): AsyncGenerator<string, void, void>\nexport function globIterate(\n  pattern: string | string[],\n  options: GlobOptions,\n): AsyncGenerator<Path, void, void> | AsyncGenerator<string, void, void>\nexport function globIterate(\n  pattern: string | string[],\n  options: GlobOptions = {},\n) {\n  return new Glob(pattern, options).iterate()\n}\n\n// aliases: glob.sync.stream() glob.stream.sync() glob.sync() etc\nexport const streamSync = globStreamSync\nexport const stream = Object.assign(globStream, { sync: globStreamSync })\nexport const iterateSync = globIterateSync\nexport const iterate = Object.assign(globIterate, {\n  sync: globIterateSync,\n})\nexport const sync = Object.assign(globSync, {\n  stream: globStreamSync,\n  iterate: globIterateSync,\n})\n\nexport const glob = Object.assign(glob_, {\n  glob: glob_,\n  globSync,\n  sync,\n  globStream,\n  stream,\n  globStreamSync,\n  streamSync,\n  globIterate,\n  iterate,\n  globIterateSync,\n  iterateSync,\n  Glob,\n  hasMagic,\n  escape,\n  unescape,\n})\nglob.glob = glob\n"],
+  "mappings": "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",
+  "names": ["balanced", "a", "b", "str", "ma", "maybeMatch", "mb", "r", "range", "reg", "m", "begs", "beg", "left", "right", "result", "ai", "bi", "i", "escSlash", "escOpen", "escClose", "escComma", "escPeriod", "escSlashPattern", "escOpenPattern", "escClosePattern", "escCommaPattern", "escPeriodPattern", "slashPattern", "openPattern", "closePattern", "commaPattern", "periodPattern", "EXPANSION_MAX", "EXPANSION_MAX_LENGTH", "EXPANSION_MAX_DEPTH", "EXPANSION_MAX_REWRITES", "numeric", "str", "escapeBraces", "unescapeBraces", "pushAll", "target", "items", "i", "parseCommaParts", "parts", "carry", "m", "balanced", "tail", "pre", "body", "post", "p", "expand", "options", "max", "maxLength", "maxDepth", "maxRewrites", "expand_", "embrace", "isPadded", "el", "lte", "y", "gte", "combine", "acc", "values", "dropEmpties", "out", "length", "a", "v", "expansion", "expandSequence", "isAlphaSequence", "n", "N", "x", "width", "incr", "test", "pad", "c", "need", "z", "depth", "isTop", "rewrites", "firstGroup", "isNumericSequence", "isSequence", "isOptions", "dropsEmpties", "d", "valuesLength", "outer", "j", "expanded", "k", "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", "MATCH", "extTypes", "lit", "ch", "reEscape", "s", "foldRe", "litMatch", "l", "c", "code", "ascii", "tokenize", "p", "nocase", "noext", "form", "toks", "i", "e", "re", "consumed", "parseClass", "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", "#literalRe", "#linear", "#wild", "#min", "#max", "#prefix", "#suffix", "#prefixStr", "#suffixStr", "#affix", "#dfa", "#form", "pattern", "options", "literal", "#test", "most", "least", "prefix", "sim", "dfa", "str", "assertValidPattern", "pattern", "escape", "s", "windowsPathsNoEscape", "magicalBraces", "unescape", "s", "windowsPathsNoEscape", "magicalBraces", "minimatch", "p", "pattern", "options", "assertValidPattern", "Minimatch", "defaultPlatform", "path", "sep", "GLOBSTAR", "filter", "ext", "a", "b", "defaults", "def", "orig", "list", "braceExpand", "expand", "match", "mm", "f", "globMagic", "classEnd", "start", "i", "sawStart", "c", "literal", "noext", "lit", "close", "body", "extSafe", "depth", "lastSplit", "lastChecked", "portionMatch", "endIndex", "last", "lastStart", "prev", "prevStart", "isDots", "isDrive", "isLongUNC", "uncHost", "h", "host", "share", "walkable", "dot", "dotPortion", "end", "k", "n", "isSep", "s", "nextSep", "from", "lastSep", "#endCheck", "#literalCheck", "#level2", "#form", "#literals", "#shapes", "#endRows", "#matchers", "#globstarParts", "awe", "drives", "row", "#rootIndex", "r", "lits", "l", "p0", "p1", "p2", "#norm", "part", "rawGlobParts", "#slashSplit", "set", "_", "__", "isUNC", "ss", "merged", "len", "groups", "Matcher", "parts", "key", "g", "drop", "first", "rest", "glob", "globParts", "partset", "j", "optimizationLevel", "gs", "root", "#canMatch", "ends", "ROWS", "resolves", "tailStart", "shape", "m", "#walk", "#matchShape", "file", "x", "t", "head", "e", "next", "#cachedSplit", "#split", "isWindows", "preserveMultipleSlashes", "normalize", "#levelTwoFileOptimize", "didSomething", "dd", "braceExpandMax", "gss", "other", "splin", "matched", "emptyGSMatch", "ai", "bi", "result", "which", "negate", "negateOffset", "#matchRow", "resolved", "partial", "fileStartIndex", "patternStartIndex", "fh", "ph", "fileDrive", "fileUNC", "patternDrive", "patternUNC", "fdi", "pdi", "fd", "pd", "#matchGlobstar", "#matchOne", "fileIndex", "patternIndex", "tail", "segments", "#getGlobstarParts", "headEnd", "fileTailMatch", "sawSome", "#matchGlobStarBodySections", "byStart", "found", "firstgs", "lastgs", "current", "nonGsParts", "nonGsPartsSums", "bodySegments", "fileLength", "bodyIndex", "globStarDepth", "sawTail", "tried", "bs", "need", "after", "sub", "fileEnd", "fi", "pi", "pl", "fl", "nocase", "nocaseMagicOnly", "split", "can", "ff", "filename", "escape", "unescape", "fileURLToPath", "tracingChannel", "channel", "metrics", "tracing", "defaultPerf", "hasSubscribers", "warned", "PROCESS", "emitWarning", "msg", "type", "code", "fn", "shouldWarn", "isPosInt", "n", "getUintArray", "max", "ZeroArray", "size", "Stack", "_Stack", "#constructing", "HeapCls", "s", "LRUCache", "_LRUCache", "#max", "#maxSize", "#dispose", "#onInsert", "#disposeAfter", "#fetchMethod", "#memoMethod", "#perf", "#size", "#calculatedSize", "#keyMap", "#keyList", "#valList", "#next", "#prev", "#head", "#tail", "#free", "#disposed", "#sizes", "#starts", "#ttls", "#autopurgeTimers", "#hasDispose", "#hasFetchMethod", "#hasDisposeAfter", "#hasOnInsert", "c", "p", "#isBackgroundFetch", "k", "index", "options", "context", "#backgroundFetch", "#moveToTail", "#indexes", "#rindexes", "#isStale", "ttl", "ttlResolution", "ttlAutopurge", "updateAgeOnGet", "updateAgeOnHas", "allowStale", "dispose", "onInsert", "disposeAfter", "noDisposeOnSet", "noUpdateTTL", "maxSize", "maxEntrySize", "sizeCalculation", "fetchMethod", "memoMethod", "noDeleteOnFetchRejection", "noDeleteOnStaleGet", "allowStaleOnFetchRejection", "allowStaleOnFetchAbort", "ignoreFetchAbort", "backgroundFetchSize", "perf", "UintArray", "#initializeSizeTracking", "#initializeTTLTracking", "key", "ttls", "starts", "purgeTimers", "#setItemTTL", "start", "setPurgeTimer", "#updateItemAge", "t", "#delete", "getRemainingTTL", "#statusTTL", "status", "cachedNow", "getNow", "age", "sizes", "#removeItemSize", "#requireSize", "v", "#addItemSize", "#evict", "_i", "_s", "_st", "_k", "_v", "i", "#isValidIndex", "getOptions", "value", "#get", "thisp", "deleted", "entry", "remain", "arr", "#set", "setOptions", "result", "bf", "isBF", "oldVal", "oldValue", "setType", "dt", "task", "val", "free", "head", "hasOptions", "#has", "peekOptions", "#peek", "ac", "signal", "fetchOpts", "cb", "updateCache", "aborted", "ignoreAbort", "proceed", "fetchFail", "vl", "eb", "er", "allowStaleAborted", "noDelete", "pcall", "res", "rej", "fmp", "b", "fetchOptions", "ths", "#fetch", "forceRefresh", "stale", "isStale", "staleVal", "#forceFetch", "memoOptions", "#memo", "refresh", "vv", "fetching", "#connect", "reason", "#clear", "pi", "ni", "posix", "win32", "fileURLToPath", "lstatSync", "readdirCB", "readdirSync", "readlinkSync", "rps", "actualFS", "lstat", "readdir", "readlink", "realpath", "EventEmitter", "Stream", "StringDecoder", "proc", "isStream", "s", "Minipass", "isReadable", "isWritable", "EOF", "MAYBE_EMIT_END", "EMITTED_END", "EMITTING_END", "EMITTED_ERROR", "CLOSED", "READ", "FLUSH", "FLUSHCHUNK", "ENCODING", "DECODER", "FLOWING", "PAUSED", "RESUME", "BUFFER", "PIPES", "BUFFERLENGTH", "BUFFERPUSH", "BUFFERSHIFT", "OBJECTMODE", "DESTROYED", "ERROR", "EMITDATA", "EMITEND", "EMITEND2", "ASYNC", "ABORT", "ABORTED", "SIGNAL", "DATALISTENERS", "DISCARDED", "defer", "fn", "nodefer", "isEndish", "ev", "isArrayBufferLike", "b", "isArrayBufferView", "Pipe", "src", "dest", "opts", "_er", "PipeProxyErrors", "er", "isObjectModeOptions", "o", "isEncodingOptions", "args", "options", "signal", "_enc", "_om", "a", "_", "chunk", "encoding", "cb", "n", "ret", "c", "noDrain", "ended", "p", "handler", "h", "data", "buf", "resolve", "reject", "stopped", "stop", "res", "onerr", "ondata", "onend", "ondestroy", "value", "rej", "next", "wc", "realpathSync", "rps", "defaultFS", "lstatSync", "readdirCB", "readdirSync", "readlinkSync", "lstat", "readdir", "readlink", "realpath", "fsFromOption", "fsOption", "actualFS", "uncDriveRegexp", "uncLongRegexp", "uncShareRegexp", "uncToDrive", "rootPath", "longUncRoot", "longDrivePrefix", "longUncPrefix", "eitherSep", "UNKNOWN", "IFIFO", "IFCHR", "IFDIR", "IFBLK", "IFREG", "IFLNK", "IFSOCK", "IFMT", "IFMT_UNKNOWN", "READDIR_CALLED", "LSTAT_CALLED", "ENOTDIR", "ENOENT", "ENOREADLINK", "ENOREALPATH", "ENOCHILD", "TYPEMASK", "entToType", "s", "normalizeCache", "I", "normalize", "c", "n", "normalizeNocaseCache", "normalizeNocase", "ResolveCache", "ChildrenCache", "maxSize", "a", "setAsCwd", "PathBase", "#fs", "#dev", "#mode", "#nlink", "#uid", "#gid", "#rdev", "#blksize", "#ino", "#size", "#blocks", "#atimeMs", "#mtimeMs", "#ctimeMs", "#birthtimeMs", "#atime", "#mtime", "#ctime", "#birthtime", "#matchName", "#depth", "#fullpath", "#fullpathPosix", "#relative", "#relativePosix", "#type", "#children", "#linkTarget", "#realpath", "name", "type", "root", "roots", "nocase", "children", "opts", "path", "dirParts", "#resolveParts", "p", "part", "cached", "pathPart", "fullpath", "pchild", "pv", "fp", "pfpp", "fpp", "ifmt", "target", "read", "linkTarget", "er", "#readlinkFail", "#readdirSuccess", "#markENOENT", "#markChildrenENOENT", "#markENOREALPATH", "#markENOTDIR", "#readdirFail", "code", "#lstatFail", "ter", "#readdirAddChild", "e", "#readdirMaybePromoteChild", "#readdirAddNewChild", "child", "#readdirPromoteChild", "index", "v", "#applyStat", "st", "atime", "atimeMs", "birthtime", "birthtimeMs", "blksize", "blocks", "ctime", "ctimeMs", "dev", "gid", "ino", "mode", "mtime", "mtimeMs", "nlink", "rdev", "size", "uid", "#onReaddirCB", "#readdirCBInFlight", "#callOnReaddirCB", "cbs", "cb", "allowZalgo", "entries", "#asyncReaddirInFlight", "resolve", "res", "dirs", "walkFilter", "rp", "oldCwd", "changed", "PathWin32", "_PathWin32", "win32", "compare", "PathScurryWin32", "PathPosix", "_PathPosix", "_rootPath", "PathScurryBase", "#resolveCache", "#resolvePosixCache", "cwd", "pathImpl", "sep", "childrenCacheSize", "fs", "fileURLToPath", "cwdPath", "split", "prev", "len", "joinSep", "abs", "sawFirst", "l", "paths", "r", "i", "result", "entry", "withFileTypes", "follow", "filter", "results", "walk", "dir", "next", "start", "rej", "options", "Minipass", "queue", "processing", "process", "paused", "onReaddir", "didRealpaths", "promises", "sync", "PathScurryPosix", "posix", "_dir", "PathScurryDarwin", "Path", "PathScurry", "isPatternList", "pl", "isGlobList", "gl", "customInspect", "Pattern", "_Pattern", "#patternList", "#globList", "#index", "#platform", "#rest", "#globString", "#isDrive", "#isUNC", "#isAbsolute", "#followGlobstar", "patternList", "globList", "index", "platform", "#isLongUNC", "proot", "groot", "prest", "grest", "p", "g", "p1", "g1", "GLOBSTAR", "h", "defaultPlatform", "Ignore", "ignored", "nobrace", "nocase", "noext", "noglobstar", "normalize", "platform", "root", "windowsPathsNoEscape", "allowWindowsEscape", "cwd", "slashRoot", "escape", "ign", "mm", "Minimatch", "i", "parsed", "globParts", "p", "Pattern", "glob", "m", "children", "absolute", "fullpath", "fullpaths", "relative", "relatives", "HasWalkedCache", "_HasWalkedCache", "parent", "#find", "fullpath", "set", "target", "pattern", "cached", "MatchRecord", "_MatchRecord", "absolute", "ifDir", "n", "current", "SubWalks", "subs", "p", "k", "Processor", "_Processor", "opts", "hasWalkedCache", "patterns", "processingSet", "t", "root", "rest", "changed", "GLOBSTAR", "rp", "rrest", "tp", "entries", "results", "e", "ep", "ABSOLUTE", "IF_DIR", "MatchRecord", "makeIgnore", "ignore", "opts", "cwd", "Ignore", "GlobUtil", "#onResume", "#ignore", "#sep", "patterns", "path", "m", "#ignored", "#childrenIgnored", "fn", "inPath", "ifDir", "rpc", "e", "s", "target", "absolute", "#matchEmitChecked", "ign", "abs", "mark", "rel", "pre", "p", "cb", "Processor", "processor", "tasks", "next", "n", "t", "childrenCached", "_", "entries", "processorx", "proc", "children", "GlobWalker", "res", "rej", "GlobStream", "Minipass", "defaultPlatform", "Glob", "pattern", "opts", "fileURLToPath", "p", "Scurry", "PathScurryWin32", "PathScurryDarwin", "PathScurryPosix", "PathScurry", "nocaseMagicOnly", "mmo", "mms", "Minimatch", "matchSet", "globParts", "set", "m", "i", "g", "Pattern", "GlobWalker", "GlobStream", "hasMagic", "pattern", "options", "p", "Minimatch", "globStreamSync", "pattern", "options", "Glob", "globStream", "globSync", "glob_", "globIterateSync", "globIterate", "streamSync", "stream", "iterateSync", "iterate", "sync", "glob", "hasMagic", "escape", "unescape"]
+}