@vitest/snapshot 2.1.2 → 2.1.4

package/dist/index.js

@@ -1,1632 +1,1386 @@
-import { plugins, format } from '@vitest/pretty-format';
 import { resolve as resolve$2 } from 'pathe';
+import { plugins, format } from '@vitest/pretty-format';
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-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        // 0-9
-				: code < 65 ? code - 11
-				: code < 91 ? code + 11        // A-Z
-				: code < 97 ? code - 37
-				: code < 123 ? code + 5        // a-z
-				: 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 naturalCompare = /*@__PURE__*/getDefaultExportFromCjs(naturalCompareExports);
-
-function notNullish(v) {
-  return v != null;
+const comma = ','.charCodeAt(0);
+const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const intToChar = new Uint8Array(64); // 64 possible chars.
+const charToInt = new Uint8Array(128); // z is 122 in ASCII
+for (let i = 0; i < chars.length; i++) {
+    const c = chars.charCodeAt(i);
+    intToChar[i] = c;
+    charToInt[c] = i;
 }
-function isPrimitive(value) {
-  return value === null || typeof value !== "function" && typeof value !== "object";
+function decodeInteger(reader, relative) {
+    let value = 0;
+    let shift = 0;
+    let integer = 0;
+    do {
+        const c = reader.next();
+        integer = charToInt[c];
+        value |= (integer & 31) << shift;
+        shift += 5;
+    } while (integer & 32);
+    const shouldNegate = value & 1;
+    value >>>= 1;
+    if (shouldNegate) {
+        value = -0x80000000 | -value;
+    }
+    return relative + value;
 }
-function isObject(item) {
-  return item != null && typeof item === "object" && !Array.isArray(item);
+function hasMoreVlq(reader, max) {
+    if (reader.pos >= max)
+        return false;
+    return reader.peek() !== comma;
 }
-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;
-      }
+class StringReader {
+    constructor(buffer) {
+        this.pos = 0;
+        this.buffer = buffer;
     }
-    if (!inString) {
-      if (char === "(") {
-        startedBracers++;
-      }
-      if (char === ")") {
-        endedBracers++;
-      }
+    next() {
+        return this.buffer.charCodeAt(this.pos++);
     }
-    if (startedBracers && endedBracers && startedBracers === endedBracers) {
-      return charIndex;
+    peek() {
+        return this.buffer.charCodeAt(this.pos);
+    }
+    indexOf(char) {
+        const { buffer, pos } = this;
+        const idx = buffer.indexOf(char, pos);
+        return idx === -1 ? buffer.length : idx;
     }
-  }
-  return null;
 }
 
-let getPromiseValue = () => 'Promise{…}';
-try {
-    // @ts-ignore
-    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>}';
+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];
+                }
             }
-            return `Promise${state === kRejected ? '!' : ''}{${options.inspect(innerValue, options)}}`;
-        };
-    }
+            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;
 }
-catch (notNode) {
-    /* ignore */
+function sort(line) {
+    line.sort(sortComparator$1);
+}
+function sortComparator$1(a, b) {
+    return a[0] - b[0];
 }
 
-/* !
- * loupe
- * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com>
- * MIT Licensed
+// Matches the scheme of a URL, eg "http://"
+const schemeRegex = /^[\w+.-]+:\/\//;
+/**
+ * Matches the parts of a URL:
+ * 1. Scheme, including ":", guaranteed.
+ * 2. User/password, including "@", optional.
+ * 3. Host, guaranteed.
+ * 4. Port, including ":", optional.
+ * 5. Path, including "/", optional.
+ * 6. Query, including "?", optional.
+ * 7. Hash, including "#", optional.
  */
-let nodeInspect = false;
-try {
-    // eslint-disable-next-line global-require
-    // @ts-ignore
-    const nodeUtil = require('util');
-    nodeInspect = nodeUtil.inspect ? nodeUtil.inspect.custom : false;
+const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+/**
+ * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
+ * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
+ *
+ * 1. Host, optional.
+ * 2. Path, which may include "/", guaranteed.
+ * 3. Query, including "?", optional.
+ * 4. Hash, including "#", optional.
+ */
+const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+var 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";
+})(UrlType || (UrlType = {}));
+function isAbsoluteUrl(input) {
+    return schemeRegex.test(input);
 }
