@noma.to/qwik-testing-library 1.0.4 → 1.2.0

package/lib/node_modules/.pnpm/@vitest_snapshot@2.1.1/node_modules/@vitest/snapshot/dist/index.qwik.mjs

@@ -0,0 +1,1641 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { format, plugins } from "../../../../../@vitest_pretty-format@2.1.1/node_modules/@vitest/pretty-format/dist/index.qwik.mjs";
+import { r as resolve$2 } from "../../../../../pathe@1.1.2/node_modules/pathe/dist/shared/pathe.ff20891b.qwik.mjs";
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var naturalCompare$2 = { exports: {} };
+/*
+ * @version    1.4.0
+ * @date       2015-10-26
+ * @stability  3 - Stable
+ * @author     Lauri Rooden (https://github.com/litejs/natural-compare-lite)
+ * @license    MIT License
+ */
+var naturalCompare = function(a2, b) {
+  var i, codeA, codeB = 1, posA = 0, posB = 0, alphabet = String.alphabet;
+  function getCode(str, pos, code) {
+    if (code) {
+      for (i = pos; code = getCode(str, i), code < 76 && code > 65; ) ++i;
+      return +str.slice(pos - 1, i);
+    }
+    code = alphabet && alphabet.indexOf(str.charAt(pos));
+    return code > -1 ? code + 76 : (code = str.charCodeAt(pos) || 0, code < 45 || code > 127) ? code : code < 46 ? 65 : code < 48 ? code - 1 : code < 58 ? code + 18 : code < 65 ? code - 11 : code < 91 ? code + 11 : code < 97 ? code - 37 : code < 123 ? code + 5 : code - 63;
+  }
+  if ((a2 += "") != (b += "")) for (; codeB; ) {
+    codeA = getCode(a2, posA++);
+    codeB = getCode(b, posB++);
+    if (codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66) {
+      codeA = getCode(a2, posA, posA);
+      codeB = getCode(b, posB, posA = i);
+      posB = i;
+    }
+    if (codeA != codeB) return codeA < codeB ? -1 : 1;
+  }
+  return 0;
+};
+try {
+  naturalCompare$2.exports = naturalCompare;
+} catch (e) {
+  String.naturalCompare = naturalCompare;
+}
+var naturalCompareExports = naturalCompare$2.exports;
+var naturalCompare$1 = /* @__PURE__ */ getDefaultExportFromCjs(naturalCompareExports);
+function notNullish(v) {
+  return v != null;
+}
+function isPrimitive(value) {
+  return value === null || typeof value !== "function" && typeof value !== "object";
+}
+function isObject(item) {
+  return item != null && typeof item === "object" && !Array.isArray(item);
+}
+function getCallLastIndex(code) {
+  let charIndex = -1;
+  let inString = null;
+  let startedBracers = 0;
+  let endedBracers = 0;
+  let beforeChar = null;
+  while (charIndex <= code.length) {
+    beforeChar = code[charIndex];
+    charIndex++;
+    const char = code[charIndex];
+    const isCharString = char === '"' || char === "'" || char === "`";
+    if (isCharString && beforeChar !== "\\") {
+      if (inString === char) {
+        inString = null;
+      } else if (!inString) {
+        inString = char;
+      }
+    }
+    if (!inString) {
+      if (char === "(") {
+        startedBracers++;
+      }
+      if (char === ")") {
+        endedBracers++;
+      }
+    }
+    if (startedBracers && endedBracers && startedBracers === endedBracers) {
+      return charIndex;
+    }
+  }
+  return null;
+}
+let getPromiseValue = () => "Promise{…}";
+try {
+  const { getPromiseDetails, kPending, kRejected } = process.binding("util");
+  if (Array.isArray(getPromiseDetails(Promise.resolve()))) {
+    getPromiseValue = (value, options) => {
+      const [state, innerValue] = getPromiseDetails(value);
+      if (state === kPending) {
+        return "Promise{<pending>}";
+      }
+      return `Promise${state === kRejected ? "!" : ""}{${options.inspect(innerValue, options)}}`;
+    };
+  }
+} catch (notNode) {
+}
+let nodeInspect = false;
+try {
+  const nodeUtil = require("util");
+  nodeInspect = nodeUtil.inspect ? nodeUtil.inspect.custom : false;
+} catch (noNodeInspect) {
+  nodeInspect = false;
+}
+const lineSplitRE = /\r?\n/;
+function positionToOffset(source, lineNumber, columnNumber) {
+  const lines = source.split(lineSplitRE);
+  const nl = /\r\n/.test(source) ? 2 : 1;
+  let start = 0;
+  if (lineNumber > lines.length) {
+    return source.length;
+  }
+  for (let i = 0; i < lineNumber - 1; i++) {
+    start += lines[i].length + nl;
+  }
+  return start + columnNumber;
+}
+function offsetToLineNumber(source, offset) {
+  if (offset > source.length) {
+    throw new Error(
+      `offset is longer than source length! offset ${offset} > length ${source.length}`
+    );
+  }
+  const lines = source.split(lineSplitRE);
+  const nl = /\r\n/.test(source) ? 2 : 1;
+  let counted = 0;
+  let line = 0;
+  for (; line < lines.length; line++) {
+    const lineLength = lines[line].length + nl;
+    if (counted + lineLength >= offset) {
+      break;
+    }
+    counted += lineLength;
+  }
+  return line + 1;
+}
+var LineTerminatorSequence;
+LineTerminatorSequence = /\r?\n|[\r\u2028\u2029]/y;
+RegExp(LineTerminatorSequence.source);
+var reservedWords = {
+  keyword: [
+    "break",
+    "case",
+    "catch",
+    "continue",
+    "debugger",
+    "default",
+    "do",
+    "else",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "return",
+    "switch",
+    "throw",
+    "try",
+    "var",
+    "const",
+    "while",
+    "with",
+    "new",
+    "this",
+    "super",
+    "class",
+    "extends",
+    "export",
+    "import",
+    "null",
+    "true",
+    "false",
+    "in",
+    "instanceof",
+    "typeof",
+    "void",
+    "delete"
+  ],
+  strict: [
+    "implements",
+    "interface",
+    "let",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "static",
+    "yield"
+  ]
+};
+new Set(reservedWords.keyword);
+new Set(reservedWords.strict);
+var f = {
+  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]
+}, h = Object.entries(f);
+function a(n) {
+  return String(n);
+}
+a.open = "";
+a.close = "";
+function C(n = false) {
+  let e = typeof process != "undefined" ? process : void 0, i = (e == null ? void 0 : e.env) || {}, g = (e == null ? void 0 : e.argv) || [];
+  return !("NO_COLOR" in i || g.includes("--no-color")) && ("FORCE_COLOR" in i || g.includes("--color") || (e == null ? void 0 : e.platform) === "win32" || n && i.TERM !== "dumb" || "CI" in i) || typeof window != "undefined" && !!window.chrome;
+}
+function p(n = false) {
+  let e = C(n), i = (r, t, c, o) => {
+    let l = "", s = 0;
+    do
+      l += r.substring(s, o) + c, s = o + t.length, o = r.indexOf(t, s);
+    while (~o);
+    return l + r.substring(s);
+  }, g = (r, t, c = r) => {
+    let o = (l) => {
+      let s = String(l), b = s.indexOf(t, r.length);
+      return ~b ? r + i(s, t, c, b) + t : r + s + t;
+    };
+    return o.open = r, o.close = t, o;
+  }, u = {
+    isColorSupported: e
+  }, d = (r) => `\x1B[${r}m`;
+  for (let [r, t] of h)
+    u[r] = e ? g(
+      d(t[0]),
+      d(t[1]),
+      t[2]
+    ) : a;
+  return u;
+}
+p(false);
+const serialize$1 = (val, config, indentation, depth, refs, printer) => {
+  const name = val.getMockName();
+  const nameString = name === "vi.fn()" ? "" : ` ${name}`;
+  let callsString = "";
+  if (val.mock.calls.length !== 0) {
+    const indentationNext = indentation + config.indent;
+    callsString = ` {${config.spacingOuter}${indentationNext}"calls": ${printer(
+      val.mock.calls,
+      config,
+      indentationNext,
+      depth,
+      refs
+    )}${config.min ? ", " : ","}${config.spacingOuter}${indentationNext}"results": ${printer(
+      val.mock.results,
+      config,
+      indentationNext,
+      depth,
+      refs
+    )}${config.min ? "" : ","}${config.spacingOuter}${indentation}}`;
+  }
+  return `[MockFunction${nameString}]${callsString}`;
+};
+const test = (val) => val && !!val._isMockFunction;
+const plugin = { serialize: serialize$1, test };
+const {
+  DOMCollection,
+  DOMElement,
+  Immutable,
+  ReactElement,
+  ReactTestComponent,
+  AsymmetricMatcher
+} = plugins;
+let PLUGINS = [
+  ReactTestComponent,
+  ReactElement,
+  DOMElement,
+  DOMCollection,
+  Immutable,
+  AsymmetricMatcher,
+  plugin
+];
+function addSerializer(plugin2) {
+  PLUGINS = [plugin2].concat(PLUGINS);
+}
+function getSerializers() {
+  return PLUGINS;
+}
+function testNameToKey(testName, count) {
+  return `${testName} ${count}`;
+}
+function keyToTestName(key) {
+  if (!/ \d+$/.test(key)) {
+    throw new Error("Snapshot keys must end with a number.");
+  }
+  return key.replace(/ \d+$/, "");
+}
+function getSnapshotData(content, options) {
+  const update = options.updateSnapshot;
+  const data = /* @__PURE__ */ Object.create(null);
+  let snapshotContents = "";
+  let dirty = false;
+  if (content != null) {
+    try {
+      snapshotContents = content;
+      const populate = new Function("exports", snapshotContents);
+      populate(data);
+    } catch {
+    }
+  }
+  const isInvalid = snapshotContents;
+  if ((update === "all" || update === "new") && isInvalid) {
+    dirty = true;
+  }
+  return { data, dirty };
+}
+function addExtraLineBreaks(string) {
+  return string.includes("\n") ? `
+${string}
+` : string;
+}
+function removeExtraLineBreaks(string) {
+  return string.length > 2 && string.startsWith("\n") && string.endsWith("\n") ? string.slice(1, -1) : string;
+}
+const escapeRegex = true;
+const printFunctionName = false;
+function serialize(val, indent = 2, formatOverrides = {}) {
+  return normalizeNewlines(
+    format(val, {
+      escapeRegex,
+      indent,
+      plugins: getSerializers(),
+      printFunctionName,
+      ...formatOverrides
+    })
+  );
+}
+function escapeBacktickString(str) {
+  return str.replace(/`|\\|\$\{/g, "\\$&");
+}
+function printBacktickString(str) {
+  return `\`${escapeBacktickString(str)}\``;
+}
+function normalizeNewlines(string) {
+  return string.replace(/\r\n|\r/g, "\n");
+}
+async function saveSnapshotFile(environment, snapshotData, snapshotPath) {
+  const snapshots = Object.keys(snapshotData).sort(naturalCompare$1).map(
+    (key) => `exports[${printBacktickString(key)}] = ${printBacktickString(
+      normalizeNewlines(snapshotData[key])
+    )};`
+  );
+  const content = `${environment.getHeader()}
+
+${snapshots.join("\n\n")}
+`;
+  const oldContent = await environment.readSnapshotFile(snapshotPath);
+  const skipWriting = oldContent != null && oldContent === content;
+  if (skipWriting) {
+    return;
+  }
+  await environment.saveSnapshotFile(snapshotPath, content);
+}
+function prepareExpected(expected) {
+  function findStartIndent() {
+    var _a, _b;
+    const matchObject = /^( +)\}\s+$/m.exec(expected || "");
+    const objectIndent = (_a = matchObject == null ? void 0 : matchObject[1]) == null ? void 0 : _a.length;
+    if (objectIndent) {
+      return objectIndent;
+    }
+    const matchText = /^\n( +)"/.exec(expected || "");
+    return ((_b = matchText == null ? void 0 : matchText[1]) == null ? void 0 : _b.length) || 0;
+  }
+  const startIndent = findStartIndent();
+  let expectedTrimmed = expected == null ? void 0 : expected.trim();
+  if (startIndent) {
+    expectedTrimmed = expectedTrimmed == null ? void 0 : expectedTrimmed.replace(new RegExp(`^${" ".repeat(startIndent)}`, "gm"), "").replace(/ +\}$/, "}");
+  }
+  return expectedTrimmed;
+}
+function deepMergeArray(target = [], source = []) {
+  const mergedOutput = Array.from(target);
+  source.forEach((sourceElement, index) => {
+    const targetElement = mergedOutput[index];
+    if (Array.isArray(target[index])) {
+      mergedOutput[index] = deepMergeArray(target[index], sourceElement);
+    } else if (isObject(targetElement)) {
+      mergedOutput[index] = deepMergeSnapshot(target[index], sourceElement);
+    } else {
+      mergedOutput[index] = sourceElement;
+    }
+  });
+  return mergedOutput;
+}
+function deepMergeSnapshot(target, source) {
+  if (isObject(target) && isObject(source)) {
+    const mergedOutput = { ...target };
+    Object.keys(source).forEach((key) => {
+      if (isObject(source[key]) && !source[key].$$typeof) {
+        if (!(key in target)) {
+          Object.assign(mergedOutput, { [key]: source[key] });
+        } else {
+          mergedOutput[key] = deepMergeSnapshot(target[key], source[key]);
+        }
+      } else if (Array.isArray(source[key])) {
+        mergedOutput[key] = deepMergeArray(target[key], source[key]);
+      } else {
+        Object.assign(mergedOutput, { [key]: source[key] });
+      }
+    });
+    return mergedOutput;
+  } else if (Array.isArray(target) && Array.isArray(source)) {
+    return deepMergeArray(target, source);
+  }
+  return target;
+}
+const comma = ",".charCodeAt(0);
+const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const intToChar = new Uint8Array(64);
+const charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c;
+  charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+  let value = 0;
+  let shift = 0;
+  let integer = 0;
+  do {
+    const c = reader.next();
+    integer = charToInt[c];
+    value |= (integer & 31) << shift;
+    shift += 5;
+  } while (integer & 32);
+  const shouldNegate = value & 1;
+  value >>>= 1;
+  if (shouldNegate) {
+    value = -2147483648 | -value;
+  }
+  return relative + value;
+}
+function hasMoreVlq(reader, max) {
+  if (reader.pos >= max)
+    return false;
+  return reader.peek() !== comma;
+}
+class StringReader {
+  constructor(buffer) {
+    this.pos = 0;
+    this.buffer = buffer;
+  }
+  next() {
+    return this.buffer.charCodeAt(this.pos++);
+  }
+  peek() {
+    return this.buffer.charCodeAt(this.pos);
+  }
+  indexOf(char) {
+    const { buffer, pos } = this;
+    const idx = buffer.indexOf(char, pos);
+    return idx === -1 ? buffer.length : idx;
+  }
+}
+function decode(mappings) {
+  const { length } = mappings;
+  const reader = new StringReader(mappings);
+  const decoded = [];
+  let genColumn = 0;
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  do {
+    const semi = reader.indexOf(";");
+    const line = [];
+    let sorted = true;
+    let lastCol = 0;
+    genColumn = 0;
+    while (reader.pos < semi) {
+      let seg;
+      genColumn = decodeInteger(reader, genColumn);
+      if (genColumn < lastCol)
+        sorted = false;
+      lastCol = genColumn;
+      if (hasMoreVlq(reader, semi)) {
+        sourcesIndex = decodeInteger(reader, sourcesIndex);
+        sourceLine = decodeInteger(reader, sourceLine);
+        sourceColumn = decodeInteger(reader, sourceColumn);
+        if (hasMoreVlq(reader, semi)) {
+          namesIndex = decodeInteger(reader, namesIndex);
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+        } else {
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+        }
+      } else {
+        seg = [genColumn];
+      }
+      line.push(seg);
+      reader.pos++;
+    }
+    if (!sorted)
+      sort(line);
+    decoded.push(line);
+    reader.pos = semi + 1;
+  } while (reader.pos <= length);
+  return decoded;
+}
+function sort(line) {
+  line.sort(sortComparator$1);
+}
+function sortComparator$1(a2, b) {
+  return a2[0] - b[0];
+}
+const schemeRegex = /^[\w+.-]+:\/\//;
+const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+var UrlType;
+(function(UrlType2) {
+  UrlType2[UrlType2["Empty"] = 1] = "Empty";
+  UrlType2[UrlType2["Hash"] = 2] = "Hash";
+  UrlType2[UrlType2["Query"] = 3] = "Query";
+  UrlType2[UrlType2["RelativePath"] = 4] = "RelativePath";
+  UrlType2[UrlType2["AbsolutePath"] = 5] = "AbsolutePath";
+  UrlType2[UrlType2["SchemeRelative"] = 6] = "SchemeRelative";
+  UrlType2[UrlType2["Absolute"] = 7] = "Absolute";
+})(UrlType || (UrlType = {}));
+function isAbsoluteUrl(input) {
+  return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+  return input.startsWith("//");
+}
+function isAbsolutePath(input) {
+  return input.startsWith("/");
+}
+function isFileUrl(input) {
+  return input.startsWith("file:");
+}
+function isRelative(input) {
+  return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+  const match = urlRegex.exec(input);
+  return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+}
+function parseFileUrl(input) {
+  const match = fileRegex.exec(input);
+  const path = match[2];
+  return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path) ? path : "/" + path, match[3] || "", match[4] || "");
+}
+function makeUrl(scheme, user, host, port, path, query, hash) {
+  return {
+    scheme,
+    user,
+    host,
+    port,
+    path,
+    query,
+    hash,
+    type: UrlType.Absolute
+  };
+}
+function parseUrl(input) {
+  if (isSchemeRelativeUrl(input)) {
+    const url2 = parseAbsoluteUrl("http:" + input);
+    url2.scheme = "";
+    url2.type = UrlType.SchemeRelative;
+    return url2;
+  }
+  if (isAbsolutePath(input)) {
+    const url2 = parseAbsoluteUrl("http://foo.com" + input);
+    url2.scheme = "";
+    url2.host = "";
+    url2.type = UrlType.AbsolutePath;
+    return url2;
+  }
+  if (isFileUrl(input))
+    return parseFileUrl(input);
+  if (isAbsoluteUrl(input))
+    return parseAbsoluteUrl(input);
+  const url = parseAbsoluteUrl("http://foo.com/" + input);
+  url.scheme = "";
+  url.host = "";
+  url.type = input ? input.startsWith("?") ? UrlType.Query : input.startsWith("#") ? UrlType.Hash : UrlType.RelativePath : UrlType.Empty;
+  return url;
+}
+function stripPathFilename(path) {
+  if (path.endsWith("/.."))
+    return path;
+  const index = path.lastIndexOf("/");
+  return path.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+  normalizePath(base, base.type);
+  if (url.path === "/") {
+    url.path = base.path;
+  } else {
+    url.path = stripPathFilename(base.path) + url.path;
+  }
+}
+function normalizePath(url, type) {
+  const rel = type <= UrlType.RelativePath;
+  const pieces = url.path.split("/");
+  let pointer = 1;
+  let positive = 0;
+  let addTrailingSlash = false;
+  for (let i = 1; i < pieces.length; i++) {
+    const piece = pieces[i];
+    if (!piece) {
+      addTrailingSlash = true;
+      continue;
+    }
+    addTrailingSlash = false;
+    if (piece === ".")
+      continue;
+    if (piece === "..") {
+      if (positive) {
+        addTrailingSlash = true;
+        positive--;
+        pointer--;
+      } else if (rel) {
+        pieces[pointer++] = piece;
+      }
+      continue;
+    }
+    pieces[pointer++] = piece;
+    positive++;
+  }
+  let path = "";
+  for (let i = 1; i < pointer; i++) {
+    path += "/" + pieces[i];
+  }
+  if (!path || addTrailingSlash && !path.endsWith("/..")) {
+    path += "/";
+  }
+  url.path = path;
+}
+function resolve$1(input, base) {
+  if (!input && !base)
+    return "";
+  const url = parseUrl(input);
+  let inputType = url.type;
+  if (base && inputType !== UrlType.Absolute) {
+    const baseUrl = parseUrl(base);
+    const baseType = baseUrl.type;
+    switch (inputType) {
+      case UrlType.Empty:
+        url.hash = baseUrl.hash;
+      case UrlType.Hash:
+        url.query = baseUrl.query;
+      case UrlType.Query:
+      case UrlType.RelativePath:
+        mergePaths(url, baseUrl);
+      case UrlType.AbsolutePath:
+        url.user = baseUrl.user;
+        url.host = baseUrl.host;
+        url.port = baseUrl.port;
+      case UrlType.SchemeRelative:
+        url.scheme = baseUrl.scheme;
+    }
+    if (baseType > inputType)
+      inputType = baseType;
+  }
+  normalizePath(url, inputType);
+  const queryHash = url.query + url.hash;
+  switch (inputType) {
+    case UrlType.Hash:
+    case UrlType.Query:
+      return queryHash;
+    case UrlType.RelativePath: {
+      const path = url.path.slice(1);
+      if (!path)
+        return queryHash || ".";
+      if (isRelative(base || input) && !isRelative(path)) {
+        return "./" + path + queryHash;
+      }
+      return path + queryHash;
+    }
+    case UrlType.AbsolutePath:
+      return url.path + queryHash;
+    default:
+      return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
+  }
+}
+function resolve(input, base) {
+  if (base && !base.endsWith("/"))
+    base += "/";
+  return resolve$1(input, base);
+}
+function stripFilename(path) {
+  if (!path)
+    return "";
+  const index = path.lastIndexOf("/");
+  return path.slice(0, index + 1);
+}
+const COLUMN = 0;
+const SOURCES_INDEX = 1;
+const SOURCE_LINE = 2;
+const SOURCE_COLUMN = 3;
+const NAMES_INDEX = 4;
+function maybeSort(mappings, owned) {
+  const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+  if (unsortedIndex === mappings.length)
+    return mappings;
+  if (!owned)
+    mappings = mappings.slice();
+  for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
+    mappings[i] = sortSegments(mappings[i], owned);
+  }
+  return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+  for (let i = start; i < mappings.length; i++) {
+    if (!isSorted(mappings[i]))
+      return i;
+  }
+  return mappings.length;
+}
+function isSorted(line) {
+  for (let j = 1; j < line.length; j++) {
+    if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+      return false;
+    }
+  }
+  return true;
+}
+function sortSegments(line, owned) {
+  if (!owned)
+    line = line.slice();
+  return line.sort(sortComparator);
+}
+function sortComparator(a2, b) {
+  return a2[COLUMN] - b[COLUMN];
+}
+let found = false;
+function binarySearch(haystack, needle, low, high) {
+  while (low <= high) {
+    const mid = low + (high - low >> 1);
+    const cmp = haystack[mid][COLUMN] - needle;
+    if (cmp === 0) {
+      found = true;
+      return mid;
+    }
+    if (cmp < 0) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  found = false;
+  return low - 1;
+}
+function upperBound(haystack, needle, index) {
+  for (let i = index + 1; i < haystack.length; index = i++) {
+    if (haystack[i][COLUMN] !== needle)
+      break;
+  }
+  return index;
+}
+function lowerBound(haystack, needle, index) {
+  for (let i = index - 1; i >= 0; index = i--) {
+    if (haystack[i][COLUMN] !== needle)
+      break;
+  }
+  return index;
+}
+function memoizedState() {
+  return {
+    lastKey: -1,
+    lastNeedle: -1,
+    lastIndex: -1
+  };
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+  const { lastKey, lastNeedle, lastIndex } = state;
+  let low = 0;
+  let high = haystack.length - 1;
+  if (key === lastKey) {
+    if (needle === lastNeedle) {
+      found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+      return lastIndex;
+    }
+    if (needle >= lastNeedle) {
+      low = lastIndex === -1 ? 0 : lastIndex;
+    } else {
+      high = lastIndex;
+    }
+  }
+  state.lastKey = key;
+  state.lastNeedle = needle;
+  return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+const LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+const COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+const LEAST_UPPER_BOUND = -1;
+const GREATEST_LOWER_BOUND = 1;
+class TraceMap {
+  constructor(map, mapUrl) {
+    const isString = typeof map === "string";
+    if (!isString && map._decodedMemo)
+      return map;
+    const parsed = isString ? JSON.parse(map) : map;
+    const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+    this.version = version;
+    this.file = file;
+    this.names = names || [];
+    this.sourceRoot = sourceRoot;
+    this.sources = sources;
+    this.sourcesContent = sourcesContent;
+    this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+    const from = resolve(sourceRoot || "", stripFilename(mapUrl));
+    this.resolvedSources = sources.map((s) => resolve(s || "", from));
+    const { mappings } = parsed;
+    if (typeof mappings === "string") {
+      this._encoded = mappings;
+      this._decoded = void 0;
+    } else {
+      this._encoded = void 0;
+      this._decoded = maybeSort(mappings, isString);
+    }
+    this._decodedMemo = memoizedState();
+    this._bySources = void 0;
+    this._bySourceMemos = void 0;
+  }
+}
+function cast(map) {
+  return map;
+}
+function decodedMappings(map) {
+  var _a;
+  return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+function originalPositionFor(map, needle) {
+  let { line, column, bias } = needle;
+  line--;
+  if (line < 0)
+    throw new Error(LINE_GTR_ZERO);
+  if (column < 0)
+    throw new Error(COL_GTR_EQ_ZERO);
+  const decoded = decodedMappings(map);
+  if (line >= decoded.length)
+    return OMapping(null, null, null, null);
+  const segments = decoded[line];
+  const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+  if (index === -1)
+    return OMapping(null, null, null, null);
+  const segment = segments[index];
+  if (segment.length === 1)
+    return OMapping(null, null, null, null);
+  const { names, resolvedSources } = map;
+  return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+}
+function OMapping(source, line, column, name) {
+  return { source, line, column, name };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+  let index = memoizedBinarySearch(segments, column, memo, line);
+  if (found) {
+    index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+  } else if (bias === LEAST_UPPER_BOUND)
+    index++;
+  if (index === -1 || index === segments.length)
+    return -1;
+  return index;
+}
+const CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m;
+const SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
+const stackIgnorePatterns = [
+  "node:internal",
+  /\/packages\/\w+\/dist\//,
+  /\/@vitest\/\w+\/dist\//,
+  "/vitest/dist/",
+  "/vitest/src/",
+  "/vite-node/dist/",
+  "/vite-node/src/",
+  "/node_modules/chai/",
+  "/node_modules/tinypool/",
+  "/node_modules/tinyspy/",
+  // browser related deps
+  "/deps/chunk-",
+  "/deps/@vitest",
+  "/deps/loupe",
+  "/deps/chai",
+  /node:\w+/,
+  /__vitest_test__/,
+  /__vitest_browser__/,
+  /\/deps\/vitest_/
+];
+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);
+    url = urlObj.pathname;
+  }
+  if (url.startsWith("/@fs/")) {
+    const isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url);
+    url = url.slice(isWindows ? 5 : 4);
+  }
+  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("@") && !line.includes(":")) {
+    return null;
+  }
+  const functionNameRegex = /((.*".+"[^@]*)?[^@]*)(@)/;
+  const matches = line.match(functionNameRegex);
+  const functionName = matches && matches[1] ? matches[1] : void 0;
+  const [url, lineNumber, columnNumber] = extractLocation(
+    line.replace(functionNameRegex, "")
+  );
+  if (!url || !lineNumber || !columnNumber) {
+    return null;
+  }
+  return {
+    file: url,
+    method: functionName || "",
+    line: Number.parseInt(lineNumber),
+    column: Number.parseInt(columnNumber)
+  };
+}
+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 = resolve$2(file);
+  if (method) {
+    method = method.replace(/__vite_ssr_import_\d+__\./g, "");
+  }
+  return {
+    method,
+    file,
+    line: Number.parseInt(lineNumber),
+    column: Number.parseInt(columnNumber)
+  };
+}
+function parseStacktrace(stack, options = {}) {
+  const { ignoreStackEntries = stackIgnorePatterns } = options;
+  let stacks = !CHROME_IE_STACK_REGEXP.test(stack) ? parseFFOrSafariStackTrace(stack) : parseV8Stacktrace(stack);
+  if (ignoreStackEntries.length) {
+    stacks = stacks.filter(
+      (stack2) => !ignoreStackEntries.some((p2) => stack2.file.match(p2))
+    );
+  }
+  return stacks.map((stack2) => {
+    var _a;
+    if (options.getFileName) {
+      stack2.file = options.getFileName(stack2.file);
+    }
+    const map = (_a = options.getSourceMap) == null ? void 0 : _a.call(options, stack2.file);
+    if (!map || typeof map !== "object" || !map.version) {
+      return stack2;
+    }
+    const traceMap = new TraceMap(map);
+    const { line, column } = originalPositionFor(traceMap, stack2);
+    if (line != null && column != null) {
+      return { ...stack2, line, column };
+    }
+    return stack2;
+  });
+}
+function parseFFOrSafariStackTrace(stack) {
+  return stack.split("\n").map((line) => parseSingleFFOrSafariStack(line)).filter(notNullish);
+}
+function parseV8Stacktrace(stack) {
+  return stack.split("\n").map((line) => parseSingleV8Stack(line)).filter(notNullish);
+}
+function parseErrorStacktrace(e, options = {}) {
+  if (!e || isPrimitive(e)) {
+    return [];
+  }
+  if (e.stacks) {
+    return e.stacks;
+  }
+  const stackStr = e.stack || e.stackStr || "";
+  let stackFrames = parseStacktrace(stackStr, options);
+  if (options.frameFilter) {
+    stackFrames = stackFrames.filter(
+      (f2) => options.frameFilter(e, f2) !== false
+    );
+  }
+  e.stacks = stackFrames;
+  return stackFrames;
+}
+async function saveInlineSnapshots(environment, snapshots) {
+  const MagicString = (await import("../../../../../magic-string@0.30.11/node_modules/magic-string/dist/magic-string.es.qwik.mjs")).default;
+  const files = new Set(snapshots.map((i) => i.file));
+  await Promise.all(
+    Array.from(files).map(async (file) => {
+      const snaps = snapshots.filter((i) => i.file === file);
+      const code = await environment.readSnapshotFile(file);
+      const s = new MagicString(code);
+      for (const snap of snaps) {
+        const index = positionToOffset(code, snap.line, snap.column);
+        replaceInlineSnap(code, s, index, snap.snapshot);
+      }
+      const transformed = s.toString();
+      if (transformed !== code) {
+        await environment.saveSnapshotFile(file, transformed);
+      }
+    })
+  );
+}
+const startObjectRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\s\S]*\*\/\s*|\/\/.*(?:[\n\r\u2028\u2029]\s*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))*\{/;
+function replaceObjectSnap(code, s, index, newSnap) {
+  let _code = code.slice(index);
+  const startMatch = startObjectRegex.exec(_code);
+  if (!startMatch) {
+    return false;
+  }
+  _code = _code.slice(startMatch.index);
+  let callEnd = getCallLastIndex(_code);
+  if (callEnd === null) {
+    return false;
+  }
+  callEnd += index + startMatch.index;
+  const shapeStart = index + startMatch.index + startMatch[0].length;
+  const shapeEnd = getObjectShapeEndIndex(code, shapeStart);
+  const snap = `, ${prepareSnapString(newSnap, code, index)}`;
+  if (shapeEnd === callEnd) {
+    s.appendLeft(callEnd, snap);
+  } else {
+    s.overwrite(shapeEnd, callEnd, snap);
+  }
+  return true;
+}
+function getObjectShapeEndIndex(code, index) {
+  let startBraces = 1;
+  let endBraces = 0;
+  while (startBraces !== endBraces && index < code.length) {
+    const s = code[index++];
+    if (s === "{") {
+      startBraces++;
+    } else if (s === "}") {
+      endBraces++;
+    }
+  }
+  return index;
+}
+function prepareSnapString(snap, source, index) {
+  const lineNumber = offsetToLineNumber(source, index);
+  const line = source.split(lineSplitRE)[lineNumber - 1];
+  const indent = line.match(/^\s*/)[0] || "";
+  const indentNext = indent.includes("	") ? `${indent}	` : `${indent}  `;
+  const lines = snap.trim().replace(/\\/g, "\\\\").split(/\n/g);
+  const isOneline = lines.length <= 1;
+  const quote = "`";
+  if (isOneline) {
+    return `${quote}${lines.join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}${quote}`;
+  }
+  return `${quote}
+${lines.map((i) => i ? indentNext + i : "").join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}
+${indent}${quote}`;
+}
+const toMatchInlineName = "toMatchInlineSnapshot";
+const toThrowErrorMatchingInlineName = "toThrowErrorMatchingInlineSnapshot";
+function getCodeStartingAtIndex(code, index) {
+  const indexInline = index - toMatchInlineName.length;
+  if (code.slice(indexInline, index) === toMatchInlineName) {
+    return {
+      code: code.slice(indexInline),
+      index: indexInline
+    };
+  }
+  const indexThrowInline = index - toThrowErrorMatchingInlineName.length;
+  if (code.slice(index - indexThrowInline, index) === toThrowErrorMatchingInlineName) {
+    return {
+      code: code.slice(index - indexThrowInline),
+      index: index - indexThrowInline
+    };
+  }
+  return {
+    code: code.slice(index),
+    index
+  };
+}
+const startRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\s\S]*\*\/\s*|\/\/.*(?:[\n\r\u2028\u2029]\s*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))*[\w$]*(['"`)])/;
+function replaceInlineSnap(code, s, currentIndex, newSnap) {
+  const { code: codeStartingAtIndex, index } = getCodeStartingAtIndex(code, currentIndex);
+  const startMatch = startRegex.exec(codeStartingAtIndex);
+  const firstKeywordMatch = /toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot/.exec(
+    codeStartingAtIndex
+  );
+  if (!startMatch || startMatch.index !== (firstKeywordMatch == null ? void 0 : firstKeywordMatch.index)) {
+    return replaceObjectSnap(code, s, index, newSnap);
+  }
+  const quote = startMatch[1];
+  const startIndex = index + startMatch.index + startMatch[0].length;
+  const snapString = prepareSnapString(newSnap, code, index);
+  if (quote === ")") {
+    s.appendRight(startIndex - 1, snapString);
+    return true;
+  }
+  const quoteEndRE = new RegExp(`(?:^|[^\\\\])${quote}`);
+  const endMatch = quoteEndRE.exec(code.slice(startIndex));
+  if (!endMatch) {
+    return false;
+  }
+  const endIndex = startIndex + endMatch.index + endMatch[0].length;
+  s.overwrite(startIndex - 1, endIndex, snapString);
+  return true;
+}
+const INDENTATION_REGEX = /^([^\S\n]*)\S/m;
+function stripSnapshotIndentation(inlineSnapshot) {
+  const match = inlineSnapshot.match(INDENTATION_REGEX);
+  if (!match || !match[1]) {
+    return inlineSnapshot;
+  }
+  const indentation = match[1];
+  const lines = inlineSnapshot.split(/\n/g);
+  if (lines.length <= 2) {
+    return inlineSnapshot;
+  }
+  if (lines[0].trim() !== "" || lines[lines.length - 1].trim() !== "") {
+    return inlineSnapshot;
+  }
+  for (let i = 1; i < lines.length - 1; i++) {
+    if (lines[i] !== "") {
+      if (lines[i].indexOf(indentation) !== 0) {
+        return inlineSnapshot;
+      }
+      lines[i] = lines[i].substring(indentation.length);
+    }
+  }
+  lines[lines.length - 1] = "";
+  inlineSnapshot = lines.join("\n");
+  return inlineSnapshot;
+}
+async function saveRawSnapshots(environment, snapshots) {
+  await Promise.all(
+    snapshots.map(async (snap) => {
+      if (!snap.readonly) {
+        await environment.saveSnapshotFile(snap.file, snap.snapshot);
+      }
+    })
+  );
+}
+class SnapshotState {
+  constructor(testFilePath, snapshotPath, snapshotContent, options) {
+    __publicField(this, "_counters");
+    __publicField(this, "_dirty");
+    __publicField(this, "_updateSnapshot");
+    __publicField(this, "_snapshotData");
+    __publicField(this, "_initialData");
+    __publicField(this, "_inlineSnapshots");
+    __publicField(this, "_inlineSnapshotStacks");
+    __publicField(this, "_rawSnapshots");
+    __publicField(this, "_uncheckedKeys");
+    __publicField(this, "_snapshotFormat");
+    __publicField(this, "_environment");
+    __publicField(this, "_fileExists");
+    __publicField(this, "added");
+    __publicField(this, "expand");
+    __publicField(this, "matched");
+    __publicField(this, "unmatched");
+    __publicField(this, "updated");
+    this.testFilePath = testFilePath;
+    this.snapshotPath = snapshotPath;
+    const { data, dirty } = getSnapshotData(snapshotContent, options);
+    this._fileExists = snapshotContent != null;
+    this._initialData = data;
+    this._snapshotData = data;
+    this._dirty = dirty;
+    this._inlineSnapshots = [];
+    this._inlineSnapshotStacks = [];
+    this._rawSnapshots = [];
+    this._uncheckedKeys = new Set(Object.keys(this._snapshotData));
+    this._counters = /* @__PURE__ */ new Map();
+    this.expand = options.expand || false;
+    this.added = 0;
+    this.matched = 0;
+    this.unmatched = 0;
+    this._updateSnapshot = options.updateSnapshot;
+    this.updated = 0;
+    this._snapshotFormat = {
+      printBasicPrototype: false,
+      escapeString: false,
+      ...options.snapshotFormat
+    };
+    this._environment = options.snapshotEnvironment;
+  }
+  static async create(testFilePath, options) {
+    const snapshotPath = await options.snapshotEnvironment.resolvePath(
+      testFilePath
+    );
+    const content = await options.snapshotEnvironment.readSnapshotFile(
+      snapshotPath
+    );
+    return new SnapshotState(testFilePath, snapshotPath, content, options);
+  }
+  get environment() {
+    return this._environment;
+  }
+  markSnapshotsAsCheckedForTest(testName) {
+    this._uncheckedKeys.forEach((uncheckedKey) => {
+      if (keyToTestName(uncheckedKey) === testName) {
+        this._uncheckedKeys.delete(uncheckedKey);
+      }
+    });
+  }
+  _inferInlineSnapshotStack(stacks) {
+    const promiseIndex = stacks.findIndex(
+      (i) => i.method.match(/__VITEST_(RESOLVES|REJECTS)__/)
+    );
+    if (promiseIndex !== -1) {
+      return stacks[promiseIndex + 3];
+    }
+    const stackIndex = stacks.findIndex(
+      (i) => i.method.includes("__INLINE_SNAPSHOT__")
+    );
+    return stackIndex !== -1 ? stacks[stackIndex + 2] : null;
+  }
+  _addSnapshot(key, receivedSerialized, options) {
+    this._dirty = true;
+    if (options.stack) {
+      this._inlineSnapshots.push({
+        snapshot: receivedSerialized,
+        ...options.stack
+      });
+    } else if (options.rawSnapshot) {
+      this._rawSnapshots.push({
+        ...options.rawSnapshot,
+        snapshot: receivedSerialized
+      });
+    } else {
+      this._snapshotData[key] = receivedSerialized;
+    }
+  }
+  clear() {
+    this._snapshotData = this._initialData;
+    this._counters = /* @__PURE__ */ new Map();
+    this.added = 0;
+    this.matched = 0;
+    this.unmatched = 0;
+    this.updated = 0;
+    this._dirty = false;
+  }
+  async save() {
+    const hasExternalSnapshots = Object.keys(this._snapshotData).length;
+    const hasInlineSnapshots = this._inlineSnapshots.length;
+    const hasRawSnapshots = this._rawSnapshots.length;
+    const isEmpty = !hasExternalSnapshots && !hasInlineSnapshots && !hasRawSnapshots;
+    const status = {
+      deleted: false,
+      saved: false
+    };
+    if ((this._dirty || this._uncheckedKeys.size) && !isEmpty) {
+      if (hasExternalSnapshots) {
+        await saveSnapshotFile(
+          this._environment,
+          this._snapshotData,
+          this.snapshotPath
+        );
+        this._fileExists = true;
+      }
+      if (hasInlineSnapshots) {
+        await saveInlineSnapshots(this._environment, this._inlineSnapshots);
+      }
+      if (hasRawSnapshots) {
+        await saveRawSnapshots(this._environment, this._rawSnapshots);
+      }
+      status.saved = true;
+    } else if (!hasExternalSnapshots && this._fileExists) {
+      if (this._updateSnapshot === "all") {
+        await this._environment.removeSnapshotFile(this.snapshotPath);
+        this._fileExists = false;
+      }
+      status.deleted = true;
+    }
+    return status;
+  }
+  getUncheckedCount() {
+    return this._uncheckedKeys.size || 0;
+  }
+  getUncheckedKeys() {
+    return Array.from(this._uncheckedKeys);
+  }
+  removeUncheckedKeys() {
+    if (this._updateSnapshot === "all" && this._uncheckedKeys.size) {
+      this._dirty = true;
+      this._uncheckedKeys.forEach((key) => delete this._snapshotData[key]);
+      this._uncheckedKeys.clear();
+    }
+  }
+  match({
+    testName,
+    received,
+    key,
+    inlineSnapshot,
+    isInline,
+    error,
+    rawSnapshot
+  }) {
+    var _a, _b;
+    this._counters.set(testName, (this._counters.get(testName) || 0) + 1);
+    const count = Number(this._counters.get(testName));
+    if (!key) {
+      key = testNameToKey(testName, count);
+    }
+    if (!(isInline && this._snapshotData[key] !== void 0)) {
+      this._uncheckedKeys.delete(key);
+    }
+    let receivedSerialized = rawSnapshot && typeof received === "string" ? received : serialize(received, void 0, this._snapshotFormat);
+    if (!rawSnapshot) {
+      receivedSerialized = addExtraLineBreaks(receivedSerialized);
+    }
+    if (rawSnapshot) {
+      if (rawSnapshot.content && rawSnapshot.content.match(/\r\n/) && !receivedSerialized.match(/\r\n/)) {
+        rawSnapshot.content = normalizeNewlines(rawSnapshot.content);
+      }
+    }
+    const expected = isInline ? inlineSnapshot : rawSnapshot ? rawSnapshot.content : this._snapshotData[key];
+    const expectedTrimmed = prepareExpected(expected);
+    const pass = expectedTrimmed === prepareExpected(receivedSerialized);
+    const hasSnapshot = expected !== void 0;
+    const snapshotIsPersisted = isInline || this._fileExists || rawSnapshot && rawSnapshot.content != null;
+    if (pass && !isInline && !rawSnapshot) {
+      this._snapshotData[key] = receivedSerialized;
+    }
+    let stack;
+    if (isInline) {
+      const stacks = parseErrorStacktrace(
+        error || new Error("snapshot"),
+        { ignoreStackEntries: [] }
+      );
+      const _stack = this._inferInlineSnapshotStack(stacks);
+      if (!_stack) {
+        throw new Error(
+          `@vitest/snapshot: Couldn't infer stack frame for inline snapshot.
+${JSON.stringify(
+            stacks
+          )}`
+        );
+      }
+      stack = ((_b = (_a = this.environment).processStackTrace) == null ? void 0 : _b.call(_a, _stack)) || _stack;
+      stack.column--;
+      if (this._inlineSnapshotStacks.some((s) => s.file === stack.file && s.line === stack.line && s.column === stack.column)) {
+        this._inlineSnapshots = this._inlineSnapshots.filter((s) => !(s.file === stack.file && s.line === stack.line && s.column === stack.column));
+        throw new Error("toMatchInlineSnapshot cannot be called multiple times at the same location.");
+      }
+      this._inlineSnapshotStacks.push(stack);
+    }
+    if (hasSnapshot && this._updateSnapshot === "all" || (!hasSnapshot || !snapshotIsPersisted) && (this._updateSnapshot === "new" || this._updateSnapshot === "all")) {
+      if (this._updateSnapshot === "all") {
+        if (!pass) {
+          if (hasSnapshot) {
+            this.updated++;
+          } else {
+            this.added++;
+          }
+          this._addSnapshot(key, receivedSerialized, {
+            stack,
+            rawSnapshot
+          });
+        } else {
+          this.matched++;
+        }
+      } else {
+        this._addSnapshot(key, receivedSerialized, {
+          stack,
+          rawSnapshot
+        });
+        this.added++;
+      }
+      return {
+        actual: "",
+        count,
+        expected: "",
+        key,
+        pass: true
+      };
+    } else {
+      if (!pass) {
+        this.unmatched++;
+        return {
+          actual: removeExtraLineBreaks(receivedSerialized),
+          count,
+          expected: expectedTrimmed !== void 0 ? removeExtraLineBreaks(expectedTrimmed) : void 0,
+          key,
+          pass: false
+        };
+      } else {
+        this.matched++;
+        return {
+          actual: "",
+          count,
+          expected: "",
+          key,
+          pass: true
+        };
+      }
+    }
+  }
+  async pack() {
+    const snapshot = {
+      filepath: this.testFilePath,
+      added: 0,
+      fileDeleted: false,
+      matched: 0,
+      unchecked: 0,
+      uncheckedKeys: [],
+      unmatched: 0,
+      updated: 0
+    };
+    const uncheckedCount = this.getUncheckedCount();
+    const uncheckedKeys = this.getUncheckedKeys();
+    if (uncheckedCount) {
+      this.removeUncheckedKeys();
+    }
+    const status = await this.save();
+    snapshot.fileDeleted = status.deleted;
+    snapshot.added = this.added;
+    snapshot.matched = this.matched;
+    snapshot.unmatched = this.unmatched;
+    snapshot.updated = this.updated;
+    snapshot.unchecked = !status.deleted ? uncheckedCount : 0;
+    snapshot.uncheckedKeys = Array.from(uncheckedKeys);
+    return snapshot;
+  }
+}
+function createMismatchError(message, expand, actual, expected) {
+  const error = new Error(message);
+  Object.defineProperty(error, "actual", {
+    value: actual,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+  Object.defineProperty(error, "expected", {
+    value: expected,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+  Object.defineProperty(error, "diffOptions", { value: { expand } });
+  return error;
+}
+class SnapshotClient {
+  constructor(options = {}) {
+    __publicField(this, "filepath");
+    __publicField(this, "name");
+    __publicField(this, "snapshotState");
+    __publicField(this, "snapshotStateMap", /* @__PURE__ */ new Map());
+    this.options = options;
+  }
+  async startCurrentRun(filepath, name, options) {
+    var _a;
+    this.filepath = filepath;
+    this.name = name;
+    if (((_a = this.snapshotState) == null ? void 0 : _a.testFilePath) !== filepath) {
+      await this.finishCurrentRun();
+      if (!this.getSnapshotState(filepath)) {
+        this.snapshotStateMap.set(
+          filepath,
+          await SnapshotState.create(filepath, options)
+        );
+      }
+      this.snapshotState = this.getSnapshotState(filepath);
+    }
+  }
+  getSnapshotState(filepath) {
+    return this.snapshotStateMap.get(filepath);
+  }
+  clearTest() {
+    this.filepath = void 0;
+    this.name = void 0;
+  }
+  skipTestSnapshots(name) {
+    var _a;
+    (_a = this.snapshotState) == null ? void 0 : _a.markSnapshotsAsCheckedForTest(name);
+  }
+  assert(options) {
+    var _a, _b, _c, _d;
+    const {
+      filepath = this.filepath,
+      name = this.name,
+      message,
+      isInline = false,
+      properties,
+      inlineSnapshot,
+      error,
+      errorMessage,
+      rawSnapshot
+    } = options;
+    let { received } = options;
+    if (!filepath) {
+      throw new Error("Snapshot cannot be used outside of test");
+    }
+    if (typeof properties === "object") {
+      if (typeof received !== "object" || !received) {
+        throw new Error(
+          "Received value must be an object when the matcher has properties"
+        );
+      }
+      try {
+        const pass2 = ((_b = (_a = this.options).isEqual) == null ? void 0 : _b.call(_a, received, properties)) ?? false;
+        if (!pass2) {
+          throw createMismatchError(
+            "Snapshot properties mismatched",
+            (_c = this.snapshotState) == null ? void 0 : _c.expand,
+            received,
+            properties
+          );
+        } else {
+          received = deepMergeSnapshot(received, properties);
+        }
+      } catch (err) {
+        err.message = errorMessage || "Snapshot mismatched";
+        throw err;
+      }
+    }
+    const testName = [name, ...message ? [message] : []].join(" > ");
+    const snapshotState = this.getSnapshotState(filepath);
+    const { actual, expected, key, pass } = snapshotState.match({
+      testName,
+      received,
+      isInline,
+      error,
+      inlineSnapshot,
+      rawSnapshot
+    });
+    if (!pass) {
+      throw createMismatchError(
+        `Snapshot \`${key || "unknown"}\` mismatched`,
+        (_d = this.snapshotState) == null ? void 0 : _d.expand,
+        actual == null ? void 0 : actual.trim(),
+        expected == null ? void 0 : expected.trim()
+      );
+    }
+  }
+  async assertRaw(options) {
+    if (!options.rawSnapshot) {
+      throw new Error("Raw snapshot is required");
+    }
+    const { filepath = this.filepath, rawSnapshot } = options;
+    if (rawSnapshot.content == null) {
+      if (!filepath) {
+        throw new Error("Snapshot cannot be used outside of test");
+      }
+      const snapshotState = this.getSnapshotState(filepath);
+      options.filepath || (options.filepath = filepath);
+      rawSnapshot.file = await snapshotState.environment.resolveRawPath(
+        filepath,
+        rawSnapshot.file
+      );
+      rawSnapshot.content = await snapshotState.environment.readSnapshotFile(rawSnapshot.file) ?? void 0;
+    }
+    return this.assert(options);
+  }
+  async finishCurrentRun() {
+    if (!this.snapshotState) {
+      return null;
+    }
+    const result = await this.snapshotState.pack();
+    this.snapshotState = void 0;
+    return result;
+  }
+  clear() {
+    this.snapshotStateMap.clear();
+  }
+}
+export {
+  SnapshotClient,
+  SnapshotState,
+  addSerializer,
+  getSerializers,
+  stripSnapshotIndentation
+};