@ls-stack/utils 1.13.2 → 2.0.0

package/dist/enhancedMap.cjs

@@ -0,0 +1,128 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/enhancedMap.ts
+var enhancedMap_exports = {};
+__export(enhancedMap_exports, {
+  EnhancedMap: () => EnhancedMap,
+  enhancedMapReject: () => enhancedMapReject
+});
+module.exports = __toCommonJS(enhancedMap_exports);
+
+// src/assertions.ts
+function isFunction(value) {
+  return typeof value === "function";
+}
+
+// src/enhancedMap.ts
+var enhancedMapReject = Symbol();
+var EnhancedMap = class _EnhancedMap extends Map {
+  find(predicate) {
+    for (const [key, value] of this) {
+      if (predicate(value, key)) {
+        return { key, value };
+      }
+    }
+    return void 0;
+  }
+  setMultiple(...values) {
+    if (Array.isArray(values[0])) {
+      for (const [key, value] of values) {
+        this.set(key, value);
+      }
+    } else {
+      for (const [key, value] of Object.entries(values[0])) {
+        this.set(key, value);
+      }
+    }
+    return this;
+  }
+  getOrThrow(key) {
+    const value = this.get(key);
+    if (value === void 0) {
+      throw new Error(`Key ${key} not found in EnhancedMap`);
+    }
+    return value;
+  }
+  getOrInsert(key, fallback) {
+    if (!this.has(key)) {
+      this.set(key, fallback());
+    }
+    return this.getOrThrow(key);
+  }
+  toFilteredValues(predicate) {
+    const values = [];
+    for (const [key, value] of this) {
+      if (predicate(value, key)) {
+        values.push(value);
+      }
+    }
+    return values;
+  }
+  toMap(mapFunction) {
+    const values = [];
+    for (const [key, value] of this) {
+      const result = mapFunction(value, key, enhancedMapReject);
+      if (result !== enhancedMapReject) {
+        values.push(result);
+      }
+    }
+    return values;
+  }
+  toObjMap(mapFunction) {
+    const values = {};
+    for (const [key, value] of this) {
+      const result = mapFunction(value, key);
+      if (result) {
+        values[result[0]] = result[1];
+      }
+    }
+    return values;
+  }
+  toValues() {
+    return [...this.values()];
+  }
+  toKeys() {
+    return [...this.keys()];
+  }
+  static from(array, mapFunction) {
+    const map = new _EnhancedMap();
+    if (!array) return map;
+    const isFn = isFunction(mapFunction);
+    for (const item of array) {
+      if (isFn) {
+        const result = mapFunction(item);
+        if (result) {
+          map.set(result[0], result[1]);
+        }
+      } else {
+        const key = item[mapFunction];
+        if (key !== void 0) {
+          map.set(key, item);
+        }
+      }
+    }
+    return map;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EnhancedMap,
+  enhancedMapReject
+});

package/dist/enhancedMap.d.cts

@@ -0,0 +1,20 @@
+declare const enhancedMapReject: unique symbol;
+declare class EnhancedMap<K, V> extends Map<K, V> {
+    find(predicate: (value: V, key: K) => boolean): {
+        key: K;
+        value: V;
+    } | undefined;
+    setMultiple(values: Record<K & string, V>): this;
+    setMultiple(...values: [key: K, value: V][]): this;
+    getOrThrow(key: K): V;
+    getOrInsert(key: K, fallback: () => V): V;
+    toFilteredValues(predicate: (value: V, key: K) => boolean): V[];
+    toMap<T>(mapFunction: (value: V, key: K, reject: typeof enhancedMapReject) => T | typeof enhancedMapReject): T[];
+    toObjMap<ObjKey extends PropertyKey, ObjValue>(mapFunction: (value: V, key: K) => [key: ObjKey, value: ObjValue] | false): Record<ObjKey, ObjValue>;
+    toValues(): V[];
+    toKeys(): K[];
+    static from<T extends Record<string, unknown>, K extends keyof T>(array: T[] | Iterable<T> | null | undefined, key: K): EnhancedMap<T[K], T>;
+    static from<T, K, V>(array: T[] | Iterable<T> | null | undefined, mapFunction: (item: T) => [key: K, value: V] | false): EnhancedMap<K, V>;
+}
+
+export { EnhancedMap, enhancedMapReject };