-catch (noNodeInspect) {
-    nodeInspect = false;
+function isSchemeRelativeUrl(input) {
+    return input.startsWith('//');
 }
-
-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 isAbsolutePath(input) {
+    return input.startsWith('/');
 }
-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;
+function isFileUrl(input) {
+    return input.startsWith('file:');
+}
+function isRelative(input) {
+    return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+    const match = urlRegex.exec(input);
+    return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || '');
+}
+function parseFileUrl(input) {
+    const match = fileRegex.exec(input);
+    const path = match[2];
+    return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || '');
+}
+function makeUrl(scheme, user, host, port, path, query, hash) {
+    return {
+        scheme,
+        user,
+        host,
+        port,
+        path,
+        query,
+        hash,
+        type: UrlType.Absolute,
+    };
+}
+function parseUrl(input) {
+    if (isSchemeRelativeUrl(input)) {
+        const url = parseAbsoluteUrl('http:' + input);
+        url.scheme = '';
+        url.type = UrlType.SchemeRelative;
+        return url;
+    }
+    if (isAbsolutePath(input)) {
+        const url = parseAbsoluteUrl('http://foo.com' + input);
+        url.scheme = '';
+        url.host = '';
+        url.type = 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('?')
+            ? UrlType.Query
+            : input.startsWith('#')
+                ? UrlType.Hash
+                : UrlType.RelativePath
+        : UrlType.Empty;
+    return url;
+}
+function stripPathFilename(path) {
+    // If a path ends with a parent directory "..", then it's a relative path with excess parent
+    // paths. It's not a file, so we can't strip it.
+    if (path.endsWith('/..'))
+        return path;
+    const index = path.lastIndexOf('/');
+    return path.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+    normalizePath(base, base.type);
+    // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
+    // path).
+    if (url.path === '/') {
+        url.path = base.path;
+    }
+    else {
+        // Resolution happens relative to the base path's directory, not the file.
+        url.path = stripPathFilename(base.path) + url.path;
+    }
+}
+/**
+ * The path can have empty directories "//", unneeded parents "foo/..", or current directory
+ * "foo/.". We need to normalize to a standard representation.
+ */
+function normalizePath(url, type) {
+    const rel = type <= UrlType.RelativePath;
+    const pieces = url.path.split('/');
+    // We need to preserve the first piece always, so that we output a leading slash. The item at
+    // pieces[0] is an empty string.
+    let pointer = 1;
+    // Positive is the number of real directories we've output, used for popping a parent directory.
+    // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo".
+    let positive = 0;
+    // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will
+    // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a
+    // real directory, we won't need to append, unless the other conditions happen again.
+    let addTrailingSlash = false;
+    for (let i = 1; i < pieces.length; i++) {
+        const piece = pieces[i];
+        // An empty directory, could be a trailing slash, or just a double "//" in the path.
+        if (!piece) {
+            addTrailingSlash = true;
+            continue;
+        }
+        // If we encounter a real directory, then we don't need to append anymore.
+        addTrailingSlash = false;
+        // A current directory, which we can always drop.
+        if (piece === '.')
+            continue;
+        // A parent directory, we need to see if there are any real directories we can pop. Else, we
+        // have an excess of parents, and we'll need to keep the "..".
+        if (piece === '..') {
+            if (positive) {
+                addTrailingSlash = true;
+                positive--;
+                pointer--;
+            }
+            else if (rel) {
+                // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute
+                // URL, protocol relative URL, or an absolute path, we don't need to keep excess.
+                pieces[pointer++] = piece;
+            }
+            continue;
+        }
+        // We've encountered a real directory. Move it to the next insertion pointer, which accounts for
+        // any popped or dropped directories.
+        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;
+}
+/**
+ * Attempts to resolve `input` URL/path relative to `base`.
+ */
+function resolve$1(input, base) {
+    if (!input && !base)
+        return '';
+    const url = parseUrl(input);
+    let inputType = url.type;
+    if (base && inputType !== UrlType.Absolute) {
+        const baseUrl = parseUrl(base);
+        const baseType = baseUrl.type;
+        switch (inputType) {
+            case UrlType.Empty:
+                url.hash = baseUrl.hash;
+            // fall through
+            case UrlType.Hash:
+                url.query = baseUrl.query;
+            // fall through
+            case UrlType.Query:
+            case UrlType.RelativePath:
+                mergePaths(url, baseUrl);
+            // fall through
+            case UrlType.AbsolutePath:
+                // The host, user, and port are joined, you can't copy one without the others.
+                url.user = baseUrl.user;
+                url.host = baseUrl.host;
+                url.port = baseUrl.port;
+            // fall through
+            case UrlType.SchemeRelative:
+                // The input doesn't have a schema at least, so we need to copy at least that over.
+                url.scheme = baseUrl.scheme;
+        }
+        if (baseType > inputType)
+            inputType = baseType;
+    }
+    normalizePath(url, inputType);
+    const queryHash = url.query + url.hash;
+    switch (inputType) {
+        // This is impossible, because of the empty checks at the start of the function.
+        // case UrlType.Empty:
+        case UrlType.Hash:
+        case UrlType.Query:
+            return queryHash;
+        case UrlType.RelativePath: {
+            // The first char is always a "/", and we need it to be relative.
+            const path = url.path.slice(1);
+            if (!path)
+                return queryHash || '.';
+            if (isRelative(base || input) && !isRelative(path)) {
+                // If base started with a leading ".", or there is no base and input started with a ".",
+                // then we need to ensure that the relative path starts with a ".". We don't know if
+                // relative starts with a "..", though, so check before prepending.
+                return './' + path + queryHash;
+            }
+            return path + queryHash;
+        }
+        case UrlType.AbsolutePath:
+            return url.path + queryHash;
+        default:
+            return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
     }
-    counted += lineLength;
-  }
-  return line + 1;
 }
 
-var jsTokens_1;
-var hasRequiredJsTokens;
+function resolve(input, base) {
+    // The base is always treated as a directory, if it's not empty.
+    // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
+    // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
+    if (base && !base.endsWith('/'))
+        base += '/';
+    return resolve$1(input, base);
+}
 
-function requireJsTokens () {
-	if (hasRequiredJsTokens) return jsTokens_1;
-	hasRequiredJsTokens = 1;
-	// Copyright 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Simon Lydell
-	// License: MIT.
-	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();
-
-// src/index.ts
-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);
-
-// src/index.ts
-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 = !1) {
-  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 = !1) {
-  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;
-}
-
-// src/browser.ts
-p(!1);
-
-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(plugin) {
-  PLUGINS = [plugin].concat(PLUGINS);
-}
-function getSerializers() {
-  return PLUGINS;
+/**
+ * Removes everything after the last "/", but leaves the slash.
+ */
+function stripFilename(path) {
+    if (!path)
+        return '';
+    const index = path.lastIndexOf('/');
+    return path.slice(0, index + 1);
 }
 
-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 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 we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If
+    // not, we do not want to modify the consumer's input array.
+    if (!owned)
+        mappings = mappings.slice();
+    for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
+        mappings[i] = sortSegments(mappings[i], owned);
     }
