first commit

node_modules/@vitest/utils/dist/chunk-_commonjsHelpers.js

@@ -0,0 +1,5 @@
+function getDefaultExportFromCjs(x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+
+export { getDefaultExportFromCjs as g };

node_modules/@vitest/utils/dist/chunk-pathe.M-eThtNZ.js

@@ -0,0 +1,156 @@
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const normalize = function(path) {
+  if (path.length === 0) {
+    return ".";
+  }
+  path = normalizeWindowsPath(path);
+  const isUNCPath = path.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path);
+  const trailingSeparator = path[path.length - 1] === "/";
+  path = normalizeString(path, !isPathAbsolute);
+  if (path.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path)) {
+    path += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path}`;
+    }
+    return `//${path}`;
+  }
+  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join = function(...segments) {
+  let path = "";
+  for (const seg of segments) {
+    if (!seg) {
+      continue;
+    }
+    if (path.length > 0) {
+      const pathTrailing = path[path.length - 1] === "/";
+      const segLeading = seg[0] === "/";
+      const both = pathTrailing && segLeading;
+      if (both) {
+        path += seg.slice(1);
+      } else {
+        path += pathTrailing || segLeading ? seg : `/${seg}`;
+      }
+    } else {
+      path += seg;
+    }
+  }
+  return normalize(path);
+};
+function cwd() {
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+}
+const resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path = index >= 0 ? arguments_[index] : cwd();
+    if (!path || path.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) ; else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+const isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+const dirname = function(p) {
+  const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+  if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
+    segments[0] += "/";
+  }
+  return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+
+export { dirname as d, join as j, resolve as r };

node_modules/@vitest/utils/dist/constants.d.ts

@@ -0,0 +1,21 @@
+declare const KNOWN_ASSET_TYPES: string[];
+declare const KNOWN_ASSET_RE: RegExp;
+declare const CSS_LANGS_RE: RegExp;
+/**
+* Prefix for resolved Ids that are not valid browser import specifiers
+*/
+declare const VALID_ID_PREFIX = "/@id/";
+/**
+* Plugins that use 'virtual modules' (e.g. for helper functions), prefix the
+* module ID with `\0`, a convention from the rollup ecosystem.
+* This prevents other plugins from trying to process the id (like node resolution),
+* and core features like sourcemaps can use this info to differentiate between
+* virtual modules and regular files.
+* `\0` is not a permitted char in import URLs so we have to replace them during
+* import analysis. The id will be decoded back before entering the plugins pipeline.
+* These encoded virtual ids are also prefixed by the VALID_ID_PREFIX, so virtual
+* modules in the browser end up encoded as `/@id/__x00__{id}`
+*/
+declare const NULL_BYTE_PLACEHOLDER = "__x00__";
+
+export { CSS_LANGS_RE, KNOWN_ASSET_RE, KNOWN_ASSET_TYPES, NULL_BYTE_PLACEHOLDER, VALID_ID_PREFIX };

node_modules/@vitest/utils/dist/constants.js

@@ -0,0 +1,49 @@
+// TODO: this is all copy pasted from Vite - can they expose a module that exports only constants?
+const KNOWN_ASSET_TYPES = [
+	"apng",
+	"bmp",
+	"png",
+	"jpe?g",
+	"jfif",
+	"pjpeg",
+	"pjp",
+	"gif",
+	"svg",
+	"ico",
+	"webp",
+	"avif",
+	"mp4",
+	"webm",
+	"ogg",
+	"mp3",
+	"wav",
+	"flac",
+	"aac",
+	"woff2?",
+	"eot",
+	"ttf",
+	"otf",
+	"webmanifest",
+	"pdf",
+	"txt"
+];
+const KNOWN_ASSET_RE = new RegExp(`\\.(${KNOWN_ASSET_TYPES.join("|")})$`);
+const CSS_LANGS_RE = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+/**
+* Prefix for resolved Ids that are not valid browser import specifiers
+*/
+const VALID_ID_PREFIX = `/@id/`;
+/**
+* Plugins that use 'virtual modules' (e.g. for helper functions), prefix the
+* module ID with `\0`, a convention from the rollup ecosystem.
+* This prevents other plugins from trying to process the id (like node resolution),
+* and core features like sourcemaps can use this info to differentiate between
+* virtual modules and regular files.
+* `\0` is not a permitted char in import URLs so we have to replace them during
+* import analysis. The id will be decoded back before entering the plugins pipeline.
+* These encoded virtual ids are also prefixed by the VALID_ID_PREFIX, so virtual
+* modules in the browser end up encoded as `/@id/__x00__{id}`
+*/
+const NULL_BYTE_PLACEHOLDER = `__x00__`;
+
+export { CSS_LANGS_RE, KNOWN_ASSET_RE, KNOWN_ASSET_TYPES, NULL_BYTE_PLACEHOLDER, VALID_ID_PREFIX };

node_modules/@vitest/utils/dist/diff.d.ts

@@ -0,0 +1,93 @@
+import { D as DiffOptions } from './types.d-BCElaP-c.js';
+export { a as DiffOptionsColor, S as SerializedDiffOptions } from './types.d-BCElaP-c.js';
+import '@vitest/pretty-format';
+
+/**
+* Diff Match and Patch
+* Copyright 2018 The diff-match-patch Authors.
+* https://github.com/google/diff-match-patch
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+/**
+* @fileoverview Computes the difference between two texts to create a patch.
+* Applies the patch onto another text, allowing for errors.
+* @author fraser@google.com (Neil Fraser)
+*/
+/**
+* CHANGES by pedrottimark to diff_match_patch_uncompressed.ts file:
+*
+* 1. Delete anything not needed to use diff_cleanupSemantic method
+* 2. Convert from prototype properties to var declarations
+* 3. Convert Diff to class from constructor and prototype
+* 4. Add type annotations for arguments and return values
+* 5. Add exports
+*/
+/**
+* The data structure representing a diff is an array of tuples:
+* [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]
+* which means: delete 'Hello', add 'Goodbye' and keep ' world.'
+*/
+declare const DIFF_DELETE = -1;
+declare const DIFF_INSERT = 1;
+declare const DIFF_EQUAL = 0;
+/**
+* Class representing one diff tuple.
+* Attempts to look like a two-element array (which is what this used to be).
+* @param {number} op Operation, one of: DIFF_DELETE, DIFF_INSERT, DIFF_EQUAL.
+* @param {string} text Text to be deleted, inserted, or retained.
+* @constructor
+*/
+declare class Diff {
+	0: number;
+	1: string;
+	constructor(op: number, text: string);
+}
+
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+declare function diffLinesUnified(aLines: Array<string>, bLines: Array<string>, options?: DiffOptions): string;
+declare function diffLinesUnified2(aLinesDisplay: Array<string>, bLinesDisplay: Array<string>, aLinesCompare: Array<string>, bLinesCompare: Array<string>, options?: DiffOptions): string;
+declare function diffLinesRaw(aLines: Array<string>, bLines: Array<string>, options?: DiffOptions): [Array<Diff>, boolean];
+
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+declare function diffStringsUnified(a: string, b: string, options?: DiffOptions): string;
+declare function diffStringsRaw(a: string, b: string, cleanup: boolean, options?: DiffOptions): [Array<Diff>, boolean];
+
+/**
+* @param a Expected value
+* @param b Received value
+* @param options Diff options
+* @returns {string | null} a string diff
+*/
+declare function diff(a: any, b: any, options?: DiffOptions): string | undefined;
+declare function printDiffOrStringify(received: unknown, expected: unknown, options?: DiffOptions): string | undefined;
+declare function replaceAsymmetricMatcher(actual: any, expected: any, actualReplaced?: WeakSet<WeakKey>, expectedReplaced?: WeakSet<WeakKey>): {
+	replacedActual: any;
+	replacedExpected: any;
+};
+type PrintLabel = (string: string) => string;
+declare function getLabelPrinter(...strings: Array<string>): PrintLabel;
+
+export { DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, Diff, DiffOptions, diff, diffLinesRaw, diffLinesUnified, diffLinesUnified2, diffStringsRaw, diffStringsUnified, getLabelPrinter, printDiffOrStringify, replaceAsymmetricMatcher };

node_modules/@vitest/utils/dist/display.d.ts

@@ -0,0 +1,28 @@
+import { PrettyFormatOptions } from '@vitest/pretty-format';
+
+type Inspect = (value: unknown, options: Options) => string;
+interface Options {
+	showHidden: boolean;
+	depth: number;
+	colors: boolean;
+	customInspect: boolean;
+	showProxy: boolean;
+	maxArrayLength: number;
+	breakLength: number;
+	truncate: number;
+	seen: unknown[];
+	inspect: Inspect;
+	stylize: (value: string, styleType: string) => string;
+}
+type LoupeOptions = Partial<Options>;
+interface StringifyOptions extends PrettyFormatOptions {
+	maxLength?: number;
+}
+declare function stringify(object: unknown, maxDepth?: number, { maxLength, ...options }?: StringifyOptions): string;
+declare const formatRegExp: RegExp;
+declare function format(...args: unknown[]): string;
+declare function inspect(obj: unknown, options?: LoupeOptions): string;
+declare function objDisplay(obj: unknown, options?: LoupeOptions): string;
+
+export { format, formatRegExp, inspect, objDisplay, stringify };
+export type { LoupeOptions, StringifyOptions };

node_modules/@vitest/utils/dist/display.js

