@calcit/ternary-tree 0.0.23 → 0.0.25

package/lib/test-list-perf.mjs

@@ -0,0 +1,153 @@
+import { initTernaryTreeList, initTernaryTreeListFromRange, listGet, assocList, insert, listLen, indexOf, listToItems, prepend, append, concat, slice, reverse, listMapValues, } from "./list.mjs";
+function createTestListData(size) {
+    const data = [];
+    for (let i = 0; i < size; i++) {
+        data.push(i);
+    }
+    return data;
+}
+function measureTime(name, fn) {
+    const start = performance.now();
+    const result = fn();
+    const end = performance.now();
+    console.log(`${name}: ${(end - start).toFixed(2)}ms`);
+    return result;
+}
+export function runListPerformanceTests() {
+    console.log("\n=== List Performance Tests ===");
+    const sizes = [100, 1000, 5000, 10000];
+    for (const size of sizes) {
+        console.log(`\n--- Testing with ${size} elements ---`);
+        const testData = createTestListData(size);
+        // Test list creation
+        const treeList = measureTime(`initTernaryTreeList(${size})`, () => {
+            return initTernaryTreeList(testData);
+        });
+        // Test range creation
+        measureTime(`initTernaryTreeListFromRange(${size})`, () => {
+            return initTernaryTreeListFromRange(testData, 0, size);
+        });
+        // Test random access (listGet)
+        const indices = Array.from({ length: Math.min(100, size) }, (_, i) => Math.floor(Math.random() * size));
+        measureTime(`Random access(${indices.length})`, () => {
+            for (const idx of indices) {
+                listGet(treeList, idx);
+            }
+        });
+        // Test sequential access
+        measureTime(`Sequential access(${size})`, () => {
+            for (let i = 0; i < size; i++) {
+                listGet(treeList, i);
+            }
+        });
+        // Test prepend operations
+        measureTime(`Prepend operations(100)`, () => {
+            let list = treeList;
+            for (let i = 0; i < 100; i++) {
+                list = prepend(list, i + size);
+            }
+            return list;
+        });
+        // Test append operations
+        measureTime(`Append operations(100)`, () => {
+            let list = treeList;
+            for (let i = 0; i < 100; i++) {
+                list = append(list, i + size);
+            }
+            return list;
+        });
+        // Test assoc operations
+        const assocIndices = Array.from({ length: Math.min(50, size) }, (_, i) => Math.floor(Math.random() * size));
+        measureTime(`Assoc operations(${assocIndices.length})`, () => {
+            let list = treeList;
+            for (const idx of assocIndices) {
+                list = assocList(list, idx, idx * 2);
+            }
+            return list;
+        });
+        // Test insert operations
+        const insertIndices = Array.from({ length: Math.min(25, size) }, (_, i) => Math.floor(Math.random() * (size + i)));
+        measureTime(`Insert operations(${insertIndices.length})`, () => {
+            let list = treeList;
+            for (let i = 0; i < insertIndices.length; i++) {
+                const idx = Math.min(insertIndices[i], listLen(list));
+                list = insert(list, idx, i + size);
+            }
+            return list;
+        });
+        // Test search operations
+        const searchValues = testData.slice(0, Math.min(50, size));
+        measureTime(`Search operations(${searchValues.length})`, () => {
+            for (const value of searchValues) {
+                indexOf(treeList, value);
+            }
+        });
+        // Test iteration
+        measureTime(`Iterator traversal(${size})`, () => {
+            let count = 0;
+            for (const item of listToItems(treeList)) {
+                count++;
+            }
+            return count;
+        });
+        // Test slice operations
+        const sliceCount = Math.min(10, size / 10);
+        measureTime(`Slice operations(${sliceCount})`, () => {
+            for (let i = 0; i < sliceCount; i++) {
+                const start = Math.floor((Math.random() * size) / 2);
+                const end = start + Math.floor((Math.random() * size) / 4);
+                slice(treeList, start, end);
+            }
+        });
+        // Test reverse operation
+        if (size <= 5000) {
+            // Only test reverse for smaller sizes as it can be expensive
+            measureTime(`Reverse(${size})`, () => {
+                return reverse(treeList);
+            });
+        }
+        // Test map operation
+        measureTime(`Map operation(${size})`, () => {
+            return listMapValues(treeList, (x) => x * 2);
+        });
+    }
+    // Concat performance test
+    console.log("\n=== Concat Performance Test ===");
+    const list1 = initTernaryTreeList(createTestListData(1000));
+    const list2 = initTernaryTreeList(createTestListData(1000));
+    const list3 = initTernaryTreeList(createTestListData(1000));
+    measureTime("Concat two lists(1000 each)", () => {
+        return concat(list1, list2);
+    });
+    measureTime("Concat three lists(1000 each)", () => {
+        return concat(concat(list1, list2), list3);
+    });
+    // Memory stress test
+    console.log("\n=== Memory Usage Test ===");
+    const largeData = createTestListData(25000);
+    measureTime("Large list creation(25k)", () => {
+        return initTernaryTreeList(largeData);
+    });
+    // Cascading operations test
+    console.log("\n=== Cascading Operations Test ===");
+    measureTime("Complex operations chain", () => {
+        let list = initTernaryTreeList(createTestListData(1000));
+        // Chain multiple operations
+        list = prepend(list, -1);
+        list = append(list, 1001);
+        list = assocList(list, 500, 9999);
+        list = insert(list, 250, 8888);
+        // Access and search
+        listGet(list, 100);
+        indexOf(list, 9999);
+        // Slice and iterate
+        const sliced = slice(list, 100, 200);
+        for (const item of listToItems(sliced)) {
+            // consume iterator
+        }
+        return list;
+    });
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    runListPerformanceTests();
+}

