nv-dag-using-str-nd 1.0.0

package/TEST/perf.js

@@ -0,0 +1,45 @@
+
+const { creat } = require("../index"); // 假设 dag.js 导出 creat
+
+function benchmark() {
+    const g = creat();
+    const nodeCount = 50000;
+    const edgeCount = 2000000;
+
+    // 生成节点名
+    const nodes = [];
+    for (let i = 0; i < nodeCount; i++) {
+        nodes.push(`N${i}`);
+    }
+
+    // 记录开始时间
+    const t1 = performance.now();
+
+    // 添加节点
+    for (const node of nodes) {
+        g.add_nd(node);
+    }
+
+    // 随机添加边（确保不重复、不形成自环）
+    let attempts = 0;
+    let edgesAdded = 0;
+    while (attempts < edgeCount) {
+        const src = nodes[Math.floor(Math.random() * 10 )];
+        let dst = nodes[Math.floor(Math.random() * nodeCount)];
+        if (src !== dst) {
+            const [ok] = g.conn(src, dst);
+            if (ok) edgesAdded++;
+        }
+        attempts++;
+    }
+
+    const t2 = performance.now();
+
+    console.log(`节点数: ${nodeCount}`);
+    console.log(`边数: ${edgesAdded}`);
+    console.log(`耗时: ${(t2 - t1).toFixed(2)} ms`);
+    ////
+    //// 删除所有 孤立节点: 出度和入度均为0
+}
+
+benchmark();

package/TEST/tst-dag.js

@@ -0,0 +1,86 @@
+// dag.test.js
+const assert = require('assert');
+const { creat } = require('../index'); // 假设 dag.js 在同一目录
+
+function runTests() {
+    console.log('开始测试 DAG 工具...');
+
+    // 创建空图
+    let g = creat();
+
+    // ========== 测试 add_nd / has_nd / del_nd ==========
+    assert.strictEqual(g.has_nd('A'), false, '初始无节点 A');
+    assert.deepStrictEqual(g.add_nd('A'), [true, 'A'], '添加节点 A 成功');
+    assert.strictEqual(g.has_nd('A'), true, '节点 A 存在');
+    assert.deepStrictEqual(g.add_nd('A'), [false, 'A already exist'], '重复添加 A 失败');
+    assert.deepStrictEqual(g.del_nd('A'), [true, 'A'], '删除节点 A 成功');
+    assert.strictEqual(g.has_nd('A'), false, '节点 A 已不存在');
+    assert.deepStrictEqual(g.del_nd('A'), [false, 'A NOT exist'], '删除不存在的节点失败');
+
+    // ========== 测试 conn / is_reachable_fr_to ==========
+    g.add_nd('X');
+    g.add_nd('Y');
+    g.add_nd('Z');
+    assert.deepStrictEqual(g.conn('X', 'Y'), [true, 'X', 'Y'], '连接 X -> Y 成功');
+    assert.deepStrictEqual(g.conn('Y', 'Z'), [true, 'Y', 'Z'], '连接 Y -> Z 成功');
+    assert.strictEqual(g.is_reachable_fr_to('X', 'Z'), true, 'X 可达 Z');
+    assert.strictEqual(g.is_reachable_fr_to('Z', 'X'), false, 'Z 不可达 X');
+    assert.strictEqual(g.is_reachable_fr_to('X', 'X'), true, '节点自身可达');
+
+    // 测试循环依赖
+    assert.deepStrictEqual(g.conn('Z', 'X'), [false, 'circular X->...->Z'], '检测循环依赖 Z -> X 失败');
+
+    // 测试重复连接
+    assert.deepStrictEqual(g.conn('X', 'Y'), [false, 'X->Y already exist'], '重复连接 X -> Y 失败');
+
+    // ========== 测试 get_reachable_fr / get_reachable_to ==========
+    let reachableFromX = g.get_reachable_fr('X');
+    assert.deepStrictEqual(reachableFromX.has('Y') && reachableFromX.has('Z'), true, '从 X 可达 Y 和 Z');
+    let reachableToZ = g.get_reachable_to('Z');
+    assert.deepStrictEqual(reachableToZ.has('X') && reachableToZ.has('Y'), true, '到 Z 的可达节点包含 X 和 Y');
+
+    // ========== 测试 add (单参数 & 双参数) ==========
+    g2 = creat();
+    assert.deepStrictEqual(g2.add('P'), [true, 'P'], 'add 单参数添加 P 成功');
+    assert.deepStrictEqual(g2.add('Q'), [true, 'Q'], 'add 单参数添加 Q 成功');
+    assert.deepStrictEqual(g2.add('P', 'Q'), [true, 'P', 'Q'], 'add 双参数连接 P -> Q 成功');
+    assert.deepStrictEqual(g2.add('P', 'Q'), [false, 'P->Q already exist'], 'add 重复连接 P -> Q 失败');
+
+    // ========== 测试 has (单参数 & 双参数) ==========
+    assert.strictEqual(g2.has('P'), true, 'has 单参数检查 P 存在');
+    assert.strictEqual(g2.has('R'), false, 'has 单参数检查 R 不存在');
+    assert.strictEqual(g2.has('P', 'Q'), true, 'has 双参数检查边 P -> Q 存在');
+    assert.strictEqual(g2.has('Q', 'P'), false, 'has 双参数检查边 Q -> P 不存在');
+
+    // ========== 测试 del (单参数 & 双参数) ==========
+    assert.deepStrictEqual(g2.del('P', 'Q'), [true, 'P', 'Q'], 'del 双参数删除边 P -> Q 成功');
+    assert.deepStrictEqual(g2.del('P', 'Q'), [false, 'edge P->Q NOT exist'], 'del 删除不存在的边失败');
+    assert.deepStrictEqual(g2.del('R'), [false, 'R NOT exist'], 'del 单参数删除不存在的节点失败');
+
+    // ========== 测试 in0nds / ot0nds ==========
+    g3 = creat();
+    g3.add_nd('A');
+    g3.add_nd('B');
+    g3.add_nd('C');
+    g3.conn('A', 'B');
+    g3.conn('A', 'C');
+    let in0 = g3.in0nds;
+    let ot0 = g3.ot0nds;
+    assert.strictEqual(in0.has('A'), true, 'A 入度为 0');
+    assert.strictEqual(ot0.has('B') && ot0.has('C'), true, 'B 和 C 出度为 0');
+
+    // ========== 测试 clone ==========
+    let g3clone = g3.clone();
+    assert.deepStrictEqual(g3clone.nds, g3.nds, '克隆后节点集合一致');
+    assert.deepStrictEqual(g3clone.dns, g3.dns, '克隆后 dns 一致');
+    assert.deepStrictEqual(g3clone.ups, g3.ups, '克隆后 ups 一致');
+    // 修改原图不影响克隆
+    g3.add_nd('D');
+    assert.strictEqual(g3clone.has_nd('D'), false, '克隆不受原图修改影响');
+
+    console.log('✅ 所有测试通过！');
+}
+
+runTests();
+
+

