@storybook/addon-vitest 0.0.0-pr-30601-sha-d70f67e1 → 0.0.0-pr-31819-sha-b1c88d51

package/dist/_browser-chunks/chunk-A47P2DCZ.js

@@ -0,0 +1,11 @@
+var d = Object.defineProperty;
+var e = (b, a) => d(b, "name", { value: a, configurable: !0 });
+var f = (b, a) => {
+  for (var c in a)
+    d(b, c, { get: a[c], enumerable: !0 });
+};
+
+export {
+  e as a,
+  f as b
+};

package/dist/_browser-chunks/chunk-VMSW5DPM.js

@@ -0,0 +1,60 @@
+// ../../core/src/component-testing/constants.ts
+var e = "storybook/interactions", s = `${e}/panel`, n = "writing-tests/integrations/vitest-addon", N = `${n}#what-happens-when-there-are-different-test-results-in-multiple-environments`;
+
+// ../a11y/src/constants.ts
+var t = "storybook/a11y", r = `${t}/panel`;
+var a = `${t}/result`, c = `${t}/request`, p = `${t}/running`, A = `${t}/error`, O = `${t}/manual`, I = `${t}/select`, i = "writing-tests/accessibility-testing", D = `${i}#why-are-my-tests-failing-in-different-environments`;
+
+// src/constants.ts
+var o = "storybook/test", R = `${o}/test-provider`;
+var _ = "writing-tests/integrations/vitest-addon", y = `${_}#what-happens-if-vitest-itself-has-an-error`;
+var E = {
+  id: o,
+  initialState: {
+    config: {
+      coverage: !1,
+      a11y: !1
+    },
+    watching: !1,
+    cancelling: !1,
+    fatalError: void 0,
+    indexUrl: void 0,
+    previewAnnotations: [],
+    currentRun: {
+      triggeredBy: void 0,
+      config: {
+        coverage: !1,
+        a11y: !1
+      },
+      componentTestCount: {
+        success: 0,
+        error: 0
+      },
+      a11yCount: {
+        success: 0,
+        warning: 0,
+        error: 0
+      },
+      storyIds: void 0,
+      totalTestCount: void 0,
+      startedAt: void 0,
+      finishedAt: void 0,
+      unhandledErrors: [],
+      coverageSummary: void 0
+    }
+  }
+}, d = ["global", "run-all"], l = `UNIVERSAL_STORE:${E.id}`;
+var x = "storybook/component-test", L = "storybook/a11y";
+
+export {
+  s as a,
+  t as b,
+  r as c,
+  o as d,
+  R as e,
+  y as f,
+  E as g,
+  d as h,
+  x as i,
+  L as j
+};

package/dist/_node-chunks/chunk-C4NXJJA3.js

