wsemi 1.9.21 → 1.9.22

package/test/flattenToConn.test.mjs

@@ -2,6 +2,89 @@ import assert from 'assert'
 import flattenToConn from '../src/flattenToConn.mjs'
 
 
+describe(`flattenToConn 偽稱Array之物件視為物件(R-OBJ-ITER-01 候選10)`, function() {
+
+    //以Symbol.toStringTag偽稱'Array'之物件(isarr為真而非真陣列), 可寫與不可寫兩種標籤
+    let mkFake = (len, writable) => {
+        let o = { a: 'kept', length: len }
+        if (writable) {
+            o[Symbol.toStringTag] = 'Array'
+        }
+        else {
+            Object.defineProperty(o, Symbol.toStringTag, { value: 'Array' })
+        }
+        return o
+    }
+
+    //flattenToConn以force走訪, 含Symbol鍵(treeObj取自有屬性名稱與自有Symbol), 偽標籤本身之Symbol鍵亦成一節點; 此處只比對字串鍵之節點
+    let strNodes = (r) => r.filter((v) => !/Symbol\(/.test(String(v.id)))
+
+    for (let writable of [true, false]) {
+        let tag = writable ? 'writable' : 'non-writable'
+
+        it(`should give the same nodes for a nested object faking Array (${tag} tag, length 2) as for the plain object with the same keys`, function() {
+            let r = strNodes(flattenToConn({ child: mkFake(2, writable) }))
+            let e = flattenToConn({ child: { a: 'kept', length: 2 } })
+            assert.strict.deepStrictEqual(r, e)
+            assert.strict.strictEqual(r[0].type, 'object')
+            assert.strict.strictEqual(r[0].numOfChilren, 2)
+            assert.strict.deepStrictEqual(r.map((v) => v.id), ['child', 'child-a', 'child-length'])
+        })
+
+        it(`should give the same nodes for a nested object faking Array (${tag} tag, length 0) as for the plain object with the same keys`, function() {
+            let r = strNodes(flattenToConn({ child: mkFake(0, writable) }))
+            let e = flattenToConn({ child: { a: 'kept', length: 0 } })
+            assert.strict.deepStrictEqual(r, e)
+            assert.strict.strictEqual(r[0].type, 'object')
+        })
+
+        it(`should give the same nodes for an object faking Array (${tag} tag, length 2) at the root as for the plain object with the same keys`, function() {
+            let r = strNodes(flattenToConn(mkFake(2, writable)))
+            let e = flattenToConn({ a: 'kept', length: 2 })
+            assert.strict.deepStrictEqual(r, e)
+            assert.strict.deepStrictEqual(r.map((v) => v.id), ['a', 'length'])
+        })
+    }
+
+    for (let writable of [true, false]) {
+        for (let len of [0, 2, 1000]) {
+            it(`should count the string keys as the children of an object faking Array (${writable ? 'writable' : 'non-writable'} tag, length ${len}), not the length value`, function() {
+                //R-OBJ-ITER-01: length為一般鍵, numOfChilren為自有鍵數(a與length共2), 與length之值無關
+                let o = { a: 'kept', length: len }
+                if (writable) {
+                    o[Symbol.toStringTag] = 'Array'
+                }
+                else {
+                    Object.defineProperty(o, Symbol.toStringTag, { value: 'Array' })
+                }
+                let r = flattenToConn({ child: o })
+                assert.strict.strictEqual(r[0].id, 'child')
+                assert.strict.strictEqual(r[0].type, 'object')
+                assert.strict.strictEqual(r[0].numOfChilren, 2)
+            })
+        }
+    }
+
+    for (let tag of ['Foo', 'Object', 'Arguments']) {
+        it(`should give array nodes for a real array with another Symbol.toStringTag (${tag}), like an ordinary array`, function() {
+            let a = Object.defineProperty([1, 2], Symbol.toStringTag, { value: tag })
+            let r = flattenToConn({ list: a })
+            let e = flattenToConn({ list: [1, 2] })
+            assert.strict.deepStrictEqual(r, e)
+            assert.strict.strictEqual(r[0].type, 'array')
+            assert.strict.deepStrictEqual(r.map((v) => v.id), ['list', 'list-0', 'list-1'])
+        })
+    }
+
+    it(`should still give array nodes for real arrays`, function() {
+        let r = flattenToConn({ list: [1, [2]] })
+        assert.strict.strictEqual(r[0].type, 'array')
+        assert.strict.strictEqual(r[0].numOfChilren, 2)
+        assert.strict.strictEqual(r.find((v) => v.id === 'list-1').type, 'array')
+    })
+
+})
+
 describe(`flattenToConn`, function() {
 
     let obj = {

package/test/flattenTree.test.mjs

@@ -2,6 +2,55 @@ import assert from 'assert'
 import flattenTree from '../src/flattenTree.mjs'
 
 
+describe(`flattenTree 偽稱Array之根節點視為物件(R-OBJ-ITER-01 候選10)`, function() {
+
+    //以Symbol.toStringTag偽稱'Array'之根節點(isarr為真而非真陣列): 結果須同無標籤之相同鍵物件(標籤不可寫者不展開進節點)
+    let mkFake = (writable, len = 2) => {
+        let o = { id: 1, length: len, children: [{ id: 2, data: 'x' }] }
+        if (writable) {
+            o[Symbol.toStringTag] = 'Array'
+        }
+        else {
+            Object.defineProperty(o, Symbol.toStringTag, { value: 'Array' })
+        }
+        return o
+    }
+
+    for (let writable of [true, false]) {
+        let tag = writable ? 'writable' : 'non-writable'
+        for (let len of [2, 0]) {
+            it(`should flatten a root object faking Array (${tag} tag, length ${len}) like the plain object with the same keys`, function() {
+                //根為物件時回傳根節點本身(含level與nk); length為0時不得被當成空陣列而回傳[]
+                let pick = (n) => ({ id: n.id, length: n.length, level: n.level, nk: n.nk, children: n.children })
+                let r = flattenTree(mkFake(writable, len))
+                let e = flattenTree({ id: 1, length: len, children: [{ id: 2, data: 'x' }] })
+                assert.strict.deepStrictEqual(pick(r), pick(e))
+                assert.strict.deepStrictEqual(pick(e), { id: 1, length: len, level: 0, nk: [0], children: [{ id: 2, data: 'x' }] })
+            })
+        }
+    }
+
+    for (let tag of ['Foo', 'Object']) {
+        it(`should flatten a real array root with another Symbol.toStringTag (${tag}) like an ordinary array`, function() {
+            let a = Object.defineProperty([{ id: 1, children: [{ id: 2 }] }], Symbol.toStringTag, { value: tag })
+            assert.strict.deepStrictEqual(flattenTree(a).map((v) => v.id), [1, 2])
+        })
+    }
+
+    it(`should return [] for an object faking Array without own string keys, like an empty object`, function() {
+        assert.strict.deepStrictEqual(flattenTree({ [Symbol.toStringTag]: 'Array' }), [])
+        assert.strict.deepStrictEqual(flattenTree(Object.defineProperty({}, Symbol.toStringTag, { value: 'Array' })), [])
+        assert.strict.deepStrictEqual(flattenTree({}), [])
+    })
+
+    it(`should still flatten a real array root and return [] for empty array and empty object`, function() {
+        assert.strict.deepStrictEqual(flattenTree([{ id: 1, children: [{ id: 2 }] }]).map((v) => v.id), [1, 2])
+        assert.strict.deepStrictEqual(flattenTree([]), [])
+        assert.strict.deepStrictEqual(flattenTree({}), [])
+    })
+
+})
+
 describe(`flattenTree`, function() {
 
     let obj = {

package/test/fsTask.test.mjs

@@ -3,8 +3,152 @@ import assert from 'assert'
 import fsDeleteFile from '../src/fsDeleteFile.mjs'
 import fsCreateFolder from '../src/fsCreateFolder.mjs'
 import fsDeleteFolder from '../src/fsDeleteFolder.mjs'
+import { fileURLToPath } from 'url'
+import { dirname, join } from 'path'
 import fsTask from '../src/fsTask.mjs'
 
+let __dirname = dirname(fileURLToPath(import.meta.url))
+
+
+describe(`fsTask 檔案來源之紀錄須為一般物件(R-OBJ-ITER-01 候選9)`, function() {
+
+    //fpHash.json、fpResult.json 讀自檔案(可能被竄改或損毀), 須視為一般物件之字典: length 為一般鍵, 非一般物件者視為無紀錄
+    let root = join(__dirname, '_tmp', 'fsTaskRecord')
+    let wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+    let item = (p) => [{ type: 'file', path: p }]
+
+    //測試自建自刪(只刪本案資料夾, 不刪 test/_tmp 根目錄)
+    after(function() {
+        fs.rmSync(root, { recursive: true, force: true })
+        assert.strict.strictEqual(fs.existsSync(root), false)
+    })
+
+    //mk, 建立案例資料夾: watch 為監看夾(可預放檔案), _tkfs 為儲存夾(可預寫紀錄檔原文)
+    let mk = (name, { hash = null, result = null, files = {} } = {}) => {
+        let base = join(root, name)
+        fs.rmSync(base, { recursive: true, force: true })
+        let fd = join(base, 'watch')
+        let st = join(base, '_tkfs')
+        fs.mkdirSync(fd, { recursive: true })
+        fs.mkdirSync(st, { recursive: true })
+        for (let [fn, c] of Object.entries(files)) {
+            fs.writeFileSync(join(fd, fn), c, 'utf8')
+        }
+        if (hash !== null) {
+            fs.writeFileSync(join(st, 'fpHash.json'), hash, 'utf8')
+        }
+        if (result !== null) {
+            fs.writeFileSync(join(st, 'fpResult.json'), result, 'utf8')
+        }
+        return { fd, st }
+    }
+
+    //watch, 以 40 ms 輪詢 ms 毫秒, 收集 change 事件並立即 resolve 其 pm
+    let watch = async (c, ms = 400) => {
+        let events = []
+        let ev = fsTask(c.fd, { fdStorage: c.st, timeInterval: 40 })
+        ev.on('change', (msg) => {
+            events.push({ type: msg.type, fp: msg.fp, fn: msg.fn, hash: msg.hash })
+            msg.pm.resolve()
+        })
+        try {
+            await wait(ms)
+        }
+        finally {
+            ev.clear()
+        }
+        return events
+    }
+
+    let readJson = (c, fn) => JSON.parse(fs.readFileSync(join(c.st, fn), 'utf8'))
+    let sortBy = (arr) => [...arr].sort((a, b) => (a.fp < b.fp ? -1 : 1))
+
+    it(`should treat a length key of fpHash.json as an ordinary path: one del event per recorded key and none repeated`, async function() {
+        //修前: 整個字典依 length 當類陣列迭代, 每個輪詢週期重複派發 { type: 'del', fp: '0', fn: '0', hash: '' }
+        let c = mk('hash-length', { hash: '{"length":1,"a":"h"}' })
+        let events = await watch(c, 500)
+        assert.strict.deepStrictEqual(sortBy(events), [
+            { type: 'del', fp: 'a', fn: 'a', hash: 'h' },
+            { type: 'del', fp: 'length', fn: 'length', hash: 1 },
+        ])
+        assert.strict.deepStrictEqual(readJson(c, 'fpHash.json'), {})
+    })
+
+    it(`should dispatch one del event for a recorded path and update the record (control without length)`, async function() {
+        let c = mk('hash-control', { hash: '{"a":"h"}' })
+        let events = await watch(c, 400)
+        assert.strict.deepStrictEqual(events, [{ type: 'del', fp: 'a', fn: 'a', hash: 'h' }])
+        assert.strict.deepStrictEqual(readJson(c, 'fpHash.json'), {})
+    })
+
+    it(`should dispatch add once for a watched file named length`, async function() {
+        let c = mk('hash-file-length', { files: { length: 'abc' } })
+        let events = await watch(c, 400)
+        assert.strict.deepStrictEqual(events.map((v) => [v.type, v.fn]), [['add', 'length']])
+        assert.strict.deepStrictEqual(Object.keys(readJson(c, 'fpHash.json')), [events[0].fp])
+    })
+
+    let notObjs = ['["a","b"]', '"abc"', '123', 'null', 'true', '{bad', '']
+    for (let content of notObjs) {
+        it(`should treat fpHash.json as no record when it is not a plain object (${JSON.stringify(content)}): no event for an empty folder`, async function() {
+            let c = mk('hash-notobj', { hash: content })
+            let events = await watch(c, 300)
+            assert.strict.deepStrictEqual(events, [])
+        })
+
+        it(`should dispatch add once for a new file and record it when fpHash.json is not a plain object (${JSON.stringify(content)})`, async function() {
+            let c = mk('hash-notobj-file', { hash: content, files: { 'f.txt': 'abc' } })
+            let events = await watch(c, 400)
+            assert.strict.deepStrictEqual(events.map((v) => [v.type, v.fn]), [['add', 'f.txt']])
+            assert.strict.deepStrictEqual(Object.keys(readJson(c, 'fpHash.json')), [events[0].fp])
+        })
+    }
+
+    it(`should keep other results and the length key when fpResult.json has a length key and a result is taken`, function() {
+        //修前: each 依 length 當類陣列迭代, 其他結果全被清空, 檔案寫成 {}
+        let c = mk('result-length', { result: JSON.stringify({ 'length': 0, 'a|h': item('x'), 'b|h': item('y') }) })
+        let ev = fsTask(c.fd, { fdStorage: c.st, timeInterval: 100000 })
+        try {
+            assert.strict.deepStrictEqual(ev.getAndEliminateResult('a', 'h'), item('x'))
+        }
+        finally {
+            ev.clear()
+        }
+        assert.strict.deepStrictEqual(readJson(c, 'fpResult.json'), { 'length': 0, 'b|h': item('y') })
+    })
+
+    it(`should keep other results when a result is taken (control without length)`, function() {
+        let c = mk('result-control', { result: JSON.stringify({ 'a|h': item('x'), 'b|h': item('y') }) })
+        let ev = fsTask(c.fd, { fdStorage: c.st, timeInterval: 100000 })
+        try {
+            assert.strict.deepStrictEqual(ev.getAndEliminateResult('a', 'h'), item('x'))
+        }
+        finally {
+            ev.clear()
+        }
+        assert.strict.deepStrictEqual(readJson(c, 'fpResult.json'), { 'b|h': item('y') })
+    })
+
+    for (let content of notObjs) {
+        it(`should treat fpResult.json as no record when it is not a plain object (${JSON.stringify(content)}): setResult does not throw and results can be taken`, function() {
+            //修前: 字串/數字/null/布林使 setResult 拋 TypeError, 字串被展開寫成 {"0":"a",...}
+            let c = mk('result-notobj', { result: content })
+            let ev = fsTask(c.fd, { fdStorage: c.st, timeInterval: 100000 })
+            try {
+                assert.strict.deepStrictEqual(ev.getAndEliminateResult('x', 'y'), [])
+                assert.strict.deepStrictEqual(readJson(c, 'fpResult.json'), {})
+                ev.setResult('f', 'h', item('p'))
+                assert.strict.deepStrictEqual(readJson(c, 'fpResult.json'), { 'f|h': item('p') })
+                assert.strict.deepStrictEqual(ev.getAndEliminateResult('f', 'h'), item('p'))
+                assert.strict.deepStrictEqual(readJson(c, 'fpResult.json'), {})
+            }
+            finally {
+                ev.clear()
+            }
+        })
+    }
+
+})
 
 describe(`fsTask`, function() {
 

package/test/getltdtkeys.test.mjs

@@ -2,6 +2,77 @@ import assert from 'assert'
 import getltdtkeys from '../src/getltdtkeys.mjs'
 
 
+describe(`getltdtkeys 列物件只依自有鍵(R-OBJ-ITER-01 候選11)`, function() {
+
+    it(`should return the own keys of a row that fakes Arguments with a non-writable Symbol.toStringTag`, function() {
+        //lodash keys 對不可寫偽稱 Arguments 之物件走 baseTimes(length), 修前得 ['0','1','a']
+        let row = Object.defineProperty({ a: 1, length: 2 }, Symbol.toStringTag, { value: 'Arguments' })
+        assert.strict.deepStrictEqual(getltdtkeys([row]), ['a', 'length'])
+        assert.strict.deepStrictEqual(getltdtkeys([{ x: 1 }, row, { y: 2 }]), ['x', 'a', 'length', 'y'])
+    })
+
+    it(`should return the own keys of a row that fakes Array or Arguments with a writable tag`, function() {
+        assert.strict.deepStrictEqual(getltdtkeys([{ a: 1, length: 2, [Symbol.toStringTag]: 'Arguments' }]), ['a', 'length'])
+        assert.strict.deepStrictEqual(getltdtkeys([{ a: 1, length: 2, [Symbol.toStringTag]: 'Array' }]), ['a', 'length'])
+    })
+
+    it(`should treat length as an ordinary key of a row (any non-negative integer, small values)`, function() {
+        assert.strict.deepStrictEqual(getltdtkeys([{ length: 2, a: 'x' }]), ['length', 'a'])
+        assert.strict.deepStrictEqual(getltdtkeys([{ length: 0, a: 'x' }, { length: 1000, b: 'y' }]), ['length', 'a', 'b'])
+        assert.strict.deepStrictEqual(getltdtkeys([{ a: 1, length: -0 }]), ['a', 'length'])
+    })
+
+    it(`should keep the behavior for rows that are arrays (including holes), strings, typed arrays, null and primitives`, function() {
+        //列為真陣列者沿用 lodash keys: 含空洞索引(Object.keys 不含)
+        assert.strict.deepStrictEqual(getltdtkeys([[1, 2]]), ['0', '1'])
+        assert.strict.deepStrictEqual(getltdtkeys([[, 1]]), ['0', '1']) // eslint-disable-line no-sparse-arrays
+        assert.strict.deepStrictEqual(getltdtkeys([new Uint8Array(2)]), ['0', '1'])
+        assert.strict.deepStrictEqual(getltdtkeys([null, undefined, 5, true, 'ab', { a: 1 }]), ['0', '1', 'a'])
+        assert.strict.deepStrictEqual(getltdtkeys([new Map([['k', 1]]), new Date(0), /a/, () => 1]), [])
+    })
+
+    it(`should return the own enumerable string keys of class instances, null-prototype rows and rows with inherited keys`, function() {
+        class Foo {
+            constructor() {
+                this.a = 1
+            }
+        }
+        let np = Object.create(null)
+        np.n = 1
+        let inh = Object.create({ p: 1 })
+        inh.q = 2
+        assert.strict.deepStrictEqual(getltdtkeys([new Foo(), np, inh]), ['a', 'n', 'q'])
+    })
+
+    it(`should return the same keys as the lodash keys on 500 random rows without length keys`, function() {
+        let seed = 20261020
+        let rnd = () => {
+            seed = (seed * 1103515245 + 12345) % 2147483648
+            return seed / 2147483648
+        }
+        let names = ['a', 'b', 'c', '0', '1', '10', 'constructor', 'toString', 'x y', '中文']
+        let rows = []
+        for (let i = 0; i < 500; i++) {
+            let o = {}
+            let n = Math.floor(rnd() * 5)
+            for (let j = 0; j < n; j++) {
+                o[names[Math.floor(rnd() * names.length)]] = j
+            }
+            rows.push(o)
+        }
+        let expected = []
+        for (let o of rows) {
+            for (let k of Object.keys(o)) {
+                if (!expected.includes(k)) {
+                    expected.push(k)
+                }
+            }
+        }
+        assert.strict.deepStrictEqual(getltdtkeys(rows), expected)
+    })
+
+})
+
 describe(`getltdtkeys`, function() {
     let k
     let o = {}

package/test/tools/clearXssWalkRunner.mjs

@@ -0,0 +1,202 @@
+//clearXssWalkRunner.mjs: 於限額子行程執行 clearXSS 之走訪案例(R-XSS-WALK-01): 極深巢狀、大型共用結構(DAG)、大型循環
+//  修前之實作對深巢狀同步拋 RangeError(未捕捉, 離開碼非 0)、對 DAG 依路徑數指數重走(2^n, 逾時被終止)
+//  約定同runChildCase: node [--max-old-space-size=N] clearXssWalkRunner.mjs <caseName>, 結果以一行'@@R@@'開頭之JSON輸出至stdout
+//  caseName:
+//    'deep:<obj|arr|mixed|map|set>:<層數>': 迭代建構之深巢狀(葉為字串)
+//    'dag:<obj|arr|map|set|mixed>:<層數>': 每層兩個參照指向同一子結構, 葉為字串; 計 filterXSS 呼叫數
+//    'cycle:<長度>': 長度為n之物件環(最後一個指回第一個), 每個節點帶一個字串
+import clearXSS from '../../src/clearXSS.mjs'
+import fxss from '../../src/_filterXSS.mjs'
+
+
+let x = '<script>alert(1)</script>'
+let fx = '&lt;script>alert(1)&lt;/script>'
+
+//計 filterXSS 呼叫數(fxss為可變單例, clearXSS每次呼叫經fxss.getFilterXSS取得)
+let calls = 0
+let origGet = fxss.getFilterXSS
+fxss.getFilterXSS = () => {
+    let f = origGet()
+    let w = (c, o) => {
+        calls++
+        return f(c, o)
+    }
+    w.escapeAttrValue = f.escapeAttrValue
+    return w
+}
+
+let caseName = process.argv[2] || ''
+let [kind, sub, sn] = caseName.split(':')
+let n = Number(kind === 'cycle' ? sub : sn)
+
+//wrap, 依種類包一層
+let wrap = (kind2, i, cur) => {
+    if (kind2 === 'obj') {
+        return { a: cur }
+    }
+    if (kind2 === 'arr') {
+        return [cur]
+    }
+    if (kind2 === 'map') {
+        return new Map([['k', cur]])
+    }
+    if (kind2 === 'set') {
+        return new Set([cur])
+    }
+    return (i % 2 === 0) ? { a: cur } : [cur] //mixed
+}
+
+//child, 取子節點(迭代取葉用)
+let child = (v) => {
+    if (Array.isArray(v)) {
+        return v[0]
+    }
+    if (v instanceof Map) {
+        return v.get('k')
+    }
+    if (v instanceof Set) {
+        return [...v][0]
+    }
+    return v.a
+}
+
+//leaf, 迭代取葉並回傳深度
+let leafOf = (v) => {
+    let d = 0
+    while (typeof v === 'object' && v !== null) {
+        v = child(v)
+        d++
+    }
+    return { v, d }
+}
+
+let out = { kind, sub, n }
+clearXSS({ b: x }) //先載入js-xss
+if (global.gc) {
+    global.gc()
+}
+
+if (kind === 'deep') {
+    let inp = x
+    for (let i = 0; i < n; i++) {
+        inp = wrap(sub, i, inp)
+    }
+    let h0 = process.memoryUsage().heapUsed
+    calls = 0
+    let t0 = process.hrtime.bigint()
+    let r = clearXSS(inp)
+    out.ms = Number(process.hrtime.bigint() - t0) / 1e6
+    out.heapMB = (process.memoryUsage().heapUsed - h0) / 1048576
+    let lo = leafOf(r)
+    let li = leafOf(inp)
+    out.leafCleaned = lo.v === fx
+    out.inputIntact = li.v === x
+    out.depthOut = lo.d
+    out.depthIn = li.d
+    out.notSame = r !== inp
+    out.calls = calls
+}
+else if (kind === 'dag') {
+    let cur = sub === 'map' ? new Map([['v', x]]) : sub === 'set' ? new Set([x]) : sub === 'arr' ? [x] : { v: x } //mixed之葉同obj
+    for (let i = 0; i < n; i++) {
+        if (sub === 'obj') {
+            cur = { l: cur, r: cur }
+        }
+        else if (sub === 'arr') {
+            cur = [cur, cur]
+        }
+        else if (sub === 'map') {
+            cur = new Map([['l', cur], ['r', cur]])
+        }
+        else if (sub === 'set') {
+            cur = new Set([{ p: cur }, { q: cur }]) //Set元素不可重複, 兩個包裝物件各引用同一子Set
+        }
+        else {
+            cur = (i % 2 === 0) ? { l: cur, r: cur } : [cur, cur]
+        }
+    }
+    calls = 0
+    let t0 = process.hrtime.bigint()
+    let r = clearXSS(cur)
+    out.ms = Number(process.hrtime.bigint() - t0) / 1e6
+    out.calls = calls
+    //共用: 沿 l 與 r 兩側各走到底, 每層兩側須為同一輸出物件
+    let shared = true
+    let v = r
+    let steps = 0
+    while (typeof v === 'object' && v !== null && steps < n + 5) {
+        if (sub === 'obj') {
+            if (v.l === undefined) {
+                break
+            }
+            shared = shared && v.l === v.r
+            v = v.l
+        }
+        else if (sub === 'arr') {
+            if (v.length !== 2) {
+                break
+            }
+            shared = shared && v[0] === v[1]
+            v = v[0]
+        }
+        else if (sub === 'map') {
+            if (!v.has('l')) {
+                break
+            }
+            shared = shared && v.get('l') === v.get('r')
+            v = v.get('l')
+        }
+        else if (sub === 'set') {
+            let es = [...v]
+            if (typeof es[0] !== 'object' || es[0] === null || es[0].p === undefined) {
+                break
+            }
+            shared = shared && es[0].p === es[1].q
+            v = es[0].p
+        }
+        else {
+            if (Array.isArray(v)) {
+                shared = shared && v[0] === v[1]
+                v = v[0]
+            }
+            else {
+                if (v.l === undefined) {
+                    break
+                }
+                shared = shared && v.l === v.r
+                v = v.l
+            }
+        }
+        steps++
+    }
+    out.shared = shared
+    out.steps = steps
+}
+else if (kind === 'cycle') {
+    let head = { i: 0, s: x }
+    let cur = head
+    for (let i = 1; i < n; i++) {
+        let nx = { i, s: x }
+        cur.next = nx
+        cur = nx
+    }
+    cur.next = head
+    let t0 = process.hrtime.bigint()
+    let r = clearXSS(head)
+    out.ms = Number(process.hrtime.bigint() - t0) / 1e6
+    //走一圈: 每個節點字串已清除, 第n步回到起點
+    let v = r
+    let ok = true
+    for (let i = 0; i < n; i++) {
+        ok = ok && v.i === i && v.s === fx
+        v = v.next
+    }
+    out.cleaned = ok
+    out.closed = v === r
+    out.inputIntact = head.s === x && cur.next === head
+}
+else {
+    throw new Error('unknown case: ' + caseName)
+}
+
+console.log('@@R@@' + JSON.stringify(out))