storybook 10.2.0-alpha.0 → 10.2.0-alpha.2

package/dist/_node-chunks/{chunk-MTAECA6H.js → chunk-KVNLJSAB.js}

@@ -1,10 +1,10 @@
-import CJS_COMPAT_NODE_URL_skf7bajczt8 from 'node:url';
-import CJS_COMPAT_NODE_PATH_skf7bajczt8 from 'node:path';
-import CJS_COMPAT_NODE_MODULE_skf7bajczt8 from "node:module";
+import CJS_COMPAT_NODE_URL_wtqlduo6et from 'node:url';
+import CJS_COMPAT_NODE_PATH_wtqlduo6et from 'node:path';
+import CJS_COMPAT_NODE_MODULE_wtqlduo6et from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_skf7bajczt8.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_skf7bajczt8.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_skf7bajczt8.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_wtqlduo6et.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_wtqlduo6et.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_wtqlduo6et.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
@@ -12,11 +12,11 @@ var require = CJS_COMPAT_NODE_MODULE_skf7bajczt8.createRequire(import.meta.url);
 import {
   __commonJS,
   __toESM
-} from "./chunk-KX2RIBIP.js";
+} from "./chunk-TOXVUAH2.js";
 
-// ../node_modules/balanced-match/index.js
+// ../../node_modules/balanced-match/index.js
 var require_balanced_match = __commonJS({
-  "../node_modules/balanced-match/index.js"(exports, module) {
+  "../../node_modules/balanced-match/index.js"(exports, module) {
     "use strict";
     module.exports = balanced;
     function balanced(a, b, str) {
@@ -49,9 +49,9 @@ var require_balanced_match = __commonJS({
   }
 });
 
-// ../node_modules/brace-expansion/index.js
+// ../../node_modules/brace-expansion/index.js
 var require_brace_expansion = __commonJS({
-  "../node_modules/brace-expansion/index.js"(exports, module) {
+  "../../node_modules/brace-expansion/index.js"(exports, module) {
     var balanced = require_balanced_match();
     module.exports = expandTop;
     var escSlash = "\0SLASH" + Math.random() + "\0", escOpen = "\0OPEN" + Math.random() + "\0", escClose = "\0CLOSE" + Math.random() + "\0", escComma = "\0COMMA" + Math.random() + "\0", escPeriod = "\0PERIOD" + Math.random() + "\0";
@@ -102,7 +102,7 @@ var require_brace_expansion = __commonJS({
       else {
         var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body), isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body), isSequence = isNumericSequence || isAlphaSequence, isOptions = m.body.indexOf(",") >= 0;
         if (!isSequence && !isOptions)
-          return m.post.match(/,(?!,).*\}/) ? (str = m.pre + "{" + m.body + escClose + m.post, expand2(str)) : [str];
+          return m.post.match(/,.*\}/) ? (str = m.pre + "{" + m.body + escClose + m.post, expand2(str)) : [str];
         var n;
         if (isSequence)
           n = m.body.split(/\.\./);
@@ -145,10 +145,10 @@ var require_brace_expansion = __commonJS({
   }
 });
 
-// ../node_modules/glob/node_modules/minimatch/dist/esm/index.js
+// ../../node_modules/glob/node_modules/minimatch/dist/esm/index.js
 var import_brace_expansion = __toESM(require_brace_expansion(), 1);
 
-// ../node_modules/glob/node_modules/minimatch/dist/esm/assert-valid-pattern.js
+// ../../node_modules/glob/node_modules/minimatch/dist/esm/assert-valid-pattern.js
 var assertValidPattern = (pattern) => {
   if (typeof pattern != "string")
     throw new TypeError("invalid pattern");
@@ -156,7 +156,7 @@ var assertValidPattern = (pattern) => {
     throw new TypeError("pattern is too long");
 };
 
-// ../node_modules/glob/node_modules/minimatch/dist/esm/brace-expressions.js
+// ../../node_modules/glob/node_modules/minimatch/dist/esm/brace-expressions.js
 var posixClasses = {
   "[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", !0],
   "[:alpha:]": ["\\p{L}\\p{Nl}", !0],
@@ -226,10 +226,10 @@ var posixClasses = {
   return [ranges.length && negs.length ? "(" + sranges + "|" + snegs + ")" : ranges.length ? sranges : snegs, uflag, endPos - pos, !0];
 };
 
-// ../node_modules/glob/node_modules/minimatch/dist/esm/unescape.js
+// ../../node_modules/glob/node_modules/minimatch/dist/esm/unescape.js
 var unescape = (s, { windowsPathsNoEscape = !1 } = {}) => windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
 
-// ../node_modules/glob/node_modules/minimatch/dist/esm/ast.js
+// ../../node_modules/glob/node_modules/minimatch/dist/esm/ast.js
 var types = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]), isExtglobType = (c) => types.has(c), startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))", startNoDot = "(?!\\.)", addPatternStart = /* @__PURE__ */ new Set(["[", "."]), justDots = /* @__PURE__ */ new Set(["..", "."]), reSpecials = new Set("().*{}+?[]^$\\!"), regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), qmark = "[^/]", star = qmark + "*?", starNoEmpty = qmark + "+?", AST = class _AST {
   type;
   #root;
@@ -565,10 +565,10 @@ var types = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]), isExtglobType =
   }
 };
 
-// ../node_modules/glob/node_modules/minimatch/dist/esm/escape.js
+// ../../node_modules/glob/node_modules/minimatch/dist/esm/escape.js
 var escape = (s, { windowsPathsNoEscape = !1 } = {}) => windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
 
