@socketsecurity/lib 5.28.0 → 6.0.0

package/dist/promises/_internal.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file Private internals for `promises/*` modules — the lazy
+ *   `node:timers/promises` accessor + the shared abort signal. Underscore
+ *   prefix excludes from public exports.
+ */
+export declare const abortSignal: AbortSignal;
+/**
+ * Get the timers/promises module. Uses lazy loading to avoid Webpack bundling
+ * issues.
+ *
+ * @private
+ *
+ * @returns The Node.js timers/promises module
+ */
+export declare function getTimers(): typeof import('node:timers/promises');

package/dist/promises/_internal.js

@@ -0,0 +1,41 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"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);
+var internal_exports = {};
+__export(internal_exports, {
+  abortSignal: () => abortSignal,
+  getTimers: () => getTimers
+});
+module.exports = __toCommonJS(internal_exports);
+var import_abort = require("../process/abort");
+const abortSignal = (0, import_abort.getAbortSignal)();
+let _timers;
+// @__NO_SIDE_EFFECTS__
+function getTimers() {
+  if (_timers === void 0) {
+    _timers = require("node:timers/promises");
+  }
+  return _timers;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  abortSignal,
+  getTimers
+});

package/dist/promises/iterate.d.ts

@@ -0,0 +1,190 @@
+/**
+ * @file Concurrency-controlled async iteration helpers: `pEach`, `pEachChunk`,
+ *   `pFilter`, `pFilterChunk`. All four use `pRetry` internally so each item's
+ *   callback can be retried independently without affecting siblings. The chunk
+ *   vs. concurrency distinction:
+ *
+ *   - `pEach` / `pFilter` use a **concurrency limit**: split the input into
+ *     chunks of size `concurrency`, process each chunk in parallel, then move
+ *     on to the next chunk.
+ *   - `pEachChunk` / `pFilterChunk` operate on **pre-chunked input**: the caller
+ *     decides chunk boundaries (e.g., bulk-insert batch size, pagination page
+ *     size). Useful when chunk size != concurrency cap.
+ */
+import type { IterationOptions, RetryOptions } from './types';
+/**
+ * Execute an async function for each array element with concurrency control.
+ *
+ * Processes array items in parallel batches (chunks) with configurable
+ * concurrency. Each item's callback can be retried independently on failure.
+ * Similar to `Promise.all(array.map(fn))` but with controlled parallelism.
+ *
+ * @example
+ *   // Process items serially (concurrency: 1)
+ *   await pEach(urls, async url => {
+ *     await fetch(url)
+ *   })
+ *
+ * @example
+ *   // Process 5 items at a time
+ *   await pEach(
+ *     files,
+ *     async file => {
+ *       await processFile(file)
+ *     },
+ *     5,
+ *   )
+ *
+ * @example
+ *   // With retries and cancellation
+ *   const controller = new AbortController()
+ *   await pEach(
+ *     tasks,
+ *     async task => {
+ *       await executeTask(task)
+ *     },
+ *     {
+ *       concurrency: 3,
+ *       retries: 2,
+ *       signal: controller.signal,
+ *     },
+ *   )
+ *
+ * @template T - The type of array elements.
+ *
+ * @param array - The array to iterate over.
+ * @param callbackFn - Async function to execute for each item.
+ * @param options - Concurrency as number, or full iteration options, or
+ *   undefined.
+ *
+ * @returns Promise that resolves when all items are processed
+ */
+export declare function pEach<T>(array: T[], callbackFn: (item: T) => Promise<unknown>, options?: number | IterationOptions | undefined): Promise<void>;
+/**
+ * Process array in chunks with an async callback.
+ *
+ * Divides the array into fixed-size chunks and processes each chunk
+ * sequentially with the callback. Useful for batch operations like bulk
+ * database inserts or API calls with payload size limits.
+ *
+ * @example
+ *   // Insert records in batches of 100
+ *   await pEachChunk(
+ *     records,
+ *     async chunk => {
+ *       await db.batchInsert(chunk)
+ *     },
+ *     { chunkSize: 100 },
+ *   )
+ *
+ * @example
+ *   // Upload files in batches with retries
+ *   await pEachChunk(
+ *     files,
+ *     async batch => {
+ *       await uploadBatch(batch)
+ *     },
+ *     {
+ *       chunkSize: 50,
+ *       retries: 3,
+ *       baseDelayMs: 1000,
+ *     },
+ *   )
+ *
+ * @example
+ *   // Process with cancellation support
+ *   const controller = new AbortController()
+ *   await pEachChunk(
+ *     items,
+ *     async chunk => {
+ *       await processChunk(chunk)
+ *     },
+ *     {
+ *       chunkSize: 25,
+ *       signal: controller.signal,
+ *     },
+ *   )
+ *
+ * @template T - The type of array elements.
+ *
+ * @param array - The array to process in chunks.
+ * @param callbackFn - Async function to execute for each chunk.
+ * @param options - Chunk size and retry options.
+ *
+ * @returns Promise that resolves when all chunks are processed
+ */
+export declare function pEachChunk<T>(array: T[], callbackFn: (chunk: T[]) => Promise<unknown>, options?: (RetryOptions & {
+    chunkSize?: number | undefined;
+}) | undefined): Promise<void>;
+/**
+ * Filter an array asynchronously with concurrency control.
+ *
+ * Tests each element with an async predicate function, processing items in
+ * parallel batches. Returns a new array with only items that pass the test.
+ * Similar to `array.filter()` but for async predicates with controlled
+ * concurrency.
+ *
+ * @example
+ *   // Filter serially
+ *   const activeUsers = await pFilter(users, async user => {
+ *     return await isUserActive(user.id)
+ *   })
+ *
+ * @example
+ *   // Filter with concurrency
+ *   const validFiles = await pFilter(
+ *     filePaths,
+ *     async path => {
+ *       return existsSync(path)
+ *     },
+ *     10,
+ *   )
+ *
+ * @example
+ *   // With retries for flaky checks
+ *   const reachable = await pFilter(
+ *     endpoints,
+ *     async url => {
+ *       const response = await fetch(url)
+ *       return response.ok
+ *     },
+ *     {
+ *       concurrency: 5,
+ *       retries: 2,
+ *     },
+ *   )
+ *
+ * @template T - The type of array elements.
+ *
+ * @param array - The array to filter.
+ * @param callbackFn - Async predicate function returning true to keep item.
+ * @param options - Concurrency as number, or full iteration options, or
+ *   undefined.
+ *
+ * @returns Promise resolving to filtered array
+ */
+export declare function pFilter<T>(array: T[], callbackFn: (item: T) => Promise<boolean>, options?: number | IterationOptions | undefined): Promise<T[]>;
+/**
+ * Filter chunked arrays with an async predicate.
+ *
+ * Internal helper for `pFilter`. Processes pre-chunked arrays, applying the
+ * predicate to each element within each chunk with retry support.
+ *
+ * @example
+ *   const chunks = [
+ *     [1, 2],
+ *     [3, 4],
+ *     [5, 6],
+ *   ]
+ *   const filtered = await pFilterChunk(chunks, async n => n % 2 === 0)
+ *   // => [[2], [4], [6]]
+ *
+ * @template T - The type of array elements.
+ *
+ * @param chunks - Pre-chunked array (array of arrays)
+ * @param callbackFn - Async predicate function.
+ * @param options - Retry count as number, or full retry options, or undefined.
+ *
+ * @returns Promise resolving to array of filtered chunks
+ */
+export declare function pFilterChunk<T>(chunks: T[][], callbackFn: (value: T) => Promise<boolean>, options?: number | RetryOptions | undefined): Promise<T[][]>;