package/dist/enhancedMap.d.ts

@@ -13,8 +13,6 @@ declare class EnhancedMap<K, V> extends Map<K, V> {
     toObjMap<ObjKey extends PropertyKey, ObjValue>(mapFunction: (value: V, key: K) => [key: ObjKey, value: ObjValue] | false): Record<ObjKey, ObjValue>;
     toValues(): V[];
     toKeys(): K[];
-    /** @deprecated, will be removed in v5 use `from` method instead */
-    static fromIterMap<T, K, V>(array: T[] | Iterable<T>, mapFunction: (item: T) => [key: K, value: V] | false): EnhancedMap<K, V>;
     static from<T extends Record<string, unknown>, K extends keyof T>(array: T[] | Iterable<T> | null | undefined, key: K): EnhancedMap<T[K], T>;
     static from<T, K, V>(array: T[] | Iterable<T> | null | undefined, mapFunction: (item: T) => [key: K, value: V] | false): EnhancedMap<K, V>;
 }

package/dist/enhancedMap.js

@@ -1,10 +1,9 @@
 import {
   EnhancedMap,
   enhancedMapReject
-} from "./chunk-4QK76IRX.js";
-import "./chunk-FYMTZQ42.js";
+} from "./chunk-T5WDDPFI.js";
+import "./chunk-4UGSP3L3.js";
 export {
   EnhancedMap,
   enhancedMapReject
 };
-//# sourceMappingURL=enhancedMap.js.map

package/dist/exhaustiveMatch.cjs

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/exhaustiveMatch.ts
+var exhaustiveMatch_exports = {};
+__export(exhaustiveMatch_exports, {
+  exhaustiveMatch: () => exhaustiveMatch
+});
+module.exports = __toCommonJS(exhaustiveMatch_exports);
+function exhaustiveMatch(value) {
+  function matchWith(pattern) {
+    const result = pattern[value];
+    if (typeof result === "function") {
+      return result();
+    }
+    if (result === "_nxt") {
+      const keys = Object.keys(pattern);
+      const nextIndex = keys.indexOf(value) + 1;
+      for (let i = nextIndex; i < keys.length; i++) {
+        const nextMatch = pattern[keys[i]];
+        if (typeof nextMatch === "function") {
+          return nextMatch();
+        }
+      }
+    }
+    throw new Error(`Exhaustive match failed: no match for ${value}`);
+  }
+  function withObject(pattern) {
+    return pattern[value];
+  }
+  return {
+    with: matchWith,
+    withObject
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exhaustiveMatch
+});

package/dist/exhaustiveMatch.d.cts

@@ -0,0 +1,6 @@
+declare function exhaustiveMatch<T extends string>(value: T): {
+    with: <R>(pattern: { [K in T]: "_nxt" | "_never" | (() => R); }) => R;
+    withObject: <R>(pattern: Record<T, R>) => R;
+};
+
+export { exhaustiveMatch };

package/dist/exhaustiveMatch.js