package/TEST/tst-iter.js

@@ -0,0 +1,103 @@
+const assert = require('assert');
+const {
+    creat,
+    sync_d2u_iter,
+    async_d2u_iter,
+    sync_u2d_iter,
+    async_u2d_iter,
+} = require("../index");
+
+
+// ========== 测试 4 个 iterator 方法 ==========
+
+console.log('\n--- 测试 sync_d2u_iter ---');
+{
+    let g = creat();
+    // 构造图: A -> B -> D, A -> C -> D
+    g.add('A', 'B');
+    g.add('A', 'C');
+    g.add('B', 'D');
+    g.add('C', 'D');
+
+    let order = [];
+    sync_d2u_iter(g, (nds, readonly_g) => {
+        // nds 是当前出度为 0 的节点集合
+        let arr = Array.from(nds).sort();
+        order.push(arr);
+        console.log('sync_d2u_iter step:', arr);
+    });
+
+    // 预期顺序：先 [D]（叶子），再 [B, C]（B、C 变成叶子），最后 [A]（根）
+    assert.deepStrictEqual(order, [['D'], ['B', 'C'], ['A']], 'sync_d2u_iter 顺序正确');
+    console.log('✅ sync_d2u_iter 测试通过');
+}
+
+console.log('\n--- 测试 sync_u2d_iter ---');
+{
+    let g = creat();
+    g.add('A', 'B');
+    g.add('A', 'C');
+    g.add('B', 'D');
+    g.add('C', 'D');
+
+    let order = [];
+    sync_u2d_iter(g, (nds, readonly_g) => {
+        let arr = Array.from(nds).sort();
+        order.push(arr);
+        console.log('sync_u2d_iter step:', arr);
+    });
+
+    // 预期顺序：先 [A]（根），再 [B, C]，最后 [D]（叶子）
+    assert.deepStrictEqual(order, [['A'], ['B', 'C'], ['D']], 'sync_u2d_iter 顺序正确');
+    console.log('✅ sync_u2d_iter 测试通过');
+}
+
+console.log('\n--- 测试 async_d2u_iter ---');
+var p
+{
+    let g = creat();
+    g.add('A', 'B');
+    g.add('A', 'C');
+    g.add('B', 'D');
+    g.add('C', 'D');
+
+    let order = [];
+    async function testAsyncD2U() {
+        await async_d2u_iter(g, async (nds, readonly_g) => {
+            let arr = Array.from(nds).sort();
+            order.push(arr);
+            console.log('async_d2u_iter step:', arr);
+            // 模拟异步操作
+            await new Promise(resolve => setTimeout(resolve, 10));
+        });
+        assert.deepStrictEqual(order, [['D'], ['B', 'C'], ['A']], 'async_d2u_iter 顺序正确');
+        console.log('✅ async_d2u_iter 测试通过');
+    }
+    p= testAsyncD2U();
+}
+
+p.then(r=>{
+console.log('\n--- 测试 async_u2d_iter ---');
+{
+    let g = creat();
+    g.add('A', 'B');
+    g.add('A', 'C');
+    g.add('B', 'D');
+    g.add('C', 'D');
+
+    let order = [];
+    async function testAsyncU2D() {
+        await async_u2d_iter(g, async (nds, readonly_g) => {
+            let arr = Array.from(nds).sort();
+            order.push(arr);
+            console.log('async_u2d_iter step:', arr);
+            await new Promise(resolve => setTimeout(resolve, 10));
+        });
+        assert.deepStrictEqual(order, [['A'], ['B', 'C'], ['D']], 'async_u2d_iter 顺序正确');
+        console.log('✅ async_u2d_iter 测试通过');
+    }
+    testAsyncU2D();
+}
+});
+
+