package/dist/promises/iterate.js

@@ -0,0 +1,111 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"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);
+var iterate_exports = {};
+__export(iterate_exports, {
+  pEach: () => pEach,
+  pEachChunk: () => pEachChunk,
+  pFilter: () => pFilter,
+  pFilterChunk: () => pFilterChunk
+});
+module.exports = __toCommonJS(iterate_exports);
+var import_chunk = require("../arrays/chunk");
+var import_promise = require("../primordials/promise");
+var import_options = require("./options");
+var import_retry = require("./retry");
+// @__NO_SIDE_EFFECTS__
+async function pEach(array, callbackFn, options) {
+  const iterOpts = (0, import_options.normalizeIterationOptions)(options);
+  const { concurrency, retries, signal } = iterOpts;
+  const chunks = (0, import_chunk.arrayChunk)(array, concurrency);
+  for (const chunk of chunks) {
+    if (signal?.aborted) {
+      return;
+    }
+    await (0, import_promise.PromiseAllSettled)(
+      chunk.map(
+        (item) => (0, import_retry.pRetry)((...args) => callbackFn(args[0]), {
+          ...retries,
+          args: [item],
+          signal
+        })
+      )
+    );
+  }
+}
+// @__NO_SIDE_EFFECTS__
+async function pEachChunk(array, callbackFn, options) {
+  const { chunkSize = 100, ...retryOpts } = options || {};
+  const chunks = (0, import_chunk.arrayChunk)(array, chunkSize);
+  const normalizedRetryOpts = (0, import_options.normalizeRetryOptions)(retryOpts);
+  const { signal } = normalizedRetryOpts;
+  for (const chunk of chunks) {
+    if (signal?.aborted) {
+      return;
+    }
+    await (0, import_retry.pRetry)((...args) => callbackFn(args[0]), {
+      ...normalizedRetryOpts,
+      args: [chunk]
+    });
+  }
+}
+// @__NO_SIDE_EFFECTS__
+async function pFilter(array, callbackFn, options) {
+  const iterOpts = (0, import_options.normalizeIterationOptions)(options);
+  return (await /* @__PURE__ */ pFilterChunk(
+    (0, import_chunk.arrayChunk)(array, iterOpts.concurrency),
+    callbackFn,
+    iterOpts.retries
+  )).flat();
+}
+// @__NO_SIDE_EFFECTS__
+async function pFilterChunk(chunks, callbackFn, options) {
+  const retryOpts = (0, import_options.normalizeRetryOptions)(options);
+  const { signal } = retryOpts;
+  const { length } = chunks;
+  const filteredChunks = Array(length);
+  for (let i = 0; i < length; i += 1) {
+    if (signal?.aborted) {
+      filteredChunks[i] = [];
+    } else {
+      const chunk = chunks[i];
+      const settled = await (0, import_promise.PromiseAllSettled)(
+        chunk.map(
+          (value) => (0, import_retry.pRetry)((...args) => callbackFn(args[0]), {
+            ...retryOpts,
+            args: [value]
+          })
+        )
+      );
+      const predicateResults = settled.map(
+        (r) => r.status === "fulfilled" ? r.value : false
+      );
+      filteredChunks[i] = chunk.filter((_v, i2) => predicateResults[i2]);
+    }
+  }
+  return filteredChunks;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pEach,
+  pEachChunk,
+  pFilter,
+  pFilterChunk
+});

