Mnemonist

https://yomguithereal.github.io/mnemonist/
Admin
Mnemonist is a curated collection of classic and exotic data structures for JavaScript, including...
Tokens:83,273
Snippets:1,004
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### TrieMap.find()

Source: https://yomguithereal.github.io/mnemonist/trie-map

Finds all prefixes within the TrieMap that start with a given prefix and returns them along with their associated values.

```APIDOC
### #.find

Returns an array of couples of every prefixes and their associated value found in the trie with the given prefix.

*   **Time Complexity**: `O(m + n)`, where `m` is the length of the query prefix and `n` is the cumulated size of the matched prefixes.

#### Parameters

*   **prefix** (string | Array) - The prefix to search for.

#### Return Value

*   (Array<Array>) - An array of `[prefix, value]` pairs.

#### Request Example

```javascript
const trie = new TrieMap();
trie.set('roman', 1);
trie.set('romanesque', 2);
trie.set('greek', 3);

trie.find('rom');
>>> [['roman', 1], ['romanesque', 2]]

trie.find('gr');
>>> [['greek', 3]]

trie.find('hel');
>>> []
```
```

--------------------------------

### SymSpell Size Method

Source: https://yomguithereal.github.io/mnemonist/symspell

Get the total number of items stored in the index.

```APIDOC
### #.size
Total number of items stored in the index.
```javascript
const index = new SymSpell();

index.add('hello');

index.size
>>> 1
```
```

--------------------------------

### Iterate Over TrieMap Prefixes

Source: https://yomguithereal.github.io/mnemonist/trie-map

Get an iterator for all prefixes stored in the TrieMap. The iteration order is arbitrary.

```javascript
const trie = TrieMap.from({roman: 1, romanesque: 2});

const iterator = trie.prefixes();

iterator.next().value
>>> 'roman'
```

--------------------------------

### Iterate Over TrieMap Entries

Source: https://yomguithereal.github.io/mnemonist/trie-map

Get an iterator for all [prefix, value] pairs in the TrieMap. The iteration order is arbitrary.

```javascript
const trie = TrieMap.from({roman: 1, romanesque: 2});

const iterator = trie.entries();

iterator.next().value
>>> ['roman', 1]
```

--------------------------------

### Get Vector Element by Index

Source: https://yomguithereal.github.io/mnemonist/vector

The get method retrieves the value stored at a specific index in the vector. Ensure the index is within the vector's bounds.

```javascript
const vector = new Vector(Uint8Array, 2);

vector.push(1);
vector.push(2);
vector.push(3);
vector.push(4);

vector.get(1);
>>> 2
```

--------------------------------

### Retrieving Values

Source: https://yomguithereal.github.io/mnemonist/lru-map

Get a value by key, updating its recency status, or peek at a value without affecting recency.

```javascript
const cache = new LRUMap(10);
cache.set('one', 1);
cache.get('one');
>>> 1
```

```javascript
const cache = new LRUMap(10);
cache.set('one', 1);
cache.peek('one');
>>> 1
```

--------------------------------

### Iterate Over TrieMap Values

Source: https://yomguithereal.github.io/mnemonist/trie-map

Get an iterator for all values stored in the TrieMap. The iteration order is arbitrary.

```javascript
const trie = TrieMap.from({roman: 1, romanesque: 2});

const iterator = trie.values();

iterator.next().value
>>> 1
```

--------------------------------

### Get Vector Values Iterator

Source: https://yomguithereal.github.io/mnemonist/vector

The values method returns an iterator over the vector's values. You can then use iterator.next() to retrieve values sequentially.

```javascript
const vector = Vector.from([1, 2, 3], Uint8Array);

const iterator = vector.values();

iterator.next().value
>>> 3
```

--------------------------------

### Get Vector Entries Iterator

Source: https://yomguithereal.github.io/mnemonist/vector

The entries method returns an iterator over the vector's entries, yielding pairs of [index, value].

```javascript
const vector = Vector.from([1, 2, 3], Uint8Array);

const iterator = vector.entries();

iterator.next().value
>>> [0, 3]
```

--------------------------------

### Trie Constructor and Initialization

Source: https://yomguithereal.github.io/mnemonist/trie

Demonstrates how to create a new Trie instance, optionally specifying the type of sequence it will store, and how to initialize it from an iterable.

```APIDOC
## Trie Constructor

The `Trie` optionally takes as single argument the type of sequence you are going to feed it.

### Usage

```javascript
// For a trie containing string prefixes
const trie = new Trie();

// For a trie containing arbitrary sequences fed as arrays
const trie = new Trie(Array);
```

### Static #.from

Alternatively, one can build a `Trie` from an arbitrary JavaScript iterable likewise:

```javascript
const trie = Trie.from(['roman', 'romanesque']);
```
```

--------------------------------

### Setting Values

Source: https://yomguithereal.github.io/mnemonist/lru-map

Insert a key-value pair into the cache, triggering eviction if the capacity is exceeded.

```javascript
const cache = new LRUMap(10);
cache.set('one', 1);
cache.has('one');
>>> true
```

--------------------------------

### Initializing LRUMap

Source: https://yomguithereal.github.io/mnemonist/lru-map

Create a new cache instance with a specified capacity, optionally using typed arrays for memory efficiency.

```javascript
const cache = new LRUMap(1000);
```

```javascript
// First argument will be instantiated for keys, second one for values
const cache = new LRUMap(Uint32Array, Float32Array, 1000);
```

--------------------------------

### Growing the Vector

Source: https://yomguithereal.github.io/mnemonist/vector

Manually trigger the growth policy to increase capacity.

```javascript
const vector = new Vector(Uint8Array, 3);

vector.grow();

// Grow until we can store at least 100 items:
vector.grow(100);
```

--------------------------------

### Building Vectors with Static from

Source: https://yomguithereal.github.io/mnemonist/vector

