@ls-stack/utils 3.12.3 → 3.14.0

package/lib/chunk-SSKW673U.js

@@ -0,0 +1,36 @@
+// src/typeGuards.ts
+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 && isFunction(value.then);
+}
+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;
+}
+function isNonEmptyArray(value) {
+  return value.length > 0;
+}
+function arrayHasAtLeastXItems(array, minLength) {
+  return array.length >= minLength;
+}
+
+export {
+  isObject,
+  isFunction,
+  isPromise,
+  isPlainObject,
+  isNonEmptyArray,
+  arrayHasAtLeastXItems
+};

package/lib/chunk-WS4WEVHU.js

@@ -0,0 +1,57 @@
+import {
+  isFunction,
+  isObject,
+  isPlainObject,
+  isPromise
+} from "./chunk-SSKW673U.js";
+
+// src/assertions.ts
+var undefErrMsg = "not undefined assertion failed";
+var nullishErrMsg = "not nullish assertion failed";
+function notUndefined(value, error = undefErrMsg) {
+  if (value === void 0) {
+    throw typeof error === "function" ? error() : new Error(error);
+  }
+  return value;
+}
+function notNullish(value, error = nullishErrMsg) {
+  if (value === void 0 || value === null) {
+    throw typeof error === "function" ? error() : new Error(error);
+  }
+  return value;
+}
+function assertIsNotNullish(value, error = nullishErrMsg) {
+  if (value === void 0 || value === null) {
+    throw typeof error === "function" ? error() : new Error(error);
+  }
+}
+function assertIsNotUndefined(value, error = undefErrMsg) {
+  if (value === void 0) {
+    throw typeof error === "function" ? error() : new Error(error);
+  }
+}
+function invariant(condition, error = "Invariant violation") {
+  if (!condition) {
+    throw typeof error === "function" ? error() : new Error(`Invariant violation: ${error}`);
+  }
+}
+function exhaustiveCheck(narrowedType) {
+  return new Error("This should never happen");
+}
+var isFunction2 = isFunction;
+var isObject2 = isObject;
+var isPlainObject2 = isPlainObject;
+var isPromise2 = isPromise;
+
+export {
+  notUndefined,
+  notNullish,
+  assertIsNotNullish,
+  assertIsNotUndefined,
+  invariant,
+  exhaustiveCheck,
+  isFunction2 as isFunction,
+  isObject2 as isObject,
+  isPlainObject2 as isPlainObject,
+  isPromise2 as isPromise
+};

package/lib/concurrentCalls.cjs

