@noma.to/qwik-testing-library 1.3.1 → 1.4.0

package/lib/node_modules/.pnpm/@vitest_snapshot@3.0.5/node_modules/@vitest/snapshot/dist/index.qwik.cjs

@@ -1,2079 +0,0 @@
-"use strict";
-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);
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const index = require("../../../../../@vitest_pretty-format@3.0.5/node_modules/@vitest/pretty-format/dist/index.qwik.cjs");
-const pathe_UZHd4nF = require("../../../../../pathe@2.0.2/node_modules/pathe/dist/shared/pathe.UZ-hd4nF.qwik.cjs");
-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 index2 = path.lastIndexOf("/");
-  return path.slice(0, index2 + 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;
-      // fall through
-      case UrlType.Hash:
-        url.query = baseUrl.query;
-      // fall through
-      case UrlType.Query:
-      case UrlType.RelativePath:
-        mergePaths(url, baseUrl);
-      // fall through
-      case UrlType.AbsolutePath:
-        url.user = baseUrl.user;
-        url.host = baseUrl.host;
-        url.port = baseUrl.port;
-      // fall through
-      case UrlType.SchemeRelative:
-        url.scheme = baseUrl.scheme;
-    }
-    if (baseType > inputType)
-      inputType = baseType;
-  }
-  normalizePath(url, inputType);
-  const queryHash = url.query + url.hash;
-  switch (inputType) {
-    // This is impossible, because of the empty checks at the start of the function.
-    // case UrlType.Empty:
-    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 index2 = path.lastIndexOf("/");
-  return path.slice(0, index2 + 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, index2) {
-  for (let i = index2 + 1; i < haystack.length; index2 = i++) {
-    if (haystack[i][COLUMN] !== needle)
-      break;
-  }
-  return index2;
-}
-function lowerBound(haystack, needle, index2) {
-  for (let i = index2 - 1; i >= 0; index2 = i--) {
-    if (haystack[i][COLUMN] !== needle)
-      break;
-  }
-  return index2;
-}
-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 index2 = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
-  if (index2 === -1)
-    return OMapping(null, null, null, null);
-  const segment = segments[index2];
-  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 index2 = memoizedBinarySearch(segments, column, memo, line);
-  if (found) {
-    index2 = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index2);
-  } else if (bias === LEAST_UPPER_BOUND)
-    index2++;
-  if (index2 === -1 || index2 === segments.length)
-    return -1;
-  return index2;
-}
-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;
-}
-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 = file.startsWith("node:") || file.startsWith("internal:") ? file : pathe_UZHd4nF.r(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;
-}
-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;
-}
-function getDefaultExportFromCjs(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
-}
-var jsTokens_1;
-var hasRequiredJsTokens;
-function requireJsTokens() {
-  if (hasRequiredJsTokens) return jsTokens_1;
-  hasRequiredJsTokens = 1;
-  var Identifier, JSXIdentifier, JSXPunctuator, JSXString, JSXText, KeywordsWithExpressionAfter, KeywordsWithNoLineTerminatorAfter, LineTerminatorSequence, MultiLineComment, Newline, NumericLiteral, Punctuator, RegularExpressionLiteral, SingleLineComment, StringLiteral, Template, TokensNotPrecedingObjectLiteral, TokensPrecedingExpression, WhiteSpace;
-  RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:(?![\]\\]).|\\.)*\]|(?![\/\\]).|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/yu;
-  Punctuator = /--|\+\+|=>|\.{3}|\??\.(?!\d)|(?:&&|\|\||\?\?|[+\-%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2}|\/(?![\/*]))=?|[?~,:;[\](){}]/y;
-  Identifier = /(\x23?)(?=[$_\p{ID_Start}\\])(?:[$_\u200C\u200D\p{ID_Continue}]|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+/yu;
-  StringLiteral = /(['"])(?:(?!\1)[^\\\n\r]|\\(?:\r\n|[^]))*(\1)?/y;
-  NumericLiteral = /(?:0[xX][\da-fA-F](?:_?[\da-fA-F])*|0[oO][0-7](?:_?[0-7])*|0[bB][01](?:_?[01])*)n?|0n|[1-9](?:_?\d)*n|(?:(?:0(?!\d)|0\d*[89]\d*|[1-9](?:_?\d)*)(?:\.(?:\d(?:_?\d)*)?)?|\.\d(?:_?\d)*)(?:[eE][+-]?\d(?:_?\d)*)?|0[0-7]+/y;
-  Template = /[`}](?:[^`\\$]|\\[^]|\$(?!\{))*(`|\$\{)?/y;
-  WhiteSpace = /[\t\v\f\ufeff\p{Zs}]+/yu;
-  LineTerminatorSequence = /\r?\n|[\r\u2028\u2029]/y;
-  MultiLineComment = /\/\*(?:[^*]|\*(?!\/))*(\*\/)?/y;
-  SingleLineComment = /\/\/.*/y;
-  JSXPunctuator = /[<>.:={}]|\/(?![\/*])/y;
-  JSXIdentifier = /[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}-]*/yu;
-  JSXString = /(['"])(?:(?!\1)[^])*(\1)?/y;
-  JSXText = /[^<>{}]+/y;
-  TokensPrecedingExpression = /^(?:[\/+-]|\.{3}|\?(?:InterpolationIn(?:JSX|Template)|NoLineTerminatorHere|NonExpressionParenEnd|UnaryIncDec))?$|[{}([,;<>=*%&|^!~?:]$/;
-  TokensNotPrecedingObjectLiteral = /^(?:=>|[;\]){}]|else|\?(?:NoLineTerminatorHere|NonExpressionParenEnd))?$/;
-  KeywordsWithExpressionAfter = /^(?:await|case|default|delete|do|else|instanceof|new|return|throw|typeof|void|yield)$/;
-  KeywordsWithNoLineTerminatorAfter = /^(?:return|throw|yield)$/;
-  Newline = RegExp(LineTerminatorSequence.source);
-  jsTokens_1 = function* (input, { jsx = false } = {}) {
-    var braces, firstCodePoint, isExpression, lastIndex, lastSignificantToken, length, match, mode, nextLastIndex, nextLastSignificantToken, parenNesting, postfixIncDec, punctuator, stack;
-    ({ length } = input);
-    lastIndex = 0;
-    lastSignificantToken = "";
-    stack = [
-      { tag: "JS" }
-    ];
-    braces = [];
-    parenNesting = 0;
-    postfixIncDec = false;
-    while (lastIndex < length) {
-      mode = stack[stack.length - 1];
-      switch (mode.tag) {
-        case "JS":
-        case "JSNonExpressionParen":
-        case "InterpolationInTemplate":
-        case "InterpolationInJSX":
-          if (input[lastIndex] === "/" && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
-            RegularExpressionLiteral.lastIndex = lastIndex;
-            if (match = RegularExpressionLiteral.exec(input)) {
-              lastIndex = RegularExpressionLiteral.lastIndex;
-              lastSignificantToken = match[0];
-              postfixIncDec = true;
-              yield {
-                type: "RegularExpressionLiteral",
-                value: match[0],
-                closed: match[1] !== void 0 && match[1] !== "\\"
-              };
-              continue;
-            }
-          }
-          Punctuator.lastIndex = lastIndex;
-          if (match = Punctuator.exec(input)) {
-            punctuator = match[0];
-            nextLastIndex = Punctuator.lastIndex;
-            nextLastSignificantToken = punctuator;
-            switch (punctuator) {
-              case "(":
-                if (lastSignificantToken === "?NonExpressionParenKeyword") {
-                  stack.push({
-                    tag: "JSNonExpressionParen",
-                    nesting: parenNesting
-                  });
-                }
-                parenNesting++;
-                postfixIncDec = false;
-                break;
-              case ")":
-                parenNesting--;
-                postfixIncDec = true;
-                if (mode.tag === "JSNonExpressionParen" && parenNesting === mode.nesting) {
-                  stack.pop();
-                  nextLastSignificantToken = "?NonExpressionParenEnd";
-                  postfixIncDec = false;
-                }
-                break;
-              case "{":
-                Punctuator.lastIndex = 0;
-                isExpression = !TokensNotPrecedingObjectLiteral.test(lastSignificantToken) && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken));
-                braces.push(isExpression);
-                postfixIncDec = false;
-                break;
-              case "}":
-                switch (mode.tag) {
-                  case "InterpolationInTemplate":
-                    if (braces.length === mode.nesting) {
-                      Template.lastIndex = lastIndex;
-                      match = Template.exec(input);
-                      lastIndex = Template.lastIndex;
-                      lastSignificantToken = match[0];
-                      if (match[1] === "${") {
-                        lastSignificantToken = "?InterpolationInTemplate";
-                        postfixIncDec = false;
-                        yield {
-                          type: "TemplateMiddle",
-                          value: match[0]
-                        };
-                      } else {
-                        stack.pop();
-                        postfixIncDec = true;
-                        yield {
-                          type: "TemplateTail",
-                          value: match[0],
-                          closed: match[1] === "`"
-                        };
-                      }
-                      continue;
-                    }
-                    break;
-                  case "InterpolationInJSX":
-                    if (braces.length === mode.nesting) {
-                      stack.pop();
-                      lastIndex += 1;
-                      lastSignificantToken = "}";
-                      yield {
-                        type: "JSXPunctuator",
-                        value: "}"
-                      };
-                      continue;
-                    }
-                }
-                postfixIncDec = braces.pop();
-                nextLastSignificantToken = postfixIncDec ? "?ExpressionBraceEnd" : "}";
-                break;
-              case "]":
-                postfixIncDec = true;
-                break;
-              case "++":
-              case "--":
-                nextLastSignificantToken = postfixIncDec ? "?PostfixIncDec" : "?UnaryIncDec";
-                break;
-              case "<":
-                if (jsx && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
-                  stack.push({ tag: "JSXTag" });
-                  lastIndex += 1;
-                  lastSignificantToken = "<";
-                  yield {
-                    type: "JSXPunctuator",
-                    value: punctuator
-                  };
-                  continue;
-                }
-                postfixIncDec = false;
-                break;
-              default:
-                postfixIncDec = false;
-            }
-            lastIndex = nextLastIndex;
-            lastSignificantToken = nextLastSignificantToken;
-            yield {
-              type: "Punctuator",
-              value: punctuator
-            };
-            continue;
-          }
-          Identifier.lastIndex = lastIndex;
-          if (match = Identifier.exec(input)) {
-            lastIndex = Identifier.lastIndex;
-            nextLastSignificantToken = match[0];
-            switch (match[0]) {
-              case "for":
-              case "if":
-              case "while":
-              case "with":
-                if (lastSignificantToken !== "." && lastSignificantToken !== "?.") {
-                  nextLastSignificantToken = "?NonExpressionParenKeyword";
-                }
-            }
-            lastSignificantToken = nextLastSignificantToken;
-            postfixIncDec = !KeywordsWithExpressionAfter.test(match[0]);
-            yield {
-              type: match[1] === "#" ? "PrivateIdentifier" : "IdentifierName",
-              value: match[0]
-            };
-            continue;
-          }
-          StringLiteral.lastIndex = lastIndex;
-          if (match = StringLiteral.exec(input)) {
-            lastIndex = StringLiteral.lastIndex;
-            lastSignificantToken = match[0];
-            postfixIncDec = true;
-            yield {
-              type: "StringLiteral",
-              value: match[0],
-              closed: match[2] !== void 0
-            };
-            continue;
-          }
-          NumericLiteral.lastIndex = lastIndex;
-          if (match = NumericLiteral.exec(input)) {
-            lastIndex = NumericLiteral.lastIndex;
-            lastSignificantToken = match[0];
-            postfixIncDec = true;
-            yield {
-              type: "NumericLiteral",
-              value: match[0]
-            };
-            continue;
-          }
-          Template.lastIndex = lastIndex;
-          if (match = Template.exec(input)) {
-            lastIndex = Template.lastIndex;
-            lastSignificantToken = match[0];
-            if (match[1] === "${") {
-              lastSignificantToken = "?InterpolationInTemplate";
-              stack.push({
-                tag: "InterpolationInTemplate",
-                nesting: braces.length
-              });
-              postfixIncDec = false;
-              yield {
-                type: "TemplateHead",
-                value: match[0]
-              };
-            } else {
-              postfixIncDec = true;
-              yield {
-                type: "NoSubstitutionTemplate",
-                value: match[0],
-                closed: match[1] === "`"
-              };
-            }
-            continue;
-          }
-          break;
-        case "JSXTag":
-        case "JSXTagEnd":
-          JSXPunctuator.lastIndex = lastIndex;
-          if (match = JSXPunctuator.exec(input)) {
-            lastIndex = JSXPunctuator.lastIndex;
-            nextLastSignificantToken = match[0];
-            switch (match[0]) {
-              case "<":
-                stack.push({ tag: "JSXTag" });
-                break;
-              case ">":
-                stack.pop();
-                if (lastSignificantToken === "/" || mode.tag === "JSXTagEnd") {
-                  nextLastSignificantToken = "?JSX";
-                  postfixIncDec = true;
-                } else {
-                  stack.push({ tag: "JSXChildren" });
-                }
-                break;
-              case "{":
-                stack.push({
-                  tag: "InterpolationInJSX",
-                  nesting: braces.length
-                });
-                nextLastSignificantToken = "?InterpolationInJSX";
-                postfixIncDec = false;
-                break;
-              case "/":
-                if (lastSignificantToken === "<") {
-                  stack.pop();
-                  if (stack[stack.length - 1].tag === "JSXChildren") {
-                    stack.pop();
-                  }
-                  stack.push({ tag: "JSXTagEnd" });
-                }
-            }
-            lastSignificantToken = nextLastSignificantToken;
-            yield {
-              type: "JSXPunctuator",
-              value: match[0]
-            };
-            continue;
-          }
-          JSXIdentifier.lastIndex = lastIndex;
-          if (match = JSXIdentifier.exec(input)) {
-            lastIndex = JSXIdentifier.lastIndex;
-            lastSignificantToken = match[0];
-            yield {
-              type: "JSXIdentifier",
-              value: match[0]
-            };
-            continue;
-          }
-          JSXString.lastIndex = lastIndex;
-          if (match = JSXString.exec(input)) {
-            lastIndex = JSXString.lastIndex;
-            lastSignificantToken = match[0];
-            yield {
-              type: "JSXString",
-              value: match[0],
-              closed: match[2] !== void 0
-            };
-            continue;
-          }
-          break;
-        case "JSXChildren":
-          JSXText.lastIndex = lastIndex;
-          if (match = JSXText.exec(input)) {
-            lastIndex = JSXText.lastIndex;
-            lastSignificantToken = match[0];
-            yield {
-              type: "JSXText",
-              value: match[0]
-            };
-            continue;
-          }
-          switch (input[lastIndex]) {
-            case "<":
-              stack.push({ tag: "JSXTag" });
-              lastIndex++;
-              lastSignificantToken = "<";
-              yield {
-                type: "JSXPunctuator",
-                value: "<"
-              };
-              continue;
-            case "{":
-              stack.push({
-                tag: "InterpolationInJSX",
-                nesting: braces.length
-              });
-              lastIndex++;
-              lastSignificantToken = "?InterpolationInJSX";
-              postfixIncDec = false;
-              yield {
-                type: "JSXPunctuator",
-                value: "{"
-              };
-              continue;
-          }
-      }
-      WhiteSpace.lastIndex = lastIndex;
-      if (match = WhiteSpace.exec(input)) {
-        lastIndex = WhiteSpace.lastIndex;
-        yield {
-          type: "WhiteSpace",
-          value: match[0]
-        };
-        continue;
-      }
-      LineTerminatorSequence.lastIndex = lastIndex;
-      if (match = LineTerminatorSequence.exec(input)) {
-        lastIndex = LineTerminatorSequence.lastIndex;
-        postfixIncDec = false;
-        if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) {
-          lastSignificantToken = "?NoLineTerminatorHere";
-        }
-        yield {
-          type: "LineTerminatorSequence",
-          value: match[0]
-        };
-        continue;
-      }
-      MultiLineComment.lastIndex = lastIndex;
-      if (match = MultiLineComment.exec(input)) {
-        lastIndex = MultiLineComment.lastIndex;
-        if (Newline.test(match[0])) {
-          postfixIncDec = false;
-          if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) {
-            lastSignificantToken = "?NoLineTerminatorHere";
-          }
-        }
-        yield {
-          type: "MultiLineComment",
-          value: match[0],
-          closed: match[1] !== void 0
-        };
-        continue;
-      }
-      SingleLineComment.lastIndex = lastIndex;
-      if (match = SingleLineComment.exec(input)) {
-        lastIndex = SingleLineComment.lastIndex;
-        postfixIncDec = false;
-        yield {
-          type: "SingleLineComment",
-          value: match[0]
-        };
-        continue;
-      }
-      firstCodePoint = String.fromCodePoint(input.codePointAt(lastIndex));
-      lastIndex += firstCodePoint.length;
-      lastSignificantToken = firstCodePoint;
-      postfixIncDec = false;
-      yield {
-        type: mode.tag.startsWith("JSX") ? "JSXInvalid" : "Invalid",
-        value: firstCodePoint
-      };
-    }
-    return void 0;
-  };
-  return jsTokens_1;
-}
-requireJsTokens();
-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();
-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;
-}
-async function saveInlineSnapshots(environment, snapshots) {
-  const MagicString = (await Promise.resolve().then(() => require("../../../../../magic-string@0.30.17/node_modules/magic-string/dist/magic-string.es.qwik.cjs"))).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 index2 = positionToOffset(code, snap.line, snap.column);
-        replaceInlineSnap(code, s, index2, 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, index2, newSnap) {
-  let _code = code.slice(index2);
-  const startMatch = startObjectRegex.exec(_code);
-  if (!startMatch) {
-    return false;
-  }
-  _code = _code.slice(startMatch.index);
-  let callEnd = getCallLastIndex(_code);
-  if (callEnd === null) {
-    return false;
-  }
-  callEnd += index2 + startMatch.index;
-  const shapeStart = index2 + startMatch.index + startMatch[0].length;
-  const shapeEnd = getObjectShapeEndIndex(code, shapeStart);
-  const snap = `, ${prepareSnapString(newSnap, code, index2)}`;
-  if (shapeEnd === callEnd) {
-    s.appendLeft(callEnd, snap);
-  } else {
-    s.overwrite(shapeEnd, callEnd, snap);
-  }
-  return true;
-}
-function getObjectShapeEndIndex(code, index2) {
-  let startBraces = 1;
-  let endBraces = 0;
-  while (startBraces !== endBraces && index2 < code.length) {
-    const s = code[index2++];
-    if (s === "{") {
-      startBraces++;
-    } else if (s === "}") {
-      endBraces++;
-    }
-  }
-  return index2;
-}
-function prepareSnapString(snap, source, index2) {
-  const lineNumber = offsetToLineNumber(source, index2);
-  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, index2) {
-  const indexInline = index2 - toMatchInlineName.length;
-  if (code.slice(indexInline, index2) === toMatchInlineName) {
-    return {
-      code: code.slice(indexInline),
-      index: indexInline
-    };
-  }
-  const indexThrowInline = index2 - toThrowErrorMatchingInlineName.length;
-  if (code.slice(index2 - indexThrowInline, index2) === toThrowErrorMatchingInlineName) {
-    return {
-      code: code.slice(index2 - indexThrowInline),
-      index: index2 - indexThrowInline
-    };
-  }
-  return {
-    code: code.slice(index2),
-    index: index2
-  };
-}
-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: index2 } = 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, index2, newSnap);
-  }
-  const quote = startMatch[1];
-  const startIndex = index2 + startMatch.index + startMatch[0].length;
-  const snapString = prepareSnapString(newSnap, code, index2);
-  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);
-      }
-    })
-  );
-}
-var naturalCompare$1 = { exports: {} };
-var hasRequiredNaturalCompare;
-function requireNaturalCompare() {
-  if (hasRequiredNaturalCompare) return naturalCompare$1.exports;
-  hasRequiredNaturalCompare = 1;
-  /*
-   * @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 naturalCompare2 = 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$1.exports = naturalCompare2;
-  } catch (e) {
-    String.naturalCompare = naturalCompare2;
-  }
-  return naturalCompare$1.exports;
-}
-var naturalCompareExports = requireNaturalCompare();
-var naturalCompare = /* @__PURE__ */ getDefaultExportFromCjs(naturalCompareExports);
-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
-} = index.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(
-    index.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).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, index2) => {
-    const targetElement = mergedOutput[index2];
-    if (Array.isArray(target[index2])) {
-      mergedOutput[index2] = deepMergeArray(target[index2], sourceElement);
-    } else if (isObject(targetElement)) {
-      mergedOutput[index2] = deepMergeSnapshot(target[index2], sourceElement);
-    } else {
-      mergedOutput[index2] = 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;
-}
-class DefaultMap extends Map {
-  constructor(defaultFn, entries) {
-    super(entries);
-    this.defaultFn = defaultFn;
-  }
-  get(key) {
-    if (!this.has(key)) {
-      this.set(key, this.defaultFn(key));
-    }
-    return super.get(key);
-  }
-}
-class CounterMap extends DefaultMap {
-  constructor() {
-    super(() => 0);
-  }
-  increment(key) {
-    this.set(key, this.get(key) + 1);
-  }
-  total() {
-    let total = 0;
-    for (const x of this.values()) {
-      total += x;
-    }
-    return total;
-  }
-}
-class SnapshotState {
-  constructor(testFilePath, snapshotPath, snapshotContent, options) {
-    __publicField(this, "_counters", new CounterMap());
-    __publicField(this, "_dirty");
-    __publicField(this, "_updateSnapshot");
-    __publicField(this, "_snapshotData");
-    __publicField(this, "_initialData");
-    __publicField(this, "_inlineSnapshots");
-    __publicField(this, "_inlineSnapshotStacks");
-    __publicField(this, "_testIdToKeys", new DefaultMap(() => []));
-    __publicField(this, "_rawSnapshots");
-    __publicField(this, "_uncheckedKeys");
-    __publicField(this, "_snapshotFormat");
-    __publicField(this, "_environment");
-    __publicField(this, "_fileExists");
-    __publicField(this, "added", new CounterMap());
-    __publicField(this, "matched", new CounterMap());
-    __publicField(this, "unmatched", new CounterMap());
-    __publicField(this, "updated", new CounterMap());
-    __publicField(this, "expand");
-    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.expand = options.expand || false;
-    this._updateSnapshot = options.updateSnapshot;
-    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 (/ \d+$| > /.test(uncheckedKey.slice(testName.length))) {
-        this._uncheckedKeys.delete(uncheckedKey);
-      }
-    });
-  }
-  clearTest(testId) {
-    this._inlineSnapshots = this._inlineSnapshots.filter((s) => s.testId !== testId);
-    this._inlineSnapshotStacks = this._inlineSnapshotStacks.filter((s) => s.testId !== testId);
-    for (const key of this._testIdToKeys.get(testId)) {
-      const name = keyToTestName(key);
-      const count = this._counters.get(name);
-      if (count > 0) {
-        if (key in this._snapshotData || key in this._initialData) {
-          this._snapshotData[key] = this._initialData[key];
-        }
-        this._counters.set(name, count - 1);
-      }
-    }
-    this._testIdToKeys.delete(testId);
-    this.added.delete(testId);
-    this.updated.delete(testId);
-    this.matched.delete(testId);
-    this.unmatched.delete(testId);
-  }
-  _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,
-        testId: options.testId,
-        ...options.stack
-      });
-    } else if (options.rawSnapshot) {
-      this._rawSnapshots.push({
-        ...options.rawSnapshot,
-        snapshot: receivedSerialized
-      });
-    } else {
-      this._snapshotData[key] = receivedSerialized;
-    }
-  }
-  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({
-    testId,
-    testName,
-    received,
-    key,
-    inlineSnapshot,
-    isInline,
-    error,
-    rawSnapshot
-  }) {
-    var _a, _b;
-    this._counters.increment(testName);
-    const count = this._counters.get(testName);
-    if (!key) {
-      key = testNameToKey(testName, count);
-    }
-    this._testIdToKeys.get(testId).push(key);
-    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 = rawSnapshot ? expected : prepareExpected(expected);
-    const pass = expectedTrimmed === (rawSnapshot ? receivedSerialized : 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, testId });
-    }
-    if (hasSnapshot && this._updateSnapshot === "all" || (!hasSnapshot || !snapshotIsPersisted) && (this._updateSnapshot === "new" || this._updateSnapshot === "all")) {
-      if (this._updateSnapshot === "all") {
-        if (!pass) {
-          if (hasSnapshot) {
-            this.updated.increment(testId);
-          } else {
-            this.added.increment(testId);
-          }
-          this._addSnapshot(key, receivedSerialized, {
-            stack,
-            testId,
-            rawSnapshot
-          });
-        } else {
-          this.matched.increment(testId);
-        }
-      } else {
-        this._addSnapshot(key, receivedSerialized, {
-          stack,
-          testId,
-          rawSnapshot
-        });
-        this.added.increment(testId);
-      }
-      return {
-        actual: "",
-        count,
-        expected: "",
-        key,
-        pass: true
-      };
-    } else {
-      if (!pass) {
-        this.unmatched.increment(testId);
-        return {
-          actual: rawSnapshot ? receivedSerialized : removeExtraLineBreaks(receivedSerialized),
-          count,
-          expected: expectedTrimmed !== void 0 ? rawSnapshot ? expectedTrimmed : removeExtraLineBreaks(expectedTrimmed) : void 0,
-          key,
-          pass: false
-        };
-      } else {
-        this.matched.increment(testId);
-        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.total();
-    snapshot.matched = this.matched.total();
-    snapshot.unmatched = this.unmatched.total();
-    snapshot.updated = this.updated.total();
-    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, "snapshotStateMap", /* @__PURE__ */ new Map());
-    this.options = options;
-  }
-  async setup(filepath, options) {
-    if (this.snapshotStateMap.has(filepath)) {
-      return;
-    }
-    this.snapshotStateMap.set(
-      filepath,
-      await SnapshotState.create(filepath, options)
-    );
-  }
-  async finish(filepath) {
-    const state = this.getSnapshotState(filepath);
-    const result = await state.pack();
-    this.snapshotStateMap.delete(filepath);
-    return result;
-  }
-  skipTest(filepath, testName) {
-    const state = this.getSnapshotState(filepath);
-    state.markSnapshotsAsCheckedForTest(testName);
-  }
-  clearTest(filepath, testId) {
-    const state = this.getSnapshotState(filepath);
-    state.clearTest(testId);
-  }
-  getSnapshotState(filepath) {
-    const state = this.snapshotStateMap.get(filepath);
-    if (!state) {
-      throw new Error(
-        `The snapshot state for '${filepath}' is not found. Did you call 'SnapshotClient.setup()'?`
-      );
-    }
-    return state;
-  }
-  assert(options) {
-    var _a, _b;
-    const {
-      filepath,
-      name,
-      testId = 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");
-    }
-    const snapshotState = this.getSnapshotState(filepath);
-    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",
-            snapshotState.expand,
-            received,
-            properties
-          );
-        } else {
-          received = deepMergeSnapshot(received, properties);
-        }
-      } catch (err) {
-        err.message = errorMessage || "Snapshot mismatched";
-        throw err;
-      }
-    }
-    const testName = [name, ...message ? [message] : []].join(" > ");
-    const { actual, expected, key, pass } = snapshotState.match({
-      testId,
-      testName,
-      received,
-      isInline,
-      error,
-      inlineSnapshot,
-      rawSnapshot
-    });
-    if (!pass) {
-      throw createMismatchError(
-        `Snapshot \`${key || "unknown"}\` mismatched`,
-        snapshotState.expand,
-        rawSnapshot ? actual : actual == null ? void 0 : actual.trim(),
-        rawSnapshot ? expected : expected == null ? void 0 : expected.trim()
-      );
-    }
-  }
-  async assertRaw(options) {
-    if (!options.rawSnapshot) {
-      throw new Error("Raw snapshot is required");
-    }
-    const { 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);
-  }
-  clear() {
-    this.snapshotStateMap.clear();
-  }
-}
-exports.SnapshotClient = SnapshotClient;
-exports.SnapshotState = SnapshotState;
-exports.addSerializer = addSerializer;
-exports.getSerializers = getSerializers;
-exports.stripSnapshotIndentation = stripSnapshotIndentation;