Create a Vector instance from an existing iterable.

```javascript
// Attempting the guess the given iterable's length/size
const vector = Vector.from([1, 2, 3], Int8Array);
```

```javascript
// Providing the desired capacity
const vector = Vector.from([1, 2, 3], Int8Array, 10);
```

```javascript
// Subclasses also have a static #.from
const vector = Vector.Uint16Vector.from([1, 2, 3]);
```

--------------------------------

### Importing Vector

Source: https://yomguithereal.github.io/mnemonist/vector

Basic import statement for the Vector class.

```javascript
const Vector = require('mnemonist/vector');
```

--------------------------------

### Setting Values with Eviction Feedback

Source: https://yomguithereal.github.io/mnemonist/lru-map

Insert a value and receive information about whether an eviction or overwrite occurred.

```javascript
const cache = new LRUMap(1);
cache.setpop('one', 1);
>>> null
cache.setpop('one', 10);
>>> {key: 'one', value: 1, evicted: false}
cache.setpop('two', 2);
>>> {key: 'one', value: 10, evicted: true}
```

--------------------------------

### LRUMap Constructor

Source: https://yomguithereal.github.io/mnemonist/lru-map

Initializes a new LRUMap instance with a specified capacity, optionally using typed arrays for memory efficiency.

```APIDOC
## Constructor

### Description
Creates a new LRUMap instance with a fixed capacity.

### Parameters
- **capacity** (number) - Required - The maximum number of items the cache can store.
- **keyType** (Constructor) - Optional - Constructor for typed keys.
- **valueType** (Constructor) - Optional - Constructor for typed values.

### Request Example
const cache = new LRUMap(1000);
const typedCache = new LRUMap(Uint32Array, Float32Array, 1000);
```

--------------------------------

### Check key existence with #.has

Source: https://yomguithereal.github.io/mnemonist/lru-map

Verifies if a key exists in the cache with O(1) complexity.

```javascript
const cache = new LRUMap(10);
cache.set('one', 1);
cache.has('one');
>>> true

cache.has('two');
>>> false
```

--------------------------------

### TrieMap Constructor

Source: https://yomguithereal.github.io/mnemonist/trie-map

Initializes a new TrieMap. Optionally accepts a type for sequence prefixes (e.g., String or Array).

```APIDOC
## Constructor

The `TrieMap` optionally takes as single argument the type of sequence you are going to feed it.

### Usage

```javascript
// For a trie containing string prefixes
const trie = new TrieMap();

// For a trie containing arbitrary sequences fed as arrays
const trie = new TrieMap(Array);
```
```

--------------------------------

### Iterate with ES2015 for...of

Source: https://yomguithereal.github.io/mnemonist/lru-map

Uses the standard ES2015 protocol to iterate over cache entries.

```javascript
const cache = new LRUMap(10);

cache.set('one', 1);
cache.set('two', 2);

for (const [key, value] of cache) {
  console.log(key, value);
}
```

--------------------------------

### Queue Methods: Iteration

Source: https://yomguithereal.github.io/mnemonist/queue

Methods for iterating over the queue: `forEach`, `toArray`, `values`, `entries`, and the iterable protocol.

```APIDOC
_Iteration_
  * #.forEach
  * #.toArray
  * #.values
  * #.entries
  * Iterable

### #.forEach
Iterates over the queue in FIFO order.
```javascript
const queue = new Queue();
queue.enqueue(1);
queue.enqueue(2);

queue.forEach((item, index, queue) => {
  console.log(index, item);
});
```

### #.toArray
Converts the queue into a FIFO JavaScript array.
```javascript
const queue = new Queue();
queue.enqueue(1);
queue.enqueue(2);

queue.toArray();
>>> [1, 2]
```

### #.values
Returns an iterator over the queue’s values.
```javascript
const queue = Queue.from([1, 2, 3]);

const iterator = queue.values();

iterator.next().value
>>> 1
```

### #.entries
Returns an iterator over the queue’s entries.
```javascript
const queue = Queue.from([1, 2, 3]);

const iterator = queue.entries();

iterator.next().value
>>> [0, 1]
```

### Iterable
Alternatively, you can iterate over a queue’s values using ES2015 `for...of` protocol:
```javascript
const queue = Queue.from([1, 2, 3]);

for (const item of queue) {
  console.log(item);
}
```
```

--------------------------------

### Finding prefixes

Source: https://yomguithereal.github.io/mnemonist/trie

Retrieve all prefixes in the Trie that match the provided query.

```javascript
const trie = new Trie();
trie.add('roman');
trie.add('romanesque');
trie.add('greek');

trie.find('rom');
>>> ['roman', 'romanesque']

trie.find('gr');
>>> ['greek']

trie.find('hel');
>>> []
```

--------------------------------

### Vector Constructor

Source: https://yomguithereal.github.io/mnemonist/vector

Instantiates a new Vector with a specified typed array class and initial capacity or options.

```APIDOC
## Constructor
The `Vector` takes a typed array class as first argument and an initial capacity or alternatively more complex options as second argument.
```javascript
const Vector = require('mnemonist/vector');
const vector = new Vector(ArrayClass, initialCapacity);
```

```javascript
// If you need to pass options such as a custom growth policy
const vector = new Vector(ArrayClass, {
  initialCapacity: 10,
  initialLength: 3,
  policy: (capacity) => Math.ceil(capacity * 2.5)  
});
```

Subclasses for each of JS typed array also exists as a convenience.
```javascript
const int8vector    = new Vector.Int8Vector(initialCapacity);
const uint8vector   = new Vector.Uint8Vector(initialCapacity);
const int16vector   = new Vector.Int16Vector(initialCapacity);
const uint16vector  = new Vector.Uint16Vector(initialCapacity);
const int32vector   = new Vector.Int32Vector(initialCapacity);
const uint32vector  = new Vector.Uint32Vector(initialCapacity);
const float32vector = new Vector.Float32Vector(initialCapacity);
const float64vector = new Vector.Float64Vector(initialCapacity);
```
```

