data-structure-typed 2.5.0 → 2.5.2

package/.vitepress/cache/deps_temp_51f5f1b0/vue.js

@@ -0,0 +1,347 @@
+import {
+  BaseTransition,
+  BaseTransitionPropsValidators,
+  Comment,
+  DeprecationTypes,
+  EffectScope,
+  ErrorCodes,
+  ErrorTypeStrings,
+  Fragment,
+  KeepAlive,
+  ReactiveEffect,
+  Static,
+  Suspense,
+  Teleport,
+  Text,
+  TrackOpTypes,
+  Transition,
+  TransitionGroup,
+  TriggerOpTypes,
+  VueElement,
+  assertNumber,
+  callWithAsyncErrorHandling,
+  callWithErrorHandling,
+  camelize,
+  capitalize,
+  cloneVNode,
+  compatUtils,
+  compile,
+  computed,
+  createApp,
+  createBaseVNode,
+  createBlock,
+  createCommentVNode,
+  createElementBlock,
+  createHydrationRenderer,
+  createPropsRestProxy,
+  createRenderer,
+  createSSRApp,
+  createSlots,
+  createStaticVNode,
+  createTextVNode,
+  createVNode,
+  customRef,
+  defineAsyncComponent,
+  defineComponent,
+  defineCustomElement,
+  defineEmits,
+  defineExpose,
+  defineModel,
+  defineOptions,
+  defineProps,
+  defineSSRCustomElement,
+  defineSlots,
+  devtools,
+  effect,
+  effectScope,
+  getCurrentInstance,
+  getCurrentScope,
+  getCurrentWatcher,
+  getTransitionRawChildren,
+  guardReactiveProps,
+  h,
+  handleError,
+  hasInjectionContext,
+  hydrate,
+  hydrateOnIdle,
+  hydrateOnInteraction,
+  hydrateOnMediaQuery,
+  hydrateOnVisible,
+  initCustomFormatter,
+  initDirectivesForSSR,
+  inject,
+  isMemoSame,
+  isProxy,
+  isReactive,
+  isReadonly,
+  isRef,
+  isRuntimeOnly,
+  isShallow,
+  isVNode,
+  markRaw,
+  mergeDefaults,
+  mergeModels,
+  mergeProps,
+  nextTick,
+  nodeOps,
+  normalizeClass,
+  normalizeProps,
+  normalizeStyle,
+  onActivated,
+  onBeforeMount,
+  onBeforeUnmount,
+  onBeforeUpdate,
+  onDeactivated,
+  onErrorCaptured,
+  onMounted,
+  onRenderTracked,
+  onRenderTriggered,
+  onScopeDispose,
+  onServerPrefetch,
+  onUnmounted,
+  onUpdated,
+  onWatcherCleanup,
+  openBlock,
+  patchProp,
+  popScopeId,
+  provide,
+  proxyRefs,
+  pushScopeId,
+  queuePostFlushCb,
+  reactive,
+  readonly,
+  ref,
+  registerRuntimeCompiler,
+  render,
+  renderList,
+  renderSlot,
+  resolveComponent,
+  resolveDirective,
+  resolveDynamicComponent,
+  resolveFilter,
+  resolveTransitionHooks,
+  setBlockTracking,
+  setDevtoolsHook,
+  setTransitionHooks,
+  shallowReactive,
+  shallowReadonly,
+  shallowRef,
+  ssrContextKey,
+  ssrUtils,
+  stop,
+  toDisplayString,
+  toHandlerKey,
+  toHandlers,
+  toRaw,
+  toRef,
+  toRefs,
+  toValue,
+  transformVNodeArgs,
+  triggerRef,
+  unref,
+  useAttrs,
+  useCssModule,
+  useCssVars,
+  useHost,
+  useId,
+  useModel,
+  useSSRContext,
+  useShadowRoot,
+  useSlots,
+  useTemplateRef,
+  useTransitionState,
+  vModelCheckbox,
+  vModelDynamic,
+  vModelRadio,
+  vModelSelect,
+  vModelText,
+  vShow,
+  version,
+  warn,
+  watch,
+  watchEffect,
+  watchPostEffect,
+  watchSyncEffect,
+  withAsyncContext,
+  withCtx,
+  withDefaults,
+  withDirectives,
+  withKeys,
+  withMemo,
+  withModifiers,
+  withScopeId
+} from "./chunk-7OIKW5WK.js";
+export {
+  BaseTransition,
+  BaseTransitionPropsValidators,
+  Comment,
+  DeprecationTypes,
+  EffectScope,
+  ErrorCodes,
+  ErrorTypeStrings,
+  Fragment,
+  KeepAlive,
+  ReactiveEffect,
+  Static,
+  Suspense,
+  Teleport,
+  Text,
+  TrackOpTypes,
+  Transition,
+  TransitionGroup,
+  TriggerOpTypes,
+  VueElement,
+  assertNumber,
+  callWithAsyncErrorHandling,
+  callWithErrorHandling,
+  camelize,
+  capitalize,
+  cloneVNode,
+  compatUtils,
+  compile,
+  computed,
+  createApp,
+  createBlock,
+  createCommentVNode,
+  createElementBlock,
+  createBaseVNode as createElementVNode,
+  createHydrationRenderer,
+  createPropsRestProxy,
+  createRenderer,
+  createSSRApp,
+  createSlots,
+  createStaticVNode,
+  createTextVNode,
+  createVNode,
+  customRef,
+  defineAsyncComponent,
+  defineComponent,
+  defineCustomElement,
+  defineEmits,
+  defineExpose,
+  defineModel,
+  defineOptions,
+  defineProps,
+  defineSSRCustomElement,
+  defineSlots,
+  devtools,
+  effect,
+  effectScope,
+  getCurrentInstance,
+  getCurrentScope,
+  getCurrentWatcher,
+  getTransitionRawChildren,
+  guardReactiveProps,
+  h,
+  handleError,
+  hasInjectionContext,
+  hydrate,
+  hydrateOnIdle,
+  hydrateOnInteraction,
+  hydrateOnMediaQuery,
+  hydrateOnVisible,
+  initCustomFormatter,
+  initDirectivesForSSR,
+  inject,
+  isMemoSame,
+  isProxy,
+  isReactive,
+  isReadonly,
+  isRef,
+  isRuntimeOnly,
+  isShallow,
+  isVNode,
+  markRaw,
+  mergeDefaults,
+  mergeModels,
+  mergeProps,
+  nextTick,
+  nodeOps,
+  normalizeClass,
+  normalizeProps,
+  normalizeStyle,
+  onActivated,
+  onBeforeMount,
+  onBeforeUnmount,
+  onBeforeUpdate,
+  onDeactivated,
+  onErrorCaptured,
+  onMounted,
+  onRenderTracked,
+  onRenderTriggered,
+  onScopeDispose,
+  onServerPrefetch,
+  onUnmounted,
+  onUpdated,
+  onWatcherCleanup,
+  openBlock,
+  patchProp,
+  popScopeId,
+  provide,
+  proxyRefs,
+  pushScopeId,
+  queuePostFlushCb,
+  reactive,
+  readonly,
+  ref,
+  registerRuntimeCompiler,
+  render,
+  renderList,
+  renderSlot,
+  resolveComponent,
+  resolveDirective,
+  resolveDynamicComponent,
+  resolveFilter,
+  resolveTransitionHooks,
+  setBlockTracking,
+  setDevtoolsHook,
+  setTransitionHooks,
+  shallowReactive,
+  shallowReadonly,
+  shallowRef,
+  ssrContextKey,
+  ssrUtils,
+  stop,
+  toDisplayString,
+  toHandlerKey,
+  toHandlers,
+  toRaw,
+  toRef,
+  toRefs,
+  toValue,
+  transformVNodeArgs,
+  triggerRef,
+  unref,
+  useAttrs,
+  useCssModule,
+  useCssVars,
+  useHost,
+  useId,
+  useModel,
+  useSSRContext,
+  useShadowRoot,
+  useSlots,
+  useTemplateRef,
+  useTransitionState,
+  vModelCheckbox,
+  vModelDynamic,
+  vModelRadio,
+  vModelSelect,
+  vModelText,
+  vShow,
+  version,
+  warn,
+  watch,
+  watchEffect,
+  watchPostEffect,
+  watchSyncEffect,
+  withAsyncContext,
+  withCtx,
+  withDefaults,
+  withDirectives,
+  withKeys,
+  withMemo,
+  withModifiers,
+  withScopeId
+};
+//# sourceMappingURL=vue.js.map

