typescript-dsa-stl 2.5.0 → 2.7.0

package/README.md

@@ -1,17 +1,58 @@
 # TypeScript_DSA
 
-**This is the GitHub repository** for the npm package **[typescript-dsa-stl](https://www.npmjs.com/package/typescript-dsa-stl)**.
+**Repository** for the npm package **[typescript-dsa-stl](https://www.npmjs.com/package/typescript-dsa-stl)** · [GitHub](https://github.com/SajidAbdullah729/TypeScript_DSA)
 
-STL-style data structures and algorithms for TypeScript: **Vector**, **Stack**, **Queue**, **List**, **PriorityQueue**, **OrderedMap** (Map), **UnorderedMap**, **OrderedSet** (Set), **UnorderedSet**, **OrderedMultiMap**, **OrderedMultiSet**, **segment trees** (`SegmentTreeSum`, `SegmentTreeMin`, `SegmentTreeMax`, `SegmentTree`, `GeneralSegmentTree`, `LazySegmentTreeSum`), and algorithms (`sort`, `binarySearch`, `lowerBound`, `min`, `max`, **KnuthMorrisPratt**, **RabinKarp**, **StringRollingHash**, etc.). Install from npm to use in your project; this repo holds the source code.
+STL-style data structures and algorithms for TypeScript: **Vector**, **Stack**, **Queue**, **Deque**, **List**, **PriorityQueue**, ordered/unordered **Map** and **Set**, **OrderedMultiMap** / **OrderedMultiSet**, **segment trees**, **graph** helpers (BFS, DFS, Dijkstra, Kruskal, DSU), and **string** algorithms (KMP, Rabin–Karp, rolling hash). Install from npm for your app; this repo is the source.
 
 ---
 
-## Install
+## Table of contents
+
+| Section | What you’ll find |
+|--------|-------------------|
+| [Installation](#installation) | npm install |
+| [Package layout & imports](#package-layout--imports) | Barrel vs subpaths (tree-shaking) |
+| [Quick start](#quick-start) | One file showing main APIs |
+| [API reference](#api-reference) | Export tables |
+| [Complexity](#complexity) | Big-O for collections and segment trees |
+| [Collections](#collections) | Deque, nested vectors, multi-map / multi-set |
+| [Segment trees](#segment-trees) | Sum/min/max, generic, lazy |
+| [Graph algorithms](#graph-algorithms) | Adjacency lists, BFS/DFS, components, MST, shortest paths |
+| [String algorithms](#string-algorithms) | KMP, Rabin–Karp, rolling hash |
+| [For maintainers](#for-maintainers) | Build and publish |
+| [License](#license) | MIT |
+
+---
+
+## Installation
 
 ```bash
 npm install typescript-dsa-stl
 ```
 
+**Runtime:** Node **18+** (see `package.json` `engines`).
+
+---
+
+## Package layout & imports
+
+Import everything from the root, or use subpaths for smaller bundles:
+
+```ts
+import { Vector, Stack, Queue, Deque } from 'typescript-dsa-stl/collections';
+import {
+  sort,
+  binarySearch,
+  breadthFirstSearch,
+  depthFirstSearch,
+  KnuthMorrisPratt,
+  RabinKarp,
+  StringRollingHash,
+} from 'typescript-dsa-stl/algorithms';
+import { clamp, range } from 'typescript-dsa-stl/utils';
+import type { Comparator } from 'typescript-dsa-stl/types';
+```
+
 ---
 
 ## Quick start
@@ -21,6 +62,7 @@ import {
   Vector,
   Stack,
   Queue,
+  Deque,
   List,
   PriorityQueue,
   OrderedMap,
@@ -32,6 +74,8 @@ import {
   sort,
   find,
   binarySearch,
+  lowerBound,
+  upperBound,
   min,
   max,
   clamp,
@@ -53,6 +97,15 @@ queue.enqueue(1);
 queue.enqueue(2);
 console.log(queue.front()); // 1
 
+// Deque — double-ended queue (like C++ std::deque): O(1) both ends + O(1) index access
+const deque = new Deque<number>();
+deque.pushBack(2);
+deque.pushFront(1);
+deque.pushBack(3);
+console.log(deque.front()); // 1
+console.log(deque.back()); // 3
+console.log(deque.at(1)); // 2
+
 const list = new List<number>();
 list.pushBack(10);
 const node = list.pushBack(20);
@@ -102,6 +155,87 @@ clamp(42, 0, 10);       // 10
 range(0, 5);            // [0, 1, 2, 3, 4]
 ```
 
+---
+
+## API reference
+
+### Main export map
+
+| Area | Exports |
+|------|---------|
+| **Collections** | `Vector`, `Stack`, `Queue`, `Deque`, `List`, `ListNode`, `PriorityQueue`, `OrderedMap`, `UnorderedMap`, `OrderedSet`, `UnorderedSet`, `OrderedMultiMap`, `OrderedMultiSet`, `GeneralSegmentTree`, `SegmentTree`, `SegmentTreeSum`, `SegmentTreeMin`, `SegmentTreeMax`, `LazySegmentTreeSum`, `WeightedEdge`, `AdjacencyList`, `WeightedAdjacencyList`, `createAdjacencyList`, `createWeightedAdjacencyList`, `addEdge`, `deleteEdge` |
+| **Algorithms** | `sort`, `find`, `findIndex`, `transform`, `filter`, `reduce`, `reverse`, `unique`, `binarySearch`, `lowerBound`, `upperBound`, `min`, `max`, `partition`, `DisjointSetUnion`, `KnuthMorrisPratt`, `RabinKarp`, `RABIN_KARP_DEFAULT_MODS`, `StringRollingHash`, `breadthFirstSearch`, `depthFirstSearch`, `connectedComponents`, `kruskalMST`, `dijkstra`, `reconstructPath` |
+| **Utils** | `clamp`, `range`, `noop`, `identity`, `swap` |
+| **Types** | `Comparator`, `Predicate`, `UnaryFn`, `Reducer`, `IterableLike`, `toArray`, `RabinKarpTripleMods`, `WeightedUndirectedEdge`, `GeneralSegmentTreeConfig`, `SegmentCombine`, `SegmentMerge`, `SegmentLeafBuild` |
+
+### Subpath imports (tree-shaking)
+
+```ts
+import { Vector, Stack, Queue, Deque } from 'typescript-dsa-stl/collections';
+import { sort, binarySearch, breadthFirstSearch, depthFirstSearch, KnuthMorrisPratt, RabinKarp, StringRollingHash } from 'typescript-dsa-stl/algorithms';
+import { clamp, range } from 'typescript-dsa-stl/utils';
+import type { Comparator } from 'typescript-dsa-stl/types';
+```
+
+---
+
+## Complexity
+
+### Linear and associative structures
+
+| Structure | Access | Insert end | Insert middle | Remove end | Remove middle |
+|-----------|--------|------------|---------------|------------|---------------|
+| **Vector** | O(1) | O(1)* | O(n) | O(1) | O(n) |
+| **Stack** | — | O(1) | — | O(1) | — |
+| **Queue** | — | O(1)* | — | O(1)* | — |
+| **Deque** | O(1) | O(1)* (front/back) | — | O(1)* (front/back) | — |
+| **List** | O(n) | O(1) | O(1)** | O(1) | O(1)** |
+| **PriorityQueue** | — | O(log n) | — | O(log n) | — |
+| **OrderedMap** (Map) | O(log n) get | O(log n) set | — | O(log n) delete | — |
+| **UnorderedMap** | O(1)* get/set | O(1)* | — | O(1)* delete | — |
+| **OrderedSet** (Set) | O(log n) has | O(log n) add | — | O(log n) delete | — |
+| **UnorderedSet** | O(1)* has/add | O(1)* | — | O(1)* delete | — |
+| **OrderedMultiMap** | O(log n) get | O(log n) set | — | O(log n) delete | — |
+| **OrderedMultiSet** | O(log n) has/count | O(log n) add | — | O(log n) delete | — |
+
+\* Amortized (hash).  
+\** At a known node.
+
+### Segment trees
+
+| Structure | Build | Point update | Range query | Extra |
+|-----------|-------|--------------|-------------|--------|
+| **GeneralSegmentTree**, **SegmentTree**, **SegmentTreeSum** / **Min** / **Max** | O(n) | O(log n) | O(log n) | Inclusive `[l, r]`; **GeneralSegmentTree** keeps raw `V` and uses `merge` + `buildLeaf` |
+| **LazySegmentTreeSum** | O(n) | `set`: O(log n) | `rangeSum`: O(log n) | `rangeAdd` on a range: O(log n) |
+
+---
+
+## Collections
+
+### Deque (like C++ `std::deque`)
+
+A **double-ended queue**: amortized **O(1)** `pushFront` / `pushBack` / `popFront` / `popBack`, and **O(1)** random access via `at` / `set`. Implemented as a growable circular buffer (same asymptotics as a typical `std::deque` for these operations).
+
+| C++ | TypeScript |
+|-----|------------|
+| `push_front` | `pushFront` |
+| `push_back` | `pushBack` |
+| `pop_front` | `popFront` |
+| `pop_back` | `popBack` |
+| `front` / `back` | `front()` / `back()` |
+| `operator[]` / `at` | `at(i)` / `set(i, value)` |
+| `size` / `empty` | `size` / `empty` |
+| — | `capacity`, `reserve`, `shrinkToFit`, `toArray()`, iterator |
+
+```ts
+import { Deque } from 'typescript-dsa-stl';
+
+const d = new Deque<number>([1, 2, 3]); // copy initial elements, or `new Deque()` / `new Deque(64)` for capacity hint
+d.pushFront(0);
+d.popBack();
+console.log(d.toArray()); // [0, 1, 2]
+```
+
 ### 2D and 3D vectors (like C++ `vector<vector<int>>`)
 
 `Vector<T>` is generic, so you can nest it for 2D/3D grids:
@@ -144,127 +278,339 @@ cube.push(layer0);
 cube.at(0).at(1).at(0);  // 3  (layer 0, row 1, col 0)
 ```
 
-### Graph adjacency list (like C++ `vector<vector<type>> graph(n)`)
+### OrderedMultiMap and OrderedMultiSet — use cases
 
-You can model C++-style adjacency lists using the graph types and helpers exported from `typescript-dsa-stl/collections` (or the main package).
+**OrderedMultiSet** is a sorted collection that allows duplicate elements (like C++ `std::multiset`). Use it when you need ordering and multiple copies of the same value.
 
-#### Unweighted adjacency list
+| Use case | Example |
+|----------|---------|
+| **Sorted runs / leaderboard with ties** | Store scores; multiple users can have the same score. Iterate in sorted order, use `count(score)` for ties. |
+| **Event timeline with repeated timestamps** | Add events by time; several events can share the same time. `add(timestamp)`, iterate in order. |
+| **K-th smallest in a multiset** | Keep elements sorted; k-th element is at index `k - 1` in iteration. |
+| **Range counts** | Combined with binary search ideas: count elements in `[low, high]` using `count` and iteration. |
 
-C++:
+**OrderedMultiMap** maps one key to multiple values while keeping keys sorted (like C++ `std::multimap`). Use it when a key can have several associated values and you need key order.
 
-```cpp
-int n = 5;
-vector<vector<int>> graph(n);
-graph[u].push_back(v);   // or graph[u].pb(v);
-```
+| Use case | Example |
+|----------|---------|
+| **Inverted index** | Key = term, values = document IDs containing that term. `set(term, docId)` for each occurrence; `getAll(term)` returns all doc IDs. |
+| **Grouping by key** | Key = category, values = items. `set(category, item)`; iterate keys in order, use `getAll(key)` per group. |
+| **One-to-many relations** | Key = user ID, values = session IDs. `set(userId, sessionId)`; `getAll(userId)` lists all sessions. |
+| **Time-series by bucket** | Key = time bucket, values = events. Sorted keys give chronological buckets; `getAll(bucket)` gets events in that bucket. |
 
-TypeScript (easy declaration with `createAdjacencyList`):
+**OrderedMultiSet example:**
 
 ```ts
-import { createAdjacencyList } from 'typescript-dsa-stl/collections';
-
-const n = 5;
-const graph = createAdjacencyList(n);   // empty graph with n vertices
-
-// C++: graph[u].push_back(v);
-graph[u].push(v);
+import { OrderedMultiSet } from 'typescript-dsa-stl';
 
-// Iteration is the same idea as in C++
-for (const v of graph[u]) {
-  // neighbor v
-}
+const scores = new OrderedMultiSet<number>();
+scores.add(85); scores.add(92); scores.add(85); scores.add(78);
+console.log(scores.toArray());   // [78, 85, 85, 92]
+console.log(scores.count(85));   // 2
+scores.delete(85);               // remove one 85
+console.log(scores.count(85));   // 1
+scores.deleteAll(85);            // remove all 85s
 ```
 
-Or with helpers `addEdge` / `deleteEdge`:
+**OrderedMultiMap example:**
 
 ```ts
-import { createAdjacencyList, addEdge, deleteEdge } from 'typescript-dsa-stl/collections';
-
-const graph = createAdjacencyList(5);
+import { OrderedMultiMap } from 'typescript-dsa-stl';
 
-addEdge(graph, u, v);        // add u -> v
-deleteEdge(graph, u, v);     // remove all edges u -> v
+const index = new OrderedMultiMap<string, number>();  // term -> doc IDs
+index.set('typescript', 1); index.set('typescript', 3); index.set('stl', 2);
+console.log(index.getAll('typescript'));  // [1, 3]
+console.log(index.get('stl'));            // 2
+for (const [key, value] of index) {
+  console.log(key, value);               // keys in sorted order
+}
 ```
 
-#### Weighted adjacency list
+---
 
-In C++ you might write:
+## Segment trees
 
-```cpp
-int n = 5;
-vector<vector<pair<int,int>>> graph(n);
-graph[u].push_back({v, w});   // edge u -> v with weight w
-```
+Segment trees support **range queries** and **point updates** in **O(log n)**. Range endpoints are **inclusive**: `query(l, r)` covers indices `l` through `r`.
 
-In TypeScript, use `createWeightedAdjacencyList` for easy declaration:
+### Ready-made variants (`SegmentTreeSum`, `SegmentTreeMin`, `SegmentTreeMax`)
 
 ```ts
-import { createWeightedAdjacencyList } from 'typescript-dsa-stl/collections';
+import {
+  SegmentTreeSum,
+  SegmentTreeMin,
+  SegmentTreeMax,
+} from 'typescript-dsa-stl';
 
-const n = 5;
-const graph = createWeightedAdjacencyList(n);   // empty weighted graph with n vertices
+const sum = new SegmentTreeSum([1, 2, 3, 4]);
+console.log(sum.query(0, 3)); // 10
+sum.update(1, 10);
+console.log(sum.query(0, 3)); // 1 + 10 + 3 + 4 = 18
 
-// C++: graph[u].push_back({v, w});
-graph[u].push({ to: v, weight: w });
+const mn = new SegmentTreeMin([5, 2, 8, 1]);
+console.log(mn.query(0, 3)); // 1
 
-// When iterating, you get both neighbor and weight
-for (const { to, weight } of graph[u]) {
-  // edge u -> to with cost = weight
-}
+const mx = new SegmentTreeMax([5, 2, 8, 1]);
+console.log(mx.query(0, 3)); // 8
 ```
 
-Or with the helper functions `addEdge` / `deleteEdge`:
+### Generic `SegmentTree<T>` (custom combine + neutral)
+
+Use the same type for array elements and aggregates. Pass an **associative** `combine` and a **neutral** value for query ranges that miss a segment (e.g. `0` for sum, `Infinity` for min).
 
 ```ts
-import { createWeightedAdjacencyList, addEdge, deleteEdge } from 'typescript-dsa-stl/collections';
+import { SegmentTree } from 'typescript-dsa-stl';
 
-const graph = createWeightedAdjacencyList(5);
+const gcdTree = new SegmentTree<number>(
+  [12, 18, 24],
+  (a, b) => {
+    let x = a;
+    let y = b;
+    while (y !== 0) {
+      const t = y;
+      y = x % y;
+      x = t;
+    }
+    return x;
+  },
+  0
+);
+console.log(gcdTree.query(0, 2)); // gcd(12, 18, 24) === 6
 
-addEdge(graph, u, v, w);         // add u -> v with weight w
-deleteEdge(graph, u, v, w);      // delete all edges u -> v with weight w
+// Non-numeric example: concatenate strings
+const strTree = new SegmentTree<string>(
+  ['a', 'b', 'c'],
+  (a, b) => a + b,
+  ''
+);
+console.log(strTree.query(0, 2)); // 'abc'
 ```
 
-#### Graph adjacency list — use cases
+### `GeneralSegmentTree<T, V>` (custom merge + buildLeaf)
 
-Use an **unweighted** graph (adjacency list) when you only care about connectivity; use a **weighted** graph when edges have costs (distance, time, capacity).
+Use when **raw** values `V` differ from the **aggregate** type `T`:
 
-| Use case | When to use |
-|----------|-------------|
-| **BFS / DFS, connectivity** | Unweighted: shortest path in terms of hop count, connected components, cycle detection. |
-| **Shortest path (Dijkstra), MST** | Weighted: edge weights as distances or costs; run Dijkstra, Prim, or Kruskal on the list. |
-| **Social / dependency graphs** | Unweighted or weighted: followers, dependencies (e.g. build order), recommendation graphs. |
-| **Grid / game graphs** | Unweighted: 4- or 8-neighbor grids; weighted if movement costs differ per cell. |
-| **Network / flow** | Weighted: capacities or latencies on edges for max-flow or routing. |
+- **`merge(left, right)`** — combine two child aggregates (internal nodes).
+- **`neutral`** — identity for `merge` when a query does not overlap a segment.
+- **`buildLeaf(value, index)`** — build the leaf from the raw array on initial construction and on every `update`.
 
-#### Breadth-first search (BFS) and depth-first search (DFS)
+```ts
+import { GeneralSegmentTree } from 'typescript-dsa-stl';
 
-`breadthFirstSearch` and `depthFirstSearch` take the number of vertices `n`, an unweighted `AdjacencyList`, and a `start` vertex. They return the **visit order** for all vertices **reachable** from `start` (vertices outside that component are not included). For an undirected graph, add each edge in **both** directions (see `addEdge` below).
+// Store sum of squares; raw array is plain numbers
+const st = new GeneralSegmentTree<number, number>([1, 2, 3], {
+  merge: (a, b) => a + b,
+  neutral: 0,
+  buildLeaf: (v, i) => v * v + i,
+});
+console.log(st.query(0, 2)); // (1+0) + (4+1) + (9+2) = 17
+st.update(1, 4);
+console.log(st.rawAt(1)); // 4 — current raw value at index 1
+```
 
-**Example graph (diamond):** edges `0—1`, `0—2`, `1—3`, `2—3`.
+### `LazySegmentTreeSum` (range add + range sum)
 
-```text
-      0
-     / \
-    1   2
-     \ /
-      3
+**`rangeAdd(l, r, delta)`** adds `delta` to every element in the inclusive range. **`rangeSum(l, r)`** returns the sum. **`set(i, value)`** assigns one position (lazy tags are applied along the path). All are **O(log n)**.
+
+```ts
+import { LazySegmentTreeSum } from 'typescript-dsa-stl';
+
+const lazy = new LazySegmentTreeSum([0, 0, 0, 0]);
+lazy.rangeAdd(1, 2, 5); // indices 1 and 2 get +5
+console.log(lazy.rangeSum(0, 3)); // 10
+lazy.set(0, 100);
+console.log(lazy.rangeSum(0, 3)); // 100 + 5 + 5 + 0
 ```
 
-With neighbors listed in ascending vertex id (`0: [1,2]`, `1: [0,3]`, …), **BFS** from `0` visits by increasing distance from `0`: first `0`, then `1` and `2`, then `3` → order `[0, 1, 2, 3]`. **DFS** (preorder, first neighbor in each list first) goes `0 → 1 → 3` then `2` → order `[0, 1, 3, 2]`. The exact DFS order depends on how you order each adjacency list.
+### Real-world use cases
 
-```ts
-import {
-  createAdjacencyList,
-  addEdge,
-  breadthFirstSearch,
-  depthFirstSearch,
-} from 'typescript-dsa-stl';
+These patterns show up in backends and internal tools when you need **many** range queries and updates on a fixed sequence (length known up front), without scanning the whole array each time.
 
-const n = 4;
-const graph = createAdjacencyList(n);
+#### 1. Analytics or reporting: totals over a time window (with corrections)
 
-// Undirected diamond: add both directions for each edge
-addEdge(graph, 0, 1);
+Each index is a **fixed bucket** (hour of day, day of month, version slot, etc.). You repeatedly ask “what is the **sum** from bucket `a` through `b`?” and sometimes **fix one bucket** after late data or a reconciliation.
+
+```ts
+import { SegmentTreeSum } from 'typescript-dsa-stl';
+
+/** Revenue (or events, page views, API calls) per calendar day; index 0 = first day of period. */
+class PeriodMetrics {
+  private readonly tree: SegmentTreeSum;
+
+  constructor(dailyValues: readonly number[]) {
+    this.tree = new SegmentTreeSum(dailyValues);
+  }
+
+  /** Total for an inclusive day range — e.g. chart drill-down or export row. */
+  totalBetweenDay(firstDayIndex: number, lastDayIndex: number): number {
+    return this.tree.query(firstDayIndex, lastDayIndex);
+  }
+
+  /** Backfill or correct one day without rebuilding the whole series. */
+  setDay(dayIndex: number, amount: number): void {
+    this.tree.update(dayIndex, amount);
+  }
+}
+
+const january = new PeriodMetrics([1200, 980, 1100, 1050, 1300]);
+console.log(january.totalBetweenDay(0, 4)); // full period
+january.setDay(2, 1150); // corrected day 2
+console.log(january.totalBetweenDay(1, 3)); // sum over days 1..3
+```
+
+In production you would usually **persist** the underlying series in a database and **rebuild** the tree when the period reloads; the tree stays useful in memory for dashboards, simulations, or request handlers that see heavy read/update traffic on the same window.
+
+#### 2. Operations or finance: bulk adjustment on a slice, then aggregate
+
+You apply the **same delta** to **every** element in an index range (tiered bonuses, prorated credits, simulation shocks), then need **range sums** for reporting. A lazy sum tree avoids touching each cell one by one.
+
+```ts
+import { LazySegmentTreeSum } from 'typescript-dsa-stl';
+
+/** Example: per-seat or per-row amounts; apply a flat bonus to ranks 10–50 (0-based 9..49), then sum a sub-range for a sub-team. */
+function simulateBulkBonusAndSubtotal(seatCount: number): void {
+  // Initial per-seat values (e.g. base commission), built once
+  const base = Array.from({ length: seatCount }, (_, i) => 100 + i);
+  const amounts = new LazySegmentTreeSum(base);
+
+  // HR: +250 to everyone in seats 10–50 inclusive (indices 9..49)
+  amounts.rangeAdd(9, 49, 250);
+
+  // Finance: subtotal for seats 20–30 only
+  console.log(amounts.rangeSum(19, 29));
+}
+
+simulateBulkBonusAndSubtotal(100);
+```
+
+The same idea applies to **inventory deltas** across bin ranges, **loyalty points** batch credits by user-ID band (when IDs map to contiguous indices), or **game/simulation** state where many cells gain the same buff and you query partial totals.
+
+---
+
+## Graph algorithms
+
+Graph helpers live on the main package and under `typescript-dsa-stl/collections` for adjacency types and factories.
+
+### Adjacency list (like C++ `vector<vector<type>> graph(n)`)
+
+You can model C++-style adjacency lists using the graph types and helpers exported from `typescript-dsa-stl/collections` (or the main package).
+
+#### Unweighted adjacency list
+
+C++:
+
+```cpp
+int n = 5;
+vector<vector<int>> graph(n);
+graph[u].push_back(v);   // or graph[u].pb(v);
+```
+
+TypeScript (easy declaration with `createAdjacencyList`):
+
+```ts
+import { createAdjacencyList } from 'typescript-dsa-stl/collections';
+
+const n = 5;
+const graph = createAdjacencyList(n);   // empty graph with n vertices
+
+// C++: graph[u].push_back(v);
+graph[u].push(v);
+
+// Iteration is the same idea as in C++
+for (const v of graph[u]) {
+  // neighbor v
+}
+```
+
+Or with helpers `addEdge` / `deleteEdge`:
+
+```ts
+import { createAdjacencyList, addEdge, deleteEdge } from 'typescript-dsa-stl/collections';
+
+const graph = createAdjacencyList(5);
+
+addEdge(graph, u, v);        // add u -> v
+deleteEdge(graph, u, v);     // remove all edges u -> v
+```
+
+#### Weighted adjacency list
+
+In C++ you might write:
+
+```cpp
+int n = 5;
+vector<vector<pair<int,int>>> graph(n);
+graph[u].push_back({v, w});   // edge u -> v with weight w
+```
+
+In TypeScript, use `createWeightedAdjacencyList` for easy declaration:
+
+```ts
+import { createWeightedAdjacencyList } from 'typescript-dsa-stl/collections';
+
+const n = 5;
+const graph = createWeightedAdjacencyList(n);   // empty weighted graph with n vertices
+
+// C++: graph[u].push_back({v, w});
+graph[u].push({ to: v, weight: w });
+
+// When iterating, you get both neighbor and weight
+for (const { to, weight } of graph[u]) {
+  // edge u -> to with cost = weight
+}
+```
+
+Or with the helper functions `addEdge` / `deleteEdge`:
+
+```ts
+import { createWeightedAdjacencyList, addEdge, deleteEdge } from 'typescript-dsa-stl/collections';
+
+const graph = createWeightedAdjacencyList(5);
+
+addEdge(graph, u, v, w);         // add u -> v with weight w
+deleteEdge(graph, u, v, w);      // delete all edges u -> v with weight w
+```
+
+#### Graph adjacency list — use cases
+
+Use an **unweighted** graph (adjacency list) when you only care about connectivity; use a **weighted** graph when edges have costs (distance, time, capacity).
+
+| Use case | When to use |
+|----------|-------------|
+| **BFS / DFS, connectivity** | Unweighted: shortest path in terms of hop count, connected components, cycle detection. |
+| **Shortest path (Dijkstra), MST** | Weighted: edge weights as distances or costs; run Dijkstra, Prim, or Kruskal on the list. |
+| **Social / dependency graphs** | Unweighted or weighted: followers, dependencies (e.g. build order), recommendation graphs. |
+| **Grid / game graphs** | Unweighted: 4- or 8-neighbor grids; weighted if movement costs differ per cell. |
+| **Network / flow** | Weighted: capacities or latencies on edges for max-flow or routing. |
+
+### Breadth-first search (BFS) and depth-first search (DFS)
+
+`breadthFirstSearch` and `depthFirstSearch` take the number of vertices `n`, an unweighted `AdjacencyList`, and a `start` vertex. They return the **visit order** for all vertices **reachable** from `start` (vertices outside that component are not included). For an undirected graph, add each edge in **both** directions (see `addEdge` below).
+
+**Example graph (diamond):** edges `0—1`, `0—2`, `1—3`, `2—3`.
+
+```text
+      0
+     / \
+    1   2
+     \ /
+      3
+```
+
+With neighbors listed in ascending vertex id (`0: [1,2]`, `1: [0,3]`, …), **BFS** from `0` visits by increasing distance from `0`: first `0`, then `1` and `2`, then `3` → order `[0, 1, 2, 3]`. **DFS** (preorder, first neighbor in each list first) goes `0 → 1 → 3` then `2` → order `[0, 1, 3, 2]`. The exact DFS order depends on how you order each adjacency list.
+
+```ts
+import {
+  createAdjacencyList,
+  addEdge,
+  breadthFirstSearch,
+  depthFirstSearch,
+} from 'typescript-dsa-stl';
+
+const n = 4;
+const graph = createAdjacencyList(n);
+
+// Undirected diamond: add both directions for each edge
+addEdge(graph, 0, 1);
 addEdge(graph, 1, 0);
 addEdge(graph, 0, 2);
 addEdge(graph, 2, 0);
@@ -300,7 +646,7 @@ console.log(breadthFirstSearch(5, withIsolated, 0)); // [0, 1] — not [0,1,2,3,
 - **Disconnected graphs:** run again from another unvisited `start`, or use `connectedComponents` to enumerate components first.
 - **Weighted graphs:** for traversal ignoring weights, use the same vertex lists as the unweighted graph (weights are ignored by these two functions).
 
-#### Disjoint Set Union (Union-Find)
+### Disjoint Set Union (Union-Find)
 
 Use Union-Find (DSU) to compute connected components efficiently. It merges endpoints of every edge in the adjacency list, so for directed graphs it returns weak connectivity components.
 
@@ -318,7 +664,7 @@ const comps = connectedComponents(n, graph);
 // e.g. [[0, 1], [2], [3, 4]]
 ```
 
-##### Traverse the result
+#### Traverse the result
 
 `connectedComponents(n, adj)` returns `number[][]` where each inner array is a component (list of vertices).
 
@@ -335,7 +681,7 @@ for (const comp of comps) {
 const sizes = comps.map(comp => comp.length);
 ```
 
-#### Kruskal MST (uses DSU)
+### Kruskal MST (uses DSU)
 
 For a weighted graph, `kruskalMST` builds a Minimum Spanning Tree (MST) using DSU.
 
@@ -359,7 +705,28 @@ const { edges, totalWeight } = kruskalMST(n, wGraph, { undirected: true });
 // edges: MST edges (chosen by weight), totalWeight: sum of weights
 ```
 
-#### Dijkstra shortest paths
+#### Traverse the MST
+
+`kruskalMST(...)` returns `{ edges, totalWeight }`. To traverse the MST like a graph, convert `edges` into an adjacency list:
+
+```ts
+import { createWeightedAdjacencyList } from 'typescript-dsa-stl/collections';
+
+const mstAdj = createWeightedAdjacencyList(n);
+
+for (const { u, v, weight } of edges) {
+  // MST is undirected (we used { undirected: true })
+  mstAdj[u].push({ to: v, weight });
+  mstAdj[v].push({ to: u, weight });
+}
+
+// Example: iterate neighbors of vertex 0 in the MST
+for (const { to, weight } of mstAdj[0]) {
+  // visit edge 0 -> to (weight)
+}
+```
+
+### Dijkstra shortest paths
 
 `dijkstra` computes single-source shortest paths on a **weighted** graph with **non-negative** edge weights.
 It returns:
@@ -391,32 +758,15 @@ const path = reconstructPath(prev, 0, target); // [0, ..., target] or [] if unre
 console.log(path); // [0, 1, 2, 4]
 ```
 
-##### Traverse the MST
-
-`kruskalMST(...)` returns `{ edges, totalWeight }`. To traverse the MST like a graph, convert `edges` into an adjacency list:
-
-```ts
-import { createWeightedAdjacencyList } from 'typescript-dsa-stl/collections';
+---
 
-const mstAdj = createWeightedAdjacencyList(n);
+## String algorithms
 
-for (const { u, v, weight } of edges) {
-  // MST is undirected (we used { undirected: true })
-  mstAdj[u].push({ to: v, weight });
-  mstAdj[v].push({ to: u, weight });
-}
-
-// Example: iterate neighbors of vertex 0 in the MST
-for (const { to, weight } of mstAdj[0]) {
-  // visit edge 0 -> to (weight)
-}
-```
-
-#### Knuth–Morris–Pratt (KMP), Rabin–Karp, and string rolling hash
+### Knuth–Morris–Pratt (KMP), Rabin–Karp, and string rolling hash
 
 All three work on **UTF-16 code units** (same as `String` indexing). They solve **different jobs**: KMP and Rabin–Karp are **pattern matchers** (list all start indices of a pattern in a text). `StringRollingHash` is a **substring-hash tool** on a **fixed** string—you combine it with your own logic (equality checks, binary search, etc.).
 
-##### When to use which
+#### When to use which
 
 | Goal | Prefer | Why |
 |------|--------|-----|
@@ -521,262 +871,6 @@ console.log(a.substringHash(2, 2) === b.fullHash()); // true — both are "na"
 
 ---
 
-## Segment trees
-
-Segment trees support **range queries** and **point updates** in **O(log n)**. Range endpoints are **inclusive**: `query(l, r)` covers indices `l` through `r`.
-
-### Ready-made variants (`SegmentTreeSum`, `SegmentTreeMin`, `SegmentTreeMax`)
-
-```ts
-import {
-  SegmentTreeSum,
-  SegmentTreeMin,
-  SegmentTreeMax,
-} from 'typescript-dsa-stl';
-
-const sum = new SegmentTreeSum([1, 2, 3, 4]);
-console.log(sum.query(0, 3)); // 10
-sum.update(1, 10);
-console.log(sum.query(0, 3)); // 1 + 10 + 3 + 4 = 18
-
-const mn = new SegmentTreeMin([5, 2, 8, 1]);
-console.log(mn.query(0, 3)); // 1
-
-const mx = new SegmentTreeMax([5, 2, 8, 1]);
-console.log(mx.query(0, 3)); // 8
-```
-
-### Generic `SegmentTree<T>` (custom combine + neutral)
-
-Use the same type for array elements and aggregates. Pass an **associative** `combine` and a **neutral** value for query ranges that miss a segment (e.g. `0` for sum, `Infinity` for min).
-
-```ts
-import { SegmentTree } from 'typescript-dsa-stl';
-
-const gcdTree = new SegmentTree<number>(
-  [12, 18, 24],
-  (a, b) => {
-    let x = a;
-    let y = b;
-    while (y !== 0) {
-      const t = y;
-      y = x % y;
-      x = t;
-    }
-    return x;
-  },
-  0
-);
-console.log(gcdTree.query(0, 2)); // gcd(12, 18, 24) === 6
-
-// Non-numeric example: concatenate strings
-const strTree = new SegmentTree<string>(
-  ['a', 'b', 'c'],
-  (a, b) => a + b,
-  ''
-);
-console.log(strTree.query(0, 2)); // 'abc'
-```
-
-### `GeneralSegmentTree<T, V>` (custom merge + buildLeaf)
-
-Use when **raw** values `V` differ from the **aggregate** type `T`:
-
-- **`merge(left, right)`** — combine two child aggregates (internal nodes).
-- **`neutral`** — identity for `merge` when a query does not overlap a segment.
-- **`buildLeaf(value, index)`** — build the leaf from the raw array on initial construction and on every `update`.
-
-```ts
-import { GeneralSegmentTree } from 'typescript-dsa-stl';
-
-// Store sum of squares; raw array is plain numbers
-const st = new GeneralSegmentTree<number, number>([1, 2, 3], {
-  merge: (a, b) => a + b,
-  neutral: 0,
-  buildLeaf: (v, i) => v * v + i,
-});
-console.log(st.query(0, 2)); // (1+0) + (4+1) + (9+2) = 17
-st.update(1, 4);
-console.log(st.rawAt(1)); // 4 — current raw value at index 1
-```
-
-### `LazySegmentTreeSum` (range add + range sum)
-
-**`rangeAdd(l, r, delta)`** adds `delta` to every element in the inclusive range. **`rangeSum(l, r)`** returns the sum. **`set(i, value)`** assigns one position (lazy tags are applied along the path). All are **O(log n)**.
-
-```ts
-import { LazySegmentTreeSum } from 'typescript-dsa-stl';
-
-const lazy = new LazySegmentTreeSum([0, 0, 0, 0]);
-lazy.rangeAdd(1, 2, 5); // indices 1 and 2 get +5
-console.log(lazy.rangeSum(0, 3)); // 10
-lazy.set(0, 100);
-console.log(lazy.rangeSum(0, 3)); // 100 + 5 + 5 + 0
-```
-
-### Real-world use cases
-
-These patterns show up in backends and internal tools when you need **many** range queries and updates on a fixed sequence (length known up front), without scanning the whole array each time.
-
-#### 1. Analytics or reporting: totals over a time window (with corrections)
-
-Each index is a **fixed bucket** (hour of day, day of month, version slot, etc.). You repeatedly ask “what is the **sum** from bucket `a` through `b`?” and sometimes **fix one bucket** after late data or a reconciliation.
-
-```ts
-import { SegmentTreeSum } from 'typescript-dsa-stl';
-
-/** Revenue (or events, page views, API calls) per calendar day; index 0 = first day of period. */
-class PeriodMetrics {
-  private readonly tree: SegmentTreeSum;
-
-  constructor(dailyValues: readonly number[]) {
-    this.tree = new SegmentTreeSum(dailyValues);
-  }
-
-  /** Total for an inclusive day range — e.g. chart drill-down or export row. */
-  totalBetweenDay(firstDayIndex: number, lastDayIndex: number): number {
-    return this.tree.query(firstDayIndex, lastDayIndex);
-  }
-
-  /** Backfill or correct one day without rebuilding the whole series. */
-  setDay(dayIndex: number, amount: number): void {
-    this.tree.update(dayIndex, amount);
-  }
-}
-
-const january = new PeriodMetrics([1200, 980, 1100, 1050, 1300]);
-console.log(january.totalBetweenDay(0, 4)); // full period
-january.setDay(2, 1150); // corrected day 2
-console.log(january.totalBetweenDay(1, 3)); // sum over days 1..3
-```
-
-In production you would usually **persist** the underlying series in a database and **rebuild** the tree when the period reloads; the tree stays useful in memory for dashboards, simulations, or request handlers that see heavy read/update traffic on the same window.
-
-#### 2. Operations or finance: bulk adjustment on a slice, then aggregate
-
-You apply the **same delta** to **every** element in an index range (tiered bonuses, prorated credits, simulation shocks), then need **range sums** for reporting. A lazy sum tree avoids touching each cell one by one.
-
-```ts
-import { LazySegmentTreeSum } from 'typescript-dsa-stl';
-
-/** Example: per-seat or per-row amounts; apply a flat bonus to ranks 10–50 (0-based 9..49), then sum a sub-range for a sub-team. */
-function simulateBulkBonusAndSubtotal(seatCount: number): void {
-  // Initial per-seat values (e.g. base commission), built once
-  const base = Array.from({ length: seatCount }, (_, i) => 100 + i);
-  const amounts = new LazySegmentTreeSum(base);
-
-  // HR: +250 to everyone in seats 10–50 inclusive (indices 9..49)
-  amounts.rangeAdd(9, 49, 250);
-
-  // Finance: subtotal for seats 20–30 only
-  console.log(amounts.rangeSum(19, 29));
-}
-
-simulateBulkBonusAndSubtotal(100);
-```
-
-The same idea applies to **inventory deltas** across bin ranges, **loyalty points** batch credits by user-ID band (when IDs map to contiguous indices), or **game/simulation** state where many cells gain the same buff and you query partial totals.
-
----
-
-## API overview
-
-| Module | Exports |
-|--------|--------|
-| **Collections** | `Vector`, `Stack`, `Queue`, `List`, `ListNode`, `PriorityQueue`, `OrderedMap`, `UnorderedMap`, `OrderedSet`, `UnorderedSet`, `OrderedMultiMap`, `OrderedMultiSet`, `GeneralSegmentTree`, `SegmentTree`, `SegmentTreeSum`, `SegmentTreeMin`, `SegmentTreeMax`, `LazySegmentTreeSum`, `WeightedEdge`, `AdjacencyList`, `WeightedAdjacencyList`, `createAdjacencyList`, `createWeightedAdjacencyList`, `addEdge`, `deleteEdge` |
-| **Algorithms** | `sort`, `find`, `findIndex`, `transform`, `filter`, `reduce`, `reverse`, `unique`, `binarySearch`, `lowerBound`, `upperBound`, `min`, `max`, `partition`, `DisjointSetUnion`, `KnuthMorrisPratt`, `RabinKarp`, `RABIN_KARP_DEFAULT_MODS`, `StringRollingHash`, `breadthFirstSearch`, `depthFirstSearch`, `connectedComponents`, `kruskalMST` |
-| **Utils** | `clamp`, `range`, `noop`, `identity`, `swap` |
-| **Types** | `Comparator`, `Predicate`, `UnaryFn`, `Reducer`, `IterableLike`, `toArray`, `RabinKarpTripleMods`, `GeneralSegmentTreeConfig`, `SegmentCombine`, `SegmentMerge`, `SegmentLeafBuild` |
-
-### Subpath imports (tree-shaking)
-
-```ts
-import { Vector, Stack } from 'typescript-dsa-stl/collections';
-import { sort, binarySearch, breadthFirstSearch, depthFirstSearch, KnuthMorrisPratt, RabinKarp, StringRollingHash } from 'typescript-dsa-stl/algorithms';
-import { clamp, range } from 'typescript-dsa-stl/utils';
-import type { Comparator } from 'typescript-dsa-stl/types';
-```
-
----
-
-## Data structures
-
-| Structure | Access | Insert end | Insert middle | Remove end | Remove middle |
-|-----------|--------|------------|---------------|------------|---------------|
-| **Vector** | O(1) | O(1)* | O(n) | O(1) | O(n) |
-| **Stack** | — | O(1) | — | O(1) | — |
-| **Queue** | — | O(1)* | — | O(1)* | — |
-| **List** | O(n) | O(1) | O(1)** | O(1) | O(1)** |
-| **PriorityQueue** | — | O(log n) | — | O(log n) | — |
-| **OrderedMap** (Map) | O(log n) get | O(log n) set | — | O(log n) delete | — |
-| **UnorderedMap** | O(1)* get/set | O(1)* | — | O(1)* delete | — |
-| **OrderedSet** (Set) | O(log n) has | O(log n) add | — | O(log n) delete | — |
-| **UnorderedSet** | O(1)* has/add | O(1)* | — | O(1)* delete | — |
-| **OrderedMultiMap** | O(log n) get | O(log n) set | — | O(log n) delete | — |
-| **OrderedMultiSet** | O(log n) has/count | O(log n) add | — | O(log n) delete | — |
-
-\* Amortized (hash).  
-\** At a known node.
-
-### Segment trees (range queries)
-
-| Structure | Build | Point update | Range query | Extra |
-|-----------|-------|--------------|-------------|--------|
-| **GeneralSegmentTree**, **SegmentTree**, **SegmentTreeSum** / **Min** / **Max** | O(n) | O(log n) | O(log n) | Inclusive `[l, r]`; **GeneralSegmentTree** keeps raw `V` and uses `merge` + `buildLeaf` |
-| **LazySegmentTreeSum** | O(n) | `set`: O(log n) | `rangeSum`: O(log n) | `rangeAdd` on a range: O(log n) |
-
----
-
-## OrderedMultiMap and OrderedMultiSet — use cases
-
-**OrderedMultiSet** is a sorted collection that allows duplicate elements (like C++ `std::multiset`). Use it when you need ordering and multiple copies of the same value.
-
-| Use case | Example |
-|----------|---------|
-| **Sorted runs / leaderboard with ties** | Store scores; multiple users can have the same score. Iterate in sorted order, use `count(score)` for ties. |
-| **Event timeline with repeated timestamps** | Add events by time; several events can share the same time. `add(timestamp)`, iterate in order. |
-| **K-th smallest in a multiset** | Keep elements sorted; k-th element is at index `k - 1` in iteration. |
-| **Range counts** | Combined with binary search ideas: count elements in `[low, high]` using `count` and iteration. |
-
-**OrderedMultiMap** maps one key to multiple values while keeping keys sorted (like C++ `std::multimap`). Use it when a key can have several associated values and you need key order.
-
-| Use case | Example |
-|----------|---------|
-| **Inverted index** | Key = term, values = document IDs containing that term. `set(term, docId)` for each occurrence; `getAll(term)` returns all doc IDs. |
-| **Grouping by key** | Key = category, values = items. `set(category, item)`; iterate keys in order, use `getAll(key)` per group. |
-| **One-to-many relations** | Key = user ID, values = session IDs. `set(userId, sessionId)`; `getAll(userId)` lists all sessions. |
-| **Time-series by bucket** | Key = time bucket, values = events. Sorted keys give chronological buckets; `getAll(bucket)` gets events in that bucket. |
-
-### OrderedMultiSet example
-
-```ts
-import { OrderedMultiSet } from 'typescript-dsa-stl';
-
-const scores = new OrderedMultiSet<number>();
-scores.add(85); scores.add(92); scores.add(85); scores.add(78);
-console.log(scores.toArray());   // [78, 85, 85, 92]
-console.log(scores.count(85));   // 2
-scores.delete(85);               // remove one 85
-console.log(scores.count(85));   // 1
-scores.deleteAll(85);            // remove all 85s
-```
-
-### OrderedMultiMap example
-
-```ts
-import { OrderedMultiMap } from 'typescript-dsa-stl';
-
-const index = new OrderedMultiMap<string, number>();  // term -> doc IDs
-index.set('typescript', 1); index.set('typescript', 3); index.set('stl', 2);
-console.log(index.getAll('typescript'));  // [1, 3]
-console.log(index.get('stl'));            // 2
-for (const [key, value] of index) {
-  console.log(key, value);               // keys in sorted order
-}
-```
-
----
-
 ## For maintainers
 
 - **Build:** `npm run build` (also runs before `npm publish` via `prepublishOnly`)

package/dist/collections/Deque.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Double-ended queue (STL `std::deque`-style API in camelCase).
+ *
+ * Backed by a growable circular buffer: amortized **O(1)** `pushFront` / `pushBack` /
+ * `popFront` / `popBack`, and **O(1)** indexed `at` / `set` (unlike a linked list).
+ */
+export declare class Deque<T> {
+    private _buf;
+    private _head;
+    private _size;
+    /**
+     * @param initial — initial capacity (number), or copy elements in order from an array.
+     */
+    constructor(initial?: readonly T[] | number);
+    get size(): number;
+    get empty(): boolean;
+    /** Current backing slot count (≥ size). */
+    get capacity(): number;
+    private grow;
+    private ensureSpace;
+    /** Ensure buffer has room for at least `n` elements total (may shrink logical size only via pop/clear). */
+    reserve(minCapacity: number): void;
+    /** Drop unused buffer capacity (keeps current elements). */
+    shrinkToFit(): void;
+    private indexPhysical;
+    at(index: number): T;
+    set(index: number, value: T): void;
+    /** Same as C++ `push_front`. */
+    pushFront(value: T): void;
+    /** Same as C++ `push_back`. */
+    pushBack(value: T): void;
+    /** Same as C++ `pop_front`. */
+    popFront(): T | undefined;
+    /** Same as C++ `pop_back`. */
+    popBack(): T | undefined;
+    /** Same as C++ `front`. */
+    front(): T;
+    /** Same as C++ `back`. */
+    back(): T;
+    clear(): void;
+    [Symbol.iterator](): Iterator<T>;
+    toArray(): T[];
+}
+//# sourceMappingURL=Deque.d.ts.map

package/dist/collections/Deque.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Deque.d.ts","sourceRoot":"","sources":["../../src/collections/Deque.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,qBAAa,KAAK,CAAC,CAAC;IAClB,OAAO,CAAC,IAAI,CAAoB;IAChC,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,KAAK,CAAK;IAElB;;OAEG;gBACS,OAAO,CAAC,EAAE,SAAS,CAAC,EAAE,GAAG,MAAM;IAkB3C,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,KAAK,IAAI,OAAO,CAEnB;IAED,2CAA2C;IAC3C,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,OAAO,CAAC,IAAI;IAUZ,OAAO,CAAC,WAAW;IAKnB,2GAA2G;IAC3G,OAAO,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAWlC,4DAA4D;IAC5D,WAAW,IAAI,IAAI;IAgBnB,OAAO,CAAC,aAAa;IAIrB,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC;IAOpB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAOlC,gCAAgC;IAChC,SAAS,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAQzB,+BAA+B;IAC/B,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAOxB,+BAA+B;IAC/B,QAAQ,IAAI,CAAC,GAAG,SAAS;IAUzB,8BAA8B;IAC9B,OAAO,IAAI,CAAC,GAAG,SAAS;IAUxB,2BAA2B;IAC3B,KAAK,IAAI,CAAC;IAKV,0BAA0B;IAC1B,IAAI,IAAI,CAAC;IAMT,KAAK,IAAI,IAAI;IAMb,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC;IAgBhC,OAAO,IAAI,CAAC,EAAE;CAQf"}

package/dist/collections/Deque.js

@@ -0,0 +1,178 @@
+/**
+ * Double-ended queue (STL `std::deque`-style API in camelCase).
+ *
+ * Backed by a growable circular buffer: amortized **O(1)** `pushFront` / `pushBack` /
+ * `popFront` / `popBack`, and **O(1)** indexed `at` / `set` (unlike a linked list).
+ */
+export class Deque {
+    /**
+     * @param initial — initial capacity (number), or copy elements in order from an array.
+     */
+    constructor(initial) {
+        this._head = 0;
+        this._size = 0;
+        if (initial === undefined) {
+            this._buf = new Array(16);
+            return;
+        }
+        if (typeof initial === 'number') {
+            this._buf = new Array(Math.max(4, initial));
+            return;
+        }
+        const n = initial.length;
+        const cap = Math.max(16, n <= 4 ? 4 : 2 ** Math.ceil(Math.log2(n)));
+        this._buf = new Array(cap);
+        for (let i = 0; i < n; i++) {
+            this._buf[i] = initial[i];
+        }
+        this._size = n;
+    }
+    get size() {
+        return this._size;
+    }
+    get empty() {
+        return this._size === 0;
+    }
+    /** Current backing slot count (≥ size). */
+    get capacity() {
+        return this._buf.length;
+    }
+    grow() {
+        const cap = this._buf.length;
+        const next = new Array(Math.max(4, cap * 2));
+        for (let i = 0; i < this._size; i++) {
+            next[i] = this._buf[(this._head + i) % cap];
+        }
+        this._buf = next;
+        this._head = 0;
+    }
+    ensureSpace() {
+        if (this._size < this._buf.length)
+            return;
+        this.grow();
+    }
+    /** Ensure buffer has room for at least `n` elements total (may shrink logical size only via pop/clear). */
+    reserve(minCapacity) {
+        if (minCapacity <= this._buf.length)
+            return;
+        const next = new Array(minCapacity);
+        const cap = this._buf.length;
+        for (let i = 0; i < this._size; i++) {
+            next[i] = this._buf[(this._head + i) % cap];
+        }
+        this._buf = next;
+        this._head = 0;
+    }
+    /** Drop unused buffer capacity (keeps current elements). */
+    shrinkToFit() {
+        if (this._size === this._buf.length)
+            return;
+        if (this._size === 0) {
+            this._buf = new Array(4);
+            this._head = 0;
+            return;
+        }
+        const next = new Array(this._size);
+        const cap = this._buf.length;
+        for (let i = 0; i < this._size; i++) {
+            next[i] = this._buf[(this._head + i) % cap];
+        }
+        this._buf = next;
+        this._head = 0;
+    }
+    indexPhysical(i) {
+        return (this._head + i) % this._buf.length;
+    }
+    at(index) {
+        if (index < 0 || index >= this._size) {
+            throw new RangeError(`Deque index ${index} out of range (size ${this._size})`);
+        }
+        return this._buf[this.indexPhysical(index)];
+    }
+    set(index, value) {
+        if (index < 0 || index >= this._size) {
+            throw new RangeError(`Deque index ${index} out of range (size ${this._size})`);
+        }
+        this._buf[this.indexPhysical(index)] = value;
+    }
+    /** Same as C++ `push_front`. */
+    pushFront(value) {
+        this.ensureSpace();
+        const cap = this._buf.length;
+        this._head = (this._head - 1 + cap) % cap;
+        this._buf[this._head] = value;
+        this._size++;
+    }
+    /** Same as C++ `push_back`. */
+    pushBack(value) {
+        this.ensureSpace();
+        const cap = this._buf.length;
+        this._buf[(this._head + this._size) % cap] = value;
+        this._size++;
+    }
+    /** Same as C++ `pop_front`. */
+    popFront() {
+        if (this._size === 0)
+            return undefined;
+        const cap = this._buf.length;
+        const value = this._buf[this._head];
+        this._buf[this._head] = undefined;
+        this._head = (this._head + 1) % cap;
+        this._size--;
+        return value;
+    }
+    /** Same as C++ `pop_back`. */
+    popBack() {
+        if (this._size === 0)
+            return undefined;
+        const cap = this._buf.length;
+        const idx = (this._head + this._size - 1 + cap) % cap;
+        const value = this._buf[idx];
+        this._buf[idx] = undefined;
+        this._size--;
+        return value;
+    }
+    /** Same as C++ `front`. */
+    front() {
+        if (this._size === 0)
+            throw new RangeError('Deque is empty');
+        return this._buf[this._head];
+    }
+    /** Same as C++ `back`. */
+    back() {
+        if (this._size === 0)
+            throw new RangeError('Deque is empty');
+        const cap = this._buf.length;
+        return this._buf[(this._head + this._size - 1 + cap) % cap];
+    }
+    clear() {
+        this._buf = new Array(this._buf.length);
+        this._head = 0;
+        this._size = 0;
+    }
+    [Symbol.iterator]() {
+        const buf = this._buf;
+        const cap = buf.length;
+        const head = this._head;
+        const size = this._size;
+        let i = 0;
+        return {
+            next() {
+                if (i >= size)
+                    return { done: true, value: undefined };
+                const value = buf[(head + i) % cap];
+                i++;
+                return { done: false, value };
+            },
+        };
+    }
+    toArray() {
+        const out = [];
+        const cap = this._buf.length;
+        for (let i = 0; i < this._size; i++) {
+            out.push(this._buf[(this._head + i) % cap]);
+        }
+        return out;
+    }
+}
+//# sourceMappingURL=Deque.js.map

package/dist/collections/Deque.js.map

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

package/dist/collections/index.d.ts

@@ -1,6 +1,7 @@
 export { Vector } from './Vector.js';
 export { Stack } from './Stack.js';
 export { Queue } from './Queue.js';
+export { Deque } from './Deque.js';
 export { List, ListNode } from './List.js';
 export { PriorityQueue } from './PriorityQueue.js';
 export { OrderedMap } from './OrderedMap.js';

package/dist/collections/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/collections/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EACL,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,cAAc,EACd,cAAc,EACd,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,wBAAwB,EACxB,cAAc,EACd,gBAAgB,EAChB,YAAY,GACb,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACrF,OAAO,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/collections/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EACL,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,cAAc,EACd,cAAc,EACd,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,wBAAwB,EACxB,cAAc,EACd,gBAAgB,EAChB,YAAY,GACb,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACrF,OAAO,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC"}

package/dist/collections/index.js

@@ -1,6 +1,7 @@
 export { Vector } from './Vector.js';
 export { Stack } from './Stack.js';
 export { Queue } from './Queue.js';
+export { Deque } from './Deque.js';
 export { List, ListNode } from './List.js';
 export { PriorityQueue } from './PriorityQueue.js';
 export { OrderedMap } from './OrderedMap.js';

package/dist/collections/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/collections/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EACL,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,cAAc,EACd,cAAc,EACd,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAQ1B,OAAO,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/collections/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EACL,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,cAAc,EACd,cAAc,EACd,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAQ1B,OAAO,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.d.ts

@@ -5,7 +5,7 @@
  * @example
  * import { Vector, Stack, Queue, List, sort, binarySearch, clamp } from 'typescript-dsa-stl';
  */
-export { Vector, Stack, Queue, List, ListNode, PriorityQueue, OrderedMap, UnorderedMap, OrderedSet, UnorderedSet, OrderedMultiSet, OrderedMultiMap, addEdge, deleteEdge, createAdjacencyList, createWeightedAdjacencyList, GeneralSegmentTree, SegmentTree, SegmentTreeSum, SegmentTreeMin, SegmentTreeMax, LazySegmentTreeSum, } from './collections/index.js';
+export { Vector, Stack, Queue, Deque, List, ListNode, PriorityQueue, OrderedMap, UnorderedMap, OrderedSet, UnorderedSet, OrderedMultiSet, OrderedMultiMap, addEdge, deleteEdge, createAdjacencyList, createWeightedAdjacencyList, GeneralSegmentTree, SegmentTree, SegmentTreeSum, SegmentTreeMin, SegmentTreeMax, LazySegmentTreeSum, } from './collections/index.js';
 export type { WeightedEdge, AdjacencyList, WeightedAdjacencyList, GeneralSegmentTreeConfig, SegmentCombine, SegmentLeafBuild, SegmentMerge, } from './collections/index.js';
 export { sort, find, findIndex, transform, filter, reduce, reverse, unique, binarySearch, lowerBound, upperBound, min, max, partition, DisjointSetUnion, KnuthMorrisPratt, StringRollingHash, RabinKarp, RABIN_KARP_DEFAULT_MODS, breadthFirstSearch, depthFirstSearch, connectedComponents, dijkstra, reconstructPath, kruskalMST, } from './algorithms/index.js';
 export type { WeightedUndirectedEdge, RabinKarpTripleMods } from './algorithms/index.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,UAAU,EACV,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,eAAe,EACf,eAAe,EACf,OAAO,EACP,UAAU,EACV,mBAAmB,EACnB,2BAA2B,EAC3B,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,cAAc,EACd,cAAc,EACd,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EACV,YAAY,EACZ,aAAa,EACb,qBAAqB,EACrB,wBAAwB,EACxB,cAAc,EACd,gBAAgB,EAChB,YAAY,GACb,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,SAAS,EACT,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAChB,mBAAmB,EACnB,QAAQ,EACR,eAAe,EACf,UAAU,GACX,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACzF,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACtE,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC9F,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,UAAU,EACV,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,eAAe,EACf,eAAe,EACf,OAAO,EACP,UAAU,EACV,mBAAmB,EACnB,2BAA2B,EAC3B,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,cAAc,EACd,cAAc,EACd,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EACV,YAAY,EACZ,aAAa,EACb,qBAAqB,EACrB,wBAAwB,EACxB,cAAc,EACd,gBAAgB,EAChB,YAAY,GACb,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,SAAS,EACT,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAChB,mBAAmB,EACnB,QAAQ,EACR,eAAe,EACf,UAAU,GACX,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACzF,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACtE,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC9F,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -5,7 +5,7 @@
  * @example
  * import { Vector, Stack, Queue, List, sort, binarySearch, clamp } from 'typescript-dsa-stl';
  */
-export { Vector, Stack, Queue, List, ListNode, PriorityQueue, OrderedMap, UnorderedMap, OrderedSet, UnorderedSet, OrderedMultiSet, OrderedMultiMap, addEdge, deleteEdge, createAdjacencyList, createWeightedAdjacencyList, GeneralSegmentTree, SegmentTree, SegmentTreeSum, SegmentTreeMin, SegmentTreeMax, LazySegmentTreeSum, } from './collections/index.js';
+export { Vector, Stack, Queue, Deque, List, ListNode, PriorityQueue, OrderedMap, UnorderedMap, OrderedSet, UnorderedSet, OrderedMultiSet, OrderedMultiMap, addEdge, deleteEdge, createAdjacencyList, createWeightedAdjacencyList, GeneralSegmentTree, SegmentTree, SegmentTreeSum, SegmentTreeMin, SegmentTreeMax, LazySegmentTreeSum, } from './collections/index.js';
 export { sort, find, findIndex, transform, filter, reduce, reverse, unique, binarySearch, lowerBound, upperBound, min, max, partition, DisjointSetUnion, KnuthMorrisPratt, StringRollingHash, RabinKarp, RABIN_KARP_DEFAULT_MODS, breadthFirstSearch, depthFirstSearch, connectedComponents, dijkstra, reconstructPath, kruskalMST, } from './algorithms/index.js';
 export { clamp, range, noop, identity, swap } from './utils/index.js';
 export { toArray } from './types/index.js';

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,UAAU,EACV,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,eAAe,EACf,eAAe,EACf,OAAO,EACP,UAAU,EACV,mBAAmB,EACnB,2BAA2B,EAC3B,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,cAAc,EACd,cAAc,EACd,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAUhC,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,SAAS,EACT,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAChB,mBAAmB,EACnB,QAAQ,EACR,eAAe,EACf,UAAU,GACX,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAEtE,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,UAAU,EACV,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,eAAe,EACf,eAAe,EACf,OAAO,EACP,UAAU,EACV,mBAAmB,EACnB,2BAA2B,EAC3B,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,cAAc,EACd,cAAc,EACd,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAUhC,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,SAAS,EACT,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAChB,mBAAmB,EACnB,QAAQ,EACR,eAAe,EACf,UAAU,GACX,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAEtE,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typescript-dsa-stl",
-  "version": "2.5.0",
-  "description": "STL-style data structures and algorithms for TypeScript: Vector, Stack, Queue, List, PriorityQueue, Map, Set, sort, binarySearch, graph utilities. Use like C++ STL.",
+  "version": "2.7.0",
+  "description": "STL-style data structures and algorithms for TypeScript: Vector, Stack, Queue, Deque (double-ended queue), List, PriorityQueue, Map, Set, sort, binarySearch, graph utilities. Use like C++ STL.",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -52,6 +52,8 @@
     "vector",
     "stack",
     "queue",
+    "deque",
+    "double-ended-queue",
     "list",
     "priority-queue",
     "map",