data-structure-typed 2.5.1 → 2.5.2

package/docs-site-docusaurus/src/pages/index.tsx

@@ -44,13 +44,32 @@ const features = [
   },
   {
     title: '✅ Battle-Tested',
-    description: '2500+ tests, 99%+ coverage. CLRS-correct Red-Black Tree, ACL-style Segment Tree. Production-ready.',
+    description: '2600+ tests, 99%+ coverage. CLRS-correct Red-Black Tree, ACL-style Segment Tree. Production-ready.',
   },
 ];
 
+const structures = [
+  { category: 'Trees', items: 'RedBlackTree, AVLTree, BST, TreeMap, TreeSet, TreeMultiMap, TreeMultiSet' },
+  { category: 'Heaps', items: 'Heap, MinHeap, MaxHeap, MinPriorityQueue, MaxPriorityQueue' },
+  { category: 'Queues & Stacks', items: 'Queue, Deque, Stack' },
+  { category: 'Linked Lists', items: 'SinglyLinkedList, DoublyLinkedList, SkipList' },
+  { category: 'Hashing', items: 'HashMap' },
+  { category: 'Graphs', items: 'DirectedGraph, UndirectedGraph' },
+  { category: 'Strings', items: 'Trie' },
+  { category: 'Arrays', items: 'SegmentTree, BinaryIndexedTree, Matrix' },
+];
+
+const useCases = [
+  { title: 'Priority Queue', link: '/docs/guide/use-cases/priority-queue-typescript', desc: 'Task scheduling, top-k problems, Dijkstra' },
+  { title: 'TreeMap / TreeSet', link: '/docs/guide/use-cases/treemap-javascript', desc: 'Sorted maps, floor/ceiling, range queries' },
+  { title: 'Array + Sort Too Slow?', link: '/docs/guide/use-cases/array-sort-alternative', desc: 'O(log n) insert vs O(n log n) re-sort' },
+  { title: 'Heap vs Sorting', link: '/docs/guide/use-cases/heap-vs-sorting', desc: 'When to use which' },
+  { title: 'Map vs TreeMap', link: '/docs/guide/use-cases/map-vs-treemap', desc: 'When native Map isn\'t enough' },
+];
+
 export default function Home(): React.JSX.Element {
   return (
-    <Layout title="Home" description="JavaScript/TypeScript Data Structure Library — STL-like, zero-dependency">
+    <Layout title="Home" description="Production-ready TypeScript data structures library — Heap, TreeMap, TreeSet, Trie, Graph, Priority Queue, Deque, and more. Zero dependencies, type-safe, with rank and range query support.">
       <HomepageHeader />
       <main>
         <section style={{padding: '4rem 0'}}>
@@ -65,6 +84,36 @@ export default function Home(): React.JSX.Element {
             </div>
           </div>
         </section>
+
+        <section style={{padding: '2rem 0 4rem', background: 'var(--ifm-background-surface-color)'}}>
+          <div className="container">
+            <h2 style={{textAlign: 'center', marginBottom: '2rem'}}>📚 Data Structures Available</h2>
+            <div className="row" style={{justifyContent: 'center'}}>
+              {structures.map((s, i) => (
+                <div key={i} className={clsx('col col--6')} style={{marginBottom: '1.5rem'}}>
+                  <h4>{s.category}</h4>
+                  <p style={{color: 'var(--ifm-color-emphasis-700)', fontSize: '0.95rem'}}>{s.items}</p>
+                </div>
+              ))}
+            </div>
+          </div>
+        </section>
+
+        <section style={{padding: '4rem 0'}}>
+          <div className="container">
+            <h2 style={{textAlign: 'center', marginBottom: '2rem'}}>🎯 Use Cases & Guides</h2>
+            <div className="row" style={{justifyContent: 'center'}}>
+              {useCases.map((u, i) => (
+                <div key={i} className={clsx('col col--4')} style={{marginBottom: '1.5rem'}}>
+                  <Link to={u.link} style={{textDecoration: 'none'}}>
+                    <h4>{u.title}</h4>
+                    <p style={{color: 'var(--ifm-color-emphasis-700)', fontSize: '0.9rem'}}>{u.desc}</p>
+                  </Link>
+                </div>
+              ))}
+            </div>
+          </div>
+        </section>
       </main>
     </Layout>
   );

package/docs-site-docusaurus/static/llms.txt

@@ -0,0 +1,37 @@
+# data-structure-typed
+
+> A production-ready TypeScript/JavaScript data structures library with zero dependencies.
+
+## What it is
+A comprehensive collection of 20+ data structures for TypeScript and JavaScript, with a unified API that feels like native Array. Includes Heap, Priority Queue, Deque, Trie, Graph, Red-Black Tree, TreeMap, TreeSet, SkipList, Segment Tree, Binary Indexed Tree, Matrix, and more.
+
+## Key capabilities
+- TreeMap / TreeSet: Sorted key-value and key-only collections (Red-Black Tree backed)
+- Order-statistic operations: getRank(key), getByRank(k), rangeByRank(start, end)
+- NavigableMap API: floor, ceiling, higher, lower, rangeSearch
+- Priority Queue / Heap: MinHeap, MaxHeap, custom comparators
+- Graph algorithms: Dijkstra, Bellman-Ford, Floyd-Warshall, Tarjan, topological sort, DFS, BFS
+- Trie: Prefix search, autocomplete
+- All structures support: forEach, filter, map, reduce, every, some, find, entries, keys, values
+
+## Install
+npm i data-structure-typed
+
+## Links
+- Documentation: https://data-structure-typed-docs.vercel.app/
+- GitHub: https://github.com/zrwusa/data-structure-typed
+- npm: https://www.npmjs.com/package/data-structure-typed
+- Quick Start: https://data-structure-typed-docs.vercel.app/docs/guide/quick-start
+- API Reference: https://data-structure-typed-docs.vercel.app/docs/api/
+- Guides: https://data-structure-typed-docs.vercel.app/docs/guide/guides
+- FAQ: https://github.com/zrwusa/data-structure-typed#-faq
+
+## Common questions
+- Does JavaScript have TreeMap? → Use TreeMap from this library (Red-Black Tree backed, sorted iteration, rank queries)
+- Priority queue in TypeScript? → Use Heap, MinHeap, MaxHeap, or MinPriorityQueue/MaxPriorityQueue
+- Sorted set / ordered set in JS? → Use TreeSet (maintains sorted order, supports floor/ceiling/range)
+- How to find kth element efficiently? → Use getByRank(k) with enableOrderStatistic: true
+- Alternative to repeatedly sorting arrays? → Use TreeMap/TreeSet for O(log n) insert with maintained order
+- Bundle size? → ~143KB UMD min, tree-shakeable subpath imports (18KB–315KB per category)
+- Zero dependencies? → Yes
+- Production ready? → Yes, 2600+ tests, 99%+ coverage

package/llms.txt

@@ -0,0 +1,37 @@
+# data-structure-typed
+
+> A production-ready TypeScript/JavaScript data structures library with zero dependencies.
+
+## What it is
+A comprehensive collection of 20+ data structures for TypeScript and JavaScript, with a unified API that feels like native Array. Includes Heap, Priority Queue, Deque, Trie, Graph, Red-Black Tree, TreeMap, TreeSet, SkipList, Segment Tree, Binary Indexed Tree, Matrix, and more.
+
+## Key capabilities
+- TreeMap / TreeSet: Sorted key-value and key-only collections (Red-Black Tree backed)
+- Order-statistic operations: getRank(key), getByRank(k), rangeByRank(start, end)
+- NavigableMap API: floor, ceiling, higher, lower, rangeSearch
+- Priority Queue / Heap: MinHeap, MaxHeap, custom comparators
+- Graph algorithms: Dijkstra, Bellman-Ford, Floyd-Warshall, Tarjan, topological sort, DFS, BFS
+- Trie: Prefix search, autocomplete
+- All structures support: forEach, filter, map, reduce, every, some, find, entries, keys, values
+
+## Install
+npm i data-structure-typed
+
+## Links
+- Documentation: https://data-structure-typed-docs.vercel.app/
+- GitHub: https://github.com/zrwusa/data-structure-typed
+- npm: https://www.npmjs.com/package/data-structure-typed
+- Quick Start: https://data-structure-typed-docs.vercel.app/docs/guide/quick-start
+- API Reference: https://data-structure-typed-docs.vercel.app/docs/api/
+- Guides: https://data-structure-typed-docs.vercel.app/docs/guide/guides
+- FAQ: https://github.com/zrwusa/data-structure-typed#-faq
+
+## Common questions
+- Does JavaScript have TreeMap? → Use TreeMap from this library (Red-Black Tree backed, sorted iteration, rank queries)
+- Priority queue in TypeScript? → Use Heap, MinHeap, MaxHeap, or MinPriorityQueue/MaxPriorityQueue
+- Sorted set / ordered set in JS? → Use TreeSet (maintains sorted order, supports floor/ceiling/range)
+- How to find kth element efficiently? → Use getByRank(k) with enableOrderStatistic: true
+- Alternative to repeatedly sorting arrays? → Use TreeMap/TreeSet for O(log n) insert with maintained order
+- Bundle size? → ~143KB UMD min, tree-shakeable subpath imports (18KB–315KB per category)
+- Zero dependencies? → Yes
+- Production ready? → Yes, 2600+ tests, 99%+ coverage

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "data-structure-typed",
-  "version": "2.5.1",
-  "description": "Standard data structure",
+  "version": "2.5.2",
+  "description": "Production-ready TypeScript data structures: Heap, Deque, Trie, Graph, Red-Black Tree, TreeMap, TreeSet, and more. Zero dependencies, type-safe, with getRank/getByRank/rangeByRank support.",
   "browser": "dist/umd/data-structure-typed.min.js",
   "umd:main": "dist/umd/data-structure-typed.min.js",
   "main": "dist/cjs/index.cjs",
@@ -129,49 +129,45 @@
     "npm": ">=6.14.0"
   },
   "scripts": {
-    "build": "npm run build:ecut && npm run build:docs-class",
+    "build": "npm run build:node && npm run build:types && npm run build:umd",
     "build:node": "tsup",
     "build:umd": "tsup --config tsup.umd.config.js",
     "build:types": "rm -rf dist/types && tsc -p tsconfig.types.json",
-    "build:ecut": "npm run build:node && npm run build:types && npm run build:umd",
     "build:leetcode": "tsup --config tsup.leetcode.config.js",
     "build:typedoc-plugin": "tsc scripts/typedoc-plugin-example-rewrite.ts --outDir scripts --esModuleInterop --module commonjs --target es2020 --moduleResolution node --skipLibCheck",
-    "build:docs": "npm run gen:examples && npm run generate:schema && npm run build:typedoc-plugin && typedoc --plugin ./scripts/typedoc-plugin-example-rewrite.js --out docs/api ./src",
-    "build:docs-class": "npm run gen:examples && npm run build:typedoc-plugin && typedoc --plugin ./scripts/typedoc-plugin-example-rewrite.js --out docs/api ./src/data-structures",
     "gen:examples": "ts-node scripts/test-to-example.ts",
-    "test:in-band": "jest --runInBand",
-    "test": "npm run test:in-band",
+    "generate:schema": "ts-node scripts/generate-schema.ts",
+    "test": "jest --runInBand",
+    "test:coverage": "jest --runInBand --coverage",
     "test:integration": "npm run update:subs && jest --config jest.integration.config.js && tsc test/integration/compile.test.ts && node test/integration/compile.mjs",
-    "test:perf": "npm run build:ecut && NODE_OPTIONS='--expose-gc --max-old-space-size=8192' node test/performance/benchmark-runner-enhanced.mjs",
+    "test:perf": "npm run build && NODE_OPTIONS='--expose-gc --max-old-space-size=8192' node test/performance/benchmark-runner-enhanced.mjs",
     "test:perf:report": "node test/performance/reportor-enhanced.mjs",
-    "test:coverage": "jest --runInBand --coverage",
     "check": "npm run check:src && npm run check:test",
     "check:src": "tsc --noEmit",
     "check:test": "tsc -p tsconfig.test.json --noEmit",
     "check:circular-refs": "dependency-cruiser src",
+    "lint": "npm run lint:src && npm run lint:test",
     "lint:src": "eslint --fix 'src/**/*.{js,ts}'",
     "lint:test": "eslint --fix 'test/**/*.{js,ts}'",
-    "lint": "npm run lint:src && npm run lint:test",
-    "inspect": "npm run build && npm run check && npm run lint",
+    "format": "npm run format:src && npm run format:test",
     "format:src": "prettier --write 'src/**/*.{js,ts}'",
     "format:test": "prettier --write 'test/**/*.{js,ts}'",
-    "format": "npm run format:src && npm run format:test",
-    "check:exist-latest": "sh scripts/check_exist_remotely.sh",
-    "ci": "env && git fetch --tags && npm run update:subs && npm run inspect && npm run lint && npm run test:coverage && npm run changelog",
+    "inspect": "npm run build && npm run check && npm run lint",
+    "ci": "env && git fetch --tags && npm run update:subs && npm run inspect && npm run test:coverage && npm run changelog",
+    "docs:api": "npm run gen:examples && npm run build:typedoc-plugin && cd docs-site-docusaurus && npx typedoc --options typedoc.json && node sort-protected.mjs",
+    "docs:dev": "cd docs-site-docusaurus && npm run start",
+    "docs:build": "cd docs-site-docusaurus && rm -rf docs/api && npx typedoc --options typedoc.json && node sort-protected.mjs && npm run build",
+    "docs:preview": "cd docs-site-docusaurus && npm run serve",
     "update:subs": "npm i avl-tree-typed binary-tree-typed bst-typed heap-typed data-structure-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-multimap-typed trie-typed undirected-graph-typed queue-typed --save-dev",
-    "changelog": "auto-changelog",
-    "coverage:badge": "istanbul-badges-readme",
-    "toc": "doctoc README.md",
     "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 check:exist-latest && npm run publish:subs",
-    "generate:schema": "ts-node scripts/generate-schema.ts",
-    "docs:api": "npm run gen:examples && npm run build:typedoc-plugin && cd docs-site-docusaurus && npx typedoc --options typedoc.json && node sort-protected.mjs",
-    "docs:dev": "cd docs-site-docusaurus && npm run start",
-    "docs:build": "cd docs-site-docusaurus && rm -rf docs/api && npx typedoc --options typedoc.json && node sort-protected.mjs && npm run build",
-    "docs:preview": "cd docs-site-docusaurus && npm run serve"
+    "check:exist-latest": "sh scripts/check_exist_remotely.sh",
+    "changelog": "auto-changelog",
+    "coverage:badge": "istanbul-badges-readme",
+    "toc": "doctoc README.md"
   },
   "repository": {
     "type": "git",
@@ -197,11 +193,11 @@
     "@typescript-eslint/eslint-plugin": "^8.12.1",
     "@typescript-eslint/parser": "^8.12.1",
     "auto-changelog": "^2.5.0",
-    "avl-tree-typed": "^2.5.0",
+    "avl-tree-typed": "^2.5.1",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^2.5.0",
-    "bst-typed": "^2.5.0",
-    "data-structure-typed": "^2.5.0",
+    "binary-tree-typed": "^2.5.1",
+    "bst-typed": "^2.5.1",
+    "data-structure-typed": "^2.5.1",
     "dependency-cruiser": "^16.5.0",
     "doctoc": "^2.2.1",
     "eslint": "^9.13.0",
@@ -210,7 +206,7 @@
     "eslint-import-resolver-typescript": "^3.6.3",
     "eslint-plugin-import": "^2.31.0",
     "fast-glob": "^3.3.2",
-    "heap-typed": "^2.5.0",
+    "heap-typed": "^2.5.1",
     "istanbul-badges-readme": "^1.9.0",
     "jest": "^29.7.0",
     "js-sdsl": "^4.4.2",
@@ -225,59 +221,71 @@
     "typescript": "~5.9"
   },
   "keywords": [
-    "data structures typescript",
-    "data structures javascript",
+    "data structures",
+    "typescript",
+    "javascript",
+    "data structures library",
     "typescript data structures",
     "javascript data structures",
-    "data-structure library",
-    "algorithm library",
+    "binary tree",
     "binary search tree",
+    "BST",
     "AVL tree",
     "red black tree",
     "tree map",
     "tree set",
+    "treemap javascript",
+    "treeset javascript",
+    "sorted map",
+    "sorted set",
+    "ordered map",
+    "ordered set",
     "tree multi map",
     "tree multi set",
-    "balanced tree",
-    "binary tree",
-    "BST",
-    "graph algorithm",
-    "directed graph",
-    "undirected graph",
     "heap",
-    "priority queue",
     "min heap",
     "max heap",
+    "priority queue",
     "queue",
     "deque",
+    "double ended queue",
     "stack",
     "linked list",
     "singly linked list",
     "doubly linked list",
+    "skip list",
     "trie",
+    "prefix tree",
+    "graph",
+    "directed graph",
+    "undirected graph",
     "hash map",
     "hash table",
-    "tree multimap",
-    "tree multiset",
-    "tree map",
-    "tree set",
-    "ordered set",
-    "ordered map",
-    "depth first search",
-    "breadth first search",
-    "DFS",
-    "BFS",
-    "dijkstra algorithm",
+    "segment tree",
+    "binary indexed tree",
+    "fenwick tree",
+    "matrix",
+    "rank query",
+    "range query",
+    "order statistic tree",
+    "getRank",
+    "getByRank",
+    "rangeByRank",
+    "dijkstra",
     "bellman ford",
-    "floyd warshall",
-    "tarjan algorithm",
     "topological sort",
+    "DFS",
+    "BFS",
     "leetcode",
     "coding interview",
-    "algorithm practice",
-    "collection",
-    "ES6 modules",
+    "algorithm",
+    "zero dependency",
+    "production ready",
+    "type safe",
+    "ES6",
     "CommonJS",
-    "type-safe"
+    "UMD",
+    "collection",
+    "sorted collection"
   ]
 }

