@vitest/utils 3.0.8 → 3.0.9

package/dist/chunk-_commonjsHelpers.js

@@ -69,6 +69,9 @@ function format(...args) {
           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);

package/dist/diff.d.ts

@@ -1,98 +1,91 @@
-import { D as DiffOptions } from './types-6R1G1gkS.js';
-export { a as DiffOptionsColor, S as SerializedDiffOptions } from './types-6R1G1gkS.js';
+import { D as DiffOptions } from './types.d-Cr0z4Cnu.js';
+export { a as DiffOptionsColor, S as SerializedDiffOptions } from './types.d-Cr0z4Cnu.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.
- */
+* 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)
- */
+* @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
- */
+* 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.'
- */
+* 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
- */
+* 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);
+	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.
- */
+* 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.
- */
+* 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];
 
 /**
- * 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.
- */
-
-/**
- * @param a Expected value
- * @param b Received value
- * @param options Diff options
- * @returns {string | null} a string diff
- */
+* @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;
+	replacedActual: any
+	replacedExpected: any
 };
 type PrintLabel = (string: string) => string;
 declare function getLabelPrinter(...strings: Array<string>): PrintLabel;

package/dist/diff.js

@@ -15,7 +15,7 @@ class Diff {
     this[1] = text;
   }
 }
-const diff_commonPrefix = function(text1, text2) {
+function diff_commonPrefix(text1, text2) {
   if (!text1 || !text2 || text1.charAt(0) !== text2.charAt(0)) {
     return 0;
   }
@@ -33,8 +33,8 @@ const diff_commonPrefix = function(text1, text2) {
     pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
   }
   return pointermid;
-};
-const diff_commonSuffix = function(text1, text2) {
+}
+function diff_commonSuffix(text1, text2) {
   if (!text1 || !text2 || text1.charAt(text1.length - 1) !== text2.charAt(text2.length - 1)) {
     return 0;
   }
@@ -52,8 +52,8 @@ const diff_commonSuffix = function(text1, text2) {
     pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
   }
   return pointermid;
-};
-const diff_commonOverlap_ = function(text1, text2) {
+}
+function diff_commonOverlap_(text1, text2) {
   const text1_length = text1.length;
   const text2_length = text2.length;
   if (text1_length === 0 || text2_length === 0) {
@@ -82,8 +82,8 @@ const diff_commonOverlap_ = function(text1, text2) {
       length++;
     }
   }
-};
-const diff_cleanupSemantic = function(diffs) {
+}
+function diff_cleanupSemantic(diffs) {
   let changes = false;
   const equalities = [];
   let equalitiesLength = 0;
@@ -173,7 +173,7 @@ const diff_cleanupSemantic = function(diffs) {
     }
     pointer++;
   }
-};
+}
 const nonAlphaNumericRegex_ = /[^a-z0-9]/i;
 const whitespaceRegex_ = /\s/;
 const linebreakRegex_ = /[\r\n]/;

package/dist/error.d.ts

@@ -1,4 +1,4 @@
-import { D as DiffOptions } from './types-6R1G1gkS.js';
+import { D as DiffOptions } from './types.d-Cr0z4Cnu.js';
 import '@vitest/pretty-format';
 
 declare function serializeValue(val: any, seen?: WeakMap<WeakKey, any>): any;

package/dist/helpers.d.ts

