@socketsecurity/cli-with-sentry 1.1.15 → 1.1.18

package/external/@socketsecurity/registry/external/@npmcli/package-json/index.js

@@ -984,12 +984,12 @@ function requireSemver$1() {
 }
 
 let parse_1
-let hasRequiredParse$2
-function requireParse$2() {
-  if (hasRequiredParse$2) {
+let hasRequiredParse$1
+function requireParse$1() {
+  if (hasRequiredParse$1) {
     return parse_1
   }
-  hasRequiredParse$2 = 1
+  hasRequiredParse$1 = 1
   const SemVer = requireSemver$1()
   const parse = (version, options, throwErrors = false) => {
     if (version instanceof SemVer) {
@@ -1015,7 +1015,7 @@ function requireValid$1() {
     return valid_1
   }
   hasRequiredValid$1 = 1
-  const parse = requireParse$2()
+  const parse = requireParse$1()
   const valid = (version, options) => {
     const v = parse(version, options)
     return v ? v.version : null
@@ -1031,7 +1031,7 @@ function requireClean() {
     return clean_1
   }
   hasRequiredClean = 1
-  const parse = requireParse$2()
+  const parse = requireParse$1()
   const clean = (version, options) => {
     const s = parse(version.trim().replace(/^[=v]+/, ''), options)
     return s ? s.version : null
@@ -1191,22 +1191,22 @@ function requireLib$a() {
   return lib$a
 }
 
-const commonjs$8 = {}
+const commonjs$5 = {}
 
-let hasRequiredCommonjs$8
-function requireCommonjs$8() {
-  if (hasRequiredCommonjs$8) {
-    return commonjs$8
+let hasRequiredCommonjs$5
+function requireCommonjs$5() {
+  if (hasRequiredCommonjs$5) {
+    return commonjs$5
   }
-  hasRequiredCommonjs$8 = 1
+  hasRequiredCommonjs$5 = 1
   /**
    * @module LRUCache
    */
-  Object.defineProperty(commonjs$8, '__esModule', {
+  Object.defineProperty(commonjs$5, '__esModule', {
     value: true
   })
-  commonjs$8.LRUCache = void 0
-  const perf =
+  commonjs$5.LRUCache = void 0
+  const defaultPerf =
     typeof performance === 'object' &&
     performance &&
     typeof performance.now === 'function'
@@ -1363,6 +1363,13 @@ function requireCommonjs$8() {
     #disposeAfter
     #fetchMethod
     #memoMethod
+    #perf
+    /**
+     * {@link LRUCache.OptionsBase.perf}
+     */
+    get perf() {
+      return this.#perf
+    }
     /**
      * {@link LRUCache.OptionsBase.ttl}
      */
@@ -1554,8 +1561,17 @@ function requireCommonjs$8() {
         noDeleteOnStaleGet,
         allowStaleOnFetchRejection,
         allowStaleOnFetchAbort,
-        ignoreFetchAbort
+        ignoreFetchAbort,
+        perf
       } = options
+      if (perf !== undefined) {
+        if (typeof perf?.now !== 'function') {
+          throw new TypeError(
+            'perf option must have a now() method if specified'
+          )
+        }
+      }
+      this.#perf = perf ?? defaultPerf
       if (max !== 0 && !isPosInt(max)) {
         throw new TypeError('max option must be a nonnegative integer')
       }
@@ -1675,7 +1691,7 @@ function requireCommonjs$8() {
       const starts = new ZeroArray(this.#max)
       this.#ttls = ttls
       this.#starts = starts
-      this.#setItemTTL = (index, ttl, start = perf.now()) => {
+      this.#setItemTTL = (index, ttl, start = this.#perf.now()) => {
         starts[index] = ttl !== 0 ? start : 0
         ttls[index] = ttl
         if (ttl !== 0 && this.ttlAutopurge) {
@@ -1693,7 +1709,7 @@ function requireCommonjs$8() {
         }
       }
       this.#updateItemAge = index => {
-        starts[index] = ttls[index] !== 0 ? perf.now() : 0
+        starts[index] = ttls[index] !== 0 ? this.#perf.now() : 0
       }
       this.#statusTTL = (status, index) => {
         if (ttls[index]) {
@@ -1714,7 +1730,7 @@ function requireCommonjs$8() {
       // that costly call repeatedly.
       let cachedNow = 0
       const getNow = () => {
-        const n = perf.now()
+        const n = this.#perf.now()
         if (this.ttlResolution > 0) {
           cachedNow = n
           const t = setTimeout(() => (cachedNow = 0), this.ttlResolution)
@@ -2033,10 +2049,13 @@ function requireCommonjs$8() {
         return undefined
       }
       const v = this.#valList[i]
+      /* c8 ignore start - this isn't tested for the info function,
+       * but it's the same logic as found in other places. */
       const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v
       if (value === undefined) {
         return undefined
       }
+      /* c8 ignore end */
       const entry = {
         value
       }
@@ -2044,7 +2063,7 @@ function requireCommonjs$8() {
         const ttl = this.#ttls[i]
         const start = this.#starts[i]
         if (ttl && start) {
-          const remain = ttl - (perf.now() - start)
+          const remain = ttl - (this.#perf.now() - start)
           entry.ttl = remain
           entry.start = Date.now()
         }
@@ -2085,7 +2104,7 @@ function requireCommonjs$8() {
           entry.ttl = this.#ttls[i]
           // always dump the start relative to a portable timestamp
           // it's ok for this to be a bit slow, it's a rare operation.
-          const age = perf.now() - this.#starts[i]
+          const age = this.#perf.now() - this.#starts[i]
           entry.start = Math.floor(Date.now() - age)
         }
         if (this.#sizes) {
@@ -2115,7 +2134,7 @@ function requireCommonjs$8() {
           //
           // it's ok for this to be a bit slow, it's a rare operation.
           const age = Date.now() - entry.start
-          entry.start = perf.now() - age
+          entry.start = this.#perf.now() - age
         }
         this.set(key, entry.value, entry)
       }
@@ -2427,7 +2446,7 @@ function requireCommonjs$8() {
         const bf = p
         if (this.#valList[index] === p) {
           if (v === undefined) {
-            if (bf.__staleWhileFetching) {
+            if (bf.__staleWhileFetching !== undefined) {
               this.#valList[index] = bf.__staleWhileFetching
             } else {
               this.#delete(k, 'fetch')
@@ -2843,8 +2862,8 @@ function requireCommonjs$8() {
       }
     }
   }
-  commonjs$8.LRUCache = LRUCache
-  return commonjs$8
+  commonjs$5.LRUCache = LRUCache
+  return commonjs$5
 }
 
 /* eslint-disable max-len */
@@ -3343,7 +3362,7 @@ function requireLib$9() {
     return lib$9
   }
   hasRequiredLib$9 = 1
-  const { LRUCache } = /*@__PURE__*/ requireCommonjs$8()
+  const { LRUCache } = /*@__PURE__*/ requireCommonjs$5()
   const hosts = requireHosts$1()
   const fromUrl = requireFromUrl$1()
   const parseUrl = requireParseUrl$1()
@@ -3586,149 +3605,136 @@ function requireLib$9() {
   return lib$9
 }
 
-const commonjs$7 = {}
-
-const commonjs$6 = {}
-
-const commonjs$5 = {}
-
 const commonjs$4 = {}
 
-let hasRequiredCommonjs$7
-function requireCommonjs$7() {
-  if (hasRequiredCommonjs$7) {
-    return commonjs$4
+const commonjs$3 = {}
+
+let balancedMatch
+let hasRequiredBalancedMatch
+function requireBalancedMatch() {
+  if (hasRequiredBalancedMatch) {
+    return balancedMatch
   }
-  hasRequiredCommonjs$7 = 1
-  ;(function (exports) {
-    Object.defineProperty(exports, '__esModule', {
-      value: true
-    })
-    exports.range = exports.balanced = void 0
-    const balanced = (a, b, str) => {
-      const ma = a instanceof RegExp ? maybeMatch(a, str) : a
-      const mb = b instanceof RegExp ? maybeMatch(b, str) : b
-      const r = ma !== null && mb != null && (0, exports.range)(ma, mb, str)
-      return (
-        r && {
-          start: r[0],
-          end: r[1],
-          pre: str.slice(0, r[0]),
-          body: str.slice(r[0] + ma.length, r[1]),
-          post: str.slice(r[1] + mb.length)
-        }
-      )
+  hasRequiredBalancedMatch = 1
+  balancedMatch = balanced
+  function balanced(a, b, str) {
+    if (a instanceof RegExp) {
+      a = maybeMatch(a, str)
     }
-    exports.balanced = balanced
-    const maybeMatch = (reg, str) => {
-      const m = str.match(reg)
-      return m ? m[0] : null
-    }
-    const range = (a, b, str) => {
-      let begs,
-        beg,
-        left,
-        right = undefined,
-        result
-      let ai = str.indexOf(a)
-      let bi = str.indexOf(b, ai + 1)
-      let i = ai
-      if (ai >= 0 && bi > 0) {
-        if (a === b) {
-          return [ai, bi]
-        }
-        begs = []
-        left = str.length
-        while (i >= 0 && !result) {
-          if (i === ai) {
-            begs.push(i)
-            ai = str.indexOf(a, i + 1)
-          } else if (begs.length === 1) {
-            const r = begs.pop()
-            if (r !== undefined) {
-              result = [r, bi]
-            }
-          } else {
-            beg = begs.pop()
-            if (beg !== undefined && beg < left) {
-              left = beg
-              right = bi
-            }
-            bi = str.indexOf(b, i + 1)
+    if (b instanceof RegExp) {
+      b = maybeMatch(b, str)
+    }
+    const r = range(a, b, str)
+    return (
+      r && {
+        start: r[0],
+        end: r[1],
+        pre: str.slice(0, r[0]),
+        body: str.slice(r[0] + a.length, r[1]),
+        post: str.slice(r[1] + b.length)
+      }
+    )
+  }
+  function maybeMatch(reg, str) {
+    const m = str.match(reg)
+    return m ? m[0] : null
+  }
+  balanced.range = range
+  function range(a, b, str) {
+    let begs, beg, left, right, result
+    let ai = str.indexOf(a)
+    let bi = str.indexOf(b, ai + 1)
+    let i = ai
+    if (ai >= 0 && bi > 0) {
+      if (a === b) {
+        return [ai, bi]
+      }
+      begs = []
+      left = str.length
+      while (i >= 0 && !result) {
+        if (i == ai) {
+          begs.push(i)
+          ai = str.indexOf(a, i + 1)
+        } else if (begs.length == 1) {
+          result = [begs.pop(), bi]
+        } else {
+          beg = begs.pop()
+          if (beg < left) {
+            left = beg
+            right = bi
           }
-          i = ai < bi && ai >= 0 ? ai : bi
-        }
-        if (begs.length && right !== undefined) {
-          result = [left, right]
+          bi = str.indexOf(b, i + 1)
         }
+        i = ai < bi && ai >= 0 ? ai : bi
+      }
+      if (begs.length) {
+        result = [left, right]
       }
-      return result
     }
-    exports.range = range
-  })(commonjs$4)
-  return commonjs$4
+    return result
+  }
+  return balancedMatch
 }
 
-let hasRequiredCommonjs$6
-function requireCommonjs$6() {
-  if (hasRequiredCommonjs$6) {
-    return commonjs$5
+let braceExpansion
+let hasRequiredBraceExpansion
+function requireBraceExpansion() {
+  if (hasRequiredBraceExpansion) {
+    return braceExpansion
   }
-  hasRequiredCommonjs$6 = 1
-  Object.defineProperty(commonjs$5, '__esModule', {
-    value: true
-  })
-  commonjs$5.expand = expand
-  const balanced_match_1 = requireCommonjs$7()
+  hasRequiredBraceExpansion = 1
+  const balanced = requireBalancedMatch()
+  braceExpansion = expandTop
   const escSlash = '\0SLASH' + Math.random() + '\0'
   const escOpen = '\0OPEN' + Math.random() + '\0'
   const escClose = '\0CLOSE' + Math.random() + '\0'
   const escComma = '\0COMMA' + Math.random() + '\0'
   const escPeriod = '\0PERIOD' + Math.random() + '\0'
-  const escSlashPattern = new RegExp(escSlash, 'g')
-  const escOpenPattern = new RegExp(escOpen, 'g')
-  const escClosePattern = new RegExp(escClose, 'g')
-  const escCommaPattern = new RegExp(escComma, 'g')
-  const escPeriodPattern = new RegExp(escPeriod, 'g')
-  const slashPattern = /\\\\/g
-  const openPattern = /\\{/g
-  const closePattern = /\\}/g
-  const commaPattern = /\\,/g
-  const periodPattern = /\\./g
   function numeric(str) {
-    return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0)
+    return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0)
   }
   function escapeBraces(str) {
     return str
-      .replace(slashPattern, escSlash)
-      .replace(openPattern, escOpen)
-      .replace(closePattern, escClose)
-      .replace(commaPattern, escComma)
-      .replace(periodPattern, escPeriod)
+      .split('\\\\')
+      .join(escSlash)
+      .split('\\{')
+      .join(escOpen)
+      .split('\\}')
+      .join(escClose)
+      .split('\\,')
+      .join(escComma)
+      .split('\\.')
+      .join(escPeriod)
   }
   function unescapeBraces(str) {
     return str
-      .replace(escSlashPattern, '\\')
-      .replace(escOpenPattern, '{')
-      .replace(escClosePattern, '}')
-      .replace(escCommaPattern, ',')
-      .replace(escPeriodPattern, '.')
-  }
-  /**
-   * Basically just str.split(","), but handling cases
-   * where we have nested braced sections, which should be
-   * treated as individual members, like {a,{b,c},d}
-   */
+      .split(escSlash)
+      .join('\\')
+      .split(escOpen)
+      .join('{')
+      .split(escClose)
+      .join('}')
+      .split(escComma)
+      .join(',')
+      .split(escPeriod)
+      .join('.')
+  }
+
+  // Basically just str.split(","), but handling cases
+  // where we have nested braced sections, which should be
+  // treated as individual members, like {a,{b,c},d}
   function parseCommaParts(str) {
     if (!str) {
       return ['']
     }
     const parts = []
-    const m = (0, balanced_match_1.balanced)('{', '}', str)
+    const m = balanced('{', '}', str)
     if (!m) {
       return str.split(',')
     }
-    const { pre, body, post } = m
+    const pre = m.pre
+    const body = m.body
+    const post = m.post
     const p = pre.split(',')
     p[p.length - 1] += '{' + body + '}'
     const postParts = parseCommaParts(post)
@@ -3739,20 +3745,21 @@ function requireCommonjs$6() {
     parts.push.apply(parts, p)
     return parts
   }
-  function expand(str) {
+  function expandTop(str) {
     if (!str) {
       return []
     }
+
     // I don't know why Bash 4.3 does this, but it does.
     // Anything starting with {} will have the first two bytes preserved
     // but *only* at the top level, so {},a}b will not expand to anything,
     // but a{},b}c will be expanded to [a}c,abc].
     // One could argue that this is a bug in Bash, but since the goal of
     // this module is to match Bash's rules, we escape a leading {}
-    if (str.slice(0, 2) === '{}') {
-      str = '\\{\\}' + str.slice(2)
+    if (str.substr(0, 2) === '{}') {
+      str = '\\{\\}' + str.substr(2)
     }
-    return expand_(escapeBraces(str), true).map(unescapeBraces)
+    return expand(escapeBraces(str), true).map(unescapeBraces)
   }
   function embrace(str) {
     return '{' + str + '}'
@@ -3766,19 +3773,19 @@ function requireCommonjs$6() {
   function gte(i, y) {
     return i >= y
   }
-  function expand_(str, isTop) {
-    /** @type {string[]} */
+  function expand(str, isTop) {
     const expansions = []
-    const m = (0, balanced_match_1.balanced)('{', '}', str)
+    const m = balanced('{', '}', str)
     if (!m) {
       return [str]
     }
+
     // no need to expand pre, since it is guaranteed to be free of brace-sets
     const pre = m.pre
-    const post = m.post.length ? expand_(m.post, false) : ['']
-    if (/\$$/.test(m.pre)) {
-      for (let k = 0; k < post.length; k++) {
-        const expansion = pre + '{' + m.body + '}' + post[k]
+    const post = m.post.length ? expand(m.post, false) : ['']
+    if (m.pre.endsWith('\u0024' /*'$'*/)) {
+      for (var k = 0; k < post.length; k++) {
+        var expansion = pre + '{' + m.body + '}' + post[k]
         expansions.push(expansion)
       }
     } else {
@@ -3792,7 +3799,7 @@ function requireCommonjs$6() {
         // {a},b}
         if (m.post.match(/,(?!,).*\}/)) {
           str = m.pre + '{' + m.body + escClose + m.post
-          return expand_(str)
+          return expand(str)
         }
         return [str]
       }
@@ -3801,26 +3808,25 @@ function requireCommonjs$6() {
         n = m.body.split(/\.\./)
       } else {
         n = parseCommaParts(m.body)
-        if (n.length === 1 && n[0] !== undefined) {
+        if (n.length === 1) {
           // x{{a,b}}y ==> x{a}y x{b}y
-          n = expand_(n[0], false).map(embrace)
-          //XXX is this necessary? Can't seem to hit it in tests.
-          /* c8 ignore start */
+          n = expand(n[0], false).map(embrace)
           if (n.length === 1) {
-            return post.map(p => m.pre + n[0] + p)
+            return post.map(function (p) {
+              return m.pre + n[0] + p
+            })
           }
-          /* c8 ignore stop */
         }
       }
+
       // at this point, n is the parts, and we know it's not a comma set
       // with a single entry.
       let N
-      if (isSequence && n[0] !== undefined && n[1] !== undefined) {
+      if (isSequence) {
         const x = numeric(n[0])
         const y = numeric(n[1])
         const width = Math.max(n[0].length, n[1].length)
-        let incr =
-          n.length === 3 && n[2] !== undefined ? Math.abs(numeric(n[2])) : 1
+        let incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1
         let test = lte
         const reverse = y < x
         if (reverse) {
@@ -3854,13 +3860,13 @@ function requireCommonjs$6() {
         }
       } else {
         N = []
-        for (let j = 0; j < n.length; j++) {
-          N.push.apply(N, expand_(n[j], false))
+        for (var j = 0; j < n.length; j++) {
+          N.push.apply(N, expand(n[j], false))
         }
       }
-      for (let j = 0; j < N.length; j++) {
-        for (let k = 0; k < post.length; k++) {
-          const expansion = pre + N[j] + post[k]
+      for (var j = 0; j < N.length; j++) {
+        for (var k = 0; k < post.length; k++) {
+          var expansion = pre + N[j] + post[k]
           if (!isTop || isSequence || expansion) {
             expansions.push(expansion)
           }
@@ -3869,7 +3875,7 @@ function requireCommonjs$6() {
     }
     return expansions
   }
-  return commonjs$5
+  return braceExpansion
 }
 
 const assertValidPattern = {}
@@ -4773,13 +4779,22 @@ function require_escape$1() {
   return _escape$1
 }
 
-let hasRequiredCommonjs$5
-function requireCommonjs$5() {
-  if (hasRequiredCommonjs$5) {
-    return commonjs$6
+let hasRequiredCommonjs$4
+function requireCommonjs$4() {
+  if (hasRequiredCommonjs$4) {
+    return commonjs$3
   }
-  hasRequiredCommonjs$5 = 1
+  hasRequiredCommonjs$4 = 1
   ;(function (exports) {
+    const __importDefault =
+      (this && this.__importDefault) ||
+      function (mod) {
+        return mod && mod.__esModule
+          ? mod
+          : {
+              default: mod
+            }
+      }
     Object.defineProperty(exports, '__esModule', {
       value: true
     })
@@ -4796,7 +4811,7 @@ function requireCommonjs$5() {
       exports.sep =
       exports.minimatch =
         void 0
-    const brace_expansion_1 = requireCommonjs$6()
+    const brace_expansion_1 = __importDefault(requireBraceExpansion())
     const assert_valid_pattern_js_1 = requireAssertValidPattern()
     const ast_js_1 = requireAst()
     const escape_js_1 = require_escape$1()
@@ -4964,7 +4979,7 @@ function requireCommonjs$5() {
         // shortcut. no need to expand.
         return [pattern]
       }
-      return (0, brace_expansion_1.expand)(pattern)
+      return (0, brace_expansion_1.default)(pattern)
     }
     exports.braceExpand = braceExpand
     exports.minimatch.braceExpand = exports.braceExpand
@@ -5482,11 +5497,11 @@ function requireCommonjs$5() {
           pattern
         })
         this.debug('matchOne', file.length, pattern.length)
-        for (
-          var fi = 0, pi = 0, fl = file.length, pl = pattern.length;
-          fi < fl && pi < pl;
-          fi++, pi++
-        ) {
+        let fi = 0,
+          pi = 0,
+          fl = file.length,
+          pl = pattern.length
+        for (; fi < fl && pi < pl; fi++, pi++) {
           this.debug('matchOne loop')
           const p = pattern[pi]
           const f = file[fi]
@@ -5726,1811 +5741,155 @@ function requireCommonjs$5() {
             })
             pp.forEach((p, i) => {
               const next = pp[i + 1]
-              const prev = pp[i - 1]
-              if (p !== exports.GLOBSTAR || prev === exports.GLOBSTAR) {
-                return
-              }
-              if (prev === undefined) {
-                if (next !== undefined && next !== exports.GLOBSTAR) {
-                  pp[i + 1] = '(?:\\/|' + twoStar + '\\/)?' + next
-                } else {
-                  pp[i] = twoStar
-                }
-              } else if (next === undefined) {
-                pp[i - 1] = prev + '(?:\\/|' + twoStar + ')?'
-              } else if (next !== exports.GLOBSTAR) {
-                pp[i - 1] = prev + '(?:\\/|\\/' + twoStar + '\\/)' + next
-                pp[i + 1] = exports.GLOBSTAR
-              }
-            })
-            return pp.filter(p => p !== exports.GLOBSTAR).join('/')
-          })
-          .join('|')
-        // need to wrap in parens if we had more than one thing with |,
-        // otherwise only the first will be anchored to ^ and the last to $
-        const [open, close] = set.length > 1 ? ['(?:', ')'] : ['', '']
-        // must match entire pattern
-        // ending in a * or ** will make it less strict.
-        re = '^' + open + re + close + '$'
-        // can match anything, as long as it's not this.
-        if (this.negate) {
-          re = '^(?!' + re + ').+$'
-        }
-        try {
-          this.regexp = new RegExp(re, [...flags].join(''))
-          /* c8 ignore start */
-        } catch (ex) {
-          // should be impossible
-          this.regexp = false
-        }
-        /* c8 ignore stop */
-        return this.regexp
-      }
-      slashSplit(p) {
-        // if p starts with // on windows, we preserve that
-        // so that UNC paths aren't broken.  Otherwise, any number of
-        // / characters are coalesced into one, unless
-        // preserveMultipleSlashes is set to true.
-        if (this.preserveMultipleSlashes) {
-          return p.split('/')
-        } else if (this.isWindows && /^\/\/[^/]+/.test(p)) {
-          // add an extra '' for the one we lose
-          return ['', ...p.split(/\/+/)]
-        } else {
-          return p.split(/\/+/)
-        }
-      }
-      match(f, partial = this.partial) {
-        this.debug('match', f, this.pattern)
-        // short-circuit in the case of busted things.
-        // comments, etc.
-        if (this.comment) {
-          return false
-        }
-        if (this.empty) {
-          return f === ''
-        }
-        if (f === '/' && partial) {
-          return true
-        }
-        const options = this.options
-        // windows: need to use /, not \
-        if (this.isWindows) {
-          f = f.split('\\').join('/')
-        }
-        // treat the test path as a set of pathparts.
-        const ff = this.slashSplit(f)
-        this.debug(this.pattern, 'split', ff)
-        // just ONE of the pattern sets in this.set needs to match
-        // in order for it to be valid.  If negating, then just one
-        // match means that we have failed.
-        // Either way, return on the first hit.
-        const set = this.set
-        this.debug(this.pattern, 'set', set)
-        // Find the basename of the path by looking for the last non-empty segment
-        let filename = ff[ff.length - 1]
-        if (!filename) {
-          for (let i = ff.length - 2; !filename && i >= 0; i--) {
-            filename = ff[i]
-          }
-        }
-        for (let i = 0; i < set.length; i++) {
-          const pattern = set[i]
-          let file = ff
-          if (options.matchBase && pattern.length === 1) {
-            file = [filename]
-          }
-          const hit = this.matchOne(file, pattern, partial)
-          if (hit) {
-            if (options.flipNegate) {
-              return true
-            }
-            return !this.negate
-          }
-        }
-        // didn't get any hits.  this is success if it's a negative
-        // pattern, failure otherwise.
-        if (options.flipNegate) {
-          return false
-        }
-        return this.negate
-      }
-      static defaults(def) {
-        return exports.minimatch.defaults(def).Minimatch
-      }
-    }
-    exports.Minimatch = Minimatch
-    /* c8 ignore start */
-    const ast_js_2 = requireAst()
-    Object.defineProperty(exports, 'AST', {
-      enumerable: true,
-      get: function () {
-        return ast_js_2.AST
-      }
-    })
-    const escape_js_2 = require_escape$1()
-    Object.defineProperty(exports, 'escape', {
-      enumerable: true,
-      get: function () {
-        return escape_js_2.escape
-      }
-    })
-    const unescape_js_2 = require_unescape()
-    Object.defineProperty(exports, 'unescape', {
-      enumerable: true,
-      get: function () {
-        return unescape_js_2.unescape
-      }
-    })
-    /* c8 ignore stop */
-    exports.minimatch.AST = ast_js_1.AST
-    exports.minimatch.Minimatch = Minimatch
-    exports.minimatch.escape = escape_js_1.escape
-    exports.minimatch.unescape = unescape_js_1.unescape
-  })(commonjs$6)
-  return commonjs$6
-}
-
-const glob = {}
-
-const commonjs$3 = {}
-
-const commonjs$2 = {}
-
-let hasRequiredCommonjs$4
-function requireCommonjs$4() {
-  if (hasRequiredCommonjs$4) {
-    return commonjs$2
-  }
-  hasRequiredCommonjs$4 = 1
-  /**
-   * @module LRUCache
-   */
-  Object.defineProperty(commonjs$2, '__esModule', {
-    value: true
-  })
-  commonjs$2.LRUCache = void 0
-  const perf =
-    typeof performance === 'object' &&
-    performance &&
-    typeof performance.now === 'function'
-      ? performance
-      : Date
-  const warned = new Set()
-  /* c8 ignore start */
-  const PROCESS = typeof process === 'object' && !!process ? process : {}
-  /* c8 ignore start */
-  const emitWarning = (msg, type, code, fn) => {
-    typeof PROCESS.emitWarning === 'function'
-      ? PROCESS.emitWarning(msg, type, code, fn)
-      : console.error(`[${code}] ${type}: ${msg}`)
-  }
-  let AC = globalThis.AbortController
-  let AS = globalThis.AbortSignal
-  /* c8 ignore start */
-  if (typeof AC === 'undefined') {
-    //@ts-ignore
-    AS = class AbortSignal {
-      onabort
-      _onabort = []
-      reason
-      aborted = false
-      addEventListener(_, fn) {
-        this._onabort.push(fn)
-      }
-    }
-    //@ts-ignore
-    AC = class AbortController {
-      constructor() {
-        warnACPolyfill()
-      }
-      signal = new AS()
-      abort(reason) {
-        if (this.signal.aborted) {
-          return
-        }
-        //@ts-ignore
-        this.signal.reason = reason
-        //@ts-ignore
-        this.signal.aborted = true
-        //@ts-ignore
-        for (const fn of this.signal._onabort) {
-          fn(reason)
-        }
-        this.signal.onabort?.(reason)
-      }
-    }
-    let printACPolyfillWarning =
-      PROCESS.env?.LRU_CACHE_IGNORE_AC_WARNING !== '1'
-    const warnACPolyfill = () => {
-      if (!printACPolyfillWarning) {
-        return
-      }
-      printACPolyfillWarning = false
-      emitWarning(
-        'AbortController is not defined. If using lru-cache in ' +
-          'node 14, load an AbortController polyfill from the ' +
-          '`node-abort-controller` package. A minimal polyfill is ' +
-          'provided for use by LRUCache.fetch(), but it should not be ' +
-          'relied upon in other contexts (eg, passing it to other APIs that ' +
-          'use AbortController/AbortSignal might have undesirable effects). ' +
-          'You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.',
-        'NO_ABORT_CONTROLLER',
-        'ENOTSUP',
-        warnACPolyfill
-      )
-    }
-  }
-  /* c8 ignore stop */
-  const shouldWarn = code => !warned.has(code)
-  const isPosInt = n => n && n === Math.floor(n) && n > 0 && isFinite(n)
-  /* c8 ignore start */
-  // This is a little bit ridiculous, tbh.
-  // The maximum array length is 2^32-1 or thereabouts on most JS impls.
-  // And well before that point, you're caching the entire world, I mean,
-  // that's ~32GB of just integers for the next/prev links, plus whatever
-  // else to hold that many keys and values.  Just filling the memory with
-  // zeroes at init time is brutal when you get that big.
-  // But why not be complete?
-  // Maybe in the future, these limits will have expanded.
-  const getUintArray = max =>
-    !isPosInt(max)
-      ? null
-      : max <= Math.pow(2, 8)
-        ? Uint8Array
-        : max <= Math.pow(2, 16)
-          ? Uint16Array
-          : max <= Math.pow(2, 32)
-            ? Uint32Array
-            : max <= Number.MAX_SAFE_INTEGER
-              ? ZeroArray
-              : null
-  /* c8 ignore stop */
-  class ZeroArray extends Array {
-    constructor(size) {
-      super(size)
-      this.fill(0)
-    }
-  }
-  class Stack {
-    heap
-    length
-    // private constructor
-    static #constructing = false
-    static create(max) {
-      const HeapCls = getUintArray(max)
-      if (!HeapCls) {
-        return []
-      }
-      Stack.#constructing = true
-      const s = new Stack(max, HeapCls)
-      Stack.#constructing = false
-      return s
-    }
-    constructor(max, HeapCls) {
-      /* c8 ignore start */
-      if (!Stack.#constructing) {
-        throw new TypeError('instantiate Stack using Stack.create(n)')
-      }
-      /* c8 ignore stop */
-      this.heap = new HeapCls(max)
-      this.length = 0
-    }
-    push(n) {
-      this.heap[this.length++] = n
-    }
-    pop() {
-      return this.heap[--this.length]
-    }
-  }
-  /**
-   * Default export, the thing you're using this module to get.
-   *
-   * The `K` and `V` types define the key and value types, respectively. The
-   * optional `FC` type defines the type of the `context` object passed to
-   * `cache.fetch()` and `cache.memo()`.
-   *
-   * Keys and values **must not** be `null` or `undefined`.
-   *
-   * All properties from the options object (with the exception of `max`,
-   * `maxSize`, `fetchMethod`, `memoMethod`, `dispose` and `disposeAfter`) are
-   * added as normal public members. (The listed options are read-only getters.)
-   *
-   * Changing any of these will alter the defaults for subsequent method calls.
-   */
-  class LRUCache {
-    // options that cannot be changed without disaster
-    #max
-    #maxSize
-    #dispose
-    #onInsert
-    #disposeAfter
-    #fetchMethod
-    #memoMethod
-    /**
-     * {@link LRUCache.OptionsBase.ttl}
-     */
-    ttl
-    /**
-     * {@link LRUCache.OptionsBase.ttlResolution}
-     */
-    ttlResolution
-    /**
-     * {@link LRUCache.OptionsBase.ttlAutopurge}
-     */
-    ttlAutopurge
-    /**
-     * {@link LRUCache.OptionsBase.updateAgeOnGet}
-     */
-    updateAgeOnGet
-    /**
-     * {@link LRUCache.OptionsBase.updateAgeOnHas}
-     */
-    updateAgeOnHas
-    /**
-     * {@link LRUCache.OptionsBase.allowStale}
-     */
-    allowStale
-    /**
-     * {@link LRUCache.OptionsBase.noDisposeOnSet}
-     */
-    noDisposeOnSet
-    /**
-     * {@link LRUCache.OptionsBase.noUpdateTTL}
-     */
-    noUpdateTTL
-    /**
-     * {@link LRUCache.OptionsBase.maxEntrySize}
-     */
-    maxEntrySize
-    /**
-     * {@link LRUCache.OptionsBase.sizeCalculation}
-     */
-    sizeCalculation
-    /**
-     * {@link LRUCache.OptionsBase.noDeleteOnFetchRejection}
-     */
-    noDeleteOnFetchRejection
-    /**
-     * {@link LRUCache.OptionsBase.noDeleteOnStaleGet}
-     */
-    noDeleteOnStaleGet
-    /**
-     * {@link LRUCache.OptionsBase.allowStaleOnFetchAbort}
-     */
-    allowStaleOnFetchAbort
-    /**
-     * {@link LRUCache.OptionsBase.allowStaleOnFetchRejection}
-     */
-    allowStaleOnFetchRejection
-    /**
-     * {@link LRUCache.OptionsBase.ignoreFetchAbort}
-     */
-    ignoreFetchAbort
-    // computed properties
-    #size
-    #calculatedSize
-    #keyMap
-    #keyList
-    #valList
-    #next
-    #prev
-    #head
-    #tail
-    #free
-    #disposed
-    #sizes
-    #starts
-    #ttls
-    #hasDispose
-    #hasFetchMethod
-    #hasDisposeAfter
-    #hasOnInsert
-    /**
-     * Do not call this method unless you need to inspect the
-     * inner workings of the cache.  If anything returned by this
-     * object is modified in any way, strange breakage may occur.
-     *
-     * These fields are private for a reason!
-     *
-     * @internal
-     */
-    static unsafeExposeInternals(c) {
-      return {
-        // properties
-        starts: c.#starts,
-        ttls: c.#ttls,
-        sizes: c.#sizes,
-        keyMap: c.#keyMap,
-        keyList: c.#keyList,
-        valList: c.#valList,
-        next: c.#next,
-        prev: c.#prev,
-        get head() {
-          return c.#head
-        },
-        get tail() {
-          return c.#tail
-        },
-        free: c.#free,
-        // methods
-        isBackgroundFetch: p => c.#isBackgroundFetch(p),
-        backgroundFetch: (k, index, options, context) =>
-          c.#backgroundFetch(k, index, options, context),
-        moveToTail: index => c.#moveToTail(index),
-        indexes: options => c.#indexes(options),
-        rindexes: options => c.#rindexes(options),
-        isStale: index => c.#isStale(index)
-      }
-    }
-    // Protected read-only members
-    /**
-     * {@link LRUCache.OptionsBase.max} (read-only)
-     */
-    get max() {
-      return this.#max
-    }
-    /**
-     * {@link LRUCache.OptionsBase.maxSize} (read-only)
-     */
-    get maxSize() {
-      return this.#maxSize
-    }
-    /**
-     * The total computed size of items in the cache (read-only)
-     */
-    get calculatedSize() {
-      return this.#calculatedSize
-    }
-    /**
-     * The number of items stored in the cache (read-only)
-     */
-    get size() {
-      return this.#size
-    }
-    /**
-     * {@link LRUCache.OptionsBase.fetchMethod} (read-only)
-     */
-    get fetchMethod() {
-      return this.#fetchMethod
-    }
-    get memoMethod() {
-      return this.#memoMethod
-    }
-    /**
-     * {@link LRUCache.OptionsBase.dispose} (read-only)
-     */
-    get dispose() {
-      return this.#dispose
-    }
-    /**
-     * {@link LRUCache.OptionsBase.onInsert} (read-only)
-     */
-    get onInsert() {
-      return this.#onInsert
-    }
-    /**
-     * {@link LRUCache.OptionsBase.disposeAfter} (read-only)
-     */
-    get disposeAfter() {
-      return this.#disposeAfter
-    }
-    constructor(options) {
-      const {
-        max = 0,
-        ttl,
-        ttlResolution = 1,
-        ttlAutopurge,
-        updateAgeOnGet,
-        updateAgeOnHas,
-        allowStale,
-        dispose,
-        onInsert,
-        disposeAfter,
-        noDisposeOnSet,
-        noUpdateTTL,
-        maxSize = 0,
-        maxEntrySize = 0,
-        sizeCalculation,
-        fetchMethod,
-        memoMethod,
-        noDeleteOnFetchRejection,
-        noDeleteOnStaleGet,
-        allowStaleOnFetchRejection,
-        allowStaleOnFetchAbort,
-        ignoreFetchAbort
-      } = options
-      if (max !== 0 && !isPosInt(max)) {
-        throw new TypeError('max option must be a nonnegative integer')
-      }
-      const UintArray = max ? getUintArray(max) : Array
-      if (!UintArray) {
-        throw new Error('invalid max value: ' + max)
-      }
-      this.#max = max
-      this.#maxSize = maxSize
-      this.maxEntrySize = maxEntrySize || this.#maxSize
-      this.sizeCalculation = sizeCalculation
-      if (this.sizeCalculation) {
-        if (!this.#maxSize && !this.maxEntrySize) {
-          throw new TypeError(
-            'cannot set sizeCalculation without setting maxSize or maxEntrySize'
-          )
-        }
-        if (typeof this.sizeCalculation !== 'function') {
-          throw new TypeError('sizeCalculation set to non-function')
-        }
-      }
-      if (memoMethod !== undefined && typeof memoMethod !== 'function') {
-        throw new TypeError('memoMethod must be a function if defined')
-      }
-      this.#memoMethod = memoMethod
-      if (fetchMethod !== undefined && typeof fetchMethod !== 'function') {
-        throw new TypeError('fetchMethod must be a function if specified')
-      }
-      this.#fetchMethod = fetchMethod
-      this.#hasFetchMethod = !!fetchMethod
-      this.#keyMap = new Map()
-      this.#keyList = new Array(max).fill(undefined)
-      this.#valList = new Array(max).fill(undefined)
-      this.#next = new UintArray(max)
-      this.#prev = new UintArray(max)
-      this.#head = 0
-      this.#tail = 0
-      this.#free = Stack.create(max)
-      this.#size = 0
-      this.#calculatedSize = 0
-      if (typeof dispose === 'function') {
-        this.#dispose = dispose
-      }
-      if (typeof onInsert === 'function') {
-        this.#onInsert = onInsert
-      }
-      if (typeof disposeAfter === 'function') {
-        this.#disposeAfter = disposeAfter
-        this.#disposed = []
-      } else {
-        this.#disposeAfter = undefined
-        this.#disposed = undefined
-      }
-      this.#hasDispose = !!this.#dispose
-      this.#hasOnInsert = !!this.#onInsert
-      this.#hasDisposeAfter = !!this.#disposeAfter
-      this.noDisposeOnSet = !!noDisposeOnSet
-      this.noUpdateTTL = !!noUpdateTTL
-      this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection
-      this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection
-      this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort
-      this.ignoreFetchAbort = !!ignoreFetchAbort
-      // NB: maxEntrySize is set to maxSize if it's set
-      if (this.maxEntrySize !== 0) {
-        if (this.#maxSize !== 0) {
-          if (!isPosInt(this.#maxSize)) {
-            throw new TypeError(
-              'maxSize must be a positive integer if specified'
-            )
-          }
-        }
-        if (!isPosInt(this.maxEntrySize)) {
-          throw new TypeError(
-            'maxEntrySize must be a positive integer if specified'
-          )
-        }
-        this.#initializeSizeTracking()
-      }
-      this.allowStale = !!allowStale
-      this.noDeleteOnStaleGet = !!noDeleteOnStaleGet
-      this.updateAgeOnGet = !!updateAgeOnGet
-      this.updateAgeOnHas = !!updateAgeOnHas
-      this.ttlResolution =
-        isPosInt(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1
-      this.ttlAutopurge = !!ttlAutopurge
-      this.ttl = ttl || 0
-      if (this.ttl) {
-        if (!isPosInt(this.ttl)) {
-          throw new TypeError('ttl must be a positive integer if specified')
-        }
-        this.#initializeTTLTracking()
-      }
-      // do not allow completely unbounded caches
-      if (this.#max === 0 && this.ttl === 0 && this.#maxSize === 0) {
-        throw new TypeError('At least one of max, maxSize, or ttl is required')
-      }
-      if (!this.ttlAutopurge && !this.#max && !this.#maxSize) {
-        const code = 'LRU_CACHE_UNBOUNDED'
-        if (shouldWarn(code)) {
-          warned.add(code)
-          const msg =
-            'TTL caching without ttlAutopurge, max, or maxSize can ' +
-            'result in unbounded memory consumption.'
-          emitWarning(msg, 'UnboundedCacheWarning', code, LRUCache)
-        }
-      }
-    }
-    /**
-     * Return the number of ms left in the item's TTL. If item is not in cache,
-     * returns `0`. Returns `Infinity` if item is in cache without a defined TTL.
-     */
-    getRemainingTTL(key) {
-      return this.#keyMap.has(key) ? Infinity : 0
-    }
-    #initializeTTLTracking() {
-      const ttls = new ZeroArray(this.#max)
-      const starts = new ZeroArray(this.#max)
-      this.#ttls = ttls
-      this.#starts = starts
-      this.#setItemTTL = (index, ttl, start = perf.now()) => {
-        starts[index] = ttl !== 0 ? start : 0
-        ttls[index] = ttl
-        if (ttl !== 0 && this.ttlAutopurge) {
-          const t = setTimeout(() => {
-            if (this.#isStale(index)) {
-              this.#delete(this.#keyList[index], 'expire')
-            }
-          }, ttl + 1)
-          // unref() not supported on all platforms
-          /* c8 ignore start */
-          if (t.unref) {
-            t.unref()
-          }
-          /* c8 ignore stop */
-        }
-      }
-      this.#updateItemAge = index => {
-        starts[index] = ttls[index] !== 0 ? perf.now() : 0
-      }
-      this.#statusTTL = (status, index) => {
-        if (ttls[index]) {
-          const ttl = ttls[index]
-          const start = starts[index]
-          /* c8 ignore next */
-          if (!ttl || !start) {
-            return
-          }
-          status.ttl = ttl
-          status.start = start
-          status.now = cachedNow || getNow()
-          const age = status.now - start
-          status.remainingTTL = ttl - age
-        }
-      }
-      // debounce calls to perf.now() to 1s so we're not hitting
-      // that costly call repeatedly.
-      let cachedNow = 0
-      const getNow = () => {
-        const n = perf.now()
-        if (this.ttlResolution > 0) {
-          cachedNow = n
-          const t = setTimeout(() => (cachedNow = 0), this.ttlResolution)
-          // not available on all platforms
-          /* c8 ignore start */
-          if (t.unref) {
-            t.unref()
-          }
-          /* c8 ignore stop */
-        }
-        return n
-      }
-      this.getRemainingTTL = key => {
-        const index = this.#keyMap.get(key)
-        if (index === undefined) {
-          return 0
-        }
-        const ttl = ttls[index]
-        const start = starts[index]
-        if (!ttl || !start) {
-          return Infinity
-        }
-        const age = (cachedNow || getNow()) - start
-        return ttl - age
-      }
-      this.#isStale = index => {
-        const s = starts[index]
-        const t = ttls[index]
-        return !!t && !!s && (cachedNow || getNow()) - s > t
-      }
-    }
-    // conditionally set private methods related to TTL
-    #updateItemAge = () => {}
-    #statusTTL = () => {}
-    #setItemTTL = () => {}
-    /* c8 ignore stop */
-    #isStale = () => false
-    #initializeSizeTracking() {
-      const sizes = new ZeroArray(this.#max)
-      this.#calculatedSize = 0
-      this.#sizes = sizes
-      this.#removeItemSize = index => {
-        this.#calculatedSize -= sizes[index]
-        sizes[index] = 0
-      }
-      this.#requireSize = (k, v, size, sizeCalculation) => {
-        // provisionally accept background fetches.
-        // actual value size will be checked when they return.
-        if (this.#isBackgroundFetch(v)) {
-          return 0
-        }
-        if (!isPosInt(size)) {
-          if (sizeCalculation) {
-            if (typeof sizeCalculation !== 'function') {
-              throw new TypeError('sizeCalculation must be a function')
-            }
-            size = sizeCalculation(v, k)
-            if (!isPosInt(size)) {
-              throw new TypeError(
-                'sizeCalculation return invalid (expect positive integer)'
-              )
-            }
-          } else {
-            throw new TypeError(
-              'invalid size value (must be positive integer). ' +
-                'When maxSize or maxEntrySize is used, sizeCalculation ' +
-                'or size must be set.'
-            )
-          }
-        }
-        return size
-      }
-      this.#addItemSize = (index, size, status) => {
-        sizes[index] = size
-        if (this.#maxSize) {
-          const maxSize = this.#maxSize - sizes[index]
-          while (this.#calculatedSize > maxSize) {
-            this.#evict(true)
-          }
-        }
-        this.#calculatedSize += sizes[index]
-        if (status) {
-          status.entrySize = size
-          status.totalCalculatedSize = this.#calculatedSize
-        }
-      }
-    }
-    #removeItemSize = _i => {}
-    #addItemSize = (_i, _s, _st) => {}
-    #requireSize = (_k, _v, size, sizeCalculation) => {
-      if (size || sizeCalculation) {
-        throw new TypeError(
-          'cannot set size without setting maxSize or maxEntrySize on cache'
-        )
-      }
-      return 0
-    };
-    *#indexes({ allowStale = this.allowStale } = {}) {
-      if (this.#size) {
-        for (let i = this.#tail; true; ) {
-          if (!this.#isValidIndex(i)) {
-            break
-          }
-          if (allowStale || !this.#isStale(i)) {
-            yield i
-          }
-          if (i === this.#head) {
-            break
-          } else {
-            i = this.#prev[i]
-          }
-        }
-      }
-    }
-    *#rindexes({ allowStale = this.allowStale } = {}) {
-      if (this.#size) {
-        for (let i = this.#head; true; ) {
-          if (!this.#isValidIndex(i)) {
-            break
-          }
-          if (allowStale || !this.#isStale(i)) {
-            yield i
-          }
-          if (i === this.#tail) {
-            break
-          } else {
-            i = this.#next[i]
-          }
-        }
-      }
-    }
-    #isValidIndex(index) {
-      return (
-        index !== undefined && this.#keyMap.get(this.#keyList[index]) === index
-      )
-    }
-    /**
-     * Return a generator yielding `[key, value]` pairs,
-     * in order from most recently used to least recently used.
-     */
-    *entries() {
-      for (const i of this.#indexes()) {
-        if (
-          this.#valList[i] !== undefined &&
-          this.#keyList[i] !== undefined &&
-          !this.#isBackgroundFetch(this.#valList[i])
-        ) {
-          yield [this.#keyList[i], this.#valList[i]]
-        }
-      }
-    }
-    /**
-     * Inverse order version of {@link LRUCache.entries}
-     *
-     * Return a generator yielding `[key, value]` pairs,
-     * in order from least recently used to most recently used.
-     */
-    *rentries() {
-      for (const i of this.#rindexes()) {
-        if (
-          this.#valList[i] !== undefined &&
-          this.#keyList[i] !== undefined &&
-          !this.#isBackgroundFetch(this.#valList[i])
-        ) {
-          yield [this.#keyList[i], this.#valList[i]]
-        }
-      }
-    }
-    /**
-     * Return a generator yielding the keys in the cache,
-     * in order from most recently used to least recently used.
-     */
-    *keys() {
-      for (const i of this.#indexes()) {
-        const k = this.#keyList[i]
-        if (k !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
-          yield k
-        }
-      }
-    }
-    /**
-     * Inverse order version of {@link LRUCache.keys}
-     *
-     * Return a generator yielding the keys in the cache,
-     * in order from least recently used to most recently used.
-     */
-    *rkeys() {
-      for (const i of this.#rindexes()) {
-        const k = this.#keyList[i]
-        if (k !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
-          yield k
-        }
-      }
-    }
-    /**
-     * Return a generator yielding the values in the cache,
-     * in order from most recently used to least recently used.
-     */
-    *values() {
-      for (const i of this.#indexes()) {
-        const v = this.#valList[i]
-        if (v !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
-          yield this.#valList[i]
-        }
-      }
-    }
-    /**
-     * Inverse order version of {@link LRUCache.values}
-     *
-     * Return a generator yielding the values in the cache,
-     * in order from least recently used to most recently used.
-     */
-    *rvalues() {
-      for (const i of this.#rindexes()) {
-        const v = this.#valList[i]
-        if (v !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
-          yield this.#valList[i]
-        }
-      }
-    }
-    /**
-     * Iterating over the cache itself yields the same results as
-     * {@link LRUCache.entries}
-     */
-    [Symbol.iterator]() {
-      return this.entries()
-    }
-    /**
-     * A String value that is used in the creation of the default string
-     * description of an object. Called by the built-in method
-     * `Object.prototype.toString`.
-     */
-    [Symbol.toStringTag] = 'LRUCache'
-    /**
-     * Find a value for which the supplied fn method returns a truthy value,
-     * similar to `Array.find()`. fn is called as `fn(value, key, cache)`.
-     */
-    find(fn, getOptions = {}) {
-      for (const i of this.#indexes()) {
-        const v = this.#valList[i]
-        const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v
-        if (value === undefined) {
-          continue
-        }
-        if (fn(value, this.#keyList[i], this)) {
-          return this.get(this.#keyList[i], getOptions)
-        }
-      }
-    }
-    /**
-     * Call the supplied function on each item in the cache, in order from most
-     * recently used to least recently used.
-     *
-     * `fn` is called as `fn(value, key, cache)`.
-     *
-     * If `thisp` is provided, function will be called in the `this`-context of
-     * the provided object, or the cache if no `thisp` object is provided.
-     *
-     * Does not update age or recenty of use, or iterate over stale values.
-     */
-    forEach(fn, thisp = this) {
-      for (const i of this.#indexes()) {
-        const v = this.#valList[i]
-        const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v
-        if (value === undefined) {
-          continue
-        }
-        fn.call(thisp, value, this.#keyList[i], this)
-      }
-    }
-    /**
-     * The same as {@link LRUCache.forEach} but items are iterated over in
-     * reverse order.  (ie, less recently used items are iterated over first.)
-     */
-    rforEach(fn, thisp = this) {
-      for (const i of this.#rindexes()) {
-        const v = this.#valList[i]
-        const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v
-        if (value === undefined) {
-          continue
-        }
-        fn.call(thisp, value, this.#keyList[i], this)
-      }
-    }
-    /**
-     * Delete any stale entries. Returns true if anything was removed,
-     * false otherwise.
-     */
-    purgeStale() {
-      let deleted = false
-      for (const i of this.#rindexes({
-        allowStale: true
-      })) {
-        if (this.#isStale(i)) {
-          this.#delete(this.#keyList[i], 'expire')
-          deleted = true
-        }
-      }
-      return deleted
-    }
-    /**
-     * Get the extended info about a given entry, to get its value, size, and
-     * TTL info simultaneously. Returns `undefined` if the key is not present.
-     *
-     * Unlike {@link LRUCache#dump}, which is designed to be portable and survive
-     * serialization, the `start` value is always the current timestamp, and the
-     * `ttl` is a calculated remaining time to live (negative if expired).
-     *
-     * Always returns stale values, if their info is found in the cache, so be
-     * sure to check for expirations (ie, a negative {@link LRUCache.Entry#ttl})
-     * if relevant.
-     */
-    info(key) {
-      const i = this.#keyMap.get(key)
-      if (i === undefined) {
-        return undefined
-      }
-      const v = this.#valList[i]
-      const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v
-      if (value === undefined) {
-        return undefined
-      }
-      const entry = {
-        value
-      }
-      if (this.#ttls && this.#starts) {
-        const ttl = this.#ttls[i]
-        const start = this.#starts[i]
-        if (ttl && start) {
-          const remain = ttl - (perf.now() - start)
-          entry.ttl = remain
-          entry.start = Date.now()
-        }
-      }
-      if (this.#sizes) {
-        entry.size = this.#sizes[i]
-      }
-      return entry
-    }
-    /**
-     * Return an array of [key, {@link LRUCache.Entry}] tuples which can be
-     * passed to {@link LRUCache#load}.
-     *
-     * The `start` fields are calculated relative to a portable `Date.now()`
-     * timestamp, even if `performance.now()` is available.
-     *
-     * Stale entries are always included in the `dump`, even if
-     * {@link LRUCache.OptionsBase.allowStale} is false.
-     *
-     * Note: this returns an actual array, not a generator, so it can be more
-     * easily passed around.
-     */
-    dump() {
-      const arr = []
-      for (const i of this.#indexes({
-        allowStale: true
-      })) {
-        const key = this.#keyList[i]
-        const v = this.#valList[i]
-        const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v
-        if (value === undefined || key === undefined) {
-          continue
-        }
-        const entry = {
-          value
-        }
-        if (this.#ttls && this.#starts) {
-          entry.ttl = this.#ttls[i]
-          // always dump the start relative to a portable timestamp
-          // it's ok for this to be a bit slow, it's a rare operation.
-          const age = perf.now() - this.#starts[i]
-          entry.start = Math.floor(Date.now() - age)
-        }
-        if (this.#sizes) {
-          entry.size = this.#sizes[i]
-        }
-        arr.unshift([key, entry])
-      }
-      return arr
-    }
-    /**
-     * Reset the cache and load in the items in entries in the order listed.
-     *
-     * The shape of the resulting cache may be different if the same options are
-     * not used in both caches.
-     *
-     * The `start` fields are assumed to be calculated relative to a portable
-     * `Date.now()` timestamp, even if `performance.now()` is available.
-     */
-    load(arr) {
-      this.clear()
-      for (const [key, entry] of arr) {
-        if (entry.start) {
-          // entry.start is a portable timestamp, but we may be using
-          // node's performance.now(), so calculate the offset, so that
-          // we get the intended remaining TTL, no matter how long it's
-          // been on ice.
-          //
-          // it's ok for this to be a bit slow, it's a rare operation.
-          const age = Date.now() - entry.start
-          entry.start = perf.now() - age
-        }
-        this.set(key, entry.value, entry)
-      }
-    }
-    /**
-     * Add a value to the cache.
-     *
-     * Note: if `undefined` is specified as a value, this is an alias for
-     * {@link LRUCache#delete}
-     *
-     * Fields on the {@link LRUCache.SetOptions} options param will override
-     * their corresponding values in the constructor options for the scope
-     * of this single `set()` operation.
-     *
-     * If `start` is provided, then that will set the effective start
-     * time for the TTL calculation. Note that this must be a previous
-     * value of `performance.now()` if supported, or a previous value of
-     * `Date.now()` if not.
-     *
-     * Options object may also include `size`, which will prevent
-     * calling the `sizeCalculation` function and just use the specified
-     * number if it is a positive integer, and `noDisposeOnSet` which
-     * will prevent calling a `dispose` function in the case of
-     * overwrites.
-     *
-     * If the `size` (or return value of `sizeCalculation`) for a given
-     * entry is greater than `maxEntrySize`, then the item will not be
-     * added to the cache.
-     *
-     * Will update the recency of the entry.
-     *
-     * If the value is `undefined`, then this is an alias for
-     * `cache.delete(key)`. `undefined` is never stored in the cache.
-     */
-    set(k, v, setOptions = {}) {
-      if (v === undefined) {
-        this.delete(k)
-        return this
-      }
-      const {
-        ttl = this.ttl,
-        start,
-        noDisposeOnSet = this.noDisposeOnSet,
-        sizeCalculation = this.sizeCalculation,
-        status
-      } = setOptions
-      let { noUpdateTTL = this.noUpdateTTL } = setOptions
-      const size = this.#requireSize(
-        k,
-        v,
-        setOptions.size || 0,
-        sizeCalculation
-      )
-      // if the item doesn't fit, don't do anything
-      // NB: maxEntrySize set to maxSize by default
-      if (this.maxEntrySize && size > this.maxEntrySize) {
-        if (status) {
-          status.set = 'miss'
-          status.maxEntrySizeExceeded = true
-        }
-        // have to delete, in case something is there already.
-        this.#delete(k, 'set')
-        return this
-      }
-      let index = this.#size === 0 ? undefined : this.#keyMap.get(k)
-      if (index === undefined) {
-        // addition
-        index =
-          this.#size === 0
-            ? this.#tail
-            : this.#free.length !== 0
-              ? this.#free.pop()
-              : this.#size === this.#max
-                ? this.#evict(false)
-                : this.#size
-        this.#keyList[index] = k
-        this.#valList[index] = v
-        this.#keyMap.set(k, index)
-        this.#next[this.#tail] = index
-        this.#prev[index] = this.#tail
-        this.#tail = index
-        this.#size++
-        this.#addItemSize(index, size, status)
-        if (status) {
-          status.set = 'add'
-        }
-        noUpdateTTL = false
-        if (this.#hasOnInsert) {
-          this.#onInsert?.(v, k, 'add')
-        }
-      } else {
-        // update
-        this.#moveToTail(index)
-        const oldVal = this.#valList[index]
-        if (v !== oldVal) {
-          if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
-            oldVal.__abortController.abort(new Error('replaced'))
-            const { __staleWhileFetching: s } = oldVal
-            if (s !== undefined && !noDisposeOnSet) {
-              if (this.#hasDispose) {
-                this.#dispose?.(s, k, 'set')
-              }
-              if (this.#hasDisposeAfter) {
-                this.#disposed?.push([s, k, 'set'])
-              }
-            }
-          } else if (!noDisposeOnSet) {
-            if (this.#hasDispose) {
-              this.#dispose?.(oldVal, k, 'set')
-            }
-            if (this.#hasDisposeAfter) {
-              this.#disposed?.push([oldVal, k, 'set'])
-            }
-          }
-          this.#removeItemSize(index)
-          this.#addItemSize(index, size, status)
-          this.#valList[index] = v
-          if (status) {
-            status.set = 'replace'
-            const oldValue =
-              oldVal && this.#isBackgroundFetch(oldVal)
-                ? oldVal.__staleWhileFetching
-                : oldVal
-            if (oldValue !== undefined) {
-              status.oldValue = oldValue
-            }
-          }
-        } else if (status) {
-          status.set = 'update'
-        }
-        if (this.#hasOnInsert) {
-          this.onInsert?.(v, k, v === oldVal ? 'update' : 'replace')
-        }
-      }
-      if (ttl !== 0 && !this.#ttls) {
-        this.#initializeTTLTracking()
-      }
-      if (this.#ttls) {
-        if (!noUpdateTTL) {
-          this.#setItemTTL(index, ttl, start)
-        }
-        if (status) {
-          this.#statusTTL(status, index)
-        }
-      }
-      if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
-        const dt = this.#disposed
-        let task
-        while ((task = dt?.shift())) {
-          this.#disposeAfter?.(...task)
-        }
-      }
-      return this
-    }
-    /**
-     * Evict the least recently used item, returning its value or
-     * `undefined` if cache is empty.
-     */
-    pop() {
-      try {
-        while (this.#size) {
-          const val = this.#valList[this.#head]
-          this.#evict(true)
-          if (this.#isBackgroundFetch(val)) {
-            if (val.__staleWhileFetching) {
-              return val.__staleWhileFetching
-            }
-          } else if (val !== undefined) {
-            return val
-          }
-        }
-      } finally {
-        if (this.#hasDisposeAfter && this.#disposed) {
-          const dt = this.#disposed
-          let task
-          while ((task = dt?.shift())) {
-            this.#disposeAfter?.(...task)
-          }
-        }
-      }
-    }
-    #evict(free) {
-      const head = this.#head
-      const k = this.#keyList[head]
-      const v = this.#valList[head]
-      if (this.#hasFetchMethod && this.#isBackgroundFetch(v)) {
-        v.__abortController.abort(new Error('evicted'))
-      } else if (this.#hasDispose || this.#hasDisposeAfter) {
-        if (this.#hasDispose) {
-          this.#dispose?.(v, k, 'evict')
-        }
-        if (this.#hasDisposeAfter) {
-          this.#disposed?.push([v, k, 'evict'])
-        }
-      }
-      this.#removeItemSize(head)
-      // if we aren't about to use the index, then null these out
-      if (free) {
-        this.#keyList[head] = undefined
-        this.#valList[head] = undefined
-        this.#free.push(head)
-      }
-      if (this.#size === 1) {
-        this.#head = this.#tail = 0
-        this.#free.length = 0
-      } else {
-        this.#head = this.#next[head]
-      }
-      this.#keyMap.delete(k)
-      this.#size--
-      return head
-    }
-    /**
-     * Check if a key is in the cache, without updating the recency of use.
-     * Will return false if the item is stale, even though it is technically
-     * in the cache.
-     *
-     * Check if a key is in the cache, without updating the recency of
-     * use. Age is updated if {@link LRUCache.OptionsBase.updateAgeOnHas} is set
-     * to `true` in either the options or the constructor.
-     *
-     * Will return `false` if the item is stale, even though it is technically in
-     * the cache. The difference can be determined (if it matters) by using a
-     * `status` argument, and inspecting the `has` field.
-     *
-     * Will not update item age unless
-     * {@link LRUCache.OptionsBase.updateAgeOnHas} is set.
-     */
-    has(k, hasOptions = {}) {
-      const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions
-      const index = this.#keyMap.get(k)
-      if (index !== undefined) {
-        const v = this.#valList[index]
-        if (
-          this.#isBackgroundFetch(v) &&
-          v.__staleWhileFetching === undefined
-        ) {
-          return false
-        }
-        if (!this.#isStale(index)) {
-          if (updateAgeOnHas) {
-            this.#updateItemAge(index)
-          }
-          if (status) {
-            status.has = 'hit'
-            this.#statusTTL(status, index)
-          }
-          return true
-        } else if (status) {
-          status.has = 'stale'
-          this.#statusTTL(status, index)
-        }
-      } else if (status) {
-        status.has = 'miss'
-      }
-      return false
-    }
-    /**
-     * Like {@link LRUCache#get} but doesn't update recency or delete stale
-     * items.
-     *
-     * Returns `undefined` if the item is stale, unless
-     * {@link LRUCache.OptionsBase.allowStale} is set.
-     */
-    peek(k, peekOptions = {}) {
-      const { allowStale = this.allowStale } = peekOptions
-      const index = this.#keyMap.get(k)
-      if (index === undefined || (!allowStale && this.#isStale(index))) {
-        return
-      }
-      const v = this.#valList[index]
-      // either stale and allowed, or forcing a refresh of non-stale value
-      return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v
-    }
-    #backgroundFetch(k, index, options, context) {
-      const v = index === undefined ? undefined : this.#valList[index]
-      if (this.#isBackgroundFetch(v)) {
-        return v
-      }
-      const ac = new AC()
-      const { signal } = options
-      // when/if our AC signals, then stop listening to theirs.
-      signal?.addEventListener('abort', () => ac.abort(signal.reason), {
-        signal: ac.signal
-      })
-      const fetchOpts = {
-        signal: ac.signal,
-        options,
-        context
-      }
-      const cb = (v, updateCache = false) => {
-        const { aborted } = ac.signal
-        const ignoreAbort = options.ignoreFetchAbort && v !== undefined
-        if (options.status) {
-          if (aborted && !updateCache) {
-            options.status.fetchAborted = true
-            options.status.fetchError = ac.signal.reason
-            if (ignoreAbort) {
-              options.status.fetchAbortIgnored = true
-            }
-          } else {
-            options.status.fetchResolved = true
-          }
-        }
-        if (aborted && !ignoreAbort && !updateCache) {
-          return fetchFail(ac.signal.reason)
-        }
-        // either we didn't abort, and are still here, or we did, and ignored
-        const bf = p
-        if (this.#valList[index] === p) {
-          if (v === undefined) {
-            if (bf.__staleWhileFetching) {
-              this.#valList[index] = bf.__staleWhileFetching
-            } else {
-              this.#delete(k, 'fetch')
-            }
-          } else {
-            if (options.status) {
-              options.status.fetchUpdated = true
-            }
-            this.set(k, v, fetchOpts.options)
-          }
-        }
-        return v
-      }
-      const eb = er => {
-        if (options.status) {
-          options.status.fetchRejected = true
-          options.status.fetchError = er
-        }
-        return fetchFail(er)
-      }
-      const fetchFail = er => {
-        const { aborted } = ac.signal
-        const allowStaleAborted = aborted && options.allowStaleOnFetchAbort
-        const allowStale =
-          allowStaleAborted || options.allowStaleOnFetchRejection
-        const noDelete = allowStale || options.noDeleteOnFetchRejection
-        const bf = p
-        if (this.#valList[index] === p) {
-          // if we allow stale on fetch rejections, then we need to ensure that
-          // the stale value is not removed from the cache when the fetch fails.
-          const del = !noDelete || bf.__staleWhileFetching === undefined
-          if (del) {
-            this.#delete(k, 'fetch')
-          } else if (!allowStaleAborted) {
-            // still replace the *promise* with the stale value,
-            // since we are done with the promise at this point.
-            // leave it untouched if we're still waiting for an
-            // aborted background fetch that hasn't yet returned.
-            this.#valList[index] = bf.__staleWhileFetching
-          }
-        }
-        if (allowStale) {
-          if (options.status && bf.__staleWhileFetching !== undefined) {
-            options.status.returnedStale = true
-          }
-          return bf.__staleWhileFetching
-        } else if (bf.__returned === bf) {
-          throw er
-        }
-      }
-      const pcall = (res, rej) => {
-        const fmp = this.#fetchMethod?.(k, v, fetchOpts)
-        if (fmp && fmp instanceof Promise) {
-          fmp.then(v => res(v === undefined ? undefined : v), rej)
-        }
-        // ignored, we go until we finish, regardless.
-        // defer check until we are actually aborting,
-        // so fetchMethod can override.
-        ac.signal.addEventListener('abort', () => {
-          if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
-            res(undefined)
-            // when it eventually resolves, update the cache.
-            if (options.allowStaleOnFetchAbort) {
-              res = v => cb(v, true)
-            }
-          }
-        })
-      }
-      if (options.status) {
-        options.status.fetchDispatched = true
-      }
-      const p = new Promise(pcall).then(cb, eb)
-      const bf = Object.assign(p, {
-        __abortController: ac,
-        __staleWhileFetching: v,
-        __returned: undefined
-      })
-      if (index === undefined) {
-        // internal, don't expose status.
-        this.set(k, bf, {
-          ...fetchOpts.options,
-          status: undefined
-        })
-        index = this.#keyMap.get(k)
-      } else {
-        this.#valList[index] = bf
-      }
-      return bf
-    }
-    #isBackgroundFetch(p) {
-      if (!this.#hasFetchMethod) {
-        return false
-      }
-      const b = p
-      return (
-        !!b &&
-        b instanceof Promise &&
-        b.hasOwnProperty('__staleWhileFetching') &&
-        b.__abortController instanceof AC
-      )
-    }
-    async fetch(k, fetchOptions = {}) {
-      const {
-        // get options
-        allowStale = this.allowStale,
-        updateAgeOnGet = this.updateAgeOnGet,
-        noDeleteOnStaleGet = this.noDeleteOnStaleGet,
-        // set options
-        ttl = this.ttl,
-        noDisposeOnSet = this.noDisposeOnSet,
-        size = 0,
-        sizeCalculation = this.sizeCalculation,
-        noUpdateTTL = this.noUpdateTTL,
-        // fetch exclusive options
-        noDeleteOnFetchRejection = this.noDeleteOnFetchRejection,
-        allowStaleOnFetchRejection = this.allowStaleOnFetchRejection,
-        ignoreFetchAbort = this.ignoreFetchAbort,
-        allowStaleOnFetchAbort = this.allowStaleOnFetchAbort,
-        context,
-        forceRefresh = false,
-        status,
-        signal
-      } = fetchOptions
-      if (!this.#hasFetchMethod) {
-        if (status) {
-          status.fetch = 'get'
-        }
-        return this.get(k, {
-          allowStale,
-          updateAgeOnGet,
-          noDeleteOnStaleGet,
-          status
-        })
-      }
-      const options = {
-        allowStale,
-        updateAgeOnGet,
-        noDeleteOnStaleGet,
-        ttl,
-        noDisposeOnSet,
-        size,
-        sizeCalculation,
-        noUpdateTTL,
-        noDeleteOnFetchRejection,
-        allowStaleOnFetchRejection,
-        allowStaleOnFetchAbort,
-        ignoreFetchAbort,
-        status,
-        signal
-      }
-      let index = this.#keyMap.get(k)
-      if (index === undefined) {
-        if (status) {
-          status.fetch = 'miss'
-        }
-        const p = this.#backgroundFetch(k, index, options, context)
-        return (p.__returned = p)
-      } else {
-        // in cache, maybe already fetching
-        const v = this.#valList[index]
-        if (this.#isBackgroundFetch(v)) {
-          const stale = allowStale && v.__staleWhileFetching !== undefined
-          if (status) {
-            status.fetch = 'inflight'
-            if (stale) {
-              status.returnedStale = true
-            }
-          }
-          return stale ? v.__staleWhileFetching : (v.__returned = v)
-        }
-        // if we force a refresh, that means do NOT serve the cached value,
-        // unless we are already in the process of refreshing the cache.
-        const isStale = this.#isStale(index)
-        if (!forceRefresh && !isStale) {
-          if (status) {
-            status.fetch = 'hit'
-          }
-          this.#moveToTail(index)
-          if (updateAgeOnGet) {
-            this.#updateItemAge(index)
-          }
-          if (status) {
-            this.#statusTTL(status, index)
-          }
-          return v
-        }
-        // ok, it is stale or a forced refresh, and not already fetching.
-        // refresh the cache.
-        const p = this.#backgroundFetch(k, index, options, context)
-        const hasStale = p.__staleWhileFetching !== undefined
-        const staleVal = hasStale && allowStale
-        if (status) {
-          status.fetch = isStale ? 'stale' : 'refresh'
-          if (staleVal && isStale) {
-            status.returnedStale = true
-          }
-        }
-        return staleVal ? p.__staleWhileFetching : (p.__returned = p)
-      }
-    }
-    async forceFetch(k, fetchOptions = {}) {
-      const v = await this.fetch(k, fetchOptions)
-      if (v === undefined) {
-        throw new Error('fetch() returned undefined')
-      }
-      return v
-    }
-    memo(k, memoOptions = {}) {
-      const memoMethod = this.#memoMethod
-      if (!memoMethod) {
-        throw new Error('no memoMethod provided to constructor')
-      }
-      const { context, forceRefresh, ...options } = memoOptions
-      const v = this.get(k, options)
-      if (!forceRefresh && v !== undefined) {
-        return v
-      }
-      const vv = memoMethod(k, v, {
-        options,
-        context
-      })
-      this.set(k, vv, options)
-      return vv
-    }
-    /**
-     * Return a value from the cache. Will update the recency of the cache
-     * entry found.
-     *
-     * If the key is not found, get() will return `undefined`.
-     */
-    get(k, getOptions = {}) {
-      const {
-        allowStale = this.allowStale,
-        updateAgeOnGet = this.updateAgeOnGet,
-        noDeleteOnStaleGet = this.noDeleteOnStaleGet,
-        status
-      } = getOptions
-      const index = this.#keyMap.get(k)
-      if (index !== undefined) {
-        const value = this.#valList[index]
-        const fetching = this.#isBackgroundFetch(value)
-        if (status) {
-          this.#statusTTL(status, index)
-        }
-        if (this.#isStale(index)) {
-          if (status) {
-            status.get = 'stale'
-          }
-          // delete only if not an in-flight background fetch
-          if (!fetching) {
-            if (!noDeleteOnStaleGet) {
-              this.#delete(k, 'expire')
-            }
-            if (status && allowStale) {
-              status.returnedStale = true
-            }
-            return allowStale ? value : undefined
-          } else {
-            if (
-              status &&
-              allowStale &&
-              value.__staleWhileFetching !== undefined
-            ) {
-              status.returnedStale = true
-            }
-            return allowStale ? value.__staleWhileFetching : undefined
-          }
-        } else {
-          if (status) {
-            status.get = 'hit'
-          }
-          // if we're currently fetching it, we don't actually have it yet
-          // it's not stale, which means this isn't a staleWhileRefetching.
-          // If it's not stale, and fetching, AND has a __staleWhileFetching
-          // value, then that means the user fetched with {forceRefresh:true},
-          // so it's safe to return that value.
-          if (fetching) {
-            return value.__staleWhileFetching
-          }
-          this.#moveToTail(index)
-          if (updateAgeOnGet) {
-            this.#updateItemAge(index)
-          }
-          return value
+              const prev = pp[i - 1]
+              if (p !== exports.GLOBSTAR || prev === exports.GLOBSTAR) {
+                return
+              }
+              if (prev === undefined) {
+                if (next !== undefined && next !== exports.GLOBSTAR) {
+                  pp[i + 1] = '(?:\\/|' + twoStar + '\\/)?' + next
+                } else {
+                  pp[i] = twoStar
+                }
+              } else if (next === undefined) {
+                pp[i - 1] = prev + '(?:\\/|' + twoStar + ')?'
+              } else if (next !== exports.GLOBSTAR) {
+                pp[i - 1] = prev + '(?:\\/|\\/' + twoStar + '\\/)' + next
+                pp[i + 1] = exports.GLOBSTAR
+              }
+            })
+            return pp.filter(p => p !== exports.GLOBSTAR).join('/')
+          })
+          .join('|')
+        // need to wrap in parens if we had more than one thing with |,
+        // otherwise only the first will be anchored to ^ and the last to $
+        const [open, close] = set.length > 1 ? ['(?:', ')'] : ['', '']
+        // must match entire pattern
+        // ending in a * or ** will make it less strict.
+        re = '^' + open + re + close + '$'
+        // can match anything, as long as it's not this.
+        if (this.negate) {
+          re = '^(?!' + re + ').+$'
         }
-      } else if (status) {
-        status.get = 'miss'
+        try {
+          this.regexp = new RegExp(re, [...flags].join(''))
+          /* c8 ignore start */
+        } catch (ex) {
+          // should be impossible
+          this.regexp = false
+        }
+        /* c8 ignore stop */
+        return this.regexp
       }
-    }
-    #connect(p, n) {
-      this.#prev[n] = p
-      this.#next[p] = n
-    }
-    #moveToTail(index) {
-      // if tail already, nothing to do
-      // if head, move head to next[index]
-      // else
-      //   move next[prev[index]] to next[index] (head has no prev)
-      //   move prev[next[index]] to prev[index]
-      // prev[index] = tail
-      // next[tail] = index
-      // tail = index
-      if (index !== this.#tail) {
-        if (index === this.#head) {
-          this.#head = this.#next[index]
+      slashSplit(p) {
+        // if p starts with // on windows, we preserve that
+        // so that UNC paths aren't broken.  Otherwise, any number of
+        // / characters are coalesced into one, unless
+        // preserveMultipleSlashes is set to true.
+        if (this.preserveMultipleSlashes) {
+          return p.split('/')
+        } else if (this.isWindows && /^\/\/[^/]+/.test(p)) {
+          // add an extra '' for the one we lose
+          return ['', ...p.split(/\/+/)]
         } else {
-          this.#connect(this.#prev[index], this.#next[index])
+          return p.split(/\/+/)
         }
-        this.#connect(this.#tail, index)
-        this.#tail = index
       }
-    }
-    /**
-     * Deletes a key out of the cache.
-     *
-     * Returns true if the key was deleted, false otherwise.
-     */
-    delete(k) {
-      return this.#delete(k, 'delete')
-    }
-    #delete(k, reason) {
-      let deleted = false
-      if (this.#size !== 0) {
-        const index = this.#keyMap.get(k)
-        if (index !== undefined) {
-          deleted = true
-          if (this.#size === 1) {
-            this.#clear(reason)
-          } else {
-            this.#removeItemSize(index)
-            const v = this.#valList[index]
-            if (this.#isBackgroundFetch(v)) {
-              v.__abortController.abort(new Error('deleted'))
-            } else if (this.#hasDispose || this.#hasDisposeAfter) {
-              if (this.#hasDispose) {
-                this.#dispose?.(v, k, reason)
-              }
-              if (this.#hasDisposeAfter) {
-                this.#disposed?.push([v, k, reason])
-              }
-            }
-            this.#keyMap.delete(k)
-            this.#keyList[index] = undefined
-            this.#valList[index] = undefined
-            if (index === this.#tail) {
-              this.#tail = this.#prev[index]
-            } else if (index === this.#head) {
-              this.#head = this.#next[index]
-            } else {
-              const pi = this.#prev[index]
-              this.#next[pi] = this.#next[index]
-              const ni = this.#next[index]
-              this.#prev[ni] = this.#prev[index]
-            }
-            this.#size--
-            this.#free.push(index)
-          }
+      match(f, partial = this.partial) {
+        this.debug('match', f, this.pattern)
+        // short-circuit in the case of busted things.
+        // comments, etc.
+        if (this.comment) {
+          return false
         }
-      }
-      if (this.#hasDisposeAfter && this.#disposed?.length) {
-        const dt = this.#disposed
-        let task
-        while ((task = dt?.shift())) {
-          this.#disposeAfter?.(...task)
+        if (this.empty) {
+          return f === ''
         }
-      }
-      return deleted
-    }
-    /**
-     * Clear the cache entirely, throwing away all values.
-     */
-    clear() {
-      return this.#clear('delete')
-    }
-    #clear(reason) {
-      for (const index of this.#rindexes({
-        allowStale: true
-      })) {
-        const v = this.#valList[index]
-        if (this.#isBackgroundFetch(v)) {
-          v.__abortController.abort(new Error('deleted'))
-        } else {
-          const k = this.#keyList[index]
-          if (this.#hasDispose) {
-            this.#dispose?.(v, k, reason)
+        if (f === '/' && partial) {
+          return true
+        }
+        const options = this.options
+        // windows: need to use /, not \
+        if (this.isWindows) {
+          f = f.split('\\').join('/')
+        }
+        // treat the test path as a set of pathparts.
+        const ff = this.slashSplit(f)
+        this.debug(this.pattern, 'split', ff)
+        // just ONE of the pattern sets in this.set needs to match
+        // in order for it to be valid.  If negating, then just one
+        // match means that we have failed.
+        // Either way, return on the first hit.
+        const set = this.set
+        this.debug(this.pattern, 'set', set)
+        // Find the basename of the path by looking for the last non-empty segment
+        let filename = ff[ff.length - 1]
+        if (!filename) {
+          for (let i = ff.length - 2; !filename && i >= 0; i--) {
+            filename = ff[i]
           }
-          if (this.#hasDisposeAfter) {
-            this.#disposed?.push([v, k, reason])
+        }
+        for (let i = 0; i < set.length; i++) {
+          const pattern = set[i]
+          let file = ff
+          if (options.matchBase && pattern.length === 1) {
+            file = [filename]
+          }
+          const hit = this.matchOne(file, pattern, partial)
+          if (hit) {
+            if (options.flipNegate) {
+              return true
+            }
+            return !this.negate
           }
         }
+        // didn't get any hits.  this is success if it's a negative
+        // pattern, failure otherwise.
+        if (options.flipNegate) {
+          return false
+        }
+        return this.negate
       }
-      this.#keyMap.clear()
-      this.#valList.fill(undefined)
-      this.#keyList.fill(undefined)
-      if (this.#ttls && this.#starts) {
-        this.#ttls.fill(0)
-        this.#starts.fill(0)
+      static defaults(def) {
+        return exports.minimatch.defaults(def).Minimatch
       }
-      if (this.#sizes) {
-        this.#sizes.fill(0)
+    }
+    exports.Minimatch = Minimatch
+    /* c8 ignore start */
+    const ast_js_2 = requireAst()
+    Object.defineProperty(exports, 'AST', {
+      enumerable: true,
+      get: function () {
+        return ast_js_2.AST
       }
-      this.#head = 0
-      this.#tail = 0
-      this.#free.length = 0
-      this.#calculatedSize = 0
-      this.#size = 0
-      if (this.#hasDisposeAfter && this.#disposed) {
-        const dt = this.#disposed
-        let task
-        while ((task = dt?.shift())) {
-          this.#disposeAfter?.(...task)
-        }
+    })
+    const escape_js_2 = require_escape$1()
+    Object.defineProperty(exports, 'escape', {
+      enumerable: true,
+      get: function () {
+        return escape_js_2.escape
       }
-    }
-  }
-  commonjs$2.LRUCache = LRUCache
-  return commonjs$2
+    })
+    const unescape_js_2 = require_unescape()
+    Object.defineProperty(exports, 'unescape', {
+      enumerable: true,
+      get: function () {
+        return unescape_js_2.unescape
+      }
+    })
+    /* c8 ignore stop */
+    exports.minimatch.AST = ast_js_1.AST
+    exports.minimatch.Minimatch = Minimatch
+    exports.minimatch.escape = escape_js_1.escape
+    exports.minimatch.unescape = unescape_js_1.unescape
+  })(commonjs$3)
+  return commonjs$3
 }
 
+const glob = {}
+
+const commonjs$2 = {}
+
 const commonjs$1 = {}
 
 let hasRequiredCommonjs$3
@@ -8674,7 +7033,7 @@ function requireCommonjs$3() {
 let hasRequiredCommonjs$2
 function requireCommonjs$2() {
   if (hasRequiredCommonjs$2) {
-    return commonjs$3
+    return commonjs$2
   }
   hasRequiredCommonjs$2 = 1
   const __createBinding =
@@ -8731,22 +7090,22 @@ function requireCommonjs$2() {
       __setModuleDefault(result, mod)
       return result
     }
-  Object.defineProperty(commonjs$3, '__esModule', {
+  Object.defineProperty(commonjs$2, '__esModule', {
     value: true
   })
-  commonjs$3.PathScurry =
-    commonjs$3.Path =
-    commonjs$3.PathScurryDarwin =
-    commonjs$3.PathScurryPosix =
-    commonjs$3.PathScurryWin32 =
-    commonjs$3.PathScurryBase =
-    commonjs$3.PathPosix =
-    commonjs$3.PathWin32 =
-    commonjs$3.PathBase =
-    commonjs$3.ChildrenCache =
-    commonjs$3.ResolveCache =
+  commonjs$2.PathScurry =
+    commonjs$2.Path =
+    commonjs$2.PathScurryDarwin =
+    commonjs$2.PathScurryPosix =
+    commonjs$2.PathScurryWin32 =
+    commonjs$2.PathScurryBase =
+    commonjs$2.PathPosix =
+    commonjs$2.PathWin32 =
+    commonjs$2.PathBase =
+    commonjs$2.ChildrenCache =
+    commonjs$2.ResolveCache =
       void 0
-  const lru_cache_1 = /*@__PURE__*/ requireCommonjs$4()
+  const lru_cache_1 = /*@__PURE__*/ requireCommonjs$5()
   const node_path_1 = require$$2$2
   const node_url_1 = require$$0$3
   const fs_1 = require$$0$2
@@ -8862,7 +7221,7 @@ function requireCommonjs$2() {
       })
     }
   }
-  commonjs$3.ResolveCache = ResolveCache
+  commonjs$2.ResolveCache = ResolveCache
   // In order to prevent blowing out the js heap by allocating hundreds of
   // thousands of Path entries when walking extremely large trees, the "children"
   // in this tree are represented by storing an array of Path entries in an
@@ -8887,7 +7246,7 @@ function requireCommonjs$2() {
       })
     }
   }
-  commonjs$3.ChildrenCache = ChildrenCache
+  commonjs$2.ChildrenCache = ChildrenCache
   const setAsCwd = Symbol('PathScurry setAsCwd')
   /**
    * Path objects are sort of like a super-powered
@@ -9961,7 +8320,7 @@ function requireCommonjs$2() {
       }
     }
   }
-  commonjs$3.PathBase = PathBase
+  commonjs$2.PathBase = PathBase
   /**
    * Path class used on win32 systems
    *
@@ -10037,7 +8396,7 @@ function requireCommonjs$2() {
       return rootPath === compare
     }
   }
-  commonjs$3.PathWin32 = PathWin32
+  commonjs$2.PathWin32 = PathWin32
   /**
    * Path class used on all posix systems.
    *
@@ -10088,7 +8447,7 @@ function requireCommonjs$2() {
       )
     }
   }
-  commonjs$3.PathPosix = PathPosix
+  commonjs$2.PathPosix = PathPosix
   /**
    * The base class for all PathScurry classes, providing the interface for path
    * resolution and filesystem operations.
@@ -10736,7 +9095,7 @@ function requireCommonjs$2() {
       this.cwd[setAsCwd](oldCwd)
     }
   }
-  commonjs$3.PathScurryBase = PathScurryBase
+  commonjs$2.PathScurryBase = PathScurryBase
   /**
    * Windows implementation of {@link PathScurryBase}
    *
@@ -10793,7 +9152,7 @@ function requireCommonjs$2() {
       )
     }
   }
-  commonjs$3.PathScurryWin32 = PathScurryWin32
+  commonjs$2.PathScurryWin32 = PathScurryWin32
   /**
    * {@link PathScurryBase} implementation for all posix systems other than Darwin.
    *
@@ -10843,7 +9202,7 @@ function requireCommonjs$2() {
       return p.startsWith('/')
     }
   }
-  commonjs$3.PathScurryPosix = PathScurryPosix
+  commonjs$2.PathScurryPosix = PathScurryPosix
   /**
    * {@link PathScurryBase} implementation for Darwin (macOS) systems.
    *
@@ -10861,26 +9220,26 @@ function requireCommonjs$2() {
       })
     }
   }
-  commonjs$3.PathScurryDarwin = PathScurryDarwin
+  commonjs$2.PathScurryDarwin = PathScurryDarwin
   /**
    * Default {@link PathBase} implementation for the current platform.
    *
    * {@link PathWin32} on Windows systems, {@link PathPosix} on all others.
    */
-  commonjs$3.Path = process.platform === 'win32' ? PathWin32 : PathPosix
+  commonjs$2.Path = process.platform === 'win32' ? PathWin32 : PathPosix
   /**
    * Default {@link PathScurryBase} implementation for the current platform.
    *
    * {@link PathScurryWin32} on Windows systems, {@link PathScurryDarwin} on
    * Darwin (macOS) systems, {@link PathScurryPosix} on all others.
    */
-  commonjs$3.PathScurry =
+  commonjs$2.PathScurry =
     process.platform === 'win32'
       ? PathScurryWin32
       : process.platform === 'darwin'
         ? PathScurryDarwin
         : PathScurryPosix
-  return commonjs$3
+  return commonjs$2
 }
 
 const pattern = {}
@@ -10896,7 +9255,7 @@ function requirePattern() {
     value: true
   })
   pattern.Pattern = void 0
-  const minimatch_1 = requireCommonjs$5()
+  const minimatch_1 = requireCommonjs$4()
   const isPatternList = pl => pl.length >= 1
   const isGlobList = gl => gl.length >= 1
   /**
@@ -11134,7 +9493,7 @@ function requireIgnore() {
     value: true
   })
   ignore.Ignore = void 0
-  const minimatch_1 = requireCommonjs$5()
+  const minimatch_1 = requireCommonjs$4()
   const pattern_js_1 = requirePattern()
   const defaultPlatform =
     typeof process === 'object' &&
@@ -11276,7 +9635,7 @@ function requireProcessor() {
     processor.MatchRecord =
     processor.HasWalkedCache =
       void 0
-  const minimatch_1 = requireCommonjs$5()
+  const minimatch_1 = requireCommonjs$4()
   /**
    * A cache of which patterns have been processed for a given Path
    */
@@ -12021,7 +10380,7 @@ function requireGlob() {
     value: true
   })
   glob.Glob = void 0
-  const minimatch_1 = requireCommonjs$5()
+  const minimatch_1 = requireCommonjs$4()
   const node_url_1 = require$$0$3
   const path_scurry_1 = requireCommonjs$2()
   const pattern_js_1 = requirePattern()
@@ -12292,7 +10651,7 @@ function requireHasMagic() {
     value: true
   })
   hasMagic.hasMagic = void 0
-  const minimatch_1 = requireCommonjs$5()
+  const minimatch_1 = requireCommonjs$4()
   /**
    * Return true if the patterns provided contain any magic glob characters,
    * given the options provided.
@@ -12322,7 +10681,7 @@ function requireHasMagic() {
 let hasRequiredCommonjs$1
 function requireCommonjs$1() {
   if (hasRequiredCommonjs$1) {
-    return commonjs$7
+    return commonjs$4
   }
   hasRequiredCommonjs$1 = 1
   ;(function (exports) {
@@ -12346,10 +10705,10 @@ function requireCommonjs$1() {
     exports.globSync = globSync
     exports.globIterateSync = globIterateSync
     exports.globIterate = globIterate
-    const minimatch_1 = requireCommonjs$5()
+    const minimatch_1 = requireCommonjs$4()
     const glob_js_1 = requireGlob()
     const has_magic_js_1 = requireHasMagic()
-    const minimatch_2 = requireCommonjs$5()
+    const minimatch_2 = requireCommonjs$4()
     Object.defineProperty(exports, 'escape', {
       enumerable: true,
       get: function () {
@@ -12432,8 +10791,8 @@ function requireCommonjs$1() {
       unescape: minimatch_1.unescape
     })
     exports.glob.glob = exports.glob
-  })(commonjs$7)
-  return commonjs$7
+  })(commonjs$4)
+  return commonjs$4
 }
 
 const require$$1$1 = [
@@ -12482,12 +10841,15 @@ const require$$1$1 = [
   'Artistic-1.0-Perl',
   'Artistic-1.0-cl8',
   'Artistic-2.0',
+  'Artistic-dist',
+  'Aspell-RU',
   'BSD-1-Clause',
   'BSD-2-Clause',
   'BSD-2-Clause-Darwin',
   'BSD-2-Clause-Patent',
   'BSD-2-Clause-Views',
   'BSD-2-Clause-first-lines',
+  'BSD-2-Clause-pkgconf-disclaimer',
   'BSD-3-Clause',
   'BSD-3-Clause-Attribution',
   'BSD-3-Clause-Clear',
@@ -12628,6 +10990,7 @@ const require$$1$1 = [
   'Cornell-Lossless-JPEG',
   'Cronyx',
   'Crossword',
+  'CryptoSwift',
   'CrystalStacker',
   'Cube',
   'D-FSL-1.0',
@@ -12638,6 +11001,7 @@ const require$$1$1 = [
   'DRL-1.0',
   'DRL-1.1',
   'DSDP',
+  'DocBook-DTD',
   'DocBook-Schema',
   'DocBook-Stylesheet',
   'DocBook-XML',
@@ -12663,7 +11027,10 @@ const require$$1$1 = [
   'FSFAP-no-warranty-disclaimer',
   'FSFUL',
   'FSFULLR',
+  'FSFULLRSD',
   'FSFULLRWD',
+  'FSL-1.1-ALv2',
+  'FSL-1.1-MIT',
   'FTL',
   'Fair',
   'Ferguson-Twofish',
@@ -12699,11 +11066,13 @@ const require$$1$1 = [
   'GPL-2.0-or-later',
   'GPL-3.0-only',
   'GPL-3.0-or-later',
+  'Game-Programming-Gems',
   'Giftware',
   'Glide',
   'Glulxe',
   'Graphics-Gems',
   'Gutmann',
+  'HDF5',
   'HIDAPI',
   'HP-1986',
   'HP-1989',
@@ -12849,6 +11218,7 @@ const require$$1$1 = [
   'NPL-1.1',
   'NPOSL-3.0',
   'NRL',
+  'NTIA-PD',
   'NTP',
   'NTP-0',
   'Naumen',
@@ -12951,11 +11321,13 @@ const require$$1$1 = [
   'SMLNJ',
   'SMPPL',
   'SNIA',
+  'SOFA',
   'SPL-1.0',
   'SSH-OpenSSH',
   'SSH-short',
   'SSLeay-standalone',
   'SSPL-1.0',
+  'SUL-1.0',
   'SWL',
   'Saxpath',
   'SchemeReport',
@@ -13001,6 +11373,8 @@ const require$$1$1 = [
   'Unicode-TOU',
   'UnixCrypt',
   'Unlicense',
+  'Unlicense-libtelnet',
+  'Unlicense-libwhirlpool',
   'VOSTROM',
   'VSL-1.0',
   'Vim',
@@ -13054,6 +11428,8 @@ const require$$1$1 = [
   'gtkbook',
   'hdparm',
   'iMatix',
+  'jove',
+  'libpng-1.6.35',
   'libpng-2.0',
   'libselinux-1.0',
   'libtiff',
@@ -13061,10 +11437,12 @@ const require$$1$1 = [
   'lsof',
   'magaz',
   'mailprio',
+  'man2html',
   'metamail',
   'mpi-permissive',
   'mpich2',
   'mplus',
+  'ngrep',
   'pkgconf',
   'pnmstitch',
   'psfrag',
@@ -13185,276 +11563,6 @@ const require$$2 = [
   'x11vnc-openssl-exception'
 ]
 
-let scan$1
-let hasRequiredScan$1
-function requireScan$1() {
-  if (hasRequiredScan$1) {
-    return scan$1
-  }
-  hasRequiredScan$1 = 1
-  const licenses = [].concat(require$$1$1).concat(require$$1)
-  const exceptions = require$$2
-  scan$1 = function (source) {
-    let index = 0
-    function hasMore() {
-      return index < source.length
-    }
-
-    // `value` can be a regexp or a string.
-    // If it is recognized, the matching source string is returned and
-    // the index is incremented. Otherwise `undefined` is returned.
-    function read(value) {
-      if (value instanceof RegExp) {
-        const chars = source.slice(index)
-        const match = chars.match(value)
-        if (match) {
-          index += match[0].length
-          return match[0]
-        }
-      } else {
-        if (source.indexOf(value, index) === index) {
-          index += value.length
-          return value
-        }
-      }
-    }
-    function skipWhitespace() {
-      read(/[ ]*/)
-    }
-    function operator() {
-      let string
-      const possibilities = ['WITH', 'AND', 'OR', '(', ')', ':', '+']
-      for (let i = 0; i < possibilities.length; i++) {
-        string = read(possibilities[i])
-        if (string) {
-          break
-        }
-      }
-      if (string === '+' && index > 1 && source[index - 2] === ' ') {
-        throw new Error('Space before `+`')
-      }
-      return (
-        string && {
-          type: 'OPERATOR',
-          string: string
-        }
-      )
-    }
-    function idstring() {
-      return read(/[A-Za-z0-9-.]+/)
-    }
-    function expectIdstring() {
-      const string = idstring()
-      if (!string) {
-        throw new Error('Expected idstring at offset ' + index)
-      }
-      return string
-    }
-    function documentRef() {
-      if (read('DocumentRef-')) {
-        const string = expectIdstring()
-        return {
-          type: 'DOCUMENTREF',
-          string: string
-        }
-      }
-    }
-    function licenseRef() {
-      if (read('LicenseRef-')) {
-        const string = expectIdstring()
-        return {
-          type: 'LICENSEREF',
-          string: string
-        }
-      }
-    }
-    function identifier() {
-      const begin = index
-      const string = idstring()
-      if (licenses.indexOf(string) !== -1) {
-        return {
-          type: 'LICENSE',
-          string: string
-        }
-      } else if (exceptions.indexOf(string) !== -1) {
-        return {
-          type: 'EXCEPTION',
-          string: string
-        }
-      }
-      index = begin
-    }
-
-    // Tries to read the next token. Returns `undefined` if no token is
-    // recognized.
-    function parseToken() {
-      // Ordering matters
-      return operator() || documentRef() || licenseRef() || identifier()
-    }
-    const tokens = []
-    while (hasMore()) {
-      skipWhitespace()
-      if (!hasMore()) {
-        break
-      }
-      const token = parseToken()
-      if (!token) {
-        throw new Error('Unexpected `' + source[index] + '` at offset ' + index)
-      }
-      tokens.push(token)
-    }
-    return tokens
-  }
-  return scan$1
-}
-
-let parse$1
-let hasRequiredParse$1
-function requireParse$1() {
-  if (hasRequiredParse$1) {
-    return parse$1
-  }
-  hasRequiredParse$1 = 1
-
-  // The ABNF grammar in the spec is totally ambiguous.
-  //
-  // This parser follows the operator precedence defined in the
-  // `Order of Precedence and Parentheses` section.
-
-  parse$1 = function (tokens) {
-    let index = 0
-    function hasMore() {
-      return index < tokens.length
-    }
-    function token() {
-      return hasMore() ? tokens[index] : null
-    }
-    function next() {
-      if (!hasMore()) {
-        throw new Error()
-      }
-      index++
-    }
-    function parseOperator(operator) {
-      const t = token()
-      if (t && t.type === 'OPERATOR' && operator === t.string) {
-        next()
-        return t.string
-      }
-    }
-    function parseWith() {
-      if (parseOperator('WITH')) {
-        const t = token()
-        if (t && t.type === 'EXCEPTION') {
-          next()
-          return t.string
-        }
-        throw new Error('Expected exception after `WITH`')
-      }
-    }
-    function parseLicenseRef() {
-      // TODO: Actually, everything is concatenated into one string
-      // for backward-compatibility but it could be better to return
-      // a nice structure.
-      const begin = index
-      let string = ''
-      let t = token()
-      if (t.type === 'DOCUMENTREF') {
-        next()
-        string += 'DocumentRef-' + t.string + ':'
-        if (!parseOperator(':')) {
-          throw new Error('Expected `:` after `DocumentRef-...`')
-        }
-      }
-      t = token()
-      if (t.type === 'LICENSEREF') {
-        next()
-        string += 'LicenseRef-' + t.string
-        return {
-          license: string
-        }
-      }
-      index = begin
-    }
-    function parseLicense() {
-      const t = token()
-      if (t && t.type === 'LICENSE') {
-        next()
-        const node = {
-          license: t.string
-        }
-        if (parseOperator('+')) {
-          node.plus = true
-        }
-        const exception = parseWith()
-        if (exception) {
-          node.exception = exception
-        }
-        return node
-      }
-    }
-    function parseParenthesizedExpression() {
-      const left = parseOperator('(')
-      if (!left) {
-        return
-      }
-      const expr = parseExpression()
-      if (!parseOperator(')')) {
-        throw new Error('Expected `)`')
-      }
-      return expr
-    }
-    function parseAtom() {
-      return (
-        parseParenthesizedExpression() || parseLicenseRef() || parseLicense()
-      )
-    }
-    function makeBinaryOpParser(operator, nextParser) {
-      return function parseBinaryOp() {
-        const left = nextParser()
-        if (!left) {
-          return
-        }
-        if (!parseOperator(operator)) {
-          return left
-        }
-        const right = parseBinaryOp()
-        if (!right) {
-          throw new Error('Expected expression')
-        }
-        return {
-          left: left,
-          conjunction: operator.toLowerCase(),
-          right: right
-        }
-      }
-    }
-    const parseAnd = makeBinaryOpParser('AND', parseAtom)
-    const parseExpression = makeBinaryOpParser('OR', parseAnd)
-    const node = parseExpression()
-    if (!node || hasMore()) {
-      throw new Error('Syntax error')
-    }
-    return node
-  }
-  return parse$1
-}
-
-let spdxExpressionParse$1
-let hasRequiredSpdxExpressionParse$1
-function requireSpdxExpressionParse$1() {
-  if (hasRequiredSpdxExpressionParse$1) {
-    return spdxExpressionParse$1
-  }
-  hasRequiredSpdxExpressionParse$1 = 1
-  const scan = requireScan$1()
-  const parse = requireParse$1()
-  spdxExpressionParse$1 = function (source) {
-    return parse(scan(source))
-  }
-  return spdxExpressionParse$1
-}
-
 let scan
 let hasRequiredScan
 function requireScan() {
@@ -14146,7 +12254,7 @@ function requireValidateNpmPackageLicense() {
     return validateNpmPackageLicense
   }
   hasRequiredValidateNpmPackageLicense = 1
-  const parse = requireSpdxExpressionParse$1()
+  const parse = requireSpdxExpressionParse()
   const correct = requireSpdxCorrect()
   const genericWarning =
     'license should be ' +
@@ -17716,7 +15824,7 @@ function requireDiff() {
     return diff_1
   }
   hasRequiredDiff = 1
-  const parse = requireParse$2()
+  const parse = requireParse$1()
   const diff = (version1, version2) => {
     const v1 = parse(version1, null, true)
     const v2 = parse(version2, null, true)
@@ -17815,7 +15923,7 @@ function requirePrerelease() {
     return prerelease_1
   }
   hasRequiredPrerelease = 1
-  const parse = requireParse$2()
+  const parse = requireParse$1()
   const prerelease = (version, options) => {
     const parsed = parse(version, options)
     return parsed && parsed.prerelease.length ? parsed.prerelease : null
@@ -18046,7 +16154,7 @@ function requireCoerce() {
   }
   hasRequiredCoerce = 1
   const SemVer = requireSemver$1()
-  const parse = requireParse$2()
+  const parse = requireParse$1()
   const { safeRe: re, t } = requireRe()
   const coerce = (version, options) => {
     if (version instanceof SemVer) {
@@ -19471,7 +17579,7 @@ function requireSemver() {
   const constants = requireConstants()
   const SemVer = requireSemver$1()
   const identifiers = requireIdentifiers()
-  const parse = requireParse$2()
+  const parse = requireParse$1()
   const valid = requireValid$1()
   const clean = requireClean()
   const inc = requireInc()
@@ -21280,12 +19388,12 @@ function requireDevEngines() {
       wanted === null ||
       Array.isArray(wanted)
     ) {
-      throw new Error(`Invalid non-object value for devEngines`)
+      throw new Error(`Invalid non-object value for "devEngines"`)
     }
     const errors = []
     for (const engine of Object.keys(wanted)) {
       if (!recognizedEngines.includes(engine)) {
-        throw new Error(`Invalid property "${engine}"`)
+        throw new Error(`Invalid property "devEngines.${engine}"`)
       }
       const dependencyAsAuthored = wanted[engine]
       const dependencies = [dependencyAsAuthored].flat()
@@ -21312,7 +19420,7 @@ function requireDevEngines() {
         if (onFail === 'download') {
           onFail = 'error'
         }
-        const err = Object.assign(new Error(`Invalid engine "${engine}"`), {
+        const err = Object.assign(new Error(`Invalid devEngines.${engine}`), {
           errors: depErrors,
           engine,
           isWarn: onFail === 'warn',