package/dist/promises/options.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @file Option-shape normalizers for the iteration / retry helpers. Three free
+ *   functions — kept together because they're a tiny cluster of pure transforms
+ *   that callers cycle through: `resolveRetryOptions` (number-shorthand →
+ *   minimal object) → `normalizeRetryOptions` (defaults + signal binding) →
+ *   `normalizeIterationOptions` (concurrency + retries combined).
+ */
+import type { IterationOptions, RetryOptions } from './types';
+/**
+ * Normalize options for iteration functions.
+ *
+ * Converts various option formats into a consistent structure with defaults
+ * applied. Handles number shorthand for concurrency and ensures minimum
+ * values.
+ *
+ * @example
+ *   // Number shorthand for concurrency
+ *   normalizeIterationOptions(5)
+ *   // => { concurrency: 5, retries: {...}, signal: AbortSignal }
+ *
+ * @example
+ *   // Full options
+ *   normalizeIterationOptions({ concurrency: 3, retries: 2 })
+ *   // => { concurrency: 3, retries: {...}, signal: AbortSignal }
+ *
+ * @param options - Concurrency as number, or full options object, or undefined.
+ *
+ * @returns Normalized options with concurrency, retries, and signal
+ */
+export declare function normalizeIterationOptions(options?: number | IterationOptions | undefined): {
+    concurrency: number;
+    retries: RetryOptions;
+    signal: AbortSignal;
+};
+/**
+ * Normalize options for retry functionality.
+ *
+ * Converts various retry option formats into a complete configuration with all
+ * defaults. Handles legacy property names (`factor`, `minTimeout`,
+ * `maxTimeout`) and merges them with modern equivalents.
+ *
+ * @example
+ *   // Number shorthand
+ *   normalizeRetryOptions(3)
+ *   // => { retries: 3, baseDelayMs: 200, backoffFactor: 2, ... }
+ *
+ * @example
+ *   // Full options with defaults filled in
+ *   normalizeRetryOptions({ retries: 5, baseDelayMs: 500 })
+ *   // => { retries: 5, baseDelayMs: 500, backoffFactor: 2, jitter: true, ... }
+ *
+ * @param options - Retry count as number, or full options object, or undefined.
+ *
+ * @returns Normalized retry options with all properties set
+ */
+export declare function normalizeRetryOptions(options?: number | RetryOptions | undefined): RetryOptions;
+/**
+ * Resolve retry options from various input formats.
+ *
+ * Converts shorthand and partial options into a base configuration that can be
+ * further normalized. This is an internal helper for option processing.
+ *
+ * @example
+ *   resolveRetryOptions(3)
+ *   // => { retries: 3, minTimeout: 200, maxTimeout: 10000, factor: 2 }
+ *
+ * @example
+ *   resolveRetryOptions({ retries: 5, maxTimeout: 5000 })
+ *   // => { retries: 5, minTimeout: 200, maxTimeout: 5000, factor: 2 }
+ *
+ * @param options - Retry count as number, or partial options object, or
+ *   undefined.
+ *
+ * @returns Resolved retry options with defaults for basic properties
+ */
+export declare function resolveRetryOptions(options?: number | RetryOptions | undefined): RetryOptions;

