@sleepy-hollow/framework 0.3.0

package/dist/chunk-D4U3ZY4O.js

@@ -0,0 +1,4585 @@
+import {
+  openEmbeddedSqlite
+} from "./chunk-BAKXP7IR.js";
+import {
+  composeProjectSecurity
+} from "./chunk-DGTHFZPZ.js";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-5WRI5ZAA.js";
+
+// node_modules/expect-type/dist/branding.js
+var require_branding = __commonJS({
+  "node_modules/expect-type/dist/branding.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// node_modules/expect-type/dist/messages.js
+var require_messages = __commonJS({
+  "node_modules/expect-type/dist/messages.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// node_modules/expect-type/dist/overloads.js
+var require_overloads = __commonJS({
+  "node_modules/expect-type/dist/overloads.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// node_modules/expect-type/dist/utils.js
+var require_utils = __commonJS({
+  "node_modules/expect-type/dist/utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// node_modules/expect-type/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/expect-type/dist/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.expectTypeOf = void 0;
+    __exportStar(require_branding(), exports);
+    __exportStar(require_messages(), exports);
+    __exportStar(require_overloads(), exports);
+    __exportStar(require_utils(), exports);
+    var fn = () => true;
+    var expectTypeOf2 = (_actual) => {
+      const nonFunctionProperties = [
+        "parameters",
+        "returns",
+        "resolves",
+        "not",
+        "items",
+        "constructorParameters",
+        "thisParameter",
+        "instance",
+        "guards",
+        "asserts"
+      ];
+      function createBranded() {
+        return {
+          inspect: () => true,
+          configure: () => createBranded(),
+          toEqualTypeOf: fn
+        };
+      }
+      const obj = {
+        toBeAny: fn,
+        toBeUnknown: fn,
+        toBeNever: fn,
+        toBeFunction: fn,
+        toBeObject: fn,
+        toBeArray: fn,
+        toBeString: fn,
+        toBeNumber: fn,
+        toBeBoolean: fn,
+        toBeVoid: fn,
+        toBeSymbol: fn,
+        toBeNull: fn,
+        toBeUndefined: fn,
+        toBeNullable: fn,
+        toBeBigInt: fn,
+        toMatchTypeOf: fn,
+        toEqualTypeOf: fn,
+        toBeConstructibleWith: fn,
+        toMatchObjectType: fn,
+        toExtend: fn,
+        map: exports.expectTypeOf,
+        toBeCallableWith: exports.expectTypeOf,
+        extract: exports.expectTypeOf,
+        exclude: exports.expectTypeOf,
+        pick: exports.expectTypeOf,
+        omit: exports.expectTypeOf,
+        toHaveProperty: exports.expectTypeOf,
+        parameter: exports.expectTypeOf,
+        get branded() {
+          return createBranded();
+        }
+      };
+      const getterProperties = nonFunctionProperties;
+      getterProperties.forEach((prop) => Object.defineProperty(obj, prop, { get: () => (0, exports.expectTypeOf)({}) }));
+      return obj;
+    };
+    exports.expectTypeOf = expectTypeOf2;
+  }
+});
+
+// core/testing/error.ts
+var TestingError = class extends Error {
+  /** Every fault found, sorted by subject and then code. */
+  diagnostics;
+  /**
+   * Builds an error carrying every fault found.
+   *
+   * @param diagnostics The faults; they are sorted for stable output.
+   */
+  constructor(diagnostics) {
+    super("Sleepy Hollow testing validation failed");
+    this.name = "TestingError";
+    this.diagnostics = [...diagnostics].sort(
+      (left, right) => (left.subject ?? "").localeCompare(right.subject ?? "") || left.code.localeCompare(right.code)
+    );
+  }
+};
+function testingDiagnostic(code, message, correction, subject) {
+  return { code, message, subject, correction };
+}
+
+// core/testing/application.ts
+function equal(left, right) {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left) && Array.isArray(right)) {
+    return left.length === right.length && left.every((value, index2) => equal(value, right[index2]));
+  }
+  if (left !== null && right !== null && typeof left === "object" && typeof right === "object") {
+    const leftRecord = left;
+    const rightRecord = right;
+    const leftKeys = Object.keys(leftRecord).sort();
+    const rightKeys = Object.keys(rightRecord).sort();
+    return equal(leftKeys, rightKeys) && leftKeys.every((key) => equal(leftRecord[key], rightRecord[key]));
+  }
+  return false;
+}
+async function problem(response, expectation) {
+  const diagnostics = [];
+  const contentType = response.headers.get("content-type") ?? "";
+  if (!contentType.toLowerCase().startsWith("application/problem+json")) {
+    diagnostics.push(testingDiagnostic(
+      "SH_TEST_PROBLEM_CONTENT_TYPE",
+      `Expected application/problem+json but received ${contentType || "no content type"}.`,
+      "Return RFC 9457 Problem Details with the problem JSON media type."
+    ));
+  }
+  if (response.status !== expectation.status || response.ok) {
+    diagnostics.push(testingDiagnostic(
+      "SH_TEST_PROBLEM_STATUS",
+      `Expected failing status ${expectation.status} but received ${response.status}.`,
+      "Return the approved non-success HTTP status in both the response and problem body."
+    ));
+  }
+  let value;
+  try {
+    value = await response.json();
+  } catch {
+    diagnostics.push(testingDiagnostic(
+      "SH_TEST_PROBLEM_JSON",
+      "Problem response body is not valid JSON.",
+      "Return one RFC 9457 JSON object."
+    ));
+  }
+  const body = value !== null && typeof value === "object" ? value : {};
+  if (typeof body.type !== "string" || typeof body.title !== "string" || typeof body.status !== "number" || body.status !== response.status) {
+    diagnostics.push(testingDiagnostic(
+      "SH_TEST_PROBLEM_SHAPE",
+      "Problem response lacks matching type, title, and numeric status members.",
+      "Return the required RFC 9457 members and match the HTTP status."
+    ));
+  }
+  if (expectation.type !== void 0 && body.type !== expectation.type) {
+    diagnostics.push(testingDiagnostic(
+      "SH_TEST_PROBLEM_TYPE",
+      `Expected problem type ${expectation.type}.`,
+      "Return the approved stable problem type URI."
+    ));
+  }
+  if (expectation.title !== void 0 && body.title !== expectation.title) {
+    diagnostics.push(testingDiagnostic(
+      "SH_TEST_PROBLEM_TITLE",
+      `Expected problem title ${expectation.title}.`,
+      "Return the approved safe problem title."
+    ));
+  }
+  for (const [key, expected] of Object.entries(expectation.extensions ?? {})) {
+    if (!equal(body[key], expected)) {
+      diagnostics.push(testingDiagnostic(
+        "SH_TEST_PROBLEM_EXTENSION",
+        `Problem extension ${key} does not match its expected value.`,
+        "Return the approved safe extension value.",
+        key
+      ));
+    }
+  }
+  if (diagnostics.length > 0) throw new TestingError(diagnostics);
+  return body;
+}
+function required(create) {
+  if (create === void 0) {
+    throw new TestingError([testingDiagnostic(
+      "SH_TEST_APPLICATION_SOURCE_REQUIRED",
+      "A test application needs either an application factory or a route inventory.",
+      "Supply create or routes."
+    )]);
+  }
+  return create;
+}
+async function secured(routes, security) {
+  const router = await composeProjectSecurity(routes, {
+    mode: "test",
+    root: security?.root ?? ".",
+    ...security?.securityModule === void 0 ? {} : { securityModule: security.securityModule },
+    ...security?.load === void 0 ? {} : { load: security.load }
+  });
+  return { fetch: (request) => router.fetch(request) };
+}
+async function testApplication(options) {
+  const database = openEmbeddedSqlite({ filename: ":memory:" });
+  let closed = false;
+  const cleanup = async () => {
+    if (closed) return;
+    closed = true;
+    try {
+      await options.cleanup?.();
+    } finally {
+      database.close();
+    }
+  };
+  try {
+    const application = options.routes === void 0 ? await required(options.create)({
+      database,
+      principal: options.principal === void 0 ? void 0 : structuredClone(options.principal),
+      credentials: options.credentials === void 0 ? void 0 : structuredClone(options.credentials)
+    }) : await secured(options.routes, options.security);
+    await options.seed?.({ database, application });
+    const origin = new URL(options.origin ?? "http://sleepy-hollow.test");
+    const fetchApplication = async (input, init) => {
+      const request = input instanceof Request ? new Request(input, init) : new Request(new URL(String(input), origin), init);
+      return await application.fetch(request);
+    };
+    const context = {
+      database,
+      application,
+      fetch: fetchApplication,
+      async request(requestOptions) {
+        const headers = new Headers(requestOptions.headers);
+        let body;
+        if (requestOptions.body !== void 0) {
+          headers.set("content-type", "application/json");
+          body = JSON.stringify(requestOptions.body);
+        }
+        const response = await fetchApplication(requestOptions.path, {
+          method: requestOptions.method ?? (body === void 0 ? "GET" : "POST"),
+          headers,
+          body
+        });
+        const text = await response.clone().text();
+        const parsed = text === "" ? void 0 : JSON.parse(text);
+        return { response, body: parsed };
+      },
+      assertProblem: problem,
+      close: cleanup,
+      [Symbol.asyncDispose]: cleanup
+    };
+    return Object.freeze(context);
+  } catch (error) {
+    await cleanup();
+    throw error;
+  }
+}
+
+// core/testing/criterion.ts
+import { createHash } from "crypto";
+
+// node_modules/tinyrainbow/dist/index.js
+var b = {
+  reset: [0, 0],
+  bold: [1, 22, "\x1B[22m\x1B[1m"],
+  dim: [2, 22, "\x1B[22m\x1B[2m"],
+  italic: [3, 23],
+  underline: [4, 24],
+  inverse: [7, 27],
+  hidden: [8, 28],
+  strikethrough: [9, 29],
+  black: [30, 39],
+  red: [31, 39],
+  green: [32, 39],
+  yellow: [33, 39],
+  blue: [34, 39],
+  magenta: [35, 39],
+  cyan: [36, 39],
+  white: [37, 39],
+  gray: [90, 39],
+  bgBlack: [40, 49],
+  bgRed: [41, 49],
+  bgGreen: [42, 49],
+  bgYellow: [43, 49],
+  bgBlue: [44, 49],
+  bgMagenta: [45, 49],
+  bgCyan: [46, 49],
+  bgWhite: [47, 49],
+  blackBright: [90, 39],
+  redBright: [91, 39],
+  greenBright: [92, 39],
+  yellowBright: [93, 39],
+  blueBright: [94, 39],
+  magentaBright: [95, 39],
+  cyanBright: [96, 39],
+  whiteBright: [97, 39],
+  bgBlackBright: [100, 49],
+  bgRedBright: [101, 49],
+  bgGreenBright: [102, 49],
+  bgYellowBright: [103, 49],
+  bgBlueBright: [104, 49],
+  bgMagentaBright: [105, 49],
+  bgCyanBright: [106, 49],
+  bgWhiteBright: [107, 49]
+};
+function i(e) {
+  return String(e);
+}
+i.open = "";
+i.close = "";
+function B() {
+  let e = typeof process != "undefined" ? process : void 0, r = (e == null ? void 0 : e.env) || {}, a = r.FORCE_TTY !== "false", l = (e == null ? void 0 : e.argv) || [];
+  return !("NO_COLOR" in r || l.includes("--no-color")) && ("FORCE_COLOR" in r || l.includes("--color") || (e == null ? void 0 : e.platform) === "win32" || a && r.TERM !== "dumb" || "CI" in r) || typeof window != "undefined" && !!window.chrome;
+}
+function C({ force: e } = {}) {
+  let r = e || B(), a = (t, o, u, n) => {
+    let g = "", s = 0;
+    do
+      g += t.substring(s, n) + u, s = n + o.length, n = t.indexOf(o, s);
+    while (~n);
+    return g + t.substring(s);
+  }, l = (t, o, u = t) => {
+    let n = (g) => {
+      let s = String(g), h = s.indexOf(o, t.length);
+      return ~h ? t + a(s, o, u, h) + o : t + s + o;
+    };
+    return n.open = t, n.close = o, n;
+  }, c = {
+    isColorSupported: r
+  }, f = (t) => `\x1B[${t}m`;
+  for (let t in b) {
+    let o = b[t];
+    c[t] = r ? l(
+      f(o[0]),
+      f(o[1]),
+      o[2]
+    ) : i;
+  }
+  return c;
+}
+var d = C();
+var y = d;
+
+// node_modules/@vitest/pretty-format/dist/index.js
+function _mergeNamespaces(n, m) {
+  m.forEach(function(e) {
+    e && typeof e !== "string" && !Array.isArray(e) && Object.keys(e).forEach(function(k) {
+      if (k !== "default" && !(k in n)) {
+        var d2 = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d2.get ? d2 : {
+          enumerable: true,
+          get: function() {
+            return e[k];
+          }
+        });
+      }
+    });
+  });
+  return Object.freeze(n);
+}
+function getKeysOfEnumerableProperties(object, compareKeys) {
+  const rawKeys = Object.keys(object);
+  const keys = compareKeys === null ? rawKeys : rawKeys.sort(compareKeys);
+  if (Object.getOwnPropertySymbols) {
+    for (const symbol of Object.getOwnPropertySymbols(object)) {
+      if (Object.getOwnPropertyDescriptor(object, symbol).enumerable) {
+        keys.push(symbol);
+      }
+    }
+  }
+  return keys;
+}
+function printIteratorEntries(iterator, config, indentation, depth, refs, printer2, separator = ": ") {
+  let result = "";
+  let width = 0;
+  let current = iterator.next();
+  if (!current.done) {
+    result += config.spacingOuter;
+    const indentationNext = indentation + config.indent;
+    while (!current.done) {
+      result += indentationNext;
+      if (width++ === config.maxWidth) {
+        result += "\u2026";
+        break;
+      }
+      const name = printer2(current.value[0], config, indentationNext, depth, refs);
+      const value = printer2(current.value[1], config, indentationNext, depth, refs);
+      result += name + separator + value;
+      current = iterator.next();
+      if (!current.done) {
+        result += `,${config.spacingInner}`;
+      } else if (!config.min) {
+        result += ",";
+      }
+    }
+    result += config.spacingOuter + indentation;
+  }
+  return result;
+}
+function printIteratorValues(iterator, config, indentation, depth, refs, printer2) {
+  let result = "";
+  let width = 0;
+  let current = iterator.next();
+  if (!current.done) {
+    result += config.spacingOuter;
+    const indentationNext = indentation + config.indent;
+    while (!current.done) {
+      result += indentationNext;
+      if (width++ === config.maxWidth) {
+        result += "\u2026";
+        break;
+      }
+      result += printer2(current.value, config, indentationNext, depth, refs);
+      current = iterator.next();
+      if (!current.done) {
+        result += `,${config.spacingInner}`;
+      } else if (!config.min) {
+        result += ",";
+      }
+    }
+    result += config.spacingOuter + indentation;
+  }
+  return result;
+}
+function printListItems(list, config, indentation, depth, refs, printer2) {
+  let result = "";
+  list = list instanceof ArrayBuffer ? new DataView(list) : list;
+  const isDataView = (l) => l instanceof DataView;
+  const length = isDataView(list) ? list.byteLength : list.length;
+  if (length > 0) {
+    result += config.spacingOuter;
+    const indentationNext = indentation + config.indent;
+    for (let i2 = 0; i2 < length; i2++) {
+      result += indentationNext;
+      if (i2 === config.maxWidth) {
+        result += "\u2026";
+        break;
+      }
+      if (isDataView(list) || i2 in list) {
+        result += printer2(isDataView(list) ? list.getInt8(i2) : list[i2], config, indentationNext, depth, refs);
+      }
+      if (i2 < length - 1) {
+        result += `,${config.spacingInner}`;
+      } else if (!config.min) {
+        result += ",";
+      }
+    }
+    result += config.spacingOuter + indentation;
+  }
+  return result;
+}
+function printObjectProperties(val, config, indentation, depth, refs, printer2) {
+  let result = "";
+  const keys = getKeysOfEnumerableProperties(val, config.compareKeys);
+  if (keys.length > 0) {
+    result += config.spacingOuter;
+    const indentationNext = indentation + config.indent;
+    for (let i2 = 0; i2 < keys.length; i2++) {
+      const key = keys[i2];
+      const name = printer2(key, config, indentationNext, depth, refs);
+      const value = printer2(val[key], config, indentationNext, depth, refs);
+      result += `${indentationNext + name}: ${value}`;
+      if (i2 < keys.length - 1) {
+        result += `,${config.spacingInner}`;
+      } else if (!config.min) {
+        result += ",";
+      }
+    }
+    result += config.spacingOuter + indentation;
+  }
+  return result;
+}
+var asymmetricMatcher = typeof Symbol === "function" && Symbol.for ? /* @__PURE__ */ Symbol.for("jest.asymmetricMatcher") : 1267621;
+var SPACE$2 = " ";
+var serialize$5 = (val, config, indentation, depth, refs, printer2) => {
+  const stringedValue = val.toString();
+  if (stringedValue === "ArrayContaining" || stringedValue === "ArrayNotContaining") {
+    if (++depth > config.maxDepth) {
+      return `[${stringedValue}]`;
+    }
+    return `${stringedValue + SPACE$2}[${printListItems(val.sample, config, indentation, depth, refs, printer2)}]`;
+  }
+  if (stringedValue === "ObjectContaining" || stringedValue === "ObjectNotContaining") {
+    if (++depth > config.maxDepth) {
+      return `[${stringedValue}]`;
+    }
+    return `${stringedValue + SPACE$2}{${printObjectProperties(val.sample, config, indentation, depth, refs, printer2)}}`;
+  }
+  if (stringedValue === "StringMatching" || stringedValue === "StringNotMatching") {
+    return stringedValue + SPACE$2 + printer2(val.sample, config, indentation, depth, refs);
+  }
+  if (stringedValue === "StringContaining" || stringedValue === "StringNotContaining") {
+    return stringedValue + SPACE$2 + printer2(val.sample, config, indentation, depth, refs);
+  }
+  if (typeof val.toAsymmetricMatcher !== "function") {
+    throw new TypeError(`Asymmetric matcher ${val.constructor.name} does not implement toAsymmetricMatcher()`);
+  }
+  return val.toAsymmetricMatcher();
+};
+var test$5 = (val) => val && val.$$typeof === asymmetricMatcher;
+var plugin$5 = {
+  serialize: serialize$5,
+  test: test$5
+};
+var SPACE$1 = " ";
+var OBJECT_NAMES = /* @__PURE__ */ new Set(["DOMStringMap", "NamedNodeMap"]);
+var ARRAY_REGEXP = /^(?:HTML\w*Collection|NodeList)$/;
+function testName(name) {
+  return OBJECT_NAMES.has(name) || ARRAY_REGEXP.test(name);
+}
+var test$4 = (val) => val && val.constructor && !!val.constructor.name && testName(val.constructor.name);
+function isNamedNodeMap(collection) {
+  return collection.constructor.name === "NamedNodeMap";
+}
+var serialize$4 = (collection, config, indentation, depth, refs, printer2) => {
+  const name = collection.constructor.name;
+  if (++depth > config.maxDepth) {
+    return `[${name}]`;
+  }
+  return (config.min ? "" : name + SPACE$1) + (OBJECT_NAMES.has(name) ? `{${printObjectProperties(isNamedNodeMap(collection) ? [...collection].reduce((props, attribute) => {
+    props[attribute.name] = attribute.value;
+    return props;
+  }, {}) : { ...collection }, config, indentation, depth, refs, printer2)}}` : `[${printListItems([...collection], config, indentation, depth, refs, printer2)}]`);
+};
+var plugin$4 = {
+  serialize: serialize$4,
+  test: test$4
+};
+function escapeHTML(str) {
+  return str.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function printProps(keys, props, config, indentation, depth, refs, printer2) {
+  const indentationNext = indentation + config.indent;
+  const colors = config.colors;
+  return keys.map((key) => {
+    const value = props[key];
+    if (typeof value === "string" && value[0] === "_" && value.startsWith("__vitest_") && value.match(/__vitest_\d+__/)) {
+      return "";
+    }
+    let printed = printer2(value, config, indentationNext, depth, refs);
+    if (typeof value !== "string") {
+      if (printed.includes("\n")) {
+        printed = config.spacingOuter + indentationNext + printed + config.spacingOuter + indentation;
+      }
+      printed = `{${printed}}`;
+    }
+    return `${config.spacingInner + indentation + colors.prop.open + key + colors.prop.close}=${colors.value.open}${printed}${colors.value.close}`;
+  }).join("");
+}
+function printChildren(children, config, indentation, depth, refs, printer2) {
+  return children.map((child) => config.spacingOuter + indentation + (typeof child === "string" ? printText(child, config) : printer2(child, config, indentation, depth, refs))).join("");
+}
+function printShadowRoot(children, config, indentation, depth, refs, printer2) {
+  if (config.printShadowRoot === false) {
+    return "";
+  }
+  return [`${config.spacingOuter + indentation}#shadow-root`, printChildren(children, config, indentation + config.indent, depth, refs, printer2)].join("");
+}
+function printText(text, config) {
+  const contentColor = config.colors.content;
+  return contentColor.open + escapeHTML(text) + contentColor.close;
+}
+function printComment(comment, config) {
+  const commentColor = config.colors.comment;
+  return `${commentColor.open}<!--${escapeHTML(comment)}-->${commentColor.close}`;
+}
+function printElement(type, printedProps, printedChildren, config, indentation) {
+  const tagColor = config.colors.tag;
+  return `${tagColor.open}<${type}${printedProps && tagColor.close + printedProps + config.spacingOuter + indentation + tagColor.open}${printedChildren ? `>${tagColor.close}${printedChildren}${config.spacingOuter}${indentation}${tagColor.open}</${type}` : `${printedProps && !config.min ? "" : " "}/`}>${tagColor.close}`;
+}
+function printElementAsLeaf(type, config) {
+  const tagColor = config.colors.tag;
+  return `${tagColor.open}<${type}${tagColor.close} \u2026${tagColor.open} />${tagColor.close}`;
+}
+var ELEMENT_NODE = 1;
+var TEXT_NODE = 3;
+var COMMENT_NODE = 8;
+var FRAGMENT_NODE = 11;
+var ELEMENT_REGEXP = /^(?:(?:HTML|SVG)\w*)?Element$/;
+function testHasAttribute(val) {
+  try {
+    return typeof val.hasAttribute === "function" && val.hasAttribute("is");
+  } catch {
+    return false;
+  }
+}
+function testNode(val) {
+  const constructorName = val.constructor.name;
+  const { nodeType, tagName } = val;
+  const isCustomElement = typeof tagName === "string" && tagName.includes("-") || testHasAttribute(val);
+  return nodeType === ELEMENT_NODE && (ELEMENT_REGEXP.test(constructorName) || isCustomElement) || nodeType === TEXT_NODE && constructorName === "Text" || nodeType === COMMENT_NODE && constructorName === "Comment" || nodeType === FRAGMENT_NODE && constructorName === "DocumentFragment";
+}
+var test$3 = (val) => val?.constructor?.name && testNode(val);
+function nodeIsText(node) {
+  return node.nodeType === TEXT_NODE;
+}
+function nodeIsComment(node) {
+  return node.nodeType === COMMENT_NODE;
+}
+function nodeIsFragment(node) {
+  return node.nodeType === FRAGMENT_NODE;
+}
+function filterChildren(children, filterNode) {
+  let filtered = children.filter((node) => {
+    if (node.nodeType === TEXT_NODE) {
+      const text = node.data || "";
+      return text.trim().length > 0;
+    }
+    return true;
+  });
+  if (filterNode) {
+    filtered = filtered.filter(filterNode);
+  }
+  return filtered;
+}
+function serializeDOM(node, config, indentation, depth, refs, printer2, filterNode) {
+  if (nodeIsText(node)) {
+    return printText(node.data, config);
+  }
+  if (nodeIsComment(node)) {
+    return printComment(node.data, config);
+  }
+  const type = nodeIsFragment(node) ? "DocumentFragment" : node.tagName.toLowerCase();
+  if (++depth > config.maxDepth) {
+    return printElementAsLeaf(type, config);
+  }
+  const children = Array.prototype.slice.call(node.childNodes || node.children);
+  const shadowChildren = nodeIsFragment(node) || !node.shadowRoot ? [] : Array.prototype.slice.call(node.shadowRoot.children);
+  const resolvedChildren = filterNode ? filterChildren(children, filterNode) : children;
+  const resolvedShadowChildren = filterNode ? filterChildren(shadowChildren, filterNode) : shadowChildren;
+  return printElement(type, printProps(nodeIsFragment(node) ? [] : Array.from(node.attributes, (attr) => attr.name).sort(), nodeIsFragment(node) ? {} : [...node.attributes].reduce((props, attribute) => {
+    props[attribute.name] = attribute.value;
+    return props;
+  }, {}), config, indentation + config.indent, depth, refs, printer2), (resolvedShadowChildren.length > 0 ? printShadowRoot(resolvedShadowChildren, config, indentation + config.indent, depth, refs, printer2) : "") + printChildren(resolvedChildren, config, indentation + config.indent, depth, refs, printer2), config, indentation);
+}
+var serialize$3 = (node, config, indentation, depth, refs, printer2) => serializeDOM(node, config, indentation, depth, refs, printer2);
+function createDOMElementFilter(filterNode) {
+  return {
+    test: test$3,
+    serialize: (node, config, indentation, depth, refs, printer2) => serializeDOM(node, config, indentation, depth, refs, printer2, filterNode)
+  };
+}
+var plugin$3 = {
+  serialize: serialize$3,
+  test: test$3
+};
+var IS_ITERABLE_SENTINEL = "@@__IMMUTABLE_ITERABLE__@@";
+var IS_LIST_SENTINEL = "@@__IMMUTABLE_LIST__@@";
+var IS_KEYED_SENTINEL = "@@__IMMUTABLE_KEYED__@@";
+var IS_MAP_SENTINEL = "@@__IMMUTABLE_MAP__@@";
+var IS_ORDERED_SENTINEL = "@@__IMMUTABLE_ORDERED__@@";
+var IS_RECORD_SENTINEL = "@@__IMMUTABLE_RECORD__@@";
+var IS_SEQ_SENTINEL = "@@__IMMUTABLE_SEQ__@@";
+var IS_SET_SENTINEL = "@@__IMMUTABLE_SET__@@";
+var IS_STACK_SENTINEL = "@@__IMMUTABLE_STACK__@@";
+var getImmutableName = (name) => `Immutable.${name}`;
+var printAsLeaf = (name) => `[${name}]`;
+var SPACE = " ";
+var LAZY = "\u2026";
+function printImmutableEntries(val, config, indentation, depth, refs, printer2, type) {
+  return ++depth > config.maxDepth ? printAsLeaf(getImmutableName(type)) : `${getImmutableName(type) + SPACE}{${printIteratorEntries(val.entries(), config, indentation, depth, refs, printer2)}}`;
+}
+function getRecordEntries(val) {
+  let i2 = 0;
+  return { next() {
+    if (i2 < val._keys.length) {
+      const key = val._keys[i2++];
+      return {
+        done: false,
+        value: [key, val.get(key)]
+      };
+    }
+    return {
+      done: true,
+      value: void 0
+    };
+  } };
+}
+function printImmutableRecord(val, config, indentation, depth, refs, printer2) {
+  const name = getImmutableName(val._name || "Record");
+  return ++depth > config.maxDepth ? printAsLeaf(name) : `${name + SPACE}{${printIteratorEntries(getRecordEntries(val), config, indentation, depth, refs, printer2)}}`;
+}
+function printImmutableSeq(val, config, indentation, depth, refs, printer2) {
+  const name = getImmutableName("Seq");
+  if (++depth > config.maxDepth) {
+    return printAsLeaf(name);
+  }
+  if (val[IS_KEYED_SENTINEL]) {
+    return `${name + SPACE}{${val._iter || val._object ? printIteratorEntries(val.entries(), config, indentation, depth, refs, printer2) : LAZY}}`;
+  }
+  return `${name + SPACE}[${val._iter || val._array || val._collection || val._iterable ? printIteratorValues(val.values(), config, indentation, depth, refs, printer2) : LAZY}]`;
+}
+function printImmutableValues(val, config, indentation, depth, refs, printer2, type) {
+  return ++depth > config.maxDepth ? printAsLeaf(getImmutableName(type)) : `${getImmutableName(type) + SPACE}[${printIteratorValues(val.values(), config, indentation, depth, refs, printer2)}]`;
+}
+var serialize$2 = (val, config, indentation, depth, refs, printer2) => {
+  if (val[IS_MAP_SENTINEL]) {
+    return printImmutableEntries(val, config, indentation, depth, refs, printer2, val[IS_ORDERED_SENTINEL] ? "OrderedMap" : "Map");
+  }
+  if (val[IS_LIST_SENTINEL]) {
+    return printImmutableValues(val, config, indentation, depth, refs, printer2, "List");
+  }
+  if (val[IS_SET_SENTINEL]) {
+    return printImmutableValues(val, config, indentation, depth, refs, printer2, val[IS_ORDERED_SENTINEL] ? "OrderedSet" : "Set");
+  }
+  if (val[IS_STACK_SENTINEL]) {
+    return printImmutableValues(val, config, indentation, depth, refs, printer2, "Stack");
+  }
+  if (val[IS_SEQ_SENTINEL]) {
+    return printImmutableSeq(val, config, indentation, depth, refs, printer2);
+  }
+  return printImmutableRecord(val, config, indentation, depth, refs, printer2);
+};
+var test$2 = (val) => val && (val[IS_ITERABLE_SENTINEL] === true || val[IS_RECORD_SENTINEL] === true);
+var plugin$2 = {
+  serialize: serialize$2,
+  test: test$2
+};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var reactIs$1 = { exports: {} };
+var reactIs_production = {};
+var hasRequiredReactIs_production;
+function requireReactIs_production() {
+  if (hasRequiredReactIs_production) return reactIs_production;
+  hasRequiredReactIs_production = 1;
+  var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = /* @__PURE__ */ Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = /* @__PURE__ */ Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo"), REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy"), REACT_VIEW_TRANSITION_TYPE = /* @__PURE__ */ Symbol.for("react.view_transition"), REACT_CLIENT_REFERENCE = /* @__PURE__ */ Symbol.for("react.client.reference");
+  function typeOf(object) {
+    if ("object" === typeof object && null !== object) {
+      var $$typeof = object.$$typeof;
+      switch ($$typeof) {
+        case REACT_ELEMENT_TYPE:
+          switch (object = object.type, object) {
+            case REACT_FRAGMENT_TYPE:
+            case REACT_PROFILER_TYPE:
+            case REACT_STRICT_MODE_TYPE:
+            case REACT_SUSPENSE_TYPE:
+            case REACT_SUSPENSE_LIST_TYPE:
+            case REACT_VIEW_TRANSITION_TYPE:
+              return object;
+            default:
+              switch (object = object && object.$$typeof, object) {
+                case REACT_CONTEXT_TYPE:
+                case REACT_FORWARD_REF_TYPE:
+                case REACT_LAZY_TYPE:
+                case REACT_MEMO_TYPE:
+                  return object;
+                case REACT_CONSUMER_TYPE:
+                  return object;
+                default:
+                  return $$typeof;
+              }
+          }
+        case REACT_PORTAL_TYPE:
+          return $$typeof;
+      }
+    }
+  }
+  reactIs_production.ContextConsumer = REACT_CONSUMER_TYPE;
+  reactIs_production.ContextProvider = REACT_CONTEXT_TYPE;
+  reactIs_production.Element = REACT_ELEMENT_TYPE;
+  reactIs_production.ForwardRef = REACT_FORWARD_REF_TYPE;
+  reactIs_production.Fragment = REACT_FRAGMENT_TYPE;
+  reactIs_production.Lazy = REACT_LAZY_TYPE;
+  reactIs_production.Memo = REACT_MEMO_TYPE;
+  reactIs_production.Portal = REACT_PORTAL_TYPE;
+  reactIs_production.Profiler = REACT_PROFILER_TYPE;
+  reactIs_production.StrictMode = REACT_STRICT_MODE_TYPE;
+  reactIs_production.Suspense = REACT_SUSPENSE_TYPE;
+  reactIs_production.SuspenseList = REACT_SUSPENSE_LIST_TYPE;
+  reactIs_production.isContextConsumer = function(object) {
+    return typeOf(object) === REACT_CONSUMER_TYPE;
+  };
+  reactIs_production.isContextProvider = function(object) {
+    return typeOf(object) === REACT_CONTEXT_TYPE;
+  };
+  reactIs_production.isElement = function(object) {
+    return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+  };
+  reactIs_production.isForwardRef = function(object) {
+    return typeOf(object) === REACT_FORWARD_REF_TYPE;
+  };
+  reactIs_production.isFragment = function(object) {
+    return typeOf(object) === REACT_FRAGMENT_TYPE;
+  };
+  reactIs_production.isLazy = function(object) {
+    return typeOf(object) === REACT_LAZY_TYPE;
+  };
+  reactIs_production.isMemo = function(object) {
+    return typeOf(object) === REACT_MEMO_TYPE;
+  };
+  reactIs_production.isPortal = function(object) {
+    return typeOf(object) === REACT_PORTAL_TYPE;
+  };
+  reactIs_production.isProfiler = function(object) {
+    return typeOf(object) === REACT_PROFILER_TYPE;
+  };
+  reactIs_production.isStrictMode = function(object) {
+    return typeOf(object) === REACT_STRICT_MODE_TYPE;
+  };
+  reactIs_production.isSuspense = function(object) {
+    return typeOf(object) === REACT_SUSPENSE_TYPE;
+  };
+  reactIs_production.isSuspenseList = function(object) {
+    return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
+  };
+  reactIs_production.isValidElementType = function(type) {
+    return "string" === typeof type || "function" === typeof type || type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || "object" === typeof type && null !== type && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_CONSUMER_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_CLIENT_REFERENCE || void 0 !== type.getModuleId) ? true : false;
+  };
+  reactIs_production.typeOf = typeOf;
+  return reactIs_production;
+}
+var hasRequiredReactIs$1;
+function requireReactIs$1() {
+  if (hasRequiredReactIs$1) return reactIs$1.exports;
+  hasRequiredReactIs$1 = 1;
+  {
+    reactIs$1.exports = requireReactIs_production();
+  }
+  return reactIs$1.exports;
+}
+var reactIsExports$1 = requireReactIs$1();
+var index$1 = /* @__PURE__ */ getDefaultExportFromCjs(reactIsExports$1);
+var ReactIs19 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: index$1
+}, [reactIsExports$1]);
+var reactIs = { exports: {} };
+var reactIs_production_min = {};
+var hasRequiredReactIs_production_min;
+function requireReactIs_production_min() {
+  if (hasRequiredReactIs_production_min) return reactIs_production_min;
+  hasRequiredReactIs_production_min = 1;
+  var b2 = /* @__PURE__ */ Symbol.for("react.element"), c = /* @__PURE__ */ Symbol.for("react.portal"), d2 = /* @__PURE__ */ Symbol.for("react.fragment"), e = /* @__PURE__ */ Symbol.for("react.strict_mode"), f = /* @__PURE__ */ Symbol.for("react.profiler"), g = /* @__PURE__ */ Symbol.for("react.provider"), h = /* @__PURE__ */ Symbol.for("react.context"), k = /* @__PURE__ */ Symbol.for("react.server_context"), l = /* @__PURE__ */ Symbol.for("react.forward_ref"), m = /* @__PURE__ */ Symbol.for("react.suspense"), n = /* @__PURE__ */ Symbol.for("react.suspense_list"), p = /* @__PURE__ */ Symbol.for("react.memo"), q = /* @__PURE__ */ Symbol.for("react.lazy"), t = /* @__PURE__ */ Symbol.for("react.offscreen"), u;
+  u = /* @__PURE__ */ Symbol.for("react.module.reference");
+  function v(a) {
+    if ("object" === typeof a && null !== a) {
+      var r = a.$$typeof;
+      switch (r) {
+        case b2:
+          switch (a = a.type, a) {
+            case d2:
+            case f:
+            case e:
+            case m:
+            case n:
+              return a;
+            default:
+              switch (a = a && a.$$typeof, a) {
+                case k:
+                case h:
+                case l:
+                case q:
+                case p:
+                case g:
+                  return a;
+                default:
+                  return r;
+              }
+          }
+        case c:
+          return r;
+      }
+    }
+  }
+  reactIs_production_min.ContextConsumer = h;
+  reactIs_production_min.ContextProvider = g;
+  reactIs_production_min.Element = b2;
+  reactIs_production_min.ForwardRef = l;
+  reactIs_production_min.Fragment = d2;
+  reactIs_production_min.Lazy = q;
+  reactIs_production_min.Memo = p;
+  reactIs_production_min.Portal = c;
+  reactIs_production_min.Profiler = f;
+  reactIs_production_min.StrictMode = e;
+  reactIs_production_min.Suspense = m;
+  reactIs_production_min.SuspenseList = n;
+  reactIs_production_min.isAsyncMode = function() {
+    return false;
+  };
+  reactIs_production_min.isConcurrentMode = function() {
+    return false;
+  };
+  reactIs_production_min.isContextConsumer = function(a) {
+    return v(a) === h;
+  };
+  reactIs_production_min.isContextProvider = function(a) {
+    return v(a) === g;
+  };
+  reactIs_production_min.isElement = function(a) {
+    return "object" === typeof a && null !== a && a.$$typeof === b2;
+  };
+  reactIs_production_min.isForwardRef = function(a) {
+    return v(a) === l;
+  };
+  reactIs_production_min.isFragment = function(a) {
+    return v(a) === d2;
+  };
+  reactIs_production_min.isLazy = function(a) {
+    return v(a) === q;
+  };
+  reactIs_production_min.isMemo = function(a) {
+    return v(a) === p;
+  };
+  reactIs_production_min.isPortal = function(a) {
+    return v(a) === c;
+  };
+  reactIs_production_min.isProfiler = function(a) {
+    return v(a) === f;
+  };
+  reactIs_production_min.isStrictMode = function(a) {
+    return v(a) === e;
+  };
+  reactIs_production_min.isSuspense = function(a) {
+    return v(a) === m;
+  };
+  reactIs_production_min.isSuspenseList = function(a) {
+    return v(a) === n;
+  };
+  reactIs_production_min.isValidElementType = function(a) {
+    return "string" === typeof a || "function" === typeof a || a === d2 || a === f || a === e || a === m || a === n || a === t || "object" === typeof a && null !== a && (a.$$typeof === q || a.$$typeof === p || a.$$typeof === g || a.$$typeof === h || a.$$typeof === l || a.$$typeof === u || void 0 !== a.getModuleId) ? true : false;
+  };
+  reactIs_production_min.typeOf = v;
+  return reactIs_production_min;
+}
+var hasRequiredReactIs;
+function requireReactIs() {
+  if (hasRequiredReactIs) return reactIs.exports;
+  hasRequiredReactIs = 1;
+  {
+    reactIs.exports = requireReactIs_production_min();
+  }
+  return reactIs.exports;
+}
+var reactIsExports = requireReactIs();
+var index = /* @__PURE__ */ getDefaultExportFromCjs(reactIsExports);
+var ReactIs18 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: index
+}, [reactIsExports]);
+var reactIsMethods = [
+  "isAsyncMode",
+  "isConcurrentMode",
+  "isContextConsumer",
+  "isContextProvider",
+  "isElement",
+  "isForwardRef",
+  "isFragment",
+  "isLazy",
+  "isMemo",
+  "isPortal",
+  "isProfiler",
+  "isStrictMode",
+  "isSuspense",
+  "isSuspenseList",
+  "isValidElementType"
+];
+var ReactIs = Object.fromEntries(reactIsMethods.map((m) => [m, (v) => ReactIs18[m](v) || ReactIs19[m](v)]));
+function getChildren(arg, children = []) {
+  if (Array.isArray(arg)) {
+    for (const item of arg) {
+      getChildren(item, children);
+    }
+  } else if (arg != null && arg !== false && arg !== "") {
+    children.push(arg);
+  }
+  return children;
+}
+function getType(element) {
+  const type = element.type;
+  if (typeof type === "string") {
+    return type;
+  }
+  if (typeof type === "function") {
+    return type.displayName || type.name || "Unknown";
+  }
+  if (ReactIs.isFragment(element)) {
+    return "React.Fragment";
+  }
+  if (ReactIs.isSuspense(element)) {
+    return "React.Suspense";
+  }
+  if (typeof type === "object" && type !== null) {
+    if (ReactIs.isContextProvider(element)) {
+      return "Context.Provider";
+    }
+    if (ReactIs.isContextConsumer(element)) {
+      return "Context.Consumer";
+    }
+    if (ReactIs.isForwardRef(element)) {
+      if (type.displayName) {
+        return type.displayName;
+      }
+      const functionName = type.render.displayName || type.render.name || "";
+      return functionName === "" ? "ForwardRef" : `ForwardRef(${functionName})`;
+    }
+    if (ReactIs.isMemo(element)) {
+      const functionName = type.displayName || type.type.displayName || type.type.name || "";
+      return functionName === "" ? "Memo" : `Memo(${functionName})`;
+    }
+  }
+  return "UNDEFINED";
+}
+function getPropKeys$1(element) {
+  const { props } = element;
+  return Object.keys(props).filter((key) => key !== "children" && props[key] !== void 0).sort();
+}
+var serialize$1 = (element, config, indentation, depth, refs, printer2) => ++depth > config.maxDepth ? printElementAsLeaf(getType(element), config) : printElement(getType(element), printProps(getPropKeys$1(element), element.props, config, indentation + config.indent, depth, refs, printer2), printChildren(getChildren(element.props.children), config, indentation + config.indent, depth, refs, printer2), config, indentation);
+var test$1 = (val) => val != null && ReactIs.isElement(val);
+var plugin$1 = {
+  serialize: serialize$1,
+  test: test$1
+};
+var testSymbol = typeof Symbol === "function" && Symbol.for ? /* @__PURE__ */ Symbol.for("react.test.json") : 245830487;
+function getPropKeys(object) {
+  const { props } = object;
+  return props ? Object.keys(props).filter((key) => props[key] !== void 0).sort() : [];
+}
+var serialize = (object, config, indentation, depth, refs, printer2) => ++depth > config.maxDepth ? printElementAsLeaf(object.type, config) : printElement(object.type, object.props ? printProps(getPropKeys(object), object.props, config, indentation + config.indent, depth, refs, printer2) : "", object.children ? printChildren(object.children, config, indentation + config.indent, depth, refs, printer2) : "", config, indentation);
+var test = (val) => val && val.$$typeof === testSymbol;
+var plugin = {
+  serialize,
+  test
+};
+var toString = Object.prototype.toString;
+var toISOString = Date.prototype.toISOString;
+var errorToString = Error.prototype.toString;
+var regExpToString = RegExp.prototype.toString;
+function getConstructorName(val) {
+  return typeof val.constructor === "function" && val.constructor.name || "Object";
+}
+function isWindow(val) {
+  return typeof window !== "undefined" && val === window;
+}
+var SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
+var NEWLINE_REGEXP = /\n/g;
+var PrettyFormatPluginError = class extends Error {
+  constructor(message, stack) {
+    super(message);
+    this.stack = stack;
+    this.name = this.constructor.name;
+  }
+};
+function isToStringedArrayType(toStringed) {
+  return toStringed === "[object Array]" || toStringed === "[object ArrayBuffer]" || toStringed === "[object DataView]" || toStringed === "[object Float32Array]" || toStringed === "[object Float64Array]" || toStringed === "[object Int8Array]" || toStringed === "[object Int16Array]" || toStringed === "[object Int32Array]" || toStringed === "[object Uint8Array]" || toStringed === "[object Uint8ClampedArray]" || toStringed === "[object Uint16Array]" || toStringed === "[object Uint32Array]";
+}
+function printNumber(val) {
+  return Object.is(val, -0) ? "-0" : String(val);
+}
+function printBigInt(val) {
+  return String(`${val}n`);
+}
+function printFunction(val, printFunctionName) {
+  if (!printFunctionName) {
+    return "[Function]";
+  }
+  return `[Function ${val.name || "anonymous"}]`;
+}
+function printSymbol(val) {
+  return String(val).replace(SYMBOL_REGEXP, "Symbol($1)");
+}
+function printError(val) {
+  return `[${errorToString.call(val)}]`;
+}
+function printBasicValue(val, printFunctionName, escapeRegex, escapeString) {
+  if (val === true || val === false) {
+    return `${val}`;
+  }
+  if (val === void 0) {
+    return "undefined";
+  }
+  if (val === null) {
+    return "null";
+  }
+  const typeOf = typeof val;
+  if (typeOf === "number") {
+    return printNumber(val);
+  }
+  if (typeOf === "bigint") {
+    return printBigInt(val);
+  }
+  if (typeOf === "string") {
+    if (escapeString) {
+      return `"${val.replaceAll(/"|\\/g, "\\$&")}"`;
+    }
+    return `"${val}"`;
+  }
+  if (typeOf === "function") {
+    return printFunction(val, printFunctionName);
+  }
+  if (typeOf === "symbol") {
+    return printSymbol(val);
+  }
+  const toStringed = toString.call(val);
+  if (toStringed === "[object WeakMap]") {
+    return "WeakMap {}";
+  }
+  if (toStringed === "[object WeakSet]") {
+    return "WeakSet {}";
+  }
+  if (toStringed === "[object Function]" || toStringed === "[object GeneratorFunction]") {
+    return printFunction(val, printFunctionName);
+  }
+  if (toStringed === "[object Symbol]") {
+    return printSymbol(val);
+  }
+  if (toStringed === "[object Date]") {
+    return Number.isNaN(+val) ? "Date { NaN }" : toISOString.call(val);
+  }
+  if (toStringed === "[object Error]") {
+    return printError(val);
+  }
+  if (toStringed === "[object RegExp]") {
+    if (escapeRegex) {
+      return regExpToString.call(val).replaceAll(/[$()*+.?[\\\]^{|}]/g, "\\$&");
+    }
+    return regExpToString.call(val);
+  }
+  if (val instanceof Error) {
+    return printError(val);
+  }
+  return null;
+}
+function printComplexValue(val, config, indentation, depth, refs, hasCalledToJSON) {
+  if (refs.includes(val)) {
+    return "[Circular]";
+  }
+  refs = [...refs];
+  refs.push(val);
+  const hitMaxDepth = ++depth > config.maxDepth;
+  const min = config.min;
+  if (config.callToJSON && !hitMaxDepth && val.toJSON && typeof val.toJSON === "function" && !hasCalledToJSON) {
+    return printer(val.toJSON(), config, indentation, depth, refs, true);
+  }
+  const toStringed = toString.call(val);
+  if (toStringed === "[object Arguments]") {
+    return hitMaxDepth ? "[Arguments]" : `${min ? "" : "Arguments "}[${printListItems(val, config, indentation, depth, refs, printer)}]`;
+  }
+  if (isToStringedArrayType(toStringed)) {
+    return hitMaxDepth ? `[${val.constructor.name}]` : `${min ? "" : !config.printBasicPrototype && val.constructor.name === "Array" ? "" : `${val.constructor.name} `}[${printListItems(val, config, indentation, depth, refs, printer)}]`;
+  }
+  if (toStringed === "[object Map]") {
+    return hitMaxDepth ? "[Map]" : `Map {${printIteratorEntries(val.entries(), config, indentation, depth, refs, printer, " => ")}}`;
+  }
+  if (toStringed === "[object Set]") {
+    return hitMaxDepth ? "[Set]" : `Set {${printIteratorValues(val.values(), config, indentation, depth, refs, printer)}}`;
+  }
+  return hitMaxDepth || isWindow(val) ? `[${getConstructorName(val)}]` : `${min ? "" : !config.printBasicPrototype && getConstructorName(val) === "Object" ? "" : `${getConstructorName(val)} `}{${printObjectProperties(val, config, indentation, depth, refs, printer)}}`;
+}
+var ErrorPlugin = {
+  test: (val) => val && val instanceof Error,
+  serialize(val, config, indentation, depth, refs, printer2) {
+    if (refs.includes(val)) {
+      return "[Circular]";
+    }
+    refs = [...refs, val];
+    const hitMaxDepth = ++depth > config.maxDepth;
+    const { message, cause, ...rest } = val;
+    const entries = {
+      message,
+      ...typeof cause !== "undefined" ? { cause } : {},
+      ...val instanceof AggregateError ? { errors: val.errors } : {},
+      ...rest
+    };
+    const name = val.name !== "Error" ? val.name : getConstructorName(val);
+    return hitMaxDepth ? `[${name}]` : `${name} {${printIteratorEntries(Object.entries(entries).values(), config, indentation, depth, refs, printer2)}}`;
+  }
+};
+function isNewPlugin(plugin2) {
+  return plugin2.serialize != null;
+}
+function printPlugin(plugin2, val, config, indentation, depth, refs) {
+  let printed;
+  try {
+    printed = isNewPlugin(plugin2) ? plugin2.serialize(val, config, indentation, depth, refs, printer) : plugin2.print(val, (valChild) => printer(valChild, config, indentation, depth, refs), (str) => {
+      const indentationNext = indentation + config.indent;
+      return indentationNext + str.replaceAll(NEWLINE_REGEXP, `
+${indentationNext}`);
+    }, {
+      edgeSpacing: config.spacingOuter,
+      min: config.min,
+      spacing: config.spacingInner
+    }, config.colors);
+  } catch (error) {
+    throw new PrettyFormatPluginError(error.message, error.stack);
+  }
+  if (typeof printed !== "string") {
+    throw new TypeError(`pretty-format: Plugin must return type "string" but instead returned "${typeof printed}".`);
+  }
+  return printed;
+}
+function findPlugin(plugins2, val) {
+  for (const plugin2 of plugins2) {
+    try {
+      if (plugin2.test(val)) {
+        return plugin2;
+      }
+    } catch (error) {
+      throw new PrettyFormatPluginError(error.message, error.stack);
+    }
+  }
+  return null;
+}
+function printer(val, config, indentation, depth, refs, hasCalledToJSON) {
+  let result;
+  const plugin2 = findPlugin(config.plugins, val);
+  if (plugin2 !== null) {
+    result = printPlugin(plugin2, val, config, indentation, depth, refs);
+  } else {
+    const basicResult = printBasicValue(val, config.printFunctionName, config.escapeRegex, config.escapeString);
+    if (basicResult !== null) {
+      result = basicResult;
+    } else {
+      result = printComplexValue(val, config, indentation, depth, refs, hasCalledToJSON);
+    }
+  }
+  config._outputLengthPerDepth[depth] ??= 0;
+  config._outputLengthPerDepth[depth] += result.length;
+  if (config._outputLengthPerDepth[depth] > config.maxOutputLength) {
+    config.maxDepth = 0;
+  }
+  return result;
+}
+var DEFAULT_THEME = {
+  comment: "gray",
+  content: "reset",
+  prop: "yellow",
+  tag: "cyan",
+  value: "green"
+};
+var DEFAULT_THEME_KEYS = Object.keys(DEFAULT_THEME);
+var DEFAULT_OPTIONS = {
+  callToJSON: true,
+  compareKeys: void 0,
+  escapeRegex: false,
+  escapeString: true,
+  highlight: false,
+  indent: 2,
+  maxDepth: Number.POSITIVE_INFINITY,
+  maxOutputLength: 1e6,
+  maxWidth: Number.POSITIVE_INFINITY,
+  min: false,
+  plugins: [],
+  printBasicPrototype: true,
+  printFunctionName: true,
+  printShadowRoot: true,
+  theme: DEFAULT_THEME
+};
+function validateOptions(options) {
+  for (const key of Object.keys(options)) {
+    if (!Object.hasOwn(DEFAULT_OPTIONS, key)) {
+      throw new Error(`pretty-format: Unknown option "${key}".`);
+    }
+  }
+  if (options.min && options.indent !== void 0 && options.indent !== 0) {
+    throw new Error('pretty-format: Options "min" and "indent" cannot be used together.');
+  }
+}
+function getColorsHighlight() {
+  return DEFAULT_THEME_KEYS.reduce((colors, key) => {
+    const value = DEFAULT_THEME[key];
+    const color = value && y[value];
+    if (color && typeof color.close === "string" && typeof color.open === "string") {
+      colors[key] = color;
+    } else {
+      throw new Error(`pretty-format: Option "theme" has a key "${key}" whose value "${value}" is undefined in ansi-styles.`);
+    }
+    return colors;
+  }, /* @__PURE__ */ Object.create(null));
+}
+function getColorsEmpty() {
+  return DEFAULT_THEME_KEYS.reduce((colors, key) => {
+    colors[key] = {
+      close: "",
+      open: ""
+    };
+    return colors;
+  }, /* @__PURE__ */ Object.create(null));
+}
+function getPrintFunctionName(options) {
+  return options?.printFunctionName ?? DEFAULT_OPTIONS.printFunctionName;
+}
+function getEscapeRegex(options) {
+  return options?.escapeRegex ?? DEFAULT_OPTIONS.escapeRegex;
+}
+function getEscapeString(options) {
+  return options?.escapeString ?? DEFAULT_OPTIONS.escapeString;
+}
+function getConfig(options) {
+  return {
+    callToJSON: options?.callToJSON ?? DEFAULT_OPTIONS.callToJSON,
+    colors: options?.highlight ? getColorsHighlight() : getColorsEmpty(),
+    compareKeys: typeof options?.compareKeys === "function" || options?.compareKeys === null ? options.compareKeys : DEFAULT_OPTIONS.compareKeys,
+    escapeRegex: getEscapeRegex(options),
+    escapeString: getEscapeString(options),
+    indent: options?.min ? "" : createIndent(options?.indent ?? DEFAULT_OPTIONS.indent),
+    maxDepth: options?.maxDepth ?? DEFAULT_OPTIONS.maxDepth,
+    maxWidth: options?.maxWidth ?? DEFAULT_OPTIONS.maxWidth,
+    min: options?.min ?? DEFAULT_OPTIONS.min,
+    plugins: options?.plugins ?? DEFAULT_OPTIONS.plugins,
+    printBasicPrototype: options?.printBasicPrototype ?? true,
+    printFunctionName: getPrintFunctionName(options),
+    printShadowRoot: options?.printShadowRoot ?? true,
+    spacingInner: options?.min ? " " : "\n",
+    spacingOuter: options?.min ? "" : "\n",
+    maxOutputLength: options?.maxOutputLength ?? DEFAULT_OPTIONS.maxOutputLength,
+    _outputLengthPerDepth: []
+  };
+}
+function createIndent(indent) {
+  return Array.from({ length: indent + 1 }).join(" ");
+}
+function format(val, options) {
+  if (options) {
+    validateOptions(options);
+    if (options.plugins) {
+      const plugin2 = findPlugin(options.plugins, val);
+      if (plugin2 !== null) {
+        return printPlugin(plugin2, val, getConfig(options), "", 0, []);
+      }
+    }
+  }
+  const basicResult = printBasicValue(val, getPrintFunctionName(options), getEscapeRegex(options), getEscapeString(options));
+  if (basicResult !== null) {
+    return basicResult;
+  }
+  return printComplexValue(val, getConfig(options), "", 0, []);
+}
+var plugins = {
+  AsymmetricMatcher: plugin$5,
+  DOMCollection: plugin$4,
+  DOMElement: plugin$3,
+  Immutable: plugin$2,
+  ReactElement: plugin$1,
+  ReactTestComponent: plugin,
+  Error: ErrorPlugin
+};
+
+// node_modules/@vitest/utils/dist/display.js
+var ansiColors = {
+  bold: ["1", "22"],
+  dim: ["2", "22"],
+  italic: ["3", "23"],
+  underline: ["4", "24"],
+  // 5 & 6 are blinking
+  inverse: ["7", "27"],
+  hidden: ["8", "28"],
+  strike: ["9", "29"],
+  // 10-20 are fonts
+  // 21-29 are resets for 1-9
+  black: ["30", "39"],
+  red: ["31", "39"],
+  green: ["32", "39"],
+  yellow: ["33", "39"],
+  blue: ["34", "39"],
+  magenta: ["35", "39"],
+  cyan: ["36", "39"],
+  white: ["37", "39"],
+  brightblack: ["30;1", "39"],
+  brightred: ["31;1", "39"],
+  brightgreen: ["32;1", "39"],
+  brightyellow: ["33;1", "39"],
+  brightblue: ["34;1", "39"],
+  brightmagenta: ["35;1", "39"],
+  brightcyan: ["36;1", "39"],
+  brightwhite: ["37;1", "39"],
+  grey: ["90", "39"]
+};
+var styles = {
+  special: "cyan",
+  number: "yellow",
+  bigint: "yellow",
+  boolean: "yellow",
+  undefined: "grey",
+  null: "bold",
+  string: "green",
+  symbol: "green",
+  date: "magenta",
+  regexp: "red"
+};
+var truncator = "\u2026";
+function colorise(value, styleType) {
+  const color = ansiColors[styles[styleType]] || ansiColors[styleType] || "";
+  if (!color) {
+    return String(value);
+  }
+  return `\x1B[${color[0]}m${String(value)}\x1B[${color[1]}m`;
+}
+function normaliseOptions({
+  showHidden = false,
+  depth = 2,
+  colors = false,
+  customInspect = true,
+  showProxy = false,
+  maxArrayLength = Infinity,
+  breakLength = Infinity,
+  seen = [],
+  // eslint-disable-next-line no-shadow
+  truncate: truncate2 = Infinity,
+  stylize = String
+} = {}, inspect2) {
+  const options = {
+    showHidden: Boolean(showHidden),
+    depth: Number(depth),
+    colors: Boolean(colors),
+    customInspect: Boolean(customInspect),
+    showProxy: Boolean(showProxy),
+    maxArrayLength: Number(maxArrayLength),
+    breakLength: Number(breakLength),
+    truncate: Number(truncate2),
+    seen,
+    inspect: inspect2,
+    stylize
+  };
+  if (options.colors) {
+    options.stylize = colorise;
+  }
+  return options;
+}
+function isHighSurrogate(char) {
+  return char >= "\uD800" && char <= "\uDBFF";
+}
+function truncate(string, length, tail = truncator) {
+  string = String(string);
+  const tailLength = tail.length;
+  const stringLength = string.length;
+  if (tailLength > length && stringLength > tailLength) {
+    return tail;
+  }
+  if (stringLength > length && stringLength > tailLength) {
+    let end = length - tailLength;
+    if (end > 0 && isHighSurrogate(string[end - 1])) {
+      end = end - 1;
+    }
+    return `${string.slice(0, end)}${tail}`;
+  }
+  return string;
+}
+function inspectList(list, options, inspectItem, separator = ", ") {
+  inspectItem = inspectItem || options.inspect;
+  const size = list.length;
+  if (size === 0)
+    return "";
+  const originalLength = options.truncate;
+  let output = "";
+  let peek = "";
+  let truncated = "";
+  for (let i2 = 0; i2 < size; i2 += 1) {
+    const last = i2 + 1 === list.length;
+    const secondToLast = i2 + 2 === list.length;
+    truncated = `${truncator}(${list.length - i2})`;
+    const value = list[i2];
+    options.truncate = originalLength - output.length - (last ? 0 : separator.length);
+    const string = peek || inspectItem(value, options) + (last ? "" : separator);
+    const nextLength = output.length + string.length;
+    const truncatedLength = nextLength + truncated.length;
+    if (last && nextLength > originalLength && output.length + truncated.length <= originalLength) {
+      break;
+    }
+    if (!last && !secondToLast && truncatedLength > originalLength) {
+      break;
+    }
+    peek = last ? "" : inspectItem(list[i2 + 1], options) + (secondToLast ? "" : separator);
+    if (!last && secondToLast && truncatedLength > originalLength && nextLength + peek.length > originalLength) {
+      break;
+    }
+    output += string;
+    if (!last && !secondToLast && nextLength + peek.length >= originalLength) {
+      truncated = `${truncator}(${list.length - i2 - 1})`;
+      break;
+    }
+    truncated = "";
+  }
+  return `${output}${truncated}`;
+}
+function quoteComplexKey(key) {
+  if (key.match(/^[a-zA-Z_][a-zA-Z_0-9]*$/)) {
+    return key;
+  }
+  return JSON.stringify(key).replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
+}
+function inspectProperty([key, value], options) {
+  options.truncate -= 2;
+  if (typeof key === "string") {
+    key = quoteComplexKey(key);
+  } else if (typeof key !== "number") {
+    key = `[${options.inspect(key, options)}]`;
+  }
+  options.truncate -= key.length;
+  value = options.inspect(value, options);
+  return `${key}: ${value}`;
+}
+function inspectArray(array, options) {
+  const nonIndexProperties = Object.keys(array).slice(array.length);
+  if (!array.length && !nonIndexProperties.length)
+    return "[]";
+  options.truncate -= 4;
+  const listContents = inspectList(array, options);
+  options.truncate -= listContents.length;
+  let propertyContents = "";
+  if (nonIndexProperties.length) {
+    propertyContents = inspectList(nonIndexProperties.map((key) => [key, array[key]]), options, inspectProperty);
+  }
+  return `[ ${listContents}${propertyContents ? `, ${propertyContents}` : ""} ]`;
+}
+var getArrayName = (array) => {
+  if (typeof Buffer === "function" && array instanceof Buffer) {
+    return "Buffer";
+  }
+  if (array[Symbol.toStringTag]) {
+    return array[Symbol.toStringTag];
+  }
+  return array.constructor.name;
+};
+function inspectTypedArray(array, options) {
+  const name = getArrayName(array);
+  options.truncate -= name.length + 4;
+  const nonIndexProperties = Object.keys(array).slice(array.length);
+  if (!array.length && !nonIndexProperties.length)
+    return `${name}[]`;
+  let output = "";
+  for (let i2 = 0; i2 < array.length; i2++) {
+    const string = `${options.stylize(truncate(array[i2], options.truncate), "number")}${i2 === array.length - 1 ? "" : ", "}`;
+    options.truncate -= string.length;
+    if (array[i2] !== array.length && options.truncate <= 3) {
+      output += `${truncator}(${array.length - array[i2] + 1})`;
+      break;
+    }
+    output += string;
+  }
+  let propertyContents = "";
+  if (nonIndexProperties.length) {
+    propertyContents = inspectList(nonIndexProperties.map((key) => [key, array[key]]), options, inspectProperty);
+  }
+  return `${name}[ ${output}${propertyContents ? `, ${propertyContents}` : ""} ]`;
+}
+function inspectDate(dateObject, options) {
+  const stringRepresentation = dateObject.toJSON();
+  if (stringRepresentation === null) {
+    return "Invalid Date";
+  }
+  const split = stringRepresentation.split("T");
+  const date = split[0];
+  return options.stylize(`${date}T${truncate(split[1], options.truncate - date.length - 1)}`, "date");
+}
+function inspectFunction(func, options) {
+  const functionType = func[Symbol.toStringTag] || "Function";
+  const name = func.name;
+  if (!name) {
+    return options.stylize(`[${functionType}]`, "special");
+  }
+  return options.stylize(`[${functionType} ${truncate(name, options.truncate - 11)}]`, "special");
+}
+function inspectMapEntry([key, value], options) {
+  options.truncate -= 4;
+  key = options.inspect(key, options);
+  options.truncate -= key.length;
+  value = options.inspect(value, options);
+  return `${key} => ${value}`;
+}
+function mapToEntries(map) {
+  const entries = [];
+  map.forEach((value, key) => {
+    entries.push([key, value]);
+  });
+  return entries;
+}
+function inspectMap(map, options) {
+  if (map.size === 0)
+    return "Map{}";
+  options.truncate -= 7;
+  return `Map{ ${inspectList(mapToEntries(map), options, inspectMapEntry)} }`;
+}
+var isNaN = Number.isNaN || ((i2) => i2 !== i2);
+function inspectNumber(number, options) {
+  if (isNaN(number)) {
+    return options.stylize("NaN", "number");
+  }
+  if (number === Infinity) {
+    return options.stylize("Infinity", "number");
+  }
+  if (number === -Infinity) {
+    return options.stylize("-Infinity", "number");
+  }
+  if (number === 0) {
+    return options.stylize(1 / number === Infinity ? "+0" : "-0", "number");
+  }
+  return options.stylize(truncate(String(number), options.truncate), "number");
+}
+function inspectBigInt(number, options) {
+  let nums = truncate(number.toString(), options.truncate - 1);
+  if (nums !== truncator)
+    nums += "n";
+  return options.stylize(nums, "bigint");
+}
+function inspectRegExp(value, options) {
+  const flags = value.toString().split("/")[2];
+  const sourceLength = options.truncate - (2 + flags.length);
+  const source = value.source;
+  return options.stylize(`/${truncate(source, sourceLength)}/${flags}`, "regexp");
+}
+function arrayFromSet(set) {
+  const values = [];
+  set.forEach((value) => {
+    values.push(value);
+  });
+  return values;
+}
+function inspectSet(set, options) {
+  if (set.size === 0)
+    return "Set{}";
+  options.truncate -= 7;
+  return `Set{ ${inspectList(arrayFromSet(set), options)} }`;
+}
+var stringEscapeChars = new RegExp("['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]", "g");
+var escapeCharacters = {
+  "\b": "\\b",
+  "	": "\\t",
+  "\n": "\\n",
+  "\f": "\\f",
+  "\r": "\\r",
+  "'": "\\'",
+  "\\": "\\\\"
+};
+var hex = 16;
+function escape(char) {
+  return escapeCharacters[char] || `\\u${`0000${char.charCodeAt(0).toString(hex)}`.slice(-4)}`;
+}
+function inspectString(string, options) {
+  if (stringEscapeChars.test(string)) {
+    string = string.replace(stringEscapeChars, escape);
+  }
+  return options.stylize(`'${truncate(string, options.truncate - 2)}'`, "string");
+}
+function inspectSymbol(value) {
+  if ("description" in Symbol.prototype) {
+    return value.description ? `Symbol(${value.description})` : "Symbol()";
+  }
+  return value.toString();
+}
+var getPromiseValue = () => "Promise{\u2026}";
+function inspectObject$1(object, options) {
+  const properties = Object.getOwnPropertyNames(object);
+  const symbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : [];
+  if (properties.length === 0 && symbols.length === 0) {
+    return "{}";
+  }
+  options.truncate -= 4;
+  options.seen = options.seen || [];
+  if (options.seen.includes(object)) {
+    return "[Circular]";
+  }
+  options.seen.push(object);
+  const propertyContents = inspectList(properties.map((key) => [key, object[key]]), options, inspectProperty);
+  const symbolContents = inspectList(symbols.map((key) => [key, object[key]]), options, inspectProperty);
+  options.seen.pop();
+  let sep = "";
+  if (propertyContents && symbolContents) {
+    sep = ", ";
+  }
+  return `{ ${propertyContents}${sep}${symbolContents} }`;
+}
+var toStringTag = typeof Symbol !== "undefined" && Symbol.toStringTag ? Symbol.toStringTag : false;
+function inspectClass(value, options) {
+  let name = "";
+  if (toStringTag && toStringTag in value) {
+    name = value[toStringTag];
+  }
+  name = name || value.constructor.name;
+  if (!name || name === "_class") {
+    name = "<Anonymous Class>";
+  }
+  options.truncate -= name.length;
+  return `${name}${inspectObject$1(value, options)}`;
+}
+function inspectArguments(args, options) {
+  if (args.length === 0)
+    return "Arguments[]";
+  options.truncate -= 13;
+  return `Arguments[ ${inspectList(args, options)} ]`;
+}
+var errorKeys = [
+  "stack",
+  "line",
+  "column",
+  "name",
+  "message",
+  "fileName",
+  "lineNumber",
+  "columnNumber",
+  "number",
+  "description",
+  "cause"
+];
+function inspectObject(error, options) {
+  const properties = Object.getOwnPropertyNames(error).filter((key) => errorKeys.indexOf(key) === -1);
+  const name = error.name;
+  options.truncate -= name.length;
+  let message = "";
+  if (typeof error.message === "string") {
+    message = truncate(error.message, options.truncate);
+  } else {
+    properties.unshift("message");
+  }
+  message = message ? `: ${message}` : "";
+  options.truncate -= message.length + 5;
+  options.seen = options.seen || [];
+  if (options.seen.includes(error)) {
+    return "[Circular]";
+  }
+  options.seen.push(error);
+  const propertyContents = inspectList(properties.map((key) => [key, error[key]]), options, inspectProperty);
+  return `${name}${message}${propertyContents ? ` { ${propertyContents} }` : ""}`;
+}
+function inspectAttribute([key, value], options) {
+  options.truncate -= 3;
+  if (!value) {
+    return `${options.stylize(String(key), "yellow")}`;
+  }
+  return `${options.stylize(String(key), "yellow")}=${options.stylize(`"${value}"`, "string")}`;
+}
+function inspectNodeCollection(collection, options) {
+  return inspectList(collection, options, inspectNode, "\n");
+}
+function inspectNode(node, options) {
+  switch (node.nodeType) {
+    case 1:
+      return inspectHTML(node, options);
+    case 3:
+      return options.inspect(node.data, options);
+    default:
+      return options.inspect(node, options);
+  }
+}
+function inspectHTML(element, options) {
+  const properties = element.getAttributeNames();
+  const name = element.tagName.toLowerCase();
+  const head = options.stylize(`<${name}`, "special");
+  const headClose = options.stylize(`>`, "special");
+  const tail = options.stylize(`</${name}>`, "special");
+  options.truncate -= name.length * 2 + 5;
+  let propertyContents = "";
+  if (properties.length > 0) {
+    propertyContents += " ";
+    propertyContents += inspectList(properties.map((key) => [key, element.getAttribute(key)]), options, inspectAttribute, " ");
+  }
+  options.truncate -= propertyContents.length;
+  const truncate2 = options.truncate;
+  let children = inspectNodeCollection(element.children, options);
+  if (children && children.length > truncate2) {
+    children = `${truncator}(${element.children.length})`;
+  }
+  return `${head}${propertyContents}${headClose}${children}${tail}`;
+}
+var symbolsSupported = typeof Symbol === "function" && typeof Symbol.for === "function";
+var chaiInspect = symbolsSupported ? /* @__PURE__ */ Symbol.for("chai/inspect") : "@@chai/inspect";
+var nodeInspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var constructorMap = /* @__PURE__ */ new WeakMap();
+var stringTagMap = {};
+var baseTypesMap = {
+  undefined: (value, options) => options.stylize("undefined", "undefined"),
+  null: (value, options) => options.stylize("null", "null"),
+  boolean: (value, options) => options.stylize(String(value), "boolean"),
+  Boolean: (value, options) => options.stylize(String(value), "boolean"),
+  number: inspectNumber,
+  Number: inspectNumber,
+  bigint: inspectBigInt,
+  BigInt: inspectBigInt,
+  string: inspectString,
+  String: inspectString,
+  function: inspectFunction,
+  Function: inspectFunction,
+  symbol: inspectSymbol,
+  // A Symbol polyfill will return `Symbol` not `symbol` from typedetect
+  Symbol: inspectSymbol,
+  Array: inspectArray,
+  Date: inspectDate,
+  Map: inspectMap,
+  Set: inspectSet,
+  RegExp: inspectRegExp,
+  Promise: getPromiseValue,
+  // WeakSet, WeakMap are totally opaque to us
+  WeakSet: (value, options) => options.stylize("WeakSet{\u2026}", "special"),
+  WeakMap: (value, options) => options.stylize("WeakMap{\u2026}", "special"),
+  Arguments: inspectArguments,
+  Int8Array: inspectTypedArray,
+  Uint8Array: inspectTypedArray,
+  Uint8ClampedArray: inspectTypedArray,
+  Int16Array: inspectTypedArray,
+  Uint16Array: inspectTypedArray,
+  Int32Array: inspectTypedArray,
+  Uint32Array: inspectTypedArray,
+  Float32Array: inspectTypedArray,
+  Float64Array: inspectTypedArray,
+  Generator: () => "",
+  DataView: () => "",
+  ArrayBuffer: () => "",
+  Error: inspectObject,
+  HTMLCollection: inspectNodeCollection,
+  NodeList: inspectNodeCollection
+};
+var inspectCustom = (value, options, type, inspectFn) => {
+  if (chaiInspect in value && typeof value[chaiInspect] === "function") {
+    return value[chaiInspect](options);
+  }
+  if (nodeInspect in value && typeof value[nodeInspect] === "function") {
+    return value[nodeInspect](options.depth, options, inspectFn);
+  }
+  if ("inspect" in value && typeof value.inspect === "function") {
+    return value.inspect(options.depth, options);
+  }
+  if ("constructor" in value && constructorMap.has(value.constructor)) {
+    return constructorMap.get(value.constructor)(value, options);
+  }
+  if (stringTagMap[type]) {
+    return stringTagMap[type](value, options);
+  }
+  return "";
+};
+var toString2 = Object.prototype.toString;
+function inspect$1(value, opts = {}) {
+  const options = normaliseOptions(opts, inspect$1);
+  const { customInspect } = options;
+  let type = value === null ? "null" : typeof value;
+  if (type === "object") {
+    type = toString2.call(value).slice(8, -1);
+  }
+  if (type in baseTypesMap) {
+    return baseTypesMap[type](value, options);
+  }
+  if (customInspect && value) {
+    const output = inspectCustom(value, options, type, inspect$1);
+    if (output) {
+      if (typeof output === "string")
+        return output;
+      return inspect$1(output, options);
+    }
+  }
+  const proto = value ? Object.getPrototypeOf(value) : false;
+  if (proto === Object.prototype || proto === null) {
+    return inspectObject$1(value, options);
+  }
+  if (value && typeof HTMLElement === "function" && value instanceof HTMLElement) {
+    return inspectHTML(value, options);
+  }
+  if ("constructor" in value) {
+    if (value.constructor !== Object) {
+      return inspectClass(value, options);
+    }
+    return inspectObject$1(value, options);
+  }
+  if (value === Object(value)) {
+    return inspectObject$1(value, options);
+  }
+  return options.stylize(String(value), type);
+}
+var { AsymmetricMatcher, DOMCollection, DOMElement, Immutable, ReactElement, ReactTestComponent } = plugins;
+var PLUGINS = [
+  ReactTestComponent,
+  ReactElement,
+  DOMElement,
+  DOMCollection,
+  Immutable,
+  AsymmetricMatcher
+];
+function stringify(object, maxDepth = 10, { maxLength, filterNode, ...options } = {}) {
+  const MAX_LENGTH = maxLength ?? 1e4;
+  let result;
+  const filterFn = typeof filterNode === "string" ? createNodeFilterFromSelector(filterNode) : filterNode;
+  const plugins2 = filterFn ? [
+    ReactTestComponent,
+    ReactElement,
+    createDOMElementFilter(filterFn),
+    DOMCollection,
+    Immutable,
+    AsymmetricMatcher
+  ] : PLUGINS;
+  try {
+    result = format(object, {
+      maxDepth,
+      escapeString: false,
+      plugins: plugins2,
+      ...options
+    });
+  } catch {
+    result = format(object, {
+      callToJSON: false,
+      maxDepth,
+      escapeString: false,
+      plugins: plugins2,
+      ...options
+    });
+  }
+  return result.length >= MAX_LENGTH && maxDepth > 1 ? stringify(object, Math.floor(Math.min(maxDepth, Number.MAX_SAFE_INTEGER) / 2), {
+    maxLength,
+    filterNode,
+    ...options
+  }) : result;
+}
+function createNodeFilterFromSelector(selector) {
+  const ELEMENT_NODE2 = 1;
+  const COMMENT_NODE2 = 8;
+  return (node) => {
+    if (node.nodeType === COMMENT_NODE2) {
+      return false;
+    }
+    if (node.nodeType === ELEMENT_NODE2 && node.matches) {
+      try {
+        return !node.matches(selector);
+      } catch {
+        return true;
+      }
+    }
+    return true;
+  };
+}
+var formatRegExp = /%[sdjifoOc%]/g;
+function baseFormat(args, options = {}) {
+  const formatArg = (item, inspecOptions) => {
+    if (options.prettifyObject) {
+      return stringify(item, void 0, {
+        printBasicPrototype: false,
+        escapeString: false
+      });
+    }
+    return inspect(item, inspecOptions);
+  };
+  if (typeof args[0] !== "string") {
+    const objects = [];
+    for (let i3 = 0; i3 < args.length; i3++) {
+      objects.push(formatArg(args[i3], {
+        depth: 0,
+        colors: false
+      }));
+    }
+    return objects.join(" ");
+  }
+  const len = args.length;
+  let i2 = 1;
+  const template = args[0];
+  let str = String(template).replace(formatRegExp, (x) => {
+    if (x === "%%") {
+      return "%";
+    }
+    if (i2 >= len) {
+      return x;
+    }
+    switch (x) {
+      case "%s": {
+        const value = args[i2++];
+        if (typeof value === "bigint") {
+          return `${value.toString()}n`;
+        }
+        if (typeof value === "number" && value === 0 && 1 / value < 0) {
+          return "-0";
+        }
+        if (typeof value === "object" && value !== null) {
+          if (typeof value.toString === "function" && value.toString !== Object.prototype.toString) {
+            return value.toString();
+          }
+          return formatArg(value, {
+            depth: 0,
+            colors: false
+          });
+        }
+        return String(value);
+      }
+      case "%d": {
+        const value = args[i2++];
+        if (typeof value === "bigint") {
+          return `${value.toString()}n`;
+        }
+        if (typeof value === "symbol") {
+          return "NaN";
+        }
+        return Number(value).toString();
+      }
+      case "%i": {
+        const value = args[i2++];
+        if (typeof value === "bigint") {
+          return `${value.toString()}n`;
+        }
+        return Number.parseInt(String(value)).toString();
+      }
+      case "%f":
+        return Number.parseFloat(String(args[i2++])).toString();
+      case "%o":
+        return formatArg(args[i2++], {
+          showHidden: true,
+          showProxy: true
+        });
+      case "%O":
+        return formatArg(args[i2++]);
+      case "%c": {
+        i2++;
+        return "";
+      }
+      case "%j":
+        try {
+          return JSON.stringify(args[i2++]);
+        } catch (err) {
+          const m = err.message;
+          if (m.includes("circular structure") || m.includes("cyclic structures") || m.includes("cyclic object")) {
+            return "[Circular]";
+          }
+          throw err;
+        }
+      default:
+        return x;
+    }
+  });
+  for (let x = args[i2]; i2 < len; x = args[++i2]) {
+    if (x === null || typeof x !== "object") {
+      str += ` ${typeof x === "symbol" ? x.toString() : x}`;
+    } else {
+      str += ` ${formatArg(x)}`;
+    }
+  }
+  return str;
+}
+function format2(...args) {
+  return baseFormat(args);
+}
+function inspect(obj, options = {}) {
+  if (options.truncate === 0) {
+    options.truncate = Number.POSITIVE_INFINITY;
+  }
+  return inspect$1(obj, options);
+}
+function objDisplay(obj, options = {}) {
+  if (typeof options.truncate === "undefined") {
+    options.truncate = 40;
+  }
+  const str = inspect(obj, options);
+  const type = Object.prototype.toString.call(obj);
+  if (options.truncate && str.length >= options.truncate) {
+    if (type === "[object Function]") {
+      const fn = obj;
+      return !fn.name ? "[Function]" : `[Function: ${fn.name}]`;
+    } else if (type === "[object Array]") {
+      return `[ Array(${obj.length}) ]`;
+    } else if (type === "[object Object]") {
+      const keys = Object.keys(obj);
+      const kstr = keys.length > 2 ? `${keys.splice(0, 2).join(", ")}, ...` : keys.join(", ");
+      return `{ Object (${kstr}) }`;
+    } else {
+      return str;
+    }
+  }
+  return str;
+}
+
+// node_modules/@vitest/utils/dist/helpers.js
+function assertTypes(value, name, types) {
+  const receivedType = typeof value;
+  const pass = types.includes(receivedType);
+  if (!pass) {
+    throw new TypeError(`${name} value must be ${types.join(" or ")}, received "${receivedType}"`);
+  }
+}
+function filterOutComments(s) {
+  const result = [];
+  let commentState = "none";
+  for (let i2 = 0; i2 < s.length; ++i2) {
+    if (commentState === "singleline") {
+      if (s[i2] === "\n") {
+        commentState = "none";
+      }
+    } else if (commentState === "multiline") {
+      if (s[i2 - 1] === "*" && s[i2] === "/") {
+        commentState = "none";
+      }
+    } else if (commentState === "none") {
+      if (s[i2] === "/" && s[i2 + 1] === "/") {
+        commentState = "singleline";
+      } else if (s[i2] === "/" && s[i2 + 1] === "*") {
+        commentState = "multiline";
+        i2 += 2;
+      } else {
+        result.push(s[i2]);
+      }
+    }
+  }
+  return result.join("");
+}
+function toArray(array) {
+  if (array === null || array === void 0) {
+    array = [];
+  }
+  if (Array.isArray(array)) {
+    return array;
+  }
+  return [array];
+}
+function isObject(item) {
+  return item != null && typeof item === "object" && !Array.isArray(item);
+}
+function objectAttr(source, path, defaultValue = void 0) {
+  const paths = path.replace(/\[(\d+)\]/g, ".$1").split(".");
+  let result = source;
+  for (const p of paths) {
+    result = new Object(result)[p];
+    if (result === void 0) {
+      return defaultValue;
+    }
+  }
+  return result;
+}
+function createDefer() {
+  let resolve2 = null;
+  let reject = null;
+  const p = new Promise((_resolve, _reject) => {
+    resolve2 = _resolve;
+    reject = _reject;
+  });
+  p.resolve = resolve2;
+  p.reject = reject;
+  return p;
+}
+function isNegativeNaN(val) {
+  if (!Number.isNaN(val)) {
+    return false;
+  }
+  const f64 = new Float64Array(1);
+  f64[0] = val;
+  const u32 = new Uint32Array(f64.buffer);
+  const isNegative = u32[1] >>> 31 === 1;
+  return isNegative;
+}
+function ordinal(i2) {
+  const j = i2 % 10;
+  const k = i2 % 100;
+  if (j === 1 && k !== 11) {
+    return `${i2}st`;
+  }
+  if (j === 2 && k !== 12) {
+    return `${i2}nd`;
+  }
+  if (j === 3 && k !== 13) {
+    return `${i2}rd`;
+  }
+  return `${i2}th`;
+}
+function unique(array) {
+  return Array.from(new Set(array));
+}
+
+// node_modules/@vitest/utils/dist/timers.js
+var SAFE_TIMERS_SYMBOL = /* @__PURE__ */ Symbol("vitest:SAFE_TIMERS");
+function getSafeTimers() {
+  const { setTimeout: safeSetTimeout, setInterval: safeSetInterval, clearInterval: safeClearInterval, clearTimeout: safeClearTimeout, setImmediate: safeSetImmediate, clearImmediate: safeClearImmediate, queueMicrotask: safeQueueMicrotask } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis;
+  const { nextTick: safeNextTick } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis.process || {};
+  return {
+    nextTick: safeNextTick,
+    setTimeout: safeSetTimeout,
+    setInterval: safeSetInterval,
+    clearInterval: safeClearInterval,
+    clearTimeout: safeClearTimeout,
+    setImmediate: safeSetImmediate,
+    clearImmediate: safeClearImmediate,
+    queueMicrotask: safeQueueMicrotask
+  };
+}
+
+// node_modules/@vitest/utils/dist/chunk-pathe.M-eThtNZ.js
+var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+function cwd() {
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+}
+var resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index2 = arguments_.length - 1; index2 >= -1 && !resolvedAbsolute; index2--) {
+    const path = index2 >= 0 ? arguments_[index2] : cwd();
+    if (!path || path.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index2 = 0; index2 <= path.length; ++index2) {
+    if (index2 < path.length) {
+      char = path[index2];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index2 - 1 || dots === 1) ;
+      else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index2;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index2;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index2)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index2);
+        }
+        lastSegmentLength = index2 - lastSlash - 1;
+      }
+      lastSlash = index2;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+var isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+
+// node_modules/@vitest/utils/dist/source-map.js
+var comma = ",".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i2 = 0; i2 < chars.length; i2++) {
+  const c = chars.charCodeAt(i2);
+  intToChar[i2] = c;
+  charToInt[c] = i2;
+}
+var CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m;
+var SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
+var NOW_LENGTH = Date.now().toString().length;
+var REGEXP_VITEST = new RegExp(`vitest=\\d{${NOW_LENGTH}}`);
+function extractLocation(urlLike) {
+  if (!urlLike.includes(":")) {
+    return [urlLike];
+  }
+  const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
+  const parts = regExp.exec(urlLike.replace(/^\(|\)$/g, ""));
+  if (!parts) {
+    return [urlLike];
+  }
+  let url = parts[1];
+  if (url.startsWith("async ")) {
+    url = url.slice(6);
+  }
+  if (url.startsWith("http:") || url.startsWith("https:")) {
+    const urlObj = new URL(url);
+    urlObj.searchParams.delete("import");
+    urlObj.searchParams.delete("browserv");
+    url = urlObj.pathname + urlObj.hash + urlObj.search;
+  }
+  if (url.startsWith("/@fs/")) {
+    const isWindows2 = /^\/@fs\/[a-zA-Z]:\//.test(url);
+    url = url.slice(isWindows2 ? 5 : 4);
+  }
+  if (url.includes("vitest=")) {
+    url = url.replace(REGEXP_VITEST, "").replace(/[?&]$/, "");
+  }
+  return [
+    url,
+    parts[2] || void 0,
+    parts[3] || void 0
+  ];
+}
+function parseSingleFFOrSafariStack(raw) {
+  let line = raw.trim();
+  if (SAFARI_NATIVE_CODE_REGEXP.test(line)) {
+    return null;
+  }
+  if (line.includes(" > eval")) {
+    line = line.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1");
+  }
+  if (!line.includes("@")) {
+    return null;
+  }
+  let atIndex = -1;
+  let locationPart = "";
+  let functionName;
+  for (let i2 = 0; i2 < line.length; i2++) {
+    if (line[i2] === "@") {
+      const candidateLocation = line.slice(i2 + 1);
+      if (candidateLocation.includes(":") && candidateLocation.length >= 3) {
+        atIndex = i2;
+        locationPart = candidateLocation;
+        functionName = i2 > 0 ? line.slice(0, i2) : void 0;
+        break;
+      }
+    }
+  }
+  if (atIndex === -1 || !locationPart.includes(":") || locationPart.length < 3) {
+    return null;
+  }
+  const [url, lineNumber, columnNumber] = extractLocation(locationPart);
+  if (!url || !lineNumber || !columnNumber) {
+    return null;
+  }
+  return {
+    file: url,
+    method: functionName || "",
+    line: Number.parseInt(lineNumber),
+    column: Number.parseInt(columnNumber)
+  };
+}
+function parseSingleStack(raw) {
+  const line = raw.trim();
+  if (!CHROME_IE_STACK_REGEXP.test(line)) {
+    return parseSingleFFOrSafariStack(line);
+  }
+  return parseSingleV8Stack(line);
+}
+function parseSingleV8Stack(raw) {
+  let line = raw.trim();
+  if (!CHROME_IE_STACK_REGEXP.test(line)) {
+    return null;
+  }
+  if (line.includes("(eval ")) {
+    line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
+  }
+  let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
+  const location = sanitizedLine.match(/ (\(.+\)$)/);
+  sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
+  const [url, lineNumber, columnNumber] = extractLocation(location ? location[1] : sanitizedLine);
+  let method = location && sanitizedLine || "";
+  let file = url && ["eval", "<anonymous>"].includes(url) ? void 0 : url;
+  if (!file || !lineNumber || !columnNumber) {
+    return null;
+  }
+  if (method.startsWith("async ")) {
+    method = method.slice(6);
+  }
+  if (file.startsWith("file://")) {
+    file = file.slice(7);
+  }
+  file = file.startsWith("node:") || file.startsWith("internal:") ? file : resolve(file);
+  if (method) {
+    method = method.replace(/\(0\s?,\s?__vite_ssr_import_\d+__.(\w+)\)/g, "$1").replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "").replace(/(Object\.)?__vite_ssr_export_default__\s?/g, "");
+  }
+  return {
+    method,
+    file,
+    line: Number.parseInt(lineNumber),
+    column: Number.parseInt(columnNumber)
+  };
+}
+
+// node_modules/@vitest/runner/dist/chunk-artifact.js
+var PendingError = class extends Error {
+  code = "VITEST_PENDING";
+  taskId;
+  constructor(message, task, note) {
+    super(message);
+    this.message = message;
+    this.note = note;
+    this.taskId = task.id;
+  }
+};
+var FixtureDependencyError = class extends Error {
+  name = "FixtureDependencyError";
+};
+var FixtureAccessError = class extends Error {
+  name = "FixtureAccessError";
+};
+var FixtureParseError = class extends Error {
+  name = "FixtureParseError";
+};
+var fnMap = /* @__PURE__ */ new WeakMap();
+var testFixtureMap = /* @__PURE__ */ new WeakMap();
+var hooksMap = /* @__PURE__ */ new WeakMap();
+function setFn(key, fn) {
+  fnMap.set(key, fn);
+}
+function setTestFixture(key, fixture) {
+  testFixtureMap.set(key, fixture);
+}
+function getTestFixtures(key) {
+  return testFixtureMap.get(key);
+}
+function setHooks(key, hooks) {
+  hooksMap.set(key, hooks);
+}
+function getHooks(key) {
+  return hooksMap.get(key);
+}
+var FIXTURE_STACK_TRACE_KEY = /* @__PURE__ */ Symbol.for("VITEST_FIXTURE_STACK_TRACE");
+var TestFixtures = class _TestFixtures {
+  _suiteContexts;
+  _overrides = /* @__PURE__ */ new WeakMap();
+  _registrations;
+  static _definitions = [];
+  static _builtinFixtures = [
+    "task",
+    "signal",
+    "onTestFailed",
+    "onTestFinished",
+    "skip",
+    "annotate"
+  ];
+  static _fixtureOptionKeys = [
+    "auto",
+    "injected",
+    "scope"
+  ];
+  static _fixtureScopes = [
+    "test",
+    "file",
+    "worker"
+  ];
+  static _workerContextSuite = { type: "worker" };
+  static clearDefinitions() {
+    _TestFixtures._definitions.length = 0;
+  }
+  static getWorkerContexts() {
+    return _TestFixtures._definitions.map((f) => f.getWorkerContext());
+  }
+  static getFileContexts(file) {
+    return _TestFixtures._definitions.map((f) => f.getFileContext(file));
+  }
+  static isFixtureOptions(obj) {
+    return isObject(obj) && Object.keys(obj).some((key) => _TestFixtures._fixtureOptionKeys.includes(key));
+  }
+  constructor(registrations) {
+    this._registrations = registrations ?? /* @__PURE__ */ new Map();
+    this._suiteContexts = /* @__PURE__ */ new WeakMap();
+    _TestFixtures._definitions.push(this);
+  }
+  extend(runner2, userFixtures) {
+    const { suite: suite2 } = getCurrentSuite();
+    const isTopLevel = !suite2 || suite2.file === suite2;
+    const registrations = this.parseUserFixtures(runner2, userFixtures, isTopLevel);
+    return new _TestFixtures(registrations);
+  }
+  get(suite2) {
+    let currentSuite = suite2;
+    while (currentSuite) {
+      const overrides = this._overrides.get(currentSuite);
+      if (overrides) {
+        return overrides;
+      }
+      if (currentSuite === currentSuite.file) {
+        break;
+      }
+      currentSuite = currentSuite.suite || currentSuite.file;
+    }
+    return this._registrations;
+  }
+  override(runner2, userFixtures) {
+    const { suite: currentSuite, file } = getCurrentSuite();
+    const suite2 = currentSuite || file;
+    const isTopLevel = !currentSuite || currentSuite.file === currentSuite;
+    const suiteRegistrations = new Map(this.get(suite2));
+    const registrations = this.parseUserFixtures(runner2, userFixtures, isTopLevel, suiteRegistrations);
+    if (isTopLevel) {
+      this._registrations = registrations;
+    } else {
+      this._overrides.set(suite2, registrations);
+    }
+  }
+  getFileContext(file) {
+    if (!this._suiteContexts.has(file)) {
+      this._suiteContexts.set(file, /* @__PURE__ */ Object.create(null));
+    }
+    return this._suiteContexts.get(file);
+  }
+  getWorkerContext() {
+    if (!this._suiteContexts.has(_TestFixtures._workerContextSuite)) {
+      this._suiteContexts.set(_TestFixtures._workerContextSuite, /* @__PURE__ */ Object.create(null));
+    }
+    return this._suiteContexts.get(_TestFixtures._workerContextSuite);
+  }
+  parseUserFixtures(runner2, userFixtures, supportNonTest, registrations = new Map(this._registrations)) {
+    const errors = [];
+    Object.entries(userFixtures).forEach(([name, fn]) => {
+      let options;
+      let value;
+      let _options;
+      if (Array.isArray(fn) && fn.length >= 2 && _TestFixtures.isFixtureOptions(fn[1])) {
+        _options = fn[1];
+        options = {
+          auto: _options.auto ?? false,
+          scope: _options.scope ?? "test",
+          injected: _options.injected ?? false
+        };
+        value = options.injected ? runner2.injectValue?.(name) ?? fn[0] : fn[0];
+      } else {
+        value = fn;
+      }
+      const parent = registrations.get(name);
+      if (parent && options) {
+        if (parent.scope !== options.scope) {
+          errors.push(new FixtureDependencyError(`The "${name}" fixture was already registered with a "${options.scope}" scope.`));
+        }
+        if (parent.auto !== options.auto) {
+          errors.push(new FixtureDependencyError(`The "${name}" fixture was already registered as { auto: ${options.auto} }.`));
+        }
+      } else if (parent) {
+        options = {
+          auto: parent.auto,
+          scope: parent.scope,
+          injected: parent.injected
+        };
+      } else if (!options) {
+        options = {
+          auto: false,
+          injected: false,
+          scope: "test"
+        };
+      }
+      if (options.scope && !_TestFixtures._fixtureScopes.includes(options.scope)) {
+        errors.push(new FixtureDependencyError(`The "${name}" fixture has unknown scope "${options.scope}".`));
+      }
+      if (!supportNonTest && options.scope !== "test") {
+        errors.push(new FixtureDependencyError(`The "${name}" fixture cannot be defined with a ${options.scope} scope${!_options?.scope && parent?.scope ? " (inherited from the base fixture)" : ""} inside the describe block. Define it at the top level of the file instead.`));
+      }
+      const deps = isFixtureFunction(value) ? getUsedProps(value) : /* @__PURE__ */ new Set();
+      const item = {
+        name,
+        value,
+        auto: options.auto ?? false,
+        injected: options.injected ?? false,
+        scope: options.scope ?? "test",
+        deps,
+        parent
+      };
+      if (isFixtureFunction(value)) {
+        Object.assign(value, { [FIXTURE_STACK_TRACE_KEY]: new Error("STACK_TRACE_ERROR") });
+      }
+      registrations.set(name, item);
+      if (item.scope === "worker" && (runner2.pool === "vmThreads" || runner2.pool === "vmForks")) {
+        item.scope = "file";
+      }
+    });
+    for (const fixture of registrations.values()) {
+      for (const depName of fixture.deps) {
+        if (_TestFixtures._builtinFixtures.includes(depName)) {
+          continue;
+        }
+        const dep = registrations.get(depName);
+        if (!dep) {
+          errors.push(new FixtureDependencyError(`The "${fixture.name}" fixture depends on unknown fixture "${depName}".`));
+          continue;
+        }
+        if (depName === fixture.name && !fixture.parent) {
+          errors.push(new FixtureDependencyError(`The "${fixture.name}" fixture depends on itself, but does not have a base implementation.`));
+          continue;
+        }
+        if (_TestFixtures._fixtureScopes.indexOf(fixture.scope) > _TestFixtures._fixtureScopes.indexOf(dep.scope)) {
+          errors.push(new FixtureDependencyError(`The ${fixture.scope} "${fixture.name}" fixture cannot depend on a ${dep.scope} fixture "${dep.name}".`));
+          continue;
+        }
+      }
+    }
+    if (errors.length === 1) {
+      throw errors[0];
+    } else if (errors.length > 1) {
+      throw new AggregateError(errors, "Cannot resolve user fixtures. See errors for more information.");
+    }
+    return registrations;
+  }
+};
+var cleanupFnArrayMap = /* @__PURE__ */ new WeakMap();
+var contextHasFixturesCache = /* @__PURE__ */ new WeakMap();
+function withFixtures(fn, options) {
+  const collector = getCurrentSuite();
+  const suite2 = options?.suite || collector.suite || collector.file;
+  return async (hookContext) => {
+    const context = hookContext || options?.context;
+    if (!context) {
+      if (options?.suiteHook) {
+        validateSuiteHook(fn, options.suiteHook, options.stackTraceError);
+      }
+      return fn({});
+    }
+    const fixtures = options?.fixtures || getTestFixtures(context);
+    if (!fixtures) {
+      return fn(context);
+    }
+    const registrations = fixtures.get(suite2);
+    if (!registrations.size) {
+      return fn(context);
+    }
+    const usedFixtures = [];
+    const usedProps = getUsedProps(fn);
+    for (const fixture of registrations.values()) {
+      if (isAutoFixture(fixture, options) || usedProps.has(fixture.name)) {
+        usedFixtures.push(fixture);
+      }
+    }
+    if (!usedFixtures.length) {
+      return fn(context);
+    }
+    if (!cleanupFnArrayMap.has(context)) {
+      cleanupFnArrayMap.set(context, []);
+    }
+    const cleanupFnArray = cleanupFnArrayMap.get(context);
+    const pendingFixtures = resolveDeps(usedFixtures, registrations);
+    if (!pendingFixtures.length) {
+      return fn(context);
+    }
+    if (options?.suiteHook) {
+      const testScopedFixtures = pendingFixtures.filter((f) => f.scope === "test");
+      if (testScopedFixtures.length > 0) {
+        const fixtureNames = testScopedFixtures.map((f) => `"${f.name}"`).join(", ");
+        const alternativeHook = {
+          aroundAll: "aroundEach",
+          beforeAll: "beforeEach",
+          afterAll: "afterEach"
+        };
+        const error = new FixtureDependencyError(`Test-scoped fixtures cannot be used inside ${options.suiteHook} hook. The following fixtures are test-scoped: ${fixtureNames}. Use { scope: 'file' } or { scope: 'worker' } fixtures instead, or move the logic to ${alternativeHook[options.suiteHook]} hook.`);
+        if (options.stackTraceError?.stack) {
+          error.stack = error.message + options.stackTraceError.stack.replace(options.stackTraceError.message, "");
+        }
+        throw error;
+      }
+    }
+    if (!contextHasFixturesCache.has(context)) {
+      contextHasFixturesCache.set(context, /* @__PURE__ */ new WeakSet());
+    }
+    const cachedFixtures = contextHasFixturesCache.get(context);
+    for (const fixture of pendingFixtures) {
+      if (fixture.scope === "test") {
+        if (cachedFixtures.has(fixture)) {
+          continue;
+        }
+        cachedFixtures.add(fixture);
+        const resolvedValue = await resolveTestFixtureValue(fixture, context, cleanupFnArray);
+        context[fixture.name] = resolvedValue;
+        cleanupFnArray.push(() => {
+          cachedFixtures.delete(fixture);
+        });
+      } else {
+        const resolvedValue = await resolveScopeFixtureValue(fixtures, suite2, fixture);
+        context[fixture.name] = resolvedValue;
+      }
+    }
+    return fn(context);
+  };
+}
+function isAutoFixture(fixture, options) {
+  if (!fixture.auto) {
+    return false;
+  }
+  if (options?.suiteHook && fixture.scope === "test") {
+    return false;
+  }
+  return true;
+}
+function isFixtureFunction(value) {
+  return typeof value === "function";
+}
+function resolveTestFixtureValue(fixture, context, cleanupFnArray) {
+  if (!isFixtureFunction(fixture.value)) {
+    return fixture.value;
+  }
+  return resolveFixtureFunction(fixture.value, fixture.name, context, cleanupFnArray);
+}
+var scopedFixturePromiseCache = /* @__PURE__ */ new WeakMap();
+async function resolveScopeFixtureValue(fixtures, suite2, fixture) {
+  const workerContext = fixtures.getWorkerContext();
+  const fileContext = fixtures.getFileContext(suite2.file);
+  const fixtureContext = fixture.scope === "worker" ? workerContext : fileContext;
+  if (!isFixtureFunction(fixture.value)) {
+    fixtureContext[fixture.name] = fixture.value;
+    return fixture.value;
+  }
+  if (fixture.name in fixtureContext) {
+    return fixtureContext[fixture.name];
+  }
+  if (scopedFixturePromiseCache.has(fixture)) {
+    return scopedFixturePromiseCache.get(fixture);
+  }
+  if (!cleanupFnArrayMap.has(fixtureContext)) {
+    cleanupFnArrayMap.set(fixtureContext, []);
+  }
+  const cleanupFnFileArray = cleanupFnArrayMap.get(fixtureContext);
+  const promise = resolveFixtureFunction(fixture.value, fixture.name, fixture.scope === "file" ? {
+    ...workerContext,
+    ...fileContext
+  } : fixtureContext, cleanupFnFileArray).then((value) => {
+    fixtureContext[fixture.name] = value;
+    scopedFixturePromiseCache.delete(fixture);
+    return value;
+  });
+  scopedFixturePromiseCache.set(fixture, promise);
+  return promise;
+}
+async function resolveFixtureFunction(fixtureFn, fixtureName, context, cleanupFnArray) {
+  const useFnArgPromise = createDefer();
+  const stackTraceError = FIXTURE_STACK_TRACE_KEY in fixtureFn && fixtureFn[FIXTURE_STACK_TRACE_KEY] instanceof Error ? fixtureFn[FIXTURE_STACK_TRACE_KEY] : void 0;
+  let isUseFnArgResolved = false;
+  const fixtureReturn = fixtureFn(context, async (useFnArg) => {
+    isUseFnArgResolved = true;
+    useFnArgPromise.resolve(useFnArg);
+    const useReturnPromise = createDefer();
+    cleanupFnArray.push(async () => {
+      useReturnPromise.resolve();
+      await fixtureReturn;
+    });
+    await useReturnPromise;
+  }).then(() => {
+    if (!isUseFnArgResolved) {
+      const error = new Error(`Fixture "${fixtureName}" returned without calling "use". Make sure to call "use" in every code path of the fixture function.`);
+      if (stackTraceError?.stack) {
+        error.stack = error.message + stackTraceError.stack.replace(stackTraceError.message, "");
+      }
+      useFnArgPromise.reject(error);
+    }
+  }).catch((e) => {
+    if (!isUseFnArgResolved) {
+      useFnArgPromise.reject(e);
+      return;
+    }
+    throw e;
+  });
+  return useFnArgPromise;
+}
+function resolveDeps(usedFixtures, registrations, depSet = /* @__PURE__ */ new Set(), pendingFixtures = []) {
+  usedFixtures.forEach((fixture) => {
+    if (pendingFixtures.includes(fixture)) {
+      return;
+    }
+    if (!isFixtureFunction(fixture.value) || !fixture.deps) {
+      pendingFixtures.push(fixture);
+      return;
+    }
+    if (depSet.has(fixture)) {
+      if (fixture.parent) {
+        fixture = fixture.parent;
+      } else {
+        throw new Error(`Circular fixture dependency detected: ${fixture.name} <- ${[...depSet].reverse().map((d2) => d2.name).join(" <- ")}`);
+      }
+    }
+    depSet.add(fixture);
+    resolveDeps([...fixture.deps].map((n) => n === fixture.name ? fixture.parent : registrations.get(n)).filter((n) => !!n), registrations, depSet, pendingFixtures);
+    pendingFixtures.push(fixture);
+    depSet.clear();
+  });
+  return pendingFixtures;
+}
+function validateSuiteHook(fn, hook, suiteError) {
+  const usedProps = getUsedProps(fn, {
+    sourceError: suiteError,
+    suiteHook: hook
+  });
+  if (usedProps.size) {
+    const error = new FixtureAccessError(`The ${hook} hook uses fixtures "${[...usedProps].join('", "')}", but has no access to context. Did you forget to call it as "test.${hook}()" instead of "${hook}()"?
+If you used internal "suite" task as the first argument previously, access it in the second argument instead. See https://vitest.dev/guide/test-context#suite-level-hooks`);
+    if (suiteError) {
+      error.stack = suiteError.stack?.replace(suiteError.message, error.message);
+    }
+    throw error;
+  }
+}
+var kPropsSymbol = /* @__PURE__ */ Symbol("$vitest:fixture-props");
+var kPropNamesSymbol = /* @__PURE__ */ Symbol("$vitest:fixture-prop-names");
+function configureProps(fn, options) {
+  Object.defineProperty(fn, kPropsSymbol, {
+    value: options,
+    enumerable: false
+  });
+}
+function memoProps(fn, props) {
+  fn[kPropNamesSymbol] = props;
+  return props;
+}
+function getUsedProps(fn, { sourceError, suiteHook } = {}) {
+  if (kPropNamesSymbol in fn) {
+    return fn[kPropNamesSymbol];
+  }
+  const { index: fixturesIndex = 0, original: implementation = fn } = kPropsSymbol in fn ? fn[kPropsSymbol] : {};
+  let fnString = filterOutComments(implementation.toString());
+  if (/__async\((?:this|null), (?:null|arguments|\[[_0-9, ]*\]), function\*/.test(fnString)) {
+    fnString = fnString.split(/__async\((?:this|null),/)[1];
+  }
+  const match = fnString.match(/[^(]*\(([^)]*)/);
+  if (!match) {
+    return memoProps(fn, /* @__PURE__ */ new Set());
+  }
+  const args = splitByComma(match[1]);
+  if (!args.length) {
+    return memoProps(fn, /* @__PURE__ */ new Set());
+  }
+  const fixturesArgument = args[fixturesIndex];
+  if (!fixturesArgument) {
+    return memoProps(fn, /* @__PURE__ */ new Set());
+  }
+  if (!(fixturesArgument[0] === "{" && fixturesArgument.endsWith("}"))) {
+    const ordinalArgument = ordinal(fixturesIndex + 1);
+    const error = new FixtureParseError(`The ${ordinalArgument} argument inside a fixture must use object destructuring pattern, e.g. ({ task } => {}). Instead, received "${fixturesArgument}".${suiteHook ? ` If you used internal "suite" task as the ${ordinalArgument} argument previously, access it in the ${ordinal(fixturesIndex + 2)} argument instead.` : ""}`);
+    if (sourceError) {
+      error.stack = sourceError.stack?.replace(sourceError.message, error.message);
+    }
+    throw error;
+  }
+  const _first = fixturesArgument.slice(1, -1).replace(/\s/g, "");
+  const props = splitByComma(_first).map((prop) => {
+    return prop.replace(/:.*|=.*/g, "");
+  });
+  const last = props.at(-1);
+  if (last && last.startsWith("...")) {
+    const error = new FixtureParseError(`Rest parameters are not supported in fixtures, received "${last}".`);
+    if (sourceError) {
+      error.stack = sourceError.stack?.replace(sourceError.message, error.message);
+    }
+    throw error;
+  }
+  return memoProps(fn, new Set(props));
+}
+function splitByComma(s) {
+  const result = [];
+  const stack = [];
+  let start = 0;
+  for (let i2 = 0; i2 < s.length; i2++) {
+    if (s[i2] === "{" || s[i2] === "[") {
+      stack.push(s[i2] === "{" ? "}" : "]");
+    } else if (s[i2] === stack.at(-1)) {
+      stack.pop();
+    } else if (!stack.length && s[i2] === ",") {
+      const token = s.substring(start, i2).trim();
+      if (token) {
+        result.push(token);
+      }
+      start = i2 + 1;
+    }
+  }
+  const lastToken = s.substring(start).trim();
+  if (lastToken) {
+    result.push(lastToken);
+  }
+  return result;
+}
+var _test;
+function getCurrentTest() {
+  return _test;
+}
+var kChainableContext = /* @__PURE__ */ Symbol("kChainableContext");
+function getChainableContext(chainable) {
+  return chainable?.[kChainableContext];
+}
+function createChainable(keys, fn, context) {
+  function create(context2) {
+    const chain2 = function(...args) {
+      return fn.apply(context2, args);
+    };
+    Object.assign(chain2, fn);
+    Object.defineProperty(chain2, kChainableContext, {
+      value: {
+        withContext: () => chain2.bind(context2),
+        getFixtures: () => context2.fixtures,
+        setContext: (key, value) => {
+          context2[key] = value;
+        },
+        mergeContext: (ctx) => {
+          Object.assign(context2, ctx);
+        }
+      },
+      enumerable: false
+    });
+    for (const key of keys) {
+      Object.defineProperty(chain2, key, { get() {
+        return create({
+          ...context2,
+          [key]: true
+        });
+      } });
+    }
+    return chain2;
+  }
+  const chain = create(context ?? {});
+  Object.defineProperty(chain, "fn", {
+    value: fn,
+    enumerable: false
+  });
+  return chain;
+}
+function getDefaultHookTimeout() {
+  return getRunner().config.hookTimeout;
+}
+var CLEANUP_TIMEOUT_KEY = /* @__PURE__ */ Symbol.for("VITEST_CLEANUP_TIMEOUT");
+var CLEANUP_STACK_TRACE_KEY = /* @__PURE__ */ Symbol.for("VITEST_CLEANUP_STACK_TRACE");
+var AROUND_TIMEOUT_KEY = /* @__PURE__ */ Symbol.for("VITEST_AROUND_TIMEOUT");
+var AROUND_STACK_TRACE_KEY = /* @__PURE__ */ Symbol.for("VITEST_AROUND_STACK_TRACE");
+function beforeAll(fn, timeout = getDefaultHookTimeout()) {
+  assertTypes(fn, '"beforeAll" callback', ["function"]);
+  const stackTraceError = new Error("STACK_TRACE_ERROR");
+  const context = getChainableContext(this);
+  return getCurrentSuite().on("beforeAll", Object.assign(withTimeout(withSuiteFixtures("beforeAll", fn, context, stackTraceError), timeout, true, stackTraceError), {
+    [CLEANUP_TIMEOUT_KEY]: timeout,
+    [CLEANUP_STACK_TRACE_KEY]: stackTraceError
+  }));
+}
+function afterAll(fn, timeout) {
+  assertTypes(fn, '"afterAll" callback', ["function"]);
+  const context = getChainableContext(this);
+  const stackTraceError = new Error("STACK_TRACE_ERROR");
+  return getCurrentSuite().on("afterAll", withTimeout(withSuiteFixtures("afterAll", fn, context, stackTraceError), timeout ?? getDefaultHookTimeout(), true, stackTraceError));
+}
+function beforeEach(fn, timeout = getDefaultHookTimeout()) {
+  assertTypes(fn, '"beforeEach" callback', ["function"]);
+  const stackTraceError = new Error("STACK_TRACE_ERROR");
+  const wrapper = (context, suite2) => {
+    const fixtureResolver = withFixtures(fn, { suite: suite2 });
+    return fixtureResolver(context);
+  };
+  return getCurrentSuite().on("beforeEach", Object.assign(withTimeout(wrapper, timeout ?? getDefaultHookTimeout(), true, stackTraceError, abortIfTimeout), {
+    [CLEANUP_TIMEOUT_KEY]: timeout,
+    [CLEANUP_STACK_TRACE_KEY]: stackTraceError
+  }));
+}
+function afterEach(fn, timeout) {
+  assertTypes(fn, '"afterEach" callback', ["function"]);
+  const wrapper = (context, suite2) => {
+    const fixtureResolver = withFixtures(fn, { suite: suite2 });
+    return fixtureResolver(context);
+  };
+  return getCurrentSuite().on("afterEach", withTimeout(wrapper, timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR"), abortIfTimeout));
+}
+var onTestFailed = createTestHook("onTestFailed", (test3, handler, timeout) => {
+  test3.onFailed ||= [];
+  test3.onFailed.push(withTimeout(handler, timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR"), abortIfTimeout));
+});
+var onTestFinished = createTestHook("onTestFinished", (test3, handler, timeout) => {
+  test3.onFinished ||= [];
+  test3.onFinished.push(withTimeout(handler, timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR"), abortIfTimeout));
+});
+function aroundAll(fn, timeout) {
+  assertTypes(fn, '"aroundAll" callback', ["function"]);
+  const stackTraceError = new Error("STACK_TRACE_ERROR");
+  const resolvedTimeout = timeout ?? getDefaultHookTimeout();
+  const context = getChainableContext(this);
+  return getCurrentSuite().on("aroundAll", Object.assign(withSuiteFixtures("aroundAll", fn, context, stackTraceError, 1), {
+    [AROUND_TIMEOUT_KEY]: resolvedTimeout,
+    [AROUND_STACK_TRACE_KEY]: stackTraceError
+  }));
+}
+function aroundEach(fn, timeout) {
+  assertTypes(fn, '"aroundEach" callback', ["function"]);
+  const stackTraceError = new Error("STACK_TRACE_ERROR");
+  const resolvedTimeout = timeout ?? getDefaultHookTimeout();
+  const wrapper = (runTest, context, suite2) => {
+    const innerFn = (ctx) => fn(runTest, ctx, suite2);
+    configureProps(innerFn, {
+      index: 1,
+      original: fn
+    });
+    const fixtureResolver = withFixtures(innerFn, { suite: suite2 });
+    return fixtureResolver(context);
+  };
+  return getCurrentSuite().on("aroundEach", Object.assign(wrapper, {
+    [AROUND_TIMEOUT_KEY]: resolvedTimeout,
+    [AROUND_STACK_TRACE_KEY]: stackTraceError
+  }));
+}
+function withSuiteFixtures(suiteHook, fn, context, stackTraceError, contextIndex = 0) {
+  return (...args) => {
+    const suite2 = args.at(-1);
+    const prefix = args.slice(0, -1);
+    const wrapper = (ctx) => fn(...prefix, ctx, suite2);
+    configureProps(wrapper, {
+      index: contextIndex,
+      original: fn
+    });
+    const fixtures = context?.getFixtures();
+    const fileContext = fixtures?.getFileContext(suite2.file);
+    const fixtured = withFixtures(wrapper, {
+      suiteHook,
+      fixtures,
+      context: fileContext,
+      stackTraceError
+    });
+    return fixtured();
+  };
+}
+function createTestHook(name, handler) {
+  return (fn, timeout) => {
+    assertTypes(fn, `"${name}" callback`, ["function"]);
+    const current = getCurrentTest();
+    if (!current) {
+      throw new Error(`Hook ${name}() can only be called inside a test`);
+    }
+    return handler(current, fn, timeout);
+  };
+}
+function findTestFileStackTrace(testFilePath, error) {
+  const lines = error.split("\n").slice(1);
+  for (const line of lines) {
+    const stack = parseSingleStack(line);
+    if (stack && stack.file === testFilePath) {
+      return stack;
+    }
+  }
+}
+function validateTags(config, tags) {
+  if (!config.strictTags) {
+    return;
+  }
+  const availableTags = new Set(config.tags.map((tag) => tag.name));
+  for (const tag of tags) {
+    if (!availableTags.has(tag)) {
+      throw createNoTagsError(config.tags, tag);
+    }
+  }
+}
+function createNoTagsError(availableTags, tag, prefix = "tag") {
+  if (!availableTags.length) {
+    throw new Error(`The Vitest config does't define any "tags", cannot apply "${tag}" ${prefix} for this test. See: https://vitest.dev/guide/test-tags`);
+  }
+  throw new Error(`The ${prefix} "${tag}" is not defined in the configuration. Available tags are:
+${availableTags.map((t) => `- ${t.name}${t.description ? `: ${t.description}` : ""}`).join("\n")}`);
+}
+function createTaskName(names, separator = " > ") {
+  return names.filter((name) => name !== void 0).join(separator);
+}
+var suite = createSuite();
+var test2 = createTest(function(name, optionsOrFn, optionsOrTest) {
+  if (getCurrentTest()) {
+    throw new Error('Calling the test function inside another test function is not allowed. Please put it inside "describe" or "suite" so it can be properly collected.');
+  }
+  getCurrentSuite().test.fn.call(this, formatName(name), optionsOrFn, optionsOrTest);
+});
+var runner;
+var defaultSuite;
+var currentTestFilepath;
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(`Vitest failed to find ${message}. One of the following is possible:
+- "vitest" is imported directly without running "vitest" command
+- "vitest" is imported inside "globalSetup" (to fix this, use "setupFiles" instead, because "globalSetup" runs in a different context)
+- "vitest" is imported inside Vite / Vitest config file
+- Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues
+`);
+  }
+}
+function getRunner() {
+  assert(runner, "the runner");
+  return runner;
+}
+function getCurrentSuite() {
+  const currentSuite = collectorContext.currentSuite || defaultSuite;
+  assert(currentSuite, "the current suite");
+  return currentSuite;
+}
+function createSuiteHooks() {
+  return {
+    beforeAll: [],
+    afterAll: [],
+    beforeEach: [],
+    afterEach: [],
+    aroundEach: [],
+    aroundAll: []
+  };
+}
+var POSITIVE_INFINITY = Number.POSITIVE_INFINITY;
+function parseArguments(optionsOrFn, timeoutOrTest) {
+  if (timeoutOrTest != null && typeof timeoutOrTest === "object") {
+    throw new TypeError(`Signature "test(name, fn, { ... })" was deprecated in Vitest 3 and removed in Vitest 4. Please, provide options as a second argument instead.`);
+  }
+  let options = {};
+  let fn;
+  if (typeof timeoutOrTest === "number") {
+    options = { timeout: timeoutOrTest };
+  } else if (typeof optionsOrFn === "object") {
+    options = optionsOrFn;
+  }
+  if (typeof optionsOrFn === "function") {
+    if (typeof timeoutOrTest === "function") {
+      throw new TypeError("Cannot use two functions as arguments. Please use the second argument for options.");
+    }
+    fn = optionsOrFn;
+  } else if (typeof timeoutOrTest === "function") {
+    fn = timeoutOrTest;
+  }
+  return {
+    options,
+    handler: fn
+  };
+}
+function createSuiteCollector(name, factory = () => {
+}, mode, each, suiteOptions) {
+  const tasks = [];
+  let suite2;
+  initSuite(true);
+  const task = function(name2 = "", options = {}) {
+    const currentSuite = collectorContext.currentSuite?.suite;
+    const parentTask = currentSuite ?? collectorContext.currentSuite?.file;
+    const parentTags = parentTask?.tags || [];
+    const testTags = unique([...parentTags, ...toArray(options.tags)]);
+    const tagsOptions = testTags.map((tag) => {
+      const tagDefinition = runner.config.tags?.find((t) => t.name === tag);
+      if (!tagDefinition && runner.config.strictTags) {
+        throw createNoTagsError(runner.config.tags, tag);
+      }
+      return tagDefinition;
+    }).filter((r) => r != null).sort((tag1, tag2) => (tag2.priority ?? POSITIVE_INFINITY) - (tag1.priority ?? POSITIVE_INFINITY)).reduce((acc, tag) => {
+      const { name: name3, description, priority, meta, ...options2 } = tag;
+      Object.assign(acc, options2);
+      if (meta) {
+        acc.meta = Object.assign(acc.meta ?? /* @__PURE__ */ Object.create(null), meta);
+      }
+      return acc;
+    }, {});
+    const testOwnMeta = options.meta;
+    options = {
+      ...tagsOptions,
+      ...options
+    };
+    const timeout = options.timeout ?? runner.config.testTimeout;
+    const parentMeta = currentSuite?.meta;
+    const tagMeta = tagsOptions.meta;
+    const testMeta = /* @__PURE__ */ Object.create(null);
+    if (tagMeta) {
+      Object.assign(testMeta, tagMeta);
+    }
+    if (parentMeta) {
+      Object.assign(testMeta, parentMeta);
+    }
+    if (testOwnMeta) {
+      Object.assign(testMeta, testOwnMeta);
+    }
+    const task2 = {
+      id: "",
+      name: name2,
+      fullName: createTaskName([currentSuite?.fullName ?? collectorContext.currentSuite?.file?.fullName, name2]),
+      fullTestName: createTaskName([currentSuite?.fullTestName, name2]),
+      suite: currentSuite,
+      each: options.each,
+      fails: options.fails,
+      context: void 0,
+      type: "test",
+      file: currentSuite?.file ?? collectorContext.currentSuite?.file,
+      timeout,
+      retry: options.retry ?? runner.config.retry,
+      repeats: options.repeats,
+      mode: options.only ? "only" : options.skip ? "skip" : options.todo ? "todo" : "run",
+      meta: testMeta,
+      annotations: [],
+      artifacts: [],
+      tags: testTags
+    };
+    const handler = options.handler;
+    if (task2.mode === "run" && !handler) {
+      task2.mode = "todo";
+    }
+    if (options.concurrent ?? (!options.sequential && runner.config.sequence.concurrent)) {
+      task2.concurrent = true;
+    }
+    task2.shuffle = suiteOptions?.shuffle;
+    const context = createTestContext(task2, runner);
+    Object.defineProperty(task2, "context", {
+      value: context,
+      enumerable: false
+    });
+    setTestFixture(context, options.fixtures ?? new TestFixtures());
+    const limit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 10;
+    const stackTraceError = new Error("STACK_TRACE_ERROR");
+    Error.stackTraceLimit = limit;
+    if (handler) {
+      setFn(task2, withTimeout(withCancel(withAwaitAsyncAssertions(withFixtures(handler, { context }), task2), task2.context.signal), timeout, false, stackTraceError, (_, error) => abortIfTimeout([context], error)));
+    }
+    if (runner.config.includeTaskLocation) {
+      const error = stackTraceError.stack;
+      const stack = findTestFileStackTrace(currentTestFilepath, error);
+      if (stack) {
+        task2.location = {
+          line: stack.line,
+          column: stack.column
+        };
+      }
+    }
+    tasks.push(task2);
+    return task2;
+  };
+  const test3 = createTest(function(name2, optionsOrFn, timeoutOrTest) {
+    let { options, handler } = parseArguments(optionsOrFn, timeoutOrTest);
+    if (typeof suiteOptions === "object") {
+      options = Object.assign({}, suiteOptions, options);
+    }
+    const concurrent = this.concurrent ?? (!this.sequential && options?.concurrent);
+    if (options.concurrent != null && concurrent != null) {
+      options.concurrent = concurrent;
+    }
+    const sequential = this.sequential ?? (!this.concurrent && options?.sequential);
+    if (options.sequential != null && sequential != null) {
+      options.sequential = sequential;
+    }
+    const test4 = task(formatName(name2), {
+      ...this,
+      ...options,
+      handler
+    });
+    test4.type = "test";
+  });
+  const collector = {
+    type: "collector",
+    name,
+    mode,
+    suite: suite2,
+    options: suiteOptions,
+    test: test3,
+    file: suite2.file,
+    tasks,
+    collect,
+    task,
+    clear,
+    on: addHook
+  };
+  function addHook(name2, ...fn) {
+    getHooks(suite2)[name2].push(...fn);
+  }
+  function initSuite(includeLocation) {
+    if (typeof suiteOptions === "number") {
+      suiteOptions = { timeout: suiteOptions };
+    }
+    const currentSuite = collectorContext.currentSuite?.suite;
+    const parentTask = currentSuite ?? collectorContext.currentSuite?.file;
+    const suiteTags = toArray(suiteOptions?.tags);
+    validateTags(runner.config, suiteTags);
+    suite2 = {
+      id: "",
+      type: "suite",
+      name,
+      fullName: createTaskName([currentSuite?.fullName ?? collectorContext.currentSuite?.file?.fullName, name]),
+      fullTestName: createTaskName([currentSuite?.fullTestName, name]),
+      suite: currentSuite,
+      mode,
+      each,
+      file: currentSuite?.file ?? collectorContext.currentSuite?.file,
+      shuffle: suiteOptions?.shuffle,
+      tasks: [],
+      meta: suiteOptions?.meta ?? /* @__PURE__ */ Object.create(null),
+      concurrent: suiteOptions?.concurrent,
+      tags: unique([...parentTask?.tags || [], ...suiteTags])
+    };
+    if (runner && includeLocation && runner.config.includeTaskLocation) {
+      const limit = Error.stackTraceLimit;
+      Error.stackTraceLimit = 15;
+      const error = new Error("stacktrace").stack;
+      Error.stackTraceLimit = limit;
+      const stack = findTestFileStackTrace(currentTestFilepath, error);
+      if (stack) {
+        suite2.location = {
+          line: stack.line,
+          column: stack.column
+        };
+      }
+    }
+    setHooks(suite2, createSuiteHooks());
+  }
+  function clear() {
+    tasks.length = 0;
+    initSuite(false);
+  }
+  async function collect(file) {
+    if (!file) {
+      throw new TypeError("File is required to collect tasks.");
+    }
+    if (factory) {
+      await runWithSuite(collector, () => factory(test3));
+    }
+    const allChildren = [];
+    for (const i2 of tasks) {
+      allChildren.push(i2.type === "collector" ? await i2.collect(file) : i2);
+    }
+    suite2.tasks = allChildren;
+    return suite2;
+  }
+  collectTask(collector);
+  return collector;
+}
+function withAwaitAsyncAssertions(fn, task) {
+  return (async (...args) => {
+    const fnResult = await fn(...args);
+    if (task.promises) {
+      const result = await Promise.allSettled(task.promises);
+      const errors = result.map((r) => r.status === "rejected" ? r.reason : void 0).filter(Boolean);
+      if (errors.length) {
+        throw errors;
+      }
+    }
+    return fnResult;
+  });
+}
+function createSuite() {
+  function suiteFn(name, factoryOrOptions, optionsOrFactory) {
+    if (getCurrentTest()) {
+      throw new Error("Calling the suite function inside test function is not allowed. It can be only called at the top level or inside another suite function.");
+    }
+    const currentSuite = collectorContext.currentSuite || defaultSuite;
+    let { options, handler: factory } = parseArguments(factoryOrOptions, optionsOrFactory);
+    const isConcurrentSpecified = options.concurrent || this.concurrent || options.sequential === false;
+    const isSequentialSpecified = options.sequential || this.sequential || options.concurrent === false;
+    const { meta: parentMeta, ...parentOptions } = currentSuite?.options || {};
+    options = {
+      ...parentOptions,
+      ...options
+    };
+    const shuffle2 = this.shuffle ?? options.shuffle ?? currentSuite?.options?.shuffle ?? runner?.config.sequence.shuffle;
+    if (shuffle2 != null) {
+      options.shuffle = shuffle2;
+    }
+    let mode = this.only ?? options.only ? "only" : this.skip ?? options.skip ? "skip" : this.todo ?? options.todo ? "todo" : "run";
+    if (mode === "run" && !factory) {
+      mode = "todo";
+    }
+    const isConcurrent = isConcurrentSpecified || options.concurrent && !isSequentialSpecified;
+    const isSequential = isSequentialSpecified || options.sequential && !isConcurrentSpecified;
+    if (isConcurrent != null) {
+      options.concurrent = isConcurrent && !isSequential;
+    }
+    if (isSequential != null) {
+      options.sequential = isSequential && !isConcurrent;
+    }
+    if (parentMeta) {
+      options.meta = Object.assign(/* @__PURE__ */ Object.create(null), parentMeta, options.meta);
+    }
+    return createSuiteCollector(formatName(name), factory, mode, this.each, options);
+  }
+  suiteFn.each = function(cases, ...args) {
+    const context = getChainableContext(this);
+    const suite2 = context.withContext();
+    context.setContext("each", true);
+    if (Array.isArray(cases) && args.length) {
+      cases = formatTemplateString(cases, args);
+    }
+    return (name, optionsOrFn, fnOrOptions) => {
+      const _name = formatName(name);
+      const arrayOnlyCases = cases.every(Array.isArray);
+      const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+      const fnFirst = typeof optionsOrFn === "function";
+      cases.forEach((i2, idx) => {
+        const items = Array.isArray(i2) ? i2 : [i2];
+        if (fnFirst) {
+          if (arrayOnlyCases) {
+            suite2(formatTitle(_name, items, idx), handler ? () => handler(...items) : void 0, options.timeout);
+          } else {
+            suite2(formatTitle(_name, items, idx), handler ? () => handler(i2) : void 0, options.timeout);
+          }
+        } else {
+          if (arrayOnlyCases) {
+            suite2(formatTitle(_name, items, idx), options, handler ? () => handler(...items) : void 0);
+          } else {
+            suite2(formatTitle(_name, items, idx), options, handler ? () => handler(i2) : void 0);
+          }
+        }
+      });
+      context.setContext("each", void 0);
+    };
+  };
+  suiteFn.for = function(cases, ...args) {
+    if (Array.isArray(cases) && args.length) {
+      cases = formatTemplateString(cases, args);
+    }
+    return (name, optionsOrFn, fnOrOptions) => {
+      const name_ = formatName(name);
+      const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+      cases.forEach((item, idx) => {
+        suite(formatTitle(name_, toArray(item), idx), options, handler ? () => handler(item) : void 0);
+      });
+    };
+  };
+  suiteFn.skipIf = (condition) => condition ? suite.skip : suite;
+  suiteFn.runIf = (condition) => condition ? suite : suite.skip;
+  return createChainable([
+    "concurrent",
+    "sequential",
+    "shuffle",
+    "skip",
+    "only",
+    "todo"
+  ], suiteFn);
+}
+function createTaskCollector(fn) {
+  const taskFn = fn;
+  taskFn.each = function(cases, ...args) {
+    const context = getChainableContext(this);
+    const test3 = context.withContext();
+    context.setContext("each", true);
+    if (Array.isArray(cases) && args.length) {
+      cases = formatTemplateString(cases, args);
+    }
+    return (name, optionsOrFn, fnOrOptions) => {
+      const _name = formatName(name);
+      const arrayOnlyCases = cases.every(Array.isArray);
+      const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+      const fnFirst = typeof optionsOrFn === "function";
+      cases.forEach((i2, idx) => {
+        const items = Array.isArray(i2) ? i2 : [i2];
+        if (fnFirst) {
+          if (arrayOnlyCases) {
+            test3(formatTitle(_name, items, idx), handler ? () => handler(...items) : void 0, options.timeout);
+          } else {
+            test3(formatTitle(_name, items, idx), handler ? () => handler(i2) : void 0, options.timeout);
+          }
+        } else {
+          if (arrayOnlyCases) {
+            test3(formatTitle(_name, items, idx), options, handler ? () => handler(...items) : void 0);
+          } else {
+            test3(formatTitle(_name, items, idx), options, handler ? () => handler(i2) : void 0);
+          }
+        }
+      });
+      context.setContext("each", void 0);
+    };
+  };
+  taskFn.for = function(cases, ...args) {
+    const context = getChainableContext(this);
+    const test3 = context.withContext();
+    if (Array.isArray(cases) && args.length) {
+      cases = formatTemplateString(cases, args);
+    }
+    return (name, optionsOrFn, fnOrOptions) => {
+      const _name = formatName(name);
+      const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+      cases.forEach((item, idx) => {
+        const handlerWrapper = handler ? (ctx) => handler(item, ctx) : void 0;
+        if (handlerWrapper) {
+          configureProps(handlerWrapper, {
+            index: 1,
+            original: handler
+          });
+        }
+        test3(formatTitle(_name, toArray(item), idx), options, handlerWrapper);
+      });
+    };
+  };
+  taskFn.skipIf = function(condition) {
+    return condition ? this.skip : this;
+  };
+  taskFn.runIf = function(condition) {
+    return condition ? this : this.skip;
+  };
+  function parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn) {
+    if (typeof fixturesOrName !== "string") {
+      return fixturesOrName;
+    }
+    const fixtureName = fixturesOrName;
+    let fixtureOptions;
+    let fixtureValue;
+    if (maybeFn !== void 0) {
+      fixtureOptions = optionsOrFn;
+      fixtureValue = maybeFn;
+    } else {
+      if (optionsOrFn !== null && typeof optionsOrFn === "object" && !Array.isArray(optionsOrFn) && TestFixtures.isFixtureOptions(optionsOrFn)) {
+        fixtureOptions = optionsOrFn;
+        fixtureValue = {};
+      } else {
+        fixtureOptions = void 0;
+        fixtureValue = optionsOrFn;
+      }
+    }
+    if (typeof fixtureValue === "function") {
+      const builderFn = fixtureValue;
+      const fixture = async (ctx, use) => {
+        let cleanup;
+        const onCleanup = (fn2) => {
+          if (cleanup !== void 0) {
+            throw new Error(`onCleanup can only be called once per fixture. Define separate fixtures if you need multiple cleanup functions.`);
+          }
+          cleanup = fn2;
+        };
+        const value = await builderFn(ctx, { onCleanup });
+        await use(value);
+        if (cleanup) {
+          await cleanup();
+        }
+      };
+      configureProps(fixture, { original: builderFn });
+      if (fixtureOptions) {
+        return { [fixtureName]: [fixture, fixtureOptions] };
+      }
+      return { [fixtureName]: fixture };
+    }
+    if (fixtureOptions) {
+      return { [fixtureName]: [fixtureValue, fixtureOptions] };
+    }
+    return { [fixtureName]: fixtureValue };
+  }
+  taskFn.override = function(fixturesOrName, optionsOrFn, maybeFn) {
+    const userFixtures = parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn);
+    getChainableContext(this).getFixtures().override(runner, userFixtures);
+    return this;
+  };
+  taskFn.scoped = function(fixtures) {
+    console.warn(`test.scoped() is deprecated and will be removed in future versions. Please use test.override() instead.`);
+    return this.override(fixtures);
+  };
+  taskFn.extend = function(fixturesOrName, optionsOrFn, maybeFn) {
+    const userFixtures = parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn);
+    const fixtures = getChainableContext(this).getFixtures().extend(runner, userFixtures);
+    const _test3 = createTest(function(name, optionsOrFn2, optionsOrTest) {
+      fn.call(this, formatName(name), optionsOrFn2, optionsOrTest);
+    });
+    getChainableContext(_test3).mergeContext({ fixtures });
+    return _test3;
+  };
+  taskFn.describe = suite;
+  taskFn.suite = suite;
+  taskFn.beforeEach = beforeEach;
+  taskFn.afterEach = afterEach;
+  taskFn.beforeAll = beforeAll;
+  taskFn.afterAll = afterAll;
+  taskFn.aroundEach = aroundEach;
+  taskFn.aroundAll = aroundAll;
+  const _test2 = createChainable([
+    "concurrent",
+    "sequential",
+    "skip",
+    "only",
+    "todo",
+    "fails"
+  ], taskFn, { fixtures: new TestFixtures() });
+  return _test2;
+}
+function createTest(fn) {
+  return createTaskCollector(fn);
+}
+function formatName(name) {
+  return typeof name === "string" ? name : typeof name === "function" ? name.name || "<anonymous>" : String(name);
+}
+function formatTitle(template, items, idx) {
+  if (template.includes("%#") || template.includes("%$")) {
+    template = template.replace(/%%/g, "__vitest_escaped_%__").replace(/%#/g, `${idx}`).replace(/%\$/g, `${idx + 1}`).replace(/__vitest_escaped_%__/g, "%%");
+  }
+  const count = template.split("%").length - 1;
+  if (template.includes("%f")) {
+    const placeholders = template.match(/%f/g) || [];
+    placeholders.forEach((_, i3) => {
+      if (isNegativeNaN(items[i3]) || Object.is(items[i3], -0)) {
+        let occurrence = 0;
+        template = template.replace(/%f/g, (match) => {
+          occurrence++;
+          return occurrence === i3 + 1 ? "-%f" : match;
+        });
+      }
+    });
+  }
+  const isObjectItem = isObject(items[0]);
+  function formatAttribute(s) {
+    return s.replace(/\$([$\w.]+)/g, (_, key) => {
+      const isArrayKey = /^\d+$/.test(key);
+      if (!isObjectItem && !isArrayKey) {
+        return `$${key}`;
+      }
+      const arrayElement = isArrayKey ? objectAttr(items, key) : void 0;
+      const value = isObjectItem ? objectAttr(items[0], key, arrayElement) : arrayElement;
+      return objDisplay(value, { truncate: runner?.config?.chaiConfig?.truncateThreshold });
+    });
+  }
+  let output = "";
+  let i2 = 0;
+  handleRegexMatch(
+    template,
+    formatRegExp,
+    // format "%"
+    (match) => {
+      if (i2 < count) {
+        output += format2(match[0], items[i2++]);
+      } else {
+        output += match[0];
+      }
+    },
+    // format "$"
+    (nonMatch) => {
+      output += formatAttribute(nonMatch);
+    }
+  );
+  return output;
+}
+function handleRegexMatch(input, regex, onMatch, onNonMatch) {
+  let lastIndex = 0;
+  for (const m of input.matchAll(regex)) {
+    if (lastIndex < m.index) {
+      onNonMatch(input.slice(lastIndex, m.index));
+    }
+    onMatch(m);
+    lastIndex = m.index + m[0].length;
+  }
+  if (lastIndex < input.length) {
+    onNonMatch(input.slice(lastIndex));
+  }
+}
+function formatTemplateString(cases, args) {
+  const header = cases.join("").trim().replace(/ /g, "").split("\n").map((i2) => i2.split("|"))[0];
+  const res = [];
+  for (let i2 = 0; i2 < Math.floor(args.length / header.length); i2++) {
+    const oneCase = {};
+    for (let j = 0; j < header.length; j++) {
+      oneCase[header[j]] = args[i2 * header.length + j];
+    }
+    res.push(oneCase);
+  }
+  return res;
+}
+var now$2 = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+var collectorContext = {
+  tasks: [],
+  currentSuite: null
+};
+function collectTask(task) {
+  collectorContext.currentSuite?.tasks.push(task);
+}
+async function runWithSuite(suite2, fn) {
+  const prev = collectorContext.currentSuite;
+  collectorContext.currentSuite = suite2;
+  await fn();
+  collectorContext.currentSuite = prev;
+}
+function withTimeout(fn, timeout, isHook = false, stackTraceError, onTimeout) {
+  if (timeout <= 0 || timeout === Number.POSITIVE_INFINITY) {
+    return fn;
+  }
+  const { setTimeout: setTimeout3, clearTimeout: clearTimeout3 } = getSafeTimers();
+  return (function runWithTimeout(...args) {
+    const startTime = now$2();
+    const runner2 = getRunner();
+    runner2._currentTaskStartTime = startTime;
+    runner2._currentTaskTimeout = timeout;
+    return new Promise((resolve_, reject_) => {
+      const timer = setTimeout3(() => {
+        clearTimeout3(timer);
+        rejectTimeoutError();
+      }, timeout);
+      timer.unref?.();
+      function rejectTimeoutError() {
+        const error = makeTimeoutError(isHook, timeout, stackTraceError);
+        onTimeout?.(args, error);
+        reject_(error);
+      }
+      function resolve2(result) {
+        runner2._currentTaskStartTime = void 0;
+        runner2._currentTaskTimeout = void 0;
+        clearTimeout3(timer);
+        if (now$2() - startTime >= timeout) {
+          rejectTimeoutError();
+          return;
+        }
+        resolve_(result);
+      }
+      function reject(error) {
+        runner2._currentTaskStartTime = void 0;
+        runner2._currentTaskTimeout = void 0;
+        clearTimeout3(timer);
+        reject_(error);
+      }
+      try {
+        const result = fn(...args);
+        if (typeof result === "object" && result != null && typeof result.then === "function") {
+          result.then(resolve2, reject);
+        } else {
+          resolve2(result);
+        }
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}
+function withCancel(fn, signal) {
+  return (function runWithCancel(...args) {
+    return new Promise((resolve2, reject) => {
+      signal.addEventListener("abort", () => reject(signal.reason));
+      try {
+        const result = fn(...args);
+        if (typeof result === "object" && result != null && typeof result.then === "function") {
+          result.then(resolve2, reject);
+        } else {
+          resolve2(result);
+        }
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}
+var abortControllers = /* @__PURE__ */ new WeakMap();
+function abortIfTimeout([context], error) {
+  if (context) {
+    abortContextSignal(context, error);
+  }
+}
+function abortContextSignal(context, error) {
+  const abortController = abortControllers.get(context);
+  abortController?.abort(error);
+}
+function createTestContext(test3, runner2) {
+  const context = function() {
+    throw new Error("done() callback is deprecated, use promise instead");
+  };
+  let abortController = abortControllers.get(context);
+  if (!abortController) {
+    abortController = new AbortController();
+    abortControllers.set(context, abortController);
+  }
+  context.signal = abortController.signal;
+  context.task = test3;
+  context.skip = (condition, note) => {
+    if (condition === false) {
+      return void 0;
+    }
+    test3.result ??= { state: "skip" };
+    test3.result.pending = true;
+    throw new PendingError("test is skipped; abort execution", test3, typeof condition === "string" ? condition : note);
+  };
+  context.annotate = ((message, type, attachment) => {
+    if (test3.result && test3.result.state !== "run") {
+      throw new Error(`Cannot annotate tests outside of the test run. The test "${test3.name}" finished running with the "${test3.result.state}" state already.`);
+    }
+    const annotation = {
+      message,
+      type: typeof type === "object" || type === void 0 ? "notice" : type
+    };
+    const annotationAttachment = typeof type === "object" ? type : attachment;
+    if (annotationAttachment) {
+      annotation.attachment = annotationAttachment;
+      manageArtifactAttachment(annotation.attachment);
+    }
+    return recordAsyncOperation(test3, recordArtifact(test3, {
+      type: "internal:annotation",
+      annotation
+    }).then(async ({ annotation: annotation2 }) => {
+      if (!runner2.onTestAnnotate) {
+        throw new Error(`Test runner doesn't support test annotations.`);
+      }
+      await finishSendTasksUpdate(runner2);
+      const resolvedAnnotation = await runner2.onTestAnnotate(test3, annotation2);
+      test3.annotations.push(resolvedAnnotation);
+      return resolvedAnnotation;
+    }));
+  });
+  context.onTestFailed = (handler, timeout) => {
+    test3.onFailed ||= [];
+    test3.onFailed.push(withTimeout(handler, timeout ?? runner2.config.hookTimeout, true, new Error("STACK_TRACE_ERROR"), (_, error) => abortController.abort(error)));
+  };
+  context.onTestFinished = (handler, timeout) => {
+    test3.onFinished ||= [];
+    test3.onFinished.push(withTimeout(handler, timeout ?? runner2.config.hookTimeout, true, new Error("STACK_TRACE_ERROR"), (_, error) => abortController.abort(error)));
+  };
+  return runner2.extendTaskContext?.(context) || context;
+}
+function makeTimeoutError(isHook, timeout, stackTraceError) {
+  const message = `${isHook ? "Hook" : "Test"} timed out in ${timeout}ms.
+If this is a long-running ${isHook ? "hook" : "test"}, pass a timeout value as the last argument or configure it globally with "${isHook ? "hookTimeout" : "testTimeout"}".`;
+  const error = new Error(message);
+  if (stackTraceError?.stack) {
+    error.stack = stackTraceError.stack.replace(error.message, stackTraceError.message);
+  }
+  return error;
+}
+var now$1 = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+var now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+var unixNow = Date.now;
+var { clearTimeout: clearTimeout2, setTimeout: setTimeout2 } = getSafeTimers();
+var packs = /* @__PURE__ */ new Map();
+var eventsPacks = [];
+var pendingTasksUpdates = [];
+function sendTasksUpdate(runner2) {
+  if (packs.size) {
+    const taskPacks = Array.from(packs).map(([id, task]) => {
+      return [
+        id,
+        task[0],
+        task[1]
+      ];
+    });
+    const p = runner2.onTaskUpdate?.(taskPacks, eventsPacks);
+    if (p) {
+      pendingTasksUpdates.push(p);
+      p.then(() => pendingTasksUpdates.splice(pendingTasksUpdates.indexOf(p), 1), () => {
+      });
+    }
+    eventsPacks.length = 0;
+    packs.clear();
+  }
+}
+async function finishSendTasksUpdate(runner2) {
+  sendTasksUpdate(runner2);
+  await Promise.all(pendingTasksUpdates);
+}
+function throttle(fn, ms) {
+  let last = 0;
+  let pendingCall;
+  return function call(...args) {
+    const now2 = unixNow();
+    if (now2 - last > ms) {
+      last = now2;
+      clearTimeout2(pendingCall);
+      pendingCall = void 0;
+      return fn.apply(this, args);
+    }
+    pendingCall ??= setTimeout2(() => call.bind(this)(...args), ms);
+  };
+}
+var sendTasksUpdateThrottled = throttle(sendTasksUpdate, 100);
+async function recordArtifact(task, artifact) {
+  const runner2 = getRunner();
+  const stack = findTestFileStackTrace(task.file.filepath, new Error("STACK_TRACE").stack);
+  if (stack) {
+    artifact.location = {
+      file: stack.file,
+      line: stack.line,
+      column: stack.column
+    };
+    if (artifact.type === "internal:annotation") {
+      artifact.annotation.location = artifact.location;
+    }
+  }
+  if (Array.isArray(artifact.attachments)) {
+    for (const attachment of artifact.attachments) {
+      manageArtifactAttachment(attachment);
+    }
+  }
+  if (artifact.type === "internal:annotation") {
+    return artifact;
+  }
+  if (!runner2.onTestArtifactRecord) {
+    throw new Error(`Test runner doesn't support test artifacts.`);
+  }
+  await finishSendTasksUpdate(runner2);
+  const resolvedArtifact = await runner2.onTestArtifactRecord(task, artifact);
+  task.artifacts.push(resolvedArtifact);
+  return resolvedArtifact;
+}
+var table = [];
+for (let i2 = 65; i2 < 91; i2++) {
+  table.push(String.fromCharCode(i2));
+}
+for (let i2 = 97; i2 < 123; i2++) {
+  table.push(String.fromCharCode(i2));
+}
+for (let i2 = 0; i2 < 10; i2++) {
+  table.push(i2.toString(10));
+}
+table.push("+", "/");
+function encodeUint8Array(bytes) {
+  let base64 = "";
+  const len = bytes.byteLength;
+  for (let i2 = 0; i2 < len; i2 += 3) {
+    if (len === i2 + 1) {
+      const a = (bytes[i2] & 252) >> 2;
+      const b2 = (bytes[i2] & 3) << 4;
+      base64 += table[a];
+      base64 += table[b2];
+      base64 += "==";
+    } else if (len === i2 + 2) {
+      const a = (bytes[i2] & 252) >> 2;
+      const b2 = (bytes[i2] & 3) << 4 | (bytes[i2 + 1] & 240) >> 4;
+      const c = (bytes[i2 + 1] & 15) << 2;
+      base64 += table[a];
+      base64 += table[b2];
+      base64 += table[c];
+      base64 += "=";
+    } else {
+      const a = (bytes[i2] & 252) >> 2;
+      const b2 = (bytes[i2] & 3) << 4 | (bytes[i2 + 1] & 240) >> 4;
+      const c = (bytes[i2 + 1] & 15) << 2 | (bytes[i2 + 2] & 192) >> 6;
+      const d2 = bytes[i2 + 2] & 63;
+      base64 += table[a];
+      base64 += table[b2];
+      base64 += table[c];
+      base64 += table[d2];
+    }
+  }
+  return base64;
+}
+function recordAsyncOperation(test3, promise) {
+  promise = promise.finally(() => {
+    if (!test3.promises) {
+      return;
+    }
+    const index2 = test3.promises.indexOf(promise);
+    if (index2 !== -1) {
+      test3.promises.splice(index2, 1);
+    }
+  });
+  if (!test3.promises) {
+    test3.promises = [];
+  }
+  test3.promises.push(promise);
+  return promise;
+}
+function manageArtifactAttachment(attachment) {
+  if (attachment.body == null && !attachment.path) {
+    throw new TypeError(`Test attachment requires "body" or "path" to be set. Both are missing.`);
+  }
+  if (attachment.body && attachment.path) {
+    throw new TypeError(`Test attachment requires only one of "body" or "path" to be set. Both are specified.`);
+  }
+  if (attachment.path && attachment.bodyEncoding) {
+    throw new TypeError(`Test attachment with "path" should not have "bodyEncoding" specified.`);
+  }
+  if (attachment.body instanceof Uint8Array) {
+    attachment.body = encodeUint8Array(attachment.body);
+  }
+  if (attachment.body != null) {
+    attachment.bodyEncoding ??= "base64";
+  }
+}
+
+// node_modules/vitest/node_modules/vite/dist/node/module-runner.js
+var SOURCEMAPPING_URL = "sourceMa";
+SOURCEMAPPING_URL += "ppingURL";
+var isWindows = typeof process < "u" && process.platform === "win32";
+var AsyncFunction = async function() {
+}.constructor;
+var textDecoder = new TextDecoder();
+var decodeBase64 = (() => {
+  let capturedBuffer = typeof Buffer == "function" ? Buffer : void 0;
+  return capturedBuffer && typeof capturedBuffer.from == "function" ? (base64) => capturedBuffer.from(base64, "base64").toString("utf-8") : (base64) => textDecoder.decode(Uint8Array.from(atob(base64), (c) => c.charCodeAt(0)));
+})();
+var chars2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar2 = /* @__PURE__ */ new Uint8Array(64);
+var charToInt2 = /* @__PURE__ */ new Uint8Array(128);
+for (let i2 = 0; i2 < chars2.length; i2++) {
+  let c = chars2.charCodeAt(i2);
+  intToChar2[i2] = c, charToInt2[c] = i2;
+}
+var MODULE_RUNNER_SOURCEMAPPING_REGEXP = RegExp(`//# ${SOURCEMAPPING_URL}=data:application/json;base64,(.+)`);
+var retrieveFileHandlers = /* @__PURE__ */ new Set();
+var retrieveSourceMapHandlers = /* @__PURE__ */ new Set();
+var createExecHandlers = (handlers) => ((...args) => {
+  for (let handler of handlers) {
+    let result = handler(...args);
+    if (result) return result;
+  }
+  return null;
+});
+var retrieveFileFromHandlers = createExecHandlers(retrieveFileHandlers);
+var retrieveSourceMapFromHandlers = createExecHandlers(retrieveSourceMapHandlers);
+var originalPrepare = Error.prepareStackTrace;
+var customizationHookNamespace = "vite-module-runner:import-meta-resolve/v1/";
+var customizationHooksModule = `
+
+export async function resolve(specifier, context, nextResolve) {
+  if (specifier.startsWith(${JSON.stringify(customizationHookNamespace)})) {
+    const data = specifier.slice(${JSON.stringify(customizationHookNamespace)}.length)
+    const [parsedSpecifier, parsedImporter] = JSON.parse(data)
+    specifier = parsedSpecifier
+    context.parentURL = parsedImporter
+  }
+  return nextResolve(specifier, context)
+}
+
+`;
+var envProxy = new Proxy({}, { get(_, p) {
+  throw Error(`[module runner] Dynamic access of "import.meta.env" is not supported. Please, use "import.meta.env.${String(p)}" instead.`);
+} });
+
+// node_modules/vitest/dist/index.js
+var import_expect_type = __toESM(require_dist(), 1);
+
+// core/testing/criterion.ts
+var stableId = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+var criterionId = /^AC-[A-Z0-9]+(?:-[A-Z0-9]+)*$/;
+function validateRequirements(requirements) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const requirement of requirements) {
+    if (byId.has(requirement.id)) {
+      throw new TestingError([testingDiagnostic(
+        "SH_TEST_REQUIREMENT_DUPLICATE",
+        `Requirement ${requirement.id} is duplicated in testing metadata.`,
+        "Provide one current parsed requirement per stable ID.",
+        requirement.id
+      )]);
+    }
+    byId.set(requirement.id, requirement);
+  }
+  return byId;
+}
+function createRegistry(options) {
+  const requirements = validateRequirements(options.requirements);
+  const register = options.register ?? ((definition) => test2(definition.name, { skip: definition.skip }, definition.fn));
+  const descriptors = /* @__PURE__ */ new Map();
+  return Object.freeze({
+    criterionTest(spec) {
+      const diagnostics = [];
+      const requirement = requirements.get(spec.requirementId);
+      if (!stableId.test(spec.id)) {
+        diagnostics.push(testingDiagnostic(
+          "SH_TEST_ID_INVALID",
+          `Test ID ${spec.id || "<empty>"} is not stable.`,
+          "Use a non-empty ID containing letters, numbers, dots, underscores, or hyphens.",
+          spec.id
+        ));
+      }
+      if (descriptors.has(spec.id)) {
+        diagnostics.push(testingDiagnostic(
+          "SH_TEST_ID_DUPLICATE",
+          `Test ID ${spec.id} is already registered.`,
+          "Give every governed test a globally unique stable ID.",
+          spec.id
+        ));
+      }
+      if (!requirement) {
+        diagnostics.push(testingDiagnostic(
+          "SH_TEST_REQUIREMENT_UNKNOWN",
+          `Test ${spec.id} names unknown requirement ${spec.requirementId}.`,
+          "Use a requirement from the approved parsed inventory.",
+          spec.id
+        ));
+      } else {
+        const approval = requirement.approval;
+        const validApproval = requirement.status !== "draft" && approval?.valid && approval.digest === requirement.governedContentDigest;
+        if (!validApproval) {
+          diagnostics.push(testingDiagnostic(
+            "SH_TEST_REQUIREMENT_NOT_APPROVED",
+            `Requirement ${requirement.id} has ${requirement.status} lifecycle state and no valid current approval for test generation.`,
+            "Obtain exact-content approval for the current requirement and bounded criteria.",
+            requirement.id
+          ));
+        }
+      }
+      if (spec.name.trim() === "") {
+        diagnostics.push(testingDiagnostic(
+          "SH_TEST_NAME_REQUIRED",
+          `Test ${spec.id} has an empty human-readable name.`,
+          "Describe the observable behavior in the test name.",
+          spec.id
+        ));
+      }
+      if (spec.sourcePath.trim() === "") {
+        diagnostics.push(testingDiagnostic(
+          "SH_TEST_SOURCE_REQUIRED",
+          `Test ${spec.id} has no source path.`,
+          "Record the repository-relative test source path.",
+          spec.id
+        ));
+      }
+      if (spec.criteria.length === 0 || spec.criteria.some((id) => !criterionId.test(id))) {
+        diagnostics.push(testingDiagnostic(
+          "SH_TEST_CRITERIA_INVALID",
+          `Test ${spec.id} must name at least one stable acceptance criterion.`,
+          "Use unique IDs such as AC-BOOKMARKS-001.",
+          spec.id
+        ));
+      }
+      if (new Set(spec.criteria).size !== spec.criteria.length) {
+        diagnostics.push(testingDiagnostic(
+          "SH_TEST_CRITERIA_DUPLICATE",
+          `Test ${spec.id} repeats a criterion mapping.`,
+          "List each mapped criterion exactly once.",
+          spec.id
+        ));
+      }
+      if (requirement) {
+        const declared = new Set(requirement.criteria.map((item) => item.id));
+        const approved = new Set(requirement.approval?.criteria ?? []);
+        for (const id of spec.criteria) {
+          if (!declared.has(id) || !approved.has(id)) {
+            diagnostics.push(testingDiagnostic(
+              "SH_TEST_CRITERION_NOT_APPROVED",
+              `Test ${spec.id} maps criterion ${id}, which is not bounded by the current approval.`,
+              "Map only current declared and approved criteria.",
+              spec.id
+            ));
+          }
+        }
+      }
+      if (diagnostics.length > 0) throw new TestingError(diagnostics);
+      const registeredName = `${spec.criteria.join(" ")} \xB7 ${spec.name.trim()}`;
+      const descriptor = Object.freeze({
+        id: spec.id,
+        requirementId: spec.requirementId,
+        criteria: Object.freeze([...spec.criteria]),
+        name: spec.name.trim(),
+        registeredName,
+        sourcePath: spec.sourcePath
+      });
+      register({
+        name: registeredName,
+        fn: spec.fn,
+        skip: spec.ignore
+      });
+      descriptors.set(spec.id, descriptor);
+      return descriptor;
+    },
+    descriptors() {
+      return Object.freeze([...descriptors.values()]);
+    }
+  });
+}
+function manifest(options) {
+  const seen = /* @__PURE__ */ new Set();
+  const tests = options.descriptors.map((descriptor) => {
+    if (seen.has(descriptor.id)) {
+      throw new TestingError([testingDiagnostic(
+        "SH_TEST_ID_DUPLICATE",
+        `Manifest contains duplicate test ID ${descriptor.id}.`,
+        "Give every governed test one globally unique ID.",
+        descriptor.id
+      )]);
+    }
+    seen.add(descriptor.id);
+    const source = options.sources[descriptor.sourcePath];
+    if (source === void 0) {
+      throw new TestingError([testingDiagnostic(
+        "SH_TEST_SOURCE_MISSING",
+        `Manifest cannot read source ${descriptor.sourcePath} for ${descriptor.id}.`,
+        "Provide the exact UTF-8 test source before recording its manifest.",
+        descriptor.id
+      )]);
+    }
+    return Object.freeze({
+      ...descriptor,
+      criteria: Object.freeze([...descriptor.criteria]),
+      sourceDigest: createHash("sha256").update(source, "utf8").digest("hex")
+    });
+  }).sort(
+    (left, right) => left.requirementId.localeCompare(right.requirementId) || left.id.localeCompare(right.id)
+  );
+  return Object.freeze({
+    schema: "sleepy-hollow-test-manifest/v1",
+    tests: Object.freeze(tests)
+  });
+}
+
+// core/testing/red_state.ts
+function redState(options) {
+  const criteria = [...options.requirement.criteria.map((item) => item.id)].sort();
+  const base = {
+    requirementId: options.requirement.id,
+    requirementDigest: options.requirement.governedContentDigest,
+    baselineRevision: options.baselineRevision,
+    runner: options.runner,
+    environment: options.environment,
+    criteria: Object.freeze(criteria),
+    tests: Object.freeze([...options.tests])
+  };
+  const failedBaseline = options.baselineChecks.filter(
+    (check) => check.status === "failed"
+  );
+  if (failedBaseline.length > 0) {
+    return Object.freeze({
+      ...base,
+      kind: "broken-baseline",
+      valid: false,
+      diagnostics: Object.freeze(
+        failedBaseline.map(
+          (check) => testingDiagnostic(
+            "SH_TEST_BASELINE_BROKEN",
+            `Baseline ${check.kind} check ${check.id} failed${check.evidence ? `: ${check.evidence}` : ""}.`,
+            "Repair or isolate the unrelated baseline failure before recording red evidence.",
+            check.id
+          )
+        )
+      )
+    });
+  }
+  const diagnostics = [];
+  const approval = options.requirement.approval;
+  if (options.requirement.status === "draft" || !approval?.valid || approval.digest !== options.requirement.governedContentDigest) {
+    diagnostics.push(testingDiagnostic(
+      "SH_TEST_RED_APPROVAL_INVALID",
+      `Requirement ${options.requirement.id} lacks approval for current content.`,
+      "Obtain current exact-content approval before treating failures as governed red evidence.",
+      options.requirement.id
+    ));
+  }
+  const reached = /* @__PURE__ */ new Set();
+  for (const test3 of options.tests) {
+    if (test3.status !== "failed" || test3.failureKind !== "missing-behavior" || !test3.expectedReason?.trim() || !test3.evidence?.trim() || !test3.testDigest.trim()) {
+      diagnostics.push(testingDiagnostic(
+        "SH_TEST_RED_FAILURE_INVALID",
+        `Test ${test3.testId} did not fail solely for documented missing approved behavior.`,
+        "Separate compile, assertion, permission, startup, dependency, unrelated, passing, and skipped outcomes from expected red evidence.",
+        test3.testId
+      ));
+      continue;
+    }
+    test3.criterionIds.forEach((id) => reached.add(id));
+  }
+  for (const criterion of criteria) {
+    if (!reached.has(criterion)) {
+      diagnostics.push(testingDiagnostic(
+        "SH_TEST_RED_CRITERION_MISSING",
+        `Criterion ${criterion} has no expected missing-behavior failure.`,
+        "Run at least one mapped acceptance test before implementation and record its expected failure.",
+        criterion
+      ));
+    }
+  }
+  return Object.freeze({
+    ...base,
+    kind: diagnostics.length === 0 ? "expected-red" : "invalid-red",
+    valid: diagnostics.length === 0,
+    diagnostics: Object.freeze(diagnostics)
+  });
+}
+
+// core/testing/selection.ts
+var sorted = (values) => [...new Set(values)].sort();
+function selection(options) {
+  const diagnostics = [];
+  const requirements = /* @__PURE__ */ new Map();
+  for (const requirement of options.requirements) {
+    if (requirements.has(requirement.id)) {
+      diagnostics.push(testingDiagnostic(
+        "SH_TEST_SELECTION_REQUIREMENT_DUPLICATE",
+        `Requirement ${requirement.id} is duplicated.`,
+        "Resolve requirement identity before targeted selection.",
+        requirement.id
+      ));
+    }
+    requirements.set(requirement.id, requirement);
+  }
+  const testIds = /* @__PURE__ */ new Set();
+  for (const test3 of options.tests) {
+    if (testIds.has(test3.id)) {
+      diagnostics.push(testingDiagnostic(
+        "SH_TEST_SELECTION_TEST_DUPLICATE",
+        `Test ${test3.id} is duplicated.`,
+        "Resolve test identity before targeted selection.",
+        test3.id
+      ));
+    }
+    testIds.add(test3.id);
+    if (!requirements.has(test3.requirementId)) {
+      diagnostics.push(testingDiagnostic(
+        "SH_TEST_SELECTION_TEST_UNMAPPED",
+        `Test ${test3.id} names unknown requirement ${test3.requirementId}.`,
+        "Map every governed test to a known requirement or run the full suite.",
+        test3.id
+      ));
+    }
+  }
+  for (const target of options.targets) {
+    if (!requirements.has(target)) {
+      diagnostics.push(testingDiagnostic(
+        "SH_TEST_SELECTION_TARGET_UNKNOWN",
+        `Target requirement ${target} is unknown.`,
+        "Choose a requirement from the parsed inventory.",
+        target
+      ));
+    }
+  }
+  for (const requirement of requirements.values()) {
+    for (const dependency of requirement.dependsOn) {
+      if (!requirements.has(dependency)) {
+        diagnostics.push(testingDiagnostic(
+          "SH_TEST_SELECTION_DEPENDENCY_MISSING",
+          `Requirement ${requirement.id} has missing dependency ${dependency}.`,
+          "Resolve the dependency graph before targeted selection.",
+          requirement.id
+        ));
+      }
+    }
+  }
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    if (visited.has(id) || !requirements.has(id)) return;
+    if (visiting.has(id)) {
+      diagnostics.push(testingDiagnostic(
+        "SH_TEST_SELECTION_DEPENDENCY_CYCLE",
+        `Requirement dependency cycle includes ${id}.`,
+        "Resolve the cycle before targeted selection.",
+        id
+      ));
+      return;
+    }
+    visiting.add(id);
+    for (const dependency of requirements.get(id)?.dependsOn ?? []) {
+      visit(dependency);
+    }
+    visiting.delete(id);
+    visited.add(id);
+  };
+  requirements.forEach((_value, id) => visit(id));
+  if (options.hasUnownedSharedChange) {
+    diagnostics.push(testingDiagnostic(
+      "SH_TEST_SELECTION_SHARED_OWNER_UNKNOWN",
+      "A changed shared artifact has no complete requirement ownership mapping.",
+      "Run the full relevant suite and define ownership before future targeting."
+    ));
+  }
+  const allRequirements = sorted(requirements.keys());
+  const allTests = sorted(options.tests.map((test3) => test3.id));
+  if (diagnostics.length > 0 || options.targets.length === 0) {
+    if (options.targets.length === 0) {
+      diagnostics.push(testingDiagnostic(
+        "SH_TEST_SELECTION_TARGET_REQUIRED",
+        "Targeted selection requires at least one requirement ID.",
+        "Name a target or run the full suite explicitly."
+      ));
+    }
+    return Object.freeze({
+      mode: "full",
+      requirementIds: Object.freeze(allRequirements),
+      testIds: Object.freeze(allTests),
+      reasons: Object.freeze(Object.fromEntries(
+        allRequirements.map((id) => [id, Object.freeze(["full-suite-escalation"])])
+      )),
+      diagnostics: Object.freeze(diagnostics)
+    });
+  }
+  const selected = new Set(options.targets);
+  const reasons = /* @__PURE__ */ new Map();
+  options.targets.forEach((id) => reasons.set(id, /* @__PURE__ */ new Set(["target"])));
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const requirement of requirements.values()) {
+      if (selected.has(requirement.id)) {
+        for (const dependency of requirement.dependsOn) {
+          if (!selected.has(dependency)) changed = true;
+          selected.add(dependency);
+          const current = reasons.get(dependency) ?? /* @__PURE__ */ new Set();
+          current.add(`dependency-of:${requirement.id}`);
+          reasons.set(dependency, current);
+        }
+      }
+      if (!selected.has(requirement.id) && requirement.dependsOn.some((dependency) => selected.has(dependency))) {
+        selected.add(requirement.id);
+        changed = true;
+        const current = reasons.get(requirement.id) ?? /* @__PURE__ */ new Set();
+        for (const dependency of requirement.dependsOn) {
+          if (selected.has(dependency)) {
+            current.add(`dependent-of:${dependency}`);
+          }
+        }
+        reasons.set(requirement.id, current);
+      }
+    }
+  }
+  const requirementIds = sorted(selected);
+  const selectedTests = sorted(
+    options.tests.filter((test3) => selected.has(test3.requirementId)).map((test3) => test3.id)
+  );
+  return Object.freeze({
+    mode: "targeted",
+    requirementIds: Object.freeze(requirementIds),
+    testIds: Object.freeze(selectedTests),
+    reasons: Object.freeze(Object.fromEntries(
+      requirementIds.map((id) => [id, Object.freeze(sorted(reasons.get(id) ?? []))])
+    )),
+    diagnostics: Object.freeze([])
+  });
+}
+
+// core/testing/traceability.ts
+var sorted2 = (values) => [...new Set(values)].sort();
+function traceability(options) {
+  const requirements = new Map(
+    options.requirements.map((requirement) => [requirement.id, requirement])
+  );
+  const results = new Map(
+    options.results.map((result) => [result.testId, result])
+  );
+  const testsByCriterion = /* @__PURE__ */ new Map();
+  const unmappedTests = [];
+  for (const test3 of options.manifest.tests) {
+    const requirement = requirements.get(test3.requirementId);
+    const approved = new Set(requirement?.approval?.criteria ?? []);
+    let mapped = Boolean(requirement && test3.criteria.length > 0);
+    for (const id of test3.criteria) {
+      if (!approved.has(id)) mapped = false;
+      const key = `${test3.requirementId}\0${id}`;
+      const current2 = testsByCriterion.get(key) ?? [];
+      current2.push(test3.id);
+      testsByCriterion.set(key, current2);
+    }
+    if (!mapped) unmappedTests.push(test3.id);
+  }
+  const traces = [];
+  for (const requirement of [...options.requirements].sort(
+    (left, right) => left.id.localeCompare(right.id)
+  )) {
+    for (const criterion of [...requirement.criteria].sort(
+      (left, right) => left.id.localeCompare(right.id)
+    )) {
+      const testIds = sorted2(
+        testsByCriterion.get(`${requirement.id}\0${criterion.id}`) ?? []
+      );
+      const statuses = testIds.map(
+        (id) => results.get(id)?.status ?? "skipped"
+      );
+      const status = testIds.length === 0 ? "unmapped" : statuses.includes("failed") ? "failing" : statuses.includes("skipped") ? "skipped" : "passing";
+      traces.push(Object.freeze({
+        requirementId: requirement.id,
+        criterionId: criterion.id,
+        testIds: Object.freeze(testIds),
+        status
+      }));
+    }
+  }
+  const previous = new Map(
+    (options.previousManifest?.tests ?? []).map((test3) => [test3.id, test3])
+  );
+  const current = new Map(
+    options.manifest.tests.map((test3) => [test3.id, test3])
+  );
+  const reviewed = new Set(options.reviewedTestIds ?? []);
+  const removedTests = sorted2(
+    [...previous.keys()].filter((id) => !current.has(id))
+  );
+  const changedTests = sorted2(
+    [...current].filter(([id, test3]) => {
+      const prior = previous.get(id);
+      return prior && prior.sourceDigest !== test3.sourceDigest && !reviewed.has(id);
+    }).map(([id]) => id)
+  );
+  const weakenedMappings = sorted2(
+    [...current].filter(([id, test3]) => {
+      const prior = previous.get(id);
+      if (!prior) return false;
+      const mappings = new Set(test3.criteria);
+      return prior.criteria.some((criterion) => !mappings.has(criterion));
+    }).map(([id]) => id)
+  );
+  const passingCriteria = traces.filter((item) => item.status === "passing").map(
+    (item) => item.criterionId
+  );
+  const failingCriteria = traces.filter((item) => item.status === "failing").map(
+    (item) => item.criterionId
+  );
+  const skippedCriteria = traces.filter((item) => item.status === "skipped").map(
+    (item) => item.criterionId
+  );
+  const unmappedCriteria = traces.filter((item) => item.status === "unmapped").map(
+    (item) => item.criterionId
+  );
+  const eligibleForVerification = traces.length > 0 && traces.every((item) => item.status === "passing") && unmappedTests.length === 0 && removedTests.length === 0 && changedTests.length === 0 && weakenedMappings.length === 0;
+  return Object.freeze({
+    schema: "sleepy-hollow-traceability/v1",
+    criteria: Object.freeze(traces),
+    passingCriteria: Object.freeze(passingCriteria),
+    failingCriteria: Object.freeze(failingCriteria),
+    skippedCriteria: Object.freeze(skippedCriteria),
+    unmappedCriteria: Object.freeze(unmappedCriteria),
+    unmappedTests: Object.freeze(sorted2(unmappedTests)),
+    removedTests: Object.freeze(removedTests),
+    changedTests: Object.freeze(changedTests),
+    weakenedMappings: Object.freeze(weakenedMappings),
+    eligibleForVerification
+  });
+}
+
+// core/testing/mod.ts
+function createCriterionRegistry(options) {
+  return createRegistry(options);
+}
+function criterionTest(spec, options) {
+  return createRegistry(options).criterionTest(spec);
+}
+function createTestManifest(options) {
+  return manifest(options);
+}
+function createTraceabilityReport(options) {
+  return traceability(options);
+}
+function classifyRedState(options) {
+  return redState(options);
+}
+function createTestApplication(options) {
+  return testApplication(options);
+}
+function assertProblem(response, expectation) {
+  return problem(response, expectation);
+}
+function selectAffectedTests(options) {
+  return selection(options);
+}
+
+export {
+  TestingError,
+  createCriterionRegistry,
+  criterionTest,
+  createTestManifest,
+  createTraceabilityReport,
+  classifyRedState,
+  createTestApplication,
+  assertProblem,
+  selectAffectedTests
+};
+/*! Bundled license information:
+
+@vitest/pretty-format/dist/index.js:
+  (**
+   * @license React
+   * react-is.production.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+  (**
+   * @license React
+   * react-is.production.min.js
+   *
+   * Copyright (c) Facebook, Inc. and its affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+*/
+//# sourceMappingURL=chunk-D4U3ZY4O.js.map