@ls-stack/utils 1.0.0

package/dist/chunk-J66LUDLH.js

@@ -0,0 +1,13 @@
+// src/mathUtils.ts
+function clampMax(value, max) {
+  return value > max ? max : value;
+}
+function clampMin(value, min) {
+  return value < min ? min : value;
+}
+
+export {
+  clampMax,
+  clampMin
+};
+//# sourceMappingURL=chunk-J66LUDLH.js.map

package/dist/chunk-J66LUDLH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/mathUtils.ts"],"sourcesContent":["export function clampMax(value: number, max: number) {\n  return value > max ? max : value;\n}\n\nexport function clampMin(value: number, min: number) {\n  return value < min ? min : value;\n}\n"],"mappings":";AAAO,SAAS,SAAS,OAAe,KAAa;AACnD,SAAO,QAAQ,MAAM,MAAM;AAC7B;AAEO,SAAS,SAAS,OAAe,KAAa;AACnD,SAAO,QAAQ,MAAM,MAAM;AAC7B;","names":[]}

package/dist/chunk-JT3EBBCA.js

@@ -0,0 +1,69 @@
+// src/assertions.ts
+var undefErrMsg = "not undefined assertion failed";
+var nullishErrMsg = "not nullish assertion failed";
+function notUndefined(value) {
+  if (value === void 0) {
+    throw new Error(undefErrMsg);
+  }
+  return value;
+}
+function notNullish(value) {
+  if (value === void 0 || value === null) {
+    throw new Error(nullishErrMsg);
+  }
+  return value;
+}
+function assertIsNotNullish(value, errorMsg = nullishErrMsg) {
+  if (value === void 0 || value === null) {
+    throw new Error(errorMsg);
+  }
+}
+function assertIsNotUndefined(value, errorMsg = undefErrMsg) {
+  if (value === void 0) {
+    throw new Error(errorMsg);
+  }
+}
+function invariant(condition, errorMsg = "Invariant violation") {
+  if (!condition) {
+    throw new Error(`Invariant violation: ${errorMsg}`);
+  }
+}
+function exhaustiveCheck(narrowedType) {
+  return new Error("This should never happen");
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isPromise(value) {
+  return isObject(value) && "then" in value;
+}
+function isPlainObject(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto === null) {
+    return true;
+  }
+  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  if (Ctor === Object)
+    return true;
+  const objectCtorString = Object.prototype.constructor.toString();
+  return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
+}
+
+export {
+  notUndefined,
+  notNullish,
+  assertIsNotNullish,
+  assertIsNotUndefined,
+  invariant,
+  exhaustiveCheck,
+  isObject,
+  isFunction,
+  isPromise,
+  isPlainObject
+};
+//# sourceMappingURL=chunk-JT3EBBCA.js.map

package/dist/chunk-JT3EBBCA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/assertions.ts"],"sourcesContent":["const undefErrMsg = 'not undefined assertion failed';\nconst nullishErrMsg = 'not nullish assertion failed';\n\ntype NotUndefined<T> = T extends undefined ? never : T;\n\ntype StrictNonUndefined<T, N = unknown> =\n  undefined extends T ? NotUndefined<T> : N;\n\nexport function notUndefined<T>(value: T): StrictNonUndefined<T> {\n  if (value === undefined) {\n    throw new Error(undefErrMsg);\n  }\n\n  return value as any;\n}\n\ntype StrictNonNullable<T, N = unknown> =\n  undefined extends T ? NonNullable<T>\n  : null extends T ? NonNullable<T>\n  : N;\n\nexport function notNullish<T>(value: T): StrictNonNullable<T> {\n  if (value === undefined || value === null) {\n    throw new Error(nullishErrMsg);\n  }\n\n  return value as any;\n}\n\nexport function assertIsNotNullish<T>(\n  value: T,\n  errorMsg = nullishErrMsg,\n): asserts value is StrictNonNullable<T, never> {\n  if (value === undefined || value === null) {\n    throw new Error(errorMsg);\n  }\n}\n\nexport function assertIsNotUndefined<T>(\n  value: T,\n  errorMsg = undefErrMsg,\n): asserts value is StrictNonUndefined<T, never> {\n  if (value === undefined) {\n    throw new Error(errorMsg);\n  }\n}\n\n/** Use this function to assert that a certain condition is always true. */\nexport function invariant(\n  condition: any,\n  errorMsg = 'Invariant violation',\n): asserts condition {\n  if (!condition) {\n    throw new Error(`Invariant violation: ${errorMsg}`);\n  }\n}\n\n/** ensures all type possibilities are being handled */\nexport function exhaustiveCheck<Except = never>(\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars -- we use this function only for type checking\n  narrowedType: NoInfer<Except>,\n): Error {\n  return new Error('This should never happen');\n}\n\nexport function isObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nexport function isFunction(value: unknown): value is (...args: any[]) => any {\n  return typeof value === 'function';\n}\n\nexport function isPromise(value: unknown): value is Promise<unknown> {\n  return isObject(value) && 'then' in value;\n}\n\nexport function isPlainObject(value: any): value is Record<string, unknown> {\n  if (!value || typeof value !== 'object') return false;\n  const proto = Object.getPrototypeOf(value);\n  if (proto === null) {\n    return true;\n  }\n  const Ctor =\n    Object.hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n\n  if (Ctor === Object) return true;\n\n  const objectCtorString = Object.prototype.constructor.toString();\n\n  return (\n    typeof Ctor == 'function' &&\n    Function.toString.call(Ctor) === objectCtorString\n  );\n}\n"],"mappings":";AAAA,IAAM,cAAc;AACpB,IAAM,gBAAgB;AAOf,SAAS,aAAgB,OAAiC;AAC/D,MAAI,UAAU,QAAW;AACvB,UAAM,IAAI,MAAM,WAAW;AAAA,EAC7B;AAEA,SAAO;AACT;AAOO,SAAS,WAAc,OAAgC;AAC5D,MAAI,UAAU,UAAa,UAAU,MAAM;AACzC,UAAM,IAAI,MAAM,aAAa;AAAA,EAC/B;AAEA,SAAO;AACT;AAEO,SAAS,mBACd,OACA,WAAW,eACmC;AAC9C,MAAI,UAAU,UAAa,UAAU,MAAM;AACzC,UAAM,IAAI,MAAM,QAAQ;AAAA,EAC1B;AACF;AAEO,SAAS,qBACd,OACA,WAAW,aACoC;AAC/C,MAAI,UAAU,QAAW;AACvB,UAAM,IAAI,MAAM,QAAQ;AAAA,EAC1B;AACF;AAGO,SAAS,UACd,WACA,WAAW,uBACQ;AACnB,MAAI,CAAC,WAAW;AACd,UAAM,IAAI,MAAM,wBAAwB,QAAQ,EAAE;AAAA,EACpD;AACF;AAGO,SAAS,gBAEd,cACO;AACP,SAAO,IAAI,MAAM,0BAA0B;AAC7C;AAEO,SAAS,SAAS,OAAkD;AACzE,SAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC5E;AAEO,SAAS,WAAW,OAAkD;AAC3E,SAAO,OAAO,UAAU;AAC1B;AAEO,SAAS,UAAU,OAA2C;AACnE,SAAO,SAAS,KAAK,KAAK,UAAU;AACtC;AAEO,SAAS,cAAc,OAA8C;AAC1E,MAAI,CAAC,SAAS,OAAO,UAAU;AAAU,WAAO;AAChD,QAAM,QAAQ,OAAO,eAAe,KAAK;AACzC,MAAI,UAAU,MAAM;AAClB,WAAO;AAAA,EACT;AACA,QAAM,OACJ,OAAO,eAAe,KAAK,OAAO,aAAa,KAAK,MAAM;AAE5D,MAAI,SAAS;AAAQ,WAAO;AAE5B,QAAM,mBAAmB,OAAO,UAAU,YAAY,SAAS;AAE/D,SACE,OAAO,QAAQ,cACf,SAAS,SAAS,KAAK,IAAI,MAAM;AAErC;","names":[]}

