elyse-help 1.1.9

package/backend/node_modules/lru.min/README.md

@@ -0,0 +1,392 @@
+<h1 align="center">lru.min</h1>
+<div align="center">
+
+[![NPM Version](https://img.shields.io/npm/v/lru.min.svg?label=&color=70a1ff&logo=npm&logoColor=white)](https://www.npmjs.com/package/lru.min)
+[![NPM Downloads](https://img.shields.io/npm/dm/lru.min.svg?label=&logo=npm&logoColor=white&color=45aaf2)](https://www.npmjs.com/package/lru.min)
+[![Coverage](https://img.shields.io/codecov/c/github/wellwelwel/lru.min?label=&logo=codecov&logoColor=white&color=98cc00)](https://app.codecov.io/gh/wellwelwel/lru.min)<br />
+[![GitHub Workflow Status (Node.js)](https://img.shields.io/github/actions/workflow/status/wellwelwel/lru.min/ci_node.yml?event=push&label=&branch=main&logo=nodedotjs&logoColor=535c68&color=badc58)](https://github.com/wellwelwel/lru.min/actions/workflows/ci_node.yml?query=branch%3Amain)
+[![GitHub Workflow Status (Bun)](https://img.shields.io/github/actions/workflow/status/wellwelwel/lru.min/ci_bun.yml?event=push&label=&branch=main&logo=bun&logoColor=ffffff&color=f368e0)](https://github.com/wellwelwel/lru.min/actions/workflows/ci_bun.yml?query=branch%3Amain)
+[![GitHub Workflow Status (Deno)](https://img.shields.io/github/actions/workflow/status/wellwelwel/lru.min/ci_deno.yml?event=push&label=&branch=main&logo=deno&logoColor=ffffff&color=079992)](https://github.com/wellwelwel/lru.min/actions/workflows/ci_deno.yml?query=branch%3Amain)
+
+🔥 An extremely fast, efficient, and lightweight <strong><a href="https://en.m.wikipedia.org/wiki/Cache_replacement_policies#Least_Recently_Used_.28LRU.29">LRU</a> Cache</strong> for <strong>JavaScript</strong> (<strong>Browser</strong> compatible).
+
+</div>
+
+## Why another LRU?
+
+- 🎖️ **lru.min** is fully compatible with both **Node.js** _(8+)_, **Bun**, **Deno** and, browser environments. All of this, while maintaining the same high performance [_(and a little more)_](https://github.com/wellwelwel/lru.min?tab=readme-ov-file#performance) as the most popular **LRU** packages.
+
+---
+
+## Install
+
+```bash
+# Node.js
+npm i lru.min
+```
+
+```bash
+# Bun
+bun add lru.min
+```
+
+```bash
+# Deno
+deno add npm:lru.min
+```
+
+---
+
+## Usage
+
+### Quickstart
+
+```js
+import { createLRU } from 'lru.min';
+
+const max = 2;
+const onEviction = (key, value) => {
+  console.log(`Key "${key}" with value "${value}" has been evicted.`);
+};
+
+const LRU = createLRU({
+  max,
+  onEviction,
+});
+
+LRU.set('A', 'My Value');
+LRU.set('B', 'Other Value');
+LRU.set('C', 'Another Value');
+
+// => Key "A" with value "My Value" has been evicted.
+
+LRU.has('B');
+LRU.get('B');
+LRU.delete('B');
+
+// => Key "B" with value "Other Value" has been evicted.
+
+LRU.peek('C');
+
+LRU.clear(); // ← recommended | LRU.evict(max) → (slower alternative)
+
+// => Key "C" with value "Another Value" has been evicted.
+
+LRU.set('D', "You're amazing 💛");
+
+LRU.size; // 1
+LRU.max; // 2
+LRU.available; // 1
+
+LRU.resize(10);
+
+LRU.size; // 1
+LRU.max; // 10
+LRU.available; // 9
+```
+
+> For _up-to-date_ documentation, always follow the [**README.md**](https://github.com/wellwelwel/lru.min?tab=readme-ov-file#readme) in the **GitHub** repository.
+
+### Import
+
+#### ES Modules
+
+```js
+import { createLRU } from 'lru.min';
+```
+
+#### CommonJS
+
+```js
+const { createLRU } = require('lru.min');
+```
+
+#### Browser
+
+> Requires **ES6**.
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/lru.min@1.x.x/browser/lru.min.js"></script>
+```
+
+- You can use tools such as [**Babel**](https://github.com/babel/babel) to increase the compatibility rate.
+
+### Create a new LRU Cache
+
+> Set maximum size when creating **LRU**.
+
+```ts
+const LRU = createLRU({ max: 150_000 });
+```
+
+Also, you can set a callback for every deletion/eviction:
+
+```ts
+const LRU = createLRU({
+  max: 150_000,
+  onEviction: (key, value) => {
+    // do something
+  },
+});
+```
+
+### Set a cache
+
+Adds a key-value pair to the cache. Updates the value if the key already exists
+
+```ts
+LRU.set('key', 'value');
+```
+
+> `undefined` keys will simply be ignored.
+
+- Complexity: **O(1)**.
+
+### Get a cache
+
+Retrieves the value for a given key and moves the key to the most recent position.
+
+```ts
+LRU.get('key');
+```
+
+- Complexity: **O(1)**.
+
+### Peek a cache
+
+Retrieves the value for a given key without changing its position.
+
+```ts
+LRU.peek('key');
+```
+
+- Complexity: **O(1)**.
+
+### Check if a key exists
+
+```ts
+LRU.has('key');
+```
+
+- Complexity: **O(1)**.
+
+### Delete a cache
+
+```ts
+LRU.delete('key');
+```
+
+- Complexity: **O(1)**.
+
+### Evict from the oldest cache
+
+Evicts the specified number of the oldest items from the cache.
+
+```ts
+LRU.evict(1000);
+```
+
+- Complexity: **O(key)** — even if passed a number greater than the number of items, only existing items will be evicted.
+
+> [!TIP]
+>
+> - Methods that perform eviction(s) when maximum size is reached: `set` and `resize`.
+> - Methods that always perform eviction(s): `delete`, `clear`, and `evict` itself.
+
+### Resize the cache
+
+Resizes the cache to a new maximum size, evicting items if necessary.
+
+```ts
+LRU.resize(50_000);
+```
+
+- Complexity:
+  - Increasing: **O(newMax - max)**.
+  - Downsizing: **O(n)**.
+
+### Clear the cache
+
+Clears and disposes (if used) all key-value pairs from the cache.
+
+```ts
+LRU.clear();
+```
+
+- Complexity:
+  - Without `onEviction`: **O(1)**.
+  - Using `onEviction`: **O(entries)**.
+
+### Debugging
+
+#### Get the max size of the cache
+
+```ts
+LRU.max;
+```
+
+- Complexity: **O(1)**.
+
+#### Get the current size of the cache
+
+```ts
+LRU.size;
+```
+
+- Complexity: **O(1)**.
+
+#### Get the available slots in the cache
+
+```ts
+LRU.available;
+```
+
+- Complexity: **O(1)**.
+
+### Iterating the cache
+
+#### Get all keys
+
+Iterates over all keys in the cache, from most recent to least recent.
+
+```ts
+const keys = [...LRU.keys()];
+```
+
+- Complexity: **O(keys)**.
+
+#### Get all values
+
+Iterates over all values in the cache, from most recent to least recent.
+
+```ts
+const values = [...LRU.values()];
+```
+
+- Complexity: **O(values)**.
+
+#### Get all entries
+
+Iterates over `[key, value]` pairs in the cache, from most recent to least recent.
+
+```ts
+const entries = [...LRU.entries()];
+```
+
+- Complexity: **O(entries)**.
+
+#### Run a callback for each entry
+
+Iterates over each value-key pair in the cache, from most recent to least recent.
+
+```ts
+LRU.forEach((value, key) => {
+  // do something
+});
+```
+
+- Complexity: **O(entries)**.
+
+---
+
+> [!NOTE]
+>
+> - We use `O(keys)`, `O(values)`, `O(entries)`, and `O(newMax - max)` to explicitly indicate what is being iterated over. In traditional complexity notation, this would be represented as `O(n)`.
+
+---
+
+### TypeScript
+
+You can set types for both keys and values. For example:
+
+```ts
+import { createLRU } from 'lru.min';
+
+type Key = number;
+
+type Value = {
+  name: string;
+};
+
+const LRU = createLRU<Key, Value>({ max: 1000 });
+
+LRU.set(1, { name: 'Peter' });
+LRU.set(2, { name: 'Mary' });
+```
+
+Also:
+
+```ts
+import { createLRU, type CacheOptions } from 'lru.min';
+
+type Key = number;
+
+type Value = {
+  name: string;
+};
+
+const options: CacheOptions<Key, Value> = {
+  max: 10,
+  onEviction(key, value) {
+    console.log(key, value);
+  },
+};
+
+// No need to repeat the type params
+const LRU = createLRU(options);
+
+LRU.set(1, { name: 'Peter' });
+LRU.set(2, { name: 'Mary' });
+```
+
+---
+
+### Performance
+
+The benchmark is performed by comparing `1,000,000` runs through a maximum cache limit of `100,000`, getting `333,333` caches and deleting `200,000` keys 10 consecutive times, clearing the cache every run.
+
+> - [**lru-cache**](https://github.com/isaacs/node-lru-cache) `v11.0.0`
+
+```sh
+# Time:
+  lru.min:    240.45ms
+  lru-cache:  258.32ms
+
+# CPU:
+  lru.min:    275558.30µs
+  lru-cache:  306858.30µs
+```
+
+- See detailed results and how the tests are run and compared in the [**benchmark**](https://github.com/wellwelwel/lru.min/tree/main/benchmark) directory.
+
+---
+
+## Security Policy
+
+[![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/wellwelwel/lru.min/ci_codeql.yml?event=push&label=&branch=main&logo=github&logoColor=white&color=f368e0)](https://github.com/wellwelwel/lru.min/actions/workflows/ci_codeql.yml?query=branch%3Amain)
+
+Please check the [**SECURITY.md**](https://github.com/wellwelwel/lru.min/blob/main/SECURITY.md).
+
+---
+
+## Contributing
+
+See the [**Contributing Guide**](https://github.com/wellwelwel/lru.min/blob/main/CONTRIBUTING.md) and please follow our [**Code of Conduct**](https://github.com/wellwelwel/lru.min/blob/main/CODE_OF_CONDUCT.md) 🚀
+
+---
+
+## Acknowledgements
+
+- [![Contributors](https://img.shields.io/github/contributors/wellwelwel/lru.min?label=Contributors)](https://github.com/wellwelwel/lru.min/graphs/contributors)
+- **lru.min** is inspired by [**lru-cache**](https://github.com/isaacs/node-lru-cache) architecture and [**quick-lru**](https://github.com/sindresorhus/quick-lru) usage, simplifying and improving their concepts for enhanced performance and compatibility.
+
+> [!IMPORTANT]
+>
+> No [**lru-cache**](https://github.com/isaacs/node-lru-cache) or [**quick-lru**](https://github.com/sindresorhus/quick-lru) code is used in **lru.min**. For more comprehensive features such as **TTL** support, consider using and supporting them 🤝
+
+---
+
+## License
+
+**lru.min** is under the [**MIT License**](https://github.com/wellwelwel/lru.min/blob/main/LICENSE).<br />
+Copyright © 2024-present [Weslley Araújo](https://github.com/wellwelwel) and **lru.min** [contributors](https://github.com/wellwelwel/lru.min/graphs/contributors).

package/backend/node_modules/lru.min/browser/lru.min.js

@@ -0,0 +1 @@
+"use strict";window.createLRU=function(e){var r=e.max;if(!(Number.isInteger(r)&&r>0))throw new TypeError("`max` must be a positive integer");var n=0,i=0,t=0,l=[],o=e.onEviction,a=new Map,f=new Array(r).fill(void 0),v=new Array(r).fill(void 0),u=new Array(r).fill(0),d=new Array(r).fill(0),c=function(e){u[t]=e,d[e]=t,u[e]=0,t=e},s=function(e){if(e!==t){var r=u[e],n=d[e];e===i?i=r:u[n]=r,d[r]=n,c(e)}};return{set:function(e,g){if(void 0!==e){var h=a.get(e);if(void 0===h){if(n===r){var w=f[h=i];null==o||o(w,v[h]),a.delete(w),i=u[h],d[i]=0}else h=l.length>0?l.pop():n,n++;a.set(e,h),f[h]=e,v[h]=g,1===n?i=t=h:c(h)}else null==o||o(e,v[h]),v[h]=g,s(h)}},get:function(e){var r=a.get(e);if(void 0!==r)return r!==t&&s(r),v[r]},peek:function(e){var r=a.get(e);return void 0!==r?v[r]:void 0},has:function(e){return a.has(e)},keys:function*(){for(var e=t,r=0;r<n;r++)yield f[e],e=d[e]},values:function*(){for(var e=t,r=0;r<n;r++)yield v[e],e=d[e]},entries:function*(){for(var e=t,r=0;r<n;r++)yield[f[e],v[e]],e=d[e]},forEach:function(e){for(var r=t,i=0;i<n;i++){var l=f[r];e(v[r],l),r=d[r]}},delete:function(e){var r=a.get(e);if(void 0===r)return!1;null==o||o(e,v[r]),a.delete(e),l.push(r),f[r]=void 0,v[r]=void 0;var c=d[r],s=u[r];return r===i?i=s:u[c]=s,r===t?t=c:d[s]=c,n--,!0},evict:function(e){for(var r=Math.min(e,n);r>0;){var c=i,s=f[c];null==o||o(s,v[c]),a.delete(s),f[c]=void 0,v[c]=void 0,i=u[c],d[i]=0,n--,l.push(c),r--}0===n&&(i=t=0)},clear:function(){if(o)for(var e=i,r=0;r<n;r++)o(f[e],v[e]),e=u[e];a.clear(),f.fill(void 0),v.fill(void 0),l=[],n=0,i=t=0},resize:function(e){if(!(Number.isInteger(e)&&e>0))throw new TypeError("`max` must be a positive integer");e!==r&&(e<r?function(e){for(var r=t,c=Math.min(n,e),s=n-c,g=new Array(c),h=new Array(c),w=0;w<s;w++){var y=f[i];null==o||o(y,v[i]),a.delete(y),i=u[i]}for(var p=c-1;p>=0;p--)g[p]=f[r],h[p]=v[r],a.set(f[r],p),r=d[r];i=0,t=c-1,n=c,f.length=e,v.length=e,u.length=e,d.length=e;for(var m=0;m<c;m++)f[m]=g[m],v[m]=h[m],u[m]=m+1,d[m]=m-1;l=[];for(var A=c;A<e;A++)l.push(A)}(e):function(e){f.length=e,v.length=e,u.length=e,d.length=e,f.fill(void 0,r),v.fill(void 0,r),u.fill(0,r),d.fill(0,r)}(e),r=e)},get max(){return r},get size(){return n},get available(){return r-n}}};

package/backend/node_modules/lru.min/lib/index.d.ts

@@ -0,0 +1,38 @@
+export type CacheOptions<Key = unknown, Value = unknown> = {
+    /** Maximum number of items the cache can hold. */
+    max: number;
+    /** Function called when an item is evicted from the cache. */
+    onEviction?: (key: Key, value: Value) => unknown;
+};
+export declare const createLRU: <Key, Value>(options: CacheOptions<Key, Value>) => {
+    /** Adds a key-value pair to the cache. Updates the value if the key already exists. */
+    set(key: Key, value: Value): undefined;
+    /** Retrieves the value for a given key and moves the key to the most recent position. */
+    get(key: Key): Value | undefined;
+    /** Retrieves the value for a given key without changing its position. */
+    peek: (key: Key) => Value | undefined;
+    /** Checks if a key exists in the cache. */
+    has: (key: Key) => boolean;
+    /** Iterates over all keys in the cache, from most recent to least recent. */
+    keys(): IterableIterator<Key>;
+    /** Iterates over all values in the cache, from most recent to least recent. */
+    values(): IterableIterator<Value>;
+    /** Iterates over `[key, value]` pairs in the cache, from most recent to least recent. */
+    entries(): IterableIterator<[Key, Value]>;
+    /** Iterates over each value-key pair in the cache, from most recent to least recent. */
+    forEach: (callback: (value: Value, key: Key) => unknown) => undefined;
+    /** Deletes a key-value pair from the cache. */
+    delete(key: Key): boolean;
+    /** Evicts the oldest item or the specified number of the oldest items from the cache. */
+    evict: (number: number) => undefined;
+    /** Clears all key-value pairs from the cache. */
+    clear(): undefined;
+    /** Resizes the cache to a new maximum size, evicting items if necessary. */
+    resize: (newMax: number) => undefined;
+    /** Returns the maximum number of items that can be stored in the cache. */
+    readonly max: number;
+    /** Returns the number of items currently stored in the cache. */
+    readonly size: number;
+    /** Returns the number of currently available slots in the cache before reaching the maximum size. */
+    readonly available: number;
+};

package/backend/node_modules/lru.min/lib/index.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLRU = void 0;
+const createLRU = (options) => {
+    let { max } = options;
+    if (!(Number.isInteger(max) && max > 0))
+        throw new TypeError('`max` must be a positive integer');
+    let size = 0;
+    let head = 0;
+    let tail = 0;
+    let free = [];
+    const { onEviction } = options;
+    const keyMap = new Map();
+    const keyList = new Array(max).fill(undefined);
+    const valList = new Array(max).fill(undefined);
+    const next = new Array(max).fill(0);
+    const prev = new Array(max).fill(0);
+    const linkTail = (index) => {
+        next[tail] = index;
+        prev[index] = tail;
+        next[index] = 0;
+        tail = index;
+    };
+    const moveToTail = (index) => {
+        if (index === tail)
+            return;
+        const nextIndex = next[index];
+        const prevIndex = prev[index];
+        if (index === head)
+            head = nextIndex;
+        else
+            next[prevIndex] = nextIndex;
+        prev[nextIndex] = prevIndex;
+        linkTail(index);
+    };
+    const _shrink = (newMax) => {
+        let current = tail;
+        const preserve = Math.min(size, newMax);
+        const remove = size - preserve;
+        const newKeyList = new Array(preserve);
+        const newValList = new Array(preserve);
+        for (let i = 0; i < remove; i++) {
+            const key = keyList[head];
+            onEviction === null || onEviction === void 0 ? void 0 : onEviction(key, valList[head]);
+            keyMap.delete(key);
+            head = next[head];
+        }
+        for (let i = preserve - 1; i >= 0; i--) {
+            newKeyList[i] = keyList[current];
+            newValList[i] = valList[current];
+            keyMap.set(keyList[current], i);
+            current = prev[current];
+        }
+        head = 0;
+        tail = preserve - 1;
+        size = preserve;
+        keyList.length = newMax;
+        valList.length = newMax;
+        next.length = newMax;
+        prev.length = newMax;
+        for (let i = 0; i < preserve; i++) {
+            keyList[i] = newKeyList[i];
+            valList[i] = newValList[i];
+            next[i] = i + 1;
+            prev[i] = i - 1;
+        }
+        free = [];
+        for (let i = preserve; i < newMax; i++)
+            free.push(i);
+    };
+    const _grow = (newMax) => {
+        keyList.length = newMax;
+        valList.length = newMax;
+        next.length = newMax;
+        prev.length = newMax;
+        keyList.fill(undefined, max);
+        valList.fill(undefined, max);
+        next.fill(0, max);
+        prev.fill(0, max);
+    };
+    return {
+        /** Adds a key-value pair to the cache. Updates the value if the key already exists. */
+        set(key, value) {
+            if (key === undefined)
+                return;
+            let index = keyMap.get(key);
+            if (index === undefined) {
+                if (size === max) {
+                    index = head;
+                    const evictKey = keyList[index];
+                    onEviction === null || onEviction === void 0 ? void 0 : onEviction(evictKey, valList[index]);
+                    keyMap.delete(evictKey);
+                    head = next[index];
+                    prev[head] = 0;
+                }
+                else {
+                    index = free.length > 0 ? free.pop() : size;
+                    size++;
+                }
+                keyMap.set(key, index);
+                keyList[index] = key;
+                valList[index] = value;
+                if (size === 1)
+                    head = tail = index;
+                else
+                    linkTail(index);
+            }
+            else {
+                onEviction === null || onEviction === void 0 ? void 0 : onEviction(key, valList[index]);
+                valList[index] = value;
+                moveToTail(index);
+            }
+        },
+        /** Retrieves the value for a given key and moves the key to the most recent position. */
+        get(key) {
+            const index = keyMap.get(key);
+            if (index === undefined)
+                return;
+            if (index !== tail)
+                moveToTail(index);
+            return valList[index];
+        },
+        /** Retrieves the value for a given key without changing its position. */
+        peek: (key) => {
+            const index = keyMap.get(key);
+            return index !== undefined ? valList[index] : undefined;
+        },
+        /** Checks if a key exists in the cache. */
+        has: (key) => keyMap.has(key),
+        /** Iterates over all keys in the cache, from most recent to least recent. */
+        *keys() {
+            let current = tail;
+            for (let i = 0; i < size; i++) {
+                yield keyList[current];
+                current = prev[current];
+            }
+        },
+        /** Iterates over all values in the cache, from most recent to least recent. */
+        *values() {
+            let current = tail;
+            for (let i = 0; i < size; i++) {
+                yield valList[current];
+                current = prev[current];
+            }
+        },
+        /** Iterates over `[key, value]` pairs in the cache, from most recent to least recent. */
+        *entries() {
+            let current = tail;
+            for (let i = 0; i < size; i++) {
+                yield [keyList[current], valList[current]];
+                current = prev[current];
+            }
+        },
+        /** Iterates over each value-key pair in the cache, from most recent to least recent. */
+        forEach: (callback) => {
+            let current = tail;
+            for (let i = 0; i < size; i++) {
+                const key = keyList[current];
+                const value = valList[current];
+                callback(value, key);
+                current = prev[current];
+            }
+        },
+        /** Deletes a key-value pair from the cache. */
+        delete(key) {
+            const index = keyMap.get(key);
+            if (index === undefined)
+                return false;
+            onEviction === null || onEviction === void 0 ? void 0 : onEviction(key, valList[index]);
+            keyMap.delete(key);
+            free.push(index);
+            keyList[index] = undefined;
+            valList[index] = undefined;
+            const prevIndex = prev[index];
+            const nextIndex = next[index];
+            if (index === head)
+                head = nextIndex;
+            else
+                next[prevIndex] = nextIndex;
+            if (index === tail)
+                tail = prevIndex;
+            else
+                prev[nextIndex] = prevIndex;
+            size--;
+            return true;
+        },
+        /** Evicts the oldest item or the specified number of the oldest items from the cache. */
+        evict: (number) => {
+            let toPrune = Math.min(number, size);
+            while (toPrune > 0) {
+                const evictHead = head;
+                const key = keyList[evictHead];
+                onEviction === null || onEviction === void 0 ? void 0 : onEviction(key, valList[evictHead]);
+                keyMap.delete(key);
+                keyList[evictHead] = undefined;
+                valList[evictHead] = undefined;
+                head = next[evictHead];
+                prev[head] = 0;
+                size--;
+                free.push(evictHead);
+                toPrune--;
+            }
+            if (size === 0)
+                head = tail = 0;
+        },
+        /** Clears all key-value pairs from the cache. */
+        clear() {
+            if (onEviction) {
+                let current = head;
+                for (let i = 0; i < size; i++) {
+                    onEviction(keyList[current], valList[current]);
+                    current = next[current];
+                }
+            }
+            keyMap.clear();
+            keyList.fill(undefined);
+            valList.fill(undefined);
+            free = [];
+            size = 0;
+            head = tail = 0;
+        },
+        /** Resizes the cache to a new maximum size, evicting items if necessary. */
+        resize: (newMax) => {
+            if (!(Number.isInteger(newMax) && newMax > 0))
+                throw new TypeError('`max` must be a positive integer');
+            if (newMax === max)
+                return;
+            if (newMax < max)
+                _shrink(newMax);
+            else
+                _grow(newMax);
+            max = newMax;
+        },
+        /** Returns the maximum number of items that can be stored in the cache. */
+        get max() {
+            return max;
+        },
+        /** Returns the number of items currently stored in the cache. */
+        get size() {
+            return size;
+        },
+        /** Returns the number of currently available slots in the cache before reaching the maximum size. */
+        get available() {
+            return max - size;
+        },
+    };
+};
+exports.createLRU = createLRU;