@@ -0,0 +1,727 @@
+import { plugins, format as format$1 } from '@vitest/pretty-format';
+
+const ansiColors = {
+    bold: ['1', '22'],
+    dim: ['2', '22'],
+    italic: ['3', '23'],
+    underline: ['4', '24'],
+    // 5 & 6 are blinking
+    inverse: ['7', '27'],
+    hidden: ['8', '28'],
+    strike: ['9', '29'],
+    // 10-20 are fonts
+    // 21-29 are resets for 1-9
+    black: ['30', '39'],
+    red: ['31', '39'],
+    green: ['32', '39'],
+    yellow: ['33', '39'],
+    blue: ['34', '39'],
+    magenta: ['35', '39'],
+    cyan: ['36', '39'],
+    white: ['37', '39'],
+    brightblack: ['30;1', '39'],
+    brightred: ['31;1', '39'],
+    brightgreen: ['32;1', '39'],
+    brightyellow: ['33;1', '39'],
+    brightblue: ['34;1', '39'],
+    brightmagenta: ['35;1', '39'],
+    brightcyan: ['36;1', '39'],
+    brightwhite: ['37;1', '39'],
+    grey: ['90', '39'],
+};
+const styles = {
+    special: 'cyan',
+    number: 'yellow',
+    bigint: 'yellow',
+    boolean: 'yellow',
+    undefined: 'grey',
+    null: 'bold',
+    string: 'green',
+    symbol: 'green',
+    date: 'magenta',
+    regexp: 'red',
+};
+const truncator = '…';
+function colorise(value, styleType) {
+    const color = ansiColors[styles[styleType]] || ansiColors[styleType] || '';
+    if (!color) {
+        return String(value);
+    }
+    return `\u001b[${color[0]}m${String(value)}\u001b[${color[1]}m`;
+}
+function normaliseOptions({ showHidden = false, depth = 2, colors = false, customInspect = true, showProxy = false, maxArrayLength = Infinity, breakLength = Infinity, seen = [], 
+// eslint-disable-next-line no-shadow
+truncate = Infinity, stylize = String, } = {}, inspect) {
+    const options = {
+        showHidden: Boolean(showHidden),
+        depth: Number(depth),
+        colors: Boolean(colors),
+        customInspect: Boolean(customInspect),
+        showProxy: Boolean(showProxy),
+        maxArrayLength: Number(maxArrayLength),
+        breakLength: Number(breakLength),
+        truncate: Number(truncate),
+        seen,
+        inspect,
+        stylize,
+    };
+    if (options.colors) {
+        options.stylize = colorise;
+    }
+    return options;
+}
+function isHighSurrogate(char) {
+    return char >= '\ud800' && char <= '\udbff';
+}
+function truncate(string, length, tail = truncator) {
+    string = String(string);
+    const tailLength = tail.length;
+    const stringLength = string.length;
+    if (tailLength > length && stringLength > tailLength) {
+        return tail;
+    }
+    if (stringLength > length && stringLength > tailLength) {
+        let end = length - tailLength;
+        if (end > 0 && isHighSurrogate(string[end - 1])) {
+            end = end - 1;
+        }
+        return `${string.slice(0, end)}${tail}`;
+    }
+    return string;
+}
+// eslint-disable-next-line complexity
+function inspectList(list, options, inspectItem, separator = ', ') {
+    inspectItem = inspectItem || options.inspect;
+    const size = list.length;
+    if (size === 0)
+        return '';
+    const originalLength = options.truncate;
+    let output = '';
+    let peek = '';
+    let truncated = '';
+    for (let i = 0; i < size; i += 1) {
+        const last = i + 1 === list.length;
+        const secondToLast = i + 2 === list.length;
+        truncated = `${truncator}(${list.length - i})`;
+        const value = list[i];
+        // If there is more than one remaining we need to account for a separator of `, `
+        options.truncate = originalLength - output.length - (last ? 0 : separator.length);
+        const string = peek || inspectItem(value, options) + (last ? '' : separator);
+        const nextLength = output.length + string.length;
+        const truncatedLength = nextLength + truncated.length;
+        // If this is the last element, and adding it would
+        // take us over length, but adding the truncator wouldn't - then break now
+        if (last && nextLength > originalLength && output.length + truncated.length <= originalLength) {
+            break;
+        }
+        // If this isn't the last or second to last element to scan,
+        // but the string is already over length then break here
+        if (!last && !secondToLast && truncatedLength > originalLength) {
+            break;
+        }
+        // Peek at the next string to determine if we should
+        // break early before adding this item to the output
+        peek = last ? '' : inspectItem(list[i + 1], options) + (secondToLast ? '' : separator);
+        // If we have one element left, but this element and
+        // the next takes over length, the break early
+        if (!last && secondToLast && truncatedLength > originalLength && nextLength + peek.length > originalLength) {
+            break;
+        }
+        output += string;
+        // If the next element takes us to length -
+        // but there are more after that, then we should truncate now
+        if (!last && !secondToLast && nextLength + peek.length >= originalLength) {
+            truncated = `${truncator}(${list.length - i - 1})`;
+            break;
+        }
+        truncated = '';
+    }
+    return `${output}${truncated}`;
+}
+function quoteComplexKey(key) {
+    if (key.match(/^[a-zA-Z_][a-zA-Z_0-9]*$/)) {
+        return key;
+    }
+    return JSON.stringify(key)
+        .replace(/'/g, "\\'")
+        .replace(/\\"/g, '"')
+        .replace(/(^"|"$)/g, "'");
+}
+function inspectProperty([key, value], options) {
+    options.truncate -= 2;
+    if (typeof key === 'string') {
+        key = quoteComplexKey(key);
+    }
+    else if (typeof key !== 'number') {
+        key = `[${options.inspect(key, options)}]`;
+    }
+    options.truncate -= key.length;
+    value = options.inspect(value, options);
+    return `${key}: ${value}`;
+}
+
+function inspectArray(array, options) {
+    // Object.keys will always output the Array indices first, so we can slice by
+    // `array.length` to get non-index properties
+    const nonIndexProperties = Object.keys(array).slice(array.length);
+    if (!array.length && !nonIndexProperties.length)
+        return '[]';
+    options.truncate -= 4;
+    const listContents = inspectList(array, options);
+    options.truncate -= listContents.length;
+    let propertyContents = '';
+    if (nonIndexProperties.length) {
+        propertyContents = inspectList(nonIndexProperties.map(key => [key, array[key]]), options, inspectProperty);
+    }
+    return `[ ${listContents}${propertyContents ? `, ${propertyContents}` : ''} ]`;
+}
+
+const getArrayName = (array) => {
+    // We need to special case Node.js' Buffers, which report to be Uint8Array
+    // @ts-ignore
+    if (typeof Buffer === 'function' && array instanceof Buffer) {
+        return 'Buffer';
+    }
+    if (array[Symbol.toStringTag]) {
+        return array[Symbol.toStringTag];
+    }
+    return array.constructor.name;
+};
+function inspectTypedArray(array, options) {
+    const name = getArrayName(array);
+    options.truncate -= name.length + 4;
+    // Object.keys will always output the Array indices first, so we can slice by
+    // `array.length` to get non-index properties
+    const nonIndexProperties = Object.keys(array).slice(array.length);
+    if (!array.length && !nonIndexProperties.length)
+        return `${name}[]`;
+    // As we know TypedArrays only contain Unsigned Integers, we can skip inspecting each one and simply
+    // stylise the toString() value of them
+    let output = '';
+    for (let i = 0; i < array.length; i++) {
+        const string = `${options.stylize(truncate(array[i], options.truncate), 'number')}${i === array.length - 1 ? '' : ', '}`;
+        options.truncate -= string.length;
+        if (array[i] !== array.length && options.truncate <= 3) {
+            output += `${truncator}(${array.length - array[i] + 1})`;
+            break;
+        }
+        output += string;
+    }
+    let propertyContents = '';
+    if (nonIndexProperties.length) {
+        propertyContents = inspectList(nonIndexProperties.map(key => [key, array[key]]), options, inspectProperty);
+    }
+    return `${name}[ ${output}${propertyContents ? `, ${propertyContents}` : ''} ]`;
+}
+
+function inspectDate(dateObject, options) {
+    const stringRepresentation = dateObject.toJSON();
+    if (stringRepresentation === null) {
+        return 'Invalid Date';
+    }
+    const split = stringRepresentation.split('T');
+    const date = split[0];
+    // If we need to - truncate the time portion, but never the date
+    return options.stylize(`${date}T${truncate(split[1], options.truncate - date.length - 1)}`, 'date');
+}
+
+function inspectFunction(func, options) {
+    const functionType = func[Symbol.toStringTag] || 'Function';
+    const name = func.name;
+    if (!name) {
+        return options.stylize(`[${functionType}]`, 'special');
+    }
+    return options.stylize(`[${functionType} ${truncate(name, options.truncate - 11)}]`, 'special');
+}
+
+function inspectMapEntry([key, value], options) {
+    options.truncate -= 4;
+    key = options.inspect(key, options);
+    options.truncate -= key.length;
+    value = options.inspect(value, options);
+    return `${key} => ${value}`;
+}
+// IE11 doesn't support `map.entries()`
+function mapToEntries(map) {
+    const entries = [];
+    map.forEach((value, key) => {
+        entries.push([key, value]);
+    });
+    return entries;
+}
+function inspectMap(map, options) {
+    if (map.size === 0)
+        return 'Map{}';
+    options.truncate -= 7;
+    return `Map{ ${inspectList(mapToEntries(map), options, inspectMapEntry)} }`;
+}
+
+const isNaN = Number.isNaN || (i => i !== i); // eslint-disable-line no-self-compare
+function inspectNumber(number, options) {
+    if (isNaN(number)) {
+        return options.stylize('NaN', 'number');
+    }
+    if (number === Infinity) {
+        return options.stylize('Infinity', 'number');
+    }
+    if (number === -Infinity) {
+        return options.stylize('-Infinity', 'number');
+    }
+    if (number === 0) {
+        return options.stylize(1 / number === Infinity ? '+0' : '-0', 'number');
+    }
+    return options.stylize(truncate(String(number), options.truncate), 'number');
+}
+
+function inspectBigInt(number, options) {
+    let nums = truncate(number.toString(), options.truncate - 1);
+    if (nums !== truncator)
+        nums += 'n';
+    return options.stylize(nums, 'bigint');
+}
+
+function inspectRegExp(value, options) {
+    const flags = value.toString().split('/')[2];
+    const sourceLength = options.truncate - (2 + flags.length);
+    const source = value.source;
+    return options.stylize(`/${truncate(source, sourceLength)}/${flags}`, 'regexp');
+}
+
+// IE11 doesn't support `Array.from(set)`
+function arrayFromSet(set) {
+    const values = [];
+    set.forEach(value => {
+        values.push(value);
+    });
+    return values;
+}
+function inspectSet(set, options) {
+    if (set.size === 0)
+        return 'Set{}';
+    options.truncate -= 7;
+    return `Set{ ${inspectList(arrayFromSet(set), options)} }`;
+}
+
+const stringEscapeChars = new RegExp("['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5" +
+    '\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]', 'g');
+const escapeCharacters = {
+    '\b': '\\b',
+    '\t': '\\t',
+    '\n': '\\n',
+    '\f': '\\f',
+    '\r': '\\r',
+    "'": "\\'",
+    '\\': '\\\\',
+};
+const hex = 16;
+function escape(char) {
+    return (escapeCharacters[char] ||
+        `\\u${`0000${char.charCodeAt(0).toString(hex)}`.slice(-4)}`);
+}
+function inspectString(string, options) {
+    if (stringEscapeChars.test(string)) {
+        string = string.replace(stringEscapeChars, escape);
+    }
+    return options.stylize(`'${truncate(string, options.truncate - 2)}'`, 'string');
+}
+
+function inspectSymbol(value) {
+    if ('description' in Symbol.prototype) {
+        return value.description ? `Symbol(${value.description})` : 'Symbol()';
+    }
+    return value.toString();
+}
+
+const getPromiseValue = () => 'Promise{…}';
+
+function inspectObject$1(object, options) {
+    const properties = Object.getOwnPropertyNames(object);
+    const symbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : [];
+    if (properties.length === 0 && symbols.length === 0) {
+        return '{}';
+    }
+    options.truncate -= 4;
+    options.seen = options.seen || [];
+    if (options.seen.includes(object)) {
+        return '[Circular]';
+    }
+    options.seen.push(object);
+    const propertyContents = inspectList(properties.map(key => [key, object[key]]), options, inspectProperty);
+    const symbolContents = inspectList(symbols.map(key => [key, object[key]]), options, inspectProperty);
+    options.seen.pop();
+    let sep = '';
+    if (propertyContents && symbolContents) {
+        sep = ', ';
+    }
+    return `{ ${propertyContents}${sep}${symbolContents} }`;
+}
+
+const toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag ? Symbol.toStringTag : false;
+function inspectClass(value, options) {
+    let name = '';
+    if (toStringTag && toStringTag in value) {
+        name = value[toStringTag];
+    }
+    name = name || value.constructor.name;
+    // Babel transforms anonymous classes to the name `_class`
+    if (!name || name === '_class') {
+        name = '<Anonymous Class>';
+    }
+    options.truncate -= name.length;
+    return `${name}${inspectObject$1(value, options)}`;
+}
+
+function inspectArguments(args, options) {
+    if (args.length === 0)
+        return 'Arguments[]';
+    options.truncate -= 13;
+    return `Arguments[ ${inspectList(args, options)} ]`;
+}
+
+const errorKeys = [
+    'stack',
+    'line',
+    'column',
+    'name',
+    'message',
+    'fileName',
+    'lineNumber',
+    'columnNumber',
+    'number',
+    'description',
+    'cause',
+];
+function inspectObject(error, options) {
+    const properties = Object.getOwnPropertyNames(error).filter(key => errorKeys.indexOf(key) === -1);
+    const name = error.name;
+    options.truncate -= name.length;
+    let message = '';
+    if (typeof error.message === 'string') {
+        message = truncate(error.message, options.truncate);
+    }
+    else {
+        properties.unshift('message');
+    }
+    message = message ? `: ${message}` : '';
+    options.truncate -= message.length + 5;
+    options.seen = options.seen || [];
+    if (options.seen.includes(error)) {
+        return '[Circular]';
+    }
+    options.seen.push(error);
+    const propertyContents = inspectList(properties.map(key => [key, error[key]]), options, inspectProperty);
+    return `${name}${message}${propertyContents ? ` { ${propertyContents} }` : ''}`;
+}
+
+function inspectAttribute([key, value], options) {
+    options.truncate -= 3;
+    if (!value) {
+        return `${options.stylize(String(key), 'yellow')}`;
+    }
+    return `${options.stylize(String(key), 'yellow')}=${options.stylize(`"${value}"`, 'string')}`;
+}
+function inspectNodeCollection(collection, options) {
+    return inspectList(collection, options, inspectNode, '\n');
+}
+function inspectNode(node, options) {
+    switch (node.nodeType) {
+        case 1:
+            return inspectHTML(node, options);
+        case 3:
+            return options.inspect(node.data, options);
+        default:
+            return options.inspect(node, options);
+    }
+}
+// @ts-ignore (Deno doesn't have Element)
+function inspectHTML(element, options) {
+    const properties = element.getAttributeNames();
+    const name = element.tagName.toLowerCase();
+    const head = options.stylize(`<${name}`, 'special');
+    const headClose = options.stylize(`>`, 'special');
+    const tail = options.stylize(`</${name}>`, 'special');
+    options.truncate -= name.length * 2 + 5;
+    let propertyContents = '';
+    if (properties.length > 0) {
+        propertyContents += ' ';
+        propertyContents += inspectList(properties.map((key) => [key, element.getAttribute(key)]), options, inspectAttribute, ' ');
+    }
+    options.truncate -= propertyContents.length;
+    const truncate = options.truncate;
+    let children = inspectNodeCollection(element.children, options);
+    if (children && children.length > truncate) {
+        children = `${truncator}(${element.children.length})`;
+    }
+    return `${head}${propertyContents}${headClose}${children}${tail}`;
+}
+
+/* !
+ * loupe
+ * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+const symbolsSupported = typeof Symbol === 'function' && typeof Symbol.for === 'function';
+const chaiInspect = symbolsSupported ? Symbol.for('chai/inspect') : '@@chai/inspect';
+const nodeInspect = Symbol.for('nodejs.util.inspect.custom');
+const constructorMap = new WeakMap();
+const stringTagMap = {};
+const baseTypesMap = {
+    undefined: (value, options) => options.stylize('undefined', 'undefined'),
+    null: (value, options) => options.stylize('null', 'null'),
+    boolean: (value, options) => options.stylize(String(value), 'boolean'),
+    Boolean: (value, options) => options.stylize(String(value), 'boolean'),
+    number: inspectNumber,
+    Number: inspectNumber,
+    bigint: inspectBigInt,
+    BigInt: inspectBigInt,
+    string: inspectString,
+    String: inspectString,
+    function: inspectFunction,
+    Function: inspectFunction,
+    symbol: inspectSymbol,
+    // A Symbol polyfill will return `Symbol` not `symbol` from typedetect
+    Symbol: inspectSymbol,
+    Array: inspectArray,
+    Date: inspectDate,
+    Map: inspectMap,
+    Set: inspectSet,
+    RegExp: inspectRegExp,
+    Promise: getPromiseValue,
+    // WeakSet, WeakMap are totally opaque to us
+    WeakSet: (value, options) => options.stylize('WeakSet{…}', 'special'),
+    WeakMap: (value, options) => options.stylize('WeakMap{…}', 'special'),
+    Arguments: inspectArguments,
+    Int8Array: inspectTypedArray,
+    Uint8Array: inspectTypedArray,
+    Uint8ClampedArray: inspectTypedArray,
+    Int16Array: inspectTypedArray,
+    Uint16Array: inspectTypedArray,
+    Int32Array: inspectTypedArray,
+    Uint32Array: inspectTypedArray,
+    Float32Array: inspectTypedArray,
+    Float64Array: inspectTypedArray,
+    Generator: () => '',
+    DataView: () => '',
+    ArrayBuffer: () => '',
+    Error: inspectObject,
+    HTMLCollection: inspectNodeCollection,
+    NodeList: inspectNodeCollection,
+};
+// eslint-disable-next-line complexity
+const inspectCustom = (value, options, type, inspectFn) => {
+    if (chaiInspect in value && typeof value[chaiInspect] === 'function') {
+        return value[chaiInspect](options);
+    }
+    if (nodeInspect in value && typeof value[nodeInspect] === 'function') {
+        return value[nodeInspect](options.depth, options, inspectFn);
+    }
+    if ('inspect' in value && typeof value.inspect === 'function') {
+        return value.inspect(options.depth, options);
+    }
+    if ('constructor' in value && constructorMap.has(value.constructor)) {
+        return constructorMap.get(value.constructor)(value, options);
+    }
+    if (stringTagMap[type]) {
+        return stringTagMap[type](value, options);
+    }
+    return '';
+};
+const toString = Object.prototype.toString;
+// eslint-disable-next-line complexity
+function inspect$1(value, opts = {}) {
+    const options = normaliseOptions(opts, inspect$1);
+    const { customInspect } = options;
+    let type = value === null ? 'null' : typeof value;
+    if (type === 'object') {
+        type = toString.call(value).slice(8, -1);
+    }
+    // If it is a base value that we already support, then use Loupe's inspector
+    if (type in baseTypesMap) {
+        return baseTypesMap[type](value, options);
+    }
+    // If `options.customInspect` is set to true then try to use the custom inspector
+    if (customInspect && value) {
+        const output = inspectCustom(value, options, type, inspect$1);
+        if (output) {
+            if (typeof output === 'string')
+                return output;
+            return inspect$1(output, options);
+        }
+    }
+    const proto = value ? Object.getPrototypeOf(value) : false;
+    // If it's a plain Object then use Loupe's inspector
+    if (proto === Object.prototype || proto === null) {
+        return inspectObject$1(value, options);
+    }
+    // Specifically account for HTMLElements
+    // @ts-ignore
+    if (value && typeof HTMLElement === 'function' && value instanceof HTMLElement) {
+        return inspectHTML(value, options);
+    }
+    if ('constructor' in value) {
+        // If it is a class, inspect it like an object but add the constructor name
+        if (value.constructor !== Object) {
+            return inspectClass(value, options);
+        }
+        // If it is an object with an anonymous prototype, display it as an object.
+        return inspectObject$1(value, options);
+    }
+    // last chance to check if it's an object
+    if (value === Object(value)) {
+        return inspectObject$1(value, options);
+    }
+    // We have run out of options! Just stringify the value
+    return options.stylize(String(value), type);
+}
+
+const { AsymmetricMatcher, DOMCollection, DOMElement, Immutable, ReactElement, ReactTestComponent } = plugins;
+const PLUGINS = [
+	ReactTestComponent,
+	ReactElement,
+	DOMElement,
+	DOMCollection,
+	Immutable,
+	AsymmetricMatcher
+];
+function stringify(object, maxDepth = 10, { maxLength, ...options } = {}) {
+	const MAX_LENGTH = maxLength ?? 1e4;
+	let result;
+	try {
+		result = format$1(object, {
+			maxDepth,
+			escapeString: false,
+			plugins: PLUGINS,
+			...options
+		});
+	} catch {
+		result = format$1(object, {
+			callToJSON: false,
+			maxDepth,
+			escapeString: false,
+			plugins: PLUGINS,
+			...options
+		});
+	}
+	// Prevents infinite loop https://github.com/vitest-dev/vitest/issues/7249
+	return result.length >= MAX_LENGTH && maxDepth > 1 ? stringify(object, Math.floor(Math.min(maxDepth, Number.MAX_SAFE_INTEGER) / 2), {
+		maxLength,
+		...options
+	}) : result;
+}
+const formatRegExp = /%[sdjifoOc%]/g;
+function format(...args) {
+	if (typeof args[0] !== "string") {
+		const objects = [];
+		for (let i = 0; i < args.length; i++) {
+			objects.push(inspect(args[i], {
+				depth: 0,
+				colors: false
+			}));
+		}
+		return objects.join(" ");
+	}
+	const len = args.length;
+	let i = 1;
+	const template = args[0];
+	let str = String(template).replace(formatRegExp, (x) => {
+		if (x === "%%") {
+			return "%";
+		}
+		if (i >= len) {
+			return x;
+		}
+		switch (x) {
+			case "%s": {
+				const value = args[i++];
+				if (typeof value === "bigint") {
+					return `${value.toString()}n`;
+				}
+				if (typeof value === "number" && value === 0 && 1 / value < 0) {
+					return "-0";
+				}
+				if (typeof value === "object" && value !== null) {
+					if (typeof value.toString === "function" && value.toString !== Object.prototype.toString) {
+						return value.toString();
+					}
+					return inspect(value, {
+						depth: 0,
+						colors: false
+					});
+				}
+				return String(value);
+			}
+			case "%d": {
+				const value = args[i++];
+				if (typeof value === "bigint") {
+					return `${value.toString()}n`;
+				}
+				return Number(value).toString();
+			}
+			case "%i": {
+				const value = args[i++];
+				if (typeof value === "bigint") {
+					return `${value.toString()}n`;
+				}
+				return Number.parseInt(String(value)).toString();
+			}
+			case "%f": return Number.parseFloat(String(args[i++])).toString();
+			case "%o": return inspect(args[i++], {
+				showHidden: true,
+				showProxy: true
+			});
+			case "%O": return inspect(args[i++]);
+			case "%c": {
+				i++;
+				return "";
+			}
+			case "%j": try {
+				return JSON.stringify(args[i++]);
+			} catch (err) {
+				const m = err.message;
+				if (m.includes("circular structure") || m.includes("cyclic structures") || m.includes("cyclic object")) {
+					return "[Circular]";
+				}
+				throw err;
+			}
+			default: return x;
+		}
+	});
+	for (let x = args[i]; i < len; x = args[++i]) {
+		if (x === null || typeof x !== "object") {
+			str += ` ${x}`;
+		} else {
+			str += ` ${inspect(x)}`;
+		}
+	}
+	return str;
+}
+function inspect(obj, options = {}) {
+	if (options.truncate === 0) {
+		options.truncate = Number.POSITIVE_INFINITY;
+	}
+	return inspect$1(obj, options);
+}
+function objDisplay(obj, options = {}) {
+	if (typeof options.truncate === "undefined") {
+		options.truncate = 40;
+	}
+	const str = inspect(obj, options);
+	const type = Object.prototype.toString.call(obj);
+	if (options.truncate && str.length >= options.truncate) {
+		if (type === "[object Function]") {
+			const fn = obj;
+			return !fn.name ? "[Function]" : `[Function: ${fn.name}]`;
+		} else if (type === "[object Array]") {
+			return `[ Array(${obj.length}) ]`;
+		} else if (type === "[object Object]") {
+			const keys = Object.keys(obj);
+			const kstr = keys.length > 2 ? `${keys.splice(0, 2).join(", ")}, ...` : keys.join(", ");
+			return `{ Object (${kstr}) }`;
+		} else {
+			return str;
+		}
+	}
+	return str;
+}
+
+export { format, formatRegExp, inspect, objDisplay, stringify };

node_modules/@vitest/utils/dist/error.d.ts

@@ -0,0 +1,7 @@
+import { D as DiffOptions } from './types.d-BCElaP-c.js';
+export { serializeValue as serializeError } from './serialize.js';
+import '@vitest/pretty-format';
+
+declare function processError(_err: any, diffOptions?: DiffOptions, seen?: WeakSet<WeakKey>): any;
+
+export { processError };

node_modules/@vitest/utils/dist/error.js

@@ -0,0 +1,42 @@
+import { printDiffOrStringify } from './diff.js';
+import { stringify } from './display.js';
+import { serializeValue } from './serialize.js';
+import '@vitest/pretty-format';
+import 'tinyrainbow';
+import './helpers.js';
+import './constants.js';
+import './chunk-_commonjsHelpers.js';
+
+function processError(_err, diffOptions, seen = new WeakSet()) {
+	if (!_err || typeof _err !== "object") {
+		return { message: String(_err) };
+	}
+	const err = _err;
+	if (err.showDiff || err.showDiff === undefined && err.expected !== undefined && err.actual !== undefined) {
+		err.diff = printDiffOrStringify(err.actual, err.expected, {
+			...diffOptions,
+			...err.diffOptions
+		});
+	}
+	if ("expected" in err && typeof err.expected !== "string") {
+		err.expected = stringify(err.expected, 10);
+	}
+	if ("actual" in err && typeof err.actual !== "string") {
+		err.actual = stringify(err.actual, 10);
+	}
+	// some Error implementations may not allow rewriting cause
+	// in most cases, the assignment will lead to "err.cause = err.cause"
+	try {
+		if (!seen.has(err) && typeof err.cause === "object") {
+			seen.add(err);
+			err.cause = processError(err.cause, diffOptions, seen);
+		}
+	} catch {}
+	try {
+		return serializeValue(err);
+	} catch (e) {
+		return serializeValue(new Error(`Failed to fully serialize error: ${e === null || e === void 0 ? void 0 : e.message}\nInner error message: ${err === null || err === void 0 ? void 0 : err.message}`));
+	}
+}
+
+export { processError, serializeValue as serializeError };

node_modules/@vitest/utils/dist/helpers.d.ts

@@ -0,0 +1,73 @@
+import { Nullable, Arrayable } from './types.js';
+
+declare function nanoid(size?: number): string;
+
+declare function shuffle<T>(array: T[], seed?: number): T[];
+
+interface CloneOptions {
+	forceWritable?: boolean;
+}
+interface ErrorOptions {
+	message?: string;
+	stackTraceLimit?: number;
+}
+
+/**
+* Get original stacktrace without source map support the most performant way.
+* - Create only 1 stack frame.
+* - Rewrite prepareStackTrace to bypass "support-stack-trace" (usually takes ~250ms).
+*/
+declare function createSimpleStackTrace(options?: ErrorOptions): string;
+declare function notNullish<T>(v: T | null | undefined): v is NonNullable<T>;
+declare function assertTypes(value: unknown, name: string, types: string[]): void;
+declare function isPrimitive(value: unknown): boolean;
+declare function slash(path: string): string;
+declare function cleanUrl(url: string): string;
+declare const isExternalUrl: (url: string) => boolean;
+/**
+* Prepend `/@id/` and replace null byte so the id is URL-safe.
+* This is prepended to resolved ids that are not valid browser
+* import specifiers by the importAnalysis plugin.
+*/
+declare function wrapId(id: string): string;
+/**
+* Undo {@link wrapId}'s `/@id/` and null byte replacements.
+*/
+declare function unwrapId(id: string): string;
+declare function withTrailingSlash(path: string): string;
+declare function isBareImport(id: string): boolean;
+declare function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T>;
+declare function isObject(item: unknown): boolean;
+declare function getType(value: unknown): string;
+declare function getOwnProperties(obj: any): (string | symbol)[];
+declare function deepClone<T>(val: T, options?: CloneOptions): T;
+declare function clone<T>(val: T, seen: WeakMap<any, any>, options?: CloneOptions): T;
+declare function noop(): void;
+declare function objectAttr(source: any, path: string, defaultValue?: undefined): any;
+type DeferPromise<T> = Promise<T> & {
+	resolve: (value: T | PromiseLike<T>) => void;
+	reject: (reason?: any) => void;
+};
+declare function createDefer<T>(): DeferPromise<T>;
+/**
+* If code starts with a function call, will return its last index, respecting arguments.
+* This will return 25 - last ending character of toMatch ")"
+* Also works with callbacks
+* ```
+* toMatch({ test: '123' });
+* toBeAliased('123')
+* ```
+*/
+declare function getCallLastIndex(code: string): number | null;
+declare function isNegativeNaN(val: number): boolean;
+/**
+* Deep merge :P
+*
+* Will merge objects only if they are plain
+*
+* Do not merge types - it is very expensive and usually it's better to case a type here
+*/
+declare function deepMerge<T extends object = object>(target: T, ...sources: any[]): T;
+
+export { assertTypes, cleanUrl, clone, createDefer, createSimpleStackTrace, deepClone, deepMerge, getCallLastIndex, getOwnProperties, getType, isBareImport, isExternalUrl, isNegativeNaN, isObject, isPrimitive, nanoid, noop, notNullish, objectAttr, shuffle, slash, toArray, unwrapId, withTrailingSlash, wrapId };
+export type { DeferPromise };

node_modules/@vitest/utils/dist/helpers.js

@@ -0,0 +1,295 @@
+import { VALID_ID_PREFIX, NULL_BYTE_PLACEHOLDER } from './constants.js';
+
+// port from nanoid
+// https://github.com/ai/nanoid
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+	let id = "";
+	let i = size;
+	while (i--) {
+		id += urlAlphabet[Math.random() * 64 | 0];
+	}
+	return id;
+}
+
+const RealDate = Date;
+function random(seed) {
+	const x = Math.sin(seed++) * 1e4;
+	return x - Math.floor(x);
+}
+function shuffle(array, seed = RealDate.now()) {
+	let length = array.length;
+	while (length) {
+		const index = Math.floor(random(seed) * length--);
+		const previous = array[length];
+		array[length] = array[index];
+		array[index] = previous;
+		++seed;
+	}
+	return array;
+}
+
+/**
+* Get original stacktrace without source map support the most performant way.
+* - Create only 1 stack frame.
+* - Rewrite prepareStackTrace to bypass "support-stack-trace" (usually takes ~250ms).
+*/
+function createSimpleStackTrace(options) {
+	const { message = "$$stack trace error", stackTraceLimit = 1 } = options || {};
+	const limit = Error.stackTraceLimit;
+	const prepareStackTrace = Error.prepareStackTrace;
+	Error.stackTraceLimit = stackTraceLimit;
+	Error.prepareStackTrace = (e) => e.stack;
+	const err = new Error(message);
+	const stackTrace = err.stack || "";
+	Error.prepareStackTrace = prepareStackTrace;
+	Error.stackTraceLimit = limit;
+	return stackTrace;
+}
+function notNullish(v) {
+	return v != null;
+}
+function assertTypes(value, name, types) {
+	const receivedType = typeof value;
+	const pass = types.includes(receivedType);
+	if (!pass) {
+		throw new TypeError(`${name} value must be ${types.join(" or ")}, received "${receivedType}"`);
+	}
+}
+function isPrimitive(value) {
+	return value === null || typeof value !== "function" && typeof value !== "object";
+}
+function slash(path) {
+	return path.replace(/\\/g, "/");
+}
+const postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+	return url.replace(postfixRE, "");
+}
+const externalRE = /^(?:[a-z]+:)?\/\//;
+const isExternalUrl = (url) => externalRE.test(url);
+/**
+* Prepend `/@id/` and replace null byte so the id is URL-safe.
+* This is prepended to resolved ids that are not valid browser
+* import specifiers by the importAnalysis plugin.
+*/
+function wrapId(id) {
+	return id.startsWith(VALID_ID_PREFIX) ? id : VALID_ID_PREFIX + id.replace("\0", NULL_BYTE_PLACEHOLDER);
+}
+/**
+* Undo {@link wrapId}'s `/@id/` and null byte replacements.
+*/
+function unwrapId(id) {
+	return id.startsWith(VALID_ID_PREFIX) ? id.slice(VALID_ID_PREFIX.length).replace(NULL_BYTE_PLACEHOLDER, "\0") : id;
+}
+function withTrailingSlash(path) {
+	if (path.at(-1) !== "/") {
+		return `${path}/`;
+	}
+	return path;
+}
+const bareImportRE = /^(?![a-z]:)[\w@](?!.*:\/\/)/i;
+function isBareImport(id) {
+	return bareImportRE.test(id);
+}
+function toArray(array) {
+	if (array === null || array === undefined) {
+		array = [];
+	}
+	if (Array.isArray(array)) {
+		return array;
+	}
+	return [array];
+}
+function isObject(item) {
+	return item != null && typeof item === "object" && !Array.isArray(item);
+}
+function isFinalObj(obj) {
+	return obj === Object.prototype || obj === Function.prototype || obj === RegExp.prototype;
+}
+function getType(value) {
+	return Object.prototype.toString.apply(value).slice(8, -1);
+}
+function collectOwnProperties(obj, collector) {
+	const collect = typeof collector === "function" ? collector : (key) => collector.add(key);
+	Object.getOwnPropertyNames(obj).forEach(collect);
+	Object.getOwnPropertySymbols(obj).forEach(collect);
+}
+function getOwnProperties(obj) {
+	const ownProps = new Set();
+	if (isFinalObj(obj)) {
+		return [];
+	}
+	collectOwnProperties(obj, ownProps);
+	return Array.from(ownProps);
+}
+const defaultCloneOptions = { forceWritable: false };
+function deepClone(val, options = defaultCloneOptions) {
+	const seen = new WeakMap();
+	return clone(val, seen, options);
+}
+function clone(val, seen, options = defaultCloneOptions) {
+	let k, out;
+	if (seen.has(val)) {
+		return seen.get(val);
+	}
+	if (Array.isArray(val)) {
+		out = Array.from({ length: k = val.length });
+		seen.set(val, out);
+		while (k--) {
+			out[k] = clone(val[k], seen, options);
+		}
+		return out;
+	}
+	if (Object.prototype.toString.call(val) === "[object Object]") {
+		out = Object.create(Object.getPrototypeOf(val));
+		seen.set(val, out);
+		// we don't need properties from prototype
+		const props = getOwnProperties(val);
+		for (const k of props) {
+			const descriptor = Object.getOwnPropertyDescriptor(val, k);
+			if (!descriptor) {
+				continue;
+			}
+			const cloned = clone(val[k], seen, options);
+			if (options.forceWritable) {
+				Object.defineProperty(out, k, {
+					enumerable: descriptor.enumerable,
+					configurable: true,
+					writable: true,
+					value: cloned
+				});
+			} else if ("get" in descriptor) {
+				Object.defineProperty(out, k, {
+					...descriptor,
+					get() {
+						return cloned;
+					}
+				});
+			} else {
+				Object.defineProperty(out, k, {
+					...descriptor,
+					value: cloned
+				});
+			}
+		}
+		return out;
+	}
+	return val;
+}
+function noop() {}
+function objectAttr(source, path, defaultValue = undefined) {
+	// a[3].b -> a.3.b
+	const paths = path.replace(/\[(\d+)\]/g, ".$1").split(".");
+	let result = source;
+	for (const p of paths) {
+		result = new Object(result)[p];
+		if (result === undefined) {
+			return defaultValue;
+		}
+	}
+	return result;
+}
+function createDefer() {
+	let resolve = null;
+	let reject = null;
+	const p = new Promise((_resolve, _reject) => {
+		resolve = _resolve;
+		reject = _reject;
+	});
+	p.resolve = resolve;
+	p.reject = reject;
+	return p;
+}
+/**
+* If code starts with a function call, will return its last index, respecting arguments.
+* This will return 25 - last ending character of toMatch ")"
+* Also works with callbacks
+* ```
+* toMatch({ test: '123' });
+* toBeAliased('123')
+* ```
+*/
+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 isNegativeNaN(val) {
+	if (!Number.isNaN(val)) {
+		return false;
+	}
+	const f64 = new Float64Array(1);
+	f64[0] = val;
+	const u32 = new Uint32Array(f64.buffer);
+	const isNegative = u32[1] >>> 31 === 1;
+	return isNegative;
+}
+function toString(v) {
+	return Object.prototype.toString.call(v);
+}
+function isPlainObject(val) {
+	return toString(val) === "[object Object]" && (!val.constructor || val.constructor.name === "Object");
+}
+function isMergeableObject(item) {
+	return isPlainObject(item) && !Array.isArray(item);
+}
+/**
+* Deep merge :P
+*
+* Will merge objects only if they are plain
+*
+* Do not merge types - it is very expensive and usually it's better to case a type here
+*/
+function deepMerge(target, ...sources) {
+	if (!sources.length) {
+		return target;
+	}
+	const source = sources.shift();
+	if (source === undefined) {
+		return target;
+	}
+	if (isMergeableObject(target) && isMergeableObject(source)) {
+		Object.keys(source).forEach((key) => {
+			const _source = source;
+			if (isMergeableObject(_source[key])) {
+				if (!target[key]) {
+					target[key] = {};
+				}
+				deepMerge(target[key], _source[key]);
+			} else {
+				target[key] = _source[key];
+			}
+		});
+	}
+	return deepMerge(target, ...sources);
+}
+
+export { assertTypes, cleanUrl, clone, createDefer, createSimpleStackTrace, deepClone, deepMerge, getCallLastIndex, getOwnProperties, getType, isBareImport, isExternalUrl, isNegativeNaN, isObject, isPrimitive, nanoid, noop, notNullish, objectAttr, shuffle, slash, toArray, unwrapId, withTrailingSlash, wrapId };