package/src/common/error.ts

@@ -1,3 +1,17 @@
+/**
+ * Centralized error dispatch.
+ * All library errors go through this function for consistent messaging and easy grep.
+ * @remarks Always throws — data structure errors are never recoverable.
+ * @param ErrorClass - The error constructor (Error, TypeError, RangeError, etc.)
+ * @param message - The error message.
+ */
+export function raise(
+  ErrorClass: new (msg: string) => Error,
+  message: string
+): never {
+  throw new ErrorClass(message);
+}
+
 /**
  * Centralized error message templates.
  * Keep using native Error/TypeError/RangeError — this only standardizes messages.
@@ -56,5 +70,9 @@ export const ERR = {
     'Matrix: Must be rectangular for transposition.',
 
   matrixRowMismatch: (expected: number, got: number) =>
-    `Matrix: Expected row length ${expected}, but got ${got}.`
+    `Matrix: Expected row length ${expected}, but got ${got}.`,
+
+  // Order statistic
+  orderStatisticNotEnabled: (method: string, ctx?: string) =>
+    `${ctx ? ctx + ': ' : ''}${method}() requires enableOrderStatistic: true.`
 } as const;

package/src/common/index.ts

@@ -1,4 +1,4 @@
-export { ERR } from './error';
+export { ERR, raise } from './error';
 
 export enum DFSOperation {
   VISIT = 0,

package/src/data-structures/base/iterable-element-base.ts

@@ -1,4 +1,5 @@
 import type { ElementCallback, IterableElementBaseOptions, ReduceElementCallback } from '../../types';
+import { raise } from '../../common';
 
 /**
  * Base class that makes a data structure iterable and provides common
@@ -25,7 +26,7 @@ export abstract class IterableElementBase<E, R> implements Iterable<E> {
     if (options) {
       const { toElementFn } = options;
       if (typeof toElementFn === 'function') this._toElementFn = toElementFn;
-      else if (toElementFn) throw new TypeError('toElementFn must be a function type');
+      else if (toElementFn) raise(TypeError, 'toElementFn must be a function type');
     }
   }
 
@@ -224,7 +225,7 @@ export abstract class IterableElementBase<E, R> implements Iterable<E> {
       acc = initialValue as U;
     } else {
       const first = iter.next();
-      if (first.done) throw new TypeError('Reduce of empty structure with no initial value');
+      if (first.done) raise(TypeError, 'Reduce of empty structure with no initial value');
       acc = first.value as unknown as U;
       index = 1;
     }

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

@@ -467,6 +467,18 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -590,6 +602,15 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -674,6 +695,12 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    
    
    
+   
+   
+   
+   
+   
+   
    
    
    
@@ -805,6 +832,15 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -970,6 +1006,8 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
     }
     this._updateHeight(A);
     if (B) this._updateHeight(B);
+    this._updateCount(A);
+    if (B) this._updateCount(B);
   }
 
   /**
@@ -1022,6 +1060,9 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
     this._updateHeight(A);
     if (B) this._updateHeight(B);
     if (C) this._updateHeight(C);
+    this._updateCount(A);
+    if (B) this._updateCount(B);
+    if (C) this._updateCount(C);
   }
 
   /**
@@ -1061,6 +1102,8 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
     }
     this._updateHeight(A);
     if (B) this._updateHeight(B);
+    this._updateCount(A);
+    if (B) this._updateCount(B);
   }
 
   /**
@@ -1112,6 +1155,9 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
     this._updateHeight(A);
     if (B) this._updateHeight(B);
     if (C) this._updateHeight(C);
+    this._updateCount(A);
+    if (B) this._updateCount(B);
+    if (C) this._updateCount(C);
   }
 
   /**
@@ -1130,6 +1176,7 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
       const A = path[i];
       if (A) {
         this._updateHeight(A);
+        this._updateCount(A);
 
         // Check the balance factor
         switch (this._balanceFactor(A)) {

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { ERR } from '../../common';
+import { ERR, raise } from '../../common';
 
 /**
  * Binary Indexed Tree (Fenwick Tree).
@@ -44,7 +44,7 @@ export class BinaryIndexedTree implements Iterable<number> {
       }
     } else {
       if (!Number.isInteger(sizeOrElements) || sizeOrElements < 0) {
-        throw new RangeError(ERR.invalidArgument('size must be a non-negative integer', 'BinaryIndexedTree'));
+        raise(RangeError, ERR.invalidArgument('size must be a non-negative integer', 'BinaryIndexedTree'));
       }
       this._size = sizeOrElements;
       this._tree = new Array(this._size + 1).fill(0);
@@ -105,6 +105,12 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
    
    
    
@@ -176,6 +182,12 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
    
    
    
@@ -247,6 +259,12 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
    
    
    
@@ -318,6 +336,12 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
    
    
    
@@ -387,6 +411,12 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
    
    
    
@@ -464,6 +494,12 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
+   
+   
+   
    
    
    
@@ -517,6 +553,9 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
    
    
    
@@ -583,6 +622,9 @@ export class BinaryIndexedTree implements Iterable<number> {
    
    
    
+   
+   
+   
    
    
    
@@ -665,10 +707,10 @@ export class BinaryIndexedTree implements Iterable<number> {
 
   protected _checkIndex(index: number): void {
     if (!Number.isInteger(index)) {
-      throw new TypeError(ERR.invalidIndex('BinaryIndexedTree'));
+      raise(TypeError, ERR.invalidIndex('BinaryIndexedTree'));
     }
     if (index < 0 || index >= this._size) {
-      throw new RangeError(ERR.indexOutOfRange(index, 0, this._size - 1, 'BinaryIndexedTree'));
+      raise(RangeError, ERR.indexOutOfRange(index, 0, this._size - 1, 'BinaryIndexedTree'));
     }
   }