data-structure-typed 1.41.3 → 1.41.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.41.3",
+  "version": "1.41.5",
   "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
@@ -31,9 +31,9 @@
     "reformat": "npm run reformat:src && npm run reformat:test",
     "update:subs": "npm i avl-tree-typed binary-tree-typed bst-typed heap-typed --save-dev",
     "install:all-subs": "npm i avl-tree-typed binary-tree-typed bst-typed deque-typed directed-graph-typed doubly-linked-list-typed graph-typed heap-typed linked-list-typed max-heap-typed max-priority-queue-typed min-heap-typed min-priority-queue-typed priority-queue-typed singly-linked-list-typed stack-typed tree-multiset-typed trie-typed undirected-graph-typed queue-typed --save-dev",
-    "test": "jest",
+    "test": "jest --runInBand",
     "test:integration": "npm run update:subs && jest --config jest.integration.config.js",
-    "benchmark": "ts-node test/performance/index.ts",
+    "benchmark": "ts-node test/performance/reportor.ts",
     "check:deps": "dependency-cruiser src",
     "changelog": "auto-changelog",
     "coverage:badge": "istanbul-badges-readme",
@@ -41,7 +41,7 @@
     "copy:to-subs": "sh scripts/copy_to_all_subs.sh",
     "publish:subs": "npm run copy:to-subs && sh scripts/publish_all_subs.sh",
     "publish:docs": "sh scripts/publish_docs.sh",