package/dist/promises/options.js

@@ -0,0 +1,108 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"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);
+var options_exports = {};
+__export(options_exports, {
+  normalizeIterationOptions: () => normalizeIterationOptions,
+  normalizeRetryOptions: () => normalizeRetryOptions,
+  resolveRetryOptions: () => resolveRetryOptions
+});
+module.exports = __toCommonJS(options_exports);
+var import_math = require("../primordials/math");
+var import_internal = require("./_internal");
+// @__NO_SIDE_EFFECTS__
+function normalizeIterationOptions(options) {
+  const opts = typeof options === "number" ? { concurrency: options } : options;
+  const {
+    // The number of concurrent executions performed at one time.
+    concurrency = 1,
+    // Retries as a number or options object.
+    retries,
+    // AbortSignal used to support cancellation.
+    signal = import_internal.abortSignal
+  } = { __proto__: null, ...opts };
+  const normalizedConcurrency = (0, import_math.MathMax)(1, concurrency);
+  const retryOpts = /* @__PURE__ */ resolveRetryOptions(retries);
+  return {
+    __proto__: null,
+    concurrency: normalizedConcurrency,
+    retries: /* @__PURE__ */ normalizeRetryOptions({ signal, ...retryOpts }),
+    signal
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function normalizeRetryOptions(options) {
+  const resolved = /* @__PURE__ */ resolveRetryOptions(options);
+  const {
+    // Arguments to pass to the callback function.
+    args = [],
+    // Multiplier for exponential backoff (e.g., 2 doubles delay each retry).
+    backoffFactor = 2,
+    // Initial delay before the first retry (in milliseconds).
+    baseDelayMs = 200,
+    // Whether to apply randomness to spread out retries.
+    jitter = true,
+    // Upper limit for any backoff delay (in milliseconds).
+    maxDelayMs = 1e4,
+    // Optional callback invoked on each retry attempt:
+    // (attempt: number, error: unknown, delay: number) => void
+    onRetry,
+    // Whether onRetry can cancel retries by returning `false`.
+    onRetryCancelOnFalse = false,
+    // Whether onRetry will rethrow errors.
+    onRetryRethrow = false,
+    // Number of retry attempts (0 = no retries, only initial attempt).
+    retries = 0,
+    // AbortSignal used to support cancellation.
+    signal = import_internal.abortSignal
+  } = resolved;
+  return {
+    args,
+    backoffFactor,
+    baseDelayMs,
+    jitter,
+    maxDelayMs,
+    onRetry,
+    onRetryCancelOnFalse,
+    onRetryRethrow,
+    retries,
+    signal
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function resolveRetryOptions(options) {
+  const defaults = {
+    __proto__: null,
+    retries: 0,
+    baseDelayMs: 200,
+    maxDelayMs: 1e4,
+    backoffFactor: 2
+  };
+  if (typeof options === "number") {
+    return { ...defaults, retries: options };
+  }
+  return options ? { ...defaults, ...options } : defaults;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  normalizeIterationOptions,
+  normalizeRetryOptions,
+  resolveRetryOptions
+});

package/dist/promises/resolvers.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @file ECMA-262 standalone async helpers — `withResolvers`
+ *   (Promise.withResolvers) and `fromAsync` (Array.fromAsync). Both prefer the
+ *   captured primordial when present, with a spec-equivalent fallback for older
+ *   runtimes. Why this lives separate from `retry.ts` / `iterate.ts`: these are
+ *   direct mirrors of standardized JS APIs, not Socket-specific helpers. They
+ *   have no retry / concurrency surface to share with the rest of the module.
+ */
+import type { PromiseWithResolvers } from './types';
+/**
+ * Drain an async iterable into an array, per [TC39
+ * Array.fromAsync](https://tc39.es/proposal-array-from-async/).
+ *
+ * Uses the `ArrayFromAsync` primordial (already bound) when available (Node
+ * 22+; V8 ≥ 12.0); otherwise falls back to a `for await…of` + push loop.
+ *
+ * Use this instead of the manual `const out = []; for await (const x of iter)
+ * out.push(x); return out` dance when collecting an async iterator's values.
+ *
+ * Like the native, this only handles the unary form (no `mapFn` / `thisArg`
+ * overload).
+ *
+ * @example
+ *   ;```typescript
+ *   import { glob } from 'node:fs/promises'
+ *   const files = await fromAsync(glob('**\/*.ts', { cwd: '/tmp/proj' }))
+ *   ```
+ */
+export declare const fromAsync: <T>(source: AsyncIterable<T> | Iterable<T | PromiseLike<T>>) => Promise<T[]>;
+/**
+ * Create a pending promise together with its `resolve` and `reject` handles as
+ * first-class values, per [ECMA-262
+ * §27.2.4.9](https://tc39.es/ecma262/#sec-promise.withResolvers).
+ *
+ * Uses the `PromiseWithResolvers` primordial (already bound) when available
+ * (Node 20.12+ / 21+ / 22+; V8 ≥ 12.0); otherwise falls back to a
+ * spec-equivalent `new Promise(executor)` that captures the handles via
+ * closure. The returned object always has own data properties `promise`,
+ * `resolve`, `reject` on `Object.prototype` — writable, enumerable, and
+ * configurable — matching the spec's `CreateDataPropertyOrThrow` steps.
+ *
+ * Use this instead of the manual `let resolve; const p = new Promise(r => {
+ * resolve = r })` dance for deferred-resolution patterns (event-driven bridges,
+ * adapter layers, handshake signaling) where the settle path lives outside the
+ * executor.
+ *
+ * @example
+ *   ;```typescript
+ *   const { promise, resolve, reject } = withResolvers<string>()
+ *   emitter.once('ready', () => resolve('ok'))
+ *   emitter.once('error', err => reject(err))
+ *   const result = await promise
+ *   ```
+ */
+export declare const withResolvers: <T>() => PromiseWithResolvers<T>;

package/dist/promises/resolvers.js

@@ -0,0 +1,49 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"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);
+var resolvers_exports = {};
+__export(resolvers_exports, {
+  fromAsync: () => fromAsync,
+  withResolvers: () => withResolvers
+});
+module.exports = __toCommonJS(resolvers_exports);
+var import_array = require("../primordials/array");
+var import_promise = require("../primordials/promise");
+const fromAsync = import_array.ArrayFromAsync !== void 0 ? import_array.ArrayFromAsync : async (source) => {
+  const out = [];
+  for await (const item of source) {
+    out.push(item);
+  }
+  return out;
+};
+const withResolvers = import_promise.PromiseWithResolvers !== void 0 ? import_promise.PromiseWithResolvers : () => {
+  let resolve;
+  let reject;
+  const promise = new import_promise.PromiseCtor((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fromAsync,
+  withResolvers
+});