@stryke/helpers 0.9.26 → 0.9.28

package/dist/lru-cache-D4VEIgtR.d.cts

@@ -1,103 +0,0 @@
-//#region src/lru-cache.d.ts
-/**
- * LRU (Least Recently Used) Cache implementation using a doubly-linked list
- * and hash map for O(1) operations.
- *
- * Algorithm:
- * - Uses a doubly-linked list to maintain access order (most recent at head)
- * - Hash map provides O(1) key-to-node lookup
- * - Sentinel head/tail nodes simplify edge case handling
- * - Size-based eviction supports custom size calculation functions
- *
- * Data Structure Layout:
- * HEAD \<-\> [most recent] \<-\> ... \<-\> [least recent] \<-\> TAIL
- *
- * Operations:
- * - get(): Move accessed node to head (mark as most recent)
- * - set(): Add new node at head, evict from tail if over capacity
- * - Eviction: Remove least recent node (tail.prev) when size exceeds limit
- */
-declare class LRUCache<T> {
-  private readonly cache;
-  private readonly head;
-  private readonly tail;
-  private totalSize;
-  private readonly maxSize;
-  private readonly calculateSize;
-  constructor(maxSize: number, calculateSize?: (value: T) => number);
-  /**
-   * Adds a node immediately after the head (marks as most recently used). Used when inserting new items or when an item is accessed. **PRECONDITION:** node must be disconnected (prev/next should be null)
-   *
-   * @param node - The node to add after the head.
-   */
-  private addToHead;
-  /**
-   * Removes a node from its current position in the doubly-linked list. Updates the prev/next pointers of adjacent nodes to maintain list integrity. **PRECONDITION:** node must be connected (prev/next are non-null)
-   *
-   * @param node - The node to remove from the list.
-   */
-  private removeNode;
-  /**
-   * Moves an existing node to the head position (marks as most recently used). This is the core LRU operation - accessed items become most recent.
-   *
-   * @param node - The node to move to the head.
-   */
-  private moveToHead;
-  /**
-   * Removes and returns the least recently used node (the one before tail). This is called during eviction when the cache exceeds capacity. **PRECONDITION:** cache is not empty (ensured by caller)
-   *
-   * @returns The removed least recently used node.
-   */
-  private removeTail;
-  /**
-   * Sets a key-value pair in the cache.
-   * If the key exists, updates the value and moves to head.
-   * If new, adds at head and evicts from tail if necessary.
-   *
-   * Time Complexity:
-   * - O(1) for uniform item sizes
-   * - O(k) where k is the number of items evicted (can be O(N) for variable sizes)
-   *
-   * @param key - The key to set.
-   * @param value - The value to set.
-   */
-  set(key: string, value: T): void;
-  /**
-   * Checks if a key exists in the cache.
-   * This is a pure query operation - does NOT update LRU order.
-   *
-   * Time Complexity: O(1)
-   */
-  has(key: string): boolean;
-  /**
-   * Retrieves a value by key and marks it as most recently used.
-   * Moving to head maintains the LRU property for future evictions.
-   *
-   * Time Complexity: O(1)
-   */
-  get(key: string): T | undefined;
-  /**
-   * Returns an iterator over the cache entries. The order is outputted in the
-   * order of most recently used to least recently used.
-   */
-  [Symbol.iterator](): IterableIterator<[string, T]>;
-  /**
-   * Removes a specific key from the cache.
-   * Updates both the hash map and doubly-linked list.
-   *
-   * Time Complexity: O(1)
-   */
-  remove(key: string): void;
-  /**
-   * Returns the number of items in the cache.
-   */
-  get size(): number;
-  /**
-   * Returns the current total size of all cached items.
-   * This uses the custom size calculation if provided.
-   */
-  get currentSize(): number;
-}
-//#endregion
-export { LRUCache as t };
-//# sourceMappingURL=lru-cache-D4VEIgtR.d.cts.map

package/dist/lru-cache-D4VEIgtR.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lru-cache-D4VEIgtR.d.cts","names":[],"sources":["../src/lru-cache.ts"],"sourcesContent":[],"mappings":";;AAgEA;;;;;;;;;;;;;;;;;cAAa;;;;;;;uDAa0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAsEtB;;;;;;;;;;;;;;oBA8CN;;;;;GAchB,MAAA,CAAO,QAAA,KAAa,0BAA0B"}

package/dist/lru-cache-DLY_yZRN.mjs

@@ -1,2 +0,0 @@
-var e=class{key;data;size;prev=null;next=null;constructor(e,t,n){this.key=e,this.data=t,this.size=n}},t=class{prev=null;next=null},n=class{cache=new Map;head;tail;totalSize=0;maxSize;calculateSize;constructor(e,n){this.maxSize=e,this.calculateSize=n,this.head=new t,this.tail=new t,this.head.next=this.tail,this.tail.prev=this.head}addToHead(e){e.prev=this.head,e.next=this.head.next,this.head.next.prev=e,this.head.next=e}removeNode(e){e.prev.next=e.next,e.next.prev=e.prev}moveToHead(e){this.removeNode(e),this.addToHead(e)}removeTail(){let e=this.tail.prev;return this.removeNode(e),e}set(t,n){let r=this.calculateSize?.(n)??1;if(r>this.maxSize)return;let i=this.cache.get(t);if(i)i.data=n,this.totalSize=this.totalSize-i.size+r,i.size=r,this.moveToHead(i);else{let i=new e(t,n,r);this.cache.set(t,i),this.addToHead(i),this.totalSize+=r}for(;this.totalSize>this.maxSize&&this.cache.size>0;){let e=this.removeTail();this.cache.delete(e.key),this.totalSize-=e.size}}has(e){return this.cache.has(e)}get(e){let t=this.cache.get(e);if(t)return this.moveToHead(t),t.data}*[Symbol.iterator](){let e=this.head.next;for(;e&&e!==this.tail;){let t=e;yield[t.key,t.data],e=e.next}}remove(e){let t=this.cache.get(e);t&&(this.removeNode(t),this.cache.delete(e),this.totalSize-=t.size)}get size(){return this.cache.size}get currentSize(){return this.totalSize}};export{n as t};
-//# sourceMappingURL=lru-cache-DLY_yZRN.mjs.map