@@ -1,17 +1,17 @@
 import { Nullable, Arrayable } from './types.js';
 
 interface CloneOptions {
-    forceWritable?: boolean;
+	forceWritable?: boolean;
 }
 interface ErrorOptions {
-    message?: string;
-    stackTraceLimit?: number;
+	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).
- */
+* 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;
@@ -27,28 +27,28 @@ declare function clone<T>(val: T, seen: WeakMap<any, any>, options?: CloneOption
 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;
+	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')
- * ```
- */
+* 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
- */
+* 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 { type DeferPromise, assertTypes, clone, createDefer, createSimpleStackTrace, deepClone, deepMerge, getCallLastIndex, getOwnProperties, getType, isNegativeNaN, isObject, isPrimitive, noop, notNullish, objectAttr, parseRegexp, slash, toArray };

package/dist/index.d.ts

@@ -5,30 +5,30 @@ export { ArgumentsType, Arrayable, Awaitable, Constructable, DeepMerge, ErrorWit
 
 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;
+	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;
+	maxLength?: number;
 }
-declare function stringify(object: unknown, maxDepth?: number, { maxLength, ...options }?: StringifyOptions): string;
+declare function stringify(object: unknown, maxDepth?: number, { maxLength,...options }?: StringifyOptions): string;
 declare function format(...args: unknown[]): string;
 declare function inspect(obj: unknown, options?: LoupeOptions): string;
 declare function objDisplay(obj: unknown, options?: LoupeOptions): string;
 
 interface HighlightOptions {
-    jsx?: boolean;
-    colors?: Colors;
+	jsx?: boolean;
+	colors?: Colors;
 }
 declare function highlight(code: string, options?: HighlightOptions): string;
 
@@ -41,14 +41,14 @@ declare function offsetToLineNumber(source: string, offset: number): number;
 declare function shuffle<T>(array: T[], seed?: number): T[];
 
 interface SafeTimers {
-    nextTick: (cb: () => void) => void;
-    setTimeout: typeof setTimeout;
-    setInterval: typeof setInterval;
-    clearInterval: typeof clearInterval;
-    clearTimeout: typeof clearTimeout;
-    setImmediate: typeof setImmediate;
-    clearImmediate: typeof clearImmediate;
-    queueMicrotask: typeof queueMicrotask;
+	nextTick: (cb: () => void) => void;
+	setTimeout: typeof setTimeout;
+	setInterval: typeof setInterval;
+	clearInterval: typeof clearInterval;
+	clearTimeout: typeof clearTimeout;
+	setImmediate: typeof setImmediate;
+	clearImmediate: typeof clearImmediate;
+	queueMicrotask: typeof queueMicrotask;
 }
 declare function getSafeTimers(): SafeTimers;
 declare function setSafeTimers(): void;

package/dist/source-map.d.ts

@@ -121,10 +121,10 @@ declare function generatedPositionFor(map: TraceMap, needle: SourceNeedle): Gene
 declare function eachMapping(map: TraceMap, cb: (mapping: EachMapping) => void): void;
 
 interface StackTraceParserOptions {
-    ignoreStackEntries?: (RegExp | string)[];
-    getSourceMap?: (file: string) => unknown;
-    getUrlId?: (id: string) => string;
-    frameFilter?: (error: ErrorWithDiff, frame: ParsedStack) => boolean | void;
+	ignoreStackEntries?: (RegExp | string)[];
+	getSourceMap?: (file: string) => unknown;
+	getUrlId?: (id: string) => string;
+	frameFilter?: (error: ErrorWithDiff, frame: ParsedStack) => boolean | void;
 }
 declare function parseSingleFFOrSafariStack(raw: string): ParsedStack | null;
 declare function parseSingleStack(raw: string): ParsedStack | null;

package/dist/types.d-Cr0z4Cnu.d.ts

@@ -0,0 +1,51 @@
+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;
+	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;
+	truncateThreshold?: number;
+	truncateAnnotation?: string;
+}
+
+export type { DiffOptions as D, SerializedDiffOptions as S, DiffOptionsColor as a };

package/dist/types.d.ts

@@ -2,57 +2,54 @@ 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;
-}>;
-type MutableArray<T extends readonly any[]> = {
-    -readonly [k in keyof T]: T[k];
-};
+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 }>;
+type MutableArray<T extends readonly any[]> = { -readonly [k in keyof T] : T[k] };
 interface Constructable {
-    new (...args: any[]): any;
+	new (...args: any[]): any;
 }
 interface ParsedStack {
-    method: string;
-    file: string;
-    line: number;
-    column: number;
+	method: string;
+	file: string;
+	line: number;
+	column: number;
 }
 interface SerializedError {
-    message: string;
-    stack?: string;
-    name?: string;
-    stacks?: ParsedStack[];
-    cause?: SerializedError;
-    [key: string]: unknown;
+	message: string;
+	stack?: string;
+	name?: string;
+	stacks?: ParsedStack[];
+	cause?: SerializedError;
+	[key: string]: unknown;
 }
 interface TestError extends SerializedError {
-    cause?: TestError;
-    diff?: string;
-    actual?: string;
-    expected?: string;
+	cause?: TestError;
+	diff?: string;
+	actual?: string;
+	expected?: string;
 }
 /**
- * @deprecated Use `TestError` instead
- */
+* @deprecated Use `TestError` instead
+*/
 interface ErrorWithDiff {
-    message: string;
-    name?: string;
-    cause?: unknown;
-    nameStr?: string;
-    stack?: string;
-    stackStr?: string;
-    stacks?: ParsedStack[];
-    showDiff?: boolean;
-    actual?: any;
-    expected?: any;
-    operator?: string;
-    type?: string;
-    frame?: string;
-    diff?: string;
-    codeFrame?: string;
+	message: string;
+	name?: string;
+	cause?: unknown;
+	nameStr?: string;
+	stack?: string;
+	stackStr?: string;
+	stacks?: ParsedStack[];
+	showDiff?: boolean;
+	actual?: any;
+	expected?: any;
+	operator?: string;
+	type?: string;
+	frame?: string;
+	diff?: string;
+	codeFrame?: string;
 }
 
 export type { ArgumentsType, Arrayable, Awaitable, Constructable, DeepMerge, ErrorWithDiff, MergeInsertions, MutableArray, Nullable, ParsedStack, SerializedError, TestError };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/utils",
   "type": "module",
-  "version": "3.0.8",
+  "version": "3.0.9",
   "description": "Shared Vitest utility functions",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -62,7 +62,7 @@
   "dependencies": {
     "loupe": "^3.1.3",
     "tinyrainbow": "^2.0.0",
-    "@vitest/pretty-format": "3.0.8"
+    "@vitest/pretty-format": "3.0.9"
   },
   "devDependencies": {
     "@jridgewell/trace-mapping": "^0.3.25",

package/dist/types-6R1G1gkS.d.ts

@@ -1,51 +0,0 @@
-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;
-    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;
-    truncateThreshold?: number;
-    truncateAnnotation?: string;
-}
-
-export type { DiffOptions as D, SerializedDiffOptions as S, DiffOptionsColor as a };