@stryke/helpers 0.9.26 → 0.9.28

package/dist/match-sorter.d.mts

@@ -1,2 +1,78 @@
-import { a as RankingInfo, c as matchSorter, i as MatchSorterOptions, l as rankings, n as KeyAttributesOptions, o as ValueGetterKey, r as KeyOption, s as defaultBaseSortFn, t as KeyAttributes } from "./match-sorter-DCRerxVe.mjs";
-export { KeyAttributes, KeyAttributesOptions, KeyOption, MatchSorterOptions, RankingInfo, ValueGetterKey, defaultBaseSortFn, matchSorter, rankings };
+//#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 { type KeyAttributes, type KeyAttributesOptions, type KeyOption, type MatchSorterOptions, type RankingInfo, type ValueGetterKey, defaultBaseSortFn, matchSorter, rankings };
+//# sourceMappingURL=match-sorter.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"match-sorter.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/match-sorter.mjs

@@ -1 +1,2 @@
-import"./remove-accents-BFmyvTRZ.mjs";import{n as e,r as t,t as n}from"./match-sorter-B9_7YvTo.mjs";export{n as defaultBaseSortFn,e as matchSorter,t as rankings};
+import{removeAccents as e}from"./remove-accents.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{n as defaultBaseSortFn,r as matchSorter,t as rankings};
+//# sourceMappingURL=match-sorter.mjs.map

package/dist/match-sorter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"match-sorter.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/memoize.cjs

@@ -1 +1 @@
-const e=require(`./memoize-qxvbI-0y.cjs`);exports.memoizeOnId=e.t;
+const e=e=>{let t=Object.prototype.hasOwnProperty,n={};return r=>t.call(n,r)?n[r]:n[r]=e(r)};exports.memoizeOnId=e;

package/dist/memoize.d.cts

@@ -1,2 +1,11 @@
-import { t as memoizeOnId } from "./memoize-tSTYY522.cjs";
-export { memoizeOnId };
+//#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 };
+//# sourceMappingURL=memoize.d.cts.map

package/dist/memoize.d.cts.map

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

package/dist/memoize.d.mts

@@ -1,2 +1,11 @@
-import { t as memoizeOnId } from "./memoize-TyrmWrfR.mjs";
-export { memoizeOnId };
+//#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 };
+//# sourceMappingURL=memoize.d.mts.map

package/dist/memoize.d.mts.map

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

package/dist/memoize.mjs

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

package/dist/memoize.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.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/mutex.cjs

@@ -1 +1 @@
-const e=require(`./mutex-CnQQBndt.cjs`);exports.Mutex=e.t;
+const e=require(`./semaphore.cjs`);var t=class{semaphore=new e.Semaphore(1);get isLocked(){return this.semaphore.available===0}async acquire(){return this.semaphore.acquire()}release(){this.semaphore.release()}};exports.Mutex=t;

package/dist/mutex.d.cts

@@ -1,2 +1,72 @@
-import { t as Mutex } from "./mutex-DCyX7B66.cjs";
-export { Mutex };
+//#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 };
+//# sourceMappingURL=mutex.d.cts.map

package/dist/mutex.d.cts.map

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

package/dist/mutex.d.mts

@@ -1,2 +1,72 @@
-import { t as Mutex } from "./mutex-DAZduiSP.mjs";
-export { Mutex };
+//#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 };
+//# sourceMappingURL=mutex.d.mts.map

package/dist/mutex.d.mts.map

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

package/dist/mutex.mjs

@@ -1 +1,2 @@
-import{t as e}from"./mutex-TqoKHosg.mjs";export{e as Mutex};
+import{Semaphore as e}from"./semaphore.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 as Mutex};
+//# sourceMappingURL=mutex.mjs.map

package/dist/mutex.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutex.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":"4CAyCA,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.cjs

@@ -1 +1 @@
-const e=require(`./noop-Dpf7hIui.cjs`);exports.asyncNoop=e.t,exports.noop=e.n;
+const e=e=>{};async function t(e){}exports.asyncNoop=t,exports.noop=e;

package/dist/noop.d.cts