package/dist/lru-cache-DLY_yZRN.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"lru-cache-DLY_yZRN.mjs","names":[],"sources":["../src/lru-cache.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nclass LRUNode<T> {\n  public readonly key: string;\n\n  public data: T;\n\n  public size: number;\n\n  public prev: LRUNode<T> | SentinelNode<T> | null = null;\n\n  public next: LRUNode<T> | SentinelNode<T> | null = null;\n\n  constructor(key: string, data: T, size: number) {\n    this.key = key;\n    this.data = data;\n    this.size = size;\n  }\n}\n\n/**\n * Sentinel node used for head/tail boundaries.\n * These nodes don't contain actual cache data but simplify list operations.\n */\nclass SentinelNode<T> {\n  public prev: LRUNode<T> | SentinelNode<T> | null = null;\n\n  public next: LRUNode<T> | SentinelNode<T> | null = null;\n}\n\n/**\n * LRU (Least Recently Used) Cache implementation using a doubly-linked list\n * and hash map for O(1) operations.\n *\n * Algorithm:\n * - Uses a doubly-linked list to maintain access order (most recent at head)\n * - Hash map provides O(1) key-to-node lookup\n * - Sentinel head/tail nodes simplify edge case handling\n * - Size-based eviction supports custom size calculation functions\n *\n * Data Structure Layout:\n * HEAD \\<-\\> [most recent] \\<-\\> ... \\<-\\> [least recent] \\<-\\> TAIL\n *\n * Operations:\n * - get(): Move accessed node to head (mark as most recent)\n * - set(): Add new node at head, evict from tail if over capacity\n * - Eviction: Remove least recent node (tail.prev) when size exceeds limit\n */\nexport class LRUCache<T> {\n  private readonly cache: Map<string, LRUNode<T>> = new Map();\n\n  private readonly head: SentinelNode<T>;\n\n  private readonly tail: SentinelNode<T>;\n\n  private totalSize: number = 0;\n\n  private readonly maxSize: number;\n\n  private readonly calculateSize: ((value: T) => number) | undefined;\n\n  constructor(maxSize: number, calculateSize?: (value: T) => number) {\n    this.maxSize = maxSize;\n    this.calculateSize = calculateSize;\n\n    // Create sentinel nodes to simplify doubly-linked list operations\n    // HEAD <-> TAIL (empty list)\n    this.head = new SentinelNode<T>();\n    this.tail = new SentinelNode<T>();\n    this.head.next = this.tail;\n    this.tail.prev = this.head;\n  }\n\n  /**\n   * Adds a node immediately after the head (marks as most recently used). Used when inserting new items or when an item is accessed. **PRECONDITION:** node must be disconnected (prev/next should be null)\n   *\n   * @param node - The node to add after the head.\n   */\n  private addToHead(node: LRUNode<T>): void {\n    node.prev = this.head;\n    node.next = this.head.next;\n    // head.next is always non-null (points to tail or another node)\n    this.head.next!.prev = node;\n    this.head.next = node;\n  }\n\n  /**\n   * Removes a node from its current position in the doubly-linked list. Updates the prev/next pointers of adjacent nodes to maintain list integrity. **PRECONDITION:** node must be connected (prev/next are non-null)\n   *\n   * @param node - The node to remove from the list.\n   */\n  private removeNode(node: LRUNode<T>): void {\n    // Connected nodes always have non-null prev/next\n    node.prev!.next = node.next;\n    node.next!.prev = node.prev;\n  }\n\n  /**\n   * Moves an existing node to the head position (marks as most recently used). This is the core LRU operation - accessed items become most recent.\n   *\n   * @param node - The node to move to the head.\n   */\n  private moveToHead(node: LRUNode<T>): void {\n    this.removeNode(node);\n    this.addToHead(node);\n  }\n\n  /**\n   * Removes and returns the least recently used node (the one before tail). This is called during eviction when the cache exceeds capacity. **PRECONDITION:** cache is not empty (ensured by caller)\n   *\n   * @returns The removed least recently used node.\n   */\n  private removeTail(): LRUNode<T> {\n    const lastNode = this.tail.prev as LRUNode<T>;\n    // tail.prev is always non-null and always LRUNode when cache is not empty\n    this.removeNode(lastNode);\n    return lastNode;\n  }\n\n  /**\n   * Sets a key-value pair in the cache.\n   * If the key exists, updates the value and moves to head.\n   * If new, adds at head and evicts from tail if necessary.\n   *\n   * Time Complexity:\n   * - O(1) for uniform item sizes\n   * - O(k) where k is the number of items evicted (can be O(N) for variable sizes)\n   *\n   * @param key - The key to set.\n   * @param value - The value to set.\n   */\n  public set(key: string, value: T): void {\n    const size = this.calculateSize?.(value) ?? 1;\n    if (size > this.maxSize) {\n      // console.warn(\"Single item size exceeds maxSize\");\n      return;\n    }\n\n    const existing = this.cache.get(key);\n    if (existing) {\n      // Update existing node: adjust size and move to head (most recent)\n      existing.data = value;\n      this.totalSize = this.totalSize - existing.size + size;\n      existing.size = size;\n      this.moveToHead(existing);\n    } else {\n      // Add new node at head (most recent position)\n      const newNode = new LRUNode(key, value, size);\n      this.cache.set(key, newNode);\n      this.addToHead(newNode);\n      this.totalSize += size;\n    }\n\n    // Evict least recently used items until under capacity\n    while (this.totalSize > this.maxSize && this.cache.size > 0) {\n      const tail = this.removeTail();\n      this.cache.delete(tail.key);\n      this.totalSize -= tail.size;\n    }\n  }\n\n  /**\n   * Checks if a key exists in the cache.\n   * This is a pure query operation - does NOT update LRU order.\n   *\n   * Time Complexity: O(1)\n   */\n  public has(key: string): boolean {\n    return this.cache.has(key);\n  }\n\n  /**\n   * Retrieves a value by key and marks it as most recently used.\n   * Moving to head maintains the LRU property for future evictions.\n   *\n   * Time Complexity: O(1)\n   */\n  public get(key: string): T | undefined {\n    const node = this.cache.get(key);\n    if (!node) return undefined;\n\n    // Mark as most recently used by moving to head\n    this.moveToHead(node);\n\n    return node.data;\n  }\n\n  /**\n   * Returns an iterator over the cache entries. The order is outputted in the\n   * order of most recently used to least recently used.\n   */\n  public *[Symbol.iterator](): IterableIterator<[string, T]> {\n    let current = this.head.next;\n    while (current && current !== this.tail) {\n      // Between head and tail, current is always LRUNode\n      const node = current as LRUNode<T>;\n      yield [node.key, node.data];\n      current = current.next;\n    }\n  }\n\n  /**\n   * Removes a specific key from the cache.\n   * Updates both the hash map and doubly-linked list.\n   *\n   * Time Complexity: O(1)\n   */\n  public remove(key: string): void {\n    const node = this.cache.get(key);\n    if (!node) return;\n\n    this.removeNode(node);\n    this.cache.delete(key);\n    this.totalSize -= node.size;\n  }\n\n  /**\n   * Returns the number of items in the cache.\n   */\n  public get size(): number {\n    return this.cache.size;\n  }\n\n  /**\n   * Returns the current total size of all cached items.\n   * This uses the custom size calculation if provided.\n   */\n  public get currentSize(): number {\n    return this.totalSize;\n  }\n}\n"],"mappings":"AAkBA,IAAM,EAAN,KAAiB,CACf,IAEA,KAEA,KAEA,KAAmD,KAEnD,KAAmD,KAEnD,YAAY,EAAa,EAAS,EAAc,CAC9C,KAAK,IAAM,EACX,KAAK,KAAO,EACZ,KAAK,KAAO,IAQV,EAAN,KAAsB,CACpB,KAAmD,KAEnD,KAAmD,MAqBxC,EAAb,KAAyB,CACvB,MAAkD,IAAI,IAEtD,KAEA,KAEA,UAA4B,EAE5B,QAEA,cAEA,YAAY,EAAiB,EAAsC,CACjE,KAAK,QAAU,EACf,KAAK,cAAgB,EAIrB,KAAK,KAAO,IAAI,EAChB,KAAK,KAAO,IAAI,EAChB,KAAK,KAAK,KAAO,KAAK,KACtB,KAAK,KAAK,KAAO,KAAK,KAQxB,UAAkB,EAAwB,CACxC,EAAK,KAAO,KAAK,KACjB,EAAK,KAAO,KAAK,KAAK,KAEtB,KAAK,KAAK,KAAM,KAAO,EACvB,KAAK,KAAK,KAAO,EAQnB,WAAmB,EAAwB,CAEzC,EAAK,KAAM,KAAO,EAAK,KACvB,EAAK,KAAM,KAAO,EAAK,KAQzB,WAAmB,EAAwB,CACzC,KAAK,WAAW,EAAK,CACrB,KAAK,UAAU,EAAK,CAQtB,YAAiC,CAC/B,IAAM,EAAW,KAAK,KAAK,KAG3B,OADA,KAAK,WAAW,EAAS,CAClB,EAeT,IAAW,EAAa,EAAgB,CACtC,IAAM,EAAO,KAAK,gBAAgB,EAAM,EAAI,EAC5C,GAAI,EAAO,KAAK,QAEd,OAGF,IAAM,EAAW,KAAK,MAAM,IAAI,EAAI,CACpC,GAAI,EAEF,EAAS,KAAO,EAChB,KAAK,UAAY,KAAK,UAAY,EAAS,KAAO,EAClD,EAAS,KAAO,EAChB,KAAK,WAAW,EAAS,KACpB,CAEL,IAAM,EAAU,IAAI,EAAQ,EAAK,EAAO,EAAK,CAC7C,KAAK,MAAM,IAAI,EAAK,EAAQ,CAC5B,KAAK,UAAU,EAAQ,CACvB,KAAK,WAAa,EAIpB,KAAO,KAAK,UAAY,KAAK,SAAW,KAAK,MAAM,KAAO,GAAG,CAC3D,IAAM,EAAO,KAAK,YAAY,CAC9B,KAAK,MAAM,OAAO,EAAK,IAAI,CAC3B,KAAK,WAAa,EAAK,MAU3B,IAAW,EAAsB,CAC/B,OAAO,KAAK,MAAM,IAAI,EAAI,CAS5B,IAAW,EAA4B,CACrC,IAAM,EAAO,KAAK,MAAM,IAAI,EAAI,CAC3B,KAKL,OAFA,KAAK,WAAW,EAAK,CAEd,EAAK,KAOd,EAAS,OAAO,WAA2C,CACzD,IAAI,EAAU,KAAK,KAAK,KACxB,KAAO,GAAW,IAAY,KAAK,MAAM,CAEvC,IAAM,EAAO,EACb,KAAM,CAAC,EAAK,IAAK,EAAK,KAAK,CAC3B,EAAU,EAAQ,MAUtB,OAAc,EAAmB,CAC/B,IAAM,EAAO,KAAK,MAAM,IAAI,EAAI,CAC3B,IAEL,KAAK,WAAW,EAAK,CACrB,KAAK,MAAM,OAAO,EAAI,CACtB,KAAK,WAAa,EAAK,MAMzB,IAAW,MAAe,CACxB,OAAO,KAAK,MAAM,KAOpB,IAAW,aAAsB,CAC/B,OAAO,KAAK"}

package/dist/lru-cache-DgTSGx5W.cjs

@@ -1 +0,0 @@
-var e=class{key;data;size;prev=null;next=null;constructor(e,t,n){this.key=e,this.data=t,this.size=n}},t=class{prev=null;next=null},n=class{cache=new Map;head;tail;totalSize=0;maxSize;calculateSize;constructor(e,n){this.maxSize=e,this.calculateSize=n,this.head=new t,this.tail=new t,this.head.next=this.tail,this.tail.prev=this.head}addToHead(e){e.prev=this.head,e.next=this.head.next,this.head.next.prev=e,this.head.next=e}removeNode(e){e.prev.next=e.next,e.next.prev=e.prev}moveToHead(e){this.removeNode(e),this.addToHead(e)}removeTail(){let e=this.tail.prev;return this.removeNode(e),e}set(t,n){let r=this.calculateSize?.(n)??1;if(r>this.maxSize)return;let i=this.cache.get(t);if(i)i.data=n,this.totalSize=this.totalSize-i.size+r,i.size=r,this.moveToHead(i);else{let i=new e(t,n,r);this.cache.set(t,i),this.addToHead(i),this.totalSize+=r}for(;this.totalSize>this.maxSize&&this.cache.size>0;){let e=this.removeTail();this.cache.delete(e.key),this.totalSize-=e.size}}has(e){return this.cache.has(e)}get(e){let t=this.cache.get(e);if(t)return this.moveToHead(t),t.data}*[Symbol.iterator](){let e=this.head.next;for(;e&&e!==this.tail;){let t=e;yield[t.key,t.data],e=e.next}}remove(e){let t=this.cache.get(e);t&&(this.removeNode(t),this.cache.delete(e),this.totalSize-=t.size)}get size(){return this.cache.size}get currentSize(){return this.totalSize}};Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return n}});