package/CHANGELOG.md

@@ -8,7 +8,11 @@ All notable changes to this project will be documented in this file.
 - [Semantic Versioning](https://semver.org/spec/v2.0.0.html)
 - [`auto-changelog`](https://github.com/CookPete/auto-changelog)
 
-## [v2.5.0](https://github.com/zrwusa/data-structure-typed/compare/v2.4.3...main) (upcoming)
+## [v2.5.2](https://github.com/zrwusa/data-structure-typed/compare/v2.5.1...main) (upcoming)
+
+## [v2.5.1](https://github.com/zrwusa/data-structure-typed/compare/v2.5.0...v2.5.1) (28 March 2026)
+
+## [v2.5.0](https://github.com/zrwusa/data-structure-typed/compare/v2.4.3...v2.5.0) (27 March 2026)
 
 ### Changes
 

package/README.md

@@ -2,9 +2,9 @@
 
 English | [简体中文](./README_CN.md)
 
-A comprehensive TypeScript data structures library with production-ready implementations.
+A production-ready TypeScript data structures library featuring **Heap, Priority Queue, Deque, Trie, Graph, Red-Black Tree, TreeMap, TreeSet, SkipList, Segment Tree**, and more — with an API that feels as intuitive as JavaScript's native `Array`. Zero dependencies. Type-safe. Supports rank queries (`getRank`), positional access (`getByRank`), and range queries (`rangeByRank`).
 
-**We TypeScript/JavaScript devs want something like C++'s `STL`, Java's `java.util` Collections, or Python's `collections` — but with an API that feels as intuitive and ergonomic as JavaScript's native `Array`.** If that's what you're looking for, you're in the right place. This is a zero-dependency library, and you can also install individual data structure packages separately if you prefer a more modular setup.
+> **Looking for a TreeMap or TreeSet in JavaScript?** Need a priority queue, an ordered set, or efficient rank/range queries? Tired of repeatedly sorting arrays after every insert? This library provides all of that with a unified, Array-like API.
 
 ![npm](https://img.shields.io/npm/dm/data-structure-typed)
 ![GitHub contributors](https://img.shields.io/github/contributors/zrwusa/data-structure-typed)
@@ -14,7 +14,7 @@ A comprehensive TypeScript data structures library with production-ready impleme
 ![NPM](https://img.shields.io/npm/l/data-structure-typed)
 ![npm](https://img.shields.io/npm/v/data-structure-typed)
 
-**📦 [Installation](#-installation) • 🎮 [Playground](#-playground) • ⚡ [Quick Start](#-quick-start-30-seconds) • 📖 [Docs](#-documentation) • 📋 [API](./docs/REFERENCE.md) • 💡 [Examples](./docs/GUIDES.md)**
+**📦 [Installation](#-installation) • 🎮 [Playground](#-playground) • ⚡ [Quick Start](#-quick-start-30-seconds) • 📖 [Docs](#-documentation) • 📋 [API](https://data-structure-typed-docs.vercel.app/) • 💡 [Examples](./docs/GUIDES.md) • ❓ [FAQ](#-faq)**
 
 ---
 
@@ -28,6 +28,7 @@ A comprehensive TypeScript data structures library with production-ready impleme
 6. [Key Features](#-key-features)
 7. [Data Structures](#-data-structures-available)
 8. [Documentation](#-documentation)
+9. [FAQ](#-faq)
 
 ---
 
@@ -45,12 +46,35 @@ yarn add data-structure-typed
 pnpm add data-structure-typed
 ```
 
+### Subpath Imports (Tree-Shaking Friendly)
+
+Import only what you need — bundlers automatically tree-shake unused code:
+
+```typescript
+// Full bundle — everything available
+import { RedBlackTree, Deque, HashMap } from 'data-structure-typed';
+
+// Subpath — smaller bundle, only loads the category you need
+import { RedBlackTree, TreeMap, AVLTree } from 'data-structure-typed/binary-tree';
+import { Deque, Queue } from 'data-structure-typed/queue';
+import { HashMap } from 'data-structure-typed/hash';
+import { Heap, MinHeap } from 'data-structure-typed/heap';
+import { Trie } from 'data-structure-typed/trie';
+import { Stack } from 'data-structure-typed/stack';
+import { DoublyLinkedList } from 'data-structure-typed/linked-list';
+import { DirectedGraph } from 'data-structure-typed/graph';
+import { Matrix } from 'data-structure-typed/matrix';
+import { MinPriorityQueue } from 'data-structure-typed/priority-queue';
+```
+
+> **Note:** With `"sideEffects": false` and modern bundlers (Vite, Webpack 5, Rollup), even the full import `from 'data-structure-typed'` will tree-shake unused structures. Subpath imports give you explicit control and faster IDE autocomplete.
+
 ### Individual Packages
 
-Use only what you need:
+Standalone packages are also available:
 
 ```bash
-npm i heap-typed deque-typed red-black-tree-typed
+npm i avl-tree-typed bst-typed heap-typed
 ```
 
 ---
@@ -232,27 +256,50 @@ const set = new Set(tree);             // Set constructor
 ```typescript
 import { RedBlackTree } from 'data-structure-typed';
 
-const leaderboard = new RedBlackTree([
+// Descending comparator — highest scores first
+const leaderboard = new RedBlackTree<number, string>([
   [100, 'Alice'],
   [85, 'Bob'],
   [92, 'Charlie']
-]);
+], { comparator: (a, b) => b - a });
 
-// Get sorted scores (automatically maintained!)
-for (const [score, player] of leaderboard) {
-  console.log(`${player}: ${score}`);
-}
-// Output:
-// Alice: 100
-// Charlie: 92
-// Bob: 85
+// Top-2 via lazy iterator — O(k log n), no array copy
+const iter = leaderboard.entries();
+const { value: [topScore, topPlayer] } = iter.next();
+console.log(`${topScore}: ${topPlayer}`); // 100: Alice
 
-// Update score
+// Update score — O(log n)
 leaderboard.delete(85);
-leaderboard.set(95, 'Bob');  // O(log n)
+leaderboard.set(95, 'Bob');
+
+// Range query — players scoring 90~100, O(log n + k)
+const scores90to100 = leaderboard.rangeSearch([90, 100]);
+// [100, 95, 92] — automatically respects tree order
+
+// For O(log n) top-k, rank, and pagination → see Order-Statistic Tree below
+```
 
-// Query top players
-const topPlayers = [...leaderboard.values()].reverse().slice(0, 3);
+### Order-Statistic Tree (Rank Queries)
+
+```typescript
+import { RedBlackTree } from 'data-structure-typed';
+
+const tree = new RedBlackTree<number, string>([
+  [100, 'Alice'], [85, 'Bob'], [92, 'Charlie'],
+  [78, 'Diana'], [95, 'Eve']
+], { comparator: (a, b) => b - a, enableOrderStatistic: true });
+
+// select(k) — find k-th element, O(log n)
+tree.getByRank(0);              // 100 (1st in tree order)
+tree.getByRank(2);              // 92  (3rd in tree order)
+
+// rank(key) — count elements preceding key in tree order, O(log n)
+tree.getRank(92);               // 2 (2 elements before 92 in tree order)
+
+// rangeByRank — pagination, O(log n + k)
+tree.rangeByRank(0, 2);      // [100, 95, 92] — top 3
+
+// Also works with TreeMap, TreeSet, TreeMultiMap, TreeMultiSet
 ```
 
 ### Task Queue (Scheduling)
@@ -299,7 +346,7 @@ queue.push(6);  // Add to back: O(1)
 | **BinaryIndexedTree**    | Prefix sums, frequency counting   | O(log n)        | —                                                         |
 | **Matrix**               | 2D grid arithmetic                | O(n²) add       | —                                                         |
 
-👉 [See all 20+ structures →](./docs/REFERENCE.md)
+👉 [See all 20+ structures →](./docs/OVERVIEW.md) | [Full API docs →](https://data-structure-typed-docs.vercel.app/)
 
 ---
 
@@ -310,8 +357,8 @@ queue.push(6);  // Add to back: O(1)
 | Your Goal                 | Start Here                                | Next Steps                              |
 |---------------------------|-------------------------------------------|-----------------------------------------|
 | **Learn concepts**        | [CONCEPTS.md](./docs/CONCEPTS.md)         | [GUIDES.md](./docs/GUIDES.md)           |
-| **Use in my project**     | [GUIDES.md](./docs/GUIDES.md)             | [REFERENCE.md](./docs/REFERENCE.md)     |
-| **Look up API**           | [REFERENCE.md](./docs/REFERENCE.md)       | [PERFORMANCE.md](./docs/PERFORMANCE.md) |
+| **Use in my project**     | [GUIDES.md](./docs/GUIDES.md)             | [OVERVIEW.md](./docs/OVERVIEW.md)       |
+| **Look up API**           | [API Docs](https://data-structure-typed-docs.vercel.app/) | [PERFORMANCE.md](./docs/PERFORMANCE.md) |
 | **Performance questions** | [PERFORMANCE.md](./docs/PERFORMANCE.md)   | [ARCHITECTURE.md](./docs/ARCHITECTURE.md)    |
 | **Framework integration** | [INTEGRATIONS.md](./docs/INTEGRATIONS.md) | [GUIDES.md](./docs/GUIDES.md)           |
 | **Understand design**     | [ARCHITECTURE.md](./docs/ARCHITECTURE.md)      | [CONCEPTS.md](./docs/CONCEPTS.md)       |
@@ -325,14 +372,19 @@ queue.push(6);  // Add to back: O(1)
   - 5 Comparisons with Native JavaScript
   - Complete Decision Guide
 
-2. **[REFERENCE.md](./docs/REFERENCE.md)** - Complete API & Data Structures
+2. **[API Docs](https://data-structure-typed-docs.vercel.app/)** - Full API Reference (TypeDoc)
+  - Complete method signatures, parameters, return types
+  - Real-world `@example` code for every method
+  - Inheritance hierarchy and type details
+
+3. **[OVERVIEW.md](./docs/OVERVIEW.md)** - Data Structures Overview
   - Quick Reference Table
   - All 20+ Structures with Examples
   - CRUD Operations
   - Common Methods
   - TypeScript Support
 
-3. **[ARCHITECTURE.md](./docs/ARCHITECTURE.md)** - Design & Implementation
+4. **[ARCHITECTURE.md](./docs/ARCHITECTURE.md)** - Design & Implementation
   - Design Philosophy & Principles
   - 3 Pain Points Solved
   - Why Deque is 484x Faster
@@ -340,20 +392,20 @@ queue.push(6);  // Add to back: O(1)
   - Self-Balancing Strategy
   - V8 JIT Optimizations
 
-4. **[PERFORMANCE.md](./docs/PERFORMANCE.md)** - Benchmarks & Comparisons
+5. **[PERFORMANCE.md](./docs/PERFORMANCE.md)** - Benchmarks & Comparisons
   - Performance Summary
   - 3 Real-World Scenarios
   - Detailed Benchmarks
   - When to Use What
   - Optimization Tips
 
-5. **[GUIDES.md](./docs/GUIDES.md)** - Real-World Examples
+6. **[GUIDES.md](./docs/GUIDES.md)** - Real-World Examples
   - 4 Design Patterns
   - 5 Production Code Examples
   - Common Mistakes
   - Best Practices
 
-6. **[INTEGRATIONS.md](./docs/INTEGRATIONS.md)** - Framework Integration
+7. **[INTEGRATIONS.md](./docs/INTEGRATIONS.md)** - Framework Integration
   - React Integration (State Management, Leaderboard)
   - Express Integration (LRU Cache, Rate Limiting)
   - Nest.js Integration (Ranking Service, Task Queue)
@@ -583,7 +635,7 @@ MIT
 README.md (this file)
 docs/
 ├── CONCEPTS.md (theory & fundamentals)
-├── REFERENCE.md (API documentation)
+├── OVERVIEW.md (Data structures overview)
 ├── ARCHITECTURE.md (design principles)
 ├── PERFORMANCE.md (benchmarks)
 ├── GUIDES.md (real-world examples)
@@ -600,7 +652,7 @@ docs/
 
 **Want to build?** → [GUIDES.md](./docs/GUIDES.md)
 
-**Need API?** → [REFERENCE.md](./docs/REFERENCE.md)
+**Need API?** → [API Docs](https://data-structure-typed-docs.vercel.app/) | [Overview](./docs/OVERVIEW.md)
 
 **Curious about performance?** → [PERFORMANCE.md](./docs/PERFORMANCE.md)
 
@@ -609,3 +661,46 @@ docs/
 ---
 
 **Ready to supercharge your TypeScript data structures? [Get started now →](#-quick-start-30-seconds)**
+
+---
+
+## ❓ FAQ
+
+### Does JavaScript have a TreeMap or TreeSet?
+
+Not natively. JavaScript's `Map` and `Set` are hash-based (unordered). This library provides `TreeMap` and `TreeSet` backed by Red-Black Trees — offering sorted iteration, `floor`/`ceiling`/`higher`/`lower` lookups, and `getRank`/`getByRank`/`rangeByRank` queries.
+
+### When should I use a Heap instead of sorting an array?
+
+When you need to repeatedly access the smallest or largest element. Sorting an array is O(n log n) every time; a Heap gives you O(log n) insert and O(1) access to the top element. Use `Heap`, `MinHeap`, or `MaxHeap` for priority queues, top-k problems, and scheduling.
+
+### Does this library support rank and range queries?
+
+Yes. Enable with `{ enableOrderStatistic: true }` on any tree-based structure (RedBlackTree, TreeMap, TreeSet, etc.):
+- `getRank(key)` — how many elements precede this key in tree order
+- `getByRank(k)` — get the element at position k
+- `rangeByRank(start, end)` — get all elements between two positions
+
+### Is it faster than native arrays for ordered operations?
+
+For ordered insert + lookup: yes. Array insert into sorted position is O(n) (shift elements). Red-Black Tree insert is O(log n). For 10,000+ elements, the difference is significant. See [PERFORMANCE.md](./docs/PERFORMANCE.md) for benchmarks.
+
+### Can I use this in React / Node.js / browser?
+
+Yes. The library ships ESM, CJS, and UMD builds. It works in Node.js, browsers, React, Vue, Angular, Next.js, and any JavaScript runtime. Zero dependencies means no compatibility concerns.
+
+### What data structures are included?
+
+Heap, MinHeap, MaxHeap, Priority Queue, Deque, Queue, Stack, Linked List (Singly / Doubly), Red-Black Tree, AVL Tree, BST, TreeMap, TreeSet, TreeMultiMap, TreeMultiSet, SkipList, Trie, HashMap, Graph (Directed / Undirected), Segment Tree, Binary Indexed Tree (Fenwick Tree), Matrix. See [full list](#-data-structures-available).
+
+### Is this library production-ready?
+
+Yes. 2600+ tests, 99%+ code coverage, zero dependencies, and used in production. Every release passes typecheck, lint, and full test suite.
+
+### How does this compare to js-sdsl or other libraries?
+
+`data-structure-typed` offers more data structures (20+), a unified Array-like API across all structures, tree-shakeable subpath exports, and active maintenance. See [PERFORMANCE.md](./docs/PERFORMANCE.md) for benchmark comparisons.
+
+### What is the bundle size?
+
+UMD bundle: ~143KB minified. With subpath imports (e.g., `data-structure-typed/heap`), you only load what you use — as small as 18KB for Stack, 30KB for Heap. `sideEffects: false` enables full tree-shaking.