@@ -28,4 +28,3 @@ function exhaustiveMatch(value) {
 export {
   exhaustiveMatch
 };
-//# sourceMappingURL=exhaustiveMatch.js.map

package/dist/interpolate.cjs

@@ -0,0 +1,88 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
+
+// src/interpolate.ts
+var interpolate_exports = {};
+__export(interpolate_exports, {
+  cyclicLerp: () => cyclicLerp,
+  interpolate: () => interpolate
+});
+module.exports = __toCommonJS(interpolate_exports);
+
+// src/assertions.ts
+function invariant(condition, errorMsg = "Invariant violation") {
+  if (!condition) {
+    throw new Error(`Invariant violation: ${errorMsg}`);
+  }
+}
+
+// src/mathUtils.ts
+function clampMax(value, max) {
+  return value > max ? max : value;
+}
+function clampMin(value, min) {
+  return value < min ? min : value;
+}
+function clampRange(num, v1, v2) {
+  if (v2 > v1) {
+    return clamp(num, v1, v2);
+  }
+  return clamp(num, v2, v1);
+}
+function clamp(num, min, max) {
+  return num > max ? max : num < min ? min : num;
+}
+
+// src/interpolate.ts
+function mod(n, m) {
+  return (n % m + m) % m;
+}
+function cyclicLerp(input, [inStart, inEnd], [outStart, outEnd]) {
+  return mod((input - inStart) / (inEnd - inStart), 1) * (outEnd - outStart) + outStart;
+}
+function findRange(input, inputRange) {
+  for (let i = 1; i < inputRange.length - 1; i++) {
+    if (inputRange[i] >= input) return i - 1;
+  }
+  return inputRange.length - 2;
+}
+function interpolate({
+  input,
+  in: inputRange,
+  out,
+  clamp: clamp2 = true
+}) {
+  invariant(
+    inputRange.length === out.length,
+    "Ranges must have the same length"
+  );
+  const range = findRange(input, inputRange);
+  const inStart = inputRange[range];
+  const inEnd = inputRange[range + 1];
+  const outStart = out[range];
+  const outEnd = out[range + 1];
+  const interpolatedValue = (input - inStart) / (inEnd - inStart) * (outEnd - outStart) + outStart;
+  const outputIsAscending = outStart < outEnd;
+  return clamp2 === "start" ? outputIsAscending ? clampMin(interpolatedValue, outStart) : clampMax(interpolatedValue, outStart) : clamp2 === "end" ? outputIsAscending ? clampMax(interpolatedValue, outEnd) : clampMin(interpolatedValue, outEnd) : clamp2 ? clampRange(interpolatedValue, outStart, outEnd) : interpolatedValue;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cyclicLerp,
+  interpolate
+});

package/dist/interpolate.d.cts

@@ -0,0 +1,11 @@
+type Interval = [number, number];
+declare function cyclicLerp(input: number, [inStart, inEnd]: Interval, [outStart, outEnd]: Interval): number;
+type InterpolateArgs = {
+    input: number;
+    in: number[];
+    out: number[];
+    clamp?: boolean | 'start' | 'end';
+};
+declare function interpolate({ input, in: inputRange, out, clamp, }: InterpolateArgs): number;
+
+export { cyclicLerp, interpolate };

package/dist/interpolate.js