package/dist/match-sorter-B9_7YvTo.mjs

@@ -1,2 +0,0 @@
-import{n as e}from"./remove-accents-BFmyvTRZ.mjs";const t={CASE_SENSITIVE_EQUAL:7,EQUAL:6,STARTS_WITH:5,WORD_STARTS_WITH:4,CONTAINS:3,ACRONYM:2,MATCHES:1,NO_MATCH:0},n=(e,t)=>String(e.rankedValue).localeCompare(String(t.rankedValue));function r(e,r,a={}){let{keys:o,threshold:s=t.MATCHES,baseSort:l=n,sorter:u=e=>e.sort((e,t)=>c(e,t,l))}=a;return u(e.reduce((e,t,n)=>d(e,t,n),[])).map(({item:e})=>e);function d(e,t,n){let c=i(t,o,r,a),{rank:l,keyThreshold:u=s}=c;return l>=u&&e.push({...c,item:t,index:n}),e}}r.rankings=t;function i(e,n,r,i){if(!n){let t=e;return{rankedValue:t,rank:a(t,r,i),keyIndex:-1,keyThreshold:i.threshold}}return f(e,n).reduce(({rank:e,rankedValue:n,keyIndex:o,keyThreshold:s},{itemValue:c,attributes:l},u)=>{let d=a(c,r,i),f=n,{minRanking:p,maxRanking:m,threshold:h}=l;return d<p&&d>=t.MATCHES?d=p:d>m&&(d=m),d>e&&(e=d,o=u,s=h,f=c),{rankedValue:f,rank:e,keyIndex:o,keyThreshold:s}},{rankedValue:e,rank:t.NO_MATCH,keyIndex:-1,keyThreshold:i.threshold})}function a(e,n,r){return e=l(e,r),n=l(n,r),n.length>e.length?t.NO_MATCH:e===n?t.CASE_SENSITIVE_EQUAL:(e=e.toLowerCase(),n=n.toLowerCase(),e===n?t.EQUAL:e.startsWith(n)?t.STARTS_WITH:e.includes(` ${n}`)?t.WORD_STARTS_WITH:e.includes(n)?t.CONTAINS:n.length===1?t.NO_MATCH:o(e).includes(n)?t.ACRONYM:s(e,n))}function o(e){let t=``,n=e.split(` `);for(let e of n){let n=e.split(`-`);for(let e of n)t+=e.slice(0,1)}return t}function s(e,n){let r=0,i=0;function a(e,t,n){for(let i=n,a=t.length;i<a;i++)if(t[i]===e)return r+=1,i+1;return-1}function o(e){let i=1/e,a=r/n.length;return t.MATCHES+a*i}let s=a(n[0],e,0);if(s<0)return t.NO_MATCH;i=s;for(let r=1,o=n.length;r<o;r++){let o=n[r];if(i=a(o,e,i),!(i>-1))return t.NO_MATCH}return o(i-s)}function c(e,t,n){let{rank:r,keyIndex:i}=e,{rank:a,keyIndex:o}=t;return r===a?i===o?n(e,t):i<o?-1:1:r>a?-1:1}function l(t,{keepDiacritics:n}){return t=`${t}`,n||(t=e(t)),t}function u(e,t){typeof t==`object`&&(t=t.key);let n;if(typeof t==`function`)n=t(e);else if(e===null)n=null;else if(Object.hasOwnProperty.call(e,t))n=e[t];else if(t.includes(`.`))return d(t,e);else n=null;return n===null?[]:Array.isArray(n)?n:[String(n)]}function d(e,t){let n=e.split(`.`),r=[t];for(let e=0,t=n.length;e<t;e++){let t=n[e],i=[];for(let e=0,n=r.length;e<n;e++){let n=r[e];if(n!==null)if(t&&Object.hasOwnProperty.call(n,t)){let e=n[t];e!==null&&i.push(e)}else n&&t===`*`&&(i=[...i,n])}r=i}return Array.isArray(r[0])?[].concat(...r):r}function f(e,t){let n=[];for(let r=0,i=t.length;r<i;r++){let i=t[r],a=m(i),o=u(e,i);for(let e=0,t=o.length;e<t;e++)n.push({itemValue:o[e],attributes:a})}return n}const p={maxRanking:1/0,minRanking:-1/0};function m(e){return typeof e==`string`?p:{...p,...e}}export{r as n,t as r,n as t};
-//# sourceMappingURL=match-sorter-B9_7YvTo.mjs.map

