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

package/lib/node_modules/.pnpm/{@vitest_snapshot@2.1.1 → @vitest_snapshot@2.1.8}/node_modules/@vitest/snapshot/dist/index.qwik.mjs

@@ -1,450 +1,8 @@
 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 { format, plugins } from "../../../../../@vitest_pretty-format@2.1.8/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);
@@ -678,15 +236,19 @@ function resolve$1(input, base) {
     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;
     }
@@ -696,6 +258,8 @@ function resolve$1(input, base) {
   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;
@@ -895,6 +459,47 @@ function traceSegmentInternal(segments, memo, line, column, bias) {
     return -1;
   return index;
 }
+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 = [
@@ -1032,31 +637,610 @@ function parseStacktrace(stack, options = {}) {
     return stack2;
   });
 }
-function parseFFOrSafariStackTrace(stack) {
-  return stack.split("\n").map((line) => parseSingleFFOrSafariStack(line)).filter(notNullish);
+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 parseV8Stacktrace(stack) {
-  return stack.split("\n").map((line) => parseSingleV8Stack(line)).filter(notNullish);
+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;
 }
-function parseErrorStacktrace(e, options = {}) {
-  if (!e || isPrimitive(e)) {
-    return [];
+p(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;
   }
-  if (e.stacks) {
-    return e.stacks;
+  for (let i = 0; i < lineNumber - 1; i++) {
+    start += lines[i].length + nl;
   }
-  const stackStr = e.stack || e.stackStr || "";
-  let stackFrames = parseStacktrace(stackStr, options);
-  if (options.frameFilter) {
-    stackFrames = stackFrames.filter(
-      (f2) => options.frameFilter(e, f2) !== false
+  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}`
     );
   }
-  e.stacks = stackFrames;
-  return stackFrames;
+  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 import("../../../../../magic-string@0.30.11/node_modules/magic-string/dist/magic-string.es.qwik.mjs")).default;
+  const MagicString = (await import("../../../../../magic-string@0.30.17/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) => {
@@ -1208,6 +1392,225 @@ async function saveRawSnapshots(environment, snapshots) {
     })
   );
 }
+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
+} = 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).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;
+}
 class SnapshotState {
   constructor(testFilePath, snapshotPath, snapshotContent, options) {
     __publicField(this, "_counters");