@@ -1,2 +1,22 @@
-import { n as noop, t as asyncNoop } from "./noop-CnJXOCpF.cjs";
-export { asyncNoop, noop };
+//#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 { asyncNoop, noop };
+//# sourceMappingURL=noop.d.cts.map

package/dist/noop.d.cts.map

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

package/dist/noop.d.mts

@@ -1,2 +1,22 @@
-import { n as noop, t as asyncNoop } from "./noop-BnXKMH6Z.mjs";
-export { asyncNoop, noop };
+//#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 { asyncNoop, noop };
+//# sourceMappingURL=noop.d.mts.map

package/dist/noop.d.mts.map

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

package/dist/noop.mjs

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

package/dist/noop.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"noop.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/omit.cjs

@@ -1 +1 @@
-const e=require(`./omit-A0uVyAS4.cjs`);exports.omit=e.t;
+function e(e,t){let n={...e};for(let e=0;e<t.length;e++){let r=t[e];r&&delete n[r]}return n}exports.omit=e;

package/dist/omit.d.cts

@@ -1,2 +1,22 @@
-import { t as omit } from "./omit-D1FKiOYz.cjs";
-export { omit };
+//#region src/omit.d.ts
+/**
+ * Creates a new object with specified keys omitted.
+ *
+ * This function takes an object and an array of keys, and returns a new object that
+ * excludes the properties corresponding to the specified keys.
+ *
+ * @param obj - The object to omit keys from.
+ * @param keys - An array of keys to be omitted from the object.
+ * @returns A new object with the specified keys omitted.
+ *
+ * @example
+ * ```typescript
+ * const obj = { a: 1, b: 2, c: 3 };
+ * const result = omit(obj, ['b', 'c']);
+ * // result will be { a: 1 }
+ * ```
+ */
+declare function omit<T extends Record<string, any>, K extends keyof T>(obj: T, keys: readonly K[]): Omit<T, K>;
+//#endregion
+export { omit };
+//# sourceMappingURL=omit.d.cts.map

package/dist/omit.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omit.d.cts","names":[],"sources":["../src/omit.ts"],"sourcesContent":[],"mappings":";;AAmCA;;;;;;;;;;;;;;;;iBAAgB,eAAe,qCAAqC,QAC7D,kBACU,MACd,KAAK,GAAG"}

package/dist/omit.d.mts

@@ -1,2 +1,22 @@
-import { t as omit } from "./omit-DpqOAtKt.mjs";
-export { omit };
+//#region src/omit.d.ts
+/**
+ * Creates a new object with specified keys omitted.
+ *
+ * This function takes an object and an array of keys, and returns a new object that
+ * excludes the properties corresponding to the specified keys.
+ *
+ * @param obj - The object to omit keys from.
+ * @param keys - An array of keys to be omitted from the object.
+ * @returns A new object with the specified keys omitted.
+ *
+ * @example
+ * ```typescript
+ * const obj = { a: 1, b: 2, c: 3 };
+ * const result = omit(obj, ['b', 'c']);
+ * // result will be { a: 1 }
+ * ```
+ */
+declare function omit<T extends Record<string, any>, K extends keyof T>(obj: T, keys: readonly K[]): Omit<T, K>;
+//#endregion
+export { omit };
+//# sourceMappingURL=omit.d.mts.map

package/dist/omit.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omit.d.mts","names":[],"sources":["../src/omit.ts"],"sourcesContent":[],"mappings":";;AAmCA;;;;;;;;;;;;;;;;iBAAgB,eAAe,qCAAqC,QAC7D,kBACU,MACd,KAAK,GAAG"}

package/dist/omit.mjs

@@ -1 +1,2 @@
-import{t as e}from"./omit-BROsDK0D.mjs";export{e as omit};
+function e(e,t){let n={...e};for(let e=0;e<t.length;e++){let r=t[e];r&&delete n[r]}return n}export{e as omit};
+//# sourceMappingURL=omit.mjs.map