package/dist/match-sorter-B9_7YvTo.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"match-sorter-B9_7YvTo.mjs","names":["defaultBaseSortFn: BaseSorter<unknown>","value: string | Array<string> | null | unknown","values: ValueA","nestedValues: ValueA","allValues: Array<{ itemValue: string; attributes: KeyAttributes }>"],"sources":["../src/match-sorter.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 License, and is\n free for commercial and private use. For more information, please visit\n our licensing page.\n\n Website:         https://stormsoftware.com\n Repository:      https://github.com/storm-software/stryke\n Documentation:   https://stormsoftware.com/projects/stryke/docs\n Contact:         https://stormsoftware.com/contact\n License:         https://stormsoftware.com/projects/stryke/license\n\n ------------------------------------------------------------------- */\n\nimport { removeAccents } from \"./remove-accents\";\n\n/* eslint-disable @cspell/spellchecker */\n\n/**\n * Forked from match-sorter by Kent C. Dodds\n */\n\ninterface KeyAttributes {\n  threshold?: Ranking;\n  maxRanking: Ranking;\n  minRanking: Ranking;\n}\ninterface RankingInfo {\n  rankedValue: string;\n  rank: Ranking;\n  keyIndex: number;\n  keyThreshold: Ranking | undefined;\n}\n\ninterface ValueGetterKey<ItemType> {\n  (item: ItemType): string | Array<string>;\n}\ninterface IndexedItem<ItemType> {\n  item: ItemType;\n  index: number;\n}\ninterface RankedItem<ItemType> extends RankingInfo, IndexedItem<ItemType> {}\n\ninterface BaseSorter<ItemType> {\n  (a: RankedItem<ItemType>, b: RankedItem<ItemType>): number;\n}\n\ninterface Sorter<ItemType> {\n  (matchItems: Array<RankedItem<ItemType>>): Array<RankedItem<ItemType>>;\n}\n\ninterface KeyAttributesOptions<ItemType> {\n  key?: string | ValueGetterKey<ItemType>;\n  threshold?: Ranking;\n  maxRanking?: Ranking;\n  minRanking?: Ranking;\n}\n\ntype KeyOption<ItemType> =\n  | KeyAttributesOptions<ItemType>\n  | ValueGetterKey<ItemType>\n  | string;\n\ninterface MatchSorterOptions<ItemType = unknown> {\n  keys?: ReadonlyArray<KeyOption<ItemType>>;\n  threshold?: Ranking;\n  baseSort?: BaseSorter<ItemType>;\n  keepDiacritics?: boolean;\n  sorter?: Sorter<ItemType>;\n}\ntype IndexableByString = Record<string, unknown>;\n\nconst rankings = {\n  CASE_SENSITIVE_EQUAL: 7,\n  EQUAL: 6,\n  STARTS_WITH: 5,\n  WORD_STARTS_WITH: 4,\n  CONTAINS: 3,\n  ACRONYM: 2,\n  MATCHES: 1,\n  NO_MATCH: 0\n} as const;\n\ntype Ranking = (typeof rankings)[keyof typeof rankings];\n\nconst defaultBaseSortFn: BaseSorter<unknown> = (a, b) =>\n  String(a.rankedValue).localeCompare(String(b.rankedValue));\n\n/**\n * Takes an array of items and a value and returns a new array with the items that match the given value\n * @param items - the items to sort\n * @param value - the value to use for ranking\n * @param options - Some options to configure the sorter\n * @returns - the new sorted array\n */\nfunction matchSorter<ItemType = string>(\n  items: ReadonlyArray<ItemType>,\n  value: string,\n  options: MatchSorterOptions<ItemType> = {}\n): Array<ItemType> {\n  const {\n    keys,\n    threshold = rankings.MATCHES,\n    baseSort = defaultBaseSortFn,\n    sorter = matchedItems =>\n      matchedItems.sort((a, b) => sortRankedValues(a, b, baseSort))\n  } = options;\n  const matchedItems = items.reduce(\n    (ret: Array<RankedItem<ItemType>>, item: ItemType, index: number) =>\n      reduceItemsToRanked(ret, item, index),\n    []\n  );\n\n  return sorter(matchedItems).map(({ item }) => item);\n\n  function reduceItemsToRanked(\n    matches: Array<RankedItem<ItemType>>,\n    item: ItemType,\n    index: number\n  ): Array<RankedItem<ItemType>> {\n    const rankingInfo = getHighestRanking(item, keys, value, options);\n    const { rank, keyThreshold = threshold } = rankingInfo;\n    if (rank >= keyThreshold) {\n      matches.push({\n        ...rankingInfo,\n        item,\n        index\n      });\n    }\n    return matches;\n  }\n}\n\nmatchSorter.rankings = rankings;\n\n/**\n * Gets the highest ranking for value for the given item based on its values for the given keys\n * @param item - the item to rank\n * @param keys - the keys to get values from the item for the ranking\n * @param value - the value to rank against\n * @param options - options to control the ranking\n * @returns The highest ranking\n */\nfunction getHighestRanking<ItemType>(\n  item: ItemType,\n  keys: ReadonlyArray<KeyOption<ItemType>> | undefined,\n  value: string,\n  options: MatchSorterOptions<ItemType>\n): RankingInfo {\n  if (!keys) {\n    // if keys is not specified, then we assume the item given is ready to be matched\n    const stringItem = item as unknown as string;\n\n    return {\n      // ends up being duplicate of 'item' in matches but consistent\n      rankedValue: stringItem,\n      rank: getMatchRanking(stringItem, value, options),\n      keyIndex: -1,\n      keyThreshold: options.threshold\n    };\n  }\n  const valuesToRank = getAllValuesToRank(item, keys);\n\n  return valuesToRank.reduce(\n    (\n      { rank, rankedValue, keyIndex, keyThreshold },\n      { itemValue, attributes },\n      i\n    ) => {\n      let newRank = getMatchRanking(itemValue, value, options);\n      let newRankedValue = rankedValue;\n      const { minRanking, maxRanking, threshold } = attributes;\n      if (newRank < minRanking && newRank >= rankings.MATCHES) {\n        newRank = minRanking;\n      } else if (newRank > maxRanking) {\n        newRank = maxRanking;\n      }\n      if (newRank > rank) {\n        rank = newRank;\n        keyIndex = i;\n        keyThreshold = threshold;\n        newRankedValue = itemValue;\n      }\n      return {\n        rankedValue: newRankedValue,\n        rank,\n        keyIndex,\n        keyThreshold\n      };\n    },\n    {\n      rankedValue: item as unknown as string,\n      rank: rankings.NO_MATCH as Ranking,\n      keyIndex: -1,\n      keyThreshold: options.threshold\n    }\n  );\n}\n\n/**\n * Gives a rankings score based on how well the two strings match.\n * @param testString - the string to test against\n * @param stringToRank - the string to rank\n * @param options - options for the match (like keepDiacritics for comparison)\n * @returns the ranking for how well stringToRank matches testString\n */\nfunction getMatchRanking<ItemType>(\n  testString: string,\n  stringToRank: string,\n  options: MatchSorterOptions<ItemType>\n): Ranking {\n  testString = prepareValueForComparison(testString, options);\n  stringToRank = prepareValueForComparison(stringToRank, options);\n\n  // too long\n  if (stringToRank.length > testString.length) {\n    return rankings.NO_MATCH;\n  }\n\n  // case sensitive equals\n  if (testString === stringToRank) {\n    return rankings.CASE_SENSITIVE_EQUAL;\n  }\n\n  // Lower casing before further comparison\n  testString = testString.toLowerCase();\n  stringToRank = stringToRank.toLowerCase();\n\n  // case insensitive equals\n  if (testString === stringToRank) {\n    return rankings.EQUAL;\n  }\n\n  // starts with\n  if (testString.startsWith(stringToRank)) {\n    return rankings.STARTS_WITH;\n  }\n\n  // word starts with\n  if (testString.includes(` ${stringToRank}`)) {\n    return rankings.WORD_STARTS_WITH;\n  }\n\n  // contains\n  if (testString.includes(stringToRank)) {\n    return rankings.CONTAINS;\n  } else if (stringToRank.length === 1) {\n    // If the only character in the given stringToRank\n    //   isn't even contained in the testString, then\n    //   it's definitely not a match.\n    return rankings.NO_MATCH;\n  }\n\n  // acronym\n  if (getAcronym(testString).includes(stringToRank)) {\n    return rankings.ACRONYM;\n  }\n\n  // will return a number between rankings.MATCHES and\n  // rankings.MATCHES + 1 depending  on how close of a match it is.\n  return getClosenessRanking(testString, stringToRank);\n}\n\n/**\n * Generates an acronym for a string.\n *\n * @param value - the string for which to produce the acronym\n * @returns the acronym\n */\nfunction getAcronym(value: string): string {\n  let acronym = \"\";\n  const wordsInString = value.split(\" \");\n  for (const wordInString of wordsInString) {\n    const splitByHyphenWords = wordInString.split(\"-\");\n    for (const splitByHyphenWord of splitByHyphenWords) {\n      acronym += splitByHyphenWord.slice(0, 1);\n    }\n  }\n  return acronym;\n}\n\n/**\n * Returns a score based on how spread apart the\n * characters from the stringToRank are within the testString.\n * A number close to rankings.MATCHES represents a loose match. A number close\n * to rankings.MATCHES + 1 represents a tighter match.\n * @param testString - the string to test against\n * @param stringToRank - the string to rank\n * @returns the number between rankings.MATCHES and\n * rankings.MATCHES + 1 for how well stringToRank matches testString\n */\nfunction getClosenessRanking(\n  testString: string,\n  stringToRank: string\n): Ranking {\n  let matchingInOrderCharCount = 0;\n  let charNumber = 0;\n  function findMatchingCharacter(\n    matchChar: string,\n    string: string,\n    index: number\n  ) {\n    for (let j = index, J = string.length; j < J; j++) {\n      const stringChar = string[j];\n      if (stringChar === matchChar) {\n        matchingInOrderCharCount += 1;\n        return j + 1;\n      }\n    }\n    return -1;\n  }\n  function getRanking(spread: number) {\n    const spreadPercentage = 1 / spread;\n    const inOrderPercentage = matchingInOrderCharCount / stringToRank.length;\n    const ranking = rankings.MATCHES + inOrderPercentage * spreadPercentage;\n\n    return ranking as Ranking;\n  }\n  const firstIndex = findMatchingCharacter(stringToRank[0]!, testString, 0);\n  if (firstIndex < 0) {\n    return rankings.NO_MATCH;\n  }\n  charNumber = firstIndex;\n  for (let i = 1, I = stringToRank.length; i < I; i++) {\n    const matchChar = stringToRank[i];\n    charNumber = findMatchingCharacter(matchChar!, testString, charNumber);\n    const found = charNumber > -1;\n    if (!found) {\n      return rankings.NO_MATCH;\n    }\n  }\n\n  const spread = charNumber - firstIndex;\n\n  return getRanking(spread);\n}\n\n/**\n * Sorts items that have a rank, index, and keyIndex\n * @param a - the first item to sort\n * @param b - the second item to sort\n * @returns -1 if a should come first, 1 if b should come first, 0 if equal\n */\nfunction sortRankedValues<ItemType>(\n  a: RankedItem<ItemType>,\n  b: RankedItem<ItemType>,\n  baseSort: BaseSorter<ItemType>\n): number {\n  const aFirst = -1;\n  const bFirst = 1;\n  const { rank: aRank, keyIndex: aKeyIndex } = a;\n  const { rank: bRank, keyIndex: bKeyIndex } = b;\n  const same = aRank === bRank;\n  if (same) {\n    if (aKeyIndex === bKeyIndex) {\n      // use the base sort function as a tie-breaker\n      return baseSort(a, b);\n    }\n    return aKeyIndex < bKeyIndex ? aFirst : bFirst;\n  }\n  return aRank > bRank ? aFirst : bFirst;\n}\n\n/**\n * Prepares value for comparison by stringifying it, removing diacritics (if specified)\n * @param value - the value to clean\n * @param options - options for the match (like keepDiacritics for comparison)\n * @returns the prepared value\n */\nfunction prepareValueForComparison<ItemType>(\n  value: string,\n  { keepDiacritics }: MatchSorterOptions<ItemType>\n): string {\n  // value might not actually be a string at this point (we don't get to choose)\n  // so part of preparing the value for comparison is ensure that it is a string\n  value = `${value}`; // toString\n  if (!keepDiacritics) {\n    value = removeAccents(value);\n  }\n  return value;\n}\n\n/**\n * Gets value for key in item at arbitrarily nested keypath\n * @param item - the item\n * @param key - the potentially nested keypath or property callback\n * @returns - an array containing the value(s) at the nested keypath\n */\nfunction getItemValues<ItemType>(\n  item: ItemType,\n  key: KeyOption<ItemType>\n): Array<string> {\n  if (typeof key === \"object\") {\n    key = key.key as string;\n  }\n  let value: string | Array<string> | null | unknown;\n  if (typeof key === \"function\") {\n    value = key(item);\n  } else if (item === null) {\n    value = null;\n  } else if (Object.hasOwnProperty.call(item, key)) {\n    value = (item as IndexableByString)[key];\n  } else if (key.includes(\".\")) {\n    return getNestedValues<ItemType>(key, item);\n  } else {\n    value = null;\n  }\n\n  // because `value` can also be undefined\n  if (value === null) {\n    return [];\n  }\n  if (Array.isArray(value)) {\n    return value;\n  }\n  return [String(value)];\n}\n\n/**\n * Given path: \"foo.bar.baz\"\n * And item: \\{foo: \\{bar: \\{baz: 'buzz'\\}\\}\\}\n *   -\\> 'buzz'\n *\n * @param path - a dot-separated set of keys\n * @param item - the item to get the value from\n */\nfunction getNestedValues<ItemType>(\n  path: string,\n  item: ItemType\n): Array<string> {\n  const keys = path.split(\".\");\n\n  type ValueA = Array<ItemType | IndexableByString | string>;\n  let values: ValueA = [item];\n\n  for (let i = 0, I = keys.length; i < I; i++) {\n    const nestedKey = keys[i];\n    let nestedValues: ValueA = [];\n\n    for (let j = 0, J = values.length; j < J; j++) {\n      const nestedItem = values[j];\n\n      if (nestedItem === null) {\n        continue;\n      }\n\n      if (nestedKey && Object.hasOwnProperty.call(nestedItem, nestedKey)) {\n        const nestedValue = (nestedItem as IndexableByString)[nestedKey];\n        if (nestedValue !== null) {\n          nestedValues.push(nestedValue as IndexableByString | string);\n        }\n      } else if (nestedItem && nestedKey === \"*\") {\n        // ensure that values is an array\n        nestedValues = [...nestedValues, nestedItem];\n      }\n    }\n\n    values = nestedValues;\n  }\n\n  if (Array.isArray(values[0])) {\n    // keep allowing the implicit wildcard for an array of strings at the end of\n    // the path; don't use `.flat()` because that's not available in node.js v10\n    const result: Array<string> = [];\n\n    return result.concat(...(values as Array<string>));\n  }\n  // Based on our logic it should be an array of strings by now...\n  // assuming the user's path terminated in strings\n  return values as Array<string>;\n}\n\n/**\n * Gets all the values for the given keys in the given item and returns an array of those values\n * @param item - the item from which the values will be retrieved\n * @param keys - the keys to use to retrieve the values\n * @returns objects with \\{itemValue, attributes\\}\n */\nfunction getAllValuesToRank<ItemType>(\n  item: ItemType,\n  keys: ReadonlyArray<KeyOption<ItemType>>\n) {\n  const allValues: Array<{ itemValue: string; attributes: KeyAttributes }> = [];\n  for (let j = 0, J = keys.length; j < J; j++) {\n    const key = keys[j];\n    const attributes = getKeyAttributes(key!);\n    const itemValues = getItemValues(item, key!);\n    for (let i = 0, I = itemValues.length; i < I; i++) {\n      allValues.push({\n        itemValue: itemValues[i]!,\n        attributes\n      });\n    }\n  }\n  return allValues;\n}\n\nconst defaultKeyAttributes = {\n  maxRanking: Infinity as Ranking,\n  minRanking: -Infinity as Ranking\n};\n/**\n * Gets all the attributes for the given key\n * @param key - the key from which the attributes will be retrieved\n * @returns object containing the key's attributes\n */\nfunction getKeyAttributes<ItemType>(key: KeyOption<ItemType>): KeyAttributes {\n  if (typeof key === \"string\") {\n    return defaultKeyAttributes;\n  }\n  return {\n    ...defaultKeyAttributes,\n    ...key\n  };\n}\n\nexport { defaultBaseSortFn, matchSorter, rankings };\n\nexport type {\n  KeyAttributes,\n  KeyAttributesOptions,\n  KeyOption,\n  MatchSorterOptions,\n  RankingInfo,\n  ValueGetterKey\n};\n"],"mappings":"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"}