--------------------------------

### SymSpell Static from Method

Source: https://yomguithereal.github.io/mnemonist/symspell

Create a SymSpell index from an iterable of terms.

```APIDOC
### Static #.from
Alternatively, one can build a `SymSpell` from an arbitrary JavaScript iterable likewise:
```javascript
const index = SymSpell.from(['hello', 'mello'], options);
```
```

--------------------------------

### Trie Members and Methods

Source: https://yomguithereal.github.io/mnemonist/trie

Details the properties and methods available for interacting with the Trie, including size, adding, deleting, checking for existence, finding prefixes, and iterating over prefixes.

```APIDOC
## Trie Members

* #.size

## Methods

_Mutation_
  * #.add
  * #.delete
  * #.clear

_Read_
  * #.has
  * #.find

_Iteration_
  * #.keys
  * #.prefixes
  * Iterable

### #.size

Number of prefixes in the trie.

```javascript
const trie = new Trie();
trie.size
>>> 0
```

### #.add

Adds a prefix into the Trie. If the prefix is a string, it will be split into characters. Else, you can provide an array of custom tokens.
`O(m)`, m being the size of the inserted string.

```javascript
const trie = new Trie();
trie.add('hello');

trie.has('hello');
>>> true

// Using custom tokens
trie.add(['I', 'am', 'very', 'happy']);
```

### #.delete

Deletes a prefix from the Trie. Returns `true` if the prefix was deleted & `false` if the prefix was not in the Trie.
`O(m)`, m being the size of the deleted string.

```javascript
const trie = new Trie();
trie.add('hello');

trie.delete('hello');
>>> true

trie.delete('world');
>>> false
```

### #.clear

Completely clears the trie.

```javascript
const trie = new Trie();
trie.add('hello');
trie.add('roman');

trie.clear();

trie.size
>>> 0
```

### #.has

Returns whether the given prefix exists in the trie.
`O(m)`, m being the size of the searched string.

```javascript
const trie = new Trie();
trie.add('hello');

trie.has('hello');
>>> true

trie.has('world');
>>> false
```

### #.find

Returns an array of every prefixes found in the trie with the given prefix.
`O(m + n)`, m being the size of the query, n being the cumulated size of the matched prefixes.

```javascript
const trie = new Trie();
trie.add('roman');
trie.add('romanesque');
trie.add('greek');

trie.find('rom');
>>> ['roman', 'romanesque']

trie.find('gr');
>>> ['greek']

trie.find('hel');
>>> []
```

### #.keys

Alias of #.prefixes.

### #.prefixes

Returns an iterator over the trie’s prefixes (note that the order on which the trie will iterate over its prefixes is arbitrary).

```javascript
const trie = Trie.from(['roman', 'romanesque']);

const iterator = trie.prefixes();

iterator.next().value
>>> 'roman'
```

### Iterable

Alternatively, you can iterate over a trie’s prefixes using ES2015 `for...of` protocol:

```javascript
const trie = Trie.from(['roman', 'romanesque']);

for (const prefix of trie) {
  console.log(prefix);
}
```
```

--------------------------------

### MultiSet Iterable Protocol

Source: https://yomguithereal.github.io/mnemonist/multi-set

Shows how to iterate over the values of a MultiSet using the ES2015 for...of loop.

```APIDOC
## MultiSet Iterable

### Description
Allows iteration over a set’s values using the ES2015 `for...of` protocol.

### Method
GET (conceptual)

### Endpoint
N/A (Instance method)

### Parameters
None

### Request Example
```javascript
const set = new MultiSet();

set.add('hello');
set.add('hello');

for (const value of set) {
  console.log(value);
}
```

### Response
#### Success Response (Console Output)
- Logs each value present in the MultiSet.

#### Response Example
```
hello
hello
```
```

--------------------------------

### Iterate cache with #.forEach

Source: https://yomguithereal.github.io/mnemonist/lru-map

Traverses the cache from the most to the least recently used key-value pairs.

```javascript
const cache = new LRUMap(10);

cache.set('one', 1);
cache.set('two', 2);

cache.forEach((value, key, cache) => {
  console.log(key, value);
});
```

--------------------------------

### Importing LRUMap

Source: https://yomguithereal.github.io/mnemonist/lru-map

Load the LRUMap or the variant that supports explicit deletions.

```javascript
const LRUMap = require('mnemonist/lru-map');
// If you need deletions
const LRUMapWithDelete = require('mnemonist/lru-map-with-delete');
```

--------------------------------

### Constructing a Vector

Source: https://yomguithereal.github.io/mnemonist/vector

Initialize a new Vector with a specific typed array class and capacity, or custom growth options.

```javascript
const vector = new Vector(ArrayClass, initialCapacity);
```

```javascript
// If you need to pass options such as a custom growth policy
const vector = new Vector(ArrayClass, {
  initialCapacity: 10,
  initialLength: 3,
  policy: (capacity) => Math.ceil(capacity * 2.5)  
});
```

--------------------------------

### LRUMap.forEach

Source: https://yomguithereal.github.io/mnemonist/lru-map

Iterates over the cache entries from most to least recently used.

```APIDOC
## .forEach(callback)

### Description
Iterates over the cache from the most to the least recently used key-value pair.

### Parameters
- **callback** (function) - Required - Function to execute for each entry, receiving (value, key, cache) as arguments.
```

--------------------------------

### Setting Values

Source: https://yomguithereal.github.io/mnemonist/vector

Update the value at a specific index.

```javascript
const vector = new Vector(Uint8Array, 2);

vector.set(1, 45);

vector.get(1);
>>> 45
```

--------------------------------

