kn-es-features 1.0.0

package/src/features/es2015/16-for-of.js

@@ -0,0 +1,75 @@
+import { createSuite } from '../../utils/runner.js'
+
+export function testForOf() {
+  const { test, assert, getResults } = createSuite('for...of 与迭代协议')
+
+  test('for...of 迭代数组', () => {
+    const result = []
+    for (const x of [1, 2, 3]) result.push(x)
+    assert(result.join(',') === '1,2,3', 'for...of 迭代数组')
+  })
+
+  test('for...of 迭代字符串', () => {
+    const chars = []
+    for (const c of 'abc') chars.push(c)
+    assert(chars.join('') === 'abc', 'for...of 迭代字符串')
+  })
+
+  test('for...of 迭代 Set', () => {
+    const result = []
+    for (const x of new Set([1, 2, 3])) result.push(x)
+    assert(result.join(',') === '1,2,3', 'for...of 迭代 Set')
+  })
+
+  test('for...of 迭代 Map', () => {
+    const result = []
+    for (const [k, v] of new Map([['a', 1], ['b', 2]])) {
+      result.push(`${k}=${v}`)
+    }
+    assert(result.join(',') === 'a=1,b=2', 'for...of 迭代 Map')
+  })
+
+  test('for...of 迭代 arguments', () => {
+    function fn() {
+      const result = []
+      for (const x of arguments) result.push(x)
+      return result
+    }
+    assert(fn(1, 2, 3).join(',') === '1,2,3', 'for...of 迭代 arguments')
+  })
+
+  test('for...of 与 break / continue', () => {
+    const result = []
+    for (const x of [1, 2, 3, 4, 5]) {
+      if (x === 3) continue
+      if (x === 5) break
+      result.push(x)
+    }
+    assert(result.join(',') === '1,2,4', 'for...of 支持 break 和 continue')
+  })
+
+  test('for...of 迭代 NodeList（DOM 环境跳过）', () => {
+    // 非 DOM 环境，仅验证迭代协议通用性
+    const iterable = {
+      [Symbol.iterator]() {
+        let n = 0
+        return { next() { return n < 3 ? { value: n++, done: false } : { done: true } } }
+      }
+    }
+    const result = []
+    for (const x of iterable) result.push(x)
+    assert(result.join(',') === '0,1,2', '自定义可迭代对象')
+  })
+
+  test('Array entries / keys / values 迭代', () => {
+    const arr = ['a', 'b', 'c']
+    const entries = [...arr.entries()]
+    const keys = [...arr.keys()]
+    const values = [...arr.values()]
+    assert(entries[1][0] === 1 && entries[1][1] === 'b', 'entries 迭代')
+    assert(keys.join(',') === '0,1,2', 'keys 迭代')
+    assert(values.join(',') === 'a,b,c', 'values 迭代')
+  })
+
+  return getResults()
+}

package/src/features/es2015/17-map.js