package/dist/match-sorter-BjnWjkKu.cjs

@@ -1 +0,0 @@
-const e=require(`./remove-accents-CXBUC-Id.cjs`),t={CASE_SENSITIVE_EQUAL:7,EQUAL:6,STARTS_WITH:5,WORD_STARTS_WITH:4,CONTAINS:3,ACRONYM:2,MATCHES:1,NO_MATCH:0},n=(e,t)=>String(e.rankedValue).localeCompare(String(t.rankedValue));function r(e,r,a={}){let{keys:o,threshold:s=t.MATCHES,baseSort:l=n,sorter:u=e=>e.sort((e,t)=>c(e,t,l))}=a;return u(e.reduce((e,t,n)=>d(e,t,n),[])).map(({item:e})=>e);function d(e,t,n){let c=i(t,o,r,a),{rank:l,keyThreshold:u=s}=c;return l>=u&&e.push({...c,item:t,index:n}),e}}r.rankings=t;function i(e,n,r,i){if(!n){let t=e;return{rankedValue:t,rank:a(t,r,i),keyIndex:-1,keyThreshold:i.threshold}}return f(e,n).reduce(({rank:e,rankedValue:n,keyIndex:o,keyThreshold:s},{itemValue:c,attributes:l},u)=>{let d=a(c,r,i),f=n,{minRanking:p,maxRanking:m,threshold:h}=l;return d<p&&d>=t.MATCHES?d=p:d>m&&(d=m),d>e&&(e=d,o=u,s=h,f=c),{rankedValue:f,rank:e,keyIndex:o,keyThreshold:s}},{rankedValue:e,rank:t.NO_MATCH,keyIndex:-1,keyThreshold:i.threshold})}function a(e,n,r){return e=l(e,r),n=l(n,r),n.length>e.length?t.NO_MATCH:e===n?t.CASE_SENSITIVE_EQUAL:(e=e.toLowerCase(),n=n.toLowerCase(),e===n?t.EQUAL:e.startsWith(n)?t.STARTS_WITH:e.includes(` ${n}`)?t.WORD_STARTS_WITH:e.includes(n)?t.CONTAINS:n.length===1?t.NO_MATCH:o(e).includes(n)?t.ACRONYM:s(e,n))}function o(e){let t=``,n=e.split(` `);for(let e of n){let n=e.split(`-`);for(let e of n)t+=e.slice(0,1)}return t}function s(e,n){let r=0,i=0;function a(e,t,n){for(let i=n,a=t.length;i<a;i++)if(t[i]===e)return r+=1,i+1;return-1}function o(e){let i=1/e,a=r/n.length;return t.MATCHES+a*i}let s=a(n[0],e,0);if(s<0)return t.NO_MATCH;i=s;for(let r=1,o=n.length;r<o;r++){let o=n[r];if(i=a(o,e,i),!(i>-1))return t.NO_MATCH}return o(i-s)}function c(e,t,n){let{rank:r,keyIndex:i}=e,{rank:a,keyIndex:o}=t;return r===a?i===o?n(e,t):i<o?-1:1:r>a?-1:1}function l(t,{keepDiacritics:n}){return t=`${t}`,n||(t=e.n(t)),t}function u(e,t){typeof t==`object`&&(t=t.key);let n;if(typeof t==`function`)n=t(e);else if(e===null)n=null;else if(Object.hasOwnProperty.call(e,t))n=e[t];else if(t.includes(`.`))return d(t,e);else n=null;return n===null?[]:Array.isArray(n)?n:[String(n)]}function d(e,t){let n=e.split(`.`),r=[t];for(let e=0,t=n.length;e<t;e++){let t=n[e],i=[];for(let e=0,n=r.length;e<n;e++){let n=r[e];if(n!==null)if(t&&Object.hasOwnProperty.call(n,t)){let e=n[t];e!==null&&i.push(e)}else n&&t===`*`&&(i=[...i,n])}r=i}return Array.isArray(r[0])?[].concat(...r):r}function f(e,t){let n=[];for(let r=0,i=t.length;r<i;r++){let i=t[r],a=m(i),o=u(e,i);for(let e=0,t=o.length;e<t;e++)n.push({itemValue:o[e],attributes:a})}return n}const p={maxRanking:1/0,minRanking:-1/0};function m(e){return typeof e==`string`?p:{...p,...e}}Object.defineProperty(exports,`n`,{enumerable:!0,get:function(){return r}}),Object.defineProperty(exports,`r`,{enumerable:!0,get:function(){return t}}),Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return n}});

package/dist/match-sorter-CMYN3GuY.d.cts