### Using for...of iteration

Source: https://yomguithereal.github.io/mnemonist/trie

Iterate over Trie prefixes using the standard ES2015 protocol.

```javascript
const trie = Trie.from(['roman', 'romanesque']);

for (const prefix of trie) {
  console.log(prefix);
}
```

--------------------------------

### TrieMap.from()

Source: https://yomguithereal.github.io/mnemonist/trie-map

Creates a TrieMap instance from an arbitrary JavaScript iterable.

```APIDOC
### Static #.from

Alternatively, one can build a `TrieMap` from an arbitrary JavaScript iterable likewise:

#### Parameters

*   **iterable** (Iterable) - An iterable object to populate the TrieMap.

#### Request Example

```javascript
const trie = TrieMap.from({
  roman: 1,
  romanesque: 2
});
```

#### Response Example

```javascript
// trie will contain {'roman': 1, 'romanesque': 2}
```
```

--------------------------------

### TrieMap.keys() / TrieMap.prefixes()

Source: https://yomguithereal.github.io/mnemonist/trie-map

Returns an iterator over the TrieMap's prefixes (keys). The iteration order is arbitrary. `keys()` is an alias for `prefixes()`.

```APIDOC
### #.keys / #.prefixes

Alias of #.prefixes.

Returns an iterator over the trie’s prefixes (note that the order on which the trie will iterate over its prefixes is arbitrary).

#### Return Value

*   (Iterator) - An iterator yielding prefixes.

#### Request Example

```javascript
const trie = TrieMap.from({roman: 1, romanesque: 2});

const iterator = trie.prefixes();

iterator.next().value
>>> 'roman'
```
```

--------------------------------

### Iterate Vector Items with forEach

Source: https://yomguithereal.github.io/mnemonist/vector

Use the forEach method to iterate over the vector's items. The callback function receives the item, its index, and the vector itself.

```javascript
const vector = new Vector(Array, 10);

stack.push(1);
stack.push(2);

stack.forEach((item, index, stack) => {
  console.log(index, item);
});
```

--------------------------------

### LRUMap Read Methods

Source: https://yomguithereal.github.io/mnemonist/lru-map

Methods for retrieving values from the cache without modifying the capacity.

```APIDOC
## Read Methods

### #.get
Retrieves the value for a key and marks it as the most recently used.

### #.peek
Retrieves the value for a key without updating its usage status.

### #.has
Checks if a key exists in the cache.
```

--------------------------------

### Iterate Over TrieMap using for...of

Source: https://yomguithereal.github.io/mnemonist/trie-map

Iterate over the TrieMap's entries using the ES2015 for...of loop.

```javascript
const trie = TrieMap.from({roman: 1, romanesque: 2});

for (const entry of trie) {
  console.log(entry);
}
```

--------------------------------

### Heap Operations

Source: https://yomguithereal.github.io/mnemonist/heap

Core heap manipulation methods including heapify, push, pop, replace, pushpop, and consume.

```APIDOC
## Heap.heapify

### Description
Converts the given array into a heap in linear time.

### Parameters
- **comparator** (function) - Required - The comparison function.
- **array** (Array) - Required - The array to heapify.

## Heap.push

### Description
Push a new item into the heap.

### Parameters
- **comparator** (function) - Required - The comparison function.
- **array** (Array) - Required - The heap array.
- **item** (any) - Required - The item to push.

## Heap.pop

### Description
Pop the heap.

### Parameters
- **comparator** (function) - Required - The comparison function.
- **array** (Array) - Required - The heap array.

## Heap.replace

### Description
Pop the heap, push an item then return the popped value. More efficient than pop then push.

### Parameters
- **comparator** (function) - Required - The comparison function.
- **array** (Array) - Required - The heap array.
- **item** (any) - Required - The item to push.

## Heap.pushpop

### Description
Push an item into the heap, then pop the heap. More efficient than push then pop.

### Parameters
- **comparator** (function) - Required - The comparison function.
- **array** (Array) - Required - The heap array.
- **item** (any) - Required - The item to push.

## Heap.consume

### Description
Completely consumes the heap and returns all its items in a sorted array.

### Parameters
- **comparator** (function) - Required - The comparison function.
- **array** (Array) - Required - The heap array.
```

--------------------------------

### Vector.forEach

Source: https://yomguithereal.github.io/mnemonist/vector

Iterates over the vector's items using a callback function.

```APIDOC
## .forEach(callback)

### Description
Iterates over the vector’s items.

### Parameters
- **callback** (function) - Required - Function to execute for each element, receiving (item, index, vector).
```

--------------------------------

### LRUMap.keys

Source: https://yomguithereal.github.io/mnemonist/lru-map

Returns an iterator for cache keys.

```APIDOC
## .keys()

### Description
Returns an iterator over the cache’s keys from the most to the least recently used key.
```

--------------------------------

### Clearing the Cache

Source: https://yomguithereal.github.io/mnemonist/lru-map

Remove all entries from the cache instance.

```javascript
const cache = new LRUMap(10);
cache.set('one', 1);
cache.clear();

cache.has('one');
>>> false
cache.size
>>> 0
```

--------------------------------

### Building LRUMap from Iterables

Source: https://yomguithereal.github.io/mnemonist/lru-map

Construct a cache from an existing JavaScript object or iterable, with optional capacity and type constraints.

```javascript
// Attempting the guess the given iterable's length/size
const cache = LRUMap.from({one: 1, two: 2});
```

```javascript
// Providing the desired capacity
const cache = LRUMap.from({one: 1, two: 2}, 10);
```

```javascript
// Typing the cache
const cache = LRUMap.from({one: 1, two: 2}, Array, Uint8Array, 10);
```

--------------------------------

### Checking for prefix existence

Source: https://yomguithereal.github.io/mnemonist/trie

Verify if a specific prefix exists within the Trie.