node_modules/@vitest/utils/dist/highlight.d.ts

@@ -0,0 +1,9 @@
+import { Colors } from 'tinyrainbow';
+
+interface HighlightOptions {
+	jsx?: boolean;
+	colors?: Colors;
+}
+declare function highlight(code: string, options?: HighlightOptions): string;
+
+export { highlight };

node_modules/@vitest/utils/dist/highlight.js

@@ -0,0 +1,538 @@
+import { g as getDefaultExportFromCjs } from './chunk-_commonjsHelpers.js';
+import c from 'tinyrainbow';
+
+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;
+}
+
+var jsTokensExports = /*@__PURE__*/ requireJsTokens();
+var jsTokens = /*@__PURE__*/getDefaultExportFromCjs(jsTokensExports);
+
+// 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"
+  ]
+}, keywords = new Set(reservedWords.keyword), reservedWordsStrictSet = new Set(reservedWords.strict), sometimesKeywords = /* @__PURE__ */ new Set(["as", "async", "from", "get", "of", "set"]);
+function isReservedWord(word) {
+  return word === "await" || word === "enum";
+}
+function isStrictReservedWord(word) {
+  return isReservedWord(word) || reservedWordsStrictSet.has(word);
+}
+function isKeyword(word) {
+  return keywords.has(word);
+}
+var BRACKET = /^[()[\]{}]$/, getTokenType = function(token) {
+  if (token.type === "IdentifierName") {
+    if (isKeyword(token.value) || isStrictReservedWord(token.value) || sometimesKeywords.has(token.value))
+      return "Keyword";
+    if (token.value[0] && token.value[0] !== token.value[0].toLowerCase())
+      return "IdentifierCapitalized";
+  }
+  return token.type === "Punctuator" && BRACKET.test(token.value) ? "Bracket" : token.type === "Invalid" && (token.value === "@" || token.value === "#") ? "Punctuator" : token.type;
+};
+function getCallableType(token) {
+  if (token.type === "IdentifierName")
+    return "IdentifierCallable";
+  if (token.type === "PrivateIdentifier")
+    return "PrivateIdentifierCallable";
+  throw new Error("Not a callable token");
+}
+var colorize = (defs, type, value) => {
+  let colorize2 = defs[type];
+  return colorize2 ? colorize2(value) : value;
+}, highlightTokens = (defs, text, jsx) => {
+  let highlighted = "", lastPotentialCallable = null, stackedHighlight = "";
+  for (let token of jsTokens(text, { jsx })) {
+    let type = getTokenType(token);
+    if (type === "IdentifierName" || type === "PrivateIdentifier") {
+      lastPotentialCallable && (highlighted += colorize(defs, getTokenType(lastPotentialCallable), lastPotentialCallable.value) + stackedHighlight, stackedHighlight = ""), lastPotentialCallable = token;
+      continue;
+    }
+    if (lastPotentialCallable && (token.type === "WhiteSpace" || token.type === "LineTerminatorSequence" || token.type === "Punctuator" && (token.value === "?." || token.value === "!"))) {
+      stackedHighlight += colorize(defs, type, token.value);
+      continue;
+    }
+    if (stackedHighlight && !lastPotentialCallable && (highlighted += stackedHighlight, stackedHighlight = ""), lastPotentialCallable) {
+      let type2 = token.type === "Punctuator" && token.value === "(" ? getCallableType(lastPotentialCallable) : getTokenType(lastPotentialCallable);
+      highlighted += colorize(defs, type2, lastPotentialCallable.value) + stackedHighlight, stackedHighlight = "", lastPotentialCallable = null;
+    }
+    highlighted += colorize(defs, type, token.value);
+  }
+  return highlighted;
+};
+function highlight$1(code, options = { jsx: false, colors: {} }) {
+  return code && highlightTokens(options.colors || {}, code, options.jsx);
+}
+
+function getDefs(c) {
+	const Invalid = (text) => c.white(c.bgRed(c.bold(text)));
+	return {
+		Keyword: c.magenta,
+		IdentifierCapitalized: c.yellow,
+		Punctuator: c.yellow,
+		StringLiteral: c.green,
+		NoSubstitutionTemplate: c.green,
+		MultiLineComment: c.gray,
+		SingleLineComment: c.gray,
+		RegularExpressionLiteral: c.cyan,
+		NumericLiteral: c.blue,
+		TemplateHead: (text) => c.green(text.slice(0, text.length - 2)) + c.cyan(text.slice(-2)),
+		TemplateTail: (text) => c.cyan(text.slice(0, 1)) + c.green(text.slice(1)),
+		TemplateMiddle: (text) => c.cyan(text.slice(0, 1)) + c.green(text.slice(1, text.length - 2)) + c.cyan(text.slice(-2)),
+		IdentifierCallable: c.blue,
+		PrivateIdentifierCallable: (text) => `#${c.blue(text.slice(1))}`,
+		Invalid,
+		JSXString: c.green,
+		JSXIdentifier: c.yellow,
+		JSXInvalid: Invalid,
+		JSXPunctuator: c.yellow
+	};
+}
+function highlight(code, options = { jsx: false }) {
+	return highlight$1(code, {
+		jsx: options.jsx,
+		colors: getDefs(options.colors || c)
+	});
+}
+
+export { highlight };