-  }
-  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;
+    return mappings;
 }
-const escapeRegex = true;
-const printFunctionName = false;
-function serialize(val, indent = 2, formatOverrides = {}) {
-  return normalizeNewlines(
-    format(val, {
-      escapeRegex,
-      indent,
-      plugins: getSerializers(),
-      printFunctionName,
-      ...formatOverrides
-    })
-  );
+function nextUnsortedSegmentLine(mappings, start) {
+    for (let i = start; i < mappings.length; i++) {
+        if (!isSorted(mappings[i]))
+            return i;
+    }
+    return mappings.length;
 }
-function escapeBacktickString(str) {
-  return str.replace(/`|\\|\$\{/g, "\\$&");
+function isSorted(line) {
+    for (let j = 1; j < line.length; j++) {
+        if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+            return false;
+        }
+    }
+    return true;
 }
-function printBacktickString(str) {
-  return `\`${escapeBacktickString(str)}\``;
+function sortSegments(line, owned) {
+    if (!owned)
+        line = line.slice();
+    return line.sort(sortComparator);
 }
-function normalizeNewlines(string) {
-  return string.replace(/\r\n|\r/g, "\n");
+function sortComparator(a, b) {
+    return a[COLUMN] - b[COLUMN];
 }
-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;
+let found = false;
+/**
+ * A binary search implementation that returns the index if a match is found.
+ * If no match is found, then the left-index (the index associated with the item that comes just
+ * before the desired index) is returned. To maintain proper sort order, a splice would happen at
+ * the next index:
+ *
+ * ```js
+ * const array = [1, 3];
+ * const needle = 2;
+ * const index = binarySearch(array, needle, (item, needle) => item - needle);
+ *
+ * assert.equal(index, 0);
+ * array.splice(index + 1, 0, needle);
+ * assert.deepEqual(array, [1, 2, 3]);
+ * ```
+ */
+function binarySearch(haystack, needle, low, high) {
+    while (low <= high) {
+        const mid = low + ((high - low) >> 1);
+        const cmp = haystack[mid][COLUMN] - needle;
+        if (cmp === 0) {
+            found = true;
+            return mid;
+        }
+        if (cmp < 0) {
+            low = mid + 1;
+        }
+        else {
+            high = mid - 1;
+        }
     }
-    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;
+    found = false;
+    return low - 1;
 }
-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;
+function upperBound(haystack, needle, index) {
+    for (let i = index + 1; i < haystack.length; index = i++) {
+        if (haystack[i][COLUMN] !== needle)
+            break;
     }
-  });
-  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); // 64 possible chars.
-const charToInt = new Uint8Array(128); // z is 122 in ASCII
-for (let i = 0; i < chars.length; i++) {
-    const c = chars.charCodeAt(i);
-    intToChar[i] = c;
-    charToInt[c] = i;
+    return index;
 }
-function decodeInteger(reader, relative) {
-    let value = 0;
-    let shift = 0;
-    let integer = 0;
-    do {
-        const c = reader.next();
-        integer = charToInt[c];
-        value |= (integer & 31) << shift;
-        shift += 5;
-    } while (integer & 32);
-    const shouldNegate = value & 1;
-    value >>>= 1;
-    if (shouldNegate) {
-        value = -0x80000000 | -value;
+function lowerBound(haystack, needle, index) {
+    for (let i = index - 1; i >= 0; index = i--) {
+        if (haystack[i][COLUMN] !== needle)
+            break;
     }
-    return relative + value;
+    return index;
 }
-function hasMoreVlq(reader, max) {
-    if (reader.pos >= max)
-        return false;
-    return reader.peek() !== comma;
+function memoizedState() {
+    return {
+        lastKey: -1,
+        lastNeedle: -1,
+        lastIndex: -1,
+    };
 }
-class StringReader {
-    constructor(buffer) {
-        this.pos = 0;
-        this.buffer = buffer;
-    }
-    next() {
-        return this.buffer.charCodeAt(this.pos++);
-    }
-    peek() {
-        return this.buffer.charCodeAt(this.pos);
-    }
-    indexOf(char) {
-        const { buffer, pos } = this;
-        const idx = buffer.indexOf(char, pos);
-        return idx === -1 ? buffer.length : idx;
+/**
+ * This overly complicated beast is just to record the last tested line/column and the resulting
+ * index, allowing us to skip a few tests if mappings are monotonically increasing.
+ */
+function memoizedBinarySearch(haystack, needle, state, key) {
+    const { lastKey, lastNeedle, lastIndex } = state;
+    let low = 0;
+    let high = haystack.length - 1;
+    if (key === lastKey) {
+        if (needle === lastNeedle) {
+            found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+            return lastIndex;
+        }
+        if (needle >= lastNeedle) {
+            // lastIndex may be -1 if the previous needle was not found.
+            low = lastIndex === -1 ? 0 : lastIndex;
+        }
+        else {
+            high = lastIndex;
+        }
     }
+    state.lastKey = key;
+    state.lastNeedle = needle;
+    return (state.lastIndex = binarySearch(haystack, needle, low, high));
 }
 
-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++;
+const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)';
+const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)';
+const LEAST_UPPER_BOUND = -1;
+const GREATEST_LOWER_BOUND = 1;
+class TraceMap {
+    constructor(map, mapUrl) {
+        const isString = typeof map === 'string';
+        if (!isString && map._decodedMemo)
+            return map;
+        const parsed = (isString ? JSON.parse(map) : map);
+        const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+        this.version = version;
+        this.file = file;
+        this.names = names || [];
+        this.sourceRoot = sourceRoot;
+        this.sources = sources;
+        this.sourcesContent = sourcesContent;
+        this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || undefined;
+        const from = resolve(sourceRoot || '', stripFilename(mapUrl));
+        this.resolvedSources = sources.map((s) => resolve(s || '', from));
+        const { mappings } = parsed;
+        if (typeof mappings === 'string') {
+            this._encoded = mappings;
+            this._decoded = undefined;
         }
-        if (!sorted)
-            sort(line);
-        decoded.push(line);
-        reader.pos = semi + 1;
-    } while (reader.pos <= length);
-    return decoded;
-}
-function sort(line) {
-    line.sort(sortComparator$1);
+        else {
+            this._encoded = undefined;
+            this._decoded = maybeSort(mappings, isString);
+        }
+        this._decodedMemo = memoizedState();
+        this._bySources = undefined;
+        this._bySourceMemos = undefined;
+    }
 }
-function sortComparator$1(a, b) {
-    return a[0] - b[0];
+/**
+ * Typescript doesn't allow friend access to private fields, so this just casts the map into a type
+ * with public access modifiers.
+ */
+function cast(map) {
+    return map;
 }
-
-// Matches the scheme of a URL, eg "http://"
-const schemeRegex = /^[\w+.-]+:\/\//;
 /**
- * Matches the parts of a URL:
- * 1. Scheme, including ":", guaranteed.
- * 2. User/password, including "@", optional.
- * 3. Host, guaranteed.
- * 4. Port, including ":", optional.
- * 5. Path, including "/", optional.
- * 6. Query, including "?", optional.
- * 7. Hash, including "#", optional.
+ * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
  */
-const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+function decodedMappings(map) {
+    var _a;
+    return ((_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded)));
+}
 /**
- * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
- * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
- *
- * 1. Host, optional.
- * 2. Path, which may include "/", guaranteed.
- * 3. Query, including "?", optional.
- * 4. Hash, including "#", optional.
+ * A higher-level API to find the source/line/column associated with a generated line/column
+ * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
+ * `source-map` library.
  */
-const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
-var 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";
-})(UrlType || (UrlType = {}));
-function isAbsoluteUrl(input) {
-    return schemeRegex.test(input);
+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);
+    // It's common for parent source maps to have pointers to lines that have no
+    // mapping (like a "//# sourceMappingURL=") at the end of the child file.
+    if (line >= decoded.length)
+        return OMapping(null, null, null, null);
+    const segments = decoded[line];
+    const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+    if (index === -1)
+        return OMapping(null, null, null, null);
+    const segment = segments[index];
+    if (segment.length === 1)
+        return OMapping(null, null, null, null);
+    const { names, resolvedSources } = map;
+    return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
 }
-function isSchemeRelativeUrl(input) {
-    return input.startsWith('//');
+function OMapping(source, line, column, name) {
+    return { source, line, column, name };
 }
-function isAbsolutePath(input) {
-    return input.startsWith('/');
+function traceSegmentInternal(segments, memo, line, column, bias) {
+    let index = memoizedBinarySearch(segments, column, memo, line);
+    if (found) {
+        index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+    }
+    else if (bias === LEAST_UPPER_BOUND)
+        index++;
+    if (index === -1 || index === segments.length)
+        return -1;
+    return index;
 }
-function isFileUrl(input) {
-    return input.startsWith('file:');
+
+function notNullish(v) {
+  return v != null;
 }
-function isRelative(input) {
-    return /^[.?#]/.test(input);
+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;
 }
-function parseAbsoluteUrl(input) {
-    const match = urlRegex.exec(input);
-    return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || '');
+
+const CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m;
+const SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
+const stackIgnorePatterns = [
+  "node:internal",
+  /\/packages\/\w+\/dist\//,
+  /\/@vitest\/\w+\/dist\//,
+  "/vitest/dist/",
+  "/vitest/src/",
+  "/vite-node/dist/",
+  "/vite-node/src/",
+  "/node_modules/chai/",
+  "/node_modules/tinypool/",
+  "/node_modules/tinyspy/",
+  // browser related deps
+  "/deps/chunk-",
+  "/deps/@vitest",
+  "/deps/loupe",
+  "/deps/chai",
+  /node:\w+/,
+  /__vitest_test__/,
+  /__vitest_browser__/,
+  /\/deps\/vitest_/
+];
+function extractLocation(urlLike) {
+  if (!urlLike.includes(":")) {
+    return [urlLike];
+  }
+  const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
+  const parts = regExp.exec(urlLike.replace(/^\(|\)$/g, ""));
+  if (!parts) {
+    return [urlLike];
+  }
+  let url = parts[1];
+  if (url.startsWith("async ")) {
+    url = url.slice(6);
+  }
+  if (url.startsWith("http:") || url.startsWith("https:")) {
+    const urlObj = new URL(url);
+    url = urlObj.pathname;
+  }
+  if (url.startsWith("/@fs/")) {
+    const isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url);
+    url = url.slice(isWindows ? 5 : 4);
+  }
+  return [url, parts[2] || void 0, parts[3] || void 0];
 }
-function 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 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 makeUrl(scheme, user, host, port, path, query, hash) {
-    return {
-        scheme,
-        user,
-        host,
-        port,
-        path,
-        query,
-        hash,
-        type: UrlType.Absolute,
-    };
+function parseSingleV8Stack(raw) {
+  let line = raw.trim();
+  if (!CHROME_IE_STACK_REGEXP.test(line)) {
+    return null;
+  }
+  if (line.includes("(eval ")) {
+    line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
+  }
+  let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
+  const location = sanitizedLine.match(/ (\(.+\)$)/);
+  sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
+  const [url, lineNumber, columnNumber] = extractLocation(
+    location ? location[1] : sanitizedLine
+  );
+  let method = location && sanitizedLine || "";
+  let file = url && ["eval", "<anonymous>"].includes(url) ? void 0 : url;
+  if (!file || !lineNumber || !columnNumber) {
+    return null;
+  }
+  if (method.startsWith("async ")) {
+    method = method.slice(6);
+  }
+  if (file.startsWith("file://")) {
+    file = file.slice(7);
+  }
+  file = resolve$2(file);
+  if (method) {
+    method = method.replace(/__vite_ssr_import_\d+__\./g, "");
+  }
+  return {
+    method,
+    file,
+    line: Number.parseInt(lineNumber),
+    column: Number.parseInt(columnNumber)
+  };
 }
-function parseUrl(input) {
-    if (isSchemeRelativeUrl(input)) {
-        const url = parseAbsoluteUrl('http:' + input);
-        url.scheme = '';
-        url.type = UrlType.SchemeRelative;
-        return url;
+function parseStacktrace(stack, options = {}) {
+  const { ignoreStackEntries = stackIgnorePatterns } = options;
+  let stacks = !CHROME_IE_STACK_REGEXP.test(stack) ? parseFFOrSafariStackTrace(stack) : parseV8Stacktrace(stack);
+  if (ignoreStackEntries.length) {
+    stacks = stacks.filter(
+      (stack2) => !ignoreStackEntries.some((p) => stack2.file.match(p))
+    );
+  }
+  return stacks.map((stack2) => {
+    var _a;
+    if (options.getFileName) {
+      stack2.file = options.getFileName(stack2.file);
     }
-    if (isAbsolutePath(input)) {
-        const url = parseAbsoluteUrl('http://foo.com' + input);
-        url.scheme = '';
-        url.host = '';
-        url.type = UrlType.AbsolutePath;
-        return url;
+    const map = (_a = options.getSourceMap) == null ? void 0 : _a.call(options, stack2.file);
+    if (!map || typeof map !== "object" || !map.version) {
+      return stack2;
     }
-    if (isFileUrl(input))
-        return parseFileUrl(input);
-    if (isAbsoluteUrl(input))
-        return parseAbsoluteUrl(input);
-    const url = parseAbsoluteUrl('http://foo.com/' + input);
-    url.scheme = '';
-    url.host = '';
-    url.type = input
-        ? input.startsWith('?')
-            ? UrlType.Query
-            : input.startsWith('#')
-                ? UrlType.Hash
-                : UrlType.RelativePath
-        : UrlType.Empty;
-    return url;
+    const traceMap = new TraceMap(map);
+    const { line, column } = originalPositionFor(traceMap, stack2);
+    if (line != null && column != null) {
+      return { ...stack2, line, column };
+    }
+    return stack2;
+  });
 }
-function stripPathFilename(path) {
-    // If a path ends with a parent directory "..", then it's a relative path with excess parent
-    // paths. It's not a file, so we can't strip it.
-    if (path.endsWith('/..'))
-        return path;
-    const index = path.lastIndexOf('/');
-    return path.slice(0, index + 1);
+function parseFFOrSafariStackTrace(stack) {
+  return stack.split("\n").map((line) => parseSingleFFOrSafariStack(line)).filter(notNullish);
 }
-function mergePaths(url, base) {
-    normalizePath(base, base.type);
-    // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
-    // path).
-    if (url.path === '/') {
-        url.path = base.path;
-    }
-    else {
-        // Resolution happens relative to the base path's directory, not the file.
-        url.path = stripPathFilename(base.path) + url.path;
-    }
+function parseV8Stacktrace(stack) {
+  return stack.split("\n").map((line) => parseSingleV8Stack(line)).filter(notNullish);
 }
-/**
- * The path can have empty directories "//", unneeded parents "foo/..", or current directory
- * "foo/.". We need to normalize to a standard representation.
- */
-function normalizePath(url, type) {
-    const rel = type <= UrlType.RelativePath;
-    const pieces = url.path.split('/');
-    // We need to preserve the first piece always, so that we output a leading slash. The item at
-    // pieces[0] is an empty string.
-    let pointer = 1;
-    // Positive is the number of real directories we've output, used for popping a parent directory.
-    // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo".
-    let positive = 0;
-    // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will
-    // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a
-    // real directory, we won't need to append, unless the other conditions happen again.
-    let addTrailingSlash = false;
-    for (let i = 1; i < pieces.length; i++) {
-        const piece = pieces[i];
-        // An empty directory, could be a trailing slash, or just a double "//" in the path.
-        if (!piece) {
-            addTrailingSlash = true;
-            continue;
-        }
-        // If we encounter a real directory, then we don't need to append anymore.
-        addTrailingSlash = false;
-        // A current directory, which we can always drop.
-        if (piece === '.')
-            continue;
-        // A parent directory, we need to see if there are any real directories we can pop. Else, we
-        // have an excess of parents, and we'll need to keep the "..".
-        if (piece === '..') {
-            if (positive) {
-                addTrailingSlash = true;
-                positive--;
-                pointer--;
-            }
-            else if (rel) {
-                // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute
-                // URL, protocol relative URL, or an absolute path, we don't need to keep excess.
-                pieces[pointer++] = piece;
+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(
+      (f) => options.frameFilter(e, f) !== false
+    );
+  }
+  e.stacks = stackFrames;
+  return stackFrames;
+}
+
+let getPromiseValue = () => 'Promise{…}';
+try {
+    // @ts-ignore
+    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>}';
             }
-            continue;
-        }
-        // We've encountered a real directory. Move it to the next insertion pointer, which accounts for
-        // any popped or dropped directories.
-        pieces[pointer++] = piece;
-        positive++;
-    }
-    let path = '';
-    for (let i = 1; i < pointer; i++) {
-        path += '/' + pieces[i];
-    }
-    if (!path || (addTrailingSlash && !path.endsWith('/..'))) {
-        path += '/';
+            return `Promise${state === kRejected ? '!' : ''}{${options.inspect(innerValue, options)}}`;
+        };
     }
-    url.path = path;
 }
-/**
- * Attempts to resolve `input` URL/path relative to `base`.
+catch (notNode) {
+    /* ignore */
+}
+
+/* !
+ * loupe
+ * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
  */
-function resolve$1(input, base) {
-    if (!input && !base)
-        return '';
-    const url = parseUrl(input);
-    let inputType = url.type;
-    if (base && inputType !== UrlType.Absolute) {
-        const baseUrl = parseUrl(base);
-        const baseType = baseUrl.type;
-        switch (inputType) {
-            case UrlType.Empty:
-                url.hash = baseUrl.hash;
-            // fall through
-            case UrlType.Hash:
-                url.query = baseUrl.query;
-            // fall through
-            case UrlType.Query:
-            case UrlType.RelativePath:
-                mergePaths(url, baseUrl);
-            // fall through
-            case UrlType.AbsolutePath:
-                // The host, user, and port are joined, you can't copy one without the others.
-                url.user = baseUrl.user;
-                url.host = baseUrl.host;
-                url.port = baseUrl.port;
-            // fall through
-            case UrlType.SchemeRelative:
-                // The input doesn't have a schema at least, so we need to copy at least that over.
-                url.scheme = baseUrl.scheme;
-        }
-        if (baseType > inputType)
-            inputType = baseType;
-    }
-    normalizePath(url, inputType);
-    const queryHash = url.query + url.hash;
-    switch (inputType) {
-        // This is impossible, because of the empty checks at the start of the function.
-        // case UrlType.Empty:
-        case UrlType.Hash:
-        case UrlType.Query:
-            return queryHash;
-        case UrlType.RelativePath: {
-            // The first char is always a "/", and we need it to be relative.
-            const path = url.path.slice(1);
-            if (!path)
-                return queryHash || '.';
-            if (isRelative(base || input) && !isRelative(path)) {
-                // If base started with a leading ".", or there is no base and input started with a ".",
-                // then we need to ensure that the relative path starts with a ".". We don't know if
-                // relative starts with a "..", though, so check before prepending.
-                return './' + path + queryHash;
-            }
-            return path + queryHash;
-        }
-        case UrlType.AbsolutePath:
-            return url.path + queryHash;
-        default:
-            return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
-    }
+let nodeInspect = false;
+try {
+    // eslint-disable-next-line global-require
+    // @ts-ignore
+    const nodeUtil = require('util');
+    nodeInspect = nodeUtil.inspect ? nodeUtil.inspect.custom : false;
+}
+catch (noNodeInspect) {
+    nodeInspect = false;
 }
 
-function resolve(input, base) {
-    // The base is always treated as a directory, if it's not empty.
-    // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
-    // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
-    if (base && !base.endsWith('/'))
-        base += '/';
-    return resolve$1(input, base);
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-/**
- * Removes everything after the last "/", but leaves the slash.
- */
-function stripFilename(path) {
-    if (!path)
-        return '';
-    const index = path.lastIndexOf('/');
-    return path.slice(0, index + 1);
+var jsTokens_1;
+var hasRequiredJsTokens;
+
+function requireJsTokens () {
+	if (hasRequiredJsTokens) return jsTokens_1;
+	hasRequiredJsTokens = 1;
+	// Copyright 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Simon Lydell
+	// License: MIT.
+	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;
 }
 
-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 we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If
-    // not, we do not want to modify the consumer's input array.
-    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];
-}
+requireJsTokens();
 
-let found = false;
-/**
- * A binary search implementation that returns the index if a match is found.
- * If no match is found, then the left-index (the index associated with the item that comes just
- * before the desired index) is returned. To maintain proper sort order, a splice would happen at
- * the next index:
- *
- * ```js
- * const array = [1, 3];
- * const needle = 2;
- * const index = binarySearch(array, needle, (item, needle) => item - needle);
- *
- * assert.equal(index, 0);
- * array.splice(index + 1, 0, needle);
- * assert.deepEqual(array, [1, 2, 3]);
- * ```
- */
-function binarySearch(haystack, needle, low, high) {
-    while (low <= high) {
-        const mid = low + ((high - low) >> 1);
-        const cmp = haystack[mid][COLUMN] - needle;
-        if (cmp === 0) {
-            found = true;
-            return mid;
-        }
-        if (cmp < 0) {
-            low = mid + 1;
-        }
-        else {
-            high = mid - 1;
-        }
-    }
-    found = false;
-    return low - 1;
-}
-function upperBound(haystack, needle, index) {
-    for (let i = index + 1; i < haystack.length; index = i++) {
-        if (haystack[i][COLUMN] !== needle)
-            break;
-    }
-    return index;
-}
-function lowerBound(haystack, needle, index) {
-    for (let i = index - 1; i >= 0; index = i--) {
-        if (haystack[i][COLUMN] !== needle)
-            break;
-    }
-    return index;
-}
-function memoizedState() {
-    return {
-        lastKey: -1,
-        lastNeedle: -1,
-        lastIndex: -1,
-    };
-}
-/**
- * This overly complicated beast is just to record the last tested line/column and the resulting
- * index, allowing us to skip a few tests if mappings are monotonically increasing.
- */
-function memoizedBinarySearch(haystack, needle, state, key) {
-    const { lastKey, lastNeedle, lastIndex } = state;
-    let low = 0;
-    let high = haystack.length - 1;
-    if (key === lastKey) {
-        if (needle === lastNeedle) {
-            found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
-            return lastIndex;
-        }
-        if (needle >= lastNeedle) {
-            // lastIndex may be -1 if the previous needle was not found.
-            low = lastIndex === -1 ? 0 : lastIndex;
-        }
-        else {
-            high = lastIndex;
-        }
-    }
-    state.lastKey = key;
-    state.lastNeedle = needle;
-    return (state.lastIndex = binarySearch(haystack, needle, low, high));
-}
+// src/index.ts
+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);
 
-const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)';
-const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)';
-const LEAST_UPPER_BOUND = -1;
-const GREATEST_LOWER_BOUND = 1;
-class TraceMap {
-    constructor(map, mapUrl) {
-        const isString = typeof map === 'string';
-        if (!isString && map._decodedMemo)
-            return map;
-        const parsed = (isString ? JSON.parse(map) : map);
-        const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
-        this.version = version;
-        this.file = file;
-        this.names = names || [];
-        this.sourceRoot = sourceRoot;
-        this.sources = sources;
-        this.sourcesContent = sourcesContent;
-        this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || undefined;
-        const from = resolve(sourceRoot || '', stripFilename(mapUrl));
-        this.resolvedSources = sources.map((s) => resolve(s || '', from));
-        const { mappings } = parsed;
-        if (typeof mappings === 'string') {
-            this._encoded = mappings;
-            this._decoded = undefined;
-        }
-        else {
-            this._encoded = undefined;
-            this._decoded = maybeSort(mappings, isString);
-        }
-        this._decodedMemo = memoizedState();
-        this._bySources = undefined;
-        this._bySourceMemos = undefined;
-    }
-}
-/**
- * Typescript doesn't allow friend access to private fields, so this just casts the map into a type
- * with public access modifiers.
- */
-function cast(map) {
-    return map;
-}
-/**
- * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
- */
-function decodedMappings(map) {
-    var _a;
-    return ((_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded)));
-}
-/**
- * A higher-level API to find the source/line/column associated with a generated line/column
- * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
- * `source-map` library.
- */
-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);
-    // It's common for parent source maps to have pointers to lines that have no
-    // mapping (like a "//# sourceMappingURL=") at the end of the child file.
-    if (line >= decoded.length)
-        return OMapping(null, null, null, null);
-    const segments = decoded[line];
-    const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
-    if (index === -1)
-        return OMapping(null, null, null, null);
-    const segment = segments[index];
-    if (segment.length === 1)
-        return OMapping(null, null, null, null);
-    const { names, resolvedSources } = map;
-    return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+// src/index.ts
+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);
 }