```javascript
const trie = new Trie();
trie.add('hello');

trie.has('hello');
>>> true

trie.has('world');
>>> false
```

--------------------------------

### SymSpell Methods

Source: https://yomguithereal.github.io/mnemonist/symspell

Perform operations on the SymSpell index.

```APIDOC
## Methods
_Mutation_
  * #.add
  * #.clear

_Read_
  * #.search
```

--------------------------------

### Vector Iteration Methods

Source: https://yomguithereal.github.io/mnemonist/vector

Methods for iterating over the Vector's elements.

```APIDOC
_Iteration_
  * #.forEach
  * #.values
  * #.entries
  * Iterable

### #.forEach
Iterates over the vector's values.
```javascript
const vector = Vector.from([1, 2, 3]);

vector.forEach((value, index) => {
  console.log(value, index);
});
// 1 0
// 2 1
// 3 2
```

### #.values
Returns an iterator over the vector's values.
```javascript
const vector = Vector.from([1, 2, 3]);
const iterator = vector.values();

iterator.next().value;
>>> 1
iterator.next().value;
>>> 2
iterator.next().value;
>>> 3
```

### #.entries
Returns an iterator over the vector's entries (value, index pairs).
```javascript
const vector = Vector.from([1, 2, 3]);
const iterator = vector.entries();

iterator.next().value;
>>> [1, 0]
iterator.next().value;
>>> [2, 1]
iterator.next().value;
>>> [3, 2]
```

### Iterable
The Vector class is iterable, allowing it to be used with `for...of` loops and other iterable constructs.
```javascript
const vector = Vector.from([1, 2, 3]);

for (const value of vector) {
  console.log(value);
}
// 1
// 2
// 3
```
```

--------------------------------

### Accessing Capacity and Size

Source: https://yomguithereal.github.io/mnemonist/lru-map

Retrieve the maximum capacity or the current number of items stored in the cache.

```javascript
const cache = new LRUMap(10);
cache.capacity
>>> 10
```

```javascript
const cache = new LRUMap(10);
cache.size
>>> 0
cache.set('one', 1);
cache.size
>>> 1
```

--------------------------------

### TrieMap.size

Source: https://yomguithereal.github.io/mnemonist/trie-map

Returns the number of prefixes currently stored in the TrieMap.

```APIDOC
### #.size

Number of prefixes in the trie.

#### Return Value

*   (number) - The number of prefixes in the trie.

#### Usage

```javascript
const trie = new TrieMap();
trie.size
>>> 0
```
```

--------------------------------

### Vector Read Methods

Source: https://yomguithereal.github.io/mnemonist/vector

Methods for reading values from the Vector.

```APIDOC
_Read_
  * #.get

### #.get
Retrieves the value at the given index.
```javascript
const vector = new Vector(Uint8Array, 2);

vector.set(1, 45);

vector.get(1);
>>> 45
```
```

--------------------------------

### LRUMap.entries

Source: https://yomguithereal.github.io/mnemonist/lru-map

Returns an iterator for cache entries.

```APIDOC
## .entries()

### Description
Returns an iterator over the cache’s entries from the most to the least recently used entry.
```

--------------------------------

### Retrieve keys with #.keys

Source: https://yomguithereal.github.io/mnemonist/lru-map

Returns an iterator over the cache keys ordered from most to least recently used.

```javascript
const cache = new LRUMap(10);

cache.set('one', 1);
cache.set('two', 2);

const iterator = cache.keys();

iterator.next().value
>>> 'two'
```

--------------------------------

### SymSpell Add Method

Source: https://yomguithereal.github.io/mnemonist/symspell

Add a single item to the SymSpell index.

```APIDOC
### #.add
Adds a single item to the index.
```javascript
const index = new SymSpell();

index.add('hello');
```
```

--------------------------------

### TrieMap.has()

Source: https://yomguithereal.github.io/mnemonist/trie-map

Checks if a given prefix exists in the TrieMap.

```APIDOC
### #.has

Returns whether the given prefix exists in the trie.

*   **Time Complexity**: `O(m)`, where `m` is the length of the searched prefix.

#### Parameters

*   **prefix** (string | Array) - The prefix to check for.

#### Return Value

*   (boolean) - `true` if the prefix exists, `false` otherwise.

#### Request Example

```javascript
const trie = new TrieMap();
trie.set('hello', 'world');

trie.has('hello');
>>> true

trie.has('world');
>>> false
```
```

--------------------------------

### TrieMap.get()

Source: https://yomguithereal.github.io/mnemonist/trie-map

Retrieves the value associated with a given prefix. Returns `undefined` if the prefix is not found.

```APIDOC
### #.get

Returns the value associated to the given prefix or `undefined` if the prefix does not exist in the trie.

*   **Time Complexity**: `O(m)`, where `m` is the length of the searched prefix.

#### Parameters

*   **prefix** (string | Array) - The prefix to search for.

#### Return Value

*   (any) - The value associated with the prefix, or `undefined` if not found.

#### Request Example

```javascript
const trie = new TrieMap();
trie.set('hello', 'world');

trie.get('hello');
>>> 'world'
```
```

--------------------------------

### LRUMap.has

Source: https://yomguithereal.github.io/mnemonist/lru-map

Checks if a specific key exists within the LRU cache.

```APIDOC
## .has(key)

### Description
Retrieves whether the given key exists in the cache. Complexity is O(1).

### Parameters
- **key** (any) - Required - The key to check for existence.

### Response
- **boolean** - Returns true if the key exists, false otherwise.
```

--------------------------------

### TrieMap.set()

Source: https://yomguithereal.github.io/mnemonist/trie-map

Inserts a prefix into the TrieMap and associates it with a given value. If the prefix already exists, its value is updated.