node_modules/@vitest/utils/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { LoupeOptions, StringifyOptions } from './display.js';
+export { DeferPromise } from './helpers.js';
+export { SafeTimers } from './timers.js';
+export { ArgumentsType, Arrayable, Awaitable, Constructable, DeepMerge, MergeInsertions, Nullable, ParsedStack, SerializedError, TestError } from './types.js';
+import '@vitest/pretty-format';

node_modules/@vitest/utils/dist/index.js

@@ -0,0 +1 @@
+

node_modules/@vitest/utils/dist/offset.d.ts

@@ -0,0 +1,5 @@
+declare const lineSplitRE: RegExp;
+declare function positionToOffset(source: string, lineNumber: number, columnNumber: number): number;
+declare function offsetToLineNumber(source: string, offset: number): number;
+
+export { lineSplitRE, offsetToLineNumber, positionToOffset };

node_modules/@vitest/utils/dist/offset.js

@@ -0,0 +1,32 @@
+const lineSplitRE = /\r?\n/;
+function positionToOffset(source, lineNumber, columnNumber) {
+	const lines = source.split(lineSplitRE);
+	const nl = /\r\n/.test(source) ? 2 : 1;
+	let start = 0;
+	if (lineNumber > lines.length) {
+		return source.length;
+	}
+	for (let i = 0; i < lineNumber - 1; i++) {
+		start += lines[i].length + nl;
+	}
+	return start + columnNumber;
+}
+function offsetToLineNumber(source, offset) {
+	if (offset > source.length) {
+		throw new Error(`offset is longer than source length! offset ${offset} > length ${source.length}`);
+	}
+	const lines = source.split(lineSplitRE);
+	const nl = /\r\n/.test(source) ? 2 : 1;
+	let counted = 0;
+	let line = 0;
+	for (; line < lines.length; line++) {
+		const lineLength = lines[line].length + nl;
+		if (counted + lineLength >= offset) {
+			break;
+		}
+		counted += lineLength;
+	}
+	return line + 1;
+}
+
+export { lineSplitRE, offsetToLineNumber, positionToOffset };