@@ -1,78 +0,0 @@
-//#region src/match-sorter.d.ts
-/**
- * Forked from match-sorter by Kent C. Dodds
- */
-interface KeyAttributes {
-  threshold?: Ranking;
-  maxRanking: Ranking;
-  minRanking: Ranking;
-}
-interface RankingInfo {
-  rankedValue: string;
-  rank: Ranking;
-  keyIndex: number;
-  keyThreshold: Ranking | undefined;
-}
-interface ValueGetterKey<ItemType> {
-  (item: ItemType): string | Array<string>;
-}
-interface IndexedItem<ItemType> {
-  item: ItemType;
-  index: number;
-}
-interface RankedItem<ItemType> extends RankingInfo, IndexedItem<ItemType> {}
-interface BaseSorter<ItemType> {
-  (a: RankedItem<ItemType>, b: RankedItem<ItemType>): number;
-}
-interface Sorter<ItemType> {
-  (matchItems: Array<RankedItem<ItemType>>): Array<RankedItem<ItemType>>;
-}
-interface KeyAttributesOptions<ItemType> {
-  key?: string | ValueGetterKey<ItemType>;
-  threshold?: Ranking;
-  maxRanking?: Ranking;
-  minRanking?: Ranking;
-}
-type KeyOption<ItemType> = KeyAttributesOptions<ItemType> | ValueGetterKey<ItemType> | string;
-interface MatchSorterOptions<ItemType = unknown> {
-  keys?: ReadonlyArray<KeyOption<ItemType>>;
-  threshold?: Ranking;
-  baseSort?: BaseSorter<ItemType>;
-  keepDiacritics?: boolean;
-  sorter?: Sorter<ItemType>;
-}
-declare const rankings: {
-  readonly CASE_SENSITIVE_EQUAL: 7;
-  readonly EQUAL: 6;
-  readonly STARTS_WITH: 5;
-  readonly WORD_STARTS_WITH: 4;
-  readonly CONTAINS: 3;
-  readonly ACRONYM: 2;
-  readonly MATCHES: 1;
-  readonly NO_MATCH: 0;
-};
-type Ranking = (typeof rankings)[keyof typeof rankings];
-declare const defaultBaseSortFn: BaseSorter<unknown>;
-/**
- * Takes an array of items and a value and returns a new array with the items that match the given value
- * @param items - the items to sort
- * @param value - the value to use for ranking
- * @param options - Some options to configure the sorter
- * @returns - the new sorted array
- */
-declare function matchSorter<ItemType = string>(items: ReadonlyArray<ItemType>, value: string, options?: MatchSorterOptions<ItemType>): Array<ItemType>;
-declare namespace matchSorter {
-  var rankings: {
-    readonly CASE_SENSITIVE_EQUAL: 7;
-    readonly EQUAL: 6;
-    readonly STARTS_WITH: 5;
-    readonly WORD_STARTS_WITH: 4;
-    readonly CONTAINS: 3;
-    readonly ACRONYM: 2;
-    readonly MATCHES: 1;
-    readonly NO_MATCH: 0;
-  };
-}
-//#endregion
-export { RankingInfo as a, matchSorter as c, MatchSorterOptions as i, rankings as l, KeyAttributesOptions as n, ValueGetterKey as o, KeyOption as r, defaultBaseSortFn as s, KeyAttributes as t };
-//# sourceMappingURL=match-sorter-CMYN3GuY.d.cts.map

package/dist/match-sorter-CMYN3GuY.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"match-sorter-CMYN3GuY.d.cts","names":[],"sources":["../src/match-sorter.ts"],"sourcesContent":[],"mappings":";;;;UAyBU,aAAA,CAEI;EACA,SAAA,CAAA,EAFA,OAEA;EAAO,UAAA,EADP,OACO;EAEX,UAAA,EAFI,OAEO;AAIE;AAIW,UARxB,WAAA,CAUW;EAIX,WAAA,EAAU,MAAA;EAA4C,IAAA,EAZxD,OAYwD;EAAzB,QAAA,EAAA,MAAA;EAAa,YAAA,EAVpC,OAUoC,GAAA,SAAA;;AAAW,UAPrD,cASU,CAAA,QAAA,CAAA,CAAA;EACH,CAAA,IAAA,EATR,QASQ,CAAA,EAAA,MAAA,GATY,KASZ,CAAA,MAAA,CAAA;;UAPP,WAOgC,CAAA,QAAA,CAAA,CAAA;EAAX,IAAA,EANvB,QAMuB;EAAU,KAAA,EAAA,MAAA;AAAA;UAH/B,UAOsB,CAAA,QAAA,CAAA,SAPO,WAOP,EAPoB,WAOpB,CAPgC,QAOhC,CAAA,CAAA;UALtB,UAKK,CAAA,QAAA,CAAA,CAAA;EAA+C,CAAA,CAAA,EAJxD,UAIwD,CAJ7C,QAI6C,CAAA,EAAA,CAAA,EAJ/B,UAI+B,CAJpB,QAIoB,CAAA,CAAA,EAAA,MAAA;;UADpD,MACmC,CAAA,QAAA,CAAA,CAAA;EAAK,CAAA,UAAA,EAAnC,KAAmC,CAA7B,UAA6B,CAAlB,QAAkB,CAAA,CAAA,CAAA,EAAL,KAAK,CAAC,UAAD,CAAY,QAAZ,CAAA,CAAA;AAAA;UAGxC,oBACsB,CAAA,QAAA,CAAA,CAAA;EAAf,GAAA,CAAA,EAAA,MAAA,GAAA,cAAA,CAAe,QAAf,CAAA;EACH,SAAA,CAAA,EAAA,OAAA;EACC,UAAA,CAAA,EAAA,OAAA;EACA,UAAA,CAAA,EAAA,OAAA;;AAAO,KAGjB,SAAA,CAAA,QAAS,CAAA,GACV,oBADU,CACW,QADX,CAAA,GAEV,cAFU,CAEK,QAFL,CAAA,GAAA,MAAA;UAKJ,kBAJe,CAAA,WAAA,OAAA,CAAA,CAAA;EAArB,IAAA,CAAA,EAKK,aALL,CAKmB,SALnB,CAK6B,QAL7B,CAAA,CAAA;EACe,SAAA,CAAA,EAKL,OALK;EAAf,QAAA,CAAA,EAMS,UANT,CAMoB,QANpB,CAAA;EAAc,cAAA,CAAA,EAAA,OAAA;EAGR,MAAA,CAAA,EAKC,MALD,CAKQ,QALU,CAAA;;cAStB,QARiB,EAAA;EAAd,SAAA,oBAAA,EAAA,CAAA;EACK,SAAA,KAAA,EAAA,CAAA;EACU,SAAA,WAAA,EAAA,CAAA;EAAX,SAAA,gBAAA,EAAA,CAAA;EAEK,SAAA,QAAA,EAAA,CAAA;EAAP,SAAA,OAAA,EAAA,CAAA;EAAM,SAAA,OAAA,EAAA,CAAA;EAIX,SAAA,QASI,EAAA,CAAA;AAAA,CAAA;AAE4C,KAAjD,OAAA,GAEC,CAAA,OAFiB,QAGqC,CAAA,CAAA,MADnC,OAFqB,QAEX,CAAA;AAAA,cAA7B,iBAUc,EAVK,UAUL,CAAA,OAAA,CAAA;;;;;;;;AAIZ,iBAJC,WAAW,CAAA,WAAA,MAAA,CAAA,CAAA,KAAA,EACX,aADW,CACG,QADH,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,OAAA,CAAA,EAGT,kBAHS,CAGU,QAHV,CAAA,CAAA,EAIjB,KAJiB,CAIX,QAJW,CAAA;kBAAX,WAAA"}

package/dist/match-sorter-DCRerxVe.d.mts

@@ -1,78 +0,0 @@
-//#region src/match-sorter.d.ts
-/**
- * Forked from match-sorter by Kent C. Dodds
- */
-interface KeyAttributes {
-  threshold?: Ranking;
-  maxRanking: Ranking;
-  minRanking: Ranking;
-}
-interface RankingInfo {
-  rankedValue: string;
-  rank: Ranking;
-  keyIndex: number;
-  keyThreshold: Ranking | undefined;
-}
-interface ValueGetterKey<ItemType> {
-  (item: ItemType): string | Array<string>;
-}
-interface IndexedItem<ItemType> {
-  item: ItemType;
-  index: number;
-}
-interface RankedItem<ItemType> extends RankingInfo, IndexedItem<ItemType> {}
-interface BaseSorter<ItemType> {
-  (a: RankedItem<ItemType>, b: RankedItem<ItemType>): number;
-}
-interface Sorter<ItemType> {
-  (matchItems: Array<RankedItem<ItemType>>): Array<RankedItem<ItemType>>;
-}
-interface KeyAttributesOptions<ItemType> {
-  key?: string | ValueGetterKey<ItemType>;
-  threshold?: Ranking;
-  maxRanking?: Ranking;
-  minRanking?: Ranking;
-}
-type KeyOption<ItemType> = KeyAttributesOptions<ItemType> | ValueGetterKey<ItemType> | string;
-interface MatchSorterOptions<ItemType = unknown> {
-  keys?: ReadonlyArray<KeyOption<ItemType>>;
-  threshold?: Ranking;
-  baseSort?: BaseSorter<ItemType>;
-  keepDiacritics?: boolean;
-  sorter?: Sorter<ItemType>;
-}
-declare const rankings: {
-  readonly CASE_SENSITIVE_EQUAL: 7;
-  readonly EQUAL: 6;
-  readonly STARTS_WITH: 5;
-  readonly WORD_STARTS_WITH: 4;
-  readonly CONTAINS: 3;
-  readonly ACRONYM: 2;
-  readonly MATCHES: 1;
-  readonly NO_MATCH: 0;
-};
-type Ranking = (typeof rankings)[keyof typeof rankings];
-declare const defaultBaseSortFn: BaseSorter<unknown>;
-/**
- * Takes an array of items and a value and returns a new array with the items that match the given value
- * @param items - the items to sort
- * @param value - the value to use for ranking
- * @param options - Some options to configure the sorter
- * @returns - the new sorted array
- */
-declare function matchSorter<ItemType = string>(items: ReadonlyArray<ItemType>, value: string, options?: MatchSorterOptions<ItemType>): Array<ItemType>;
-declare namespace matchSorter {
-  var rankings: {
-    readonly CASE_SENSITIVE_EQUAL: 7;
-    readonly EQUAL: 6;
-    readonly STARTS_WITH: 5;
-    readonly WORD_STARTS_WITH: 4;
-    readonly CONTAINS: 3;
-    readonly ACRONYM: 2;
-    readonly MATCHES: 1;
-    readonly NO_MATCH: 0;
-  };
-}
-//#endregion
-export { RankingInfo as a, matchSorter as c, MatchSorterOptions as i, rankings as l, KeyAttributesOptions as n, ValueGetterKey as o, KeyOption as r, defaultBaseSortFn as s, KeyAttributes as t };
-//# sourceMappingURL=match-sorter-DCRerxVe.d.mts.map

