diff --git a/api/assert.md b/api/assert.md
index d6907123..78fcd770 100644
--- a/api/assert.md
+++ b/api/assert.md
@@ -1,12 +1,12 @@
 # assert
 
-Vitest reexports the `assert` method from [`chai`](https://www.chaijs.com/api/assert/) for verifying invariants.
+Vitest 从 [`chai`](https://www.chaijs.com/api/assert/) 重新导出了 `assert` 方法，用于验证不变量。
 
 ## assert
 
-- **Type:** `(expression: any, message?: string) => asserts expression`
+- **类型:** `(expression: any, message?: string) => asserts expression`
 
-Assert that the given `expression` is truthy, otherwise the assertion fails.
+断言给定的 `expression` 是 true，否则断言失败。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -18,11 +18,11 @@ test('assert', () => {
 
 ## fail
 
-- **Type:**
+- **类型:**
   - `(message?: string) => never`
   - `<T>(actual: T, expected: T, message?: string, operator?: string) => never`
 
-Force an assertion failure.
+强制断言失败。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -35,10 +35,10 @@ test('assert.fail', () => {
 
 ## isOk
 
-- **Type:** `<T>(value: T, message?: string) => asserts value`
+- **类型:** `<T>(value: T, message?: string) => asserts value`
 - **Alias** `ok`
 
-Assert that the given `value` is truthy.
+断言给定的 `value` 是 true 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -51,10 +51,10 @@ test('assert.isOk', () => {
 
 ## isNotOk
 
-- **Type:** `<T>(value: T, message?: string) => void`
+- **类型:** `<T>(value: T, message?: string) => void`
 - **Alias** `notOk`
 
-Assert that the given `value` is falsy.
+断言给定的 `value` 是 false 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -67,9 +67,9 @@ test('assert.isNotOk', () => {
 
 ## equal
 
-- **Type:** `<T>(actual: T, expected: T, message?: string) => void`
+- **类型:** `<T>(actual: T, expected: T, message?: string) => void`
 
-Asserts non-strict equality (==) of `actual` and `expected`.
+断言 `actual` 和 `expected` 非严格相等 (==)。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -81,9 +81,9 @@ test('assert.equal', () => {
 
 ## notEqual
 
-- **Type:** `<T>(actual: T, expected: T, message?: string) => void`
+- **类型:** `<T>(actual: T, expected: T, message?: string) => void`
 
-Asserts non-strict inequality (!=) of `actual` and `expected`.
+断言 `actual` 和 `expected` 非严格不等 (!=)。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -95,9 +95,9 @@ test('assert.equal', () => {
 
 ## strictEqual
 
-- **Type:** `<T>(actual: T, expected: T, message?: string) => void`
+- **类型:** `<T>(actual: T, expected: T, message?: string) => void`
 
-Asserts strict equality (===) of `actual` and `expected`.
+断言 `actual` 和 `expected` 严格相等 (===)。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -109,9 +109,9 @@ test('assert.strictEqual', () => {
 
 ## deepEqual
 
-- **Type:** `<T>(actual: T, expected: T, message?: string) => void`
+- **类型:** `<T>(actual: T, expected: T, message?: string) => void`
 
-Asserts that `actual` is deeply equal to `expected`.
+断言 `actual` 深度等于 `expected` 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -123,9 +123,9 @@ test('assert.deepEqual', () => {
 
 ## notDeepEqual
 
-- **Type:** `<T>(actual: T, expected: T, message?: string) => void`
+- **类型:** `<T>(actual: T, expected: T, message?: string) => void`
 
-Assert that `actual` is not deeply equal to `expected`.
+断言 `actual` 不深度等于 `expected` 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -137,9 +137,9 @@ test('assert.notDeepEqual', () => {
 
 ## isAbove
 
-- **Type:** `(valueToCheck: number, valueToBeAbove: number, message?: string) => void`
+- **类型:** `(valueToCheck: number, valueToBeAbove: number, message?: string) => void`
 
-Assert that `valueToCheck` is strictly greater than (>) `valueToBeAbove`.
+断言 `valueToCheck` 严格大于 (>) `valueToBeAbove` 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -151,9 +151,9 @@ test('assert.isAbove', () => {
 
 ## isAtLeast
 
-- **Type:** `(valueToCheck: number, valueToBeAtLeast: number, message?: string) => void`
+- **类型:** `(valueToCheck: number, valueToBeAtLeast: number, message?: string) => void`
 
-Assert that `valueToCheck` is greater than or equal to (>=) `valueToBeAtLeast`.
+断言 `valueToCheck` 大于等于 (>=) `valueToBeAtLeast` 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -166,9 +166,9 @@ test('assert.isAtLeast', () => {
 
 ## isBelow
 
-- **Type:** `(valueToCheck: number, valueToBeBelow: number, message?: string) => void`
+- **类型:** `(valueToCheck: number, valueToBeBelow: number, message?: string) => void`
 
-Asserts `valueToCheck` is strictly less than (<) `valueToBeBelow`.
+断言 `valueToCheck` 严格小于 (<) `valueToBeBelow` 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -180,9 +180,9 @@ test('assert.isBelow', () => {
 
 ## isAtMost
 
-- **Type:** `(valueToCheck: number, valueToBeAtMost: number, message?: string) => void`
+- **类型:** `(valueToCheck: number, valueToBeAtMost: number, message?: string) => void`
 
-Asserts `valueToCheck` is less than or equal to (<=) `valueToBeAtMost`.
+断言 `valueToCheck` 小于等于 (<=) `valueToBeAtMost` 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -195,9 +195,9 @@ test('assert.isAtMost', () => {
 
 ## isTrue
 
-- **Type:** `<T>(value: T, message?: string) => asserts value is true`
+- **类型:** `<T>(value: T, message?: string) => asserts value is true`
 
-Asserts that `value` is true.
+断言 `value` 是 true 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -211,9 +211,9 @@ test('assert.isTrue', () => {
 
 ## isNotTrue
 
-- **Type:** `<T>(value: T, message?: string) => asserts value is Exclude<T, true>`
+- **类型:** `<T>(value: T, message?: string) => asserts value is Exclude<T, true>`
 
-Asserts that `value` is not true.
+断言 `value` 不是 true 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -227,9 +227,9 @@ test('assert.isNotTrue', () => {
 
 ## isFalse
 
-- **Type:** `<T>(value: T, message?: string) => asserts value is false`
+- **类型:** `<T>(value: T, message?: string) => asserts value is false`
 
-Asserts that `value` is false.
+断言 `value` 是 false 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -243,9 +243,9 @@ test('assert.isFalse', () => {
 
 ## isNotFalse
 
-- **Type:** `<T>(value: T, message?: string) => asserts value is Exclude<T, false>`
+- **类型:** `<T>(value: T, message?: string) => asserts value is Exclude<T, false>`
 
-Asserts that `value` is not false.
+断言 `value` 不是 false 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -259,9 +259,9 @@ test('assert.isNotFalse', () => {
 
 ## isNull
 
-- **Type:** `<T>(value: T, message?: string) => asserts value is null`
+- **类型:** `<T>(value: T, message?: string) => asserts value is null`
 
-Asserts that `value` is null.
+断言 `value` 是 null 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -275,9 +275,9 @@ test('assert.isNull', () => {
 
 ## isNotNull
 
-- **Type:** `<T>(value: T, message?: string) => asserts value is Exclude<T, null>`
+- **类型:** `<T>(value: T, message?: string) => asserts value is Exclude<T, null>`
 
-Asserts that `value` is not null.
+断言 `value` 不是 null 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -291,9 +291,9 @@ test('assert.isNotNull', () => {
 
 ## isNaN
 
-- **Type:** `<T>(value: T, message?: string) => void`
+- **类型:** `<T>(value: T, message?: string) => void`
 
-Asserts that `value` is NaN.
+断言 `value` 是 NaN 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -307,9 +307,9 @@ test('assert.isNaN', () => {
 
 ## isNotNaN
 
-- **Type:** `<T>(value: T, message?: string) => void`
+- **类型:** `<T>(value: T, message?: string) => void`
 
-Asserts that `value` is not NaN.
+断言 `value` 不是 NaN 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -323,9 +323,9 @@ test('assert.isNotNaN', () => {
 
 ## exists
 
-- **Type:** `<T>(value: T, message?: string) => asserts value is NonNullable<T>`
+- **类型:** `<T>(value: T, message?: string) => asserts value is NonNullable<T>`
 
-Asserts that `value` is neither null nor undefined.
+断言 `value` 既不是 null 也不是 undefined 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -339,9 +339,9 @@ test('assert.exists', () => {
 
 ## notExists
 
-- **Type:** `<T>(value: T, message?: string) => asserts value is null | undefined`
+- **类型:** `<T>(value: T, message?: string) => asserts value is null | undefined`
 
-Asserts that `value` is either null nor undefined.
+断言 `value` 是 null 或 undefined 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -357,9 +357,9 @@ test('assert.notExists', () => {
 
 ## isUndefined
 
-- **Type:** `<T>(value: T, message?: string) => asserts value is undefined`
+- **类型:** `<T>(value: T, message?: string) => asserts value is undefined`
 
-Asserts that `value` is undefined.
+断言 `value` 是 undefined 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -373,9 +373,9 @@ test('assert.isUndefined', () => {
 
 ## isDefined
 
-- **Type:** `<T>(value: T, message?: string) => asserts value is Exclude<T, undefined>`
+- **类型:** `<T>(value: T, message?: string) => asserts value is Exclude<T, undefined>`
 
-Asserts that `value` is not undefined.
+断言 `value` 不是 undefined 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -389,9 +389,9 @@ test('assert.isDefined', () => {
 
 ## isFunction
 
-- **Type:** `<T>(value: T, message?: string) => void`
-- **Alias:** `isCallable`
-  Asserts that `value` is a function.
+- **类型:** `<T>(value: T, message?: string) => void`
+- **别名:** `isCallable`
+  断言 `value` 是一个函数。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -407,10 +407,10 @@ test('assert.isFunction', () => {
 
 ## isNotFunction
 
-- **Type:** `<T>(value: T, message?: string) => void`
-- **Alias:** `isNotCallable`
+- **类型:** `<T>(value: T, message?: string) => void`
+- **别名:** `isNotCallable`
 
-Asserts that `value` is not a function.
+断言 `value` 不是一个函数。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -424,9 +424,9 @@ test('assert.isNotFunction', () => {
 
 ## isObject
 
-- **Type:** `<T>(value: T, message?: string) => void`
+- **类型:** `<T>(value: T, message?: string) => void`
 
-Asserts that `value` is an object of type Object (as revealed by Object.prototype.toString). The assertion does not match subclassed objects.
+断言 `value` 是一个类型为 Object 的对象 (由 Object.prototype.toString 确定)。 此断言不匹配子类对象。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -440,9 +440,9 @@ test('assert.isObject', () => {
 
 ## isNotObject
 
-- **Type:** `<T>(value: T, message?: string) => void`
+- **类型:** `<T>(value: T, message?: string) => void`
 
-Asserts that `value` is not an object of type Object (as revealed by Object.prototype.toString). The assertion does not match subclassed objects.
+断言 `value` 不是一个类型为 Object 的对象 (如 Object.prototype.toString 确定)。 该断言不匹配子类对象。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -456,9 +456,9 @@ test('assert.isNotObject', () => {
 
 ## isArray
 
-- **Type:** `<T>(value: T, message?: string) => void`
+- **类型:** `<T>(value: T, message?: string) => void`
 
-Asserts that `value` is an array.
+断言 `value` 是一个数组。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -472,9 +472,9 @@ test('assert.isArray', () => {
 
 ## isNotArray
 
-- **Type:** `<T>(value: T, message?: string) => void`
+- **类型:** `<T>(value: T, message?: string) => void`
 
-Asserts that `value` is not an array.
+断言 `value` 不是一个数组。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -488,9 +488,9 @@ test('assert.isNotArray', () => {
 
 ## isString
 
-- **Type:** `<T>(value: T, message?: string) => void`
+- **类型:** `<T>(value: T, message?: string) => void`
 
-Asserts that `value` is a string.
+断言 `value` 是一个字符串。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -504,9 +504,9 @@ test('assert.isString', () => {
 
 ## isNotString
 
-- **Type:** `<T>(value: T, message?: string) => void`
+- **类型:** `<T>(value: T, message?: string) => void`
 
-Asserts that `value` is not a string.
+断言 `value` 不是一个字符串。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -520,9 +520,9 @@ test('assert.isNotString', () => {
 
 ## isNumber
 
-- **Type:** `<T>(value: T, message?: string) => void`
+- **类型:** `<T>(value: T, message?: string) => void`
 
-Asserts that `value` is a number.
+断言 `value` 是一个数字。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -536,9 +536,9 @@ test('assert.isNumber', () => {
 
 ## isNotNumber
 
-- **Type:** `<T>(value: T, message?: string) => void`
+- **类型:** `<T>(value: T, message?: string) => void`
 
-Asserts that `value` is not a number.
+断言 `value` 不是一个数字。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -552,9 +552,9 @@ test('assert.isNotNumber', () => {
 
 ## isFinite
 
-- **Type:** `<T>(value: T, message?: string) => void`
+- **类型:** `<T>(value: T, message?: string) => void`
 
-Asserts that `value` is a finite number (not NaN, Infinity).
+断言 `value` 是一个有限数字。(不是 NaN, Infinity)。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -568,9 +568,9 @@ test('assert.isFinite', () => {
 
 ## isBoolean
 
-- **Type:** `<T>(value: T, message?: string) => void`
+- **类型:** `<T>(value: T, message?: string) => void`
 
-Asserts that `value` is a boolean.
+断言 `value` 是一个布尔值。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -584,9 +584,9 @@ test('assert.isBoolean', () => {
 
 ## isNotBoolean
 
-- **Type:** `<T>(value: T, message?: string) => void`
+- **类型:** `<T>(value: T, message?: string) => void`
 
-Asserts that `value` is not a boolean.
+断言 `value` 不是一个布尔值。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -600,9 +600,9 @@ test('assert.isBoolean', () => {
 
 ## typeOf
 
-- **Type:** `<T>(value: T, name: string, message?: string) => void`
+- **类型:** `<T>(value: T, name: string, message?: string) => void`
 
-Asserts that `value`’s type is `name`, as determined by Object.prototype.toString.
+断言 `value` 的类型是 `name`， 由 Object.prototype.toString 确定。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -619,9 +619,9 @@ test('assert.typeOf', () => {
 
 ## notTypeOf
 
-- **Type:** `<T>(value: T, name: string, message?: string) => void`
+- **类型:** `<T>(value: T, name: string, message?: string) => void`
 
-Asserts that `value`’s type is not `name`, as determined by Object.prototype.toString.
+断言 `value` 的类型不是 `name`，由 Object.prototype.toString 确定。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -633,9 +633,9 @@ test('assert.notTypeOf', () => {
 
 ## instanceOf
 
-- **Type:** `<T>(value: T, constructor: Function, message?: string) => asserts value is T`
+- **类型:** `<T>(value: T, constructor: Function, message?: string) => asserts value is T`
 
-Asserts that `value` is an instance of `constructor`.
+断言 `value` 是 `constructor` 的实例。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -660,9 +660,9 @@ test('assert.instanceOf', () => {
 
 ## notInstanceOf
 
-- **Type:** `<T>(value: T, constructor: Function, message?: string) => asserts value is Exclude<T, U>`
+- **类型:** `<T>(value: T, constructor: Function, message?: string) => asserts value is Exclude<T, U>`
 
-Asserts that `value` is not an instance of `constructor`.
+断言 `value` 不是 `constructor` 的实例。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -686,13 +686,13 @@ test('assert.instanceOf', () => {
 
 ## include
 
-- **Type:**
+- **类型:**
   - `(haystack: string, needle: string, message?: string) => void`
   - `<T>(haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string) => void`
   - `<T extends object>(haystack: WeakSet<T>, needle: T, message?: string) => void`
   - `<T>(haystack: T, needle: Partial<T>, message?: string) => void`
 
-Asserts that `haystack` includes `needle`. Can be used to assert the inclusion of a value in an array, a substring in a string, or a subset of properties in an object.
+断言 `haystack` 包含 `needle` 。可以用来断言数组中是否包含一个值、字符串中是否包含一个子字符串、或者对象中是否包含一组属性。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -710,13 +710,13 @@ test('assert.include', () => {
 
 ## notInclude
 
-- **Type:**
+- **类型:**
   - `(haystack: string, needle: string, message?: string) => void`
   - `<T>(haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string) => void`
   - `<T extends object>(haystack: WeakSet<T>, needle: T, message?: string) => void`
   - `<T>(haystack: T, needle: Partial<T>, message?: string) => void`
 
-Asserts that `haystack` does not include `needle`. It can be used to assert the absence of a value in an array, a substring in a string, or a subset of properties in an object.
+断言 `haystack` 不包含 `needle` 。可以用来断言数组中是否不包含一个值、字符串中是否不包含一个子字符串、或者对象中是否不包含一组属性。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -734,12 +734,12 @@ test('assert.notInclude', () => {
 
 ## deepInclude
 
-- **Type:**
+- **类型:**
 - `(haystack: string, needle: string, message?: string) => void`
 - `<T>(haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string) => void`
 - `<T>(haystack: T, needle: T extends WeakSet<any> ? never : Partial<T>, message?: string) => void`
 
-Asserts that `haystack` includes `needle`. Can be used to assert the inclusion of a value in an array or a subset of properties in an object. Deep equality is used.
+断言 `haystack`  包含 `needle` 。可以用来断言数组中是否包含一个值或对象中是否包含一组属性。使用深度相等。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -755,12 +755,12 @@ test('assert.deepInclude', () => {
 
 ## notDeepInclude
 
-- **Type:**
+- **类型:**
   - `(haystack: string, needle: string, message?: string) => void`
   - `<T>(haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>, needle: T, message?: string) => void`
   - `<T>(haystack: T, needle: T extends WeakSet<any> ? never : Partial<T>, message?: string) => void`
 
-Asserts that `haystack` does not include `needle`. It can be used to assert the absence of a value in an array or a subset of properties in an object. Deep equality is used.
+断言 `haystack` 不包含 `needle` 。可以用来断言数组中是否不包含一个值或对象中是否不包含一组属性。使用深度相等。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -776,9 +776,9 @@ test('assert.notDeepInclude', () => {
 
 ## nestedInclude
 
-- **Type:** `(haystack: any, needle: any, message?: string) => void`
+- **类型:** `(haystack: any, needle: any, message?: string) => void`
 
-Asserts that `haystack` includes `needle`. Can be used to assert the inclusion of a subset of properties in an object. Enables the use of dot- and bracket-notation for referencing nested properties. ‘[]’ and ‘.’ in property names can be escaped using double backslashes.
+断言 `haystack` 包含 `needle` 。 可以用来断言对象中是否包含一组属性。允许使用点和括号表示法来引用嵌套属性。属性名中的 ‘[]’ 和 ‘.’ 可以使用双反斜杠转义。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -791,9 +791,9 @@ test('assert.nestedInclude', () => {
 
 ## notNestedInclude
 
-- **Type:** `(haystack: any, needle: any, message?: string) => void`
+- **类型:** `(haystack: any, needle: any, message?: string) => void`
 
-Asserts that `haystack` does not include `needle`. Can be used to assert the inclusion of a subset of properties in an object. Enables the use of dot- and bracket-notation for referencing nested properties. ‘[]’ and ‘.’ in property names can be escaped using double backslashes.
+断言 `haystack` 不包含 `needle` 。可以用来断言对象中是否不包含一组属性。允许使用点和括号表示法来引用嵌套属性。属性名中的 ‘[]’ 和 ‘.’ 可以使用双反斜杠转义。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -806,9 +806,9 @@ test('assert.nestedInclude', () => {
 
 ## deepNestedInclude
 
-- **Type:** `(haystack: any, needle: any, message?: string) => void`
+- **类型:** `(haystack: any, needle: any, message?: string) => void`
 
-Asserts that `haystack` includes `needle`. Can be used to assert the inclusion of a subset of properties in an object while checking for deep equality. Enables the use of dot- and bracket-notation for referencing nested properties. ‘[]’ and ‘.’ in property names can be escaped using double backslashes.
+断言 `haystack` 包含 `needle` 。可以用来断言对象中是否包含一组属性，同时检查深度相等性。允许使用点和括号表示法来引用嵌套属性。属性名中的 ‘[]’ 和 ‘.’ 可以使用双反斜杠转义。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -824,9 +824,9 @@ test('assert.deepNestedInclude', () => {
 
 ## notDeepNestedInclude
 
-- **Type:** `(haystack: any, needle: any, message?: string) => void`
+- **类型:** `(haystack: any, needle: any, message?: string) => void`
 
-Asserts that `haystack` not includes `needle`. Can be used to assert the absence of a subset of properties in an object while checking for deep equality. Enables the use of dot- and bracket-notation for referencing nested properties. ‘[]’ and ‘.’ in property names can be escaped using double backslashes.
+断言 `haystack` 不包含 `needle` 。可以用来断言对象中是否不包含一组属性，同时检查深度相等性。允许使用点和括号表示法来引用嵌套属性。属性名中的 ‘[]’ 和 ‘.’ 可以使用双反斜杠转义。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -842,9 +842,9 @@ test('assert.notDeepNestedInclude', () => {
 
 ## ownInclude
 
-- **Type:** `(haystack: any, needle: any, message?: string) => void`
+- **类型:** `(haystack: any, needle: any, message?: string) => void`
 
-Asserts that `haystack` includes `needle`. Can be used to assert the inclusion of a subset of properties in an object while ignoring inherited properties.
+断言 `haystack` 包含 `needle` 。可以用来断言对象中是否包含一组属性，同时忽略继承的属性。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -856,9 +856,9 @@ test('assert.ownInclude', () => {
 
 ## notOwnInclude
 
-- **Type:** `(haystack: any, needle: any, message?: string) => void`
+- **类型:** `(haystack: any, needle: any, message?: string) => void`
 
-Asserts that `haystack` includes `needle`. Can be used to assert the absence of a subset of properties in an object while ignoring inherited properties.
+断言 `haystack` 包含 `needle` 。可以用来断言对象中是否不包含一组属性，同时忽略继承的属性
 
 ```ts
 import { assert, test } from 'vitest'
@@ -877,9 +877,9 @@ test('assert.notOwnInclude', () => {
 
 ## deepOwnInclude
 
-- **Type:** `(haystack: any, needle: any, message?: string) => void`
+- **类型:** `(haystack: any, needle: any, message?: string) => void`
 
-Asserts that `haystack` includes `needle`. Can be used to assert the inclusion of a subset of properties in an object while ignoring inherited properties and checking for deep equality.
+断言 `haystack` 包含 `needle` 。可以用来断言对象中是否包含一组属性，同时忽略继承的属性并检查深度相等性。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -891,9 +891,9 @@ test('assert.deepOwnInclude', () => {
 
 ## notDeepOwnInclude
 
-- **Type:** `(haystack: any, needle: any, message?: string) => void`
+- **类型:** `(haystack: any, needle: any, message?: string) => void`
 
-Asserts that `haystack` not includes `needle`. Can be used to assert the absence of a subset of properties in an object while ignoring inherited properties and checking for deep equality.
+断言 `haystack` 不包含 `needle` 。可以用来断言对象中是否不包含一组属性，同时忽略继承的属性并检查深度相等性。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -905,9 +905,9 @@ test('assert.notDeepOwnInclude', () => {
 
 ## match
 
-- **Type:** `(value: string, regexp: RegExp, message?: string) => void`
+- **类型:** `(value: string, regexp: RegExp, message?: string) => void`
 
-Asserts that `value` matches the regular expression `regexp`.
+断言 `value` 匹配正则表达式 `regexp` 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -919,9 +919,9 @@ test('assert.match', () => {
 
 ## notMatch
 
-- **Type:** `(value: string, regexp: RegExp, message?: string) => void`
+- **类型:** `(value: string, regexp: RegExp, message?: string) => void`
 
-Asserts that `value` does not matches the regular expression `regexp`.
+断言 `value` 不匹配正则表达式 `regexp` 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -933,9 +933,9 @@ test('assert.notMatch', () => {
 
 ## property
 
-- **Type:** `<T>(object: T, property: string, message?: string) => void`
+- **类型:** `<T>(object: T, property: string, message?: string) => void`
 
-Asserts that `object` has a direct or inherited property named by `property`
+断言 `object` 具有由 `property` 指定的直接或继承属性。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -948,9 +948,9 @@ test('assert.property', () => {
 
 ## notProperty
 
-- **Type:** `<T>(object: T, property: string, message?: string) => void`
+- **类型:** `<T>(object: T, property: string, message?: string) => void`
 
-Asserts that `object` does not have a direct or inherited property named by `property`
+断言 `object` 没有由 `property` 指定的直接或继承属性。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -962,9 +962,9 @@ test('assert.notProperty', () => {
 
 ## propertyVal
 
-- **Type:** `<T, V>(object: T, property: string, value: V, message?: string) => void`
+- **类型:** `<T, V>(object: T, property: string, value: V, message?: string) => void`
 
-Asserts that `object` has a direct or inherited property named by `property` with a value given by `value`. Uses a strict equality check (===).
+断言 `object` 具有由 `property` 指定的直接或继承属性，其值为 `value` 。使用严格相等检查（===）。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -976,9 +976,9 @@ test('assert.notPropertyVal', () => {
 
 ## notPropertyVal
 
-- **Type:** `<T, V>(object: T, property: string, value: V, message?: string) => void`
+- **类型:** `<T, V>(object: T, property: string, value: V, message?: string) => void`
 
-Asserts that `object` does not have a direct or inherited property named by `property` with a value given by `value`. Uses a strict equality check (===).
+断言 `object` 没有由 `property` 指定的直接或继承属性，其值为 `value` 。使用严格相等检查（===）。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -991,9 +991,9 @@ test('assert.notPropertyVal', () => {
 
 ## deepPropertyVal
 
-- **Type:** `<T, V>(object: T, property: string, value: V, message?: string) => void`
+- **类型:** `<T, V>(object: T, property: string, value: V, message?: string) => void`
 
-Asserts that `object` has a direct or inherited property named by `property` with a value given by `value`. Uses a deep equality check.
+断言 `object` 具有由 `property` 指定的直接或继承属性，其值为 `value` 。使用深度相等检查。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1007,9 +1007,9 @@ test('assert.deepPropertyVal', () => {
 
 ## notDeepPropertyVal
 
-- **Type:** `<T, V>(object: T, property: string, value: V, message?: string) => void`
+- **类型:** `<T, V>(object: T, property: string, value: V, message?: string) => void`
 
-Asserts that `object` does not have a direct or inherited property named by `property` with a value given by `value`. Uses a deep equality check.
+断言 `object` 没有由 `property` 指定的直接或继承属性，其值为 `value` 。使用深度相等检查。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1029,9 +1029,9 @@ test('assert.deepPropertyVal', () => {
 
 ## nestedProperty
 
-- **Type:** `<T>(object: T, property: string, message?: string) => void`
+- **类型:** `<T>(object: T, property: string, message?: string) => void`
 
-Asserts that `object` has a direct or inherited property named by `property`, which can be a string using dot- and bracket-notation for nested reference.
+断言 `object` 具有由 `property` 指定的直接或继承属性，它可以是一个字符串，使用点和括号表示法来引用嵌套的引用。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1043,9 +1043,9 @@ test('assert.deepPropertyVal', () => {
 
 ## notNestedProperty
 
-- **Type:** `<T>(object: T, property: string, message?: string) => void`
+- **类型:** `<T>(object: T, property: string, message?: string) => void`
 
-Asserts that `object` does not have a direct or inherited property named by `property`, which can be a string using dot- and bracket-notation for nested reference.
+断言 `object` 没有由 `property` 指定的属性，它可以是一个字符串，使用点和括号表示法来引用嵌套的引用。该属性不能存在于对象上，也不能存在于其原型链中的任何地方。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1057,9 +1057,9 @@ test('assert.deepPropertyVal', () => {
 
 ## nestedPropertyVal
 
-- **Type:** `<T>(object: T, property: string, value: any, message?: string) => void`
+- **类型:** `<T>(object: T, property: string, value: any, message?: string) => void`
 
-Asserts that `object` has a property named by `property` with value given by `value`. `property` can use dot- and bracket-notation for nested reference. Uses a strict equality check (===).
+断言 `object` 具有由 `property` 指定的属性，其值为 `value` 给出。 `property` 可以使用点和方括号表示法进行嵌套引用。使用严格相等检查 (===)。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1071,9 +1071,9 @@ test('assert.nestedPropertyVal', () => {
 
 ## notNestedPropertyVal
 
-- **Type:** `<T>(object: T, property: string, value: any, message?: string) => void`
+- **类型:** `<T>(object: T, property: string, value: any, message?: string) => void`
 
-Asserts that `object` does not have a property named by `property` with value given by `value`. `property` can use dot- and bracket-notation for nested reference. Uses a strict equality check (===).
+断言 `object` 没有由 `property` 指定的属性，其值为 `value` 给出。 `property` 可以使用点和方括号表示法进行嵌套引用。使用严格相等检查 (===)。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1094,9 +1094,9 @@ test('assert.notNestedPropertyVal', () => {
 
 ## deepNestedPropertyVal
 
-- **Type:** `<T>(object: T, property: string, value: any, message?: string) => void`
+- **类型:** `<T>(object: T, property: string, value: any, message?: string) => void`
 
-Asserts that `object` has a property named by `property` with a value given by `value`. `property` can use dot- and bracket-notation for nested reference. Uses a deep equality check (===).
+断言 `object` 具有由 `property` 指定的属性，其值为 `value` 给出。 `property` 可以使用点和方括号表示法进行嵌套引用。使用深度相等检查。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1117,9 +1117,9 @@ test('assert.notNestedPropertyVal', () => {
 
 ## notDeepNestedPropertyVal
 
-- **Type:** `<T>(object: T, property: string, value: any, message?: string) => void`
+- **类型:** `<T>(object: T, property: string, value: any, message?: string) => void`
 
-Asserts that `object` does not have a property named by `property` with value given by `value`. `property` can use dot- and bracket-notation for nested reference. Uses a deep equality check.
+断言 `object` 没有由 `property` 指定的属性，其值为 `value` 给出。 `property` 可以使用点和方括号表示法进行嵌套引用。使用深度相等检查。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1145,9 +1145,9 @@ test('assert.notDeepNestedPropertyVal', () => {
 
 ## lengthOf
 
-- **Type:** `<T extends { readonly length?: number | undefined } | { readonly size?: number | undefined }>(object: T, length: number, message?: string) => void`
+- **类型:** `<T extends { readonly length?: number | undefined } | { readonly size?: number | undefined }>(object: T, length: number, message?: string) => void`
 
-Asserts that `object` has a `length` or `size` with the expected value.
+断言 `object` 具有预期的 `length` 或 `size` 值。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1170,9 +1170,9 @@ test('assert.lengthOf', () => {
 
 ## hasAnyKeys
 
-- **Type:** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`
+- **类型:** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`
 
-Asserts that `object` has at least one of the `keys` provided. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.
+断言 `object` 至少拥有一个提供的 `keys` 。你也可以提供一个单独的对象而不是一个 `keys` 数组，它的键将被用作预期的键集。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1199,9 +1199,9 @@ test('assert.hasAnyKeys', () => {
 
 ## hasAllKeys
 
-- **Type:** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`
+- **类型:** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`
 
-Asserts that `object` has all and only all of the `keys` provided. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.
+断言 `object` 拥有且仅拥有所有提供的 `keys` 。你也可以提供一个单独的对象而不是一个 `keys` 数组，它的键将被用作预期的键集。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1227,9 +1227,9 @@ test('assert.hasAllKeys', () => {
 
 ## containsAllKeys
 
-- **Type:** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`
+- **类型:** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`
 
-Asserts that `object` has all of the `keys` provided but may have more keys not listed. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.
+断言 `object` 拥有所有提供的 `keys`，但可能还有更多未列出的键。你也可以提供一个单独的对象而不是一个 `keys` 数组，它的键将被用作预期的键集。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1267,9 +1267,9 @@ test('assert.containsAllKeys', () => {
 
 ## doesNotHaveAnyKeys
 
-- **Type:** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`
+- **类型:** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`
 
-Asserts that `object` has none of the `keys` provided. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.
+断言 `object` 不拥有任何提供的 `keys` 。你也可以提供一个单独的对象而不是一个 `keys` 数组，它的键将被用作预期的键集。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1299,9 +1299,9 @@ test('assert.doesNotHaveAnyKeys', () => {
 
 ## doesNotHaveAllKeys
 
-- **Type:** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`
+- **类型:** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`
 
-Asserts that `object` does not have at least one of the `keys` provided. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.
+断言 `object` 至少不拥有一个提供的 `keys` 。你也可以提供一个单独的对象而不是一个 `keys` 数组，它的键将被用作预期的键集。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1332,9 +1332,9 @@ test('assert.hasAnyKeys', () => {
 
 ## hasAnyDeepKeys
 
-- **Type:** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`
+- **类型:** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`
 
-Asserts that `object` has at least one of the `keys` provided. Since Sets and Maps can have objects as keys you can use this assertion to perform a deep comparison. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.
+断言 `object` 至少拥有一个提供的 `keys` 。由于 Set 和 Map 可以拥有对象作为键，你可以使用这个断言来进行深度比较。你也可以提供一个单独的对象而不是一个 keys 数组，它的键将被用作预期的键集。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1377,9 +1377,9 @@ test('assert.hasAnyDeepKeys', () => {
 
 ## hasAllDeepKeys
 
-- **Type:** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`
+- **类型:** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`
 
-Asserts that `object` has all and only all of the `keys` provided. Since Sets and Maps can have objects as keys you can use this assertion to perform a deep comparison. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.
+断言 `object` 拥有且仅拥有所有提供的 `keys` 。由于 Set 和 Map 可以拥有对象作为键，你可以使用这个断言来进行深度比较。你也可以提供一个单独的对象而不是一个 keys 数组，它的键将被用作预期的键集。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1405,9 +1405,9 @@ test('assert.hasAnyDeepKeys', () => {
 
 ## containsAllDeepKeys
 
-- **Type:** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`
+- **类型:** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`
 
-Asserts that `object` contains all of the `keys` provided. Since Sets and Maps can have objects as keys you can use this assertion to perform a deep comparison. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.
+断言 `object` 包含所有提供的 `keys` 。由于 Set 和 Map 可以拥有对象作为键，你可以使用这个断言来进行深度比较。你也可以提供一个单独的对象而不是一个 `keys` 数组，它的键将被用作预期的键集。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1439,9 +1439,9 @@ test('assert.containsAllDeepKeys', () => {
 
 ## doesNotHaveAnyDeepKeys
 
-- **Type:** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`
+- **类型:** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`
 
-Asserts that `object` has none of the `keys` provided. Since Sets and Maps can have objects as keys you can use this assertion to perform a deep comparison. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.
+断言 `object` 不拥有任何提供的 `keys` 。由于 Set 和 Map 可以拥有对象作为键，你可以使用这个断言来进行深度比较。你也可以提供一个单独的对象而不是一个 `keys` 数组，它的键将被用作预期的键集。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1473,9 +1473,9 @@ test('assert.doesNotHaveAnyDeepKeys', () => {
 
 ## doesNotHaveAllDeepKeys
 
-- **Type:** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`
+- **类型:** `<T>(object: T, keys: Array<Object | string> | { [key: string]: any }, message?: string) => void`
 
-Asserts that `object` does not have at least one of the `keys` provided. Since Sets and Maps can have objects as keys you can use this assertion to perform a deep comparison. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.
+断言 `object` 至少不拥有一个提供的 `keys` 。由于 Set 和 Map 可以拥有对象作为键，你可以使用这个断言来进行深度比较。你也可以提供一个单独的对象而不是一个 `keys` 数组，它的键将被用作预期的键集。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1507,14 +1507,14 @@ test('assert.doesNotHaveAllDeepKeys', () => {
 
 ## throws
 
-- **Type:**
+- **类型:**
   - `(fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string) => void`
   - `(fn: () => void, errorLike?: ErrorConstructor | Error | null, errMsgMatcher?: RegExp | string | null, message?: string) => void`
-- **Alias:**
+- **别名:**
   - `throw`
   - `Throw`
 
-If `errorLike` is an Error constructor, asserts that `fn` will throw an error that is an instance of `errorLike`. If errorLike is an Error instance, asserts that the error thrown is the same instance as `errorLike`. If `errMsgMatcher` is provided, it also asserts that the error thrown will have a message matching `errMsgMatcher`.
+如果 `errorLike` 是一个 Error 构造函数，则断言 `fn` 将抛出一个 errorLike 实例的错误。如果 `errorLike` 是一个 Error 实例，则断言抛出的错误与 `errorLike` 是同一个实例。如果提供了 `errMsgMatcher`，它还断言抛出的错误将具有与 `errMsgMatcher` 相匹配的消息。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1549,10 +1549,10 @@ test('assert.throws', () => {
 
 ## doesNotThrow
 
-- **Type:** `(fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string) => void`
-- **Type:** `(fn: () => void, errorLike?: ErrorConstructor | Error | null, errMsgMatcher?: RegExp | string | null, message?: string) => void`
+- **类型:** `(fn: () => void, errMsgMatcher?: RegExp | string, ignored?: any, message?: string) => void`
+- **类型:** `(fn: () => void, errorLike?: ErrorConstructor | Error | null, errMsgMatcher?: RegExp | string | null, message?: string) => void`
 
-If `errorLike` is an Error constructor, asserts that `fn` will not throw an error that is an instance of `errorLike`. If errorLike is an Error instance, asserts that the error thrown is not the same instance as `errorLike`. If `errMsgMatcher` is provided, it also asserts that the error thrown will not have a message matching `errMsgMatcher`.
+如果 `errorLike` 是一个 Error 构造函数，则断言 `fn` 不会 抛出一个 errorLike 实例的错误。如果 `errorLike` 是一个 Error 实例，则断言抛出的错误不是与 errorLike 是同一个实例。如果提供了 `errMsgMatcher`，它还断言抛出的错误不会 具有与 `errMsgMatcher` 相匹配的消息。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1571,9 +1571,9 @@ test('assert.doesNotThrow', () => {
 
 ## operator
 
-- **Type:** `(val1: OperatorComparable, operator: Operator, val2: OperatorComparable, message?: string) => void`
+- **类型:** `(val1: OperatorComparable, operator: Operator, val2: OperatorComparable, message?: string) => void`
 
-Compare `val1` and `val2` using `operator`.
+使用 `operator` 比较 `val1` 和 `val2` 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1585,10 +1585,10 @@ test('assert.operator', () => {
 
 ## closeTo
 
-- **Type:** `(actual: number, expected: number, delta: number, message?: string) => void`
-- **Alias:** `approximately`
+- **类型:** `(actual: number, expected: number, delta: number, message?: string) => void`
+- **别名:** `approximately`
 
-Asserts that the `actual` is equal `expected`, to within a +/- `delta` range.
+断言 `actual` 等于 `expected`，误差范围控制在 +/- `delta` 内。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1600,9 +1600,9 @@ test('assert.closeTo', () => {
 
 ## sameMembers
 
-- **Type:** `<T>(set1: T[], set2: T[], message?: string) => void`
+- **类型:** `<T>(set1: T[], set2: T[], message?: string) => void`
 
-Asserts that `set1` and `set2` have the same members in any order. Uses a strict equality check (===).
+断言 `set1` 和 `set2` 具有相同的成员，但顺序可以不同。使用严格相等检查 (===)。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1614,9 +1614,9 @@ test('assert.sameMembers', () => {
 
 ## notSameMembers
 
-- **Type:** `<T>(set1: T[], set2: T[], message?: string) => void`
+- **类型:** `<T>(set1: T[], set2: T[], message?: string) => void`
 
-Asserts that `set1` and `set2` don't have the same members in any order. Uses a strict equality check (===).
+断言 `set1` 和 `set2` 不具有相同的成员，但顺序可以不同。使用严格相等检查 (===)。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1628,9 +1628,9 @@ test('assert.sameMembers', () => {
 
 ## sameDeepMembers
 
-- **Type:** `<T>(set1: T[], set2: T[], message?: string) => void`
+- **类型:** `<T>(set1: T[], set2: T[], message?: string) => void`
 
-Asserts that `set1` and `set2` have the same members in any order. Uses a deep equality check.
+断言 `set1` 和 `set2` 具有相同的成员，但顺序可以不同。使用深度相等检查。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1646,9 +1646,9 @@ test('assert.sameDeepMembers', () => {
 
 ## notSameDeepMembers
 
-- **Type:** `<T>(set1: T[], set2: T[], message?: string) => void`
+- **类型:** `<T>(set1: T[], set2: T[], message?: string) => void`
 
-Asserts that `set1` and `set2` don’t have the same members in any order. Uses a deep equality check.
+断言 `set1` 和 `set2` 不具有相同的成员，但顺序可以不同。使用深度相等检查。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1664,9 +1664,9 @@ test('assert.sameDeepMembers', () => {
 
 ## sameOrderedMembers
 
-- **Type:** `<T>(set1: T[], set2: T[], message?: string) => void`
+- **类型:** `<T>(set1: T[], set2: T[], message?: string) => void`
 
-Asserts that `set1` and `set2` have the same members in the same order. Uses a strict equality check (===).
+断言 `set1` 和 `set2` 具有相同的成员，并且顺序也相同。使用严格相等检查 (===)。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1678,9 +1678,9 @@ test('assert.sameOrderedMembers', () => {
 
 ## notSameOrderedMembers
 
-- **Type:** `<T>(set1: T[], set2: T[], message?: string) => void`
+- **类型:** `<T>(set1: T[], set2: T[], message?: string) => void`
 
-Asserts that `set1` and `set2` have the same members in the same order. Uses a strict equality check (===).
+断言 `set1` 和 `set2` 的成员不相同或顺序不同。使用严格相等比较 (===)。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1696,9 +1696,9 @@ test('assert.notSameOrderedMembers', () => {
 
 ## sameDeepOrderedMembers
 
-- **Type:** `<T>(set1: T[], set2: T[], message?: string) => void`
+- **类型:** `<T>(set1: T[], set2: T[], message?: string) => void`
 
-Asserts that `set1` and `set2` have the same members in the same order. Uses a deep equality check.
+断言 `set1` 和 `set2` 的成员相同且顺序相同。使用深度相等比较。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1714,9 +1714,9 @@ test('assert.sameDeepOrderedMembers', () => {
 
 ## notSameDeepOrderedMembers
 
-- **Type:** `<T>(set1: T[], set2: T[], message?: string) => void`
+- **类型:** `<T>(set1: T[], set2: T[], message?: string) => void`
 
-Asserts that `set1` and `set2` don’t have the same members in the same order. Uses a deep equality check.
+断言 `set1` 和 `set2` 的成员不相同或顺序不同。使用深度相等比较。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1737,9 +1737,9 @@ test('assert.notSameDeepOrderedMembers', () => {
 
 ## includeMembers
 
-- **Type:** `<T>(superset: T[], subset: T[], message?: string) => void`
+- **类型:** `<T>(superset: T[], subset: T[], message?: string) => void`
 
-Asserts that `subset` is included in `superset` in any order. Uses a strict equality check (===). Duplicates are ignored.
+断言 `subset` 被包含在 `superset` 中，顺序可以不同。使用严格相等比较 (===)。忽略重复项。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1751,9 +1751,9 @@ test('assert.includeMembers', () => {
 
 ## notIncludeMembers
 
-- **Type:** `<T>(superset: T[], subset: T[], message?: string) => void`
+- **类型:** `<T>(superset: T[], subset: T[], message?: string) => void`
 
-Asserts that `subset` isn't included in `superset` in any order. Uses a strict equality check (===). Duplicates are ignored.
+断言 `subset` 未被包含在 `superset` 中，顺序可以不同。使用严格相等比较 (===)。忽略重复项。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1765,9 +1765,9 @@ test('assert.notIncludeMembers', () => {
 
 ## includeDeepMembers
 
-- **Type:** `<T>(superset: T[], subset: T[], message?: string) => void`
+- **类型:** `<T>(superset: T[], subset: T[], message?: string) => void`
 
-Asserts that `subset` is included in `superset` in any order. Uses a deep equality check. Duplicates are ignored.
+断言 `subset` 被包含在 `superset` 中，顺序可以不同。使用深度相等比较。忽略重复项。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1783,9 +1783,9 @@ test('assert.includeDeepMembers', () => {
 
 ## notIncludeDeepMembers
 
-- **Type:** `<T>(superset: T[], subset: T[], message?: string) => void`
+- **类型:** `<T>(superset: T[], subset: T[], message?: string) => void`
 
-Asserts that `subset` isn’t included in `superset` in any order. Uses a deep equality check. Duplicates are ignored.
+断言 `subset` 未被包含在 `superset` 中，顺序可以不同。使用深度相等比较。忽略重复项。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1801,9 +1801,9 @@ test('assert.notIncludeDeepMembers', () => {
 
 ## includeOrderedMembers
 
-- **Type:** `<T>(superset: T[], subset: T[], message?: string) => void`
+- **类型:** `<T>(superset: T[], subset: T[], message?: string) => void`
 
-Asserts that `subset` is included in `superset` in the same order beginning with the first element in `superset`. Uses a strict equality check (===).
+断言 `subset` 被包含在 `superset` 中，顺序相同，从 `superset` 中的第一个元素开始。使用严格相等比较 (===)。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1815,9 +1815,9 @@ test('assert.includeOrderedMembers', () => {
 
 ## notIncludeOrderedMembers
 
-- **Type:** `<T>(superset: T[], subset: T[], message?: string) => void`
+- **类型:** `<T>(superset: T[], subset: T[], message?: string) => void`
 
-Asserts that `subset` isn't included in `superset` in the same order beginning with the first element in `superset`. Uses a strict equality check (===).
+断言 `subset` 未被包含在 `superset` 中，顺序相同，从 `superset` 中的第一个元素开始。使用严格相等比较 (===)。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1838,9 +1838,9 @@ test('assert.notIncludeOrderedMembers', () => {
 
 ## includeDeepOrderedMembers
 
-- **Type:** `<T>(superset: T[], subset: T[], message?: string) => void`
+- **类型:** `<T>(superset: T[], subset: T[], message?: string) => void`
 
-Asserts that `subset` is included in `superset` in the same order beginning with the first element in `superset`. Uses a deep equality check.
+断言 `subset` 被包含在 `superset` 中，顺序相同，从 `superset` 中的第一个元素开始。使用深度相等比较。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1856,9 +1856,9 @@ test('assert.includeDeepOrderedMembers', () => {
 
 ## notIncludeDeepOrderedMembers
 
-- **Type:** `<T>(superset: T[], subset: T[], message?: string) => void`
+- **类型:** `<T>(superset: T[], subset: T[], message?: string) => void`
 
-Asserts that `subset` isn’t included in `superset` in the same order beginning with the first element in superset. Uses a deep equality check.
+断言 `subset` 未被包含在 `superset` 中，顺序相同，从 `superset` 中的第一个元素开始。使用深度相等比较。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1884,9 +1884,9 @@ test('assert.includeDeepOrderedMembers', () => {
 
 ## oneOf
 
-- **Type:** `<T>(inList: T, list: T[], message?: string) => void`
+- **类型:** `<T>(inList: T, list: T[], message?: string) => void`
 
-Asserts that non-object, non-array value `inList` appears in the flat array `list`.
+断言非对象、非数组值 `inList` 出现在扁平数组 list 中。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1898,9 +1898,9 @@ test('assert.oneOf', () => {
 
 ## changes
 
-- **Type:** `<T>(modifier: Function, object: T, property: string, message?: string) => void`
+- **类型:** `<T>(modifier: Function, object: T, property: string, message?: string) => void`
 
-Asserts that a `modifier` changes the `object` of a `property`.
+断言 `函数` 用于修改 `property` 所属 `object` 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1916,9 +1916,9 @@ test('assert.changes', () => {
 
 ## changesBy
 
-- **Type:** `<T>(modifier: Function, object: T, property: string, change: number, message?: string) => void`
+- **类型:** `<T>(modifier: Function, object: T, property: string, change: number, message?: string) => void`
 
-Asserts that a `modifier` changes the `object` of a `property` by a `change`.
+断言 `函数` 通过 `change` 修改 `property` 所属的 `object` 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1934,9 +1934,9 @@ test('assert.changesBy', () => {
 
 ## doesNotChange
 
-- **Type:** `<T>(modifier: Function, object: T, property: string, message?: string) => void`
+- **类型:** `<T>(modifier: Function, object: T, property: string, message?: string) => void`
 
-Asserts that a `modifier` does not changes the `object` of a `property`.
+断言 `函数` 不会通过 `change` 修改 `property` 或 `函数` 返回值的 `object` 。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1952,9 +1952,9 @@ test('assert.doesNotChange', () => {
 
 ## changesButNotBy
 
-- **Type:** `<T>(modifier: Function, object: T, property: string, change:number, message?: string) => void`
+- **类型:** `<T>(modifier: Function, object: T, property: string, change:number, message?: string) => void`
 
-Asserts that a `modifier` does not change the `object` of a `property` or of a `modifier` return value by a `change`.
+断言 `函数` 不会通过 `change` 修改 `property` 或 `函数` 返回值的所属对象。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1970,9 +1970,9 @@ test('assert.changesButNotBy', () => {
 
 ## increases
 
-- **Type:** `<T>(modifier: Function, object: T, property: string, message?: string) => void`
+- **类型:** `<T>(modifier: Function, object: T, property: string, message?: string) => void`
 
-Asserts that a `modifier` increases a numeric `object`'s `property`.
+断言 `函数` 会增加数值类型对象属性。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -1988,9 +1988,9 @@ test('assert.increases', () => {
 
 ## increasesBy
 
-- **Type:** `<T>(modifier: Function, object: T, property: string, change: number, message?: string) => void`
+- **类型:** `<T>(modifier: Function, object: T, property: string, change: number, message?: string) => void`
 
-Asserts that a `modifier` increases a numeric `object`'s `property` or a `modifier` return value by an `change`.
+断言 `函数` 会通过 `change` 增加数值类型对象属性或 `函数` 返回值的数值。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -2004,9 +2004,9 @@ test('assert.increasesBy', () => {
 
 ## doesNotIncrease
 
-- **Type:** `<T>(modifier: Function, object: T, property: string, message?: string) => void`
+- **类型:** `<T>(modifier: Function, object: T, property: string, message?: string) => void`
 
-Asserts that a `modifier` does not increases a numeric `object`'s `property`.
+断言 `函数` 不会增加数值类型对象属性。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -2022,9 +2022,9 @@ test('assert.doesNotIncrease', () => {
 
 ## increasesButNotBy
 
-- **Type:** `<T>(modifier: Function, object: T, property: string, change: number, message?: string) => void`
+- **类型:** `<T>(modifier: Function, object: T, property: string, change: number, message?: string) => void`
 
-Asserts that a `modifier` does not increases a numeric `object`'s `property` or a `modifier` return value by an `change`.
+断言 `函数` 不会通过 `change` 增加数值类型对象属性或 `函数` 返回值的数值。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -2040,9 +2040,9 @@ test('assert.increasesButNotBy', () => {
 
 ## decreases
 
-- **Type:** `<T>(modifier: Function, object: T, property: string, message?: string) => void`
+- **类型:** `<T>(modifier: Function, object: T, property: string, message?: string) => void`
 
-Asserts that a `modifier` decreases a numeric `object`'s `property`.
+断言 `函数` 不会通过 `change` 增加数值类型对象属性或 `函数` 返回值的数值。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -2058,9 +2058,9 @@ test('assert.decreases', () => {
 
 ## decreasesBy
 
-- **Type:** `<T>(modifier: Function, object: T, property: string, change: number, message?: string) => void`
+- **类型:** `<T>(modifier: Function, object: T, property: string, change: number, message?: string) => void`
 
-Asserts that a `modifier` decreases a numeric `object`'s `property` or a `modifier` return value by a `change`.
+断言 `函数` 会通过 `change` 减少数值类型对象属性或 `函数` 返回值的数值。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -2076,9 +2076,9 @@ test('assert.decreasesBy', () => {
 
 ## doesNotDecrease
 
-- **Type:** `<T>(modifier: Function, object: T, property: string, message?: string) => void`
+- **类型:** `<T>(modifier: Function, object: T, property: string, message?: string) => void`
 
-Asserts that a `modifier` dose not decrease a numeric `object`'s `property`.
+断言 `函数` 不会减少数值类型对象属性。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -2094,9 +2094,9 @@ test('assert.doesNotDecrease', () => {
 
 ## doesNotDecreaseBy
 
-- **Type:** `<T>(modifier: Function, object: T, property: string, change: number, message?: string) => void`
+- **类型:** `<T>(modifier: Function, object: T, property: string, change: number, message?: string) => void`
 
-Asserts that a `modifier` does not decrease a numeric `object`'s `property` or a `modifier` return value by a `change`.
+断言 `函数` 不会通过 `change` 减少数值类型对象属性或 `函数` 返回值的数值。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -2112,9 +2112,9 @@ test('assert.doesNotDecreaseBy', () => {
 
 ## decreasesButNotBy
 
-- **Type:** `<T>(modifier: Function, object: T, property: string, change: number, message?: string) => void`
+- **类型:** `<T>(modifier: Function, object: T, property: string, change: number, message?: string) => void`
 
-Asserts that a `modifier` does not decrease a numeric `object`'s `property` or a `modifier` return value by a `change`.
+断言 `函数` 不会通过 change 减少数值类型对象属性或 `函数` 返回值的数值。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -2130,25 +2130,25 @@ test('assert.decreasesButNotBy', () => {
 
 ## ifError
 
-- **Type:** `<T>(object: T, message?: string) => void`
+- **类型:** `<T>(object: T, message?: string) => void`
 
-Asserts if `object` is not a false value, and throws if it is a true value. This is added to allow for chai to be a drop-in replacement for Node’s assert class.
+断言 `object` 是否为假值，如果它是真值则抛出错误。这是为了允许 chai 作为 Node 的 assert 类的一个直接替代品。
 
 ```ts
 import { assert, test } from 'vitest'
 
 test('assert.ifError', () => {
   const err = new Error('I am a custom error')
-  assert.ifError(err) // Rethrows err!
+  assert.ifError(err) // 重新抛出错误！
 })
 ```
 
 ## isExtensible
 
-- **Type:** `<T>(object: T, message?: string) => void`
-- **Alias:** `extensible`
+- **类型:** `<T>(object: T, message?: string) => void`
+- **别名:** `extensible`
 
-Asserts that `object` is extensible (can have new properties added to it).
+断言 `object` 是可扩展的（可以向其添加新的属性）。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -2160,10 +2160,10 @@ test('assert.isExtensible', () => {
 
 ## isNotExtensible
 
-- **Type:** `<T>(object: T, message?: string) => void`
-- **Alias:** `notExtensible`
+- **类型:** `<T>(object: T, message?: string) => void`
+- **别名:** `notExtensible`
 
-Asserts that `object` is not extensible (can not have new properties added to it).
+断言 `object` 是不可扩展的 （不能添加新属性）。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -2181,10 +2181,10 @@ test('assert.isNotExtensible', () => {
 
 ## isSealed
 
-- **Type:** `<T>(object: T, message?: string) => void`
-- **Alias:** `sealed`
+- **类型:** `<T>(object: T, message?: string) => void`
+- **别名:** `sealed`
 
-Asserts that `object` is sealed (cannot have new properties added to it and its existing properties cannot be removed).
+断言 `object` 是密封的（不能向其添加新的属性，也不能删除其现有属性）。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -2200,10 +2200,10 @@ test('assert.isSealed', () => {
 
 ## isNotSealed
 
-- **Type:** `<T>(object: T, message?: string) => void`
-- **Alias:** `notSealed`
+- **类型:** `<T>(object: T, message?: string) => void`
+- **别名:** `notSealed`
 
-Asserts that `object` is not sealed (can have new properties added to it and its existing properties can be removed).
+断言 `object` 未被密封（可以添加新属性，并且可以删除其现有属性）。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -2215,10 +2215,10 @@ test('assert.isNotSealed', () => {
 
 ## isFrozen
 
-- **Type:** `<T>(object: T, message?: string) => void`
-- **Alias:** `frozen`
+- **类型:** `<T>(object: T, message?: string) => void`
+- **别名:** `frozen`
 
-Asserts that object is frozen (cannot have new properties added to it and its existing properties cannot be modified).
+断言 `object` 是冻结的（不能向其添加新的属性，也不能修改其现有属性）。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -2231,10 +2231,10 @@ test('assert.isFrozen', () => {
 
 ## isNotFrozen
 
-- **Type:** `<T>(object: T, message?: string) => void`
-- **Alias:** `notFrozen`
+- **类型:** `<T>(object: T, message?: string) => void`
+- **别名:** `notFrozen`
 
-Asserts that `object` is not frozen (can have new properties added to it and its existing properties can be modified).
+断言 `object` 未被冻结（可以向其添加新属性，并且可以修改其现有属性）。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -2246,10 +2246,10 @@ test('assert.isNotFrozen', () => {
 
 ## isEmpty
 
-- **Type:** `<T>(target: T, message?: string) => void`
-- **Alias:** `empty`
+- **类型:** `<T>(target: T, message?: string) => void`
+- **别名:** `empty`
 
-Asserts that the `target` does not contain any values. For arrays and strings, it checks the length property. For Map and Set instances, it checks the size property. For non-function objects, it gets the count of its own enumerable string keys.
+断言 `target` 不包含任何值。对于数组和字符串，它检查 length 属性。对于 Map 和 Set 实例，它检查 size 属性。对于非函数对象，它获取自身可枚举字符串键的数量。
 
 ```ts
 import { assert, test } from 'vitest'
@@ -2264,10 +2264,10 @@ test('assert.isEmpty', () => {
 
 ## isNotEmpty
 
-- **Type:** `<T>(object: T, message?: string) => void`
-- **Alias:** `notEmpty`
+- **类型:** `<T>(object: T, message?: string) => void`
+- **别名:** `notEmpty`
 
-Asserts that the `target` contains values. For arrays and strings, it checks the length property. For Map and Set instances, it checks the size property. For non-function objects, it gets the count of its own enumerable string keys.
+断言 `target` 包含值。对于数组和字符串，它检查 length 属性。对于 Map 和 Set 实例，它检查 size 属性。对于非函数对象，它获取自身可枚举字符串键的数量。
 
 ```ts
 import { assert, test } from 'vitest'
diff --git a/api/expect-typeof.md b/api/expect-typeof.md
index 1b23800c..8ac3e967 100644
--- a/api/expect-typeof.md
+++ b/api/expect-typeof.md
@@ -46,7 +46,7 @@ expectTypeOf<string | number>().not.toMatchTypeOf<number>()
 
 ## toExtend
 
-- **Type:** `<T>(expected: T) => void`
+- **类型：** `<T>(expected: T) => void`
 
 这个匹配器用于检查期望类型是否扩展了提供的类型。它与 `toEqual` 不同，更类似于 [expect](/api/expect) 的 `toMatchObject()`。使用这个匹配器，你可以检查一个对象是否"匹配"某个类型。
 
@@ -60,7 +60,7 @@ expectTypeOf<string | number>().not.toExtend<number>()
 
 ## toMatchObjectType
 
-- **Type:** `() => void`
+- **类型：** `() => void`
 
 这个匹配器对对象类型执行严格检查，确保期望的类型与提供的对象类型相匹配。它比 [`toExtend`](#toextend) 更严格，是在处理对象类型时的推荐选择，因为它更有可能捕获到像只读属性这样的问题。
 
diff --git a/api/expect.md b/api/expect.md
index 5b474d1e..322862de 100644
--- a/api/expect.md
+++ b/api/expect.md
@@ -41,7 +41,7 @@ expect(input).toBe(2) // jest API
 
 ## assert
 
-- **Type:** `Chai.AssertStatic`
+- **类型:** `Chai.AssertStatic`
 
 Vitest reexports chai's [`assert` API](https://www.chaijs.com/api/assert/) as `expect.assert` for convenience. You can see the supported methods on the [Assert API page](/api/assert).
 
@@ -332,7 +332,7 @@ test('we don\'t have apples', () => {
 
 ## toBeNullable
 
-- **Type:** `() => Awaitable<void>`
+- **类型:** `() => Awaitable<void>`
 
 `toBeNullable` simply asserts if something is nullable (`null` or `undefined`).
 
diff --git a/config/index.md b/config/index.md
index 91a9682c..9acd9040 100644
--- a/config/index.md
+++ b/config/index.md
@@ -139,7 +139,7 @@ export default defineConfig({
 
 ### name
 
-- **Type:** `string | { label: string, color?: LabelColor }`
+- **类型：** `string | { label: string, color?: LabelColor }`
 
 你可以为测试项目或 Vitest 进程指定一个自定义名称，这个名称会在命令行界面（CLI）和用户界面（UI）中显示，同时也能通过 Node.js API 中的 [`project.name`](/advanced/api/test-project#name) 获取。
 
@@ -624,7 +624,7 @@ jsdom 环境变量导出了等同于当前[JSDOM](https://github.com/jsdom/jsdom
 
 ### watchTriggerPatterns <Version>3.2.0</Version><NonProjectOption /> {#watchtriggerpatterns}
 
-- **Type:** `WatcherTriggerPattern[]`
+- **类型：** `WatcherTriggerPattern[]`
 
 Vitest 依据静态与动态 `import` 语句生成的模块图来决定重新执行哪些测试。但若测试读取文件系统或向代理拉取数据，这些依赖便无法被自动探测。
 
@@ -1069,7 +1069,7 @@ globalThis.resetBeforeEachTest = true
 
 ### provide <Version>2.1.0</Version> {#provide}
 
-- **Type:** `Partial<ProvidedContext>`
+- **类型：** `Partial<ProvidedContext>`
 
 使用 `inject` 方法定义可在测试中访问的值。
 
@@ -1509,7 +1509,7 @@ Vitest 会将所有文件，包括那些被 glob 模式覆盖的文件，计入
 
 ##### coverage.thresholds[glob-pattern].100 <Version>2.1.0</Version> {#coverage-thresholds-glob-pattern-100}
 
-- **Type:** `boolean`
+- **类型：** `boolean`
 - **Default:** `false`
 - **Available for providers:** `'v8' | 'istanbul'`
 
@@ -1847,7 +1847,7 @@ npx vitest --sequence.shuffle --sequence.seed=1000
 
 #### groupOrder <Version>3.2.0</Version> {#grouporder}
 
-- **Type:** `number`
+- **类型：** `number`
 - **Default:** `0`
 
 控制使用多个[项目](/guide/projects) 时该项目运行测试的顺序。
@@ -2172,7 +2172,7 @@ export default defineConfig({
 
 ### onUnhandledError<NonProjectOption /> {#onunhandlederror}
 
-- **Type:** `(error: (TestError | Error) & { type: string }) => boolean | void`
+- **类型：** `(error: (TestError | Error) & { type: string }) => boolean | void`
 
 自定义处理程序，用于过滤掉不应报告的未处理错误。 如果过滤掉错误，则不会再影响测试结果。
 
diff --git a/guide/browser/config.md b/guide/browser/config.md
index 6908e527..f5830437 100644
--- a/guide/browser/config.md
+++ b/guide/browser/config.md
@@ -302,7 +302,7 @@ export interface BrowserScript {
 
 ## browser.trace
 
-- **Type:** `'on' | 'off' | 'on-first-retry' | 'on-all-retries' | 'retain-on-failure' | object`
+- **类型：** `'on' | 'off' | 'on-first-retry' | 'on-all-retries' | 'retain-on-failure' | object`
 - **CLI:** `--browser.trace=on`, `--browser.trace=retain-on-failure`
 - **Default:** `'off'`
 
@@ -346,7 +346,7 @@ This option is supported only by the [**playwright**](/guide/browser/playwright)
 
 ## browser.trackUnhandledErrors
 
-- **Type:** `boolean`
+- **类型：** `boolean`
 - **Default:** `true`
 
 启用对未捕获错误和异常的跟踪，以便 Vitest 报告。
@@ -357,7 +357,7 @@ This option is supported only by the [**playwright**](/guide/browser/playwright)
 
 ## browser.expect
 
-- **Type:** `ExpectOptions`
+- **类型：** `ExpectOptions`
 
 ### browser.expect.toMatchScreenshot
 
@@ -395,7 +395,7 @@ export default defineConfig({
 
 #### browser.expect.toMatchScreenshot.resolveScreenshotPath
 
-- **Type:** `(data: PathResolveData) => string`
+- **类型：** `(data: PathResolveData) => string`
 - **Default output:** `` `${root}/${testFileDirectory}/${screenshotDirectory}/${testFileName}/${arg}-${browserName}-${platform}${ext}` ``
 
 一个用于自定义参考截图存储位置的函数。该函数接收一个包含以下属性的对象：
@@ -465,7 +465,7 @@ resolveScreenshotPath: ({ arg, browserName, ext, root, testFileName }) =>
 
 #### browser.expect.toMatchScreenshot.resolveDiffPath
 
-- **Type:** `(data: PathResolveData) => string`
+- **类型：** `(data: PathResolveData) => string`
 - **Default output:** `` `${root}/${attachmentsDir}/${testFileDirectory}/${testFileName}/${arg}-${browserName}-${platform}${ext}` ``
 
 一个用于自定义截图比较失败时差异图像存储位置的函数。它接收与 [`resolveScreenshotPath`](#browser-expect-tomatchscreenshot-resolvescreenshotpath) 相同的数据对象。
diff --git a/guide/browser/locators.md b/guide/browser/locators.md
index 3640effa..7f6699da 100644
--- a/guide/browser/locators.md
+++ b/guide/browser/locators.md
@@ -499,7 +499,7 @@ This methods narrows down the locator according to the options, such as filterin
 
 ### has
 
-- **Type:** `Locator`
+- **类型：** `Locator`
 
 This options narrows down the selector to match elements that contain other elements matching provided locator. For example, with this HTML:
 
@@ -542,7 +542,7 @@ page.getByRole('article')
 
 ### hasNot
 
-- **Type:** `Locator`
+- **类型：** `Locator`
 
 This option narrows down the selector to match elements that do not contain other elements matching provided locator. For example, with this HTML:
 
@@ -570,7 +570,7 @@ Note that provided locator is queried against the parent, not the document root,
 
 ### hasText
 
-- **Type:** `string | RegExp`
+- **类型：** `string | RegExp`
 
 This options narrows down the selector to only match elements that contain provided text somewhere inside. When the `string` is passed, matching is case-insensitive and searches for a substring.
 
@@ -592,7 +592,7 @@ page.getByRole('article').filter({ hasText: 'Vite' }) // ✅
 
 ### hasNotText
 
-- **Type:** `string | RegExp`
+- **类型：** `string | RegExp`
 
 This options narrows down the selector to only match elements that do not contain provided text somewhere inside. When the `string` is passed, matching is case-insensitive and searches for a substring.