package/dist/omit.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"omit.mjs","names":[],"sources":["../src/omit.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                             ⚡ Storm Software \n\n This code was released as part of a Storm Software project. The project\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/license.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software\n Documentation:            https://stormsoftware.com/docs\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\n/**\n * Creates a new object with specified keys omitted.\n *\n * This function takes an object and an array of keys, and returns a new object that\n * excludes the properties corresponding to the specified keys.\n *\n * @param obj - The object to omit keys from.\n * @param keys - An array of keys to be omitted from the object.\n * @returns A new object with the specified keys omitted.\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: 2, c: 3 };\n * const result = omit(obj, ['b', 'c']);\n * // result will be { a: 1 }\n * ```\n */\nexport function omit<T extends Record<string, any>, K extends keyof T>(\n  obj: T,\n  keys: readonly K[]\n): Omit<T, K> {\n  const result = { ...obj };\n\n  for (let i = 0; i < keys.length; i++) {\n    const key = keys[i];\n    if (key) {\n      delete result[key];\n    }\n  }\n\n  return result as Omit<T, K>;\n}\n"],"mappings":"AAmCA,SAAgB,EACd,EACA,EACY,CACZ,IAAM,EAAS,CAAE,GAAG,EAAK,CAEzB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAK,OAAQ,IAAK,CACpC,IAAM,EAAM,EAAK,GACb,GACF,OAAO,EAAO,GAIlB,OAAO"}

package/dist/once.cjs

@@ -1 +1 @@
-const e=require(`./once-DZCwmdkv.cjs`);exports.once=e.t,exports.safeFunctionCast=e.n;
+function e(e){return e}function t(t){let n,r=!1;return e(function(...e){return r||=(n=t.apply(this,e),!0),n})}exports.once=t,exports.safeFunctionCast=e;

package/dist/once.d.cts

@@ -1,2 +1,13 @@
-import { n as safeFunctionCast, t as once } from "./once-DqmxXwEB.cjs";
-export { once, safeFunctionCast };
+//#region src/once.d.ts
+/** silence "error TS2322" but practically this is safer and more convenient than resorting to `any` in a random place */
+declare function safeFunctionCast<TFunc extends (...args: any[]) => any>(fn: (...args: Parameters<TFunc>) => ReturnType<TFunc>): TFunc;
+/**
+ * Executes a function only once.
+ *
+ * @param fn - The function to be executed only once.
+ * @returns A function that, when called, will execute the original function only once.
+ */
+declare function once<TFunc extends (...args: any[]) => any>(fn: TFunc): TFunc;
+//#endregion
+export { once, safeFunctionCast };
+//# sourceMappingURL=once.d.cts.map

package/dist/once.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"once.d.cts","names":[],"sources":["../src/once.ts"],"sourcesContent":[],"mappings":";;AAmBgB,iBAAA,gBAAgB,CAAA,cAAA,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GAAA,GAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,IAAA,EAChB,UADgB,CACL,KADK,CAAA,EAAA,GACM,UADN,CACiB,KADjB,CAAA,CAAA,EAE7B,KAF6B;;;;;;;AAehB,iBAAA,IAAgD,CAAA,cAAa,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GAAA,GAAA,CAAA,CAAA,EAAA,EAAb,KAAa,CAAA,EAAL,KAAK"}

package/dist/once.d.mts

@@ -1,2 +1,13 @@
-import { n as safeFunctionCast, t as once } from "./once-DNPPQd3P.mjs";
-export { once, safeFunctionCast };
+//#region src/once.d.ts
+/** silence "error TS2322" but practically this is safer and more convenient than resorting to `any` in a random place */
+declare function safeFunctionCast<TFunc extends (...args: any[]) => any>(fn: (...args: Parameters<TFunc>) => ReturnType<TFunc>): TFunc;
+/**
+ * Executes a function only once.
+ *
+ * @param fn - The function to be executed only once.
+ * @returns A function that, when called, will execute the original function only once.
+ */
+declare function once<TFunc extends (...args: any[]) => any>(fn: TFunc): TFunc;
+//#endregion
+export { once, safeFunctionCast };
+//# sourceMappingURL=once.d.mts.map