package/dist/match-sorter-DCRerxVe.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"match-sorter-DCRerxVe.d.mts","names":[],"sources":["../src/match-sorter.ts"],"sourcesContent":[],"mappings":";;;;UAyBU,aAAA,CAEI;EACA,SAAA,CAAA,EAFA,OAEA;EAAO,UAAA,EADP,OACO;EAEX,UAAA,EAFI,OAEO;AAIE;AAIW,UARxB,WAAA,CAUW;EAIX,WAAA,EAAU,MAAA;EAA4C,IAAA,EAZxD,OAYwD;EAAzB,QAAA,EAAA,MAAA;EAAa,YAAA,EAVpC,OAUoC,GAAA,SAAA;;AAAW,UAPrD,cASU,CAAA,QAAA,CAAA,CAAA;EACH,CAAA,IAAA,EATR,QASQ,CAAA,EAAA,MAAA,GATY,KASZ,CAAA,MAAA,CAAA;;UAPP,WAOgC,CAAA,QAAA,CAAA,CAAA;EAAX,IAAA,EANvB,QAMuB;EAAU,KAAA,EAAA,MAAA;AAAA;UAH/B,UAOsB,CAAA,QAAA,CAAA,SAPO,WAOP,EAPoB,WAOpB,CAPgC,QAOhC,CAAA,CAAA;UALtB,UAKK,CAAA,QAAA,CAAA,CAAA;EAA+C,CAAA,CAAA,EAJxD,UAIwD,CAJ7C,QAI6C,CAAA,EAAA,CAAA,EAJ/B,UAI+B,CAJpB,QAIoB,CAAA,CAAA,EAAA,MAAA;;UADpD,MACmC,CAAA,QAAA,CAAA,CAAA;EAAK,CAAA,UAAA,EAAnC,KAAmC,CAA7B,UAA6B,CAAlB,QAAkB,CAAA,CAAA,CAAA,EAAL,KAAK,CAAC,UAAD,CAAY,QAAZ,CAAA,CAAA;AAAA;UAGxC,oBACsB,CAAA,QAAA,CAAA,CAAA;EAAf,GAAA,CAAA,EAAA,MAAA,GAAA,cAAA,CAAe,QAAf,CAAA;EACH,SAAA,CAAA,EAAA,OAAA;EACC,UAAA,CAAA,EAAA,OAAA;EACA,UAAA,CAAA,EAAA,OAAA;;AAAO,KAGjB,SAAA,CAAA,QAAS,CAAA,GACV,oBADU,CACW,QADX,CAAA,GAEV,cAFU,CAEK,QAFL,CAAA,GAAA,MAAA;UAKJ,kBAJe,CAAA,WAAA,OAAA,CAAA,CAAA;EAArB,IAAA,CAAA,EAKK,aALL,CAKmB,SALnB,CAK6B,QAL7B,CAAA,CAAA;EACe,SAAA,CAAA,EAKL,OALK;EAAf,QAAA,CAAA,EAMS,UANT,CAMoB,QANpB,CAAA;EAAc,cAAA,CAAA,EAAA,OAAA;EAGR,MAAA,CAAA,EAKC,MALD,CAKQ,QALU,CAAA;;cAStB,QARiB,EAAA;EAAd,SAAA,oBAAA,EAAA,CAAA;EACK,SAAA,KAAA,EAAA,CAAA;EACU,SAAA,WAAA,EAAA,CAAA;EAAX,SAAA,gBAAA,EAAA,CAAA;EAEK,SAAA,QAAA,EAAA,CAAA;EAAP,SAAA,OAAA,EAAA,CAAA;EAAM,SAAA,OAAA,EAAA,CAAA;EAIX,SAAA,QASI,EAAA,CAAA;AAAA,CAAA;AAE4C,KAAjD,OAAA,GAEC,CAAA,OAFiB,QAGqC,CAAA,CAAA,MADnC,OAFqB,QAEX,CAAA;AAAA,cAA7B,iBAUc,EAVK,UAUL,CAAA,OAAA,CAAA;;;;;;;;AAIZ,iBAJC,WAAW,CAAA,WAAA,MAAA,CAAA,CAAA,KAAA,EACX,aADW,CACG,QADH,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,OAAA,CAAA,EAGT,kBAHS,CAGU,QAHV,CAAA,CAAA,EAIjB,KAJiB,CAIX,QAJW,CAAA;kBAAX,WAAA"}

package/dist/memoize-Cr5jFKxi.mjs

@@ -1,2 +0,0 @@
-const e=e=>{let t=Object.prototype.hasOwnProperty,n={};return r=>t.call(n,r)?n[r]:n[r]=e(r)};export{e as t};
-//# sourceMappingURL=memoize-Cr5jFKxi.mjs.map

package/dist/memoize-Cr5jFKxi.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"memoize-Cr5jFKxi.mjs","names":["results: Record<string, T>"],"sources":["../src/memoize.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\n/**\n * Memoizes a function based on its string identifier.\n *\n * @param fn - The function to memoize.\n * @returns A memoized version of the input function.\n */\nexport const memoizeOnId = <T>(fn: (id: string) => T) => {\n  // eslint-disable-next-line ts/unbound-method\n  const hasOwnProperty = Object.prototype.hasOwnProperty;\n  const results: Record<string, T> = {};\n\n  const memoizedFn = (id: string) => {\n    if (hasOwnProperty.call(results, id)) {\n      return results[id];\n    }\n    return (results[id] = fn(id));\n  };\n\n  return memoizedFn;\n};\n"],"mappings":"AAwBA,MAAa,EAAkB,GAA0B,CAEvD,IAAM,EAAiB,OAAO,UAAU,eAClCA,EAA6B,EAAE,CASrC,MAPoB,IACd,EAAe,KAAK,EAAS,EAAG,CAC3B,EAAQ,GAET,EAAQ,GAAM,EAAG,EAAG"}

package/dist/memoize-TyrmWrfR.d.mts

@@ -1,11 +0,0 @@
-//#region src/memoize.d.ts
-/**
- * Memoizes a function based on its string identifier.
- *
- * @param fn - The function to memoize.
- * @returns A memoized version of the input function.
- */
-declare const memoizeOnId: <T>(fn: (id: string) => T) => (id: string) => T | undefined;
-//#endregion
-export { memoizeOnId as t };
-//# sourceMappingURL=memoize-TyrmWrfR.d.mts.map

package/dist/memoize-TyrmWrfR.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memoize-TyrmWrfR.d.mts","names":[],"sources":["../src/memoize.ts"],"sourcesContent":[],"mappings":";;AAwBA;;;;;cAAa,qCAAsC,sBAKnB"}

package/dist/memoize-qxvbI-0y.cjs

@@ -1 +0,0 @@
-const e=e=>{let t=Object.prototype.hasOwnProperty,n={};return r=>t.call(n,r)?n[r]:n[r]=e(r)};Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return e}});

package/dist/memoize-tSTYY522.d.cts

@@ -1,11 +0,0 @@
-//#region src/memoize.d.ts
-/**
- * Memoizes a function based on its string identifier.
- *
- * @param fn - The function to memoize.
- * @returns A memoized version of the input function.
- */
-declare const memoizeOnId: <T>(fn: (id: string) => T) => (id: string) => T | undefined;
-//#endregion
-export { memoizeOnId as t };
-//# sourceMappingURL=memoize-tSTYY522.d.cts.map

package/dist/memoize-tSTYY522.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memoize-tSTYY522.d.cts","names":[],"sources":["../src/memoize.ts"],"sourcesContent":[],"mappings":";;AAwBA;;;;;cAAa,qCAAsC,sBAKnB"}

package/dist/mutex-CnQQBndt.cjs

@@ -1 +0,0 @@
-const e=require(`./semaphore-DkHqPlow.cjs`);var t=class{semaphore=new e.t(1);get isLocked(){return this.semaphore.available===0}async acquire(){return this.semaphore.acquire()}release(){this.semaphore.release()}};Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});

package/dist/mutex-DAZduiSP.d.mts

@@ -1,72 +0,0 @@
-//#region src/mutex.d.ts
-/**
- * A Mutex (mutual exclusion lock) for async functions.
- * It allows only one async task to access a critical section at a time.
- *
- * @example
- * ```typescript
- * const mutex = new Mutex();
- *
- * async function criticalSection() {
- *   await mutex.acquire();
- *   try {
- *     // This code section cannot be executed simultaneously
- *   } finally {
- *     mutex.release();
- *   }
- * }
- *
- * criticalSection();
- * criticalSection(); // This call will wait until the first call releases the mutex.
- * ```
- */
-declare class Mutex {
-  private semaphore;
-  /**
-   * Checks if the mutex is currently locked.
-   * @returns True if the mutex is locked, false otherwise.
-   *
-   * @example
-   * const mutex = new Mutex();
-   * console.log(mutex.isLocked); // false
-   * await mutex.acquire();
-   * console.log(mutex.isLocked); // true
-   * mutex.release();
-   * console.log(mutex.isLocked); // false
-   */
-  get isLocked(): boolean;
-  /**
-   * Acquires the mutex, blocking if necessary until it is available.
-   * @returns A promise that resolves when the mutex is acquired.
-   *
-   * @example
-   * ```typescript
-   * const mutex = new Mutex();
-   * await mutex.acquire();
-   * try {
-   *   // This code section cannot be executed simultaneously
-   * } finally {
-   *   mutex.release();
-   * }
-   * ```
-   */
-  acquire(): Promise<void>;
-  /**
-   * Releases the mutex, allowing another waiting task to proceed.
-   *
-   * @example
-   * ```typescript
-   * const mutex = new Mutex();
-   * await mutex.acquire();
-   * try {
-   *   // This code section cannot be executed simultaneously
-   * } finally {
-   *   mutex.release(); // Allows another waiting task to proceed.
-   * }
-   * ```
-   */
-  release(): void;
-}
-//#endregion
-export { Mutex as t };
-//# sourceMappingURL=mutex-DAZduiSP.d.mts.map