@@ -0,0 +1,80 @@
+import { createSuite } from '../../utils/runner.js'
+
+// // Map.prototype.getOrInsert / getOrInsertComputed 是 Stage 4 提案（ES2025）
+// // 旧版浏览器（如 Chrome 40）不支持，注入 polyfill 以演示其行为
+// function ensureGetOrInsert() {
+//   if (!Map.prototype.getOrInsert) {
+//     Map.prototype.getOrInsert = function (key, defaultValue) {
+//       if (!this.has(key)) this.set(key, defaultValue)
+//       return this.get(key)
+//     }
+//   }
+//   if (!Map.prototype.getOrInsertComputed) {
+//     Map.prototype.getOrInsertComputed = function (key, callbackFn) {
+//       if (!this.has(key)) this.set(key, callbackFn(key))
+//       return this.get(key)
+//     }
+//   }
+// }
+
+export function testMapGetOrInsert() {
+  // ensureGetOrInsert()
+
+  const { test, assert, getResults } = createSuite('map getOrInsert')
+
+  test('getOrInsert - key 已存在返回原值', () => {
+    const map = new Map([['bar', 'foo']])
+    const result = map.getOrInsert('bar', 'default')
+    assert(result === 'foo', 'key 已存在应返回原值 foo')
+  })
+
+  test('getOrInsert - key 不存在时插入默认值', () => {
+    const map = new Map()
+    const result = map.getOrInsert('newKey', 42)
+    assert(result === 42, '应返回插入的默认值 42')
+    assert(map.get('newKey') === 42, 'key 已被写入 map')
+  })
+
+  test('getOrInsert - 不覆盖已有值', () => {
+    const map = new Map([['x', 100]])
+    map.getOrInsert('x', 999)
+    assert(map.get('x') === 100, '已有值不应被覆盖')
+  })
+
+  test('getOrInsert - 词频统计经典用法', () => {
+    const words = ['apple', 'banana', 'apple', 'apple', 'banana']
+    const freq = new Map()
+    for (const w of words) {
+      freq.getOrInsert(w, 0)
+      freq.set(w, freq.get(w) + 1)
+    }
+    assert(freq.get('apple') === 3, 'apple 出现 3 次')
+    assert(freq.get('banana') === 2, 'banana 出现 2 次')
+  })
+
+  test('getOrInsertComputed - key 不存在时用回调计算', () => {
+    const map = new Map()
+    const result = map.getOrInsertComputed('user:1', (k) => ({ id: k, score: 0 }))
+    assert(result.id === 'user:1' && result.score === 0, '回调以 key 为参数生成默认值')
+  })
+
+  test('getOrInsertComputed - key 已存在时不调用回调', () => {
+    const map = new Map([['x', 'original']])
+    let called = false
+    const result = map.getOrInsertComputed('x', () => { called = true; return 'new' })
+    assert(!called, 'key 已存在，回调不应被调用')
+    assert(result === 'original', '应返回原有值')
+  })
+
+  test('getOrInsertComputed - 构建邻接表', () => {
+    const edges = [[1, 2], [1, 3], [2, 3]]
+    const graph = new Map()
+    for (const [from, to] of edges) {
+      graph.getOrInsertComputed(from, () => []).push(to)
+    }
+    assert(graph.get(1).join(',') === '2,3', '节点 1 的邻居为 [2,3]')
+    assert(graph.get(2).join(',') === '3', '节点 2 的邻居为 [3]')
+  })
+
+  return getResults()
+}

package/src/features/es2022/01-class-fields.js