-    "publish:all": "npm run ci && npm publish && npm run publish:docs && npm run publish:subs"
+    "publish:all": "npm run ci && npm run benchmark && npm publish && npm run publish:docs && npm run publish:subs"
   },
   "repository": {
     "type": "git",
@@ -60,6 +60,7 @@
     "@types/benchmark": "^2.1.3",
     "@types/jest": "^29.5.5",
     "@types/node": "^20.8.2",
+    "@types/underscore": "^1.11.12",
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
@@ -132,9 +133,12 @@
     "UMD",
     "esmodule",
     "java.util",
+    "c++ stl",
     "c++ std",
     "Python collections",
     "System.Collections.Generic",
+    "STL",
+    "stl",
     "STD",
     "std",
     "util",

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

@@ -179,7 +179,10 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
       while (queue.size > 0) {
         const cur = queue.shift();
         if (cur) {
-          if (newNode && cur.key === newNode.key) return;
+          if (newNode && cur.key === newNode.key) {
+            cur.value = newNode.value;
+            return;
+          }
           const inserted = this._addTo(newNode, cur);
           if (inserted !== undefined) return inserted;
           if (cur.left) queue.push(cur.left);
@@ -201,16 +204,16 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
       return;
     }
 
-    const key = typeof keyOrNode === 'number' ? keyOrNode : keyOrNode ? keyOrNode.key : undefined;
-    const existNode = key !== undefined ? this.getNode(key, (node: N) => node.key) : undefined;
+    // const key = typeof keyOrNode === 'number' ? keyOrNode : keyOrNode ? keyOrNode.key : undefined;
+    // const existNode = key !== undefined ? this.getNode(key, (node: N) => node.key) : undefined;
 
     if (this.root) {
-      if (existNode) {
-        existNode.value = value;
-        inserted = existNode;
-      } else {
-        inserted = _bfs(this.root, needInsert);
-      }
+      // if (existNode) {
+      //   existNode.value = value;
+      //   inserted = existNode;
+      // } else {
+      inserted = _bfs(this.root, needInsert);
+      // }
     } else {
       this._setRoot(needInsert);
       if (needInsert !== null) {

package/test/config.ts

@@ -1 +1 @@
-export const isDebugTest = true;
+export const isDebugTest = false;

package/test/performance/data-structures/binary-tree/avl-tree.test.ts

@@ -0,0 +1,36 @@
+import {AVLTree} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {getRandomIntArray, magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const avl = new AVLTree<number>();
+const {N_LOG_N} = magnitude;
+const arr = getRandomIntArray(N_LOG_N, 0, N_LOG_N, true);
+
+suite
+  .add(`${N_LOG_N} add randomly`, () => {
+    avl.clear();
+    for (let i = 0; i < arr.length; i++) {
+      avl.add(arr[i]);
+    }
+  })
+  .add(`${N_LOG_N} add & delete randomly`, () => {
+    avl.clear();
+    for (let i = 0; i < arr.length; i++) {
+      avl.add(arr[i]);
+    }
+    for (let i = 0; i < arr.length; i++) {
+      avl.delete(arr[i]);
+    }
+  })
+  .add(`${N_LOG_N} addMany`, () => {
+    avl.clear();
+    avl.addMany(arr);
+  })
+  .add(`${N_LOG_N} get`, () => {
+    for (let i = 0; i < arr.length; i++) {
+      avl.get(arr[i]);
+    }
+  });
+
+export {suite};

package/test/performance/data-structures/binary-tree/binary-tree.test.ts

@@ -0,0 +1,45 @@
+import {BinaryTree} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {getRandomIntArray, magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const biTree = new BinaryTree<number>();
+const {N_LOG_N} = magnitude;
+const arr = getRandomIntArray(N_LOG_N, 0, N_LOG_N, true);
+
+suite
+  .add(`${N_LOG_N} add randomly`, () => {
+    biTree.clear();
+    for (let i = 0; i < arr.length; i++) {
+      biTree.add(arr[i]);
+    }
+  })
+  .add(`${N_LOG_N} add & delete randomly`, () => {
+    biTree.clear();
+    for (let i = 0; i < arr.length; i++) {
+      biTree.add(arr[i]);
+    }
+    for (let i = 0; i < arr.length; i++) {
+      biTree.delete(arr[i]);
+    }
+  })
+  .add(`${N_LOG_N} addMany`, () => {
+    biTree.clear();
+    biTree.addMany(arr);
+  })
+  .add(`${N_LOG_N} get`, () => {
+    for (let i = 0; i < arr.length; i++) {
+      biTree.get(arr[i]);
+    }
+  })
+  .add(`${N_LOG_N} dfs`, () => {
+    for (let i = 0; i < N_LOG_N; i++) biTree.dfs();
+  })
+  .add(`${N_LOG_N} bfs`, () => {
+    for (let i = 0; i < N_LOG_N; i++) biTree.bfs();
+  })
+  .add(`${N_LOG_N} morris`, () => {
+    for (let i = 0; i < N_LOG_N; i++) biTree.morris(n => n, 'pre');
+  });
+
+export {suite};

package/test/performance/data-structures/binary-tree/bst.test.ts

@@ -0,0 +1,36 @@
+import {BST} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {getRandomIntArray, magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const bst = new BST<number>();
+const {N_LOG_N} = magnitude;
+const arr = getRandomIntArray(N_LOG_N, 0, N_LOG_N, true);
+
+suite
+  .add(`${N_LOG_N} add randomly`, () => {
+    bst.clear();
+    for (let i = 0; i < arr.length; i++) {
+      bst.add(arr[i]);
+    }
+  })
+  .add(`${N_LOG_N} add & delete randomly`, () => {
+    bst.clear();
+    for (let i = 0; i < arr.length; i++) {
+      bst.add(arr[i]);
+    }
+    for (let i = 0; i < arr.length; i++) {
+      bst.delete(arr[i]);
+    }
+  })
+  .add(`${N_LOG_N} addMany`, () => {
+    bst.clear();
+    bst.addMany(arr);
+  })
+  .add(`${N_LOG_N} get`, () => {
+    for (let i = 0; i < arr.length; i++) {
+      bst.get(arr[i]);
+    }
+  });
+
+export {suite};

package/test/performance/data-structures/graph/directed-graph.test.ts

@@ -0,0 +1,49 @@
+import {DirectedGraph} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {getRandomIndex, getRandomWords, magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const {THOUSAND} = magnitude;
+const graph = new DirectedGraph<number, number>();
+const vertexes = getRandomWords(THOUSAND);
+
+suite
+  .add(`${THOUSAND} addVertex`, () => {
+    for (const v of vertexes) {
+      graph.addVertex(v);
+    }
+  })
+  .add(`${THOUSAND} addEdge`, () => {
+    for (let i = 0; i < THOUSAND; i++) {
+      const v1 = vertexes[getRandomIndex(vertexes)];
+      const v2 = vertexes[getRandomIndex(vertexes)];
+      graph.addEdge(v1, v2);
+    }
+  })
+  .add(`${THOUSAND} getVertex`, () => {
+    for (let i = 0; i < THOUSAND; i++) {
+      graph.getVertex(vertexes[getRandomIndex(vertexes)]);
+    }
+  })
+  .add(`${THOUSAND} getEdge`, () => {
+    for (let i = 0; i < THOUSAND; i++) {
+      graph.getEdge(vertexes[getRandomIndex(vertexes)], vertexes[getRandomIndex(vertexes)]);
+    }
+  })
+  .add(`tarjan`, () => {
+    // for (let i = 0; i < THOUSAND; i++) {
+    graph.tarjan(true);
+    // }
+  })
+  .add(`tarjan all`, () => {
+    // for (let i = 0; i < THOUSAND; i++) {
+    graph.tarjan(true, true, true, true);
+    // }
+  })
+  .add(`topologicalSort`, () => {
+    // for (let i = 0; i < THOUSAND; i++) {
+    graph.topologicalSort('key');
+    // }
+  });
+
+export {suite};

package/test/performance/data-structures/heap/heap.test.ts

@@ -0,0 +1,30 @@
+import {FibonacciHeap, Heap} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const {N_LOG_N} = magnitude;
+
+suite
+  .add(`${N_LOG_N} add & pop`, () => {
+    const heap = new Heap<number>({comparator: (a, b) => b - a});
+
+    for (let i = 0; i < N_LOG_N; i++) {
+      heap.add(i);
+    }
+
+    for (let i = 0; i < N_LOG_N; i++) {
+      heap.pop();
+    }
+  })
+  .add(`${N_LOG_N} fib add & pop`, () => {
+    const fbHeap = new FibonacciHeap<number>();
+    for (let i = 1; i <= N_LOG_N; i++) {
+      fbHeap.push(i);
+    }
+    for (let i = 1; i <= N_LOG_N; i++) {
+      fbHeap.pop();
+    }
+  });
+
+export {suite};

package/test/performance/data-structures/linked-list/doubly-linked-list.test.ts

@@ -0,0 +1,40 @@
+import {DoublyLinkedList, DoublyLinkedListNode} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const {LINEAR, N_LOG_N} = magnitude;
+
+suite
+  .add(`${LINEAR} unshift`, () => {
+    const list = new DoublyLinkedList<number>();
+
+    for (let i = 0; i < LINEAR; i++) {
+      list.unshift(i);
+    }
+  })
+  .add(`${LINEAR} unshift & shift`, () => {
+    const list = new DoublyLinkedList<number>();
+
+    for (let i = 0; i < LINEAR; i++) {
+      list.unshift(i);
+    }
+    for (let i = 0; i < LINEAR; i++) {
+      list.shift();
+    }
+  })
+  .add(`${N_LOG_N} insertBefore`, () => {
+    const doublyList = new DoublyLinkedList<number>();
+    let midNode: DoublyLinkedListNode | null = null;
+    const midIndex = Math.floor(N_LOG_N / 2);
+    for (let i = 0; i < N_LOG_N; i++) {
+      doublyList.push(i);
+      if (i === midIndex) {
+        midNode = doublyList.getNode(i);
+      } else if (i > midIndex && midNode) {
+        doublyList.insertBefore(midNode, i);
+      }
+    }
+  });
+
+export {suite};

package/test/performance/data-structures/linked-list/singly-linked-list.test.ts

@@ -0,0 +1,34 @@
+import {SinglyLinkedList, SinglyLinkedListNode} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const {N_LOG_N} = magnitude;
+
+suite
+  .add(`${N_LOG_N} push & pop`, () => {
+    const list = new SinglyLinkedList<number>();
+
+    for (let i = 0; i < N_LOG_N; i++) {
+      list.push(i);
+    }
+
+    for (let i = 0; i < N_LOG_N; i++) {
+      list.pop();
+    }
+  })
+  .add(`${N_LOG_N} insertBefore`, () => {
+    const singlyList = new SinglyLinkedList<number>();
+    let midSinglyNode: SinglyLinkedListNode | null = null;
+    const midIndex = Math.floor(N_LOG_N / 2);
+    for (let i = 0; i < N_LOG_N; i++) {
+      singlyList.push(i);
+      if (i === midIndex) {
+        midSinglyNode = singlyList.getNode(i);
+      } else if (i > midIndex && midSinglyNode) {
+        singlyList.insertBefore(midSinglyNode.value, i);
+      }
+    }
+  });
+
+export {suite};

package/test/performance/data-structures/priority-queue/max-priority-queue.test.ts

@@ -0,0 +1,19 @@
+import {MaxPriorityQueue} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const {TEN_THOUSAND} = magnitude;
+
+suite.add(`${TEN_THOUSAND} refill & poll`, () => {
+  const nodes = Array.from(
+    new Set<number>(Array.from(new Array(TEN_THOUSAND), () => Math.floor(Math.random() * TEN_THOUSAND * 100)))
+  );
+  const maxPQ = new MaxPriorityQueue<number>();
+  maxPQ.refill(nodes);
+  while (maxPQ.size > 0) {
+    maxPQ.poll();
+  }
+});
+
+export {suite};

package/test/performance/data-structures/queue/deque.test.ts

@@ -1,19 +1,21 @@
-import {Deque} from "../../../../src";
+import {Deque} from '../../../../src';
 import * as Benchmark from 'benchmark';
+import {magnitude} from '../../../utils';
 
 export const suite = new Benchmark.Suite();
+const {LINEAR} = magnitude;
 
 suite
-  .add('push', () => {
+  .add(`${LINEAR} push`, () => {
     const deque = new Deque<number>();
-    for (let i = 0; i < 10; i++) {
+    for (let i = 0; i < LINEAR; i++) {
       deque.push(i);
     }
   })
-  .add('shift', () => {
+  .add(`${LINEAR} shift`, () => {
     const deque = new Deque<number>();
-    for (let i = 0; i < 10; i++) {
+    for (let i = 0; i < LINEAR; i++) {
       deque.push(i);
       deque.shift();
     }
-  })
+  });

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

@@ -1,20 +1,25 @@
-import {Queue} from "../../../../src";
-
+import {Queue} from '../../../../src';
 import * as Benchmark from 'benchmark';
+import {magnitude} from '../../../utils';
 
-export const suite = new Benchmark.Suite();
+const suite = new Benchmark.Suite();
+const {LINEAR} = magnitude;
 
 suite
-  .add('push', () => {
+  .add(`${LINEAR} push`, () => {
     const queue = new Queue<number>();
-    for (let i = 0; i < 1000000; i++) {
+
+    for (let i = 0; i < LINEAR; i++) {
       queue.push(i);
     }
   })
-  // .add('shift', () => {
-  //   const queue = new Queue<number>();
-  //   for (let i = 0; i < 10000; i++) {
-  //     queue.push(i);
-  //     queue.shift();
-  //   }
-  // })
+  .add(`${LINEAR} push & shift`, () => {
+    const queue = new Queue<number>();
+
+    for (let i = 0; i < LINEAR; i++) {
+      queue.push(i);
+      queue.shift();
+    }
+  });
+
+export {suite};

package/test/performance/data-structures/trie/trie.test.ts

@@ -0,0 +1,22 @@
+import {Trie} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {getRandomWords, magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const {HUNDRED_THOUSAND} = magnitude;
+const trie = new Trie();
+const randomWords = getRandomWords(HUNDRED_THOUSAND, false);
+
+suite
+  .add(`${HUNDRED_THOUSAND} push`, () => {
+    for (let i = 0; i < randomWords.length; i++) {
+      trie.add(randomWords[i]);
+    }
+  })
+  .add(`${HUNDRED_THOUSAND} getWords`, () => {
+    for (let i = 0; i < randomWords.length; i++) {
+      trie.getWords(randomWords[i]);
+    }
+  });
+
+export {suite};

package/test/performance/reportor.ts

@@ -0,0 +1,183 @@
+import * as Benchmark from 'benchmark';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as fastGlob from 'fast-glob';
+import {Color, numberFix, render} from '../utils';
+import {PerformanceTest} from './types';
+
+const reportDistPath = 'benchmark';
+const testDir = path.join(__dirname, 'data-structures');
+const testFiles = fastGlob.sync(path.join(testDir, '**', '*.test.ts'));
+
+const report: {[key: string]: any} = {};
+
+let completedCount = 0;
+
+const performanceTests: PerformanceTest[] = [];
+const {GREEN, BOLD, END, YELLOW, GRAY, CYAN, BG_YELLOW} = Color;
+
+testFiles.forEach((file: string) => {
+  const testName = path.basename(file, '.test.ts');
+  const testFunction = require(file);
+  const {suite} = testFunction;
+  if (suite) performanceTests.push({testName, suite, file});
+});
+
+const composeReport = () => {
+  if (!fs.existsSync(reportDistPath)) fs.mkdirSync(reportDistPath, {recursive: true});
+
+  const filePath = path.join(reportDistPath, 'report.json');
+  const htmlFilePath = path.join(reportDistPath, 'report.html');
+  fs.writeFileSync(filePath, JSON.stringify(report, null, 2));
+  let html = `<!DOCTYPE html>
+                        <html lang="en">
+                        <head>
+                          <meta charset="UTF-8">
+                          <title>performance of data-structure-typed</title>
+                          <style>
+                          *{
+                          box-sizing: border-box;
+                          }
+                                #json-to-html {
+                                padding: 0 10px 20px;
+                                }
+                                
+                                .json-to-html-label {
+                                    font-size: 2rem;
+                                    margin: 2rem 0 0 3px;
+                                }
+                               .content table {
+                                  width: 100%;
+                                  table-layout: fixed;
+                                  border-collapse: collapse;
+                                  margin-top: 10px;
+                                  font-size: 16px;
+                                }
+                            
+                                .content table th,
+                                .content table td {
+                                  padding: 8px 12px;
+                                  text-align: left;
+                                  border: 1px solid #ddd;
+                                }
+                            
+                                .content table th {
+                                  background-color: #f2f2f2;
+                                  font-weight: bold;
+                                }
+                            
+                                .content table tr:nth-child(odd) {
+                                  background-color: #ffffff;
+                                }
+                            </style>
+                        </head>
+                        <body>
+                        <div id="json-to-html">`;
+  let htmlTables = '';
+  for (const r in report) {
+    if (report.hasOwnProperty(r)) {
+      htmlTables += render(report[r].testName, report[r].benchmarks, {
+        plainHtml: true,
+        '<>': 'table',
+        html: [
+          {
+            '<>': 'tr',
+            html: [
+              {'<>': 'td', html: '${name}'},
+              {'<>': 'td', html: '${periodMS}'},
+              {'<>': 'td', html: '${mean}'}
+            ]
+          }
+        ]
+      });
+    }
+  }
+  html += htmlTables;
+  html += `</div>
+                    </body>
+                  </html>`;
+  writeIntoMarkdown(htmlTables);
+  fs.writeFileSync(htmlFilePath, html);
+  console.log(`Performance ${BOLD}${GREEN}report${END} file generated`);
+};
+
+function writeIntoMarkdown(html: string) {
+  const parentDirectory = path.resolve(__dirname, '../..'); // The path to the parent directory
+  const markdownFilePath = path.join(parentDirectory, 'README.md'); // Path to README.md file
+  const textToInsert = html;
+
+  // Read the original README.md file
+  fs.readFile(markdownFilePath, 'utf8', (err, data) => {
+    if (err) {
+      console.error('Unable to read README.md file：', err);
+      return;
+    }
+
+    // Find the location in the README.md file where you want to insert the text, for example under a specific tag
+    const insertMarker = '## Benchmark';
+
+    const index = data.indexOf(insertMarker);
+    if (index === -1) {
+      console.error('Unable to find insertion point');
+      return;
+    }
+
+    // insert text
+    const updatedMarkdown =
+      data.slice(0, index + insertMarker.length) + '\n' + textToInsert + data.slice(index + insertMarker.length);
+
+    // Try writing the modified content back to the README.md file
+    fs.writeFile(markdownFilePath, updatedMarkdown, 'utf8', err => {
+      if (err) {
+        console.error('Unable to write to README.md file：', err);
+      } else {
+        console.log('The tables have been successfully inserted into the README.md file!');
+      }
+    });
+  });
+}
+
+performanceTests.forEach(item => {
+  const {suite, testName, file} = item;
+  const relativeFilePath = path.relative(__dirname, file);
+  const directory = path.dirname(relativeFilePath);
+  const fileName = path.basename(relativeFilePath);
+  console.log(`${BG_YELLOW}Running in${END}: ${GRAY}${directory}/${END}${CYAN}${fileName}${END}`);
+
+  if (suite) {
+    let runTime = 0;
+    suite
+      .on('complete', function (this: Benchmark.Suite) {
+        completedCount++;
+        report[testName] = {};
+        report[testName].benchmarks = this.map((benchmark: Benchmark) => {
+          runTime += benchmark.times.elapsed;
+          return {
+            'test name': benchmark.name,
+            'time taken (ms)': numberFix(benchmark.times.period * 1000, 2),
+            'executions per sec': numberFix(benchmark.hz, 2),
+            'executed times': numberFix(benchmark.count, 0),
+            'sample mean (secs)': numberFix(benchmark.stats.mean, 2),
+            'sample deviation': numberFix(benchmark.stats.deviation, 2)
+          };
+        });
+
+        report[testName].testName = testName;
+        const isDone = completedCount === performanceTests.length;
+        runTime = Number(runTime.toFixed(2));
+        const isTimeWarn = runTime > 120;
+        console.log(
+          // `Files: ${GREEN}${testFileCount}${END} `,
+          // `Suites: ${GREEN}${performanceTests.length}${END} `,
+          `Suites Progress: ${isDone ? GREEN : YELLOW}${completedCount}${END}/${isDone ? GREEN : YELLOW}${
+            performanceTests.length
+          }${END}`,
+          `Time: ${isTimeWarn ? YELLOW : GREEN}${runTime}s${END}`
+        );
+        if (isDone) {
+          composeReport();
+        }
+      })
+      .run({async: false});
+  }
+});

package/test/performance/types/index.ts

@@ -0,0 +1 @@
+export * from './reportor';

package/test/performance/types/reportor.ts

@@ -0,0 +1,3 @@
+import * as Benchmark from 'benchmark';
+
+export type PerformanceTest = {testName: string; suite: Benchmark.Suite; file: string};

package/test/types/utils/index.ts

@@ -1 +1,2 @@
 export * from './big-o';
+export * from './json2html';

package/test/types/utils/json2html.ts

@@ -0,0 +1 @@
+export type Json2htmlOptions = {plainHtml?: boolean} & Partial<{[key: string]: any}>;