package/dist/mutex-DAZduiSP.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mutex-DAZduiSP.d.mts","names":[],"sources":["../src/mutex.ts"],"sourcesContent":[],"mappings":";;AAyCA;;;;;;;;;;;;;;;;;;;;cAAa,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAkCa"}

package/dist/mutex-DCyX7B66.d.cts

@@ -1,72 +0,0 @@
-//#region src/mutex.d.ts
-/**
- * A Mutex (mutual exclusion lock) for async functions.
- * It allows only one async task to access a critical section at a time.
- *
- * @example
- * ```typescript
- * const mutex = new Mutex();
- *
- * async function criticalSection() {
- *   await mutex.acquire();
- *   try {
- *     // This code section cannot be executed simultaneously
- *   } finally {
- *     mutex.release();
- *   }
- * }
- *
- * criticalSection();
- * criticalSection(); // This call will wait until the first call releases the mutex.
- * ```
- */
-declare class Mutex {
-  private semaphore;
-  /**
-   * Checks if the mutex is currently locked.
-   * @returns True if the mutex is locked, false otherwise.
-   *
-   * @example
-   * const mutex = new Mutex();
-   * console.log(mutex.isLocked); // false
-   * await mutex.acquire();
-   * console.log(mutex.isLocked); // true
-   * mutex.release();
-   * console.log(mutex.isLocked); // false
-   */
-  get isLocked(): boolean;
-  /**
-   * Acquires the mutex, blocking if necessary until it is available.
-   * @returns A promise that resolves when the mutex is acquired.
-   *
-   * @example
-   * ```typescript
-   * const mutex = new Mutex();
-   * await mutex.acquire();
-   * try {
-   *   // This code section cannot be executed simultaneously
-   * } finally {
-   *   mutex.release();
-   * }
-   * ```
-   */
-  acquire(): Promise<void>;
-  /**
-   * Releases the mutex, allowing another waiting task to proceed.
-   *
-   * @example
-   * ```typescript
-   * const mutex = new Mutex();
-   * await mutex.acquire();
-   * try {
-   *   // This code section cannot be executed simultaneously
-   * } finally {
-   *   mutex.release(); // Allows another waiting task to proceed.
-   * }
-   * ```
-   */
-  release(): void;
-}
-//#endregion
-export { Mutex as t };
-//# sourceMappingURL=mutex-DCyX7B66.d.cts.map

package/dist/mutex-DCyX7B66.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mutex-DCyX7B66.d.cts","names":[],"sources":["../src/mutex.ts"],"sourcesContent":[],"mappings":";;AAyCA;;;;;;;;;;;;;;;;;;;;cAAa,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAkCa"}

package/dist/mutex-TqoKHosg.mjs

@@ -1,2 +0,0 @@
-import{t as e}from"./semaphore-4zJqtox8.mjs";var t=class{semaphore=new e(1);get isLocked(){return this.semaphore.available===0}async acquire(){return this.semaphore.acquire()}release(){this.semaphore.release()}};export{t};
-//# sourceMappingURL=mutex-TqoKHosg.mjs.map

package/dist/mutex-TqoKHosg.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"mutex-TqoKHosg.mjs","names":[],"sources":["../src/mutex.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport { Semaphore } from \"./semaphore\";\n\n/**\n * A Mutex (mutual exclusion lock) for async functions.\n * It allows only one async task to access a critical section at a time.\n *\n * @example\n * ```typescript\n * const mutex = new Mutex();\n *\n * async function criticalSection() {\n *   await mutex.acquire();\n *   try {\n *     // This code section cannot be executed simultaneously\n *   } finally {\n *     mutex.release();\n *   }\n * }\n *\n * criticalSection();\n * criticalSection(); // This call will wait until the first call releases the mutex.\n * ```\n */\nexport class Mutex {\n  private semaphore = new Semaphore(1);\n\n  /**\n   * Checks if the mutex is currently locked.\n   * @returns True if the mutex is locked, false otherwise.\n   *\n   * @example\n   * const mutex = new Mutex();\n   * console.log(mutex.isLocked); // false\n   * await mutex.acquire();\n   * console.log(mutex.isLocked); // true\n   * mutex.release();\n   * console.log(mutex.isLocked); // false\n   */\n  public get isLocked(): boolean {\n    return this.semaphore.available === 0;\n  }\n\n  /**\n   * Acquires the mutex, blocking if necessary until it is available.\n   * @returns A promise that resolves when the mutex is acquired.\n   *\n   * @example\n   * ```typescript\n   * const mutex = new Mutex();\n   * await mutex.acquire();\n   * try {\n   *   // This code section cannot be executed simultaneously\n   * } finally {\n   *   mutex.release();\n   * }\n   * ```\n   */\n  public async acquire(): Promise<void> {\n    return this.semaphore.acquire();\n  }\n\n  /**\n   * Releases the mutex, allowing another waiting task to proceed.\n   *\n   * @example\n   * ```typescript\n   * const mutex = new Mutex();\n   * await mutex.acquire();\n   * try {\n   *   // This code section cannot be executed simultaneously\n   * } finally {\n   *   mutex.release(); // Allows another waiting task to proceed.\n   * }\n   * ```\n   */\n  public release(): void {\n    this.semaphore.release();\n  }\n}\n"],"mappings":"6CAyCA,IAAa,EAAb,KAAmB,CACjB,UAAoB,IAAI,EAAU,EAAE,CAcpC,IAAW,UAAoB,CAC7B,OAAO,KAAK,UAAU,YAAc,EAkBtC,MAAa,SAAyB,CACpC,OAAO,KAAK,UAAU,SAAS,CAiBjC,SAAuB,CACrB,KAAK,UAAU,SAAS"}

package/dist/noop-B7OetrhD.mjs

@@ -1,2 +0,0 @@
-const e=e=>{};async function t(e){}export{e as n,t};
-//# sourceMappingURL=noop-B7OetrhD.mjs.map

package/dist/noop-B7OetrhD.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"noop-B7OetrhD.mjs","names":[],"sources":["../src/noop.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 License, and is\n free for commercial and private use. For more information, please visit\n our licensing page.\n\n Website:         https://stormsoftware.com\n Repository:      https://github.com/storm-software/stryke\n Documentation:   https://stormsoftware.com/projects/stryke/docs\n Contact:         https://stormsoftware.com/contact\n License:         https://stormsoftware.com/projects/stryke/license\n\n ------------------------------------------------------------------- */\n\n/**\n * A no op, or no-op, function for no operation\n *\n * @remarks Please see {@link https://dev.to/praneshpsg239/noop-in-javascript-478h | this article} for more information.\n *\n * @param _params - An optional parameter passed to the function. It can be anything (but is not used in any way)\n */\nexport const noop = (_params?: unknown): void => {};\n\n/**\n * An asynchronous no-operation function that does nothing.\n * This can be used as a placeholder or default function.\n *\n * @example\n * asyncNoop(); // Does nothing\n *\n * @returns This function returns a Promise that resolves to undefined.\n */\nexport async function asyncNoop(_params?: unknown): Promise<void> {}\n"],"mappings":"AAwBA,MAAa,EAAQ,GAA4B,GAWjD,eAAsB,EAAU,EAAkC"}

package/dist/noop-BnXKMH6Z.d.mts

@@ -1,22 +0,0 @@
-//#region src/noop.d.ts
-/**
- * A no op, or no-op, function for no operation
- *
- * @remarks Please see {@link https://dev.to/praneshpsg239/noop-in-javascript-478h | this article} for more information.
- *
- * @param _params - An optional parameter passed to the function. It can be anything (but is not used in any way)
- */
-declare const noop: (_params?: unknown) => void;
-/**
- * An asynchronous no-operation function that does nothing.
- * This can be used as a placeholder or default function.
- *
- * @example
- * asyncNoop(); // Does nothing
- *
- * @returns This function returns a Promise that resolves to undefined.
- */
-declare function asyncNoop(_params?: unknown): Promise<void>;
-//#endregion
-export { noop as n, asyncNoop as t };
-//# sourceMappingURL=noop-BnXKMH6Z.d.mts.map

package/dist/noop-BnXKMH6Z.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"noop-BnXKMH6Z.d.mts","names":[],"sources":["../src/noop.ts"],"sourcesContent":[],"mappings":";;AAwBA;AAWA;;;;;cAXa;;;;;;;;;;iBAWS,SAAA,qBAA8B"}