node_modules/@vitest/utils/dist/resolver.d.ts

@@ -0,0 +1,7 @@
+declare function findNearestPackageData(basedir: string): {
+	type?: "module" | "commonjs";
+};
+declare function getCachedData<T>(cache: Map<string, T>, basedir: string, originalBasedir: string): NonNullable<T> | undefined;
+declare function setCacheData<T>(cache: Map<string, T>, data: T, basedir: string, originalBasedir: string): void;
+
+export { findNearestPackageData, getCachedData, setCacheData };

node_modules/@vitest/utils/dist/resolver.js

@@ -0,0 +1,71 @@
+import fs from 'node:fs';
+import { j as join, d as dirname } from './chunk-pathe.M-eThtNZ.js';
+
+const packageCache = new Map();
+function findNearestPackageData(basedir) {
+	const originalBasedir = basedir;
+	while (basedir) {
+		var _tryStatSync;
+		const cached = getCachedData(packageCache, basedir, originalBasedir);
+		if (cached) {
+			return cached;
+		}
+		const pkgPath = join(basedir, "package.json");
+		if ((_tryStatSync = tryStatSync(pkgPath)) === null || _tryStatSync === void 0 ? void 0 : _tryStatSync.isFile()) {
+			const pkgData = JSON.parse(stripBomTag(fs.readFileSync(pkgPath, "utf8")));
+			if (packageCache) {
+				setCacheData(packageCache, pkgData, basedir, originalBasedir);
+			}
+			return pkgData;
+		}
+		const nextBasedir = dirname(basedir);
+		if (nextBasedir === basedir) {
+			break;
+		}
+		basedir = nextBasedir;
+	}
+	return {};
+}
+function stripBomTag(content) {
+	if (content.charCodeAt(0) === 65279) {
+		return content.slice(1);
+	}
+	return content;
+}
+function tryStatSync(file) {
+	try {
+		// The "throwIfNoEntry" is a performance optimization for cases where the file does not exist
+		return fs.statSync(file, { throwIfNoEntry: false });
+	} catch {}
+}
+function getCachedData(cache, basedir, originalBasedir) {
+	const pkgData = cache.get(getFnpdCacheKey(basedir));
+	if (pkgData) {
+		traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+			cache.set(getFnpdCacheKey(dir), pkgData);
+		});
+		return pkgData;
+	}
+}
+function setCacheData(cache, data, basedir, originalBasedir) {
+	cache.set(getFnpdCacheKey(basedir), data);
+	traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+		cache.set(getFnpdCacheKey(dir), data);
+	});
+}
+function getFnpdCacheKey(basedir) {
+	return `fnpd_${basedir}`;
+}
+/**
+* Traverse between `longerDir` (inclusive) and `shorterDir` (exclusive) and call `cb` for each dir.
+* @param longerDir Longer dir path, e.g. `/User/foo/bar/baz`
+* @param shorterDir Shorter dir path, e.g. `/User/foo`
+*/
+function traverseBetweenDirs(longerDir, shorterDir, cb) {
+	while (longerDir !== shorterDir) {
+		cb(longerDir);
+		longerDir = dirname(longerDir);
+	}
+}
+
+export { findNearestPackageData, getCachedData, setCacheData };