package/lib/test-list.mjs

@@ -1,208 +1,207 @@
 import { listToString, initTernaryTreeList, initTernaryTreeListFromRange, indexOf, findIndex, reverse, checkListStructure, slice, listToPairs, listToItems, formatListInline, sameListShape, assocBefore, concat, assocAfter, prepend, append, rest, butlast, first, assocList, dissocList, listGet, insert, initEmptyTernaryTreeList, last, listLen, forceListInplaceBalancing, listEqual, indexToItems, listMapValues, concat2, } from "./list.mjs";
-import { test, check, arrayEqual, checkEqual } from "./test-utils.mjs";
+import { describe, test, check, checkEqual, checkArrayEqual } from "./test-utils.mjs";
 export let runListTests = () => {
-    test("init list", () => {
-        check(listToString(initTernaryTreeList([1, 2, 3, 4])) === "TernaryTreeList[4, ...]");
-        let origin11 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
-        let data11 = initTernaryTreeList(origin11);
-        check(checkListStructure(data11));
-        checkEqual(formatListInline(data11), "((1 (2 3 _) 4) (5 6 7) (8 (9 10 _) 11))");
-        check(arrayEqual(origin11, [...listToItems(data11)]));
-        check(arrayEqual([...listToItems(data11)], [...indexToItems(data11)]));
-        let emptyXs = new Array(0);
-        check(listEqual(initEmptyTernaryTreeList(), initTernaryTreeList(emptyXs)));
-    });
-    test("list operations", () => {
-        let origin11 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
-        let data11 = initTernaryTreeList(origin11);
-        // get
-        for (let idx = 0; idx < origin11.length; idx++) {
-            check(origin11[idx] === listGet(data11, idx));
-        }
-        check(first(data11) === 1);
-        check(last(data11) === 11);
-        // assoc
-        let origin5 = [1, 2, 3, 4, 5];
-        let data5 = initTernaryTreeList(origin5);
-        let updated = assocList(data5, 3, 10);
-        check(listGet(updated, 3) === 10);
-        check(listGet(data5, 3) === 4);
-        check(listLen(updated) === listLen(data5));
-        for (let idx = 0; idx < listLen(data5); idx++) {
-            // echo data5.dissoc(idx).formatInline
-            check(listLen(dissocList(data5, idx)) === listLen(data5) - 1);
-        }
-        checkEqual(formatListInline(data5), "((1 2 _) 3 (4 5 _))");
-        checkEqual(formatListInline(dissocList(data5, 0)), "(2 3 (4 5 _))");
-        checkEqual(formatListInline(dissocList(data5, 1)), "(1 3 (4 5 _))");
-        checkEqual(formatListInline(dissocList(data5, 2)), "((1 2 _) (4 5 _) _)");
-        checkEqual(formatListInline(dissocList(data5, 3)), "((1 2 _) 3 5)");
-        checkEqual(formatListInline(dissocList(data5, 4)), "((1 2 _) 3 4)");
-        checkEqual(formatListInline(rest(initTernaryTreeList([1]))), "_");
-        checkEqual(formatListInline(rest(initTernaryTreeList([1, 2]))), "2");
-        checkEqual(formatListInline(rest(initTernaryTreeList([1, 2, 3]))), "(2 3 _)");
-        checkEqual(formatListInline(rest(initTernaryTreeList([1, 2, 3, 4]))), "((2 3 _) 4 _)");
-        checkEqual(formatListInline(rest(initTernaryTreeList([1, 2, 3, 4, 5]))), "(2 3 (4 5 _))");
-        checkEqual(formatListInline(butlast(initTernaryTreeList([1]))), "_");
-        checkEqual(formatListInline(butlast(initTernaryTreeList([1, 2]))), "1");
-        checkEqual(formatListInline(butlast(initTernaryTreeList([1, 2, 3]))), "(1 2 _)");
-        checkEqual(formatListInline(butlast(initTernaryTreeList([1, 2, 3, 4]))), "(1 (2 3 _) _)");
-        checkEqual(formatListInline(butlast(initTernaryTreeList([1, 2, 3, 4, 5]))), "((1 2 _) 3 4)");
-    });
-    test("list insertions", () => {
-        let origin5 = [1, 2, 3, 4, 5];
-        let data5 = initTernaryTreeList(origin5);
-        checkEqual(formatListInline(data5), "((1 2 _) 3 (4 5 _))");
-        checkEqual(formatListInline(insert(data5, 0, 10, false)), "(10 ((1 2 _) 3 (4 5 _)) _)");
-        checkEqual(formatListInline(insert(data5, 0, 10, true)), "((1 10 2) 3 (4 5 _))");
-        checkEqual(formatListInline(insert(data5, 1, 10, false)), "((1 10 2) 3 (4 5 _))");
-        checkEqual(formatListInline(insert(data5, 1, 10, true)), "((1 2 10) 3 (4 5 _))");
-        checkEqual(formatListInline(insert(data5, 2, 10, false)), "((1 2 _) (10 3 _) (4 5 _))");
-        checkEqual(formatListInline(insert(data5, 2, 10, true)), "((1 2 _) (3 10 _) (4 5 _))");
-        checkEqual(formatListInline(insert(data5, 3, 10, false)), "((1 2 _) 3 (10 4 5))");
-        checkEqual(formatListInline(insert(data5, 3, 10, true)), "((1 2 _) 3 (4 10 5))");
-        checkEqual(formatListInline(insert(data5, 4, 10, false)), "((1 2 _) 3 (4 10 5))");
-        checkEqual(formatListInline(insert(data5, 4, 10, true)), "(((1 2 _) 3 (4 5 _)) 10 _)");
-        let origin4 = [1, 2, 3, 4];
-        let data4 = initTernaryTreeList(origin4);
-        checkEqual(formatListInline(assocBefore(data4, 3, 10)), "(1 (2 3 _) (10 4 _))");
-        checkEqual(formatListInline(assocAfter(data4, 3, 10)), "(1 (2 3 _) (4 10 _))");
-        checkEqual(formatListInline(prepend(data4, 10)), "((10 1 _) (2 3 _) 4)");
-        checkEqual(formatListInline(append(data4, 10)), "(1 (2 3 _) (4 10 _))");
-    });
-    test("concat", () => {
-        let data1 = initTernaryTreeList([1, 2]);
-        let data2 = initTernaryTreeList([3, 4]);
-        let data3 = initTernaryTreeList([5, 6]);
-        let data4 = initTernaryTreeList([7, 8]);
-        check(formatListInline(concat(data1, data2)) === "(1 2 (3 4 _))");
-        check(formatListInline(concat(initTernaryTreeList([]), data1)) === "(1 2 _)");
-        check(formatListInline(concat(data1, data2, data3)) === "((1 2 _) (3 4 _) (5 6 _))");
-        check(formatListInline(concat(data1, data2, data3, data4)) === "((1 2 _) ((3 4 _) (5 6 _) _) (7 8 _))");
-        checkListStructure(concat(data1, data2));
-        checkListStructure(concat(data1, data2, data3));
-        checkListStructure(concat(data1, data2, data3, data4));
-        check(listLen(concat(data1, data2, data3, data4)) === 8);
-    });
-    test("check(equality", () => {
-        let origin4 = [1, 2, 3, 4];
-        let data4 = initTernaryTreeList(origin4);
-        let data4n = initTernaryTreeList(origin4);
-        let data4Made = prepend(initTernaryTreeList([2, 3, 4]), 1);
-        checkListStructure(data4);
-        checkListStructure(data4n);
-        checkListStructure(data4Made);
-        check(sameListShape(data4, data4) === true);
-        check(sameListShape(data4, data4n) === true);
-        check(sameListShape(data4, data4Made) === false);
-        check(listEqual(data4, data4n));
-        check(listEqual(data4, data4Made));
-        check(listEqual(data4n, data4Made));
-        check(data4 !== data4Made); // identical false
-    });
-    test("force balancing", () => {
-        var data = initTernaryTreeList([]);
-        for (let idx = 0; idx < 20; idx++) {
-            data = append(data, idx, true);
-            checkListStructure(data);
-        }
-        // echo data.formatInline
-        check(formatListInline(data) === "(((0 1 2) (3 4 5) (6 7 8)) ((9 10 11) (12 13 14) (15 16 17)) (18 19 _))");
-        forceListInplaceBalancing(data);
-        check(formatListInline(data) === "(((0 1 _) (2 3 4) (5 6 _)) ((7 8 _) (9 10 _) (11 12 _)) ((13 14 _) (15 16 17) (18 19 _)))");
-        // echo data.formatInline
-    });
-    test("iterator", () => {
-        let origin4 = [1, 2, 3, 4];
-        let data4 = initTernaryTreeList(origin4);
-        checkListStructure(data4);
-        var i = 0;
-        for (let item of listToItems(data4)) {
-            i = i + 1;
-        }
-        check(i === 4);
-        i = 0;
-        for (let [idx, item] of listToPairs(data4)) {
-            i = i + idx;
-        }
-        check(i === 6);
-    });
-    test("check structure", () => {
-        var data = initTernaryTreeList([]);
-        for (let idx = 0; idx < 20; idx++) {
-            data = append(data, idx, true);
-            checkListStructure(data);
-        }
-        check(checkListStructure(data));
-        for (let idx = 0; idx < 20; idx++) {
-            data = rest(data);
-            checkListStructure(data);
-        }
-        let origin11 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
-        let data11 = initTernaryTreeList(origin11);
-        check(checkListStructure(data11));
-        checkListStructure(prepend(initEmptyTernaryTreeList(), 1));
-        checkListStructure(prepend(null, 1));
-    });
-    test("slices", () => {
-        var data = initTernaryTreeList([]);
-        for (let idx = 0; idx < 40; idx++) {
-            data = append(data, idx, true);
-        }
-        var list40 = [];
-        for (let idx = 0; idx < 40; idx++) {
-            list40.push(idx);
-        }
-        for (let i = 0; i < 40; i++) {
-            for (let j = i; j < 40; j++) {
-                check(arrayEqual([...listToItems(slice(data, i, j))], list40.slice(i, j)));
-                checkListStructure(slice(data, i, j));
+    describe("TernaryTreeList Tests", () => {
+        test("should initialize list correctly", () => {
+            check(listToString(initTernaryTreeList([1, 2, 3, 4])) === "TernaryTreeList[4, ...]");
+            let origin11 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+            let data11 = initTernaryTreeList(origin11);
+            check(checkListStructure(data11));
+            checkEqual(formatListInline(data11), "((1 (2 3 _) 4) (5 6 7) (8 (9 10 _) 11))");
+            checkArrayEqual([...listToItems(data11)], origin11);
+            checkArrayEqual([...listToItems(data11)], [...indexToItems(data11)]);
+            let emptyXs = new Array(0);
+            check(listEqual(initEmptyTernaryTreeList(), initTernaryTreeList(emptyXs)));
+        });
+        test("should perform basic list operations", () => {
+            let origin11 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+            let data11 = initTernaryTreeList(origin11);
+            // get
+            for (let idx = 0; idx < origin11.length; idx++) {
+                check(origin11[idx] === listGet(data11, idx));
             }
-        }
-    });
-    test("reverse", () => {
-        let data = initTernaryTreeList([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-        let reversedData = reverse(data);
-        check(arrayEqual([...listToItems(data)].reverse(), [...listToItems(reversedData)]));
-        check(checkListStructure(reversedData));
-    });
-    test("list traverse", () => {
-        var i = 0;
-        let data = initTernaryTreeList([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-        checkListStructure(data);
-        for (let x of listToItems(data)) {
-            i = i + 1;
-        }
-        check(i === 10);
-    });
-    test("index of", () => {
-        let data = initTernaryTreeList([1, 2, 3, 4, 5, 6, 7, 8]);
-        check(indexOf(data, 2) === 1);
-        check(findIndex(data, (x) => x === 2) === 1);
-        check(indexOf(data, 9) === -1);
-        check(findIndex(data, (x) => x === 9) === -1);
-    });
-    test("map values", () => {
-        let data = initTernaryTreeList([1, 2, 3, 4]);
-        let data2 = initTernaryTreeList([1, 4, 9, 16]);
-        let data3 = listMapValues(data, (x) => x * x);
-        checkListStructure(data3);
-        check(listEqual(data2, data3));
-        check(formatListInline(data2) === formatListInline(data3));
-    });
-    test("concat", () => {
-        let data1 = initTernaryTreeList([3, 4]);
-        let data2 = initTernaryTreeListFromRange([1, 2, 3, 4, 5, 6], 2, 4);
-        check(listEqual(data1, data2));
-        checkListStructure(data1);
-        checkListStructure(data2);
-    });
-    test("concat loop", () => {
-        let data1 = initTernaryTreeList([3, 4]);
-        let data2 = initTernaryTreeList([5]);
-        for (let i = 0; i < 100; i++) {
-            data1 = concat2(data1, data2);
-        }
-        console.log("concat into depth", formatListInline(data1));
+            check(first(data11) === 1);
+            check(last(data11) === 11);
+            // assoc
+            let origin5 = [1, 2, 3, 4, 5];
+            let data5 = initTernaryTreeList(origin5);
+            let updated = assocList(data5, 3, 10);
+            check(listGet(updated, 3) === 10);
+            check(listGet(data5, 3) === 4);
+            check(listLen(updated) === listLen(data5));
+            for (let idx = 0; idx < listLen(data5); idx++) {
+                check(listLen(dissocList(data5, idx)) === listLen(data5) - 1);
+            }
+            checkEqual(formatListInline(data5), "((1 2 _) 3 (4 5 _))");
+            checkEqual(formatListInline(dissocList(data5, 0)), "(2 3 (4 5 _))");
+            checkEqual(formatListInline(dissocList(data5, 1)), "(1 3 (4 5 _))");
+            checkEqual(formatListInline(dissocList(data5, 2)), "((1 2 _) (4 5 _) _)");
+            checkEqual(formatListInline(dissocList(data5, 3)), "((1 2 _) 3 5)");
+            checkEqual(formatListInline(dissocList(data5, 4)), "((1 2 _) 3 4)");
+            checkEqual(formatListInline(rest(initTernaryTreeList([1]))), "_");
+            checkEqual(formatListInline(rest(initTernaryTreeList([1, 2]))), "2");
+            checkEqual(formatListInline(rest(initTernaryTreeList([1, 2, 3]))), "(2 3 _)");
+            checkEqual(formatListInline(rest(initTernaryTreeList([1, 2, 3, 4]))), "((2 3 _) 4 _)");
+            checkEqual(formatListInline(rest(initTernaryTreeList([1, 2, 3, 4, 5]))), "(2 3 (4 5 _))");
+            checkEqual(formatListInline(butlast(initTernaryTreeList([1]))), "_");
+            checkEqual(formatListInline(butlast(initTernaryTreeList([1, 2]))), "1");
+            checkEqual(formatListInline(butlast(initTernaryTreeList([1, 2, 3]))), "(1 2 _)");
+            checkEqual(formatListInline(butlast(initTernaryTreeList([1, 2, 3, 4]))), "(1 (2 3 _) _)");
+            checkEqual(formatListInline(butlast(initTernaryTreeList([1, 2, 3, 4, 5]))), "((1 2 _) 3 4)");
+        });
+        test("should handle list insertions", () => {
+            let origin5 = [1, 2, 3, 4, 5];
+            let data5 = initTernaryTreeList(origin5);
+            checkEqual(formatListInline(data5), "((1 2 _) 3 (4 5 _))");
+            checkEqual(formatListInline(insert(data5, 0, 10, false)), "(10 ((1 2 _) 3 (4 5 _)) _)");
+            checkEqual(formatListInline(insert(data5, 0, 10, true)), "((1 10 2) 3 (4 5 _))");
+            checkEqual(formatListInline(insert(data5, 1, 10, false)), "((1 10 2) 3 (4 5 _))");
+            checkEqual(formatListInline(insert(data5, 1, 10, true)), "((1 2 10) 3 (4 5 _))");
+            checkEqual(formatListInline(insert(data5, 2, 10, false)), "((1 2 _) (10 3 _) (4 5 _))");
+            checkEqual(formatListInline(insert(data5, 2, 10, true)), "((1 2 _) (3 10 _) (4 5 _))");
+            checkEqual(formatListInline(insert(data5, 3, 10, false)), "((1 2 _) 3 (10 4 5))");
+            checkEqual(formatListInline(insert(data5, 3, 10, true)), "((1 2 _) 3 (4 10 5))");
+            checkEqual(formatListInline(insert(data5, 4, 10, false)), "((1 2 _) 3 (4 10 5))");
+            checkEqual(formatListInline(insert(data5, 4, 10, true)), "(((1 2 _) 3 (4 5 _)) 10 _)");
+            let origin4 = [1, 2, 3, 4];
+            let data4 = initTernaryTreeList(origin4);
+            checkEqual(formatListInline(assocBefore(data4, 3, 10)), "(1 (2 3 _) (10 4 _))");
+            checkEqual(formatListInline(assocAfter(data4, 3, 10)), "(1 (2 3 _) (4 10 _))");
+            checkEqual(formatListInline(prepend(data4, 10)), "((10 1 _) (2 3 _) 4)");
+            checkEqual(formatListInline(append(data4, 10)), "(1 (2 3 _) (4 10 _))");
+        });
+        test("should handle list concatenation", () => {
+            let data1 = initTernaryTreeList([1, 2]);
+            let data2 = initTernaryTreeList([3, 4]);
+            let data3 = initTernaryTreeList([5, 6]);
+            let data4 = initTernaryTreeList([7, 8]);
+            check(formatListInline(concat(data1, data2)) === "(1 2 (3 4 _))");
+            check(formatListInline(concat(initTernaryTreeList([]), data1)) === "(1 2 _)");
+            check(formatListInline(concat(data1, data2, data3)) === "((1 2 _) (3 4 _) (5 6 _))");
+            check(formatListInline(concat(data1, data2, data3, data4)) === "((1 2 _) ((3 4 _) (5 6 _) _) (7 8 _))");
+            check(checkListStructure(concat(data1, data2)));
+            check(checkListStructure(concat(data1, data2, data3)));
+            check(checkListStructure(concat(data1, data2, data3, data4)));
+            check(listLen(concat(data1, data2, data3, data4)) === 8);
+        });
+        test("should check equality correctly", () => {
+            let origin4 = [1, 2, 3, 4];
+            let data4 = initTernaryTreeList(origin4);
+            let data4n = initTernaryTreeList(origin4);
+            let data4Made = prepend(initTernaryTreeList([2, 3, 4]), 1);
+            check(checkListStructure(data4));
+            check(checkListStructure(data4n));
+            check(checkListStructure(data4Made));
+            check(sameListShape(data4, data4) === true);
+            check(sameListShape(data4, data4n) === true);
+            check(sameListShape(data4, data4Made) === false);
+            check(listEqual(data4, data4n));
+            check(listEqual(data4, data4Made));
+            check(listEqual(data4n, data4Made));
+            check(data4 !== data4Made); // identical false
+        });
+        test("should force balancing correctly", () => {
+            var data = initTernaryTreeList([]);
+            for (let idx = 0; idx < 20; idx++) {
+                data = append(data, idx, true);
+                check(checkListStructure(data));
+            }
+            check(formatListInline(data) === "(((0 1 2) (3 4 5) (6 7 8)) ((9 10 11) (12 13 14) (15 16 17)) (18 19 _))");
+            forceListInplaceBalancing(data);
+            check(formatListInline(data) === "(((0 1 _) (2 3 4) (5 6 _)) ((7 8 _) (9 10 _) (11 12 _)) ((13 14 _) (15 16 17) (18 19 _)))");
+        });
+        test("should handle iteration correctly", () => {
+            let origin4 = [1, 2, 3, 4];
+            let data4 = initTernaryTreeList(origin4);
+            check(checkListStructure(data4));
+            var count = 0;
+            for (let item of listToItems(data4)) {
+                count = count + 1;
+            }
+            check(count === 4);
+            var indexSum = 0;
+            for (let [idx, item] of listToPairs(data4)) {
+                indexSum = indexSum + idx;
+            }
+            check(indexSum === 6);
+        });
+        test("should maintain structure integrity", () => {
+            var data = initTernaryTreeList([]);
+            for (let idx = 0; idx < 20; idx++) {
+                data = append(data, idx, true);
+                check(checkListStructure(data));
+            }
+            check(checkListStructure(data));
+            for (let idx = 0; idx < 20; idx++) {
+                data = rest(data);
+                check(checkListStructure(data));
+            }
+            let origin11 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+            let data11 = initTernaryTreeList(origin11);
+            check(checkListStructure(data11));
+            check(checkListStructure(prepend(initEmptyTernaryTreeList(), 1)));
+            check(checkListStructure(prepend(null, 1)));
+        });
+        test("should handle slicing correctly", () => {
+            var data = initTernaryTreeList([]);
+            for (let idx = 0; idx < 40; idx++) {
+                data = append(data, idx, true);
+            }
+            var list40 = [];
+            for (let idx = 0; idx < 40; idx++) {
+                list40.push(idx);
+            }
+            for (let i = 0; i < 40; i++) {
+                for (let j = i; j < 40; j++) {
+                    checkArrayEqual([...listToItems(slice(data, i, j))], list40.slice(i, j));
+                    check(checkListStructure(slice(data, i, j)));
+                }
+            }
+        });
+        test("should reverse lists correctly", () => {
+            let data = initTernaryTreeList([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+            let reversedData = reverse(data);
+            checkArrayEqual([...listToItems(reversedData)], [...listToItems(data)].reverse());
+            check(checkListStructure(reversedData));
+        });
+        test("should traverse lists correctly", () => {
+            var count = 0;
+            let data = initTernaryTreeList([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+            check(checkListStructure(data));
+            for (let x of listToItems(data)) {
+                count = count + 1;
+            }
+            check(count === 10);
+        });
+        test("should find index correctly", () => {
+            let data = initTernaryTreeList([1, 2, 3, 4, 5, 6, 7, 8]);
+            check(indexOf(data, 2) === 1);
+            check(findIndex(data, (x) => x === 2) === 1);
+            check(indexOf(data, 9) === -1);
+            check(findIndex(data, (x) => x === 9) === -1);
+        });
+        test("should map values correctly", () => {
+            let data = initTernaryTreeList([1, 2, 3, 4]);
+            let data2 = initTernaryTreeList([1, 4, 9, 16]);
+            let data3 = listMapValues(data, (x) => x * x);
+            check(checkListStructure(data3));
+            check(listEqual(data2, data3));
+            check(formatListInline(data2) === formatListInline(data3));
+        });
+        test("should handle range initialization", () => {
+            let data1 = initTernaryTreeList([3, 4]);
+            let data2 = initTernaryTreeListFromRange([1, 2, 3, 4, 5, 6], 2, 4);
+            check(listEqual(data1, data2));
+            check(checkListStructure(data1));
+            check(checkListStructure(data2));
+        });
+        test("should handle concat loop stress test", () => {
+            let data1 = initTernaryTreeList([3, 4]);
+            let data2 = initTernaryTreeList([5]);
+            for (let i = 0; i < 100; i++) {
+                data1 = concat2(data1, data2);
+            }
+            console.log("concat into depth", formatListInline(data1));
+        });
     });
 };

package/lib/test-map-perf.d.mts

@@ -0,0 +1 @@
+export declare function runPerformanceTests(): void;

package/lib/test-map-perf.mjs

@@ -0,0 +1,70 @@
+import { initTernaryTreeMap, initTernaryTreeMapFromArray, assocMap, contains, mapGetDefault, dissocMap, toPairsArray, initEmptyTernaryTreeMap, } from "./map.mjs";
+function createTestData(size) {
+    const data = [];
+    for (let i = 0; i < size; i++) {
+        data.push([i, `value_${i}`]);
+    }
+    return data;
+}
+function measureTime(name, fn) {
+    const start = performance.now();
+    const result = fn();
+    const end = performance.now();
+    console.log(`${name}: ${(end - start).toFixed(2)}ms`);
+    return result;
+}
+export function runPerformanceTests() {
+    console.log("\n=== Performance Tests ===");
+    const sizes = [100, 1000, 5000, 10000];
+    for (const size of sizes) {
+        console.log(`\n--- Testing with ${size} elements ---`);
+        const testData = createTestData(size);
+        const mapData = new Map(testData);
+        // Test initTernaryTreeMapFromArray
+        const treeFromArray = measureTime(`initTernaryTreeMapFromArray(${size})`, () => {
+            return initTernaryTreeMapFromArray(testData);
+        });
+        // Test initTernaryTreeMap
+        const treeFromMap = measureTime(`initTernaryTreeMap(${size})`, () => {
+            return initTernaryTreeMap(mapData);
+        });
+        // Test sequential assoc operations
+        measureTime(`Sequential assoc(${size})`, () => {
+            let tree = initEmptyTernaryTreeMap();
+            for (const [k, v] of testData) {
+                tree = assocMap(tree, k, v);
+            }
+            return tree;
+        });
+        // Test lookups
+        const lookupKeys = testData.slice(0, Math.min(100, size)).map(([k]) => k);
+        measureTime(`Lookups(${lookupKeys.length})`, () => {
+            for (const key of lookupKeys) {
+                contains(treeFromArray, key);
+                mapGetDefault(treeFromArray, key, "default");
+            }
+        });
+        // Test dissoc operations
+        const dissocKeys = testData.slice(0, Math.min(50, size)).map(([k]) => k);
+        measureTime(`Dissoc(${dissocKeys.length})`, () => {
+            let tree = treeFromArray;
+            for (const key of dissocKeys) {
+                tree = dissocMap(tree, key);
+            }
+            return tree;
+        });
+        // Test toPairsArray
+        measureTime(`toPairsArray(${size})`, () => {
+            return toPairsArray(treeFromArray);
+        });
+    }
+    console.log("\n=== Memory usage test ===");
+    const largeData = createTestData(50000);
+    console.log(`Testing with ${largeData.length} elements for memory efficiency`);
+    measureTime("Large dataset creation", () => {
+        return initTernaryTreeMapFromArray(largeData);
+    });
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    runPerformanceTests();
+}