data-structure-typed 1.50.2 → 1.50.4

package/test/unit/data-structures/graph/undirected-graph.test.ts

@@ -1,5 +1,5 @@
 import { UndirectedEdge, UndirectedGraph, UndirectedVertex } from '../../../../src';
-import saltyVertexes from './salty-vertexes.json';
+import saltyVertices from './salty-vertexes.json';
 import saltyEdges from './salty-edges.json';
 
 describe('UndirectedGraph Operation Test', () => {
@@ -17,7 +17,7 @@ describe('UndirectedGraph Operation Test', () => {
     expect(graph.getEndsOfEdge(new UndirectedEdge('c', 'd'))).toBe(undefined);
   });
 
-  it('should add vertexMap', () => {
+  it('should add vertices', () => {
     const vertex1 = new UndirectedVertex('A');
     const vertex2 = new UndirectedVertex('B');
 
@@ -76,8 +76,8 @@ describe('UndirectedGraph', () => {
     undirectedGraph = new UndirectedGraph<string, string>();
   });
 
-  // Test adding vertexMap to the graph
-  it('should add vertexMap to the graph', () => {
+  // Test adding vertices to the graph
+  it('should add vertices to the graph', () => {
     const vertexA = new UndirectedVertex('A', 'Location A');
     const vertexB = new UndirectedVertex('B', 'Location B');
 
@@ -130,7 +130,7 @@ describe('UndirectedGraph', () => {
     const edgeAB = new UndirectedEdge('A', 'B', 3, 'Edge between A and B');
     const edgeBC = new UndirectedEdge('B', 'C', 4, 'Edge between B and C');
 
-    edgeAB.vertexMap = edgeAB.vertexMap;
+    edgeAB.endpoints = edgeAB.endpoints;
     expect(undirectedGraph.edgeMap.size).toBe(0);
     undirectedGraph.addVertex(vertexA);
     undirectedGraph.addVertex(vertexB);
@@ -151,7 +151,7 @@ describe('UndirectedGraph', () => {
 
   it('should getAllPathsBetween work well in 66 vertexes 97 edges graph', () => {
     const graph = new UndirectedGraph<{ name: string }, number>();
-    for (const v of saltyVertexes) {
+    for (const v of saltyVertices) {
       graph.addVertex(v.name, v);
     }
     for (const e of saltyEdges) {
@@ -181,16 +181,16 @@ describe('UndirectedGraph', () => {
     dg.addVertex('hey');
     dg.addEdge('hello', 'hi');
     dg.addEdge('hello', 'hey');
-    expect(dg.getEdge('hello', 'hi')?.vertexMap[0]).toBe('hello');
-    expect(dg.getEdge('hello', 'hi')?.vertexMap[1]).toBe('hi');
-    expect(dg.getEdge('hello', 'hey')?.vertexMap[0]).toBe('hello');
-    expect(dg.getEdge('hello', 'hey')?.vertexMap[1]).toBe('hey');
+    expect(dg.getEdge('hello', 'hi')?.endpoints[0]).toBe('hello');
+    expect(dg.getEdge('hello', 'hi')?.endpoints[1]).toBe('hi');
+    expect(dg.getEdge('hello', 'hey')?.endpoints[0]).toBe('hello');
+    expect(dg.getEdge('hello', 'hey')?.endpoints[1]).toBe('hey');
     dg.deleteEdge('hello', 'hi');
     expect(dg.getEdge('hello', 'hi')).toBe(undefined);
     expect(dg.getEdge('hello', 'hey')).toBeInstanceOf(UndirectedEdge);
   });
 
-  test('Removing a vertex of a DirectedGraph should delete additional edges', () => {
+  test('Removing a vertex of a UndirectedGraph should delete additional edges', () => {
     const graph = new UndirectedGraph();
 
     graph.addVertex('Hello');
@@ -212,13 +212,13 @@ describe('UndirectedGraph', () => {
     dg.addEdge('hello', 'earth');
     dg.addEdge('world', 'earth');
 
-    expect(dg.getEdge('hello', 'world')?.vertexMap[0]).toBe('hello');
+    expect(dg.getEdge('hello', 'world')?.endpoints[0]).toBe('hello');
     expect(dg.edgeSet().length).toBe(3);
-    expect(dg.edgeSet()[0].vertexMap).toEqual(['hello', 'world']);
+    expect(dg.edgeSet()[0].endpoints).toEqual(['hello', 'world']);
 
     dg.deleteVertex('hello');
     expect(dg.edgeSet().length).toBe(1);
-    expect(dg.edgeSet()?.[0].vertexMap[0]).toBe('world');
+    expect(dg.edgeSet()?.[0].endpoints[0]).toBe('world');
 
     expect(dg.getEdge('hello', 'world')).toBe(undefined);
   });
@@ -244,15 +244,15 @@ describe('cycles, strongly connected components, bridges, articular points in Un
   graph.addEdge('E', 'H');
   graph.addEdge('H', 'F');
   const cycles = graph.getCycles();
-  const scCs = graph.getSCCs();
+  // const cCs = graph.getCCs();
   const bridges = graph.getBridges();
-  const cutVertexes = graph.getCutVertexes();
+  const cutVertices = graph.getCutVertices();
   const dfnMap = graph.getDFNMap();
   const lowMap = graph.getLowMap();
   expect(cycles.length).toBe(3);
-  expect(scCs.size).toBe(5);
+  // expect(cCs.size).toBe(5);
   expect(bridges.length).toBe(4);
-  expect(cutVertexes.length).toBe(4);
+  expect(cutVertices.length).toBe(4);
   expect(dfnMap.size).toBe(8);
   expect(lowMap.size).toBe(8);
 });
@@ -356,3 +356,248 @@ describe('UndirectedGraph getCycles', () => {
     ]);
   });
 });
+
+describe('UndirectedGraph tarjan', () => {
+  test('should simple cycles graph tarjan cycles return correct result', () => {
+    const graph = new UndirectedGraph();
+
+    graph.addVertex('A');
+    graph.addVertex('B');
+    graph.addVertex('C');
+    graph.addVertex('D');
+
+    graph.addEdge('A', 'B');
+    graph.addEdge('B', 'C');
+    graph.addEdge('C', 'A');
+    graph.addEdge('A', 'D');
+    graph.addEdge('D', 'C');
+    const cycles = graph.getCycles();
+    expect(cycles.length).toBe(3);
+    expect(cycles).toEqual([
+      ['A', 'B', 'C'],
+      ['A', 'B', 'C', 'D'],
+      ['A', 'C', 'D']
+    ]);
+  });
+
+  function createExampleGraph1() {
+    const graph = new UndirectedGraph();
+    graph.addVertex('A');
+    graph.addVertex('B');
+    graph.addVertex('C');
+    graph.addVertex('D');
+    graph.addVertex('E');
+    graph.addEdge('A', 'B');
+    graph.addEdge('A', 'C');
+    graph.addEdge('B', 'D');
+    graph.addEdge('C', 'D');
+    graph.addEdge('D', 'E');
+    graph.addEdge('E', 'B');
+    return graph;
+  }
+
+  test('should tarjan cut vertexes return correct result', () => {
+    const graph = createExampleGraph1();
+    const cutVertices = graph.tarjan().cutVertices;
+    expect(cutVertices.length).toBe(0);
+  });
+
+  test('should tarjan bridges return correct result', () => {
+    const graph = createExampleGraph1();
+    const bridges = graph.tarjan().bridges;
+    expect(bridges.length).toBe(0);
+  });
+
+  test('should 3 cycles graph tarjan cut vertexes return correct result', () => {
+    const graph = createExampleGraph1();
+    const cutVertices = graph.tarjan().cutVertices;
+    expect(cutVertices.length).toBe(0);
+  });
+
+  test('should 3 cycles graph tarjan bridges return correct result', () => {
+    const graph = createExampleGraph1();
+    const bridges = graph.tarjan().bridges;
+    expect(bridges.length).toBe(0);
+  });
+
+  test('should cuttable graph tarjan cut vertexes return correct result', () => {
+    const graph = createExampleGraph3();
+    const cutVertices = graph.tarjan().cutVertices;
+    expect(cutVertices.length).toBe(3);
+    expect(cutVertices.map(cv => cv.key)).toEqual(['B', 'E', 'A']);
+  });
+
+  test('should cuttable graph tarjan bridges return correct result', () => {
+    const graph = createExampleGraph3();
+    const bridges = graph.tarjan().bridges;
+    expect(bridges.length).toBe(2);
+    expect(bridges.map(edge => edge.endpoints)).toEqual([
+      ['A', 'B'],
+      ['A', 'E']
+    ]);
+  });
+
+  test('should more cuttable graph tarjan cut vertexes return correct result', () => {
+    const graph = createExampleGraph4();
+    const cutVertices = graph.tarjan().cutVertices;
+    expect(cutVertices.length).toBe(4);
+    expect(cutVertices.map(cv => cv.key)).toEqual(['H', 'B', 'E', 'A']);
+  });
+
+  test('should more cuttable graph tarjan bridges return correct result', () => {
+    const graph = createExampleGraph4();
+    const bridges = graph.tarjan().bridges;
+    expect(bridges.length).toBe(2);
+    expect(bridges.map(edge => edge.endpoints)).toEqual([
+      ['A', 'B'],
+      ['A', 'E']
+    ]);
+  });
+
+  test('should uncuttable graph tarjan cut vertexes return correct result', () => {
+    const graph = createExampleGraph5();
+    const cutVertices = graph.tarjan().cutVertices;
+    expect(cutVertices.length).toBe(1);
+  });
+
+  test('should uncuttable graph tarjan bridges return correct result', () => {
+    const graph = createExampleGraph5();
+    const bridges = graph.tarjan().bridges;
+    expect(bridges.length).toBe(0);
+  });
+
+  function createExampleGraph2() {
+    const graph = createExampleGraph1();
+    graph.addVertex('F');
+    graph.addVertex('G');
+    graph.addEdge('B', 'F');
+    graph.addEdge('F', 'E');
+    graph.addEdge('C', 'G');
+    graph.addEdge('G', 'A');
+    return graph;
+  }
+
+  test('should 3 cycles graph tarjan cycles return correct result', () => {
+    const graph = createExampleGraph2();
+    const cycles = graph.getCycles();
+    expect(cycles.length).toBe(10);
+    expect(cycles).toEqual([
+      ['A', 'B', 'D', 'C'],
+      ['A', 'B', 'D', 'C', 'G'],
+      ['A', 'B', 'E', 'D', 'C'],
+      ['A', 'B', 'E', 'D', 'C', 'G'],
+      ['A', 'B', 'F', 'E', 'D', 'C'],
+      ['A', 'B', 'F', 'E', 'D', 'C', 'G'],
+      ['A', 'C', 'G'],
+      ['B', 'D', 'E'],
+      ['B', 'D', 'E', 'F'],
+      ['B', 'E', 'F']
+    ]);
+  });
+
+  function createExampleGraph3() {
+    const graph = new UndirectedGraph();
+    graph.addVertex('A');
+    graph.addVertex('B');
+    graph.addVertex('C');
+    graph.addVertex('D');
+    graph.addVertex('E');
+    graph.addVertex('F');
+    graph.addVertex('G');
+    graph.addEdge('A', 'B');
+    graph.addEdge('B', 'C');
+    graph.addEdge('C', 'D');
+    graph.addEdge('D', 'B');
+    graph.addEdge('A', 'E');
+    graph.addEdge('E', 'F');
+    graph.addEdge('F', 'G');
+    graph.addEdge('G', 'E');
+    return graph;
+  }
+
+  test('should cuttable graph tarjan cycles return correct result', () => {
+    const graph = createExampleGraph3();
+    const cycles = graph.getCycles();
+    expect(cycles.length).toBe(2);
+    expect(cycles).toEqual([
+      ['B', 'C', 'D'],
+      ['E', 'F', 'G']
+    ]);
+  });
+
+  // test('should cuttable graph tarjan CCs return correct result', () => {
+  // const graph = createExampleGraph3();
+  // const ccs = graph.tarjan().CCs;
+  // expect(ccs.size).toBe(3);
+  // expect(getAsVerticesArrays(ccs)).toEqual([["D", "C", "B"], ["G", "F", "E"], ["A"]]);
+  // });
+
+  function createExampleGraph4() {
+    const graph = createExampleGraph3();
+    graph.addVertex('H');
+    graph.addVertex('I');
+    graph.addVertex('J');
+    graph.addVertex('K');
+    graph.addEdge('C', 'H');
+    graph.addEdge('H', 'I');
+    graph.addEdge('I', 'D');
+    graph.addEdge('H', 'J');
+    graph.addEdge('J', 'K');
+    graph.addEdge('K', 'H');
+    return graph;
+  }
+
+  test('should more cuttable graph tarjan cycles return correct result', () => {
+    const graph = createExampleGraph4();
+    const cycles = graph.getCycles();
+    expect(cycles.length).toBe(5);
+    expect(cycles).toEqual([
+      ['B', 'C', 'D'],
+      ['B', 'C', 'H', 'I', 'D'],
+      ['C', 'D', 'I', 'H'],
+      ['E', 'F', 'G'],
+      ['H', 'J', 'K']
+    ]);
+  });
+
+  // test('should more cuttable graph tarjan SCCs return correct result', () => {
+  //   const graph = createExampleGraph4();
+  //   const ccs = graph.tarjan().CCs;
+  //   expect(ccs.size).toBe(3);
+  //   expect(getAsVerticesArrays(ccs)).toEqual([["K", "J", "I", "H", "D", "C", "B"], ["G", "F", "E"], ["A"]]);
+  // });
+
+  function createExampleGraph5() {
+    const graph = createExampleGraph4();
+    graph.addEdge('F', 'H');
+    return graph;
+  }
+
+  test('should uncuttable graph tarjan cycles return correct result', () => {
+    const graph = createExampleGraph5();
+    const cycles = graph.getCycles();
+    expect(cycles.length).toBe(13);
+    expect(cycles).toEqual([
+      ['A', 'B', 'C', 'D', 'I', 'H', 'F', 'E'],
+      ['A', 'B', 'C', 'D', 'I', 'H', 'F', 'G', 'E'],
+      ['A', 'B', 'C', 'H', 'F', 'E'],
+      ['A', 'B', 'C', 'H', 'F', 'G', 'E'],
+      ['A', 'B', 'D', 'C', 'H', 'F', 'E'],
+      ['A', 'B', 'D', 'C', 'H', 'F', 'G', 'E'],
+      ['A', 'B', 'D', 'I', 'H', 'F', 'E'],
+      ['A', 'B', 'D', 'I', 'H', 'F', 'G', 'E'],
+      ['B', 'C', 'D'],
+      ['B', 'C', 'H', 'I', 'D'],
+      ['C', 'D', 'I', 'H'],
+      ['E', 'F', 'G'],
+      ['H', 'J', 'K']
+    ]);
+  });
+
+  // test('should uncuttable graph tarjan SCCs return correct result', () => {
+  //   const graph = createExampleGraph5();
+  //   const ccs = graph.tarjan().CCs;
+  //   expect(ccs.size).toBe(3);
+  //   expect(getAsVerticesArrays(ccs)).toEqual([["K", "J", "I", "H", "D", "C", "B"], ["G", "F", "E"], ["A"]]);
+  // });
+});

package/test/unit/data-structures/queue/queue.test.ts

@@ -104,6 +104,8 @@ describe('Queue', () => {
     expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
     queue.delete('5');
     expect([...queue]).toEqual(['1', '6', '0', '9']);
+    queue.deleteAt(2);
+    expect([...queue]).toEqual(['1', '6', '9']);
     expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
   });
 });

package/test/unit/unrestricted-interconversion.test.ts

@@ -14,7 +14,7 @@ import {
   RedBlackTree,
   SinglyLinkedList,
   Stack,
-  TreeMultimap,
+  TreeMultiMap,
   Trie
 } from '../../src';
 import { isDebugTest } from '../config';
@@ -167,8 +167,8 @@ describe('conversions', () => {
     ]);
   });
 
-  it('Entry Array to TreeMultimap', () => {
-    const treeMulti = new TreeMultimap<number>(entries);
+  it('Entry Array to TreeMultiMap', () => {
+    const treeMulti = new TreeMultiMap<number>(entries);
     expect(treeMulti.size).toBe(9);
     isDebug && treeMulti.print();
     expect([...treeMulti]).toEqual([

package/dist/cjs/data-structures/binary-tree/tree-multimap.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tree-multimap.js","sourceRoot":"","sources":["../../../../src/data-structures/binary-tree/tree-multimap.ts"],"names":[],"mappings":"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"}

package/dist/cjs/types/data-structures/binary-tree/tree-multimap.d.ts

@@ -1,5 +0,0 @@
-import { TreeMultimap, TreeMultimapNode } from '../../../data-structures';
-import type { AVLTreeOptions } from './avl-tree';
-export type TreeMultimapNodeNested<K, V> = TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type TreeMultimapNested<K, V, N extends TreeMultimapNode<K, V, N>> = TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type TreeMultimapOptions<K> = AVLTreeOptions<K> & {};

package/dist/cjs/types/data-structures/binary-tree/tree-multimap.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tree-multimap.js","sourceRoot":"","sources":["../../../../../src/types/data-structures/binary-tree/tree-multimap.ts"],"names":[],"mappings":""}

package/dist/mjs/types/data-structures/binary-tree/tree-multimap.d.ts

@@ -1,5 +0,0 @@
-import { TreeMultimap, TreeMultimapNode } from '../../../data-structures';
-import type { AVLTreeOptions } from './avl-tree';
-export type TreeMultimapNodeNested<K, V> = TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type TreeMultimapNested<K, V, N extends TreeMultimapNode<K, V, N>> = TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type TreeMultimapOptions<K> = AVLTreeOptions<K> & {};

package/src/types/data-structures/binary-tree/tree-multimap.ts

@@ -1,8 +0,0 @@
-import { TreeMultimap, TreeMultimapNode } from '../../../data-structures';
-import type { AVLTreeOptions } from './avl-tree';
-
-export type TreeMultimapNodeNested<K, V> = TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
-
-export type TreeMultimapNested<K, V, N extends TreeMultimapNode<K, V, N>> = TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
-
-export type TreeMultimapOptions<K> = AVLTreeOptions<K> & {}