@@ -2,10 +2,10 @@ import {
   clampMax,
   clampMin,
   clampRange
-} from "./chunk-NKCC3375.js";
+} from "./chunk-NWXBMMHO.js";
 import {
   invariant
-} from "./chunk-FYMTZQ42.js";
+} from "./chunk-4UGSP3L3.js";
 
 // src/interpolate.ts
 function mod(n, m) {
@@ -43,4 +43,3 @@ export {
   cyclicLerp,
   interpolate
 };
-//# sourceMappingURL=interpolate.js.map

package/dist/levenshtein.cjs

@@ -0,0 +1,180 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/levenshtein.ts
+var levenshtein_exports = {};
+__export(levenshtein_exports, {
+  getClosestString: () => getClosestString,
+  getClosestStringsUpToDist: () => getClosestStringsUpToDist,
+  levenshteinDistance: () => levenshteinDistance
+});
+module.exports = __toCommonJS(levenshtein_exports);
+var peq = new Uint32Array(65536);
+var myers_32 = (a, b) => {
+  const n = a.length;
+  const m = b.length;
+  const lst = 1 << n - 1;
+  let pv = -1;
+  let mv = 0;
+  let sc = n;
+  let i = n;
+  while (i--) {
+    peq[a.charCodeAt(i)] |= 1 << i;
+  }
+  for (i = 0; i < m; i++) {
+    let eq = peq[b.charCodeAt(i)];
+    const xv = eq | mv;
+    eq |= (eq & pv) + pv ^ pv;
+    mv |= ~(eq | pv);
+    pv &= eq;
+    if (mv & lst) {
+      sc++;
+    }
+    if (pv & lst) {
+      sc--;
+    }
+    mv = mv << 1 | 1;
+    pv = pv << 1 | ~(xv | mv);
+    mv &= xv;
+  }
+  i = n;
+  while (i--) {
+    peq[a.charCodeAt(i)] = 0;
+  }
+  return sc;
+};
+var myers_x = (b, a) => {
+  const n = a.length;
+  const m = b.length;
+  const mhc = [];
+  const phc = [];
+  const hsize = Math.ceil(n / 32);
+  const vsize = Math.ceil(m / 32);
+  for (let i = 0; i < hsize; i++) {
+    phc[i] = -1;
+    mhc[i] = 0;
+  }
+  let j = 0;
+  for (; j < vsize - 1; j++) {
+    let mv2 = 0;
+    let pv2 = -1;
+    const start2 = j * 32;
+    const vlen2 = Math.min(32, m) + start2;
+    for (let k = start2; k < vlen2; k++) {
+      peq[b.charCodeAt(k)] |= 1 << k;
+    }
+    for (let i = 0; i < n; i++) {
+      const eq = peq[a.charCodeAt(i)];
+      const pb = phc[i / 32 | 0] >>> i & 1;
+      const mb = mhc[i / 32 | 0] >>> i & 1;
+      const xv = eq | mv2;
+      const xh = ((eq | mb) & pv2) + pv2 ^ pv2 | eq | mb;
+      let ph = mv2 | ~(xh | pv2);
+      let mh = pv2 & xh;
+      if (ph >>> 31 ^ pb) {
+        phc[i / 32 | 0] ^= 1 << i;
+      }
+      if (mh >>> 31 ^ mb) {
+        mhc[i / 32 | 0] ^= 1 << i;
+      }
+      ph = ph << 1 | pb;
+      mh = mh << 1 | mb;
+      pv2 = mh | ~(xv | ph);
+      mv2 = ph & xv;
+    }
+    for (let k = start2; k < vlen2; k++) {
+      peq[b.charCodeAt(k)] = 0;
+    }
+  }
+  let mv = 0;
+  let pv = -1;
+  const start = j * 32;
+  const vlen = Math.min(32, m - start) + start;
+  for (let k = start; k < vlen; k++) {
+    peq[b.charCodeAt(k)] |= 1 << k;
+  }
+  let score = m;
+  for (let i = 0; i < n; i++) {
+    const eq = peq[a.charCodeAt(i)];
+    const pb = phc[i / 32 | 0] >>> i & 1;
+    const mb = mhc[i / 32 | 0] >>> i & 1;
+    const xv = eq | mv;
+    const xh = ((eq | mb) & pv) + pv ^ pv | eq | mb;
+    let ph = mv | ~(xh | pv);
+    let mh = pv & xh;
+    score += ph >>> m - 1 & 1;
+    score -= mh >>> m - 1 & 1;
+    if (ph >>> 31 ^ pb) {
+      phc[i / 32 | 0] ^= 1 << i;
+    }
+    if (mh >>> 31 ^ mb) {
+      mhc[i / 32 | 0] ^= 1 << i;
+    }
+    ph = ph << 1 | pb;
+    mh = mh << 1 | mb;
+    pv = mh | ~(xv | ph);
+    mv = ph & xv;
+  }
+  for (let k = start; k < vlen; k++) {
+    peq[b.charCodeAt(k)] = 0;
+  }
+  return score;
+};
+function levenshteinDistance(a, b) {
+  if (a.length < b.length) {
+    const tmp = b;
+    b = a;
+    a = tmp;
+  }
+  if (b.length === 0) {
+    return a.length;
+  }
+  if (a.length <= 32) {
+    return myers_32(a, b);
+  }
+  return myers_x(a, b);
+}
+function getClosestString(str, arr, maxDistance = 2) {
+  let min_distance = Infinity;
+  let closestString;
+  for (let i = 0; i < arr.length; i++) {
+    const dist = levenshteinDistance(str, arr[i]);
+    if (dist < min_distance && dist <= maxDistance) {
+      min_distance = dist;
+      closestString = arr[i];
+    }
+  }
+  return closestString;
+}
+function getClosestStringsUpToDist(str, arr, maxDistance = 2) {
+  const distanceMap = /* @__PURE__ */ new Map();
+  for (const item of arr) {
+    const distance = levenshteinDistance(str, item);
+    if (distance <= maxDistance) {
+      distanceMap.set(item, distance);
+    }
+  }
+  return Array.from(distanceMap.entries()).sort((a, b) => a[1] - b[1]).map(([item]) => item);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getClosestString,
+  getClosestStringsUpToDist,
+  levenshteinDistance
+});