```APIDOC
### #.set

Inserts a prefix into the Trie and associates it to the given value.

*   **Time Complexity**: `O(m)`, where `m` is the length of the inserted prefix.

#### Parameters

*   **prefix** (string | Array) - The prefix to insert.
*   **value** (any) - The value to associate with the prefix.

#### Request Example

```javascript
const trie = new TrieMap();
trie.set('hello', 'world');

trie.get('hello');
>>> 'world'

// Using custom tokens
trie.set(['I', 'am', 'very', 'happy'], 'world');
```
```

--------------------------------

### Using Vector Subclasses

Source: https://yomguithereal.github.io/mnemonist/vector

Convenience subclasses for specific typed array types.

```javascript
const int8vector    = new Vector.Int8Vector(initialCapacity);
const uint8vector   = new Vector.Uint8Vector(initialCapacity);
const int16vector   = new Vector.Int16Vector(initialCapacity);
const uint16vector  = new Vector.Uint16Vector(initialCapacity);
const int32vector   = new Vector.Int32Vector(initialCapacity);
const uint32vector  = new Vector.Uint32Vector(initialCapacity);
const float32vector = new Vector.Float32Vector(initialCapacity);
const float64vector = new Vector.Float64Vector(initialCapacity);
```

--------------------------------

### Retrieve entries with #.entries

Source: https://yomguithereal.github.io/mnemonist/lru-map

Returns an iterator over the cache entries ordered from most to least recently used.

```javascript
const cache = new LRUMap(10);

cache.set('one', 1);
cache.set('two', 2);

const iterator = cache.entries();

iterator.next().value
>>> ['two', 2]
```

--------------------------------

### Removing Keys with Value Return

Source: https://yomguithereal.github.io/mnemonist/lru-map

Remove a key and return its associated value, or a default value if the key was missing.

```javascript
const cache = new LRUMapWithDelete(1);
cache.set('one', 1)

cache.remove('one');
>>> 1

cache.remove('one');
>>> undefined

cache.remove('one', 'not-found');
>>> 'not-found'
```

--------------------------------

### Checking Trie size

Source: https://yomguithereal.github.io/mnemonist/trie

Retrieve the number of prefixes currently stored in the Trie.

```javascript
const trie = new Trie();
trie.size
>>> 0
```

--------------------------------

### TrieMap.update()

Source: https://yomguithereal.github.io/mnemonist/trie-map

Updates the value associated with a prefix. It accepts a function that receives the current value and returns the new one.

```APIDOC
### #.update

Updates the value associated with a prefix. Accepts a function receiving the current value and returning the new one.

*   **Time Complexity**: `O(m)`, where `m` is the length of the prefix string.

#### Parameters

*   **prefix** (string | Array) - The prefix whose value needs to be updated.
*   **updater** (function) - A function that takes the current value and returns the new value.

#### Request Example

```javascript
const trie = new TrieMap();

const updater = v => (v || 0) + 1;

trie.update('counter', updater);
trie.update('counter', updater);

trie.get('counter');
>>> 2
```
```

--------------------------------

### Vector.from Static Method

Source: https://yomguithereal.github.io/mnemonist/vector

Creates a new Vector instance from an arbitrary JavaScript iterable.

```APIDOC
### Static #.from
Alternatively, one can build a `Vector` from an arbitrary JavaScript iterable likewise:
```javascript
// Attempting the guess the given iterable's length/size
const vector = Vector.from([1, 2, 3], Int8Array);
```

```javascript
// Providing the desired capacity
const vector = Vector.from([1, 2, 3], Int8Array, 10);
```

```javascript
// Subclasses also have a static #.from
const vector = Vector.Uint16Vector.from([1, 2, 3]);
```
```

--------------------------------

### TrieMap.entries()

Source: https://yomguithereal.github.io/mnemonist/trie-map

Returns an iterator over the TrieMap's entries (key-value pairs). The iteration order is arbitrary.

```APIDOC
### #.entries

Returns an iterator over the trie’s entries (note that the order on which the trie will iterate over its entries is arbitrary).

#### Return Value

*   (Iterator) - An iterator yielding `[prefix, value]` pairs.

#### Request Example

```javascript
const trie = TrieMap.from({roman: 1, romanesque: 2});

const iterator = trie.entries();

iterator.next().value
>>> ['roman', 1]
```
```

--------------------------------

### Deleting Keys

Source: https://yomguithereal.github.io/mnemonist/lru-map

Remove a key from the cache using the LRUMapWithDelete variant.

```javascript
const cache = new LRUMapWithDelete(1);
cache.set('one', 1)

cache.delete('one');
>>> true

cache.delete('one');
>>> false
```

--------------------------------

### Building a Trie from an iterable

Source: https://yomguithereal.github.io/mnemonist/trie

Create a Trie instance directly from an array or other iterable.

```javascript
const trie = Trie.from(['roman', 'romanesque']);
```

--------------------------------

### Iterate Vector with for...of

Source: https://yomguithereal.github.io/mnemonist/vector

Vectors support the ES2015 for...of protocol, allowing direct iteration over their values using a standard for...of loop.

```javascript
const vector = Vector.from([1, 2, 3], Uint8Array);

for (const item of vector) {
  console.log(item);
}
```

--------------------------------

### LRUMap.values

Source: https://yomguithereal.github.io/mnemonist/lru-map

Returns an iterator for cache values.

```APIDOC
## .values()

### Description
Returns an iterator over the cache’s values from the most to the least recently used value.
```

--------------------------------

### Vector.get

Source: https://yomguithereal.github.io/mnemonist/vector

Retrieves the value stored at a specific index.

```APIDOC
## .get(index)

### Description
Retrieves the value stored at the given index.

### Parameters
- **index** (number) - Required - The index of the element to retrieve.

### Request Example
vector.get(1);
```

--------------------------------

### Resize Vector Length

Source: https://yomguithereal.github.io/mnemonist/vector