-// ../node_modules/glob/node_modules/minimatch/dist/esm/index.js
+// ../../node_modules/glob/node_modules/minimatch/dist/esm/index.js
 var minimatch = (p, pattern, options = {}) => (assertValidPattern(pattern), !options.nocomment && pattern.charAt(0) === "#" ? !1 : new Minimatch(pattern, options).match(p)), starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/, starDotExtTest = (ext2) => (f) => !f.startsWith(".") && f.endsWith(ext2), starDotExtTestDot = (ext2) => (f) => f.endsWith(ext2), starDotExtTestNocase = (ext2) => (ext2 = ext2.toLowerCase(), (f) => !f.startsWith(".") && f.toLowerCase().endsWith(ext2)), starDotExtTestNocaseDot = (ext2) => (ext2 = ext2.toLowerCase(), (f) => f.toLowerCase().endsWith(ext2)), starDotStarRE = /^\*+\.\*+$/, starDotStarTest = (f) => !f.startsWith(".") && f.includes("."), starDotStarTestDot = (f) => f !== "." && f !== ".." && f.includes("."), dotStarRE = /^\.\*+$/, dotStarTest = (f) => f !== "." && f !== ".." && f.startsWith("."), starRE = /^\*+$/, starTest = (f) => f.length !== 0 && !f.startsWith("."), starTestDot = (f) => f.length !== 0 && f !== "." && f !== "..", qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/, qmarksTestNocase = ([$0, ext2 = ""]) => {
   let noext = qmarksTestNoExt([$0]);
   return ext2 ? (ext2 = ext2.toLowerCase(), (f) => noext(f) && f.toLowerCase().endsWith(ext2)) : noext;
@@ -990,10 +990,10 @@ minimatch.Minimatch = Minimatch;
 minimatch.escape = escape;
 minimatch.unescape = unescape;
 
-// ../node_modules/glob/dist/esm/glob.js
+// ../../node_modules/glob/dist/esm/glob.js
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
-// ../node_modules/glob/node_modules/lru-cache/dist/esm/index.js
+// ../../node_modules/path-scurry/node_modules/lru-cache/dist/esm/index.js
 var perf = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date, warned = /* @__PURE__ */ new Set(), PROCESS = typeof process == "object" && process ? process : {}, emitWarning = (msg, type, code, fn) => {
   typeof PROCESS.emitWarning == "function" ? PROCESS.emitWarning(msg, type, code, fn) : console.error(`[${code}] ${type}: ${msg}`);
 }, AC = globalThis.AbortController, AS = globalThis.AbortSignal;
@@ -1053,13 +1053,14 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
     return this.heap[--this.length];
   }
 }, LRUCache = class _LRUCache {
-  // options that cannot be changed without disaster
+  // properties coming in from the options of these, only max and maxSize
+  // really *need* to be protected. The rest can be modified, as they just
+  // set defaults for various methods.
   #max;
   #maxSize;
   #dispose;
   #disposeAfter;
   #fetchMethod;
-  #memoMethod;
   /**
    * {@link LRUCache.OptionsBase.ttl}
    */
@@ -1205,9 +1206,6 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
   get fetchMethod() {
     return this.#fetchMethod;
   }
-  get memoMethod() {
-    return this.#memoMethod;
-  }
   /**
    * {@link LRUCache.OptionsBase.dispose} (read-only)
    */
@@ -1221,7 +1219,7 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
     return this.#disposeAfter;
   }
   constructor(options) {
-    let { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort } = options;
+    let { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort } = options;
     if (max !== 0 && !isPosInt(max))
       throw new TypeError("max option must be a nonnegative integer");
     let UintArray = max ? getUintArray(max) : Array;
@@ -1233,9 +1231,7 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
       if (typeof this.sizeCalculation != "function")
         throw new TypeError("sizeCalculation set to non-function");
     }