-function OMapping(source, line, column, name) {
-    return { source, line, column, name };
+a.open = "";
+a.close = "";
+function C(n = !1) {
+  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 traceSegmentInternal(segments, memo, line, column, bias) {
-    let index = memoizedBinarySearch(segments, column, memo, line);
-    if (found) {
-        index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
-    }
-    else if (bias === LEAST_UPPER_BOUND)
-        index++;
-    if (index === -1 || index === segments.length)
-        return -1;
-    return index;
+function p(n = !1) {
+  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;
 }
 
-const CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m;
-const SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
-const stackIgnorePatterns = [
-  "node:internal",
-  /\/packages\/\w+\/dist\//,
-  /\/@vitest\/\w+\/dist\//,
-  "/vitest/dist/",
-  "/vitest/src/",
-  "/vite-node/dist/",
-  "/vite-node/src/",
-  "/node_modules/chai/",
-  "/node_modules/tinypool/",
-  "/node_modules/tinyspy/",
-  // browser related deps
-  "/deps/chunk-",
-  "/deps/@vitest",
-  "/deps/loupe",
-  "/deps/chai",
-  /node:\w+/,
-  /__vitest_test__/,
-  /__vitest_browser__/,
-  /\/deps\/vitest_/
-];
-function extractLocation(urlLike) {
-  if (!urlLike.includes(":")) {
-    return [urlLike];
-  }
-  const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
-  const parts = regExp.exec(urlLike.replace(/^\(|\)$/g, ""));
-  if (!parts) {
-    return [urlLike];
-  }
-  let url = parts[1];
-  if (url.startsWith("async ")) {
-    url = url.slice(6);
-  }
-  if (url.startsWith("http:") || url.startsWith("https:")) {
-    const urlObj = new URL(url);
-    url = urlObj.pathname;
-  }
-  if (url.startsWith("/@fs/")) {
-    const isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url);
-    url = url.slice(isWindows ? 5 : 4);
-  }
-  return [url, parts[2] || void 0, parts[3] || void 0];
-}
-function parseSingleFFOrSafariStack(raw) {
-  let line = raw.trim();
-  if (SAFARI_NATIVE_CODE_REGEXP.test(line)) {
-    return null;
-  }
-  if (line.includes(" > eval")) {
-    line = line.replace(
-      / line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g,
-      ":$1"
-    );
-  }
-  if (!line.includes("@") && !line.includes(":")) {
-    return null;
-  }
-  const functionNameRegex = /((.*".+"[^@]*)?[^@]*)(@)/;
-  const matches = line.match(functionNameRegex);
-  const functionName = matches && matches[1] ? matches[1] : void 0;
-  const [url, lineNumber, columnNumber] = extractLocation(
-    line.replace(functionNameRegex, "")
-  );
-  if (!url || !lineNumber || !columnNumber) {
-    return null;
-  }
-  return {
-    file: url,
-    method: functionName || "",
-    line: Number.parseInt(lineNumber),
-    column: Number.parseInt(columnNumber)
-  };
-}
-function parseSingleV8Stack(raw) {
-  let line = raw.trim();
-  if (!CHROME_IE_STACK_REGEXP.test(line)) {
-    return null;
-  }
-  if (line.includes("(eval ")) {
-    line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
-  }
-  let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
-  const location = sanitizedLine.match(/ (\(.+\)$)/);
-  sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
-  const [url, lineNumber, columnNumber] = extractLocation(
-    location ? location[1] : sanitizedLine
-  );
-  let method = location && sanitizedLine || "";
-  let file = url && ["eval", "<anonymous>"].includes(url) ? void 0 : url;
-  if (!file || !lineNumber || !columnNumber) {
-    return null;
-  }
-  if (method.startsWith("async ")) {
-    method = method.slice(6);
-  }
-  if (file.startsWith("file://")) {
-    file = file.slice(7);
+// src/browser.ts
+p(!1);
+
+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;
   }
-  file = resolve$2(file);
-  if (method) {
-    method = method.replace(/__vite_ssr_import_\d+__\./g, "");
+  for (let i = 0; i < lineNumber - 1; i++) {
+    start += lines[i].length + nl;
   }
-  return {
-    method,
-    file,
-    line: Number.parseInt(lineNumber),
-    column: Number.parseInt(columnNumber)
-  };
+  return start + columnNumber;
 }
-function parseStacktrace(stack, options = {}) {
-  const { ignoreStackEntries = stackIgnorePatterns } = options;
-  let stacks = !CHROME_IE_STACK_REGEXP.test(stack) ? parseFFOrSafariStackTrace(stack) : parseV8Stacktrace(stack);
-  if (ignoreStackEntries.length) {
-    stacks = stacks.filter(
-      (stack2) => !ignoreStackEntries.some((p) => stack2.file.match(p))
+function offsetToLineNumber(source, offset) {
+  if (offset > source.length) {
+    throw new Error(
+      `offset is longer than source length! offset ${offset} > length ${source.length}`
     );
   }
-  return stacks.map((stack2) => {
-    var _a;
-    if (options.getFileName) {
-      stack2.file = options.getFileName(stack2.file);
-    }
-    const map = (_a = options.getSourceMap) == null ? void 0 : _a.call(options, stack2.file);
-    if (!map || typeof map !== "object" || !map.version) {
-      return stack2;
-    }
-    const traceMap = new TraceMap(map);
-    const { line, column } = originalPositionFor(traceMap, stack2);
-    if (line != null && column != null) {
-      return { ...stack2, line, column };
-    }
-    return stack2;
-  });
-}
-function parseFFOrSafariStackTrace(stack) {
-  return stack.split("\n").map((line) => parseSingleFFOrSafariStack(line)).filter(notNullish);
-}
-function parseV8Stacktrace(stack) {
-  return stack.split("\n").map((line) => parseSingleV8Stack(line)).filter(notNullish);
-}
-function parseErrorStacktrace(e, options = {}) {
-  if (!e || isPrimitive(e)) {
-    return [];
-  }
-  if (e.stacks) {
-    return e.stacks;
-  }
-  const stackStr = e.stack || e.stackStr || "";
-  let stackFrames = parseStacktrace(stackStr, options);
-  if (options.frameFilter) {
-    stackFrames = stackFrames.filter(
-      (f) => options.frameFilter(e, f) !== false
-    );
+  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;
   }
-  e.stacks = stackFrames;
-  return stackFrames;
+  return line + 1;
 }
 
 async function saveInlineSnapshots(environment, snapshots) {
@@ -1784,6 +1538,252 @@ 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 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        // 0-9
+				: code < 65 ? code - 11
+				: code < 91 ? code + 11        // A-Z
+				: code < 97 ? code - 37
+				: code < 123 ? code + 5        // a-z
+				: 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 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(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 = /* @__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) {
     this.testFilePath = testFilePath;