@@ -26,12 +26,7 @@ __export(concurrentCalls_exports, {
 module.exports = __toCommonJS(concurrentCalls_exports);
 var import_t_result = require("t-result");
 
-// src/assertions.ts
-function invariant(condition, errorMsg = "Invariant violation") {
-  if (!condition) {
-    throw new Error(`Invariant violation: ${errorMsg}`);
-  }
-}
+// src/typeGuards.ts
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -42,12 +37,21 @@ function isPromise(value) {
   return isObject(value) && "then" in value && isFunction(value.then);
 }
 
+// src/assertions.ts
+function invariant(condition, error = "Invariant violation") {
+  if (!condition) {
+    throw typeof error === "function" ? error() : new Error(`Invariant violation: ${error}`);
+  }
+}
+var isFunction2 = isFunction;
+var isPromise2 = isPromise;
+
 // src/arrayUtils.ts
 function truncateArray(array, maxLength, appendIfTruncated) {
   const truncate = array.length > maxLength;
   const result = truncate ? [...array.slice(0, maxLength)] : array;
   if (truncate && appendIfTruncated) {
-    if (isFunction(appendIfTruncated)) {
+    if (isFunction2(appendIfTruncated)) {
       return [...result, appendIfTruncated(array.length - maxLength)];
     }
     return [...result, appendIfTruncated];
@@ -76,14 +80,14 @@ var ConcurrentCalls = class {
   }
   resultifyAdd(...calls) {
     const processedCalls = calls.map((call) => {
-      if (isPromise(call)) {
+      if (isPromise2(call)) {
         return call.then((value) => import_t_result.Result.ok(value)).catch((err) => import_t_result.Result.err((0, import_t_result.unknownToError)(err)));
       } else {
         const originalFn = call;
         return async () => {
           try {
             const valueOrPromise = originalFn();
-            const value = isPromise(valueOrPromise) ? await valueOrPromise : valueOrPromise;
+            const value = isPromise2(valueOrPromise) ? await valueOrPromise : valueOrPromise;
             return import_t_result.Result.ok(value);
           } catch (err) {
             return import_t_result.Result.err((0, import_t_result.unknownToError)(err));
@@ -101,7 +105,7 @@ var ConcurrentCalls = class {
       const asyncResults = await Promise.all(
         this.#pendingCalls.map(async (fn, i) => {
           try {
-            const isP = isPromise(fn);
+            const isP = isPromise2(fn);
             if (delayStart) {
               invariant(
                 !isP,
@@ -131,7 +135,7 @@ var ConcurrentCalls = class {
     const settledResults = await Promise.allSettled(
       this.#pendingCalls.map(async (callOrPromise, i) => {
         try {
-          const isP = isPromise(callOrPromise);
+          const isP = isPromise2(callOrPromise);
           if (delayStart) {
             invariant(
               !isP,
@@ -186,7 +190,7 @@ var ConcurrentCallsWithMetadata = class {
   }
   resultifyAdd(...items) {
     const processedItems = items.map(({ fn, metadata }) => {
-      const cb = isPromise(fn) ? (0, import_t_result.resultify)(fn) : () => (0, import_t_result.resultify)(async () => {
+      const cb = isPromise2(fn) ? (0, import_t_result.resultify)(fn) : () => (0, import_t_result.resultify)(async () => {
         const result = await fn();
         return result;
       });
@@ -210,7 +214,7 @@ var ConcurrentCallsWithMetadata = class {
           if (delayStart) {
             await sleep(delayStart(i));
           }
-          const result = await (isPromise(call.fn) ? call.fn : call.fn());
+          const result = await (isPromise2(call.fn) ? call.fn : call.fn());
           if (!result.ok) {
             throw { metadata: call.metadata, error: result.error };
           }
@@ -244,6 +248,7 @@ var ConcurrentCallsWithMetadata = class {
       return {
         succeeded: [],
         failed: [],
+        failures: [],
         results: [],
         allFailed: false,
         total: 0,
@@ -256,7 +261,7 @@ var ConcurrentCallsWithMetadata = class {
           if (delayStart) {
             await sleep(delayStart(i));
           }
-          const result = await (isPromise(call.fn) ? call.fn : call.fn());
+          const result = await (isPromise2(call.fn) ? call.fn : call.fn());
           if (!result.ok) {
             throw result.error;
           }
@@ -294,6 +299,7 @@ var ConcurrentCallsWithMetadata = class {
     return {
       succeeded: succeededProcessing,
       failed: failedProcessing,
+      failures: failedProcessing,
       results: resultsProcessing,
       allFailed,
       total,

package/lib/concurrentCalls.d.cts

@@ -56,7 +56,9 @@ declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown,
     runAll({ delayStart }?: RunProps): Promise<Result<SucceededCall<R, M>[], FailedCall<M, E>>>;
     runAllSettled({ delayStart }?: RunProps): Promise<{
         allFailed: boolean;
+        /** @deprecated Use failures property instead */
         failed: FailedCall<M, E>[];
+        failures: FailedCall<M, E>[];
         succeeded: SucceededCall<R, M>[];
         total: number;
         results: SettledResultWithMetadata<R, M, E>[];

package/lib/concurrentCalls.d.ts

@@ -56,7 +56,9 @@ declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown,
     runAll({ delayStart }?: RunProps): Promise<Result<SucceededCall<R, M>[], FailedCall<M, E>>>;
     runAllSettled({ delayStart }?: RunProps): Promise<{
         allFailed: boolean;
+        /** @deprecated Use failures property instead */
         failed: FailedCall<M, E>[];
+        failures: FailedCall<M, E>[];
         succeeded: SucceededCall<R, M>[];
         total: number;
         results: SettledResultWithMetadata<R, M, E>[];

package/lib/concurrentCalls.js

@@ -6,11 +6,12 @@ import {
 } from "./chunk-5DZT3Z5Z.js";
 import {
   truncateArray
-} from "./chunk-UTFE4P3P.js";
+} from "./chunk-DMW5Q4T2.js";
 import {
   invariant,
   isPromise
-} from "./chunk-3XCS7FVO.js";
+} from "./chunk-WS4WEVHU.js";
+import "./chunk-SSKW673U.js";
 
 // src/concurrentCalls.ts
 import { Result, resultify, unknownToError } from "t-result";
@@ -191,6 +192,7 @@ var ConcurrentCallsWithMetadata = class {
       return {
         succeeded: [],
         failed: [],
+        failures: [],
         results: [],
         allFailed: false,
         total: 0,
@@ -241,6 +243,7 @@ var ConcurrentCallsWithMetadata = class {
     return {
       succeeded: succeededProcessing,
       failed: failedProcessing,
+      failures: failedProcessing,
       results: resultsProcessing,
       allFailed,
       total,

package/lib/createThrottleController.cjs

@@ -24,11 +24,14 @@ __export(createThrottleController_exports, {
 });
 module.exports = __toCommonJS(createThrottleController_exports);
 
-// src/assertions.ts
+// src/typeGuards.ts
 function isFunction(value) {
   return typeof value === "function";
 }
 
+// src/assertions.ts
+var isFunction2 = isFunction;
+
 // src/enhancedMap.ts
 var enhancedMapReject = Symbol();
 var EnhancedMap = class _EnhancedMap extends Map {
@@ -103,7 +106,7 @@ var EnhancedMap = class _EnhancedMap extends Map {
   static from(array, mapFunction) {
     const map = new _EnhancedMap();
     if (!array) return map;
-    const isFn = isFunction(mapFunction);
+    const isFn = isFunction2(mapFunction);
     for (const item of array) {
       if (isFn) {
         const result = mapFunction(item);

package/lib/createThrottleController.js

@@ -1,12 +1,13 @@
 import {
   EnhancedMap
-} from "./chunk-OHHF4CJZ.js";
+} from "./chunk-GKOTKAIV.js";
 import {
   durationObjToMs
 } from "./chunk-5MNYPLZI.js";
 import "./chunk-HTCYUMDR.js";
 import "./chunk-II4R3VVX.js";
-import "./chunk-3XCS7FVO.js";
+import "./chunk-WS4WEVHU.js";
+import "./chunk-SSKW673U.js";
 
 // src/createThrottleController.ts
 function createThrottleController({

package/lib/enhancedMap.cjs

@@ -25,11 +25,14 @@ __export(enhancedMap_exports, {
 });
 module.exports = __toCommonJS(enhancedMap_exports);
 
-// src/assertions.ts
+// src/typeGuards.ts
 function isFunction(value) {
   return typeof value === "function";
 }
 
+// src/assertions.ts
+var isFunction2 = isFunction;
+
 // src/enhancedMap.ts
 var enhancedMapReject = Symbol();
 var EnhancedMap = class _EnhancedMap extends Map {
@@ -104,7 +107,7 @@ var EnhancedMap = class _EnhancedMap extends Map {
   static from(array, mapFunction) {
     const map = new _EnhancedMap();
     if (!array) return map;
-    const isFn = isFunction(mapFunction);
+    const isFn = isFunction2(mapFunction);
     for (const item of array) {
       if (isFn) {
         const result = mapFunction(item);

package/lib/enhancedMap.js

@@ -1,8 +1,9 @@
 import {
   EnhancedMap,
   enhancedMapReject
-} from "./chunk-OHHF4CJZ.js";
-import "./chunk-3XCS7FVO.js";
+} from "./chunk-GKOTKAIV.js";
+import "./chunk-WS4WEVHU.js";
+import "./chunk-SSKW673U.js";
 export {
   EnhancedMap,
   enhancedMapReject

package/lib/getCompositeKey.cjs

@@ -0,0 +1,86 @@
+"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/getCompositeKey.ts
+var getCompositeKey_exports = {};
+__export(getCompositeKey_exports, {
+  getCompositeKey: () => getCompositeKey
+});
+module.exports = __toCommonJS(getCompositeKey_exports);
+
+// src/typeGuards.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/assertions.ts
+var isObject2 = isObject;
+
+// src/getCompositeKey.ts
+function getCompositeKey(input, maxSortingDepth = 3) {
+  if (typeof input === "string") return `"${input}`;
+  if (!input || typeof input !== "object") return `$${input}`;
+  return stringifyCompact(input, maxSortingDepth, 0, /* @__PURE__ */ new WeakSet());
+}
+function stringifyCompact(input, maxSortingDepth, depth, refs) {
+  const isJsObj = input && typeof input === "object";
+  if (isJsObj) {
+    if (refs.has(input)) {
+      throw new Error("Circular reference detected");
+    }
+    refs.add(input);
+  }
+  let result;
+  if (Array.isArray(input)) {
+    result = "[";
+    for (const v of input) {
+      if (result.length > 1) result += ",";
+      result += stringifyCompact(v, maxSortingDepth, depth + 1, refs);
+    }
+    result += "]";
+  } else if (isObject2(input)) {
+    let entries = Object.entries(input);
+    if (entries.length === 0) {
+      result = "{}";
+    } else {
+      if (depth < maxSortingDepth) {
+        entries = entries.sort(
+          ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+        );
+      }
+      result = "{";
+      for (const [k, v] of entries) {
+        if (v === void 0) continue;
+        if (result.length > 1) result += ",";
+        result += `${k}:${stringifyCompact(v, maxSortingDepth, depth + 1, refs)}`;
+      }
+      result += "}";
+    }
+  } else {
+    result = JSON.stringify(input);
+  }
+  if (isJsObj) {
+    refs.delete(input);
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCompositeKey
+});

package/lib/getCompositeKey.d.cts

@@ -0,0 +1,10 @@
+/**
+ * Returns a stable key for the input value.
+ *
+ * @param input - The value to get a stable key for.
+ * @param maxSortingDepth - The maximum depth to sort the input value. Default is 3.
+ * @returns A stable key for the input value.
+ */
+declare function getCompositeKey(input: unknown, maxSortingDepth?: number): string;
+
+export { getCompositeKey };

package/lib/getCompositeKey.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns a stable key for the input value.
+ *
+ * @param input - The value to get a stable key for.
+ * @param maxSortingDepth - The maximum depth to sort the input value. Default is 3.
+ * @returns A stable key for the input value.
+ */
+declare function getCompositeKey(input: unknown, maxSortingDepth?: number): string;
+
+export { getCompositeKey };

package/lib/getCompositeKey.js

@@ -0,0 +1,8 @@
+import {
+  getCompositeKey
+} from "./chunk-NH2LCAQS.js";
+import "./chunk-WS4WEVHU.js";
+import "./chunk-SSKW673U.js";
+export {
+  getCompositeKey
+};

package/lib/getValueStableKey.cjs

@@ -24,13 +24,16 @@ __export(getValueStableKey_exports, {
 });
 module.exports = __toCommonJS(getValueStableKey_exports);
 
-// src/assertions.ts
+// src/typeGuards.ts
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-// src/getValueStableKey.ts
-function getValueStableKey(input, maxSortingDepth = 3) {
+// src/assertions.ts
+var isObject2 = isObject;
+
+// src/getCompositeKey.ts
+function getCompositeKey(input, maxSortingDepth = 3) {
   if (typeof input === "string") return `"${input}`;
   if (!input || typeof input !== "object") return `$${input}`;
   return stringifyCompact(input, maxSortingDepth, 0, /* @__PURE__ */ new WeakSet());
@@ -51,7 +54,7 @@ function stringifyCompact(input, maxSortingDepth, depth, refs) {
       result += stringifyCompact(v, maxSortingDepth, depth + 1, refs);
     }
     result += "]";
-  } else if (isObject(input)) {
+  } else if (isObject2(input)) {
     let entries = Object.entries(input);
     if (entries.length === 0) {
       result = "{}";
@@ -77,6 +80,9 @@ function stringifyCompact(input, maxSortingDepth, depth, refs) {
   }
   return result;
 }
+
+// src/getValueStableKey.ts
+var getValueStableKey = getCompositeKey;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getValueStableKey

package/lib/getValueStableKey.d.cts

@@ -1,10 +1,14 @@
+import { getCompositeKey } from './getCompositeKey.cjs';
+
 /**
  * Returns a stable key for the input value.
  *
  * @param input - The value to get a stable key for.
  * @param maxSortingDepth - The maximum depth to sort the input value. Default is 3.
  * @returns A stable key for the input value.
+ *
+ * @deprecated Use `getCompositeKey` from `@ls-stack/utils/getCompositeKey` instead.
  */
-declare function getValueStableKey(input: unknown, maxSortingDepth?: number): string;
+declare const getValueStableKey: typeof getCompositeKey;
 
 export { getValueStableKey };

package/lib/getValueStableKey.d.ts

@@ -1,10 +1,14 @@
+import { getCompositeKey } from './getCompositeKey.js';
+
 /**
  * Returns a stable key for the input value.
  *
  * @param input - The value to get a stable key for.
  * @param maxSortingDepth - The maximum depth to sort the input value. Default is 3.
  * @returns A stable key for the input value.
+ *
+ * @deprecated Use `getCompositeKey` from `@ls-stack/utils/getCompositeKey` instead.
  */
-declare function getValueStableKey(input: unknown, maxSortingDepth?: number): string;
+declare const getValueStableKey: typeof getCompositeKey;
 
 export { getValueStableKey };

package/lib/getValueStableKey.js

@@ -1,55 +1,11 @@
 import {
-  isObject
-} from "./chunk-3XCS7FVO.js";
+  getCompositeKey
+} from "./chunk-NH2LCAQS.js";
+import "./chunk-WS4WEVHU.js";
+import "./chunk-SSKW673U.js";
 
 // src/getValueStableKey.ts
-function getValueStableKey(input, maxSortingDepth = 3) {
-  if (typeof input === "string") return `"${input}`;
-  if (!input || typeof input !== "object") return `$${input}`;
-  return stringifyCompact(input, maxSortingDepth, 0, /* @__PURE__ */ new WeakSet());
-}
-function stringifyCompact(input, maxSortingDepth, depth, refs) {
-  const isJsObj = input && typeof input === "object";
-  if (isJsObj) {
-    if (refs.has(input)) {
-      throw new Error("Circular reference detected");
-    }
-    refs.add(input);
-  }
-  let result;
-  if (Array.isArray(input)) {
-    result = "[";
-    for (const v of input) {
-      if (result.length > 1) result += ",";
-      result += stringifyCompact(v, maxSortingDepth, depth + 1, refs);
-    }
-    result += "]";
-  } else if (isObject(input)) {
-    let entries = Object.entries(input);
-    if (entries.length === 0) {
-      result = "{}";
-    } else {
-      if (depth < maxSortingDepth) {
-        entries = entries.sort(
-          ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
-        );
-      }
-      result = "{";
-      for (const [k, v] of entries) {
-        if (v === void 0) continue;
-        if (result.length > 1) result += ",";
-        result += `${k}:${stringifyCompact(v, maxSortingDepth, depth + 1, refs)}`;
-      }
-      result += "}";
-    }
-  } else {
-    result = JSON.stringify(input);
-  }
-  if (isJsObj) {
-    refs.delete(input);
-  }
-  return result;
-}
+var getValueStableKey = getCompositeKey;
 export {
   getValueStableKey
 };

package/lib/interpolate.cjs

@@ -26,9 +26,9 @@ __export(interpolate_exports, {
 module.exports = __toCommonJS(interpolate_exports);
 
 // src/assertions.ts
-function invariant(condition, errorMsg = "Invariant violation") {
+function invariant(condition, error = "Invariant violation") {
   if (!condition) {
-    throw new Error(`Invariant violation: ${errorMsg}`);
+    throw typeof error === "function" ? error() : new Error(`Invariant violation: ${error}`);
   }
 }
 

package/lib/interpolate.js

@@ -5,7 +5,8 @@ import {
 } from "./chunk-HTCYUMDR.js";
 import {
   invariant
-} from "./chunk-3XCS7FVO.js";
+} from "./chunk-WS4WEVHU.js";
+import "./chunk-SSKW673U.js";
 
 // src/interpolate.ts
 function mod(n, m) {

package/lib/objUtils.d.cts

@@ -1,3 +1,4 @@
+/** @deprecated use typedObjectEntries from @ls-stack/utils/typingFnUtils instead */
 declare function objectTypedEntries<T extends Record<string, unknown>>(obj: T): [Extract<keyof T, string>, T[keyof T]][];
 declare function pick<T, K extends keyof T>(obj: T | undefined, keys: K[], rename?: Partial<Record<K, string>>): Record<string, unknown>;
 declare function mapArrayToObject<T, K extends string, O>(array: T[], mapper: (item: T, index: number) => [K, O]): Record<K, O>;

package/lib/objUtils.d.ts

@@ -1,3 +1,4 @@
+/** @deprecated use typedObjectEntries from @ls-stack/utils/typingFnUtils instead */
 declare function objectTypedEntries<T extends Record<string, unknown>>(obj: T): [Extract<keyof T, string>, T[keyof T]][];
 declare function pick<T, K extends keyof T>(obj: T | undefined, keys: K[], rename?: Partial<Record<K, string>>): Record<string, unknown>;
 declare function mapArrayToObject<T, K extends string, O>(array: T[], mapper: (item: T, index: number) => [K, O]): Record<K, O>;

package/lib/parallelAsyncCalls.cjs

@@ -25,15 +25,18 @@ __export(parallelAsyncCalls_exports, {
 module.exports = __toCommonJS(parallelAsyncCalls_exports);
 var import_t_result = require("t-result");
 
+// src/typeGuards.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/assertions.ts
-function invariant(condition, errorMsg = "Invariant violation") {
+function invariant(condition, error = "Invariant violation") {
   if (!condition) {
-    throw new Error(`Invariant violation: ${errorMsg}`);
+    throw typeof error === "function" ? error() : new Error(`Invariant violation: ${error}`);
   }
 }
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
+var isObject2 = isObject;
 
 // src/sleep.ts
 function sleep(ms) {
@@ -48,7 +51,7 @@ var ParallelAsyncResultCalls = class {
   }
   add(call) {
     this.pendingCalls.push(
-      isObject(call) ? call : { metadata: void 0, fn: call }
+      isObject2(call) ? call : { metadata: void 0, fn: call }
     );
     return this;
   }
@@ -56,7 +59,7 @@ var ParallelAsyncResultCalls = class {
   addTuple(...calls) {
     for (const call of calls) {
       this.pendingCalls.push(
-        isObject(call) ? call : { metadata: void 0, fn: call }
+        isObject2(call) ? call : { metadata: void 0, fn: call }
       );
     }
     return {