@rstest/core 0.9.4 → 0.9.6

package/dist/browser-runtime/2~snapshot.js

@@ -0,0 +1,2138 @@
+/*! LICENSE: 2~snapshot.js.LICENSE.txt */
+import { __webpack_require__ } from "./723.js";
+import { dist_format, dist_plugins, getTaskNameWithPrefix, subsetEquality, pathe_M_eThtNZ_resolve, dist_equals, iterableEquality } from "./723.js";
+var snapshot_namespaceObject = {};
+__webpack_require__.r(snapshot_namespaceObject);
+__webpack_require__.d(snapshot_namespaceObject, {
+    SnapshotPlugin: ()=>SnapshotPlugin
+});
+var process = __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
+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 |= (31 & integer) << shift;
+        shift += 5;
+    }while (32 & integer)
+    const shouldNegate = 1 & value;
+    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 -1 === idx ? 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(a, b) {
+    return a[0] - b[0];
+}
+const schemeRegex = /^[\w+.-]+:\/\//;
+const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+var dist_UrlType;
+(function(UrlType) {
+    UrlType[UrlType["Empty"] = 1] = "Empty";
+    UrlType[UrlType["Hash"] = 2] = "Hash";
+    UrlType[UrlType["Query"] = 3] = "Query";
+    UrlType[UrlType["RelativePath"] = 4] = "RelativePath";
+    UrlType[UrlType["AbsolutePath"] = 5] = "AbsolutePath";
+    UrlType[UrlType["SchemeRelative"] = 6] = "SchemeRelative";
+    UrlType[UrlType["Absolute"] = 7] = "Absolute";
+})(dist_UrlType || (dist_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: dist_UrlType.Absolute
+    };
+}
+function parseUrl(input) {
+    if (isSchemeRelativeUrl(input)) {
+        const url = parseAbsoluteUrl('http:' + input);
+        url.scheme = '';
+        url.type = dist_UrlType.SchemeRelative;
+        return url;
+    }
+    if (isAbsolutePath(input)) {
+        const url = parseAbsoluteUrl('http://foo.com' + input);
+        url.scheme = '';
+        url.host = '';
+        url.type = dist_UrlType.AbsolutePath;
+        return url;
+    }
+    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('?') ? dist_UrlType.Query : input.startsWith('#') ? dist_UrlType.Hash : dist_UrlType.RelativePath : dist_UrlType.Empty;
+    return url;
+}
+function stripPathFilename(path) {
+    if (path.endsWith('/..')) return path;
+    const index = path.lastIndexOf('/');
+    return path.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+    normalizePath(base, base.type);
+    if ('/' === url.path) url.path = base.path;
+    else url.path = stripPathFilename(base.path) + url.path;
+}
+function normalizePath(url, type) {
+    const rel = type <= dist_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) {
+            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 !== dist_UrlType.Absolute) {
+        const baseUrl = parseUrl(base);
+        const baseType = baseUrl.type;
+        switch(inputType){
+            case dist_UrlType.Empty:
+                url.hash = baseUrl.hash;
+            case dist_UrlType.Hash:
+                url.query = baseUrl.query;
+            case dist_UrlType.Query:
+            case dist_UrlType.RelativePath:
+                mergePaths(url, baseUrl);
+            case dist_UrlType.AbsolutePath:
+                url.user = baseUrl.user;
+                url.host = baseUrl.host;
+                url.port = baseUrl.port;
+            case dist_UrlType.SchemeRelative:
+                url.scheme = baseUrl.scheme;
+        }
+        if (baseType > inputType) inputType = baseType;
+    }
+    normalizePath(url, inputType);
+    const queryHash = url.query + url.hash;
+    switch(inputType){
+        case dist_UrlType.Hash:
+        case dist_UrlType.Query:
+            return queryHash;
+        case dist_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 dist_UrlType.AbsolutePath:
+            return url.path + queryHash;
+        default:
+            return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
+    }
+}
+function resolve(input, base) {
+    if (base && !base.endsWith('/')) base += '/';
+    return resolve$1(input, base);
+}
+function stripFilename(path) {
+    if (!path) return '';
+    const index = path.lastIndexOf('/');
+    return path.slice(0, index + 1);
+}
+const COLUMN = 0;
+const SOURCES_INDEX = 1;
+const SOURCE_LINE = 2;
+const SOURCE_COLUMN = 3;
+const NAMES_INDEX = 4;
+function maybeSort(mappings, owned) {
+    const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+    if (unsortedIndex === mappings.length) return mappings;
+    if (!owned) mappings = mappings.slice();
+    for(let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1))mappings[i] = sortSegments(mappings[i], owned);
+    return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+    for(let i = start; i < mappings.length; i++)if (!isSorted(mappings[i])) return i;
+    return mappings.length;
+}
+function isSorted(line) {
+    for(let j = 1; j < line.length; j++)if (line[j][COLUMN] < line[j - 1][COLUMN]) return false;
+    return true;
+}
+function sortSegments(line, owned) {
+    if (!owned) line = line.slice();
+    return line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+    return a[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 (0 === cmp) {
+            found = true;
+            return mid;
+        }
+        if (cmp < 0) low = mid + 1;
+        else high = mid - 1;
+    }
+    found = false;
+    return low - 1;
+}
+function upperBound(haystack, needle, index) {
+    for(let i = index + 1; i < haystack.length && haystack[i][COLUMN] === needle; index = i++);
+    return index;
+}
+function lowerBound(haystack, needle, index) {
+    for(let i = index - 1; i >= 0 && haystack[i][COLUMN] === needle; index = i--);
+    return index;
+}
+function memoizedState() {
+    return {
+        lastKey: -1,
+        lastNeedle: -1,
+        lastIndex: -1
+    };
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+    const { lastKey, lastNeedle, lastIndex } = state;
+    let low = 0;
+    let high = haystack.length - 1;
+    if (key === lastKey) {
+        if (needle === lastNeedle) {
+            found = -1 !== lastIndex && haystack[lastIndex][COLUMN] === needle;
+            return lastIndex;
+        }
+        if (needle >= lastNeedle) low = -1 === lastIndex ? 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 = 'string' == typeof map;
+        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 ('string' == typeof mappings) {
+            this._encoded = mappings;
+            this._decoded = void 0;
+        } else {
+            this._encoded = void 0;
+            this._decoded = maybeSort(mappings, isString);
+        }
+        this._decodedMemo = memoizedState();
+        this._bySources = void 0;
+        this._bySourceMemos = void 0;
+    }
+}
+function cast(map) {
+    return map;
+}
+function decodedMappings(map) {
+    var _a;
+    return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+function originalPositionFor(map, needle) {
+    let { line, column, bias } = needle;
+    line--;
+    if (line < 0) throw new Error(LINE_GTR_ZERO);
+    if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+    const decoded = decodedMappings(map);
+    if (line >= decoded.length) return OMapping(null, null, null, null);
+    const segments = decoded[line];
+    const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+    if (-1 === index) return OMapping(null, null, null, null);
+    const segment = segments[index];
+    if (1 === segment.length) return OMapping(null, null, null, null);
+    const { names, resolvedSources } = map;
+    return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], 5 === segment.length ? names[segment[NAMES_INDEX]] : null);
+}
+function OMapping(source, line, column, name) {
+    return {
+        source,
+        line,
+        column,
+        name
+    };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+    let index = memoizedBinarySearch(segments, column, memo, line);
+    if (found) index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+    else if (bias === LEAST_UPPER_BOUND) index++;
+    if (-1 === index || index === segments.length) return -1;
+    return index;
+}
+function notNullish(v) {
+    return null != v;
+}
+function isPrimitive(value) {
+    return null === value || "function" != typeof value && "object" != typeof value;
+}
+function isObject(item) {
+    return null != item && "object" == typeof item && !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/",
+    "/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);
+        urlObj.searchParams.delete("import");
+        urlObj.searchParams.delete("browserv");
+        url = urlObj.pathname + urlObj.hash + urlObj.search;
+    }
+    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_M_eThtNZ_resolve(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;
+    const stacks = CHROME_IE_STACK_REGEXP.test(stack) ? parseV8Stacktrace(stack) : parseFFOrSafariStackTrace(stack);
+    return stacks.map((stack)=>{
+        var _options$getSourceMap;
+        if (options.getUrlId) stack.file = options.getUrlId(stack.file);
+        const map = null == (_options$getSourceMap = options.getSourceMap) ? void 0 : _options$getSourceMap.call(options, stack.file);
+        if (!map || "object" != typeof map || !map.version) return shouldFilter(ignoreStackEntries, stack.file) ? null : stack;
+        const traceMap = new TraceMap(map);
+        const { line, column, source, name } = originalPositionFor(traceMap, stack);
+        let file = stack.file;
+        if (source) {
+            const fileUrl = stack.file.startsWith("file://") ? stack.file : `file://${stack.file}`;
+            const sourceRootUrl = map.sourceRoot ? new URL(map.sourceRoot, fileUrl) : fileUrl;
+            file = new URL(source, sourceRootUrl).pathname;
+            if (file.match(/\/\w:\//)) file = file.slice(1);
+        }
+        if (shouldFilter(ignoreStackEntries, file)) return null;
+        if (null != line && null != column) return {
+            line,
+            column,
+            file,
+            method: name || stack.method
+        };
+        return stack;
+    }).filter((s)=>null != s);
+}
+function shouldFilter(ignoreStackEntries, file) {
+    return ignoreStackEntries.some((p)=>file.match(p));
+}
+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 || "";
+    let stackFrames = "string" == typeof stackStr ? parseStacktrace(stackStr, options) : [];
+    if (!stackFrames.length) {
+        const e_ = e;
+        if (null != e_.fileName && null != e_.lineNumber && null != e_.columnNumber) stackFrames = parseStacktrace(`${e_.fileName}:${e_.lineNumber}:${e_.columnNumber}`, options);
+        if (null != e_.sourceURL && null != e_.line && null != e_._column) stackFrames = parseStacktrace(`${e_.sourceURL}:${e_.line}:${e_.column}`, options);
+    }
+    if (options.frameFilter) stackFrames = stackFrames.filter((f)=>false !== options.frameFilter(e, f));
+    e.stacks = stackFrames;
+    return stackFrames;
+}
+try {
+    const { getPromiseDetails, kPending, kRejected } = process.binding('util');
+    Array.isArray(getPromiseDetails(Promise.resolve()));
+} catch (notNode) {}
+const { AsymmetricMatcher: AsymmetricMatcher$1, DOMCollection: DOMCollection$1, DOMElement: DOMElement$1, Immutable: Immutable$1, ReactElement: ReactElement$1, ReactTestComponent: ReactTestComponent$1 } = dist_plugins;
+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: void 0 !== match[1] && "\\" !== match[1]
+                            };
+                            continue;
+                        }
+                    }
+                    Punctuator.lastIndex = lastIndex;
+                    if (match = Punctuator.exec(input)) {
+                        punctuator = match[0];
+                        nextLastIndex = Punctuator.lastIndex;
+                        nextLastSignificantToken = punctuator;
+                        switch(punctuator){
+                            case "(":
+                                if ("?NonExpressionParenKeyword" === lastSignificantToken) stack.push({
+                                    tag: "JSNonExpressionParen",
+                                    nesting: parenNesting
+                                });
+                                parenNesting++;
+                                postfixIncDec = false;
+                                break;
+                            case ")":
+                                parenNesting--;
+                                postfixIncDec = true;
+                                if ("JSNonExpressionParen" === mode.tag && 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: void 0 !== match[2]
+                        };
+                        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 || "JSXTagEnd" === mode.tag) {
+                                    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 ("JSXChildren" === stack[stack.length - 1].tag) 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: void 0 !== match[2]
+                        };
+                        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: void 0 !== match[1]
+                };
+                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 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 dist_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(dist_f);
+function dist_a(n) {
+    return String(n);
+}
+dist_a.open = "";
+dist_a.close = "";
+function C(n = false) {
+    let e = void 0 !== process ? process : void 0, i = (null == e ? void 0 : e.env) || {}, g = (null == e ? void 0 : e.argv) || [];
+    return !("NO_COLOR" in i || g.includes("--no-color")) && ("FORCE_COLOR" in i || g.includes("--color") || (null == e ? void 0 : e.platform) === "win32" || n && "dumb" !== i.TERM || "CI" in i) || "u" > typeof window && !!window.chrome;
+}
+function dist_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]) : dist_a;
+    return u;
+}
+dist_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 import("./2~magic-string.es.js")).default;
+    const files = new Set(snapshots.map((i)=>i.file));
+    await Promise.all(Array.from(files).map(async (file)=>{
+        const snaps = snapshots.filter((i)=>i.file === file);
+        const code = await environment.readSnapshotFile(file);
+        const s = new MagicString(code);
+        for (const snap of snaps){
+            const index = positionToOffset(code, snap.line, snap.column);
+            replaceInlineSnap(code, s, index, snap.snapshot);
+        }
+        const transformed = s.toString();
+        if (transformed !== code) await environment.saveSnapshotFile(file, transformed);
+    }));
+}
+const startObjectRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\s\S]*\*\/\s*|\/\/.*(?:[\n\r\u2028\u2029]\s*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))*\{/;
+function replaceObjectSnap(code, s, index, newSnap) {
+    let _code = code.slice(index);
+    const startMatch = startObjectRegex.exec(_code);
+    if (!startMatch) return false;
+    _code = _code.slice(startMatch.index);
+    let callEnd = getCallLastIndex(_code);
+    if (null === callEnd) return false;
+    callEnd += index + startMatch.index;
+    const shapeStart = index + startMatch.index + startMatch[0].length;
+    const shapeEnd = getObjectShapeEndIndex(code, shapeStart);
+    const snap = `, ${prepareSnapString(newSnap, code, index)}`;
+    if (shapeEnd === callEnd) s.appendLeft(callEnd, snap);
+    else s.overwrite(shapeEnd, callEnd, snap);
+    return true;
+}
+function getObjectShapeEndIndex(code, index) {
+    let startBraces = 1;
+    let endBraces = 0;
+    while(startBraces !== endBraces && index < code.length){
+        const s = code[index++];
+        if ("{" === s) startBraces++;
+        else if ("}" === s) endBraces++;
+    }
+    return index;
+}
+function prepareSnapString(snap, source, index) {
+    const lineNumber = offsetToLineNumber(source, index);
+    const line = source.split(lineSplitRE)[lineNumber - 1];
+    const indent = line.match(/^\s*/)[0] || "";
+    const indentNext = indent.includes("	") ? `${indent}\t` : `${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}\n${lines.map((i)=>i ? indentNext + i : "").join("\n").replace(/`/g, "\\`").replace(/\$\{/g, "\\${")}\n${indent}${quote}`;
+}
+const toMatchInlineName = "toMatchInlineSnapshot";
+const toThrowErrorMatchingInlineName = "toThrowErrorMatchingInlineSnapshot";
+function getCodeStartingAtIndex(code, index) {
+    const indexInline = index - toMatchInlineName.length;
+    if (code.slice(indexInline, index) === toMatchInlineName) return {
+        code: code.slice(indexInline),
+        index: indexInline
+    };
+    const indexThrowInline = index - toThrowErrorMatchingInlineName.length;
+    if (code.slice(index - indexThrowInline, index) === toThrowErrorMatchingInlineName) return {
+        code: code.slice(index - indexThrowInline),
+        index: index - indexThrowInline
+    };
+    return {
+        code: code.slice(index),
+        index
+    };
+}
+const startRegex = /(?:toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot)\s*\(\s*(?:\/\*[\s\S]*\*\/\s*|\/\/.*(?:[\n\r\u2028\u2029]\s*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF]))*[\w$]*(['"`)])/;
+function replaceInlineSnap(code, s, currentIndex, newSnap) {
+    const { code: codeStartingAtIndex, index } = getCodeStartingAtIndex(code, currentIndex);
+    const startMatch = startRegex.exec(codeStartingAtIndex);
+    const firstKeywordMatch = /toMatchInlineSnapshot|toThrowErrorMatchingInlineSnapshot/.exec(codeStartingAtIndex);
+    if (!startMatch || startMatch.index !== (null == firstKeywordMatch ? void 0 : firstKeywordMatch.index)) return replaceObjectSnap(code, s, index, newSnap);
+    const quote = startMatch[1];
+    const startIndex = index + startMatch.index + startMatch[0].length;
+    const snapString = prepareSnapString(newSnap, code, index);
+    if (")" === quote) {
+        s.appendRight(startIndex - 1, snapString);
+        return true;
+    }
+    const quoteEndRE = new RegExp(`(?:^|[^\\\\])${quote}`);
+    const endMatch = quoteEndRE.exec(code.slice(startIndex));
+    if (!endMatch) return false;
+    const endIndex = startIndex + endMatch.index + endMatch[0].length;
+    s.overwrite(startIndex - 1, endIndex, snapString);
+    return true;
+}
+const INDENTATION_REGEX = /^([^\S\n]*)\S/m;
+function stripSnapshotIndentation(inlineSnapshot) {
+    const match = inlineSnapshot.match(INDENTATION_REGEX);
+    if (!match || !match[1]) return inlineSnapshot;
+    const indentation = match[1];
+    const lines = inlineSnapshot.split(/\n/g);
+    if (lines.length <= 2) return inlineSnapshot;
+    if ("" !== lines[0].trim() || "" !== lines[lines.length - 1].trim()) return inlineSnapshot;
+    for(let i = 1; i < lines.length - 1; i++)if ("" !== lines[i]) {
+        if (0 !== lines[i].indexOf(indentation)) 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 naturalCompare = function(a, 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 ((a += "") != (b += "")) for(; codeB;){
+            codeA = getCode(a, posA++);
+            codeB = getCode(b, posB++);
+            if (codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66) {
+                codeA = getCode(a, posA, posA);
+                codeB = getCode(b, posB, posA = i);
+                posB = i;
+            }
+            if (codeA != codeB) return codeA < codeB ? -1 : 1;
+        }
+        return 0;
+    };
+    try {
+        naturalCompare$1.exports = naturalCompare;
+    } catch (e) {
+        String.naturalCompare = naturalCompare;
+    }
+    return naturalCompare$1.exports;
+}
+var naturalCompareExports = requireNaturalCompare();
+var dist_naturalCompare = /*@__PURE__*/ getDefaultExportFromCjs(naturalCompareExports);
+const serialize$1 = (val, config, indentation, depth, refs, printer)=>{
+    const name = val.getMockName();
+    const nameString = "vi.fn()" === name ? "" : ` ${name}`;
+    let callsString = "";
+    if (0 !== val.mock.calls.length) {
+        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 dist_test = (val)=>val && !!val._isMockFunction;
+const dist_plugin = {
+    serialize: serialize$1,
+    test: dist_test
+};
+const { DOMCollection: DOMCollection, DOMElement: DOMElement, Immutable: Immutable, ReactElement: ReactElement, ReactTestComponent: ReactTestComponent, AsymmetricMatcher: AsymmetricMatcher } = dist_plugins;
+let PLUGINS = [
+    ReactTestComponent,
+    ReactElement,
+    DOMElement,
+    DOMCollection,
+    Immutable,
+    AsymmetricMatcher,
+    dist_plugin
+];
+function addSerializer(plugin) {
+    PLUGINS = [
+        plugin
+    ].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 = Object.create(null);
+    let snapshotContents = "";
+    let dirty = false;
+    if (null != content) try {
+        snapshotContents = content;
+        const populate = new Function("exports", snapshotContents);
+        populate(data);
+    } catch  {}
+    const isInvalid = snapshotContents;
+    if (("all" === update || "new" === update) && isInvalid) dirty = true;
+    return {
+        data,
+        dirty
+    };
+}
+function addExtraLineBreaks(string) {
+    return string.includes("\n") ? `\n${string}\n` : 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(dist_format(val, {
+        escapeRegex: escapeRegex,
+        indent,
+        plugins: getSerializers(),
+        printFunctionName: 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(dist_naturalCompare).map((key)=>`exports[${printBacktickString(key)}] = ${printBacktickString(normalizeNewlines(snapshotData[key]))};`);
+    const content = `${environment.getHeader()}\n\n${snapshots.join("\n\n")}\n`;
+    const oldContent = await environment.readSnapshotFile(snapshotPath);
+    const skipWriting = null != oldContent && oldContent === content;
+    if (skipWriting) return;
+    await environment.saveSnapshotFile(snapshotPath, content);
+}
+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) mergedOutput[key] = deepMergeSnapshot(target[key], source[key]);
+            else Object.assign(mergedOutput, {
+                [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;
+    }
+    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);
+    }
+    _total;
+    valueOf() {
+        return this._total = this.total();
+    }
+    increment(key) {
+        if (void 0 !== this._total) this._total++;
+        this.set(key, this.get(key) + 1);
+    }
+    total() {
+        if (void 0 !== this._total) return this._total;
+        let total = 0;
+        for (const x of this.values())total += x;
+        return total;
+    }
+}
+function isSameStackPosition(x, y) {
+    return x.file === y.file && x.column === y.column && x.line === y.line;
+}
+class SnapshotState {
+    _counters = new CounterMap();
+    _dirty;
+    _updateSnapshot;
+    _snapshotData;
+    _initialData;
+    _inlineSnapshots;
+    _inlineSnapshotStacks;
+    _testIdToKeys = new DefaultMap(()=>[]);
+    _rawSnapshots;
+    _uncheckedKeys;
+    _snapshotFormat;
+    _environment;
+    _fileExists;
+    expand;
+    _added = new CounterMap();
+    _matched = new CounterMap();
+    _unmatched = new CounterMap();
+    _updated = new CounterMap();
+    get added() {
+        return this._added;
+    }
+    set added(value) {
+        this._added._total = value;
+    }
+    get matched() {
+        return this._matched;
+    }
+    set matched(value) {
+        this._matched._total = value;
+    }
+    get unmatched() {
+        return this._unmatched;
+    }
+    set unmatched(value) {
+        this._unmatched._total = value;
+    }
+    get updated() {
+        return this._updated;
+    }
+    set updated(value) {
+        this._updated._total = value;
+    }
+    constructor(testFilePath, snapshotPath, snapshotContent, options){
+        this.testFilePath = testFilePath;
+        this.snapshotPath = snapshotPath;
+        const { data, dirty } = getSnapshotData(snapshotContent, options);
+        this._fileExists = null != snapshotContent;
+        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 (-1 !== promiseIndex) return stacks[promiseIndex + 3];
+        const stackIndex = stacks.findIndex((i)=>i.method.includes("__INLINE_SNAPSHOT__"));
+        return -1 !== stackIndex ? 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 ("all" === this._updateSnapshot) {
+                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 ("all" === this._updateSnapshot && 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 }) {
+        this._counters.increment(testName);
+        const count = this._counters.get(testName);
+        if (!key) key = testNameToKey(testName, count);
+        this._testIdToKeys.get(testId).push(key);
+        if (!(isInline && void 0 !== this._snapshotData[key])) this._uncheckedKeys.delete(key);
+        let receivedSerialized = rawSnapshot && "string" == typeof received ? 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 : null == expected ? void 0 : expected.trim();
+        const pass = expectedTrimmed === (rawSnapshot ? receivedSerialized : receivedSerialized.trim());
+        const hasSnapshot = void 0 !== expected;
+        const snapshotIsPersisted = isInline || this._fileExists || rawSnapshot && null != rawSnapshot.content;
+        if (pass && !isInline && !rawSnapshot) this._snapshotData[key] = receivedSerialized;
+        let stack;
+        if (isInline) {
+            var _this$environment$pro, _this$environment;
+            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.\n${JSON.stringify(stacks)}`);
+            stack = (null == (_this$environment$pro = (_this$environment = this.environment).processStackTrace) ? void 0 : _this$environment$pro.call(_this$environment, _stack)) || _stack;
+            stack.column--;
+            const snapshotsWithSameStack = this._inlineSnapshotStacks.filter((s)=>isSameStackPosition(s, stack));
+            if (snapshotsWithSameStack.length > 0) {
+                this._inlineSnapshots = this._inlineSnapshots.filter((s)=>!isSameStackPosition(s, stack));
+                const differentSnapshot = snapshotsWithSameStack.find((s)=>s.snapshot !== receivedSerialized);
+                if (differentSnapshot) throw Object.assign(new Error("toMatchInlineSnapshot with different snapshots cannot be called at the same location"), {
+                    actual: receivedSerialized,
+                    expected: differentSnapshot.snapshot
+                });
+            }
+            this._inlineSnapshotStacks.push({
+                ...stack,
+                testId,
+                snapshot: receivedSerialized
+            });
+        }
+        if ((!hasSnapshot || "all" !== this._updateSnapshot) && (hasSnapshot && snapshotIsPersisted || "new" !== this._updateSnapshot && "all" !== this._updateSnapshot)) if (pass) {
+            this.matched.increment(testId);
+            return {
+                actual: "",
+                count,
+                expected: "",
+                key,
+                pass: true
+            };
+        } else {
+            this.unmatched.increment(testId);
+            return {
+                actual: rawSnapshot ? receivedSerialized : removeExtraLineBreaks(receivedSerialized),
+                count,
+                expected: void 0 !== expectedTrimmed ? rawSnapshot ? expectedTrimmed : removeExtraLineBreaks(expectedTrimmed) : void 0,
+                key,
+                pass: false
+            };
+        }
+        if ("all" === this._updateSnapshot) if (pass) this.matched.increment(testId);
+        else {
+            if (hasSnapshot) this.updated.increment(testId);
+            else this.added.increment(testId);
+            this._addSnapshot(key, receivedSerialized, {
+                stack,
+                testId,
+                rawSnapshot
+            });
+        }
+        else {
+            this._addSnapshot(key, receivedSerialized, {
+                stack,
+                testId,
+                rawSnapshot
+            });
+            this.added.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 ? 0 : uncheckedCount;
+        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 {
+    snapshotStateMap = new Map();
+    constructor(options = {}){
+        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) {
+        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 ("object" == typeof properties) {
+            if ("object" != typeof received || !received) throw new Error("Received value must be an object when the matcher has properties");
+            try {
+                var _this$options$isEqual, _this$options;
+                const pass = (null == (_this$options$isEqual = (_this$options = this.options).isEqual) ? void 0 : _this$options$isEqual.call(_this$options, received, properties)) ?? false;
+                if (pass) received = deepMergeSnapshot(received, properties);
+                else throw createMismatchError("Snapshot properties mismatched", snapshotState.expand, 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 : null == actual ? void 0 : actual.trim(), rawSnapshot ? expected : null == expected ? void 0 : expected.trim());
+    }
+    async assertRaw(options) {
+        if (!options.rawSnapshot) throw new Error("Raw snapshot is required");
+        const { filepath, rawSnapshot } = options;
+        if (null == rawSnapshot.content) {
+            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();
+    }
+}
+function recordAsyncExpect(_test, promise, assertion, error) {
+    const test = _test;
+    if (test && promise instanceof Promise) {
+        promise = promise.finally(()=>{
+            if (!test.promises) return;
+            const index = test.promises.indexOf(promise);
+            if (-1 !== index) test.promises.splice(index, 1);
+        });
+        if (!test.promises) test.promises = [];
+        test.promises.push(promise);
+        let resolved = false;
+        test.onFinished ??= [];
+        test.onFinished.push(()=>{
+            if (!resolved) {
+                const processor = globalThis.__vitest_worker__?.onFilterStackTrace || ((s)=>s || '');
+                const stack = processor(error.stack);
+                console.warn([
+                    `Promise returned by \`${assertion}\` was not awaited. `,
+                    'Rstest currently auto-awaits hanging assertions at the end of the test.',
+                    'Please remember to await the assertion.\n',
+                    stack
+                ].join(''));
+            }
+        });
+        return {
+            then (onFulfilled, onRejected) {
+                resolved = true;
+                return promise.then(onFulfilled, onRejected);
+            },
+            catch (onRejected) {
+                return promise.catch(onRejected);
+            },
+            finally (onFinally) {
+                return promise.finally(onFinally);
+            },
+            [Symbol.toStringTag]: 'Promise'
+        };
+    }
+    return promise;
+}
+function createAssertionMessage(util, assertion, hasArgs) {
+    const not = util.flag(assertion, 'negate') ? 'not.' : '';
+    const name = `${util.flag(assertion, '_name')}(${hasArgs ? 'expected' : ''})`;
+    const promiseName = util.flag(assertion, 'promise');
+    const promise = promiseName ? `.${promiseName}` : '';
+    return `expect(actual)${promise}.${not}${name}`;
+}
+function getError(expected, promise) {
+    if ('function' != typeof expected) {
+        if (!promise) throw new Error(`expected must be a function, received ${typeof expected}`);
+        return expected;
+    }
+    try {
+        expected();
+    } catch (e) {
+        return e;
+    }
+    throw new Error("snapshot function didn't throw");
+}
+function getTestMeta(test) {
+    return {
+        filepath: test.testPath,
+        name: getTaskNameWithPrefix(test),
+        testId: test.testId
+    };
+}
+const SnapshotPlugin = (workerState)=>{
+    let _client;
+    if (!workerState.snapshotClient) workerState.snapshotClient = new SnapshotClient({
+        isEqual: (received, expected)=>dist_equals(received, expected, [
+                iterableEquality,
+                subsetEquality
+            ])
+    });
+    _client = workerState.snapshotClient;
+    function getSnapshotClient() {
+        return _client;
+    }
+    return (chai, utils)=>{
+        function getTest(obj) {
+            const test = utils.flag(obj, 'vitest-test');
+            return test;
+        }
+        function getTestOrThrow(assertionName, obj) {
+            const test = getTest(obj);
+            if (!test) throw new Error(`'${assertionName}' cannot be used without test context`);
+            return test;
+        }
+        for (const key of [
+            'matchSnapshot',
+            'toMatchSnapshot'
+        ])utils.addMethod(chai.Assertion.prototype, key, function(properties, message) {
+            utils.flag(this, '_name', key);
+            const isNot = utils.flag(this, 'negate');
+            if (isNot) throw new Error(`${key} cannot be used with "not"`);
+            const expected = utils.flag(this, 'object');
+            const test = getTestOrThrow(key, this);
+            if ('string' == typeof properties && void 0 === message) {
+                message = properties;
+                properties = void 0;
+            }
+            const errorMessage = utils.flag(this, 'message');
+            getSnapshotClient().assert({
+                received: expected,
+                message,
+                isInline: false,
+                properties,
+                errorMessage,
+                ...getTestMeta(test)
+            });
+        });
+        utils.addMethod(chai.Assertion.prototype, 'toMatchFileSnapshot', function(file, message) {
+            utils.flag(this, '_name', 'toMatchFileSnapshot');
+            const isNot = utils.flag(this, 'negate');
+            if (isNot) throw new Error('toMatchFileSnapshot cannot be used with "not"');
+            const error = new Error('resolves');
+            const expected = utils.flag(this, 'object');
+            const test = getTestOrThrow('toMatchFileSnapshot', this);
+            const errorMessage = utils.flag(this, 'message');
+            const promise = getSnapshotClient().assertRaw({
+                received: expected,
+                message,
+                isInline: false,
+                rawSnapshot: {
+                    file
+                },
+                errorMessage,
+                ...getTestMeta(test)
+            });
+            return recordAsyncExpect(test, promise, createAssertionMessage(utils, this, true), error);
+        });
+        utils.addMethod(chai.Assertion.prototype, 'toMatchInlineSnapshot', function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
+            utils.flag(this, '_name', 'toMatchInlineSnapshot');
+            const isNot = utils.flag(this, 'negate');
+            if (isNot) throw new Error('toMatchInlineSnapshot cannot be used with "not"');
+            const test = getTest(this);
+            const expected = utils.flag(this, 'object');
+            const error = utils.flag(this, 'error');
+            if ('string' == typeof properties) {
+                message = inlineSnapshot;
+                inlineSnapshot = properties;
+                properties = void 0;
+            }
+            if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
+            const errorMessage = utils.flag(this, 'message');
+            getSnapshotClient().assert({
+                received: expected,
+                message,
+                isInline: true,
+                properties,
+                inlineSnapshot,
+                error,
+                errorMessage,
+                ...test ? getTestMeta(test) : {
+                    filepath: workerState.testPath,
+                    name: 'toMatchInlineSnapshot',
+                    testId: String(workerState.taskId)
+                }
+            });
+        });
+        utils.addMethod(chai.Assertion.prototype, 'toThrowErrorMatchingSnapshot', function(message) {
+            utils.flag(this, '_name', 'toThrowErrorMatchingSnapshot');
+            const isNot = utils.flag(this, 'negate');
+            if (isNot) throw new Error('toThrowErrorMatchingSnapshot cannot be used with "not"');
+            const expected = utils.flag(this, 'object');
+            const test = getTestOrThrow('toThrowErrorMatchingSnapshot', this);
+            const promise = utils.flag(this, 'promise');
+            const errorMessage = utils.flag(this, 'message');
+            getSnapshotClient().assert({
+                received: getError(expected, promise),
+                message,
+                errorMessage,
+                ...getTestMeta(test)
+            });
+        });
+        utils.addMethod(chai.Assertion.prototype, 'toThrowErrorMatchingInlineSnapshot', function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
+            const isNot = utils.flag(this, 'negate');
+            if (isNot) throw new Error('toThrowErrorMatchingInlineSnapshot cannot be used with "not"');
+            const test = getTest(this);
+            const expected = utils.flag(this, 'object');
+            const error = utils.flag(this, 'error');
+            const promise = utils.flag(this, 'promise');
+            const errorMessage = utils.flag(this, 'message');
+            if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
+            getSnapshotClient().assert({
+                received: getError(expected, promise),
+                message,
+                inlineSnapshot,
+                isInline: true,
+                error,
+                errorMessage,
+                ...test ? getTestMeta(test) : {
+                    name: 'toThrowErrorMatchingInlineSnapshot',
+                    filepath: workerState.testPath,
+                    testId: String(workerState.taskId)
+                }
+            });
+        });
+        utils.addMethod(chai.expect, 'addSnapshotSerializer', addSerializer);
+    };
+};
+export { snapshot_namespaceObject };