@@ -0,0 +1,114 @@
+/**
+ * ES2022 —— Class Fields
+ *
+ * 正式将以下语法纳入规范（ES2022 之前是提案）：
+ *   - 公共实例字段（public instance fields）
+ *   - 私有实例字段（private fields）    #field
+ *   - 私有实例方法（private methods）   #method()
+ *   - 静态公共字段（static fields）
+ *   - 静态私有字段（static private fields）
+ *   - 静态私有方法
+ *   - 私有字段存在性判断（in 操作符）
+ */
+import { createSuite } from '../../utils/runner.js'
+
+export function testClassFields() {
+  const { test, assert, getResults } = createSuite('Class Fields (ES2022)')
+
+  test('公共实例字段 —— 声明并初始化', () => {
+    class Point {
+      x = 0
+      y = 0
+      constructor(x, y) { this.x = x; this.y = y }
+    }
+    const p = new Point(3, 4)
+    assert(p.x === 3 && p.y === 4, '公共字段应可读写')
+  })
+
+  test('公共字段默认值在 constructor 之前初始化', () => {
+    class Counter {
+      count = 10
+      constructor() { this.count += 5 }
+    }
+    assert(new Counter().count === 15, '默认值应先于 constructor 体初始化')
+  })
+
+  test('私有实例字段 #field —— 外部不可访问', () => {
+    class BankAccount {
+      #balance = 0
+      deposit(n) { this.#balance += n }
+      get balance() { return this.#balance }
+    }
+    const acc = new BankAccount()
+    acc.deposit(100)
+    assert(acc.balance === 100, '私有字段应通过访问器正确读取')
+    assert(!('#balance' in acc), '私有字段不应出现在普通属性枚举中')
+
+    let threw = false
+    try { eval('acc.#balance') } catch (e) { threw = true }
+    assert(threw, '外部直接访问私有字段应抛出语法错误')
+  })
+
+  test('私有实例方法 #method()', () => {
+    class Formatter {
+      #prefix = '[LOG]'
+      #wrap(msg) { return `${this.#prefix} ${msg}` }
+      format(msg) { return this.#wrap(msg) }
+    }
+    assert(new Formatter().format('hello') === '[LOG] hello', '私有方法应正常调用')
+  })
+
+  test('静态公共字段', () => {
+    class Config {
+      static version = '1.0.0'
+      static maxRetry = 3
+    }
+    assert(Config.version === '1.0.0', '静态公共字段应可通过类名访问')
+    assert(Config.maxRetry === 3, '静态字段应保持初始值')
+  })
+
+  test('静态私有字段 —— 追踪实例数量', () => {
+    class Registry {
+      static #count = 0
+      constructor() { Registry.#count++ }
+      static getCount() { return Registry.#count }
+    }
+    new Registry(); new Registry(); new Registry()
+    assert(Registry.getCount() === 3, '静态私有字段应跨实例共享')
+  })
+
+  test('静态私有方法', () => {
+    class MathUtils {
+      static #clamp(v, min, max) { return Math.min(Math.max(v, min), max) }
+      static normalize(v) { return MathUtils.#clamp(v, 0, 1) }
+    }
+    assert(MathUtils.normalize(-0.5) === 0, '静态私有方法：低于下界应返回 0')
+    assert(MathUtils.normalize(1.5)  === 1, '静态私有方法：超出上界应返回 1')
+    assert(MathUtils.normalize(0.5)  === 0.5, '静态私有方法：正常值应原样返回')
+  })
+
+  test('私有字段存在性：`#field in obj`', () => {
+    class Node {
+      #value
+      constructor(v) { this.#value = v }
+      static isNode(obj) { return #value in obj }
+    }
+    assert(Node.isNode(new Node(1)) === true,  '实例应包含私有字段')
+    assert(Node.isNode({})          === false, '普通对象不应包含私有字段')
+  })
+
+  test('私有字段不参与继承 —— 子类无法访问父类私有字段', () => {
+    class Animal {
+      #name
+      constructor(name) { this.#name = name }
+      getName() { return this.#name }
+    }
+    class Dog extends Animal {
+      bark() { return `${this.getName()} says woof` }
+    }
+    const d = new Dog('Rex')
+    assert(d.bark() === 'Rex says woof', '子类可通过父类公共方法访问私有字段')
+  })
+
+  return getResults()
+}

package/src/features/es2022/02-class-static-blocks.js

@@ -0,0 +1,108 @@
+/**
+ * ES2022 —— Class Static Initialization Blocks
+ *
+ * `static { ... }` 块在类定义时执行一次，用于：
+ *   - 复杂的静态字段初始化（需要 try/catch、条件判断等）
+ *   - 访问私有字段来初始化外部资源
+ *   - 替代类外部的静态初始化代码
+ *
+ * 执行顺序：父类静态块 → 子类静态块，每个类只执行一次。
+ */
+import { createSuite } from '../../utils/runner.js'
+
+export function testClassStaticBlocks() {
+  const { test, assert, getResults } = createSuite('Class Static Blocks (ES2022)')
+
+  test('基本静态块 —— 初始化静态字段', () => {
+    class AppConfig {
+      static host
+      static port
+      static {
+        AppConfig.host = 'localhost'
+        AppConfig.port = 8080
+      }
+    }
+    assert(AppConfig.host === 'localhost', '静态块应初始化 host')
+    assert(AppConfig.port === 8080,        '静态块应初始化 port')
+  })
+
+  test('静态块中可使用 try/catch 处理初始化失败', () => {
+    class SafeConfig {
+      static value
+      static {
+        try {
+          // 模拟可能失败的操作
+          const raw = '{"timeout":3000}'
+          SafeConfig.value = JSON.parse(raw).timeout
+        } catch {
+          SafeConfig.value = 1000 // 默认值
+        }
+      }
+    }
+    assert(SafeConfig.value === 3000, '静态块中 try/catch 初始化应正确执行')
+  })
+
+  test('静态块访问同类私有字段', () => {
+    // 常见模式：将私有字段的 setter 暴露给类外的受信任代码
+    let setSecret
+    class SecureStore {
+      static #secret = 'initial'
+      static {
+        // 将私有字段的修改能力暴露给模块内部
+        setSecret = (val) => { SecureStore.#secret = val }
+      }
+      static getSecret() { return SecureStore.#secret }
+    }
+    setSecret('updated')
+    assert(SecureStore.getSecret() === 'updated', '静态块应能操作同类私有字段')
+  })
+
+  test('多个静态块按声明顺序执行', () => {
+    const log = []
+    class Sequence {
+      static a
+      static { log.push(1); Sequence.a = 10 }
+      static b
+      static { log.push(2); Sequence.b = Sequence.a * 2 }
+    }
+    assert(log[0] === 1 && log[1] === 2, '多个静态块应按顺序执行')
+    assert(Sequence.b === 20, '第二个静态块应能读取第一个块的结果')
+  })
+
+  test('静态块与静态字段声明交替执行', () => {
+    const order = []
+    class Mixed {
+      static x = (order.push('field-x'), 1)
+      static { order.push('block-1') }
+      static y = (order.push('field-y'), 2)
+      static { order.push('block-2') }
+    }
+    assert(order.join(',') === 'field-x,block-1,field-y,block-2', '字段与静态块应按声明顺序交替初始化')
+    assert(Mixed.x === 1 && Mixed.y === 2, '所有字段应正确赋值')
+  })
+
+  test('子类静态块在父类之后执行', () => {
+    const order = []
+    class Base {
+      static { order.push('base') }
+    }
+    class Child extends Base {
+      static { order.push('child') }
+    }
+    assert(order[0] === 'base' && order[1] === 'child', '父类静态块应先于子类执行')
+  })
+
+  test('静态块中 this 指向类本身', () => {
+    class Widget {
+      static name2 = 'Widget'
+      static instance
+      static {
+        // this 指向 Widget 类
+        this.instance = { type: this.name2 }
+      }
+    }
+    assert(Widget.instance.type === 'Widget', '静态块内 this 应指向类本身')
+  })
+
+  return getResults()
+}

package/src/features/es2022/03-at-method.js

@@ -0,0 +1,86 @@
+/**
+ * ES2022 —— Array.prototype.at() / String.prototype.at()
+ *         TypedArray.prototype.at()
+ *
+ * .at(index) 支持负索引，解决了 arr[arr.length - 1] 这种冗长写法：
+ *   arr.at(0)   → 第一个元素
+ *   arr.at(-1)  → 最后一个元素（等价于 arr[arr.length - 1]）
+ *   arr.at(-2)  → 倒数第二个元素
+ *
+ * 同样适用于 String、TypedArray（Int8Array、Uint8Array 等）。
+ */
+import { createSuite } from '../../utils/runner.js'
+
+export function testAtMethod() {
+  const { test, assert, getResults } = createSuite('Array/String.at() (ES2022)')
+
+  // ── Array.prototype.at ─────────────────────────────────────────────
+
+  test('Array.at() —— 正索引与 arr[i] 等价', () => {
+    const arr = [10, 20, 30, 40, 50]
+    assert(arr.at(0) === 10, 'at(0) 应返回第一个元素')
+    assert(arr.at(2) === 30, 'at(2) 应返回第三个元素')
+    assert(arr.at(4) === 50, 'at(4) 应返回最后一个元素')
+  })
+
+  test('Array.at() —— 负索引从末尾倒数', () => {
+    const arr = [10, 20, 30, 40, 50]
+    assert(arr.at(-1) === 50, 'at(-1) 应返回最后一个元素')
+    assert(arr.at(-2) === 40, 'at(-2) 应返回倒数第二个元素')
+    assert(arr.at(-5) === 10, 'at(-5) 应返回第一个元素')
+  })
+
+  test('Array.at() —— 越界返回 undefined', () => {
+    const arr = [1, 2, 3]
+    assert(arr.at(5)  === undefined, '正向越界应返回 undefined')
+    assert(arr.at(-4) === undefined, '负向越界应返回 undefined')
+  })
+
+  test('Array.at() —— 空数组始终返回 undefined', () => {
+    assert([].at(0) === undefined,  '空数组 at(0) 应返回 undefined')
+    assert([].at(-1) === undefined, '空数组 at(-1) 应返回 undefined')
+  })
+
+  test('对比旧写法：arr.at(-1) vs arr[arr.length - 1]', () => {
+    const data = [3, 1, 4, 1, 5, 9, 2, 6]
+    const last  = data.at(-1)
+    const last2 = data[data.length - 1]
+    assert(last === last2, 'at(-1) 应与 arr[length-1] 等价')
+  })
+
+  // ── String.prototype.at ────────────────────────────────────────────
+
+  test('String.at() —— 正索引', () => {
+    const s = 'hello'
+    assert(s.at(0) === 'h', 'at(0) 应返回首字符')
+    assert(s.at(4) === 'o', 'at(4) 应返回末字符')
+  })
+
+  test('String.at() —— 负索引', () => {
+    const s = 'hello'
+    assert(s.at(-1) === 'o', 'at(-1) 应返回最后一个字符')
+    assert(s.at(-3) === 'l', 'at(-3) 应返回倒数第三个字符')
+  })
+
+  test('String.at() —— 越界返回 undefined', () => {
+    assert('abc'.at(10)  === undefined, '正向越界应返回 undefined')
+    assert('abc'.at(-10) === undefined, '负向越界应返回 undefined')
+  })
+
+  // ── TypedArray.prototype.at ────────────────────────────────────────
+
+  test('TypedArray.at() —— 支持负索引', () => {
+    const ta = new Int32Array([100, 200, 300, 400])
+    assert(ta.at(0)  === 100, 'TypedArray.at(0) 应返回第一个元素')
+    assert(ta.at(-1) === 400, 'TypedArray.at(-1) 应返回最后一个元素')
+    assert(ta.at(-2) === 300, 'TypedArray.at(-2) 应返回倒数第二个元素')
+  })
+
+  test('at() 不修改原数组', () => {
+    const arr = [1, 2, 3]
+    arr.at(-1)
+    assert(arr.length === 3 && arr[2] === 3, 'at() 不应修改原数组')
+  })
+
+  return getResults()
+}

package/src/features/es2022/04-object-has-own.js

@@ -0,0 +1,82 @@
+/**
+ * ES2022 —— Object.hasOwn()
+ *
+ * Object.hasOwn(obj, key) 是 Object.prototype.hasOwnProperty.call(obj, key) 的简洁替代。
+ *
+ * 为什么需要它？
+ *   1. Object.create(null) 创建的对象没有原型链，调用 .hasOwnProperty() 会报错
+ *   2. 对象可能覆盖了自身的 hasOwnProperty 方法，导致判断不可靠
+ *   3. Object.hasOwn 基于规范内部操作，始终安全可靠
+ */
+import { createSuite } from '../../utils/runner.js'
+
+export function testObjectHasOwn() {
+  const { test, assert, getResults } = createSuite('Object.hasOwn() (ES2022)')
+
+  test('基本用法 —— 自有属性返回 true', () => {
+    const obj = { name: 'Alice', age: 30 }
+    assert(Object.hasOwn(obj, 'name') === true,  'name 是自有属性，应返回 true')
+    assert(Object.hasOwn(obj, 'age')  === true,  'age 是自有属性，应返回 true')
+  })
+
+  test('不存在的属性返回 false', () => {
+    const obj = { a: 1 }
+    assert(Object.hasOwn(obj, 'b')    === false, '不存在的属性应返回 false')
+    assert(Object.hasOwn(obj, 'toString') === false, '原型链上的属性应返回 false')
+  })
+
+  test('继承属性返回 false —— 只检查自有属性', () => {
+    class Animal { constructor(name) { this.name = name } }
+    class Dog extends Animal {}
+    const d = new Dog('Rex')
+    assert(Object.hasOwn(d, 'name')       === true,  'name 是实例自有属性')
+    assert(Object.hasOwn(d, 'constructor') === false, 'constructor 在原型上，不是自有属性')
+  })
+
+  test('null 原型对象 —— hasOwnProperty 不可用时的安全方案', () => {
+    // Object.create(null) 的对象没有 hasOwnProperty 方法
+    const dict = Object.create(null)
+    dict.key = 'value'
+
+    let threw = false
+    try { dict.hasOwnProperty('key') } catch (e) { threw = true }
+    assert(threw, 'null 原型对象调用 hasOwnProperty 应抛出错误')
+
+    // Object.hasOwn 不依赖原型链，安全可用
+    assert(Object.hasOwn(dict, 'key')    === true,  'hasOwn 对 null 原型对象应正常工作')
+    assert(Object.hasOwn(dict, 'other')  === false, '不存在的键应返回 false')
+  })
+
+  test('对象覆盖 hasOwnProperty —— hasOwn 不受影响', () => {
+    const malicious = {
+      hasOwnProperty() { return false }, // 伪造返回值
+      secret: 42
+    }
+    // 旧方式被欺骗
+    assert(malicious.hasOwnProperty('secret') === false, '被覆盖的 hasOwnProperty 返回错误结果')
+    // Object.hasOwn 不调用实例方法，始终可靠
+    assert(Object.hasOwn(malicious, 'secret') === true,  'hasOwn 不受覆盖影响，结果正确')
+  })
+
+  test('值为 undefined 的属性仍返回 true', () => {
+    const obj = { key: undefined }
+    assert(Object.hasOwn(obj, 'key') === true, '值为 undefined 的自有属性应返回 true')
+  })
+
+  test('Symbol 作为键', () => {
+    const sym = Symbol('id')
+    const obj = { [sym]: 123 }
+    assert(Object.hasOwn(obj, sym)        === true,  'Symbol 键的自有属性应返回 true')
+    assert(Object.hasOwn(obj, Symbol('id')) === false, '不同的 Symbol 实例应返回 false')
+  })
+
+  test('数组的索引属性', () => {
+    const arr = [10, 20, 30]
+    assert(Object.hasOwn(arr, 0)       === true,  '数组索引 0 是自有属性')
+    assert(Object.hasOwn(arr, '1')     === true,  '字符串索引 "1" 也是自有属性')
+    assert(Object.hasOwn(arr, 'length') === true, 'length 是数组的自有属性')
+    assert(Object.hasOwn(arr, 3)        === false, '越界索引应返回 false')
+  })
+
+  return getResults()
+}

package/src/features/es2022/05-error-cause.js

@@ -0,0 +1,92 @@
+/**
+ * ES2022 —— Error Cause
+ *
+ * Error 构造函数接受第二个参数 options，其中 cause 属性用于链式传递原始错误：
+ *   new Error('高层描述', { cause: originalError })
+ *
+ * 所有内置 Error 子类（TypeError、RangeError 等）同样支持。
+ * 主要用途：在错误封装时保留根因，方便调试和日志溯源。
+ */
+import { createSuite } from '../../utils/runner.js'
+
+export function testErrorCause() {
+  const { test, assert, getResults } = createSuite('Error Cause (ES2022)')
+
+  test('基本用法 —— cause 属性保存原始错误', () => {
+    const original = new TypeError('原始类型错误')
+    const wrapped  = new Error('操作失败', { cause: original })
+    assert(wrapped.message === '操作失败', '外层错误消息应正确')
+    assert(wrapped.cause === original,    'cause 应指向原始错误')
+    assert(wrapped.cause instanceof TypeError, 'cause 类型应保留')
+  })
+
+  test('所有内置子类均支持 cause', () => {
+    const root = new Error('根因')
+    const types = [
+      new TypeError('类型错误',   { cause: root }),
+      new RangeError('范围错误',  { cause: root }),
+      new SyntaxError('语法错误', { cause: root }),
+    ]
+    types.forEach(e => {
+      assert(e.cause === root, `${e.constructor.name} 的 cause 应指向根因`)
+    })
+  })
+
+  test('错误链可以多层嵌套', () => {
+    const level1 = new Error('数据库连接失败')
+    const level2 = new Error('查询用户失败',   { cause: level1 })
+    const level3 = new Error('登录接口报错',   { cause: level2 })
+
+    assert(level3.cause === level2,        '第三层 cause 应指向第二层')
+    assert(level3.cause.cause === level1,  '第二层 cause 应指向第一层')
+    assert(level3.cause.cause.message === '数据库连接失败', '根因消息应可追溯')
+  })
+
+  test('不传 cause 时属性为 undefined', () => {
+    const e = new Error('普通错误')
+    assert(e.cause === undefined, '未传 cause 时属性应为 undefined')
+  })
+
+  test('cause 可以是任意值（不限于 Error）', () => {
+    const e1 = new Error('原因是字符串', { cause: '网络超时' })
+    const e2 = new Error('原因是数字',   { cause: 404 })
+    const e3 = new Error('原因是对象',   { cause: { code: 'ENOENT' } })
+    assert(e1.cause === '网络超时',      'cause 可以是字符串')
+    assert(e2.cause === 404,             'cause 可以是数字')
+    assert(e3.cause.code === 'ENOENT',   'cause 可以是对象')
+  })
+
+  test('实际应用：fetch 封装中传递原始网络错误', async () => {
+    async function fetchUser(id) {
+      try {
+        // 模拟请求失败
+        throw new Error('fetch failed: 500')
+      } catch (networkErr) {
+        throw new Error(`获取用户 ${id} 失败`, { cause: networkErr })
+      }
+    }
+
+    let caught = null
+    try { await fetchUser(42) } catch (e) { caught = e }
+
+    assert(caught !== null,                       '应捕获到封装后的错误')
+    assert(caught.message.includes('42'),         '外层错误消息应包含用户 id')
+    assert(caught.cause instanceof Error,         'cause 应是原始 Error')
+    assert(caught.cause.message.includes('500'),  '原始错误消息应保留')
+  })
+
+  test('自定义 Error 子类也支持 cause', () => {
+    class AppError extends Error {
+      constructor(msg, options) {
+        super(msg, options)
+        this.name = 'AppError'
+      }
+    }
+    const root = new TypeError('底层失败')
+    const e    = new AppError('应用层失败', { cause: root })
+    assert(e.name === 'AppError',        '子类名称应正确')
+    assert(e.cause === root,             '自定义子类应支持 cause')
+  })
+
+  return getResults()
+}