package/TEST/tst-show-dag.js

@@ -0,0 +1,13 @@
+const {creat} = require("../index")
+
+// 测试 show 方法
+let gShow = creat();
+gShow.add_nd('A');
+gShow.add_nd('B');
+gShow.add_nd('C');
+gShow.add_nd('D');
+gShow.conn('A', 'B');
+gShow.conn('A', 'C');
+gShow.conn('B', 'D');
+gShow.conn('C', 'D');
+gShow.show();

package/index.js

@@ -0,0 +1,517 @@
+//src depends on dst
+
+// 例如我们有 4个节点 A B C D
+// 关系 A->B  A->C  B->D C->D
+//    nds :{A,B,C,D}
+//    dns: {
+//       A:{B,C}
+//       B:{D}
+//       C:{D}
+//       D:{}
+//    }
+//
+//    ups {
+//        A:{}
+//        B:{A}
+//        C:{A}
+//        D:{BMC} 
+//    }
+//
+//------我们适当增加一些冗余数据结构(空间换时间)
+//------让我们探测环路 和  算必经点 容易一些
+//
+
+
+class G {
+    nds  = new Set();
+    dns  = {};                //直连下游
+    ups  = {};                //直连上游
+    ////
+    has_nd(p) { return this.nds.has(p); }
+    indeg(p)  { 
+        if(this.has_nd(p)) {
+            return this.ups[p].size();
+        } else {
+            return -1;
+        }
+    }
+    otdeg(p) {
+        if(this.has_nd(p)) {
+            return this.dns[p].size();
+        } else {
+            return -1;
+        }    
+    }
+    ////
+    _add_nd(p) {
+        this.nds.add(p);
+        this.dns[p] = new Set();           // p 直接连向的节点
+        this.ups[p] = new Set();           // 直接连向p 的节点    
+    }
+    add_nd(p) {
+        if(this.has_nd(p)) {
+            return [false, `${p} already exist`]
+        } else {
+            this._add_nd(p);
+            return [true,p]
+        }
+    }
+    _del_nd(p) {
+        this.nds.delete(p);  //先从节点集删除 
+        var ups = this.ups[p]; delete this.ups[p];
+        for(var u of ups) {
+            //所有p 的直连上游节点u  删除 其下游节点p
+            delete this.dns[u].delete(p);
+        }
+        var dns = this.dns[p];  delete this.dns[p];
+        for(var d of dns) {
+            //所有p 的直连下游节点d 删除 其上游节点p
+            delete this.ups[d].delete(p);
+        }
+    }
+    del_nd(p) {
+        if(!this.has_nd(p)) {
+            return [false, `${p} NOT exist`]
+        } else {
+            this._del_nd(p);
+            return [true,p]
+        }    
+    }
+    ////
+    _is_reachable_fr_to(src,dst) {
+        var unhandled = [];
+        for(var d of this.dns[src]) {
+            if(d=== dst) {
+                return true;
+            } else {
+                unhandled.push(d)
+            }
+        }
+        var next_unhandled = [];
+        while(unhandled.length>0) {
+            for(var s of unhandled) {
+                var dsts = this.dns[s];
+                for(var d of dsts) {
+                    if(d=== dst) {
+                        return true
+                    } else {
+                        next_unhandled.push(d)
+                    }
+                }
+            }
+            unhandled = next_unhandled;
+            next_unhandled = [];
+        }
+        return false;
+    }
+    is_reachable_fr_to(src,dst) {
+        if(this.has_nd(src)) {
+            if(this.has_nd(dst)) {
+                if(src !== dst) {
+                    return this. _is_reachable_fr_to(src,dst);
+                } else {
+                    return true;
+                }
+            } else {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
+    ////
+    _conn(src,dst) {
+        this.dns[src].add(dst);
+        this.ups[dst].add(src);
+    }
+    conn(src,dst) {
+        if(this.has_nd(src)) {
+            if(this.has_nd(dst)) {
+                if(this._is_reachable_fr_to(dst,src)) {
+                    return [false,`circular ${dst}->...->${src}`];
+                } else if(src === dst) {
+                    return [false, `${src} MUST be different  from${dst}`]
+                } else if(this.dns[src].has(dst)) {
+                    return [false, `${src}->${dst} already exist`]
+                } else {
+                    this._conn(src,dst);
+                    return [true,src,dst]
+                }
+            } else {
+                return [false,`first add_nd(${dst})`];
+            }
+        } else {
+            return [false,`fisrt add_nd(${src})`];
+        }
+    }
+    ////
+    get_reachable_fr(src) {
+        var st = new Set();
+        var unhandled = [];
+        for(var d of this.dns[src]) {
+            st.add(d);
+            unhandled.push(d)
+        }
+        var next_unhandled = [];
+        while(unhandled.length>0) {
+            for(var s of unhandled) {
+                var dsts = this.dns[s];
+                for(var d of dsts) {
+                    st.add(d);
+                    next_unhandled.push(d)
+                }
+            }
+            unhandled = next_unhandled;
+            unhandled = [];
+        }
+        return st;    
+    }
+    get_reachable_to(dst) {
+        var st = new Set();
+        var unhandled = [];
+        for(var s of this.ups[dst]) {
+            st.add(s);
+            unhandled.push(s)
+        }
+        var next_unhandled = [];
+        while(unhandled.length>0) {
+            for(var d of unhandled) {
+                var srcs = this.ups[d];
+                for(var s of srcs) {
+                    st.add(s);
+                    next_unhandled.push(s)
+                }
+            }
+            unhandled = next_unhandled;
+            unhandled = [];
+        }
+        return st;      
+    }
+    ////--------------------------------------------------------------------------------
+    add(...args) {
+        if(args.length ===0) {
+            return [false,`args.length MUST be 1 OR 2`];
+        } else if(args.length === 1) {
+            return this.add_nd(args[0]);
+        } else if(args.length === 2) {
+            var src = args[0];
+            var dst = args[1];
+            if(this.has_nd(src)) {} else {this.add_nd(src)}
+            if(this.has_nd(dst)) {} else {this.add_nd(dst)}
+            if(this._is_reachable_fr_to(dst,src)) {
+                return [false,`circular ${dst}->...->${src}`];
+            } else if(src === dst) {
+                return [false, `${src} MUST be different  from${dst}`]
+            } else if(this.dns[src].has(dst)) {
+                return [false, `${src}->${dst} already exist`]
+            } else {
+                this.conn(src,dst);
+                return [true,src,dst]
+            }
+        } else {
+            return [false,`args.length MUST be 1 OR 2`];
+        }
+    }
+    has(...args) {
+        if(args.length ===0) { 
+            return false;
+        } else if(args.length === 1) {  
+            return this.has_nd(args[0]);
+        } else if(args.length === 2) {
+            var src = args[0]; 
+            var dst = args[1];
+            if(this.has_nd(src)) {
+                if(this.has_nd(dst)) {
+                    return this.dns[src].has(dst);
+                } else {
+                    return false;
+                }
+            } else {
+                return false;
+            }
+        } else {
+            return false;
+        }     
+    }
+    del(...args) {
+        if(args.length ===0) {
+            return [false,`args.length MUST be 1 OR 2`];
+        } else if(args.length === 1) {
+            return this.del_nd(args[0]);
+        } else if(args.length === 2) {
+            var src = args[0];
+            var dst = args[1];
+            if(this.has_nd(src)) {
+                if(this.has_nd(dst)) {
+                    if(this.dns[src].has(dst)) {
+                        this.dns[src].delete(dst);
+                        this.ups[dst].delete(src);
+                        return [true,src,dst];
+                    } else {
+                        return [false,`edge ${src}->${dst} NOT exist`]
+                    }
+                } else {
+                    return [false,`${dst} NOT exist`];
+                }
+            } else {
+                return [false,`${src} NOT exist`];
+            }
+        } else {
+            return [false,`args.length MUST be 1 OR 2`];
+        }    
+    }
+    ////--------------------------------------------------------------------
+    get in0nds() {   
+        //入度为0的节点
+        var st = new Set();
+        for(var dst in this.ups) {
+            var ups = this.ups[dst];
+            if(ups.size === 0) {
+                st.add(dst);
+            }
+        }
+        return st;
+    }
+    get ot0nds() {
+        //出度为0的节点
+        var st = new Set();
+        for(var src in this.dns) {
+            var dns = this.dns[src];
+            if(dns.size === 0) {
+                st.add(src);
+            }
+        }
+        return st;
+    }
+    ////
+    clone() {
+        var ng = new G();  
+        for(var nd of this.nds) {ng.nds.add(nd)}
+        for(var src in this.dns) {
+            var st = new Set();
+            ng.dns[src] = st;
+            for(var dst of this.dns[src]) {
+                st.add(dst);
+            }
+        }
+        for(var dst in this.ups) {
+            var st = new Set();
+            ng.ups[dst] = st;
+            for(var src of this.ups[dst]) {
+                st.add(src);
+            }
+        }
+        return ng;
+    }
+    ////
+    show() {
+        if (this.nds.size === 0) {
+            console.log("(empty graph)");
+            return;
+        }
+        // 1. 打印所有节点
+        console.log("Nodes:");
+        for (let nd of this.nds) {
+            console.log(`  ${nd}`);
+        }
+
+        // 2. 打印所有边，按源节点分组
+        console.log("Edges:");
+        // 收集所有源节点并按字母顺序排序
+        let sources = Array.from(this.nds).filter(nd => this.dns[nd] && this.dns[nd].size > 0);
+        sources.sort();
+
+        for (let src of sources) {
+            let dsts = Array.from(this.dns[src]).sort();
+            for (let dst of dsts) {
+                console.log(`  ${src} -> ${dst}`);
+            }
+        }
+
+        // 3. 打印入度为 0 的节点（根）
+        let roots = Array.from(this.in0nds).sort();
+        console.log("Root nodes (in-degree 0):", roots.join(", ") || "(none)");
+
+        // 4. 打印出度为 0 的节点（叶子）
+        let leaves = Array.from(this.ot0nds).sort();
+        console.log("Leaf nodes (out-degree 0):", leaves.join(", ") || "(none)");    
+    }
+    ////
+    get_all_paths_fr(src) {
+        if(this.has_nd(src)) {
+            // 求出所有 从 src 可达 的路径
+            // 返回 Array<Array>
+            var paths = [];
+            var unhandled = [];
+            for(var d of this.dns[src]) {
+                paths.push([src,d]);
+                unhandled.push([src,d])
+            }
+            var next_unhandled = [];
+            while(unhandled.length>0) {  
+                for(var pl of unhandled) {
+                    var lst = pl[pl.length-1];
+                    for(var d of this.dns[lst]) {
+                        var npl = pl.slice(0);
+                        npl.push(d);
+                        paths.push(npl);
+                        next_unhandled.push(npl.slice(0))
+                    }
+                }
+                unhandled = next_unhandled;
+                next_unhandled = [];
+
+            }
+            return paths
+        } else {
+            return [];
+        }
+    }
+    get_all_paths_to(dst) {
+        if (this.has_nd(dst)) {
+            // 求出所有 能到达 dst 的路径（从某个起点到 dst）
+            // 返回 Array<Array>
+            var paths = [];
+            var unhandled = [];
+            // 从 dst 的直连上游开始
+            for (var u of this.ups[dst]) {
+                paths.push([u, dst]);
+                unhandled.push([u, dst]);
+            }
+            var next_unhandled = [];
+            while (unhandled.length > 0) {
+                for (var pl of unhandled) {
+                    var lst = pl[0]; // 路径的第一个节点（最上游端）
+                    for (var s of this.ups[lst]) { // 找 lst 的上游
+                        var npl = [s, ...pl]; // 在路径前端插入 s
+                        paths.push(npl);
+                        next_unhandled.push(npl.slice(0));
+                    }
+                }
+                unhandled = next_unhandled;
+                next_unhandled = [];
+            }
+            return paths;
+        } else {
+            return [];
+        }    
+    }
+    ////
+    get_all_paths_fr_to(src,dst) {
+        if (!this.has_nd(src) || !this.has_nd(dst)) return [];
+        if (src === dst) return [[src]];
+
+        var paths = [];
+        var unhandled = [];
+        // 初始化：从 src 的直连下游开始
+        for (var d of this.dns[src]) {
+            if (d === dst) {
+                paths.push([src, dst]);
+            } else {
+                unhandled.push([src, d]);
+            }
+        }
+
+        var next_unhandled = [];
+        while (unhandled.length > 0) {
+            for (var pl of unhandled) {
+                var last = pl[pl.length - 1];
+                for (var d of this.dns[last]) {
+                    if (d === dst) {
+                        // 到达终点，保存路径
+                        paths.push([...pl, d]);
+                    } else {
+                        // 未到终点，继续扩展
+                        next_unhandled.push([...pl, d]);
+                    }
+                }
+            }
+            unhandled = next_unhandled;
+            next_unhandled = [];
+        }
+
+        return paths;    
+    }
+    ////
+    del_all_iso_nds() {
+        //删除所有出度和入度均为0的节点
+        // 先收集所有孤立节点
+        const isolated = [];
+        for (const nd of this.nds) {
+            if (this.dns[nd].size === 0 && this.ups[nd].size === 0) {
+                isolated.push(nd);
+            }
+        }
+        // 再删除
+        for (const nd of isolated) {
+            this.del_nd(nd);
+        }
+        // 返回删除了多少个节点
+        return isolated.length;
+    }
+    ////
+}
+
+
+const  creat     = ()=>new G();
+const  sync_d2u_iter = (g,handle=(ndst,readonly_g)=>{}) =>{
+    var og = g;
+    g = g.clone();
+    while(true) {
+        var nds = g.ot0nds;
+        if(nds.size !== 0) {
+            handle(nds,og);
+            for(var nd of nds) {g.del_nd(nd)}
+        } else {
+            break;
+        }
+    }
+}
+const async_d2u_iter = async (g,handle=async(ndst,readonly_g)=>{}) => {
+    var og = g;
+    g = g.clone();
+    while(true) {
+        var nds = g.ot0nds;
+        if(nds.size !== 0) {
+            await handle(nds,og);
+            for(var nd of nds) {g.del_nd(nd)}
+        } else {        
+            break;              
+        }               
+    }                           
+}            
+
+const  sync_u2d_iter = (g,handle=(ndst,readonly_g)=>{})=> {
+    var og = g;
+    g = g.clone();
+    while(true) {
+        var nds = g.in0nds;
+        if(nds.size !== 0) {
+            handle(nds,og);
+            for(var nd of nds) {g.del_nd(nd)}
+        } else {
+            break;
+        }
+    }
+}
+const async_u2d_iter = async (g,handle=async(ndst,readonly_g)=>{})=> {
+    var og = g;
+    g = g.clone();
+    while(true) {
+        var nds = g.in0nds;
+        if(nds.size !== 0) {
+            await handle(nds,og);
+            for(var nd of nds) {g.del_nd(nd)}
+        } else {
+            break;
+        }
+    }
+}
+
+module.exports = {
+    creat,
+    sync_d2u_iter,
+    async_d2u_iter,
+    sync_u2d_iter,
+    async_u2d_iter,
+}

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "nv-dag-using-str-nd",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "description": ""
+}