Use the resize method to change the vector's length. It will reallocate if capacity is insufficient. Note that it won't deallocate if the new length is smaller than the current one.

```javascript
const vector = new Vector(Uint8Array, {initialLength: 10});

vector.resize(5);
vector.length;
>>> 5
vector.capacity;
>>> 10

// This will reallocate
vector.resize(25);
vector.length;
>>> 25
vector.capacity;
>>> 25
```

--------------------------------

### TrieMap Iterable Protocol

Source: https://yomguithereal.github.io/mnemonist/trie-map

Allows iterating over the TrieMap's entries using the `for...of` loop.

```APIDOC
### Iterable

Alternatively, you can iterate over a trie’s entries using ES2015 `for...of` protocol.

#### Request Example

```javascript
const trie = TrieMap.from({roman: 1, romanesque: 2});

for (const entry of trie) {
  console.log(entry);
}
// Output:
// ['roman', 1]
// ['romanesque', 2]
```
```

--------------------------------

### Iterating over prefixes

Source: https://yomguithereal.github.io/mnemonist/trie

Access all prefixes stored in the Trie using an iterator.

```javascript
const trie = Trie.from(['roman', 'romanesque']);

const iterator = trie.prefixes();

iterator.next().value
>>> 'roman'
```

--------------------------------

### LRUMap Mutation Methods

Source: https://yomguithereal.github.io/mnemonist/lru-map

Methods for modifying the contents of the LRUMap, including setting values and clearing the cache.

```APIDOC
## Mutation Methods

### #.set
Sets a value for the given key. If full, the least recently used key is evicted.

### #.setpop
Sets a value and returns an object containing information about the eviction or overwrite status.

### #.delete
Removes a key from the cache (Available on LRUMapWithDelete).

### #.remove
Removes a key and returns the associated value or a default value (Available on LRUMapWithDelete).

### #.clear
Removes all items from the cache.
```

--------------------------------

### Vector Mutation Methods

Source: https://yomguithereal.github.io/mnemonist/vector

Methods for modifying the Vector's contents and structure.

```APIDOC
## Methods
_Mutation_
  * #.grow
  * #.set
  * #.pop
  * #.push
  * #.reallocate
  * #.resize

### #.grow
Applies the growing policy once and reallocates the underlying array.
If given a number, will run the growing policy until we attain a suitable capacity.
```javascript
const vector = new Vector(Uint8Array, 3);

vector.grow();

// Grow until we can store at least 100 items:
vector.grow(100);
```

### #.set
Sets the value at the given index.
```javascript
const vector = new Vector(Uint8Array, 2);

vector.set(1, 45);

vector.get(1);
>>> 45
```

### #.pop
Removes & returns the last value of the vector.
```javascript
const vector = new Vector(Uint8Array, 2);

vector.push(1);
vector.push(2);
vector.push(3);

vector.pop();
>>> 3
vector.length
>>> 2
```

### #.push
Pushes a new value in the vector.
```javascript
const vector = new Vector(Uint8Array, 2);

vector.push(1);
vector.push(2);
vector.push(3);
vector.push(4);

vector.length
>>> 4

vector.get(1);
>>> 2
```

### #.reallocate
Reallocates the underlying array and truncates length if needed.
```javascript
const vector = new Vector(Uint8Array, 3);

vector.reallocate(10);

vector.set(7, 3);

// This will truncate length
vector.reallocate(5);
```
```

--------------------------------

### Retrieve values with #.values

Source: https://yomguithereal.github.io/mnemonist/lru-map

Returns an iterator over the cache values ordered from most to least recently used.

```javascript
const cache = new LRUMap(10);

cache.set('one', 1);
cache.set('two', 2);

const iterator = cache.values();

iterator.next().value
>>> 2
```

--------------------------------

### Adding prefixes to a Trie

Source: https://yomguithereal.github.io/mnemonist/trie

Insert strings or custom token arrays into the Trie.

```javascript
const trie = new Trie();
trie.add('hello');

trie.has('hello');
>>> true

// Using custom tokens
trie.add(['I', 'am', 'very', 'happy']);
```

--------------------------------

### TrieMap.values()

Source: https://yomguithereal.github.io/mnemonist/trie-map

Returns an iterator over the values stored in the TrieMap. The iteration order is arbitrary.

```APIDOC
### #.values

Returns an iterator over the trie’s values (note that the order on which the trie will iterate over its values is arbitrary).

#### Return Value

*   (Iterator) - An iterator yielding values.

#### Request Example

```javascript
const trie = TrieMap.from({roman: 1, romanesque: 2});

const iterator = trie.values();

iterator.next().value
>>> 1
```
```

--------------------------------

### Vector.entries

Source: https://yomguithereal.github.io/mnemonist/vector

Returns an iterator over the vector's entries (index, value pairs).

```APIDOC
## .entries()

### Description
Returns an iterator over the vector’s entries.
```

--------------------------------

### TrieMap.clear()

Source: https://yomguithereal.github.io/mnemonist/trie-map

Removes all prefixes and their associated values from the TrieMap, making it empty.

```APIDOC
### #.clear

Completely clears the trie.

#### Request Example

```javascript
const trie = new TrieMap();
trie.set('hello', 1);
trie.set('roman', 2);

trie.clear();

trie.size
>>> 0
```
```

--------------------------------

### Pushing Values

Source: https://yomguithereal.github.io/mnemonist/vector

Add a new value to the end of the vector.

```javascript
const vector = new Vector(Uint8Array, 2);

vector.push(1);
vector.push(2);
vector.push(3);
vector.push(4);

vector.length
>>> 4

vector.get(1);
>>> 2
```

--------------------------------

### N-Extreme Values

Source: https://yomguithereal.github.io/mnemonist/heap

Methods to retrieve the n smallest or largest values from iterables.