@@ -0,0 +1,324 @@
+import CJS_COMPAT_NODE_URL from 'node:url';
+import CJS_COMPAT_NODE_PATH from 'node:path';
+import CJS_COMPAT_NODE_MODULE from "node:module";
+
+const __filename = CJS_COMPAT_NODE_URL.fileURLToPath(import.meta.url);
+const __dirname = CJS_COMPAT_NODE_PATH.dirname(__filename);
+const require = CJS_COMPAT_NODE_MODULE.createRequire(import.meta.url);
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Storybook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  a,
+  c
+} from "./chunk-KVKHJ5OL.js";
+
+// ../../node_modules/semver/internal/constants.js
+var O = c((Re, S) => {
+  "use strict";
+  var x = "2.0.0", y = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+  9007199254740991, v = 16, H = 250, k = [
+    "major",
+    "premajor",
+    "minor",
+    "preminor",
+    "patch",
+    "prepatch",
+    "prerelease"
+  ];
+  S.exports = {
+    MAX_LENGTH: 256,
+    MAX_SAFE_COMPONENT_LENGTH: v,
+    MAX_SAFE_BUILD_LENGTH: H,
+    MAX_SAFE_INTEGER: y,
+    RELEASE_TYPES: k,
+    SEMVER_SPEC_VERSION: x,
+    FLAG_INCLUDE_PRERELEASE: 1,
+    FLAG_LOOSE: 2
+  };
+});
+
+// ../../node_modules/semver/internal/debug.js
+var $ = c((oe, m) => {
+  "use strict";
+  var V = typeof process == "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...n) => console.error("SEMVER", ...n) : () => {
+  };
+  m.exports = V;
+});
+
+// ../../node_modules/semver/internal/re.js
+var D = c((o, f) => {
+  "use strict";
+  var {
+    MAX_SAFE_COMPONENT_LENGTH: A,
+    MAX_SAFE_BUILD_LENGTH: q,
+    MAX_LENGTH: B
+  } = O(), z = $();
+  o = f.exports = {};
+  var Y = o.re = [], Z = o.safeRe = [], s = o.src = [], W = o.safeSrc = [], r = o.t = {}, J = 0, T = "[a-zA-Z0-9-]", K = [
+    ["\\s", 1],
+    ["\\d", B],
+    [T, q]
+  ], Q = /* @__PURE__ */ a((n) => {
+    for (let [e, E] of K)
+      n = n.split(`${e}*`).join(`${e}{0,${E}}`).split(`${e}+`).join(`${e}{1,${E}}`);
+    return n;
+  }, "makeSafeRegex"), t = /* @__PURE__ */ a((n, e, E) => {
+    let i = Q(e), I = J++;
+    z(n, I, e), r[n] = I, s[I] = e, W[I] = i, Y[I] = new RegExp(e, E ? "g" : void 0), Z[I] = new RegExp(i, E ? "g" : void 0);
+  }, "createToken");
+  t("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+  t("NUMERICIDENTIFIERLOOSE", "\\d+");
+  t("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${T}*`);
+  t("MAINVERSION", `(${s[r.NUMERICIDENTIFIER]})\\.(${s[r.NUMERICIDENTIFIER]})\\.(${s[r.NUMERICIDENTIFIER]})`);
+  t("MAINVERSIONLOOSE", `(${s[r.NUMERICIDENTIFIERLOOSE]})\\.(${s[r.NUMERICIDENTIFIERLOOSE]})\\.(${s[r.NUMERICIDENTIFIERLOOSE]})`);
+  t("PRERELEASEIDENTIFIER", `(?:${s[r.NONNUMERICIDENTIFIER]}|${s[r.NUMERICIDENTIFIER]})`);
+  t("PRERELEASEIDENTIFIERLOOSE", `(?:${s[r.NONNUMERICIDENTIFIER]}|${s[r.NUMERICIDENTIFIERLOOSE]})`);
+  t("PRERELEASE", `(?:-(${s[r.PRERELEASEIDENTIFIER]}(?:\\.${s[r.PRERELEASEIDENTIFIER]})*))`);
+  t("PRERELEASELOOSE", `(?:-?(${s[r.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${s[r.PRERELEASEIDENTIFIERLOOSE]})*))`);
+  t("BUILDIDENTIFIER", `${T}+`);
+  t("BUILD", `(?:\\+(${s[r.BUILDIDENTIFIER]}(?:\\.${s[r.BUILDIDENTIFIER]})*))`);
+  t("FULLPLAIN", `v?${s[r.MAINVERSION]}${s[r.PRERELEASE]}?${s[r.BUILD]}?`);
+  t("FULL", `^${s[r.FULLPLAIN]}$`);
+  t("LOOSEPLAIN", `[v=\\s]*${s[r.MAINVERSIONLOOSE]}${s[r.PRERELEASELOOSE]}?${s[r.BUILD]}?`);
+  t("LOOSE", `^${s[r.LOOSEPLAIN]}$`);
+  t("GTLT", "((?:<|>)?=?)");
+  t("XRANGEIDENTIFIERLOOSE", `${s[r.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+  t("XRANGEIDENTIFIER", `${s[r.NUMERICIDENTIFIER]}|x|X|\\*`);
+  t("XRANGEPLAIN", `[v=\\s]*(${s[r.XRANGEIDENTIFIER]})(?:\\.(${s[r.XRANGEIDENTIFIER]})(?:\\.(${s[r.XRANGEIDENTIFIER]})(?:${s[r.PRERELEASE]})?${s[r.BUILD]}?)?)?`);
+  t("XRANGEPLAINLOOSE", `[v=\\s]*(${s[r.XRANGEIDENTIFIERLOOSE]})(?:\\.(${s[r.XRANGEIDENTIFIERLOOSE]})(?:\\.(${s[r.XRANGEIDENTIFIERLOOSE]})(?:${s[r.PRERELEASELOOSE]})?${s[r.BUILD]}?)?)?`);
+  t("XRANGE", `^${s[r.GTLT]}\\s*${s[r.XRANGEPLAIN]}$`);
+  t("XRANGELOOSE", `^${s[r.GTLT]}\\s*${s[r.XRANGEPLAINLOOSE]}$`);
+  t("COERCEPLAIN", `(^|[^\\d])(\\d{1,${A}})(?:\\.(\\d{1,${A}}))?(?:\\.(\\d{1,${A}}))?`);
+  t("COERCE", `${s[r.COERCEPLAIN]}(?:$|[^\\d])`);
+  t("COERCEFULL", s[r.COERCEPLAIN] + `(?:${s[r.PRERELEASE]})?(?:${s[r.BUILD]})?(?:$|[^\\d])`);
+  t("COERCERTL", s[r.COERCE], !0);
+  t("COERCERTLFULL", s[r.COERCEFULL], !0);
+  t("LONETILDE", "(?:~>?)");
+  t("TILDETRIM", `(\\s*)${s[r.LONETILDE]}\\s+`, !0);
+  o.tildeTrimReplace = "$1~";
+  t("TILDE", `^${s[r.LONETILDE]}${s[r.XRANGEPLAIN]}$`);
+  t("TILDELOOSE", `^${s[r.LONETILDE]}${s[r.XRANGEPLAINLOOSE]}$`);
+  t("LONECARET", "(?:\\^)");
+  t("CARETTRIM", `(\\s*)${s[r.LONECARET]}\\s+`, !0);
+  o.caretTrimReplace = "$1^";
+  t("CARET", `^${s[r.LONECARET]}${s[r.XRANGEPLAIN]}$`);
+  t("CARETLOOSE", `^${s[r.LONECARET]}${s[r.XRANGEPLAINLOOSE]}$`);
+  t("COMPARATORLOOSE", `^${s[r.GTLT]}\\s*(${s[r.LOOSEPLAIN]})$|^$`);
+  t("COMPARATOR", `^${s[r.GTLT]}\\s*(${s[r.FULLPLAIN]})$|^$`);
+  t("COMPARATORTRIM", `(\\s*)${s[r.GTLT]}\\s*(${s[r.LOOSEPLAIN]}|${s[r.XRANGEPLAIN]})`, !0);
+  o.comparatorTrimReplace = "$1$2$3";
+  t("HYPHENRANGE", `^\\s*(${s[r.XRANGEPLAIN]})\\s+-\\s+(${s[r.XRANGEPLAIN]})\\s*$`);
+  t("HYPHENRANGELOOSE", `^\\s*(${s[r.XRANGEPLAINLOOSE]})\\s+-\\s+(${s[r.XRANGEPLAINLOOSE]})\\s*$`);
+  t("STAR", "(<|>)?=?\\s*\\*");
+  t("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+  t("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+});
+
+// ../../node_modules/semver/internal/identifiers.js
+var C = c((Ne, G) => {
+  "use strict";
+  var P = /^[0-9]+$/, F = /* @__PURE__ */ a((n, e) => {
+    let E = P.test(n), i = P.test(e);
+    return E && i && (n = +n, e = +e), n === e ? 0 : E && !i ? -1 : i && !E ? 1 : n < e ? -1 : 1;
+  }, "compareIdentifiers"), ee = /* @__PURE__ */ a((n, e) => F(e, n), "rcompareIdentifiers");
+  G.exports = {
+    compareIdentifiers: F,
+    rcompareIdentifiers: ee
+  };
+});
+
+// ../../node_modules/semver/internal/parse-options.js
+var d = c((he, M) => {
+  "use strict";
+  var se = Object.freeze({ loose: !0 }), re = Object.freeze({}), Ee = /* @__PURE__ */ a((n) => n ? typeof n != "object" ? se : n : re, "parseOptions");
+  M.exports = Ee;
+});
+
+// ../../node_modules/semver/classes/semver.js
+var U = c((le, w) => {
+  "use strict";
+  var L = $(), { MAX_LENGTH: g, MAX_SAFE_INTEGER: h } = O(), { safeRe: p, t: l } = D(), te = d(), { compareIdentifiers: N } = C(), u = class n {
+    static {
+      a(this, "SemVer");
+    }
+    constructor(e, E) {
+      if (E = te(E), e instanceof n) {
+        if (e.loose === !!E.loose && e.includePrerelease === !!E.includePrerelease)
+          return e;
+        e = e.version;
+      } else if (typeof e != "string")
+        throw new TypeError(`Invalid version. Must be a string. Got type "${typeof e}".`);
+      if (e.length > g)
+        throw new TypeError(
+          `version is longer than ${g} characters`
+        );
+      L("SemVer", e, E), this.options = E, this.loose = !!E.loose, this.includePrerelease = !!E.includePrerelease;
+      let i = e.trim().match(E.loose ? p[l.LOOSE] : p[l.FULL]);
+      if (!i)
+        throw new TypeError(`Invalid Version: ${e}`);
+      if (this.raw = e, this.major = +i[1], this.minor = +i[2], this.patch = +i[3], this.major > h || this.major < 0)
+        throw new TypeError("Invalid major version");
+      if (this.minor > h || this.minor < 0)
+        throw new TypeError("Invalid minor version");
+      if (this.patch > h || this.patch < 0)
+        throw new TypeError("Invalid patch version");
+      i[4] ? this.prerelease = i[4].split(".").map((I) => {
+        if (/^[0-9]+$/.test(I)) {
+          let R = +I;
+          if (R >= 0 && R < h)
+            return R;
+        }
+        return I;
+      }) : this.prerelease = [], this.build = i[5] ? i[5].split(".") : [], this.format();
+    }
+    format() {
+      return this.version = `${this.major}.${this.minor}.${this.patch}`, this.prerelease.length && (this.version += `-${this.prerelease.join(".")}`), this.version;
+    }
+    toString() {
+      return this.version;
+    }
+    compare(e) {
+      if (L("SemVer.compare", this.version, this.options, e), !(e instanceof n)) {
+        if (typeof e == "string" && e === this.version)
+          return 0;
+        e = new n(e, this.options);
+      }
+      return e.version === this.version ? 0 : this.compareMain(e) || this.comparePre(e);
+    }
+    compareMain(e) {
+      return e instanceof n || (e = new n(e, this.options)), N(this.major, e.major) || N(this.minor, e.minor) || N(this.patch, e.patch);
+    }
+    comparePre(e) {
+      if (e instanceof n || (e = new n(e, this.options)), this.prerelease.length && !e.prerelease.length)
+        return -1;
+      if (!this.prerelease.length && e.prerelease.length)
+        return 1;
+      if (!this.prerelease.length && !e.prerelease.length)
+        return 0;
+      let E = 0;
+      do {
+        let i = this.prerelease[E], I = e.prerelease[E];
+        if (L("prerelease compare", E, i, I), i === void 0 && I === void 0)
+          return 0;
+        if (I === void 0)
+          return 1;
+        if (i === void 0)
+          return -1;
+        if (i === I)
+          continue;
+        return N(i, I);
+      } while (++E);
+    }
+    compareBuild(e) {
+      e instanceof n || (e = new n(e, this.options));
+      let E = 0;
+      do {
+        let i = this.build[E], I = e.build[E];
+        if (L("build compare", E, i, I), i === void 0 && I === void 0)
+          return 0;
+        if (I === void 0)
+          return 1;
+        if (i === void 0)
+          return -1;
+        if (i === I)
+          continue;
+        return N(i, I);
+      } while (++E);
+    }
+    // preminor will bump the version up to the next minor release, and immediately
+    // down to pre-release. premajor and prepatch work the same way.
+    inc(e, E, i) {
+      if (e.startsWith("pre")) {
+        if (!E && i === !1)
+          throw new Error("invalid increment argument: identifier is empty");
+        if (E) {
+          let I = `-${E}`.match(this.options.loose ? p[l.PRERELEASELOOSE] : p[l.PRERELEASE]);
+          if (!I || I[1] !== E)
+            throw new Error(`invalid identifier: ${E}`);
+        }
+      }
+      switch (e) {
+        case "premajor":
+          this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++, this.inc("pre", E, i);
+          break;
+        case "preminor":
+          this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", E, i);
+          break;
+        case "prepatch":
+          this.prerelease.length = 0, this.inc("patch", E, i), this.inc("pre", E, i);
+          break;
+        // If the input is a non-prerelease version, this acts the same as
+        // prepatch.
+        case "prerelease":
+          this.prerelease.length === 0 && this.inc("patch", E, i), this.inc("pre", E, i);
+          break;
+        case "release":
+          if (this.prerelease.length === 0)
+            throw new Error(`version ${this.raw} is not a prerelease`);
+          this.prerelease.length = 0;
+          break;
+        case "major":
+          (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) && this.major++, this.minor = 0, this.patch = 0, this.prerelease = [];
+          break;
+        case "minor":
+          (this.patch !== 0 || this.prerelease.length === 0) && this.minor++, this.patch = 0, this.prerelease = [];
+          break;
+        case "patch":
+          this.prerelease.length === 0 && this.patch++, this.prerelease = [];
+          break;
+        // This probably shouldn't be used publicly.
+        // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+        case "pre": {
+          let I = Number(i) ? 1 : 0;
+          if (this.prerelease.length === 0)
+            this.prerelease = [I];
+          else {
+            let R = this.prerelease.length;
+            for (; --R >= 0; )
+              typeof this.prerelease[R] == "number" && (this.prerelease[R]++, R = -2);
+            if (R === -1) {
+              if (E === this.prerelease.join(".") && i === !1)
+                throw new Error("invalid increment argument: identifier already exists");
+              this.prerelease.push(I);
+            }
+          }
+          if (E) {
+            let R = [E, I];
+            i === !1 && (R = [E]), N(this.prerelease[0], E) === 0 ? isNaN(this.prerelease[1]) && (this.prerelease = R) : this.prerelease = R;
+          }
+          break;
+        }
+        default:
+          throw new Error(`invalid increment argument: ${e}`);
+      }
+      return this.raw = this.format(), this.build.length && (this.raw += `+${this.build.join(".")}`), this;
+    }
+  };
+  w.exports = u;
+});
+
+// ../../node_modules/semver/functions/compare.js
+var j = c(($e, b) => {
+  "use strict";
+  var X = U(), ie = /* @__PURE__ */ a((n, e, E) => new X(n, E).compare(new X(e, E)), "compare");
+  b.exports = ie;
+});
+
+// ../../node_modules/semver/functions/gte.js
+var ae = c((Te, _) => {
+  "use strict";
+  var ne = j(), Ie = /* @__PURE__ */ a((n, e, E) => ne(n, e, E) >= 0, "gte");
+  _.exports = Ie;
+});
+
+export {
+  O as a,
+  $ as b,
+  D as c,
+  d,
+  C as e,
+  U as f,
+  j as g,
+  ae as h
+};

package/dist/_node-chunks/chunk-CIKGVIS6.js

@@ -0,0 +1,223 @@
+import CJS_COMPAT_NODE_URL from 'node:url';
+import CJS_COMPAT_NODE_PATH from 'node:path';
+import CJS_COMPAT_NODE_MODULE from "node:module";
+
+const __filename = CJS_COMPAT_NODE_URL.fileURLToPath(import.meta.url);
+const __dirname = CJS_COMPAT_NODE_PATH.dirname(__filename);
+const require = CJS_COMPAT_NODE_MODULE.createRequire(import.meta.url);
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Storybook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  a as r
+} from "./chunk-KVKHJ5OL.js";
+
+// src/utils.ts
+function z(t) {
+  return (t.addons || []).map((s) => {
+    let c = "";
+    return typeof s == "string" ? c = s : typeof s == "object" && (c = s.name), c;
+  }).filter((s) => s != null);
+}
+r(z, "getAddonNames");
+function v(t) {
+  return {
+    message: t.message,
+    name: t.name,
+    // avoid duplicating the error message in the stack trace
+    stack: t.stack?.replace(t.message, ""),
+    cause: t.cause && t.cause instanceof Error ? v(t.cause) : void 0
+  };
+}
+r(v, "errorToErrorLike");
+
+// ../../node_modules/find-up/index.js
+import m from "node:path";
+
+// ../../node_modules/locate-path/index.js
+import g from "node:process";
+import N from "node:path";
+import J, { promises as b } from "node:fs";
+import { fileURLToPath as T } from "node:url";
+
+// ../../node_modules/yocto-queue/index.js
+var d = class {
+  static {
+    r(this, "Node");
+  }
+  value;
+  next;
+  constructor(e) {
+    this.value = e;
+  }
+}, p = class {
+  static {
+    r(this, "Queue");
+  }
+  #t;
+  #e;
+  #r;
+  constructor() {
+    this.clear();
+  }
+  enqueue(e) {
+    let n = new d(e);
+    this.#t ? (this.#e.next = n, this.#e = n) : (this.#t = n, this.#e = n), this.#r++;
+  }
+  dequeue() {
+    let e = this.#t;
+    if (e)
+      return this.#t = this.#t.next, this.#r--, e.value;
+  }
+  peek() {
+    if (this.#t)
+      return this.#t.value;
+  }
+  clear() {
+    this.#t = void 0, this.#e = void 0, this.#r = 0;
+  }
+  get size() {
+    return this.#r;
+  }
+  *[Symbol.iterator]() {
+    let e = this.#t;
+    for (; e; )
+      yield e.value, e = e.next;
+  }
+  *drain() {
+    for (; this.#t; )
+      yield this.dequeue();
+  }
+};
+
+// ../../node_modules/locate-path/node_modules/p-limit/index.js
+function h(t) {
+  if (!((Number.isInteger(t) || t === Number.POSITIVE_INFINITY) && t > 0))
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  let e = new p(), n = 0, s = /* @__PURE__ */ r(() => {
+    n--, e.size > 0 && e.dequeue()();
+  }, "next"), c = /* @__PURE__ */ r(async (o, a, i) => {
+    n++;
+    let l = (async () => o(...i))();
+    a(l);
+    try {
+      await l;
+    } catch {
+    }
+    s();
+  }, "run"), f = /* @__PURE__ */ r((o, a, i) => {
+    e.enqueue(c.bind(void 0, o, a, i)), (async () => (await Promise.resolve(), n < t && e.size > 0 && e.dequeue()()))();
+  }, "enqueue"), u = /* @__PURE__ */ r((o, ...a) => new Promise((i) => {
+    f(o, i, a);
+  }), "generator");
+  return Object.defineProperties(u, {
+    activeCount: {
+      get: /* @__PURE__ */ r(() => n, "get")
+    },
+    pendingCount: {
+      get: /* @__PURE__ */ r(() => e.size, "get")
+    },
+    clearQueue: {
+      value: /* @__PURE__ */ r(() => {
+        e.clear();
+      }, "value")
+    }
+  }), u;
+}
+r(h, "pLimit");
+
+// ../../node_modules/locate-path/node_modules/p-locate/index.js
+var y = class extends Error {
+  static {
+    r(this, "EndError");
+  }
+  constructor(e) {
+    super(), this.value = e;
+  }
+}, E = /* @__PURE__ */ r(async (t, e) => e(await t), "testElement"), S = /* @__PURE__ */ r(async (t) => {
+  let e = await Promise.all(t);
+  if (e[1] === !0)
+    throw new y(e[0]);
+  return !1;
+}, "finder");
+async function w(t, e, {
+  concurrency: n = Number.POSITIVE_INFINITY,
+  preserveOrder: s = !0
+} = {}) {
+  let c = h(n), f = [...t].map((o) => [o, c(E, o, e)]), u = h(s ? 1 : Number.POSITIVE_INFINITY);
+  try {
+    await Promise.all(f.map((o) => u(S, o)));
+  } catch (o) {
+    if (o instanceof y)
+      return o.value;
+    throw o;
+  }
+}
+r(w, "pLocate");
+
+// ../../node_modules/locate-path/index.js
+var P = {
+  directory: "isDirectory",
+  file: "isFile"
+};
+function k(t) {
+  if (!Object.hasOwnProperty.call(P, t))
+    throw new Error(`Invalid type specified: ${t}`);
+}
+r(k, "checkType");
+var L = /* @__PURE__ */ r((t, e) => e[P[t]](), "matchType"), U = /* @__PURE__ */ r((t) => t instanceof URL ? T(t) : t, "toPath");
+async function x(t, {
+  cwd: e = g.cwd(),
+  type: n = "file",
+  allowSymlinks: s = !0,
+  concurrency: c,
+  preserveOrder: f
+} = {}) {
+  k(n), e = U(e);
+  let u = s ? b.stat : b.lstat;
+  return w(t, async (o) => {
+    try {
+      let a = await u(N.resolve(e, o));
+      return L(n, a);
+    } catch {
+      return !1;
+    }
+  }, { concurrency: c, preserveOrder: f });
+}
+r(x, "locatePath");
+
+// ../../node_modules/find-up/node_modules/unicorn-magic/node.js
+import { fileURLToPath as q } from "node:url";
+function I(t) {
+  return t instanceof URL ? q(t) : t;
+}
+r(I, "toPath");
+
+// ../../node_modules/find-up/index.js
+var F = Symbol("findUpStop");
+async function _(t, e = {}) {
+  let n = m.resolve(I(e.cwd) ?? ""), { root: s } = m.parse(n), c = m.resolve(n, I(e.stopAt ?? s)), f = e.limit ?? Number.POSITIVE_INFINITY, u = [t].flat(), o = /* @__PURE__ */ r(async (i) => {
+    if (typeof t != "function")
+      return x(u, i);
+    let l = await t(i.cwd);
+    return typeof l == "string" ? x([l], i) : l;
+  }, "runMatcher"), a = [];
+  for (; ; ) {
+    let i = await o({ ...e, cwd: n });
+    if (i === F || (i && a.push(m.resolve(n, i)), n === c || a.length >= f))
+      break;
+    n = m.dirname(n);
+  }
+  return a;
+}
+r(_, "findUpMultiple");
+async function mt(t, e = {}) {
+  return (await _(t, { ...e, limit: 1 }))[0];
+}
+r(mt, "findUp");
+
+export {
+  z as a,
+  v as b,
+  mt as c
+};