node_modules/@vitest/utils/dist/serialize.d.ts

@@ -0,0 +1,3 @@
+declare function serializeValue(val: any, seen?: WeakMap<WeakKey, any>): any;
+
+export { serializeValue };

node_modules/@vitest/utils/dist/serialize.js

@@ -0,0 +1,118 @@
+const IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";
+const IS_COLLECTION_SYMBOL = "@@__IMMUTABLE_ITERABLE__@@";
+function isImmutable(v) {
+	return v && (v[IS_COLLECTION_SYMBOL] || v[IS_RECORD_SYMBOL]);
+}
+const OBJECT_PROTO = Object.getPrototypeOf({});
+function getUnserializableMessage(err) {
+	if (err instanceof Error) {
+		return `<unserializable>: ${err.message}`;
+	}
+	if (typeof err === "string") {
+		return `<unserializable>: ${err}`;
+	}
+	return "<unserializable>";
+}
+// https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
+function serializeValue(val, seen = new WeakMap()) {
+	if (!val || typeof val === "string") {
+		return val;
+	}
+	if (val instanceof Error && "toJSON" in val && typeof val.toJSON === "function") {
+		const jsonValue = val.toJSON();
+		if (jsonValue && jsonValue !== val && typeof jsonValue === "object") {
+			if (typeof val.message === "string") {
+				safe(() => jsonValue.message ?? (jsonValue.message = normalizeErrorMessage(val.message)));
+			}
+			if (typeof val.stack === "string") {
+				safe(() => jsonValue.stack ?? (jsonValue.stack = val.stack));
+			}
+			if (typeof val.name === "string") {
+				safe(() => jsonValue.name ?? (jsonValue.name = val.name));
+			}
+			if (val.cause != null) {
+				safe(() => jsonValue.cause ?? (jsonValue.cause = serializeValue(val.cause, seen)));
+			}
+		}
+		return serializeValue(jsonValue, seen);
+	}
+	if (typeof val === "function") {
+		return `Function<${val.name || "anonymous"}>`;
+	}
+	if (typeof val === "symbol") {
+		return val.toString();
+	}
+	if (typeof val !== "object") {
+		return val;
+	}
+	if (typeof Buffer !== "undefined" && val instanceof Buffer) {
+		return `<Buffer(${val.length}) ...>`;
+	}
+	if (typeof Uint8Array !== "undefined" && val instanceof Uint8Array) {
+		return `<Uint8Array(${val.length}) ...>`;
+	}
+	// cannot serialize immutables as immutables
+	if (isImmutable(val)) {
+		return serializeValue(val.toJSON(), seen);
+	}
+	if (val instanceof Promise || val.constructor && val.constructor.prototype === "AsyncFunction") {
+		return "Promise";
+	}
+	if (typeof Element !== "undefined" && val instanceof Element) {
+		return val.tagName;
+	}
+	if (typeof val.toJSON === "function") {
+		return serializeValue(val.toJSON(), seen);
+	}
+	if (seen.has(val)) {
+		return seen.get(val);
+	}
+	if (Array.isArray(val)) {
+		// eslint-disable-next-line unicorn/no-new-array -- we need to keep sparse arrays ([1,,3])
+		const clone = new Array(val.length);
+		seen.set(val, clone);
+		val.forEach((e, i) => {
+			try {
+				clone[i] = serializeValue(e, seen);
+			} catch (err) {
+				clone[i] = getUnserializableMessage(err);
+			}
+		});
+		return clone;
+	} else {
+		// Objects with `Error` constructors appear to cause problems during worker communication
+		// using `MessagePort`, so the serialized error object is being recreated as plain object.
+		const clone = Object.create(null);
+		seen.set(val, clone);
+		let obj = val;
+		while (obj && obj !== OBJECT_PROTO) {
+			Object.getOwnPropertyNames(obj).forEach((key) => {
+				if (key in clone) {
+					return;
+				}
+				try {
+					clone[key] = serializeValue(val[key], seen);
+				} catch (err) {
+					// delete in case it has a setter from prototype that might throw
+					delete clone[key];
+					clone[key] = getUnserializableMessage(err);
+				}
+			});
+			obj = Object.getPrototypeOf(obj);
+		}
+		if (val instanceof Error) {
+			safe(() => val.message = normalizeErrorMessage(val.message));
+		}
+		return clone;
+	}
+}
+function safe(fn) {
+	try {
+		return fn();
+	} catch {}
+}
+function normalizeErrorMessage(message) {
+	return message.replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "");
+}
+
+export { serializeValue };

node_modules/@vitest/utils/dist/source-map.d.ts

@@ -0,0 +1,55 @@
+import { TestError, ParsedStack } from './types.js';
+
+type OriginalMapping = {
+    source: string | null;
+    line: number;
+    column: number;
+    name: string | null;
+};
+
+interface StackTraceParserOptions {
+	ignoreStackEntries?: (RegExp | string)[];
+	getSourceMap?: (file: string) => unknown;
+	getUrlId?: (id: string) => string;
+	frameFilter?: (error: TestError, frame: ParsedStack) => boolean | void;
+}
+declare const stackIgnorePatterns: (string | RegExp)[];
+
+declare function parseSingleFFOrSafariStack(raw: string): ParsedStack | null;
+declare function parseSingleStack(raw: string): ParsedStack | null;
+declare function parseSingleV8Stack(raw: string): ParsedStack | null;
+declare function createStackString(stacks: ParsedStack[]): string;
+declare function parseStacktrace(stack: string, options?: StackTraceParserOptions): ParsedStack[];
+declare function parseErrorStacktrace(e: TestError | Error, options?: StackTraceParserOptions): ParsedStack[];
+interface SourceMapLike {
+	version: number;
+	mappings?: string;
+	names?: string[];
+	sources?: string[];
+	sourcesContent?: string[];
+	sourceRoot?: string;
+}
+interface Needle {
+	line: number;
+	column: number;
+}
+declare class DecodedMap {
+	map: SourceMapLike;
+	_encoded: string;
+	_decoded: undefined | number[][][];
+	_decodedMemo: Stats;
+	url: string;
+	version: number;
+	names: string[];
+	resolvedSources: string[];
+	constructor(map: SourceMapLike, from: string);
+}
+interface Stats {
+	lastKey: number;
+	lastNeedle: number;
+	lastIndex: number;
+}
+declare function getOriginalPosition(map: DecodedMap, needle: Needle): OriginalMapping | null;
+
+export { DecodedMap, createStackString, stackIgnorePatterns as defaultStackIgnorePatterns, getOriginalPosition, parseErrorStacktrace, parseSingleFFOrSafariStack, parseSingleStack, parseSingleV8Stack, parseStacktrace };
+export type { StackTraceParserOptions };