-    if (memoMethod !== void 0 && typeof memoMethod != "function")
-      throw new TypeError("memoMethod must be a function if defined");
-    if (this.#memoMethod = memoMethod, fetchMethod !== void 0 && typeof fetchMethod != "function")
+    if (fetchMethod !== void 0 && typeof fetchMethod != "function")
       throw new TypeError("fetchMethod must be a function if specified");
     if (this.#fetchMethod = fetchMethod, this.#hasFetchMethod = !!fetchMethod, this.#keyMap = /* @__PURE__ */ new Map(), this.#keyList = new Array(max).fill(void 0), this.#valList = new Array(max).fill(void 0), 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, typeof dispose == "function" && (this.#dispose = dispose), typeof disposeAfter == "function" ? (this.#disposeAfter = disposeAfter, this.#disposed = []) : (this.#disposeAfter = void 0, this.#disposed = void 0), this.#hasDispose = !!this.#dispose, this.#hasDisposeAfter = !!this.#disposeAfter, this.noDisposeOnSet = !!noDisposeOnSet, this.noUpdateTTL = !!noUpdateTTL, this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection, this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection, this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort, this.ignoreFetchAbort = !!ignoreFetchAbort, this.maxEntrySize !== 0) {
       if (this.#maxSize !== 0 && !isPosInt(this.#maxSize))
@@ -1257,8 +1253,7 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
     }
   }
   /**
-   * 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.
+   * Return the remaining TTL time for a given entry key
    */
   getRemainingTTL(key) {
     return this.#keyMap.has(key) ? 1 / 0 : 0;
@@ -1268,7 +1263,7 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
     this.#ttls = ttls, this.#starts = starts, this.#setItemTTL = (index, ttl, start = perf.now()) => {
       if (starts[index] = ttl !== 0 ? start : 0, ttls[index] = ttl, ttl !== 0 && this.ttlAutopurge) {
         let t = setTimeout(() => {
-          this.#isStale(index) && this.#delete(this.#keyList[index], "expire");
+          this.#isStale(index) && this.delete(this.#keyList[index]);
         }, ttl + 1);
         t.unref && t.unref();
       }
@@ -1429,14 +1424,13 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
     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`.
+   * 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)`.
+   * similar to Array.find().  fn is called as fn(value, key, cache).
    */
   find(fn, getOptions = {}) {
     for (let i of this.#indexes()) {
@@ -1446,15 +1440,10 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
     }
   }
   /**
-   * 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.
+   * 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).  Does not update age or recenty of use.
+   * Does not iterate over stale values.
    */
   forEach(fn, thisp = this) {
     for (let i of this.#indexes()) {
@@ -1479,20 +1468,14 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
   purgeStale() {
     let deleted = !1;
     for (let i of this.#rindexes({ allowStale: !0 }))
-      this.#isStale(i) && (this.#delete(this.#keyList[i], "expire"), deleted = !0);
+      this.#isStale(i) && (this.delete(this.#keyList[i]), deleted = !0);
     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.
+   * TTL info simultaneously. Like {@link LRUCache#dump}, but just for a
+   * single key. Always returns stale values, if their info is found in the
+   * cache, so be sure to check for expired TTLs if relevant.
    */
   info(key) {
     let i = this.#keyMap.get(key);
@@ -1513,16 +1496,7 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
   }
   /**
    * Return an array of [key, {@link LRUCache.Entry}] tuples which can be
-   * passed to {@link LRLUCache#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.
+   * passed to cache.load()
    */
   dump() {
     let arr = [];
@@ -1542,12 +1516,8 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
   }
   /**
    * 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.
+   * Note that the shape of the resulting cache may be different if the
+   * same options are not used in both caches.
    */
   load(arr) {
     this.clear();
@@ -1564,37 +1534,13 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
    *
    * 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 === void 0)
       return this.delete(k), this;
     let { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status } = setOptions, { noUpdateTTL = this.noUpdateTTL } = setOptions, size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation);
     if (this.maxEntrySize && size > this.maxEntrySize)
-      return status && (status.set = "miss", status.maxEntrySizeExceeded = !0), this.#delete(k, "set"), this;
+      return status && (status.set = "miss", status.maxEntrySizeExceeded = !0), this.delete(k), this;
     let index = this.#size === 0 ? void 0 : this.#keyMap.get(k);
     if (index === void 0)
       index = this.#size === 0 ? this.#tail : this.#free.length !== 0 ? this.#free.pop() : this.#size === this.#max ? this.#evict(!1) : 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), status && (status.set = "add"), noUpdateTTL = !1;
@@ -1652,14 +1598,6 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
    * 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.
    */
@@ -1706,10 +1644,10 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
       if (options.status && (aborted && !updateCache ? (options.status.fetchAborted = !0, options.status.fetchError = ac.signal.reason, ignoreAbort && (options.status.fetchAbortIgnored = !0)) : options.status.fetchResolved = !0), aborted && !ignoreAbort && !updateCache)
         return fetchFail(ac.signal.reason);
       let bf2 = p;
-      return this.#valList[index] === p && (v2 === void 0 ? bf2.__staleWhileFetching ? this.#valList[index] = bf2.__staleWhileFetching : this.#delete(k, "fetch") : (options.status && (options.status.fetchUpdated = !0), this.set(k, v2, fetchOpts.options))), v2;
+      return this.#valList[index] === p && (v2 === void 0 ? bf2.__staleWhileFetching ? this.#valList[index] = bf2.__staleWhileFetching : this.delete(k) : (options.status && (options.status.fetchUpdated = !0), this.set(k, v2, fetchOpts.options))), v2;
     }, eb = (er) => (options.status && (options.status.fetchRejected = !0, options.status.fetchError = er), fetchFail(er)), fetchFail = (er) => {
       let { aborted } = ac.signal, allowStaleAborted = aborted && options.allowStaleOnFetchAbort, allowStale = allowStaleAborted || options.allowStaleOnFetchRejection, noDelete = allowStale || options.noDeleteOnFetchRejection, bf2 = p;
-      if (this.#valList[index] === p && (!noDelete || bf2.__staleWhileFetching === void 0 ? this.#delete(k, "fetch") : allowStaleAborted || (this.#valList[index] = bf2.__staleWhileFetching)), allowStale)
+      if (this.#valList[index] === p && (!noDelete || bf2.__staleWhileFetching === void 0 ? this.delete(k) : allowStaleAborted || (this.#valList[index] = bf2.__staleWhileFetching)), allowStale)
         return options.status && bf2.__staleWhileFetching !== void 0 && (options.status.returnedStale = !0), bf2.__staleWhileFetching;
       if (bf2.__returned === bf2)
         throw er;
@@ -1795,25 +1733,6 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
       return status && (status.fetch = isStale ? "stale" : "refresh", staleVal && isStale && (status.returnedStale = !0)), staleVal ? p.__staleWhileFetching : p.__returned = p;
     }
   }
-  async forceFetch(k, fetchOptions = {}) {
-    let v = await this.fetch(k, fetchOptions);
-    if (v === void 0)
-      throw new Error("fetch() returned undefined");
-    return v;
-  }
-  memo(k, memoOptions = {}) {
-    let memoMethod = this.#memoMethod;
-    if (!memoMethod)
-      throw new Error("no memoMethod provided to constructor");
-    let { context, forceRefresh, ...options } = memoOptions, v = this.get(k, options);
-    if (!forceRefresh && v !== void 0)
-      return v;
-    let vv = memoMethod(k, v, {
-      options,
-      context
-    });
-    return this.set(k, vv, options), vv;
-  }
   /**
    * Return a value from the cache. Will update the recency of the cache
    * entry found.
@@ -1824,7 +1743,7 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
     let { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status } = getOptions, index = this.#keyMap.get(k);
     if (index !== void 0) {
       let value = this.#valList[index], fetching = this.#isBackgroundFetch(value);
-      return status && this.#statusTTL(status, index), this.#isStale(index) ? (status && (status.get = "stale"), fetching ? (status && allowStale && value.__staleWhileFetching !== void 0 && (status.returnedStale = !0), allowStale ? value.__staleWhileFetching : void 0) : (noDeleteOnStaleGet || this.#delete(k, "expire"), status && allowStale && (status.returnedStale = !0), allowStale ? value : void 0)) : (status && (status.get = "hit"), fetching ? value.__staleWhileFetching : (this.#moveToTail(index), updateAgeOnGet && this.#updateItemAge(index), value));
+      return status && this.#statusTTL(status, index), this.#isStale(index) ? (status && (status.get = "stale"), fetching ? (status && allowStale && value.__staleWhileFetching !== void 0 && (status.returnedStale = !0), allowStale ? value.__staleWhileFetching : void 0) : (noDeleteOnStaleGet || this.delete(k), status && allowStale && (status.returnedStale = !0), allowStale ? value : void 0)) : (status && (status.get = "hit"), fetching ? value.__staleWhileFetching : (this.#moveToTail(index), updateAgeOnGet && this.#updateItemAge(index), value));
     } else status && (status.get = "miss");
   }
   #connect(p, n) {
@@ -1835,23 +1754,19 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
   }
   /**
    * 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 = !1;
     if (this.#size !== 0) {
       let index = this.#keyMap.get(k);
       if (index !== void 0)
         if (deleted = !0, this.#size === 1)
-          this.#clear(reason);
+          this.clear();
         else {
           this.#removeItemSize(index);
           let v = this.#valList[index];
-          if (this.#isBackgroundFetch(v) ? v.__abortController.abort(new Error("deleted")) : (this.#hasDispose || this.#hasDisposeAfter) && (this.#hasDispose && this.#dispose?.(v, k, reason), this.#hasDisposeAfter && this.#disposed?.push([v, k, reason])), this.#keyMap.delete(k), this.#keyList[index] = void 0, this.#valList[index] = void 0, index === this.#tail)
+          if (this.#isBackgroundFetch(v) ? v.__abortController.abort(new Error("deleted")) : (this.#hasDispose || this.#hasDisposeAfter) && (this.#hasDispose && this.#dispose?.(v, k, "delete"), this.#hasDisposeAfter && this.#disposed?.push([v, k, "delete"])), this.#keyMap.delete(k), this.#keyList[index] = void 0, this.#valList[index] = void 0, index === this.#tail)
             this.#tail = this.#prev[index];
           else if (index === this.#head)
             this.#head = this.#next[index];
@@ -1875,16 +1790,13 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
    * Clear the cache entirely, throwing away all values.
    */
   clear() {
-    return this.#clear("delete");
-  }
-  #clear(reason) {
     for (let index of this.#rindexes({ allowStale: !0 })) {
       let v = this.#valList[index];
       if (this.#isBackgroundFetch(v))
         v.__abortController.abort(new Error("deleted"));
       else {
         let k = this.#keyList[index];
-        this.#hasDispose && this.#dispose?.(v, k, reason), this.#hasDisposeAfter && this.#disposed?.push([v, k, reason]);
+        this.#hasDispose && this.#dispose?.(v, k, "delete"), this.#hasDisposeAfter && this.#disposed?.push([v, k, "delete"]);
       }
     }
     if (this.#keyMap.clear(), this.#valList.fill(void 0), this.#keyList.fill(void 0), this.#ttls && this.#starts && (this.#ttls.fill(0), this.#starts.fill(0)), this.#sizes && this.#sizes.fill(0), this.#head = 0, this.#tail = 0, this.#free.length = 0, this.#calculatedSize = 0, this.#size = 0, this.#hasDisposeAfter && this.#disposed) {
@@ -1895,14 +1807,14 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
   }
 };
 
-// ../node_modules/glob/node_modules/path-scurry/dist/esm/index.js
+// ../../node_modules/path-scurry/dist/esm/index.js
 import { posix, win32 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { lstatSync, readdir as readdirCB, readdirSync, readlinkSync, realpathSync as rps } from "fs";
 import * as actualFS from "node:fs";
 import { lstat, readdir, readlink, realpath } from "node:fs/promises";
 
-// ../node_modules/minipass/dist/esm/index.js
+// ../../node_modules/path-scurry/node_modules/minipass/dist/esm/index.js
 import { EventEmitter } from "node:events";
 import Stream from "node:stream";
 import { StringDecoder } from "node:string_decoder";
@@ -2461,7 +2373,7 @@ s.pipe !== Stream.Writable.prototype.pipe, isWritable = (s) => !!s && typeof s =
   }
 };
 
-// ../node_modules/glob/node_modules/path-scurry/dist/esm/index.js
+// ../../node_modules/path-scurry/dist/esm/index.js
 var realpathSync = rps.native, defaultFS = {
   lstatSync,
   readdir: readdirCB,
@@ -3755,7 +3667,7 @@ var realpathSync = rps.native, defaultFS = {
   }
 }, Path = process.platform === "win32" ? PathWin32 : PathPosix, PathScurry = process.platform === "win32" ? PathScurryWin32 : process.platform === "darwin" ? PathScurryDarwin : PathScurryPosix;
 
-// ../node_modules/glob/dist/esm/pattern.js
+// ../../node_modules/glob/dist/esm/pattern.js
 var isPatternList = (pl) => pl.length >= 1, isGlobList = (gl) => gl.length >= 1, Pattern = class _Pattern {
   #patternList;
   #globList;
@@ -3884,7 +3796,566 @@ var isPatternList = (pl) => pl.length >= 1, isGlobList = (gl) => gl.length >= 1,
   }
 };
 
-// ../node_modules/glob/dist/esm/ignore.js
+// ../../node_modules/glob/node_modules/minipass/dist/esm/index.js
+import { EventEmitter as EventEmitter2 } from "node:events";
+import Stream2 from "node:stream";
+import { StringDecoder as StringDecoder2 } from "node:string_decoder";
+var proc2 = typeof process == "object" && process ? process : {
+  stdout: null,
+  stderr: null
+}, isStream2 = (s) => !!s && typeof s == "object" && (s instanceof Minipass2 || s instanceof Stream2 || isReadable2(s) || isWritable2(s)), isReadable2 = (s) => !!s && typeof s == "object" && s instanceof EventEmitter2 && typeof s.pipe == "function" && // node core Writable streams have a pipe() method, but it throws
+s.pipe !== Stream2.Writable.prototype.pipe, isWritable2 = (s) => !!s && typeof s == "object" && s instanceof EventEmitter2 && typeof s.write == "function" && typeof s.end == "function", EOF2 = Symbol("EOF"), MAYBE_EMIT_END2 = Symbol("maybeEmitEnd"), EMITTED_END2 = Symbol("emittedEnd"), EMITTING_END2 = Symbol("emittingEnd"), EMITTED_ERROR2 = Symbol("emittedError"), CLOSED2 = Symbol("closed"), READ2 = Symbol("read"), FLUSH2 = Symbol("flush"), FLUSHCHUNK2 = Symbol("flushChunk"), ENCODING2 = Symbol("encoding"), DECODER2 = Symbol("decoder"), FLOWING2 = Symbol("flowing"), PAUSED2 = Symbol("paused"), RESUME2 = Symbol("resume"), BUFFER2 = Symbol("buffer"), PIPES2 = Symbol("pipes"), BUFFERLENGTH2 = Symbol("bufferLength"), BUFFERPUSH2 = Symbol("bufferPush"), BUFFERSHIFT2 = Symbol("bufferShift"), OBJECTMODE2 = Symbol("objectMode"), DESTROYED2 = Symbol("destroyed"), ERROR2 = Symbol("error"), EMITDATA2 = Symbol("emitData"), EMITEND3 = Symbol("emitEnd"), EMITEND22 = Symbol("emitEnd2"), ASYNC2 = Symbol("async"), ABORT2 = Symbol("abort"), ABORTED2 = Symbol("aborted"), SIGNAL2 = Symbol("signal"), DATALISTENERS2 = Symbol("dataListeners"), DISCARDED2 = Symbol("discarded"), defer2 = (fn) => Promise.resolve().then(fn), nodefer2 = (fn) => fn(), isEndish2 = (ev) => ev === "end" || ev === "finish" || ev === "prefinish", isArrayBufferLike2 = (b) => b instanceof ArrayBuffer || !!b && typeof b == "object" && b.constructor && b.constructor.name === "ArrayBuffer" && b.byteLength >= 0, isArrayBufferView2 = (b) => !Buffer.isBuffer(b) && ArrayBuffer.isView(b), Pipe2 = class {
+  src;
+  dest;
+  opts;
+  ondrain;
+  constructor(src, dest, opts) {
+    this.src = src, this.dest = dest, this.opts = opts, this.ondrain = () => src[RESUME2](), this.dest.on("drain", this.ondrain);
+  }
+  unpipe() {
+    this.dest.removeListener("drain", this.ondrain);
+  }
+  // only here for the prototype
+  /* c8 ignore start */
+  proxyErrors(_er) {
+  }
+  /* c8 ignore stop */
+  end() {
+    this.unpipe(), this.opts.end && this.dest.end();
+  }
+}, PipeProxyErrors2 = class extends Pipe2 {
+  unpipe() {
+    this.src.removeListener("error", this.proxyErrors), super.unpipe();
+  }
+  constructor(src, dest, opts) {
+    super(src, dest, opts), this.proxyErrors = (er) => dest.emit("error", er), src.on("error", this.proxyErrors);
+  }
+}, isObjectModeOptions2 = (o) => !!o.objectMode, isEncodingOptions2 = (o) => !o.objectMode && !!o.encoding && o.encoding !== "buffer", Minipass2 = class extends EventEmitter2 {
+  [FLOWING2] = !1;
+  [PAUSED2] = !1;
+  [PIPES2] = [];
+  [BUFFER2] = [];
+  [OBJECTMODE2];
+  [ENCODING2];
+  [ASYNC2];
+  [DECODER2];
+  [EOF2] = !1;
+  [EMITTED_END2] = !1;
+  [EMITTING_END2] = !1;
+  [CLOSED2] = !1;
+  [EMITTED_ERROR2] = null;
+  [BUFFERLENGTH2] = 0;
+  [DESTROYED2] = !1;
+  [SIGNAL2];
+  [ABORTED2] = !1;
+  [DATALISTENERS2] = 0;
+  [DISCARDED2] = !1;
+  /**
+   * true if the stream can be written
+   */
+  writable = !0;
+  /**
+   * true if the stream can be read
+   */
+  readable = !0;
+  /**
+   * If `RType` is Buffer, then options do not need to be provided.
+   * Otherwise, an options object must be provided to specify either
+   * {@link Minipass.SharedOptions.objectMode} or
+   * {@link Minipass.SharedOptions.encoding}, as appropriate.
+   */
+  constructor(...args) {
+    let options = args[0] || {};
+    if (super(), options.objectMode && typeof options.encoding == "string")
+      throw new TypeError("Encoding and objectMode may not be used together");
+    isObjectModeOptions2(options) ? (this[OBJECTMODE2] = !0, this[ENCODING2] = null) : isEncodingOptions2(options) ? (this[ENCODING2] = options.encoding, this[OBJECTMODE2] = !1) : (this[OBJECTMODE2] = !1, this[ENCODING2] = null), this[ASYNC2] = !!options.async, this[DECODER2] = this[ENCODING2] ? new StringDecoder2(this[ENCODING2]) : null, options && options.debugExposeBuffer === !0 && Object.defineProperty(this, "buffer", { get: () => this[BUFFER2] }), options && options.debugExposePipes === !0 && Object.defineProperty(this, "pipes", { get: () => this[PIPES2] });
+    let { signal } = options;
+    signal && (this[SIGNAL2] = signal, signal.aborted ? this[ABORT2]() : signal.addEventListener("abort", () => this[ABORT2]()));
+  }
+  /**
+   * The amount of data stored in the buffer waiting to be read.
+   *
+   * For Buffer strings, this will be the total byte length.
+   * For string encoding streams, this will be the string character length,
+   * according to JavaScript's `string.length` logic.
+   * For objectMode streams, this is a count of the items waiting to be
+   * emitted.
+   */
+  get bufferLength() {
+    return this[BUFFERLENGTH2];
+  }
+  /**
+   * The `BufferEncoding` currently in use, or `null`
+   */
+  get encoding() {
+    return this[ENCODING2];
+  }
+  /**
+   * @deprecated - This is a read only property
+   */
+  set encoding(_enc) {
+    throw new Error("Encoding must be set at instantiation time");
+  }
+  /**
+   * @deprecated - Encoding may only be set at instantiation time
+   */
+  setEncoding(_enc) {
+    throw new Error("Encoding must be set at instantiation time");
+  }
+  /**
+   * True if this is an objectMode stream
+   */
+  get objectMode() {
+    return this[OBJECTMODE2];
+  }
+  /**
+   * @deprecated - This is a read-only property
+   */
+  set objectMode(_om) {
+    throw new Error("objectMode must be set at instantiation time");
+  }
+  /**
+   * true if this is an async stream
+   */
+  get async() {
+    return this[ASYNC2];
+  }
+  /**
+   * Set to true to make this stream async.
+   *
+   * Once set, it cannot be unset, as this would potentially cause incorrect
+   * behavior.  Ie, a sync stream can be made async, but an async stream
+   * cannot be safely made sync.
+   */
+  set async(a) {
+    this[ASYNC2] = this[ASYNC2] || !!a;
+  }
+  // drop everything and get out of the flow completely
+  [ABORT2]() {
+    this[ABORTED2] = !0, this.emit("abort", this[SIGNAL2]?.reason), this.destroy(this[SIGNAL2]?.reason);
+  }
+  /**
+   * True if the stream has been aborted.
+   */
+  get aborted() {
+    return this[ABORTED2];
+  }
+  /**
+   * No-op setter. Stream aborted status is set via the AbortSignal provided
+   * in the constructor options.
+   */
+  set aborted(_) {
+  }
+  write(chunk, encoding, cb) {
+    if (this[ABORTED2])
+      return !1;
+    if (this[EOF2])
+      throw new Error("write after end");
+    if (this[DESTROYED2])
+      return this.emit("error", Object.assign(new Error("Cannot call write after a stream was destroyed"), { code: "ERR_STREAM_DESTROYED" })), !0;
+    typeof encoding == "function" && (cb = encoding, encoding = "utf8"), encoding || (encoding = "utf8");
+    let fn = this[ASYNC2] ? defer2 : nodefer2;
+    if (!this[OBJECTMODE2] && !Buffer.isBuffer(chunk)) {
+      if (isArrayBufferView2(chunk))
+        chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+      else if (isArrayBufferLike2(chunk))
+        chunk = Buffer.from(chunk);
+      else if (typeof chunk != "string")
+        throw new Error("Non-contiguous data written to non-objectMode stream");
+    }
+    return this[OBJECTMODE2] ? (this[FLOWING2] && this[BUFFERLENGTH2] !== 0 && this[FLUSH2](!0), this[FLOWING2] ? this.emit("data", chunk) : this[BUFFERPUSH2](chunk), this[BUFFERLENGTH2] !== 0 && this.emit("readable"), cb && fn(cb), this[FLOWING2]) : chunk.length ? (typeof chunk == "string" && // unless it is a string already ready for us to use
+    !(encoding === this[ENCODING2] && !this[DECODER2]?.lastNeed) && (chunk = Buffer.from(chunk, encoding)), Buffer.isBuffer(chunk) && this[ENCODING2] && (chunk = this[DECODER2].write(chunk)), this[FLOWING2] && this[BUFFERLENGTH2] !== 0 && this[FLUSH2](!0), this[FLOWING2] ? this.emit("data", chunk) : this[BUFFERPUSH2](chunk), this[BUFFERLENGTH2] !== 0 && this.emit("readable"), cb && fn(cb), this[FLOWING2]) : (this[BUFFERLENGTH2] !== 0 && this.emit("readable"), cb && fn(cb), this[FLOWING2]);
+  }
+  /**
+   * Low-level explicit read method.
+   *
+   * In objectMode, the argument is ignored, and one item is returned if
+   * available.
+   *
+   * `n` is the number of bytes (or in the case of encoding streams,
+   * characters) to consume. If `n` is not provided, then the entire buffer
+   * is returned, or `null` is returned if no data is available.
+   *
+   * If `n` is greater that the amount of data in the internal buffer,
+   * then `null` is returned.
+   */
+  read(n) {
+    if (this[DESTROYED2])
+      return null;
+    if (this[DISCARDED2] = !1, this[BUFFERLENGTH2] === 0 || n === 0 || n && n > this[BUFFERLENGTH2])
+      return this[MAYBE_EMIT_END2](), null;
+    this[OBJECTMODE2] && (n = null), this[BUFFER2].length > 1 && !this[OBJECTMODE2] && (this[BUFFER2] = [
+      this[ENCODING2] ? this[BUFFER2].join("") : Buffer.concat(this[BUFFER2], this[BUFFERLENGTH2])
+    ]);
+    let ret = this[READ2](n || null, this[BUFFER2][0]);
+    return this[MAYBE_EMIT_END2](), ret;
+  }
+  [READ2](n, chunk) {
+    if (this[OBJECTMODE2])
+      this[BUFFERSHIFT2]();
+    else {
+      let c = chunk;
+      n === c.length || n === null ? this[BUFFERSHIFT2]() : typeof c == "string" ? (this[BUFFER2][0] = c.slice(n), chunk = c.slice(0, n), this[BUFFERLENGTH2] -= n) : (this[BUFFER2][0] = c.subarray(n), chunk = c.subarray(0, n), this[BUFFERLENGTH2] -= n);
+    }
+    return this.emit("data", chunk), !this[BUFFER2].length && !this[EOF2] && this.emit("drain"), chunk;
+  }
+  end(chunk, encoding, cb) {
+    return typeof chunk == "function" && (cb = chunk, chunk = void 0), typeof encoding == "function" && (cb = encoding, encoding = "utf8"), chunk !== void 0 && this.write(chunk, encoding), cb && this.once("end", cb), this[EOF2] = !0, this.writable = !1, (this[FLOWING2] || !this[PAUSED2]) && this[MAYBE_EMIT_END2](), this;
+  }
+  // don't let the internal resume be overwritten
+  [RESUME2]() {
+    this[DESTROYED2] || (!this[DATALISTENERS2] && !this[PIPES2].length && (this[DISCARDED2] = !0), this[PAUSED2] = !1, this[FLOWING2] = !0, this.emit("resume"), this[BUFFER2].length ? this[FLUSH2]() : this[EOF2] ? this[MAYBE_EMIT_END2]() : this.emit("drain"));
+  }
+  /**
+   * Resume the stream if it is currently in a paused state
+   *
+   * If called when there are no pipe destinations or `data` event listeners,
+   * this will place the stream in a "discarded" state, where all data will
+   * be thrown away. The discarded state is removed if a pipe destination or
+   * data handler is added, if pause() is called, or if any synchronous or
+   * asynchronous iteration is started.
+   */
+  resume() {
+    return this[RESUME2]();
+  }
+  /**
+   * Pause the stream
+   */
+  pause() {
+    this[FLOWING2] = !1, this[PAUSED2] = !0, this[DISCARDED2] = !1;
+  }
+  /**
+   * true if the stream has been forcibly destroyed
+   */
+  get destroyed() {
+    return this[DESTROYED2];
+  }
+  /**
+   * true if the stream is currently in a flowing state, meaning that
+   * any writes will be immediately emitted.
+   */
+  get flowing() {
+    return this[FLOWING2];
+  }
+  /**
+   * true if the stream is currently in a paused state
+   */
+  get paused() {
+    return this[PAUSED2];
+  }
+  [BUFFERPUSH2](chunk) {
+    this[OBJECTMODE2] ? this[BUFFERLENGTH2] += 1 : this[BUFFERLENGTH2] += chunk.length, this[BUFFER2].push(chunk);
+  }
+  [BUFFERSHIFT2]() {
+    return this[OBJECTMODE2] ? this[BUFFERLENGTH2] -= 1 : this[BUFFERLENGTH2] -= this[BUFFER2][0].length, this[BUFFER2].shift();
+  }
+  [FLUSH2](noDrain = !1) {
+    do
+      ;
+    while (this[FLUSHCHUNK2](this[BUFFERSHIFT2]()) && this[BUFFER2].length);
+    !noDrain && !this[BUFFER2].length && !this[EOF2] && this.emit("drain");
+  }
+  [FLUSHCHUNK2](chunk) {
+    return this.emit("data", chunk), this[FLOWING2];
+  }
+  /**
+   * Pipe all data emitted by this stream into the destination provided.
+   *
+   * Triggers the flow of data.
+   */
+  pipe(dest, opts) {
+    if (this[DESTROYED2])
+      return dest;
+    this[DISCARDED2] = !1;
+    let ended = this[EMITTED_END2];
+    return opts = opts || {}, dest === proc2.stdout || dest === proc2.stderr ? opts.end = !1 : opts.end = opts.end !== !1, opts.proxyErrors = !!opts.proxyErrors, ended ? opts.end && dest.end() : (this[PIPES2].push(opts.proxyErrors ? new PipeProxyErrors2(this, dest, opts) : new Pipe2(this, dest, opts)), this[ASYNC2] ? defer2(() => this[RESUME2]()) : this[RESUME2]()), dest;
+  }
+  /**
+   * Fully unhook a piped destination stream.
+   *
+   * If the destination stream was the only consumer of this stream (ie,
+   * there are no other piped destinations or `'data'` event listeners)
+   * then the flow of data will stop until there is another consumer or
+   * {@link Minipass#resume} is explicitly called.
+   */
+  unpipe(dest) {
+    let p = this[PIPES2].find((p2) => p2.dest === dest);
+    p && (this[PIPES2].length === 1 ? (this[FLOWING2] && this[DATALISTENERS2] === 0 && (this[FLOWING2] = !1), this[PIPES2] = []) : this[PIPES2].splice(this[PIPES2].indexOf(p), 1), p.unpipe());
+  }
+  /**
+   * Alias for {@link Minipass#on}
+   */
+  addListener(ev, handler) {
+    return this.on(ev, handler);
+  }
+  /**
+   * Mostly identical to `EventEmitter.on`, with the following
+   * behavior differences to prevent data loss and unnecessary hangs:
+   *
+   * - Adding a 'data' event handler will trigger the flow of data
+   *
+   * - Adding a 'readable' event handler when there is data waiting to be read
+   *   will cause 'readable' to be emitted immediately.
+   *
+   * - Adding an 'endish' event handler ('end', 'finish', etc.) which has
+   *   already passed will cause the event to be emitted immediately and all
+   *   handlers removed.
+   *
+   * - Adding an 'error' event handler after an error has been emitted will
+   *   cause the event to be re-emitted immediately with the error previously
+   *   raised.
+   */
+  on(ev, handler) {
+    let ret = super.on(ev, handler);
+    if (ev === "data")
+      this[DISCARDED2] = !1, this[DATALISTENERS2]++, !this[PIPES2].length && !this[FLOWING2] && this[RESUME2]();
+    else if (ev === "readable" && this[BUFFERLENGTH2] !== 0)
+      super.emit("readable");
+    else if (isEndish2(ev) && this[EMITTED_END2])
+      super.emit(ev), this.removeAllListeners(ev);
+    else if (ev === "error" && this[EMITTED_ERROR2]) {
+      let h = handler;
+      this[ASYNC2] ? defer2(() => h.call(this, this[EMITTED_ERROR2])) : h.call(this, this[EMITTED_ERROR2]);
+    }
+    return ret;
+  }
+  /**
+   * Alias for {@link Minipass#off}
+   */
+  removeListener(ev, handler) {
+    return this.off(ev, handler);
+  }
+  /**
+   * Mostly identical to `EventEmitter.off`
+   *
+   * If a 'data' event handler is removed, and it was the last consumer
+   * (ie, there are no pipe destinations or other 'data' event listeners),
+   * then the flow of data will stop until there is another consumer or
+   * {@link Minipass#resume} is explicitly called.
+   */
+  off(ev, handler) {
+    let ret = super.off(ev, handler);
+    return ev === "data" && (this[DATALISTENERS2] = this.listeners("data").length, this[DATALISTENERS2] === 0 && !this[DISCARDED2] && !this[PIPES2].length && (this[FLOWING2] = !1)), ret;
+  }
+  /**
+   * Mostly identical to `EventEmitter.removeAllListeners`
+   *
+   * If all 'data' event handlers are removed, and they were the last consumer
+   * (ie, there are no pipe destinations), then the flow of data will stop
+   * until there is another consumer or {@link Minipass#resume} is explicitly
+   * called.
+   */
+  removeAllListeners(ev) {
+    let ret = super.removeAllListeners(ev);
+    return (ev === "data" || ev === void 0) && (this[DATALISTENERS2] = 0, !this[DISCARDED2] && !this[PIPES2].length && (this[FLOWING2] = !1)), ret;
+  }
+  /**
+   * true if the 'end' event has been emitted
+   */
+  get emittedEnd() {
+    return this[EMITTED_END2];
+  }
+  [MAYBE_EMIT_END2]() {
+    !this[EMITTING_END2] && !this[EMITTED_END2] && !this[DESTROYED2] && this[BUFFER2].length === 0 && this[EOF2] && (this[EMITTING_END2] = !0, this.emit("end"), this.emit("prefinish"), this.emit("finish"), this[CLOSED2] && this.emit("close"), this[EMITTING_END2] = !1);
+  }
+  /**
+   * Mostly identical to `EventEmitter.emit`, with the following
+   * behavior differences to prevent data loss and unnecessary hangs:
+   *
+   * If the stream has been destroyed, and the event is something other
+   * than 'close' or 'error', then `false` is returned and no handlers
+   * are called.
+   *
+   * If the event is 'end', and has already been emitted, then the event
+   * is ignored. If the stream is in a paused or non-flowing state, then
+   * the event will be deferred until data flow resumes. If the stream is
+   * async, then handlers will be called on the next tick rather than
+   * immediately.
+   *
+   * If the event is 'close', and 'end' has not yet been emitted, then
+   * the event will be deferred until after 'end' is emitted.
+   *
+   * If the event is 'error', and an AbortSignal was provided for the stream,
+   * and there are no listeners, then the event is ignored, matching the
+   * behavior of node core streams in the presense of an AbortSignal.
+   *
+   * If the event is 'finish' or 'prefinish', then all listeners will be
+   * removed after emitting the event, to prevent double-firing.
+   */
+  emit(ev, ...args) {
+    let data = args[0];
+    if (ev !== "error" && ev !== "close" && ev !== DESTROYED2 && this[DESTROYED2])
+      return !1;
+    if (ev === "data")
+      return !this[OBJECTMODE2] && !data ? !1 : this[ASYNC2] ? (defer2(() => this[EMITDATA2](data)), !0) : this[EMITDATA2](data);
+    if (ev === "end")
+      return this[EMITEND3]();
+    if (ev === "close") {
+      if (this[CLOSED2] = !0, !this[EMITTED_END2] && !this[DESTROYED2])
+        return !1;
+      let ret2 = super.emit("close");
+      return this.removeAllListeners("close"), ret2;
+    } else if (ev === "error") {
+      this[EMITTED_ERROR2] = data, super.emit(ERROR2, data);
+      let ret2 = !this[SIGNAL2] || this.listeners("error").length ? super.emit("error", data) : !1;
+      return this[MAYBE_EMIT_END2](), ret2;
+    } else if (ev === "resume") {
+      let ret2 = super.emit("resume");
+      return this[MAYBE_EMIT_END2](), ret2;
+    } else if (ev === "finish" || ev === "prefinish") {
+      let ret2 = super.emit(ev);
+      return this.removeAllListeners(ev), ret2;
+    }
+    let ret = super.emit(ev, ...args);
+    return this[MAYBE_EMIT_END2](), ret;
+  }
+  [EMITDATA2](data) {
+    for (let p of this[PIPES2])
+      p.dest.write(data) === !1 && this.pause();
+    let ret = this[DISCARDED2] ? !1 : super.emit("data", data);
+    return this[MAYBE_EMIT_END2](), ret;
+  }
+  [EMITEND3]() {
+    return this[EMITTED_END2] ? !1 : (this[EMITTED_END2] = !0, this.readable = !1, this[ASYNC2] ? (defer2(() => this[EMITEND22]()), !0) : this[EMITEND22]());
+  }
+  [EMITEND22]() {
+    if (this[DECODER2]) {
+      let data = this[DECODER2].end();
+      if (data) {
+        for (let p of this[PIPES2])
+          p.dest.write(data);
+        this[DISCARDED2] || super.emit("data", data);
+      }
+    }
+    for (let p of this[PIPES2])
+      p.end();
+    let ret = super.emit("end");
+    return this.removeAllListeners("end"), ret;
+  }
+  /**
+   * Return a Promise that resolves to an array of all emitted data once
+   * the stream ends.
+   */
+  async collect() {
+    let buf = Object.assign([], {
+      dataLength: 0
+    });
+    this[OBJECTMODE2] || (buf.dataLength = 0);
+    let p = this.promise();
+    return this.on("data", (c) => {
+      buf.push(c), this[OBJECTMODE2] || (buf.dataLength += c.length);
+    }), await p, buf;
+  }
+  /**
+   * Return a Promise that resolves to the concatenation of all emitted data
+   * once the stream ends.
+   *
+   * Not allowed on objectMode streams.
+   */
+  async concat() {
+    if (this[OBJECTMODE2])
+      throw new Error("cannot concat in objectMode");
+    let buf = await this.collect();
+    return this[ENCODING2] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
+  }
+  /**
+   * Return a void Promise that resolves once the stream ends.
+   */
+  async promise() {
+    return new Promise((resolve, reject) => {
+      this.on(DESTROYED2, () => reject(new Error("stream destroyed"))), this.on("error", (er) => reject(er)), this.on("end", () => resolve());
+    });
+  }
+  /**
+   * Asynchronous `for await of` iteration.
+   *
+   * This will continue emitting all chunks until the stream terminates.
+   */
+  [Symbol.asyncIterator]() {
+    this[DISCARDED2] = !1;
+    let stopped = !1, stop = async () => (this.pause(), stopped = !0, { value: void 0, done: !0 });
+    return {
+      next: () => {
+        if (stopped)
+          return stop();
+        let res = this.read();
+        if (res !== null)
+          return Promise.resolve({ done: !1, value: res });
+        if (this[EOF2])
+          return stop();
+        let resolve, reject, onerr = (er) => {
+          this.off("data", ondata), this.off("end", onend), this.off(DESTROYED2, ondestroy), stop(), reject(er);
+        }, ondata = (value) => {
+          this.off("error", onerr), this.off("end", onend), this.off(DESTROYED2, ondestroy), this.pause(), resolve({ value, done: !!this[EOF2] });
+        }, onend = () => {
+          this.off("error", onerr), this.off("data", ondata), this.off(DESTROYED2, ondestroy), stop(), resolve({ done: !0, value: void 0 });
+        }, ondestroy = () => onerr(new Error("stream destroyed"));
+        return new Promise((res2, rej) => {
+          reject = rej, resolve = res2, this.once(DESTROYED2, ondestroy), this.once("error", onerr), this.once("end", onend), this.once("data", ondata);
+        });
+      },
+      throw: stop,
+      return: stop,
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
+  }
+  /**
+   * Synchronous `for of` iteration.
+   *
+   * The iteration will terminate when the internal buffer runs out, even
+   * if the stream has not yet terminated.
+   */
+  [Symbol.iterator]() {
+    this[DISCARDED2] = !1;
+    let stopped = !1, stop = () => (this.pause(), this.off(ERROR2, stop), this.off(DESTROYED2, stop), this.off("end", stop), stopped = !0, { done: !0, value: void 0 }), next = () => {
+      if (stopped)
+        return stop();
+      let value = this.read();
+      return value === null ? stop() : { done: !1, value };
+    };
+    return this.once("end", stop), this.once(ERROR2, stop), this.once(DESTROYED2, stop), {
+      next,
+      throw: stop,
+      return: stop,
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  }
+  /**
+   * Destroy a stream, preventing it from being used for any further purpose.
+   *
+   * If the stream has a `close()` method, then it will be called on
+   * destruction.
+   *
+   * After destruction, any attempt to write data, read data, or emit most
+   * events will be ignored.
+   *
+   * If an error argument is provided, then it will be emitted in an
+   * 'error' event.
+   */
+  destroy(er) {
+    if (this[DESTROYED2])
+      return er ? this.emit("error", er) : this.emit(DESTROYED2), this;
+    this[DESTROYED2] = !0, this[DISCARDED2] = !0, this[BUFFER2].length = 0, this[BUFFERLENGTH2] = 0;
+    let wc = this;
+    return typeof wc.close == "function" && !this[CLOSED2] && wc.close(), er ? this.emit("error", er) : this.emit(DESTROYED2), this;
+  }
+  /**
+   * Alias for {@link isStream}
+   *
+   * Former export location, maintained for backwards compatibility.
+   *
+   * @deprecated
+   */
+  static get isStream() {
+    return isStream2;
+  }
+};
+
+// ../../node_modules/glob/dist/esm/ignore.js
 var defaultPlatform2 = typeof process == "object" && process && typeof process.platform == "string" ? process.platform : "linux", Ignore = class {
   relative;
   relativeChildren;
@@ -3941,7 +4412,7 @@ var defaultPlatform2 = typeof process == "object" && process && typeof process.p
   }
 };
 
-// ../node_modules/glob/dist/esm/processor.js
+// ../../node_modules/glob/dist/esm/processor.js
 var HasWalkedCache = class _HasWalkedCache {
   store;
   constructor(store = /* @__PURE__ */ new Map()) {
@@ -4084,7 +4555,7 @@ var HasWalkedCache = class _HasWalkedCache {
   }
 };
 
-// ../node_modules/glob/dist/esm/walker.js
+// ../../node_modules/glob/dist/esm/walker.js
 var makeIgnore = (ignore, opts) => typeof ignore == "string" ? new Ignore([ignore], opts) : Array.isArray(ignore) ? new Ignore(ignore, opts) : ignore, GlobUtil = class {
   path;
   patterns;
@@ -4293,7 +4764,7 @@ var makeIgnore = (ignore, opts) => typeof ignore == "string" ? new Ignore([ignor
 }, GlobStream = class extends GlobUtil {
   results;
   constructor(patterns, path2, opts) {
-    super(patterns, path2, opts), this.results = new Minipass({
+    super(patterns, path2, opts), this.results = new Minipass2({
       signal: this.signal,
       objectMode: !0
     }), this.results.on("drain", () => this.resume()), this.results.on("resume", () => this.resume());
@@ -4312,7 +4783,7 @@ var makeIgnore = (ignore, opts) => typeof ignore == "string" ? new Ignore([ignor
   }
 };
 
-// ../node_modules/glob/dist/esm/glob.js
+// ../../node_modules/glob/dist/esm/glob.js
 var defaultPlatform3 = typeof process == "object" && process && typeof process.platform == "string" ? process.platform : "linux", Glob = class {
   absolute;
   cwd;
@@ -4465,7 +4936,7 @@ var defaultPlatform3 = typeof process == "object" && process && typeof process.p
   }
 };
 
-// ../node_modules/glob/dist/esm/has-magic.js
+// ../../node_modules/glob/dist/esm/has-magic.js
 var hasMagic = (pattern, options = {}) => {
   Array.isArray(pattern) || (pattern = [pattern]);
   for (let p of pattern)
@@ -4474,7 +4945,7 @@ var hasMagic = (pattern, options = {}) => {
   return !1;
 };
 
-// ../node_modules/glob/dist/esm/index.js
+// ../../node_modules/glob/dist/esm/index.js
 function globStreamSync(pattern, options = {}) {
   return new Glob(pattern, options).streamSync();
 }