package/dist/once.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"once.d.mts","names":[],"sources":["../src/once.ts"],"sourcesContent":[],"mappings":";;AAmBgB,iBAAA,gBAAgB,CAAA,cAAA,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GAAA,GAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,IAAA,EAChB,UADgB,CACL,KADK,CAAA,EAAA,GACM,UADN,CACiB,KADjB,CAAA,CAAA,EAE7B,KAF6B;;;;;;;AAehB,iBAAA,IAAgD,CAAA,cAAa,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GAAA,GAAA,CAAA,CAAA,EAAA,EAAb,KAAa,CAAA,EAAL,KAAK"}

package/dist/once.mjs

@@ -1 +1,2 @@
-import{n as e,t}from"./once-txoW63yJ.mjs";export{t as once,e as safeFunctionCast};
+function e(e){return e}function t(t){let n,r=!1;return e(function(...e){return r||=(n=t.apply(this,e),!0),n})}export{t as once,e as safeFunctionCast};
+//# sourceMappingURL=once.mjs.map

package/dist/once.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"once.mjs","names":["result: ReturnType<TFunc>"],"sources":["../src/once.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/** silence \"error TS2322\" but practically this is safer and more convenient than resorting to `any` in a random place */\nexport function safeFunctionCast<TFunc extends (...args: any[]) => any>(\n  fn: (...args: Parameters<TFunc>) => ReturnType<TFunc>\n): TFunc {\n  // @ts-expect-error\n  //   error TS2322: Type '(...args: Parameters<F>) => ReturnType<F>' is not assignable to type 'F'.\n  //   '(...args: Parameters<F>) => ReturnType<F>' is assignable to the constraint of type 'F', but 'F' could be instantiated with a different subtype of constraint '(...args: any[]) => any'.\n  return fn;\n}\n\n/**\n * Executes a function only once.\n *\n * @param fn - The function to be executed only once.\n * @returns A function that, when called, will execute the original function only once.\n */\nexport function once<TFunc extends (...args: any[]) => any>(fn: TFunc): TFunc {\n  let result: ReturnType<TFunc>;\n  let called = false;\n\n  // eslint-disable-next-line func-names\n  return safeFunctionCast<TFunc>(function (this: unknown, ...args) {\n    if (!called) {\n      result = fn.apply(this, args);\n      called = true;\n    }\n    return result;\n  });\n}\n"],"mappings":"AAmBA,SAAgB,EACd,EACO,CAIP,OAAO,EAST,SAAgB,EAA4C,EAAkB,CAC5E,IAAIA,EACA,EAAS,GAGb,OAAO,EAAwB,SAAyB,GAAG,EAAM,CAK/D,MAJA,CAEE,KADA,EAAS,EAAG,MAAM,KAAM,EAAK,CACpB,IAEJ,GACP"}

package/dist/pick.cjs

@@ -1 +1 @@
-const e=require(`./pick-GDOwAh6I.cjs`);exports.pick=e.t;
+function e(e,t){let n={};for(let r=0;r<t.length;r++){let i=t[r];i&&Object.hasOwn(e,i)&&(n[i]=e[i])}return n}exports.pick=e;

package/dist/pick.d.cts

@@ -1,2 +1,22 @@
-import { t as pick } from "./pick-DXREvZBr.cjs";
-export { pick };
+//#region src/pick.d.ts
+/**
+ * Creates a new object composed of the picked object properties.
+ *
+ * This function takes an object and an array of keys, and returns a new object that
+ * includes only the properties corresponding to the specified keys.
+ *
+ * @param obj - The object to pick keys from.
+ * @param keys - An array of keys to be picked from the object.
+ * @returns A new object with the specified keys picked.
+ *
+ * @example
+ * ```typescript
+ * const obj = { a: 1, b: 2, c: 3 };
+ * const result = pick(obj, ['a', 'c']);
+ * // result will be { a: 1, c: 3 }
+ * ```
+ */
+declare function pick<T extends Record<string, any>, K extends keyof T>(obj: T, keys: readonly K[]): Pick<T, K>;
+//#endregion
+export { pick };
+//# sourceMappingURL=pick.d.cts.map

package/dist/pick.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick.d.cts","names":[],"sources":["../src/pick.ts"],"sourcesContent":[],"mappings":";;AAmCA;;;;;;;;;;;;;;;;iBAAgB,eAAe,qCAAqC,QAC7D,kBACU,MACd,KAAK,GAAG"}