```APIDOC
## Heap.nsmallest

### Description
Retrieves the n smallest values from the given iterables.

### Parameters
- **comparator** (function) - Optional - Custom comparison function.
- **n** (number) - Required - Number of smallest values to retrieve.
- **iterable** (Array) - Required - The source values.

## Heap.nlargest

### Description
Retrieves the n largest values from the given iterables.

### Parameters
- **comparator** (function) - Optional - Custom comparison function.
- **n** (number) - Required - Number of largest values to retrieve.
- **iterable** (Array) - Required - The source values.
```

--------------------------------

### SymSpell Search Method

Source: https://yomguithereal.github.io/mnemonist/symspell

Find items in the index that are within a specified edit distance from the query.

```APIDOC
### #.search
Returns every item relevant to the given query.
```javascript
const index = new SymSpell();

index.add('hello');
index.add('mello');
index.add('roman');

index.search('vello');
>>> [
  {item: 'hello', distance: 1, count: 1}
  {item: 'mello', distance: 1, count: 1}
]
```
```

--------------------------------

### MultiSet.isSubset Static Method

Source: https://yomguithereal.github.io/mnemonist/multi-set

Checks if one MultiSet is a subset of another.

```APIDOC
## MultiSet.isSubset(subset, superset)

### Description
Static method returning whether the first multiset is a subset of the second.

### Method
GET (conceptual)

### Endpoint
N/A (Static method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```javascript
const letters = MultiSet.from('aaabbc');
const lessLetters = MultiSet.from('aab');

MultiSet.isSubset(lessLetters, letters);
>>> true
```

### Response
#### Success Response (200)
- **result** (boolean) - True if the first multiset is a subset of the second, false otherwise.

#### Response Example
```json
true
```
```

--------------------------------

### SymSpell Clear Method

Source: https://yomguithereal.github.io/mnemonist/symspell

Remove all items from the SymSpell index.

```APIDOC
### #.clear
Completely clears the index of its items.
```javascript
const index = new SymSpell();

index.add('hello');
index.clear();

index.size
>>> 0
```
```

--------------------------------

### Vector.resize

Source: https://yomguithereal.github.io/mnemonist/vector

Resizes the vector's length. Reallocates memory if the new length exceeds current capacity.

```APIDOC
## .resize(length)

### Description
Resize the vector’s length. Will reallocate if current capacity is insufficient. Note that it won’t deallocate if the given length is inferior to the current one.

### Parameters
- **length** (number) - Required - The new length for the vector.

### Request Example
vector.resize(25);
```

--------------------------------

### Vector.values

Source: https://yomguithereal.github.io/mnemonist/vector

Returns an iterator over the vector's values.

```APIDOC
## .values()

### Description
Returns an iterator over the vector’s values.
```

--------------------------------

### Vector Members

Source: https://yomguithereal.github.io/mnemonist/vector

Exposes the underlying typed array, capacity, and current length of the vector.

```APIDOC
## Members
  * #.array
  * #.capacity
  * #.length

### #.array
The underlying typed array, if you need it for any reason (probably performance, in some precise use cases).
```javascript
const vector = new Vector(Uint8Array, 4);

vector.push(1);
vector.push(2);

vector.array
>>> [1, 2, 0, 0]

// BEWARE: don't keep a reference of this array
// it can be swapped by the implementation when growing!
const underlyingArray = vector.array;
// ^ this could result in unexpected behaviors
// if you expand the array later on
// Example:
vector.push(3);
vector.push(4);
vector.push(5);

underlyingArray;
>>> [1, 2, 3, 4]
vector.array
>>> [1, 2, 3, 4, 5, 0] // The underlying array has grown!
```

### #.capacity
Real length of the underlying array, i.e. the maximum number of items the array can hold before needing to resize. Not to be confused with #.length.
```javascript
const vector = new Vector(Uint8Array, 10);

vector.push(1);
vector.push(2);

vector.capacity
>>> 10
```

### #.length
Current length of the vector, that is to say the last set index plus one.
```javascript
const vector = new Vector(Uint8Array, 10);

vector.push(1);
vector.push(2);

vector.length
>>> 2
```
```

--------------------------------

### MultiSet.isSuperset Static Method

Source: https://yomguithereal.github.io/mnemonist/multi-set

Checks if one MultiSet is a superset of another.

```APIDOC
## MultiSet.isSuperset(superset, subset)

### Description
Static method returning whether the first multiset is a superset of the second.

### Method
GET (conceptual)

### Endpoint
N/A (Static method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```javascript
const letters = MultiSet.from('aaabbc');
const lessLetters = MultiSet.from('aab');

MultiSet.isSuperset(letters, lessLetters);
>>> true
```

### Response
#### Success Response (200)
- **result** (boolean) - True if the first multiset is a superset of the second, false otherwise.

#### Response Example
```json
true
```
```

--------------------------------

### Checking Vector Length

Source: https://yomguithereal.github.io/mnemonist/vector

Retrieve the current number of elements in the vector.

```javascript
const vector = new Vector(Uint8Array, 10);

vector.push(1);
vector.push(2);

vector.length
>>> 2
```

--------------------------------

### TrieMap.delete()

Source: https://yomguithereal.github.io/mnemonist/trie-map

Removes a prefix and its associated value from the TrieMap.

```APIDOC
### #.delete

Deletes a prefix from the TrieMap. Returns `true` if the prefix was deleted and `false` if the prefix was not in the TrieMap.

*   **Time Complexity**: `O(m)`, where `m` is the length of the prefix string.

#### Parameters

*   **prefix** (string | Array) - The prefix to delete.

#### Return Value

*   (boolean) - `true` if the prefix was deleted, `false` otherwise.

#### Request Example

```javascript
const trie = new TrieMap();
trie.set('hello', 'world');

trie.delete('hello');
>>> true

trie.delete('world');
>>> false
```
```
Tokens:
Raw