package/dist/levenshtein.d.cts

@@ -0,0 +1,5 @@
+declare function levenshteinDistance(a: string, b: string): number;
+declare function getClosestString(str: string, arr: readonly string[], maxDistance?: number): string | undefined;
+declare function getClosestStringsUpToDist(str: string, arr: readonly string[], maxDistance?: number): string[];
+
+export { getClosestString, getClosestStringsUpToDist, levenshteinDistance };

package/dist/levenshtein.js

@@ -151,4 +151,3 @@ export {
   getClosestStringsUpToDist,
   levenshteinDistance
 };
-//# sourceMappingURL=levenshtein.js.map

package/dist/main.cjs

@@ -0,0 +1,4 @@
+"use strict";
+
+// src/main.ts
+throw new Error("do not use this file");

package/dist/main.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/main.d.ts

@@ -14,7 +14,7 @@
 ///<reference path="main.d.ts" />
 ///<reference path="mathUtils.d.ts" />
 ///<reference path="objUtils.d.ts" />
-///<reference path="parallelAsyncResultCalls.d.ts" />
+///<reference path="parallelAsyncCalls.d.ts" />
 ///<reference path="promiseUtils.d.ts" />
 ///<reference path="rsResult.d.ts" />
 ///<reference path="runShellCmd.d.ts" />

package/dist/main.js

@@ -1,3 +1,2 @@
 // src/main.ts
 throw new Error("do not use this file");
-//# sourceMappingURL=main.js.map

package/dist/mathUtils.cjs

@@ -0,0 +1,50 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/mathUtils.ts
+var mathUtils_exports = {};
+__export(mathUtils_exports, {
+  clamp: () => clamp,
+  clampMax: () => clampMax,
+  clampMin: () => clampMin,
+  clampRange: () => clampRange
+});
+module.exports = __toCommonJS(mathUtils_exports);
+function clampMax(value, max) {
+  return value > max ? max : value;
+}
+function clampMin(value, min) {
+  return value < min ? min : value;
+}
+function clampRange(num, v1, v2) {
+  if (v2 > v1) {
+    return clamp(num, v1, v2);
+  }
+  return clamp(num, v2, v1);
+}
+function clamp(num, min, max) {
+  return num > max ? max : num < min ? min : num;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clamp,
+  clampMax,
+  clampMin,
+  clampRange
+});

package/dist/mathUtils.d.cts

@@ -0,0 +1,6 @@
+declare function clampMax(value: number, max: number): number;
+declare function clampMin(value: number, min: number): number;
+declare function clampRange(num: number, v1: number, v2: number): number;
+declare function clamp(num: number, min: number, max: number): number;
+
+export { clamp, clampMax, clampMin, clampRange };

package/dist/mathUtils.js

@@ -3,11 +3,10 @@ import {
   clampMax,
   clampMin,
   clampRange
-} from "./chunk-NKCC3375.js";
+} from "./chunk-NWXBMMHO.js";
 export {
   clamp,
   clampMax,
   clampMin,
   clampRange
 };
-//# sourceMappingURL=mathUtils.js.map