package/dist/chunk-JZUOIOMU.js

@@ -0,0 +1,75 @@
+// src/deepEqual.ts
+var has = Object.prototype.hasOwnProperty;
+function find(iter, tar, key) {
+  for (key of iter.keys()) {
+    if (deepEqual(key, tar))
+      return key;
+  }
+}
+function deepEqual(foo, bar) {
+  var ctor, len, tmp;
+  if (foo === bar)
+    return true;
+  if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+    if (ctor === Date)
+      return deepEqual(foo.getTime(), bar.getTime());
+    if (ctor === RegExp)
+      return foo.toString() === bar.toString();
+    if (ctor === Array) {
+      if ((len = foo.length) === bar.length) {
+        while (len-- && deepEqual(foo[len], bar[len]))
+          ;
+      }
+      return len === -1;
+    }
+    if (ctor === Set) {
+      if (foo.size !== bar.size) {
+        return false;
+      }
+      for (len of foo) {
+        tmp = len;
+        if (tmp && typeof tmp === "object") {
+          tmp = find(bar, tmp);
+          if (!tmp)
+            return false;
+        }
+        if (!bar.has(tmp))
+          return false;
+      }
+      return true;
+    }
+    if (ctor === Map) {
+      if (foo.size !== bar.size) {
+        return false;
+      }
+      for (len of foo) {
+        tmp = len[0];
+        if (tmp && typeof tmp === "object") {
+          tmp = find(bar, tmp);
+          if (!tmp)
+            return false;
+        }
+        if (!deepEqual(len[1], bar.get(tmp))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (!ctor || typeof foo === "object") {
+      len = 0;
+      for (ctor in foo) {
+        if (has.call(foo, ctor) && ++len && !has.call(bar, ctor))
+          return false;
+        if (!(ctor in bar) || !deepEqual(foo[ctor], bar[ctor]))
+          return false;
+      }
+      return Object.keys(bar).length === len;
+    }
+  }
+  return foo !== foo && bar !== bar;
+}
+
+export {
+  deepEqual
+};
+//# sourceMappingURL=chunk-JZUOIOMU.js.map

package/dist/chunk-JZUOIOMU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/deepEqual.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unsafe-argument */\n/* eslint-disable @typescript-eslint/no-unsafe-call */\n/* eslint-disable no-param-reassign */\n/** forked from https://github.com/lukeed/dequal to conside invalid dates as equal */\n\nvar has = Object.prototype.hasOwnProperty;\n\nfunction find(iter: any[], tar: any, key?: any) {\n  for (key of iter.keys()) {\n    if (deepEqual(key, tar)) return key;\n  }\n}\n\nexport function deepEqual(foo: any, bar: any): boolean {\n  var ctor, len, tmp;\n  if (foo === bar) return true;\n\n  if (foo && bar && (ctor = foo.constructor) === bar.constructor) {\n    if (ctor === Date) return deepEqual(foo.getTime(), bar.getTime());\n    if (ctor === RegExp) return foo.toString() === bar.toString();\n\n    if (ctor === Array) {\n      if ((len = foo.length) === bar.length) {\n        while (len-- && deepEqual(foo[len], bar[len]));\n      }\n      return len === -1;\n    }\n\n    if (ctor === Set) {\n      if (foo.size !== bar.size) {\n        return false;\n      }\n      for (len of foo) {\n        tmp = len;\n        if (tmp && typeof tmp === 'object') {\n          tmp = find(bar, tmp);\n          if (!tmp) return false;\n        }\n        if (!bar.has(tmp)) return false;\n      }\n      return true;\n    }\n\n    if (ctor === Map) {\n      if (foo.size !== bar.size) {\n        return false;\n      }\n      for (len of foo) {\n        tmp = len[0];\n        if (tmp && typeof tmp === 'object') {\n          tmp = find(bar, tmp);\n          if (!tmp) return false;\n        }\n        if (!deepEqual(len[1], bar.get(tmp))) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    if (!ctor || typeof foo === 'object') {\n      len = 0;\n      for (ctor in foo) {\n        if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;\n        if (!(ctor in bar) || !deepEqual(foo[ctor], bar[ctor])) return false;\n      }\n      return Object.keys(bar).length === len;\n    }\n  }\n\n  return foo !== foo && bar !== bar;\n}\n"],"mappings":";AAKA,IAAI,MAAM,OAAO,UAAU;AAE3B,SAAS,KAAK,MAAa,KAAU,KAAW;AAC9C,OAAK,OAAO,KAAK,KAAK,GAAG;AACvB,QAAI,UAAU,KAAK,GAAG;AAAG,aAAO;AAAA,EAClC;AACF;AAEO,SAAS,UAAU,KAAU,KAAmB;AACrD,MAAI,MAAM,KAAK;AACf,MAAI,QAAQ;AAAK,WAAO;AAExB,MAAI,OAAO,QAAQ,OAAO,IAAI,iBAAiB,IAAI,aAAa;AAC9D,QAAI,SAAS;AAAM,aAAO,UAAU,IAAI,QAAQ,GAAG,IAAI,QAAQ,CAAC;AAChE,QAAI,SAAS;AAAQ,aAAO,IAAI,SAAS,MAAM,IAAI,SAAS;AAE5D,QAAI,SAAS,OAAO;AAClB,WAAK,MAAM,IAAI,YAAY,IAAI,QAAQ;AACrC,eAAO,SAAS,UAAU,IAAI,GAAG,GAAG,IAAI,GAAG,CAAC;AAAE;AAAA,MAChD;AACA,aAAO,QAAQ;AAAA,IACjB;AAEA,QAAI,SAAS,KAAK;AAChB,UAAI,IAAI,SAAS,IAAI,MAAM;AACzB,eAAO;AAAA,MACT;AACA,WAAK,OAAO,KAAK;AACf,cAAM;AACN,YAAI,OAAO,OAAO,QAAQ,UAAU;AAClC,gBAAM,KAAK,KAAK,GAAG;AACnB,cAAI,CAAC;AAAK,mBAAO;AAAA,QACnB;AACA,YAAI,CAAC,IAAI,IAAI,GAAG;AAAG,iBAAO;AAAA,MAC5B;AACA,aAAO;AAAA,IACT;AAEA,QAAI,SAAS,KAAK;AAChB,UAAI,IAAI,SAAS,IAAI,MAAM;AACzB,eAAO;AAAA,MACT;AACA,WAAK,OAAO,KAAK;AACf,cAAM,IAAI,CAAC;AACX,YAAI,OAAO,OAAO,QAAQ,UAAU;AAClC,gBAAM,KAAK,KAAK,GAAG;AACnB,cAAI,CAAC;AAAK,mBAAO;AAAA,QACnB;AACA,YAAI,CAAC,UAAU,IAAI,CAAC,GAAG,IAAI,IAAI,GAAG,CAAC,GAAG;AACpC,iBAAO;AAAA,QACT;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAEA,QAAI,CAAC,QAAQ,OAAO,QAAQ,UAAU;AACpC,YAAM;AACN,WAAK,QAAQ,KAAK;AAChB,YAAI,IAAI,KAAK,KAAK,IAAI,KAAK,EAAE,OAAO,CAAC,IAAI,KAAK,KAAK,IAAI;AAAG,iBAAO;AACjE,YAAI,EAAE,QAAQ,QAAQ,CAAC,UAAU,IAAI,IAAI,GAAG,IAAI,IAAI,CAAC;AAAG,iBAAO;AAAA,MACjE;AACA,aAAO,OAAO,KAAK,GAAG,EAAE,WAAW;AAAA,IACrC;AAAA,EACF;AAEA,SAAO,QAAQ,OAAO,QAAQ;AAChC;","names":[]}

package/dist/chunk-MMKMF4GG.js

@@ -0,0 +1,21 @@
+// src/conversions.ts
+function bytesToHumanReadable(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} B`;
+  }
+  const kb = bytes / 1024;
+  if (kb < 1024) {
+    return `${kb.toFixed(2)} KB`;
+  }
+  const mb = kb / 1024;
+  if (mb < 1024) {
+    return `${mb.toFixed(2)} MB`;
+  }
+  const gb = mb / 1024;
+  return `${gb.toFixed(2)} GB`;
+}
+
+export {
+  bytesToHumanReadable
+};
+//# sourceMappingURL=chunk-MMKMF4GG.js.map

package/dist/chunk-MMKMF4GG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/conversions.ts"],"sourcesContent":["export function bytesToHumanReadable(bytes: number) {\n  if (bytes < 1024) {\n    return `${bytes} B`;\n  }\n\n  const kb = bytes / 1024;\n\n  if (kb < 1024) {\n    return `${kb.toFixed(2)} KB`;\n  }\n\n  const mb = kb / 1024;\n\n  if (mb < 1024) {\n    return `${mb.toFixed(2)} MB`;\n  }\n\n  const gb = mb / 1024;\n\n  return `${gb.toFixed(2)} GB`;\n}\n"],"mappings":";AAAO,SAAS,qBAAqB,OAAe;AAClD,MAAI,QAAQ,MAAM;AAChB,WAAO,GAAG,KAAK;AAAA,EACjB;AAEA,QAAM,KAAK,QAAQ;AAEnB,MAAI,KAAK,MAAM;AACb,WAAO,GAAG,GAAG,QAAQ,CAAC,CAAC;AAAA,EACzB;AAEA,QAAM,KAAK,KAAK;AAEhB,MAAI,KAAK,MAAM;AACb,WAAO,GAAG,GAAG,QAAQ,CAAC,CAAC;AAAA,EACzB;AAEA,QAAM,KAAK,KAAK;AAEhB,SAAO,GAAG,GAAG,QAAQ,CAAC,CAAC;AACzB;","names":[]}

package/dist/chunk-SNAAKCTH.js

@@ -0,0 +1,40 @@
+// src/objUtils.ts
+function objectTypedEntries(obj) {
+  return Object.entries(obj);
+}
+function pick(obj, keys, rename) {
+  const result = {};
+  if (!obj) {
+    return result;
+  }
+  for (const key of keys) {
+    result[rename?.[key] || key] = obj[key];
+  }
+  return result;
+}
+function mapArrayToObject(array, mapper) {
+  return Object.fromEntries(array.map(mapper));
+}
+function mapObjectToObject(obj, mapper) {
+  return Object.fromEntries(
+    objectTypedEntries(obj).map(([key, value]) => mapper(key, value))
+  );
+}
+function omit(obj, keys) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    if (!keys.includes(key)) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+
+export {
+  objectTypedEntries,
+  pick,
+  mapArrayToObject,
+  mapObjectToObject,
+  omit
+};
+//# sourceMappingURL=chunk-SNAAKCTH.js.map

package/dist/chunk-SNAAKCTH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/objUtils.ts"],"sourcesContent":["export function objectTypedEntries<T extends Record<string, unknown>>(obj: T) {\n  return Object.entries(obj) as [Extract<keyof T, string>, T[keyof T]][];\n}\n\nexport function pick<T, K extends keyof T>(\n  obj: T | undefined,\n  keys: K[],\n  rename?: Partial<Record<K, string>>,\n): Record<string, unknown> {\n  const result: any = {};\n\n  if (!obj) {\n    return result;\n  }\n\n  for (const key of keys) {\n    result[rename?.[key] || key] = obj[key];\n  }\n  return result;\n}\n\nexport function mapArrayToObject<T, K extends string, O>(\n  array: T[],\n  mapper: (item: T, index: number) => [K, O],\n): Record<K, O> {\n  return Object.fromEntries(array.map(mapper)) as any;\n}\n\nexport function mapObjectToObject<\n  I extends Record<string | number | symbol, unknown>,\n  K extends string | number | symbol,\n  O,\n>(obj: I, mapper: (key: keyof I, value: I[keyof I]) => [K, O]): Record<K, O> {\n  return Object.fromEntries(\n    objectTypedEntries(obj).map(([key, value]) => mapper(key, value)),\n  ) as any;\n}\n\nexport function omit<T extends Record<string, unknown>, K extends keyof T>(\n  obj: T,\n  keys: K[],\n): Omit<T, K> {\n  const result: any = {};\n\n  for (const key of Object.keys(obj)) {\n    if (!keys.includes(key as K)) {\n      result[key] = obj[key];\n    }\n  }\n\n  return result;\n}\n"],"mappings":";AAAO,SAAS,mBAAsD,KAAQ;AAC5E,SAAO,OAAO,QAAQ,GAAG;AAC3B;AAEO,SAAS,KACd,KACA,MACA,QACyB;AACzB,QAAM,SAAc,CAAC;AAErB,MAAI,CAAC,KAAK;AACR,WAAO;AAAA,EACT;AAEA,aAAW,OAAO,MAAM;AACtB,WAAO,SAAS,GAAG,KAAK,GAAG,IAAI,IAAI,GAAG;AAAA,EACxC;AACA,SAAO;AACT;AAEO,SAAS,iBACd,OACA,QACc;AACd,SAAO,OAAO,YAAY,MAAM,IAAI,MAAM,CAAC;AAC7C;AAEO,SAAS,kBAId,KAAQ,QAAmE;AAC3E,SAAO,OAAO;AAAA,IACZ,mBAAmB,GAAG,EAAE,IAAI,CAAC,CAAC,KAAK,KAAK,MAAM,OAAO,KAAK,KAAK,CAAC;AAAA,EAClE;AACF;AAEO,SAAS,KACd,KACA,MACY;AACZ,QAAM,SAAc,CAAC;AAErB,aAAW,OAAO,OAAO,KAAK,GAAG,GAAG;AAClC,QAAI,CAAC,KAAK,SAAS,GAAQ,GAAG;AAC5B,aAAO,GAAG,IAAI,IAAI,GAAG;AAAA,IACvB;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/consoleFmt.d.ts

@@ -0,0 +1,48 @@
+declare const colorToCodeASCII: {
+    red: string;
+    green: string;
+    yellow: string;
+    blue: string;
+    magenta: string;
+    cyan: string;
+    white: string;
+    black: string;
+    gray: string;
+    brightRed: string;
+    brightGreen: string;
+    brightYellow: string;
+    brightBlue: string;
+    brightMagenta: string;
+    brightCyan: string;
+    brightWhite: string;
+};
+declare function consoleColors(color: keyof typeof colorToCodeASCII, text: string): string;
+declare function bold(text: string): string;
+declare function underline(text: string): string;
+declare const bgColorToCodeASCII: {
+    red: string;
+    green: string;
+    yellow: string;
+    blue: string;
+    magenta: string;
+    cyan: string;
+    white: string;
+    black: string;
+    gray: string;
+    brightRed: string;
+    brightGreen: string;
+    brightYellow: string;
+    brightBlue: string;
+    brightMagenta: string;
+    brightCyan: string;
+    brightWhite: string;
+};
+declare function bgColor(color: keyof typeof bgColorToCodeASCII, text: string): string;
+declare const consoleFmt: {
+    color: typeof consoleColors;
+    bold: typeof bold;
+    underline: typeof underline;
+    bgColor: typeof bgColor;
+};
+
+export { consoleFmt };

package/dist/consoleFmt.js

@@ -0,0 +1,60 @@
+// src/consoleFmt.ts
+var colorToCodeASCII = {
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  black: "\x1B[30m",
+  gray: "\x1B[90m",
+  brightRed: "\x1B[91m",
+  brightGreen: "\x1B[92m",
+  brightYellow: "\x1B[93m",
+  brightBlue: "\x1B[94m",
+  brightMagenta: "\x1B[95m",
+  brightCyan: "\x1B[96m",
+  brightWhite: "\x1B[97m"
+};
+function consoleColors(color, text) {
+  return `${colorToCodeASCII[color]}${text}\x1B[0m`;
+}
+function bold(text) {
+  return `\x1B[1m${text}\x1B[0m`;
+}
+function underline(text) {
+  return `\x1B[4m${text}\x1B[0m`;
+}
+var bgColorToCodeASCII = {
+  red: "\x1B[41m",
+  green: "\x1B[42m",
+  yellow: "\x1B[43m",
+  blue: "\x1B[44m",
+  magenta: "\x1B[45m",
+  cyan: "\x1B[46m",
+  white: "\x1B[47m",
+  black: "\x1B[40m",
+  gray: "\x1B[100m",
+  brightRed: "\x1B[101m",
+  brightGreen: "\x1B[102m",
+  brightYellow: "\x1B[103m",
+  brightBlue: "\x1B[104m",
+  brightMagenta: "\x1B[105m",
+  brightCyan: "\x1B[106m",
+  brightWhite: "\x1B[107m"
+};
+function bgColor(color, text) {
+  const resetBgColor = "\x1B[49m";
+  return `${bgColorToCodeASCII[color]}${text}${resetBgColor}\x1B[0m`;
+}
+var consoleFmt = {
+  color: consoleColors,
+  bold,
+  underline,
+  bgColor
+};
+export {
+  consoleFmt
+};
+//# sourceMappingURL=consoleFmt.js.map

package/dist/consoleFmt.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/consoleFmt.ts"],"sourcesContent":["const colorToCodeASCII = {\n  red: '\\x1b[31m',\n  green: '\\x1b[32m',\n  yellow: '\\x1b[33m',\n  blue: '\\x1b[34m',\n  magenta: '\\x1b[35m',\n  cyan: '\\x1b[36m',\n  white: '\\x1b[37m',\n  black: '\\x1b[30m',\n  gray: '\\x1b[90m',\n  brightRed: '\\x1b[91m',\n  brightGreen: '\\x1b[92m',\n  brightYellow: '\\x1b[93m',\n  brightBlue: '\\x1b[94m',\n  brightMagenta: '\\x1b[95m',\n  brightCyan: '\\x1b[96m',\n  brightWhite: '\\x1b[97m',\n};\n\nfunction consoleColors(color: keyof typeof colorToCodeASCII, text: string) {\n  return `${colorToCodeASCII[color]}${text}\\x1b[0m`;\n}\n\nfunction bold(text: string) {\n  return `\\x1b[1m${text}\\x1b[0m`;\n}\n\nfunction underline(text: string) {\n  return `\\x1b[4m${text}\\x1b[0m`;\n}\n\nconst bgColorToCodeASCII = {\n  red: '\\x1b[41m',\n  green: '\\x1b[42m',\n  yellow: '\\x1b[43m',\n  blue: '\\x1b[44m',\n  magenta: '\\x1b[45m',\n  cyan: '\\x1b[46m',\n  white: '\\x1b[47m',\n  black: '\\x1b[40m',\n  gray: '\\x1b[100m',\n  brightRed: '\\x1b[101m',\n  brightGreen: '\\x1b[102m',\n  brightYellow: '\\x1b[103m',\n  brightBlue: '\\x1b[104m',\n  brightMagenta: '\\x1b[105m',\n  brightCyan: '\\x1b[106m',\n  brightWhite: '\\x1b[107m',\n};\n\nfunction bgColor(color: keyof typeof bgColorToCodeASCII, text: string) {\n  const resetBgColor = '\\x1b[49m';\n  return `${bgColorToCodeASCII[color]}${text}${resetBgColor}\\x1b[0m`;\n}\n\nexport const consoleFmt = {\n  color: consoleColors,\n  bold,\n  underline,\n  bgColor,\n};\n"],"mappings":";AAAA,IAAM,mBAAmB;AAAA,EACvB,KAAK;AAAA,EACL,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,SAAS;AAAA,EACT,MAAM;AAAA,EACN,OAAO;AAAA,EACP,OAAO;AAAA,EACP,MAAM;AAAA,EACN,WAAW;AAAA,EACX,aAAa;AAAA,EACb,cAAc;AAAA,EACd,YAAY;AAAA,EACZ,eAAe;AAAA,EACf,YAAY;AAAA,EACZ,aAAa;AACf;AAEA,SAAS,cAAc,OAAsC,MAAc;AACzE,SAAO,GAAG,iBAAiB,KAAK,CAAC,GAAG,IAAI;AAC1C;AAEA,SAAS,KAAK,MAAc;AAC1B,SAAO,UAAU,IAAI;AACvB;AAEA,SAAS,UAAU,MAAc;AAC/B,SAAO,UAAU,IAAI;AACvB;AAEA,IAAM,qBAAqB;AAAA,EACzB,KAAK;AAAA,EACL,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,SAAS;AAAA,EACT,MAAM;AAAA,EACN,OAAO;AAAA,EACP,OAAO;AAAA,EACP,MAAM;AAAA,EACN,WAAW;AAAA,EACX,aAAa;AAAA,EACb,cAAc;AAAA,EACd,YAAY;AAAA,EACZ,eAAe;AAAA,EACf,YAAY;AAAA,EACZ,aAAa;AACf;AAEA,SAAS,QAAQ,OAAwC,MAAc;AACrE,QAAM,eAAe;AACrB,SAAO,GAAG,mBAAmB,KAAK,CAAC,GAAG,IAAI,GAAG,YAAY;AAC3D;AAEO,IAAM,aAAa;AAAA,EACxB,OAAO;AAAA,EACP;AAAA,EACA;AAAA,EACA;AACF;","names":[]}

package/dist/conversions.d.ts

@@ -0,0 +1,3 @@
+declare function bytesToHumanReadable(bytes: number): string;
+
+export { bytesToHumanReadable };

package/dist/conversions.js

@@ -0,0 +1,7 @@
+import {
+  bytesToHumanReadable
+} from "./chunk-MMKMF4GG.js";
+export {
+  bytesToHumanReadable
+};
+//# sourceMappingURL=conversions.js.map

package/dist/conversions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/createThrottleController.d.ts

@@ -0,0 +1,16 @@
+type Options = {
+    maxCalls: number;
+    per: {
+        ms?: number;
+        seconds?: number;
+        minutes?: number;
+        hours?: number;
+    };
+    cleanupCheckSecsInterval?: number;
+};
+type ThrottleController = {
+    shouldSkip: (callId?: string | number | (string | number)[]) => boolean;
+};
+declare function createThrottleController({ maxCalls, per, cleanupCheckSecsInterval, }: Options): ThrottleController;
+
+export { createThrottleController };

package/dist/createThrottleController.js

@@ -0,0 +1,66 @@
+import {
+  EnhancedMap
+} from "./chunk-5FQYH3ZJ.js";
+import "./chunk-JT3EBBCA.js";
+
+// src/createThrottleController.ts
+function createThrottleController({
+  maxCalls,
+  per,
+  cleanupCheckSecsInterval = 60 * 30
+}) {
+  let msInterval = 0;
+  if (per.ms) {
+    msInterval = per.ms;
+  } else if (per.seconds) {
+    msInterval = per.seconds * 1e3;
+  } else if (per.minutes) {
+    msInterval = per.minutes * 1e3 * 60;
+  } else if (per.hours) {
+    msInterval = per.hours * 1e3 * 60 * 60;
+  }
+  if (msInterval === 0) {
+    throw new Error("Invalid interval");
+  }
+  let lastCleanupCheck = Date.now();
+  const windows = new EnhancedMap();
+  function cleanup(checkTime) {
+    const shouldCleanup = checkTime - lastCleanupCheck > cleanupCheckSecsInterval * 1e3;
+    if (!shouldCleanup)
+      return;
+    setTimeout(() => {
+      const now = Date.now();
+      lastCleanupCheck = now;
+      for (const [key, value] of windows) {
+        if (now - value.windowStartTime > msInterval) {
+          windows.delete(key);
+        }
+      }
+    }, 2);
+  }
+  return {
+    shouldSkip(callId = "") {
+      const now = Date.now();
+      const serializedCallId = String(callId);
+      const window = windows.getOrInsert(serializedCallId, () => ({
+        windowStartTime: now,
+        calls: 0
+      }));
+      if (now - window.windowStartTime > msInterval) {
+        window.windowStartTime = now;
+        window.calls = 0;
+      }
+      window.calls++;
+      cleanup(now);
+      if (window.calls > maxCalls) {
+        return true;
+      }
+      return false;
+    },
+    _currentWindows: windows
+  };
+}
+export {
+  createThrottleController
+};
+//# sourceMappingURL=createThrottleController.js.map

package/dist/createThrottleController.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/createThrottleController.ts"],"sourcesContent":["import { EnhancedMap } from './enhancedMap';\n\ntype Options = {\n  maxCalls: number;\n  per: { ms?: number; seconds?: number; minutes?: number; hours?: number };\n  cleanupCheckSecsInterval?: number;\n};\n\ntype ThrottleController = {\n  shouldSkip: (callId?: string | number | (string | number)[]) => boolean;\n  /** @internal */\n  _currentWindows: EnhancedMap<\n    string,\n    { windowStartTime: number; calls: number }\n  >;\n};\n\nexport function createThrottleController({\n  maxCalls,\n  per,\n  cleanupCheckSecsInterval = 60 * 30,\n}: Options): ThrottleController {\n  let msInterval = 0;\n\n  if (per.ms) {\n    msInterval = per.ms;\n  } else if (per.seconds) {\n    msInterval = per.seconds * 1000;\n  } else if (per.minutes) {\n    msInterval = per.minutes * 1000 * 60;\n  } else if (per.hours) {\n    msInterval = per.hours * 1000 * 60 * 60;\n  }\n\n  if (msInterval === 0) {\n    throw new Error('Invalid interval');\n  }\n\n  let lastCleanupCheck = Date.now();\n\n  const windows = new EnhancedMap<\n    string,\n    { windowStartTime: number; calls: number }\n  >();\n\n  function cleanup(checkTime: number) {\n    const shouldCleanup =\n      checkTime - lastCleanupCheck > cleanupCheckSecsInterval * 1000;\n\n    if (!shouldCleanup) return;\n\n    setTimeout(() => {\n      const now = Date.now();\n\n      lastCleanupCheck = now;\n\n      for (const [key, value] of windows) {\n        if (now - value.windowStartTime > msInterval) {\n          windows.delete(key);\n        }\n      }\n    }, 2);\n  }\n\n  return {\n    shouldSkip(callId = '') {\n      const now = Date.now();\n\n      const serializedCallId = String(callId);\n\n      const window = windows.getOrInsert(serializedCallId, () => ({\n        windowStartTime: now,\n        calls: 0,\n      }));\n\n      if (now - window.windowStartTime > msInterval) {\n        window.windowStartTime = now;\n        window.calls = 0;\n      }\n\n      window.calls++;\n\n      cleanup(now);\n\n      if (window.calls > maxCalls) {\n        return true;\n      }\n\n      return false;\n    },\n    _currentWindows: windows,\n  };\n}\n"],"mappings":";;;;;;AAiBO,SAAS,yBAAyB;AAAA,EACvC;AAAA,EACA;AAAA,EACA,2BAA2B,KAAK;AAClC,GAAgC;AAC9B,MAAI,aAAa;AAEjB,MAAI,IAAI,IAAI;AACV,iBAAa,IAAI;AAAA,EACnB,WAAW,IAAI,SAAS;AACtB,iBAAa,IAAI,UAAU;AAAA,EAC7B,WAAW,IAAI,SAAS;AACtB,iBAAa,IAAI,UAAU,MAAO;AAAA,EACpC,WAAW,IAAI,OAAO;AACpB,iBAAa,IAAI,QAAQ,MAAO,KAAK;AAAA,EACvC;AAEA,MAAI,eAAe,GAAG;AACpB,UAAM,IAAI,MAAM,kBAAkB;AAAA,EACpC;AAEA,MAAI,mBAAmB,KAAK,IAAI;AAEhC,QAAM,UAAU,IAAI,YAGlB;AAEF,WAAS,QAAQ,WAAmB;AAClC,UAAM,gBACJ,YAAY,mBAAmB,2BAA2B;AAE5D,QAAI,CAAC;AAAe;AAEpB,eAAW,MAAM;AACf,YAAM,MAAM,KAAK,IAAI;AAErB,yBAAmB;AAEnB,iBAAW,CAAC,KAAK,KAAK,KAAK,SAAS;AAClC,YAAI,MAAM,MAAM,kBAAkB,YAAY;AAC5C,kBAAQ,OAAO,GAAG;AAAA,QACpB;AAAA,MACF;AAAA,IACF,GAAG,CAAC;AAAA,EACN;AAEA,SAAO;AAAA,IACL,WAAW,SAAS,IAAI;AACtB,YAAM,MAAM,KAAK,IAAI;AAErB,YAAM,mBAAmB,OAAO,MAAM;AAEtC,YAAM,SAAS,QAAQ,YAAY,kBAAkB,OAAO;AAAA,QAC1D,iBAAiB;AAAA,QACjB,OAAO;AAAA,MACT,EAAE;AAEF,UAAI,MAAM,OAAO,kBAAkB,YAAY;AAC7C,eAAO,kBAAkB;AACzB,eAAO,QAAQ;AAAA,MACjB;AAEA,aAAO;AAEP,cAAQ,GAAG;AAEX,UAAI,OAAO,QAAQ,UAAU;AAC3B,eAAO;AAAA,MACT;AAEA,aAAO;AAAA,IACT;AAAA,IACA,iBAAiB;AAAA,EACnB;AACF;","names":[]}

package/dist/dedent.d.ts

@@ -0,0 +1,4 @@
+declare function dedent(strings: string): string;
+declare function dedent(strings: TemplateStringsArray, ...values: string[]): string;
+
+export { dedent };

package/dist/dedent.js

@@ -0,0 +1,33 @@
+// src/dedent.ts
+function dedent(strings, ...values) {
+  const raw = typeof strings === "string" ? [strings] : strings.raw;
+  let result = "";
+  for (let i = 0; i < raw.length; i++) {
+    result += raw[i].replace(/\\\n[ \t]*/g, "").replace(/\\`/g, "`");
+    if (i < values.length) {
+      result += values[i];
+    }
+  }
+  const lines = result.split("\n");
+  let mindent = null;
+  lines.forEach((l) => {
+    const m = l.match(/^(\s+)\S+/);
+    if (m) {
+      const indent = m[1].length;
+      if (!mindent) {
+        mindent = indent;
+      } else {
+        mindent = Math.min(mindent, indent);
+      }
+    }
+  });
+  if (mindent !== null) {
+    const m = mindent;
+    result = lines.map((l) => l.startsWith(" ") ? l.slice(m) : l).join("\n");
+  }
+  return result.trim().replace(/\\n/g, "\n");
+}
+export {
+  dedent
+};
+//# sourceMappingURL=dedent.js.map

package/dist/dedent.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/dedent.ts"],"sourcesContent":["// fork of https://github.com/dmnd/dedent\n\nexport function dedent(strings: string): string;\nexport function dedent(\n  strings: TemplateStringsArray,\n  ...values: string[]\n): string;\nexport function dedent(\n  strings: TemplateStringsArray | string,\n  ...values: string[]\n) {\n  // $FlowFixMe: Flow doesn't undestand .raw\n  const raw = typeof strings === 'string' ? [strings] : strings.raw;\n\n  // first, perform interpolation\n  let result = '';\n  for (let i = 0; i < raw.length; i++) {\n    result += raw[i]! // join lines when there is a suppressed newline\n      .replace(/\\\\\\n[ \\t]*/g, '')\n      // handle escaped backticks\n      .replace(/\\\\`/g, '`');\n\n    if (i < values.length) {\n      result += values[i];\n    }\n  }\n\n  // now strip indentation\n  const lines = result.split('\\n');\n  let mindent: number | null = null;\n  lines.forEach((l) => {\n    const m = l.match(/^(\\s+)\\S+/);\n    if (m) {\n      const indent = m[1]!.length;\n      if (!mindent) {\n        // this is the first indented line\n        mindent = indent;\n      } else {\n        mindent = Math.min(mindent, indent);\n      }\n    }\n  });\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  if (mindent !== null) {\n    const m = mindent; // appease Flow\n    result = lines.map((l) => (l.startsWith(' ') ? l.slice(m) : l)).join('\\n');\n  }\n\n  return (\n    result\n      // dedent eats leading and trailing whitespace too\n      .trim()\n      // handle escaped newlines at the end to ensure they don't get stripped too\n      .replace(/\\\\n/g, '\\n')\n  );\n}\n"],"mappings":";AAOO,SAAS,OACd,YACG,QACH;AAEA,QAAM,MAAM,OAAO,YAAY,WAAW,CAAC,OAAO,IAAI,QAAQ;AAG9D,MAAI,SAAS;AACb,WAAS,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;AACnC,cAAU,IAAI,CAAC,EACZ,QAAQ,eAAe,EAAE,EAEzB,QAAQ,QAAQ,GAAG;AAEtB,QAAI,IAAI,OAAO,QAAQ;AACrB,gBAAU,OAAO,CAAC;AAAA,IACpB;AAAA,EACF;AAGA,QAAM,QAAQ,OAAO,MAAM,IAAI;AAC/B,MAAI,UAAyB;AAC7B,QAAM,QAAQ,CAAC,MAAM;AACnB,UAAM,IAAI,EAAE,MAAM,WAAW;AAC7B,QAAI,GAAG;AACL,YAAM,SAAS,EAAE,CAAC,EAAG;AACrB,UAAI,CAAC,SAAS;AAEZ,kBAAU;AAAA,MACZ,OAAO;AACL,kBAAU,KAAK,IAAI,SAAS,MAAM;AAAA,MACpC;AAAA,IACF;AAAA,EACF,CAAC;AAGD,MAAI,YAAY,MAAM;AACpB,UAAM,IAAI;AACV,aAAS,MAAM,IAAI,CAAC,MAAO,EAAE,WAAW,GAAG,IAAI,EAAE,MAAM,CAAC,IAAI,CAAE,EAAE,KAAK,IAAI;AAAA,EAC3E;AAEA,SACE,OAEG,KAAK,EAEL,QAAQ,QAAQ,IAAI;AAE3B;","names":[]}

package/dist/deepEqual.d.ts

@@ -0,0 +1,4 @@
+/** forked from https://github.com/lukeed/dequal to conside invalid dates as equal */
+declare function deepEqual(foo: any, bar: any): boolean;
+
+export { deepEqual };

package/dist/deepEqual.js

@@ -0,0 +1,7 @@
+import {
+  deepEqual
+} from "./chunk-JZUOIOMU.js";
+export {
+  deepEqual
+};
+//# sourceMappingURL=deepEqual.js.map

package/dist/deepEqual.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/enhancedMap.d.ts

@@ -0,0 +1,22 @@
+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[];
+    /** @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>;
+}
+
+export { EnhancedMap, enhancedMapReject };

package/dist/enhancedMap.js

@@ -0,0 +1,10 @@
+import {
+  EnhancedMap,
+  enhancedMapReject
+} from "./chunk-5FQYH3ZJ.js";
+import "./chunk-JT3EBBCA.js";
+export {
+  EnhancedMap,
+  enhancedMapReject
+};
+//# sourceMappingURL=enhancedMap.js.map

package/dist/enhancedMap.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/exhaustiveMatch.d.ts

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

package/dist/exhaustiveMatch.js

@@ -0,0 +1,27 @@
+// src/exhaustiveMatch.ts
+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}`);
+  }
+  return {
+    with: matchWith
+  };
+}
+export {
+  exhaustiveMatch
+};
+//# sourceMappingURL=exhaustiveMatch.js.map

package/dist/exhaustiveMatch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/exhaustiveMatch.ts"],"sourcesContent":["export function exhaustiveMatch<T extends string>(value: T) {\n  type Pattern<R> = {\n    [K in T]: (() => R) | '_nxt' | '_never';\n  };\n\n  /**\n   * The pattern can be:\n   * - a function that returns the result\n   * - '_nxt' to try the next pattern\n   * - '_never' to indicate that this pattern should never be matched\n   */\n  function matchWith<R>(pattern: Pattern<R>): R {\n    const result = pattern[value];\n\n    if (typeof result === 'function') {\n      return result();\n    }\n\n    if (result === '_nxt') {\n      const keys = Object.keys(pattern);\n\n      const nextIndex = keys.indexOf(value) + 1;\n\n      for (let i = nextIndex; i < keys.length; i++) {\n        const nextMatch = pattern[keys[i] as T];\n\n        if (typeof nextMatch === 'function') {\n          return nextMatch();\n        }\n      }\n    }\n\n    throw new Error(`Exhaustive match failed: no match for ${value}`);\n  }\n\n  return {\n    with: matchWith,\n  };\n}\n"],"mappings":";AAAO,SAAS,gBAAkC,OAAU;AAW1D,WAAS,UAAa,SAAwB;AAC5C,UAAM,SAAS,QAAQ,KAAK;AAE5B,QAAI,OAAO,WAAW,YAAY;AAChC,aAAO,OAAO;AAAA,IAChB;AAEA,QAAI,WAAW,QAAQ;AACrB,YAAM,OAAO,OAAO,KAAK,OAAO;AAEhC,YAAM,YAAY,KAAK,QAAQ,KAAK,IAAI;AAExC,eAAS,IAAI,WAAW,IAAI,KAAK,QAAQ,KAAK;AAC5C,cAAM,YAAY,QAAQ,KAAK,CAAC,CAAM;AAEtC,YAAI,OAAO,cAAc,YAAY;AACnC,iBAAO,UAAU;AAAA,QACnB;AAAA,MACF;AAAA,IACF;AAEA,UAAM,IAAI,MAAM,yCAAyC,KAAK,EAAE;AAAA,EAClE;AAEA,SAAO;AAAA,IACL,MAAM;AAAA,EACR;AACF;","names":[]}

package/dist/main.d.ts

@@ -0,0 +1,25 @@
+///<reference path="arrayUtils.d.ts" />
+///<reference path="assertions.d.ts" />
+///<reference path="castValues.d.ts" />
+///<reference path="consoleFmt.d.ts" />
+///<reference path="conversions.d.ts" />
+///<reference path="createThrottleController.d.ts" />
+///<reference path="dedent.d.ts" />
+///<reference path="deepEqual.d.ts" />
+///<reference path="enhancedMap.d.ts" />
+///<reference path="exhaustiveMatch.d.ts" />
+///<reference path="main.d.ts" />
+///<reference path="mathUtils.d.ts" />
+///<reference path="objUtils.d.ts" />
+///<reference path="parallelAsyncResultCalls.d.ts" />
+///<reference path="promiseUtils.d.ts" />
+///<reference path="rsResult.d.ts" />
+///<reference path="runShellCmd.d.ts" />
+///<reference path="shallowEqual.d.ts" />
+///<reference path="sleep.d.ts" />
+///<reference path="stringUtils.d.ts" />
+///<reference path="testUtils.d.ts" />
+///<reference path="typingFnUtils.d.ts" />
+///<reference path="typingTestUtils.d.ts" />
+///<reference path="typingUtils.d.ts" />
+///<reference path="yamlStringify.d.ts" />