node_modules/@vitest/utils/dist/source-map.js

@@ -0,0 +1,478 @@
+import { isPrimitive, notNullish } from './helpers.js';
+import { r as resolve } from './chunk-pathe.M-eThtNZ.js';
+import './constants.js';
+
+// src/vlq.ts
+var comma = ",".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c;
+  charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+  let value = 0;
+  let shift = 0;
+  let integer = 0;
+  do {
+    const c = reader.next();
+    integer = charToInt[c];
+    value |= (integer & 31) << shift;
+    shift += 5;
+  } while (integer & 32);
+  const shouldNegate = value & 1;
+  value >>>= 1;
+  if (shouldNegate) {
+    value = -2147483648 | -value;
+  }
+  return relative + value;
+}
+function hasMoreVlq(reader, max) {
+  if (reader.pos >= max) return false;
+  return reader.peek() !== comma;
+}
+var StringReader = class {
+  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;
+  }
+};
+
+// src/sourcemap-codec.ts
+function decode(mappings) {
+  const { length } = mappings;
+  const reader = new StringReader(mappings);
+  const decoded = [];
+  let genColumn = 0;
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  do {
+    const semi = reader.indexOf(";");
+    const line = [];
+    let sorted = true;
+    let lastCol = 0;
+    genColumn = 0;
+    while (reader.pos < semi) {
+      let seg;
+      genColumn = decodeInteger(reader, genColumn);
+      if (genColumn < lastCol) sorted = false;
+      lastCol = genColumn;
+      if (hasMoreVlq(reader, semi)) {
+        sourcesIndex = decodeInteger(reader, sourcesIndex);
+        sourceLine = decodeInteger(reader, sourceLine);
+        sourceColumn = decodeInteger(reader, sourceColumn);
+        if (hasMoreVlq(reader, semi)) {
+          namesIndex = decodeInteger(reader, namesIndex);
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+        } else {
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+        }
+      } else {
+        seg = [genColumn];
+      }
+      line.push(seg);
+      reader.pos++;
+    }
+    if (!sorted) sort(line);
+    decoded.push(line);
+    reader.pos = semi + 1;
+  } while (reader.pos <= length);
+  return decoded;
+}
+function sort(line) {
+  line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+  return a[0] - b[0];
+}
+
+// src/trace-mapping.ts
+
+// src/sourcemap-segment.ts
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+
+// src/binary-search.ts
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+  while (low <= high) {
+    const mid = low + (high - low >> 1);
+    const cmp = haystack[mid][COLUMN] - needle;
+    if (cmp === 0) {
+      found = true;
+      return mid;
+    }
+    if (cmp < 0) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  found = false;
+  return low - 1;
+}
+function upperBound(haystack, needle, index) {
+  for (let i = index + 1; i < haystack.length; index = i++) {
+    if (haystack[i][COLUMN] !== needle) break;
+  }
+  return index;
+}
+function lowerBound(haystack, needle, index) {
+  for (let i = index - 1; i >= 0; index = i--) {
+    if (haystack[i][COLUMN] !== needle) break;
+  }
+  return index;
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+  const { lastKey, lastNeedle, lastIndex } = state;
+  let low = 0;
+  let high = haystack.length - 1;
+  if (key === lastKey) {
+    if (needle === lastNeedle) {
+      found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+      return lastIndex;
+    }
+    if (needle >= lastNeedle) {
+      low = lastIndex === -1 ? 0 : lastIndex;
+    } else {
+      high = lastIndex;
+    }
+  }
+  state.lastKey = key;
+  state.lastNeedle = needle;
+  return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+
+// src/trace-mapping.ts
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var LEAST_UPPER_BOUND = -1;
+var GREATEST_LOWER_BOUND = 1;
+function cast(map) {
+  return map;
+}
+function decodedMappings(map) {
+  var _a;
+  return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+function originalPositionFor(map, needle) {
+  let { line, column, bias } = needle;
+  line--;
+  if (line < 0) throw new Error(LINE_GTR_ZERO);
+  if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+  const decoded = decodedMappings(map);
+  if (line >= decoded.length) return OMapping(null, null, null, null);
+  const segments = decoded[line];
+  const index = traceSegmentInternal(
+    segments,
+    cast(map)._decodedMemo,
+    line,
+    column,
+    bias || GREATEST_LOWER_BOUND
+  );
+  if (index === -1) return OMapping(null, null, null, null);
+  const segment = segments[index];
+  if (segment.length === 1) return OMapping(null, null, null, null);
+  const { names, resolvedSources } = map;
+  return OMapping(
+    resolvedSources[segment[SOURCES_INDEX]],
+    segment[SOURCE_LINE] + 1,
+    segment[SOURCE_COLUMN],
+    segment.length === 5 ? names[segment[NAMES_INDEX]] : null
+  );
+}
+function OMapping(source, line, column, name) {
+  return { source, line, column, name };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+  let index = memoizedBinarySearch(segments, column, memo, line);
+  if (found) {
+    index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+  } else if (bias === LEAST_UPPER_BOUND) index++;
+  if (index === -1 || index === segments.length) return -1;
+  return index;
+}
+
+const CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m;
+const SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
+const stackIgnorePatterns = [
+	"node:internal",
+	/\/packages\/\w+\/dist\//,
+	/\/@vitest\/\w+\/dist\//,
+	"/vitest/dist/",
+	"/vitest/src/",
+	"/node_modules/chai/",
+	"/node_modules/tinyspy/",
+	"/vite/dist/node/module-runner",
+	"/rolldown-vite/dist/node/module-runner",
+	"/deps/chunk-",
+	"/deps/@vitest",
+	"/deps/loupe",
+	"/deps/chai",
+	"/browser-playwright/dist/locators.js",
+	"/browser-webdriverio/dist/locators.js",
+	"/browser-preview/dist/locators.js",
+	/node:\w+/,
+	/__vitest_test__/,
+	/__vitest_browser__/,
+	/\/deps\/vitest_/
+];
+function extractLocation(urlLike) {
+	// Fail-fast but return locations like "(native)"
+	if (!urlLike.includes(":")) {
+		return [urlLike];
+	}
+	const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
+	const parts = regExp.exec(urlLike.replace(/^\(|\)$/g, ""));
+	if (!parts) {
+		return [urlLike];
+	}
+	let url = parts[1];
+	if (url.startsWith("async ")) {
+		url = url.slice(6);
+	}
+	if (url.startsWith("http:") || url.startsWith("https:")) {
+		const urlObj = new URL(url);
+		urlObj.searchParams.delete("import");
+		urlObj.searchParams.delete("browserv");
+		url = urlObj.pathname + urlObj.hash + urlObj.search;
+	}
+	if (url.startsWith("/@fs/")) {
+		const isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url);
+		url = url.slice(isWindows ? 5 : 4);
+	}
+	return [
+		url,
+		parts[2] || undefined,
+		parts[3] || undefined
+	];
+}
+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");
+	}
+	// Early return for lines that don't look like Firefox/Safari stack traces
+	// Firefox/Safari stack traces must contain '@' and should have location info after it
+	if (!line.includes("@")) {
+		return null;
+	}
+	// Find the correct @ that separates function name from location
+	// For cases like '@https://@fs/path' or 'functionName@https://@fs/path'
+	// we need to find the first @ that precedes a valid location (containing :)
+	let atIndex = -1;
+	let locationPart = "";
+	let functionName;
+	// Try each @ from left to right to find the one that gives us a valid location
+	for (let i = 0; i < line.length; i++) {
+		if (line[i] === "@") {
+			const candidateLocation = line.slice(i + 1);
+			// Minimum length 3 for valid location: 1 for filename + 1 for colon + 1 for line number (e.g., "a:1")
+			if (candidateLocation.includes(":") && candidateLocation.length >= 3) {
+				atIndex = i;
+				locationPart = candidateLocation;
+				functionName = i > 0 ? line.slice(0, i) : undefined;
+				break;
+			}
+		}
+	}
+	// Validate we found a valid location with minimum length (filename:line format)
+	if (atIndex === -1 || !locationPart.includes(":") || locationPart.length < 3) {
+		return null;
+	}
+	const [url, lineNumber, columnNumber] = extractLocation(locationPart);
+	if (!url || !lineNumber || !columnNumber) {
+		return null;
+	}
+	return {
+		file: url,
+		method: functionName || "",
+		line: Number.parseInt(lineNumber),
+		column: Number.parseInt(columnNumber)
+	};
+}
+function parseSingleStack(raw) {
+	const line = raw.trim();
+	if (!CHROME_IE_STACK_REGEXP.test(line)) {
+		return parseSingleFFOrSafariStack(line);
+	}
+	return parseSingleV8Stack(line);
+}
+// Based on https://github.com/stacktracejs/error-stack-parser
+// Credit to stacktracejs
+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+/, "");
+	// capture and preserve the parenthesized location "(/foo/my bar.js:12:87)" in
+	// case it has spaces in it, as the string is split on \s+ later on
+	const location = sanitizedLine.match(/ (\(.+\)$)/);
+	// remove the parenthesized location from the line, if it was matched
+	sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
+	// if a location was matched, pass it to extractLocation() otherwise pass all sanitizedLine
+	// because this line doesn't have function name
+	const [url, lineNumber, columnNumber] = extractLocation(location ? location[1] : sanitizedLine);
+	let method = location && sanitizedLine || "";
+	let file = url && ["eval", "<anonymous>"].includes(url) ? undefined : url;
+	if (!file || !lineNumber || !columnNumber) {
+		return null;
+	}
+	if (method.startsWith("async ")) {
+		method = method.slice(6);
+	}
+	if (file.startsWith("file://")) {
+		file = file.slice(7);
+	}
+	// normalize Windows path (\ -> /)
+	file = file.startsWith("node:") || file.startsWith("internal:") ? file : resolve(file);
+	if (method) {
+		method = method.replace(/__vite_ssr_import_\d+__\./g, "").replace(/(Object\.)?__vite_ssr_export_default__\s?/g, "");
+	}
+	return {
+		method,
+		file,
+		line: Number.parseInt(lineNumber),
+		column: Number.parseInt(columnNumber)
+	};
+}
+function createStackString(stacks) {
+	return stacks.map((stack) => {
+		const line = `${stack.file}:${stack.line}:${stack.column}`;
+		if (stack.method) {
+			return `    at ${stack.method}(${line})`;
+		}
+		return `    at ${line}`;
+	}).join("\n");
+}
+function parseStacktrace(stack, options = {}) {
+	const { ignoreStackEntries = stackIgnorePatterns } = options;
+	const stacks = !CHROME_IE_STACK_REGEXP.test(stack) ? parseFFOrSafariStackTrace(stack) : parseV8Stacktrace(stack);
+	return stacks.map((stack) => {
+		var _options$getSourceMap;
+		if (options.getUrlId) {
+			stack.file = options.getUrlId(stack.file);
+		}
+		const map = (_options$getSourceMap = options.getSourceMap) === null || _options$getSourceMap === void 0 ? void 0 : _options$getSourceMap.call(options, stack.file);
+		if (!map || typeof map !== "object" || !map.version) {
+			return shouldFilter(ignoreStackEntries, stack.file) ? null : stack;
+		}
+		const traceMap = new DecodedMap(map, stack.file);
+		const position = getOriginalPosition(traceMap, stack);
+		if (!position) {
+			return stack;
+		}
+		const { line, column, source, name } = position;
+		let file = source || stack.file;
+		if (file.match(/\/\w:\//)) {
+			file = file.slice(1);
+		}
+		if (shouldFilter(ignoreStackEntries, file)) {
+			return null;
+		}
+		if (line != null && column != null) {
+			return {
+				line,
+				column,
+				file,
+				method: name || stack.method
+			};
+		}
+		return stack;
+	}).filter((s) => s != null);
+}
+function shouldFilter(ignoreStackEntries, file) {
+	return ignoreStackEntries.some((p) => file.match(p));
+}
+function parseFFOrSafariStackTrace(stack) {
+	return stack.split("\n").map((line) => parseSingleFFOrSafariStack(line)).filter(notNullish);
+}
+function parseV8Stacktrace(stack) {
+	return stack.split("\n").map((line) => parseSingleV8Stack(line)).filter(notNullish);
+}
+function parseErrorStacktrace(e, options = {}) {
+	if (!e || isPrimitive(e)) {
+		return [];
+	}
+	if ("stacks" in e && e.stacks) {
+		return e.stacks;
+	}
+	const stackStr = e.stack || "";
+	// if "stack" property was overwritten at runtime to be something else,
+	// ignore the value because we don't know how to process it
+	let stackFrames = typeof stackStr === "string" ? parseStacktrace(stackStr, options) : [];
+	if (!stackFrames.length) {
+		const e_ = e;
+		if (e_.fileName != null && e_.lineNumber != null && e_.columnNumber != null) {
+			stackFrames = parseStacktrace(`${e_.fileName}:${e_.lineNumber}:${e_.columnNumber}`, options);
+		}
+		if (e_.sourceURL != null && e_.line != null && e_._column != null) {
+			stackFrames = parseStacktrace(`${e_.sourceURL}:${e_.line}:${e_.column}`, options);
+		}
+	}
+	if (options.frameFilter) {
+		stackFrames = stackFrames.filter((f) => options.frameFilter(e, f) !== false);
+	}
+	e.stacks = stackFrames;
+	return stackFrames;
+}
+class DecodedMap {
+	_encoded;
+	_decoded;
+	_decodedMemo;
+	url;
+	version;
+	names = [];
+	resolvedSources;
+	constructor(map, from) {
+		this.map = map;
+		const { mappings, names, sources } = map;
+		this.version = map.version;
+		this.names = names || [];
+		this._encoded = mappings || "";
+		this._decodedMemo = memoizedState();
+		this.url = from;
+		this.resolvedSources = (sources || []).map((s) => resolve(s || "", from));
+	}
+}
+function memoizedState() {
+	return {
+		lastKey: -1,
+		lastNeedle: -1,
+		lastIndex: -1
+	};
+}
+function getOriginalPosition(map, needle) {
+	const result = originalPositionFor(map, needle);
+	if (result.column == null) {
+		return null;
+	}
+	return result;
+}
+
+export { DecodedMap, createStackString, stackIgnorePatterns as defaultStackIgnorePatterns, getOriginalPosition, parseErrorStacktrace, parseSingleFFOrSafariStack, parseSingleStack, parseSingleV8Stack, parseStacktrace };

node_modules/@vitest/utils/dist/timers.d.ts

@@ -0,0 +1,33 @@
+interface SafeTimers {
+	nextTick?: (cb: () => void) => void;
+	setImmediate?: {
+		<TArgs extends any[]>(callback: (...args: TArgs) => void, ...args: TArgs): any;
+		__promisify__: <T = void>(value?: T, options?: any) => Promise<T>;
+	};
+	clearImmediate?: (immediateId: any) => void;
+	setTimeout: typeof setTimeout;
+	setInterval: typeof setInterval;
+	clearInterval: typeof clearInterval;
+	clearTimeout: typeof clearTimeout;
+	queueMicrotask: typeof queueMicrotask;
+}
+declare function getSafeTimers(): SafeTimers;
+declare function setSafeTimers(): void;
+/**
+* Returns a promise that resolves after the specified duration.
+*
+* @param timeout - Delay in milliseconds
+* @param scheduler - Timer function to use, defaults to `setTimeout`. Useful for mocked timers.
+*
+* @example
+* await delay(100)
+*
+* @example
+* // With mocked timers
+* const { setTimeout } = getSafeTimers()
+* await delay(100, setTimeout)
+*/
+declare function delay(timeout: number, scheduler?: typeof setTimeout): Promise<void>;
+
+export { delay, getSafeTimers, setSafeTimers };
+export type { SafeTimers };

node_modules/@vitest/utils/dist/timers.js

@@ -0,0 +1,49 @@
+const SAFE_TIMERS_SYMBOL = Symbol("vitest:SAFE_TIMERS");
+function getSafeTimers() {
+	const { setTimeout: safeSetTimeout, setInterval: safeSetInterval, clearInterval: safeClearInterval, clearTimeout: safeClearTimeout, setImmediate: safeSetImmediate, clearImmediate: safeClearImmediate, queueMicrotask: safeQueueMicrotask } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis;
+	const { nextTick: safeNextTick } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis.process || {};
+	return {
+		nextTick: safeNextTick,
+		setTimeout: safeSetTimeout,
+		setInterval: safeSetInterval,
+		clearInterval: safeClearInterval,
+		clearTimeout: safeClearTimeout,
+		setImmediate: safeSetImmediate,
+		clearImmediate: safeClearImmediate,
+		queueMicrotask: safeQueueMicrotask
+	};
+}
+function setSafeTimers() {
+	const { setTimeout: safeSetTimeout, setInterval: safeSetInterval, clearInterval: safeClearInterval, clearTimeout: safeClearTimeout, setImmediate: safeSetImmediate, clearImmediate: safeClearImmediate, queueMicrotask: safeQueueMicrotask } = globalThis;
+	const { nextTick: safeNextTick } = globalThis.process || {};
+	const timers = {
+		nextTick: safeNextTick,
+		setTimeout: safeSetTimeout,
+		setInterval: safeSetInterval,
+		clearInterval: safeClearInterval,
+		clearTimeout: safeClearTimeout,
+		setImmediate: safeSetImmediate,
+		clearImmediate: safeClearImmediate,
+		queueMicrotask: safeQueueMicrotask
+	};
+	globalThis[SAFE_TIMERS_SYMBOL] = timers;
+}
+/**
+* Returns a promise that resolves after the specified duration.
+*
+* @param timeout - Delay in milliseconds
+* @param scheduler - Timer function to use, defaults to `setTimeout`. Useful for mocked timers.
+*
+* @example
+* await delay(100)
+*
+* @example
+* // With mocked timers
+* const { setTimeout } = getSafeTimers()
+* await delay(100, setTimeout)
+*/
+function delay(timeout, scheduler = setTimeout) {
+	return new Promise((resolve) => scheduler(resolve, timeout));
+}
+
+export { delay, getSafeTimers, setSafeTimers };

node_modules/@vitest/utils/dist/types.d-BCElaP-c.d.ts

@@ -0,0 +1,53 @@
+import { CompareKeys } from '@vitest/pretty-format';
+
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+type DiffOptionsColor = (arg: string) => string;
+interface DiffOptions {
+	aAnnotation?: string;
+	aColor?: DiffOptionsColor;
+	aIndicator?: string;
+	bAnnotation?: string;
+	bColor?: DiffOptionsColor;
+	bIndicator?: string;
+	changeColor?: DiffOptionsColor;
+	changeLineTrailingSpaceColor?: DiffOptionsColor;
+	commonColor?: DiffOptionsColor;
+	commonIndicator?: string;
+	commonLineTrailingSpaceColor?: DiffOptionsColor;
+	contextLines?: number;
+	emptyFirstOrLastLinePlaceholder?: string;
+	expand?: boolean;
+	includeChangeCounts?: boolean;
+	omitAnnotationLines?: boolean;
+	patchColor?: DiffOptionsColor;
+	printBasicPrototype?: boolean;
+	maxDepth?: number;
+	compareKeys?: CompareKeys;
+	truncateThreshold?: number;
+	truncateAnnotation?: string;
+	truncateAnnotationColor?: DiffOptionsColor;
+}
+interface SerializedDiffOptions {
+	aAnnotation?: string;
+	aIndicator?: string;
+	bAnnotation?: string;
+	bIndicator?: string;
+	commonIndicator?: string;
+	contextLines?: number;
+	emptyFirstOrLastLinePlaceholder?: string;
+	expand?: boolean;
+	includeChangeCounts?: boolean;
+	omitAnnotationLines?: boolean;
+	printBasicPrototype?: boolean;
+	maxDepth?: number;
+	truncateThreshold?: number;
+	truncateAnnotation?: string;
+}
+
+export type { DiffOptions as D, SerializedDiffOptions as S, DiffOptionsColor as a };

node_modules/@vitest/utils/dist/types.d.ts

@@ -0,0 +1,34 @@
+type Awaitable<T> = T | PromiseLike<T>;
+type Nullable<T> = T | null | undefined;
+type Arrayable<T> = T | Array<T>;
+type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
+type MergeInsertions<T> = T extends object ? { [K in keyof T] : MergeInsertions<T[K]> } : T;
+type DeepMerge<
+	F,
+	S
+> = MergeInsertions<{ [K in keyof F | keyof S] : K extends keyof S & keyof F ? DeepMerge<F[K], S[K]> : K extends keyof S ? S[K] : K extends keyof F ? F[K] : never }>;
+interface Constructable {
+	new (...args: any[]): any;
+}
+interface ParsedStack {
+	method: string;
+	file: string;
+	line: number;
+	column: number;
+}
+interface SerializedError {
+	message: string;
+	stacks?: ParsedStack[];
+	stack?: string;
+	name?: string;
+	cause?: SerializedError;
+	[key: string]: unknown;
+}
+interface TestError extends SerializedError {
+	cause?: TestError;
+	diff?: string;
+	actual?: string;
+	expected?: string;
+}
+
+export type { ArgumentsType, Arrayable, Awaitable, Constructable, DeepMerge, MergeInsertions, Nullable, ParsedStack, SerializedError, TestError };

node_modules/@vitest/utils/dist/types.js

@@ -0,0 +1 @@
+