@stackframe/stack-shared 2.8.8 → 2.8.10

package/dist/utils/promises.js

@@ -1,412 +1,271 @@
-import { KnownError } from "..";
-import { StackAssertionError, captureError, concatStacktraces } from "./errors";
-import { DependenciesMap } from "./maps";
-import { Result } from "./results";
-import { generateUuid } from "./uuids";
-export function createPromise(callback) {
-    let status = "pending";
-    let valueOrReason = undefined;
-    let resolve = null;
-    let reject = null;
-    const promise = new Promise((res, rej) => {
-        resolve = (value) => {
-            if (status !== "pending")
-                return;
-            status = "fulfilled";
-            valueOrReason = value;
-            res(value);
-        };
-        reject = (reason) => {
-            if (status !== "pending")
-                return;
-            status = "rejected";
-            valueOrReason = reason;
-            rej(reason);
-        };
-    });
-    callback(resolve, reject);
-    return Object.assign(promise, {
-        status: status,
-        ...status === "fulfilled" ? { value: valueOrReason } : {},
-        ...status === "rejected" ? { reason: valueOrReason } : {},
-    });
-}
-import.meta.vitest?.test("createPromise", async ({ expect }) => {
-    // Test resolved promise
-    const resolvedPromise = createPromise((resolve) => {
-        resolve(42);
-    });
-    expect(resolvedPromise.status).toBe("fulfilled");
-    expect(resolvedPromise.value).toBe(42);
-    expect(await resolvedPromise).toBe(42);
-    // Test rejected promise
-    const error = new Error("Test error");
-    const rejectedPromise = createPromise((_, reject) => {
-        reject(error);
-    });
-    expect(rejectedPromise.status).toBe("rejected");
-    expect(rejectedPromise.reason).toBe(error);
-    await expect(rejectedPromise).rejects.toBe(error);
-    // Test pending promise
-    const pendingPromise = createPromise(() => {
-        // Do nothing, leave it pending
-    });
-    expect(pendingPromise.status).toBe("pending");
-    expect(pendingPromise.value).toBeUndefined();
-    expect(pendingPromise.reason).toBeUndefined();
-    // Test that resolving after already resolved does nothing
-    let resolveCount = 0;
-    const multiResolvePromise = createPromise((resolve) => {
-        resolve(1);
-        resolveCount++;
-        resolve(2);
-        resolveCount++;
-    });
-    expect(resolveCount).toBe(2); // Both resolve calls executed
-    expect(multiResolvePromise.status).toBe("fulfilled");
-    expect(multiResolvePromise.value).toBe(1); // Only first resolve took effect
-    expect(await multiResolvePromise).toBe(1);
-});
-let resolvedCache = null;
-/**
- * Like Promise.resolve(...), but also adds the status and value properties for use with React's `use` hook, and caches
- * the value so that invoking `resolved` twice returns the same promise.
- */
-export function resolved(value) {
-    resolvedCache ??= new DependenciesMap();
-    if (resolvedCache.has([value])) {
-        return resolvedCache.get([value]);
-    }
-    const res = Object.assign(Promise.resolve(value), {
-        status: "fulfilled",
-        value,
-    });
-    resolvedCache.set([value], res);
-    return res;
-}
-import.meta.vitest?.test("resolved", async ({ expect }) => {
-    // Test with primitive value
-    const promise1 = resolved(42);
-    expect(promise1.status).toBe("fulfilled");
-    // Need to use type assertion since value is only available when status is "fulfilled"
-    expect(promise1.value).toBe(42);
-    expect(await promise1).toBe(42);
-    // Test with object value
-    const obj = { test: true };
-    const promise2 = resolved(obj);
-    expect(promise2.status).toBe("fulfilled");
-    expect(promise2.value).toBe(obj);
-    expect(await promise2).toBe(obj);
-    // Test caching (same reference for same value)
-    const promise3 = resolved(42);
-    expect(promise3).toBe(promise1); // Same reference due to caching
-    // Test with different value (different reference)
-    const promise4 = resolved(43);
-    expect(promise4).not.toBe(promise1);
+"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/utils/promises.tsx
+var promises_exports = {};
+__export(promises_exports, {
+  createPromise: () => createPromise,
+  ignoreUnhandledRejection: () => ignoreUnhandledRejection,
+  neverResolve: () => neverResolve,
+  pending: () => pending,
+  rateLimited: () => rateLimited,
+  rejected: () => rejected,
+  resolved: () => resolved,
+  runAsynchronously: () => runAsynchronously,
+  runAsynchronouslyWithAlert: () => runAsynchronouslyWithAlert,
+  throttled: () => throttled,
+  timeout: () => timeout,
+  timeoutThrow: () => timeoutThrow,
+  wait: () => wait,
+  waitUntil: () => waitUntil
 });
-let rejectedCache = null;
-/**
- * Like Promise.reject(...), but also adds the status and value properties for use with React's `use` hook, and caches
- * the value so that invoking `rejected` twice returns the same promise.
- */
-export function rejected(reason) {
-    rejectedCache ??= new DependenciesMap();
-    if (rejectedCache.has([reason])) {
-        return rejectedCache.get([reason]);
-    }
-    const promise = Promise.reject(reason);
-    ignoreUnhandledRejection(promise);
-    const res = Object.assign(promise, {
-        status: "rejected",
-        reason: reason,
-    });
-    rejectedCache.set([reason], res);
-    return res;
+module.exports = __toCommonJS(promises_exports);
+var import__ = require("..");
+var import_errors = require("./errors");
+var import_maps = require("./maps");
+var import_results = require("./results");
+var import_uuids = require("./uuids");
+function createPromise(callback) {
+  let status = "pending";
+  let valueOrReason = void 0;
+  let resolve = null;
+  let reject = null;
+  const promise = new Promise((res, rej) => {
+    resolve = (value) => {
+      if (status !== "pending") return;
+      status = "fulfilled";
+      valueOrReason = value;
+      res(value);
+    };
+    reject = (reason) => {
+      if (status !== "pending") return;
+      status = "rejected";
+      valueOrReason = reason;
+      rej(reason);
+    };
+  });
+  callback(resolve, reject);
+  return Object.assign(promise, {
+    status,
+    ...status === "fulfilled" ? { value: valueOrReason } : {},
+    ...status === "rejected" ? { reason: valueOrReason } : {}
+  });
 }
-import.meta.vitest?.test("rejected", ({ expect }) => {
-    // Test with error object
-    const error = new Error("Test error");
-    const promise1 = rejected(error);
-    expect(promise1.status).toBe("rejected");
-    // Need to use type assertion since reason is only available when status is "rejected"
-    expect(promise1.reason).toBe(error);
-    // Test with string reason
-    const promise2 = rejected("error message");
-    expect(promise2.status).toBe("rejected");
-    expect(promise2.reason).toBe("error message");
-    // Test caching (same reference for same reason)
-    const promise3 = rejected(error);
-    expect(promise3).toBe(promise1); // Same reference due to caching
-    // Test with different reason (different reference)
-    const differentError = new Error("Different error");
-    const promise4 = rejected(differentError);
-    expect(promise4).not.toBe(promise1);
-    // Note: We're not using await expect(promise).rejects to avoid unhandled rejections
-});
-// We'll skip the rejection test for pending() since it's causing unhandled rejections
-// The function is already well tested through other tests like rejected() and createPromise()
-const neverResolvePromise = pending(new Promise(() => { }));
-export function neverResolve() {
-    return neverResolvePromise;
+var resolvedCache = null;
+function resolved(value) {
+  resolvedCache ??= new import_maps.DependenciesMap();
+  if (resolvedCache.has([value])) {
+    return resolvedCache.get([value]);
+  }
+  const res = Object.assign(Promise.resolve(value), {
+    status: "fulfilled",
+    value
+  });
+  resolvedCache.set([value], res);
+  return res;
 }
-import.meta.vitest?.test("neverResolve", ({ expect }) => {
-    const promise = neverResolve();
-    expect(promise.status).toBe("pending");
-    expect(promise.value).toBeUndefined();
-    expect(promise.reason).toBeUndefined();
-    // Test that multiple calls return the same promise
-    const promise2 = neverResolve();
-    expect(promise2).toBe(promise);
-});
-export function pending(promise, options = {}) {
-    const res = promise.then(value => {
-        res.status = "fulfilled";
-        res.value = value;
-        return value;
-    }, actualReason => {
-        res.status = "rejected";
-        res.reason = actualReason;
-        throw actualReason;
-    });
-    res.status = "pending";
-    return res;
+var rejectedCache = null;
+function rejected(reason) {
+  rejectedCache ??= new import_maps.DependenciesMap();
+  if (rejectedCache.has([reason])) {
+    return rejectedCache.get([reason]);
+  }
+  const promise = Promise.reject(reason);
+  ignoreUnhandledRejection(promise);
+  const res = Object.assign(promise, {
+    status: "rejected",
+    reason
+  });
+  rejectedCache.set([reason], res);
+  return res;
 }
-import.meta.vitest?.test("pending", async ({ expect }) => {
-    // Test with a promise that resolves
-    const resolvePromise = Promise.resolve(42);
-    const pendingPromise = pending(resolvePromise);
-    // Initially it should be pending
-    expect(pendingPromise.status).toBe("pending");
-    // After resolution, it should be fulfilled
-    await resolvePromise;
-    // Need to wait a tick for the then handler to execute
-    await new Promise(resolve => setTimeout(resolve, 0));
-    expect(pendingPromise.status).toBe("fulfilled");
-    expect(pendingPromise.value).toBe(42);
-    // For the rejection test, we'll use a separate test to avoid unhandled rejections
-});
-/**
- * Should be used to wrap Promises that are not immediately awaited, so they don't throw an unhandled promise rejection
- * error.
- *
- * Vercel kills serverless functions on unhandled promise rejection errors, so this is important.
- */
-export function ignoreUnhandledRejection(promise) {
-    promise.catch(() => { });
+var neverResolvePromise = pending(new Promise(() => {
+}));
+function neverResolve() {
+  return neverResolvePromise;
 }
-import.meta.vitest?.test("ignoreUnhandledRejection", async ({ expect }) => {
-    // Test with a promise that resolves
-    const resolvePromise = Promise.resolve(42);
-    ignoreUnhandledRejection(resolvePromise);
-    expect(await resolvePromise).toBe(42); // Should still resolve to the same value
-    // Test with a promise that rejects
-    // The promise should still reject, but the rejection is caught internally
-    // so it doesn't cause an unhandled rejection error
-    const error = new Error("Test error");
-    const rejectPromise = Promise.reject(error);
-    ignoreUnhandledRejection(rejectPromise);
-    await expect(rejectPromise).rejects.toBe(error);
-});
-export async function wait(ms) {
-    if (!Number.isFinite(ms) || ms < 0) {
-        throw new StackAssertionError(`wait() requires a non-negative integer number of milliseconds to wait. (found: ${ms}ms)`);
-    }
-    if (ms >= 2 ** 31) {
-        throw new StackAssertionError("The maximum timeout for wait() is 2147483647ms (2**31 - 1). (found: ${ms}ms)");
+function pending(promise, options = {}) {
+  const res = promise.then(
+    (value) => {
+      res.status = "fulfilled";
+      res.value = value;
+      return value;
+    },
+    (actualReason) => {
+      res.status = "rejected";
+      res.reason = actualReason;
+      throw actualReason;
     }
-    return await new Promise(resolve => setTimeout(resolve, ms));
+  );
+  res.status = "pending";
+  return res;
 }
-import.meta.vitest?.test("wait", async ({ expect }) => {
-    // Test with valid input
-    const start = Date.now();
-    await wait(10);
-    const elapsed = Date.now() - start;
-    expect(elapsed).toBeGreaterThanOrEqual(5); // Allow some flexibility in timing
-    // Test with zero
-    await expect(wait(0)).resolves.toBeUndefined();
-    // Test with negative number
-    await expect(wait(-10)).rejects.toThrow("wait() requires a non-negative integer");
-    // Test with non-finite number
-    await expect(wait(NaN)).rejects.toThrow("wait() requires a non-negative integer");
-    await expect(wait(Infinity)).rejects.toThrow("wait() requires a non-negative integer");
-    // Test with too large number
-    await expect(wait(2 ** 31)).rejects.toThrow("The maximum timeout for wait()");
-});
-export async function waitUntil(date) {
-    return await wait(date.getTime() - Date.now());
+function ignoreUnhandledRejection(promise) {
+  promise.catch(() => {
+  });
 }
-import.meta.vitest?.test("waitUntil", async ({ expect }) => {
-    // Test with future date
-    const futureDate = new Date(Date.now() + 10);
-    const start = Date.now();
-    await waitUntil(futureDate);
-    const elapsed = Date.now() - start;
-    expect(elapsed).toBeGreaterThanOrEqual(5); // Allow some flexibility in timing
-    // Test with past date - this will throw because wait() requires non-negative time
-    // We need to verify it throws the correct error
-    try {
-        await waitUntil(new Date(Date.now() - 1000));
-        expect.fail("Should have thrown an error");
-    }
-    catch (error) {
-        expect(error).toBeInstanceOf(StackAssertionError);
-        expect(error.message).toContain("wait() requires a non-negative integer");
-    }
-});
-export function runAsynchronouslyWithAlert(...args) {
-    return runAsynchronously(args[0], {
-        ...args[1],
-        onError: error => {
-            if (error instanceof KnownError && process.env.NODE_ENV.includes("production")) {
-                alert(error.message);
-            }
-            else {
-                alert(`An unhandled error occurred. Please ${process.env.NODE_ENV === "development" ? `check the browser console for the full error.` : "report this to the developer."}\n\n${error}`);
-            }
-            args[1]?.onError?.(error);
-        },
-    }, ...args.slice(2));
+async function wait(ms) {
+  if (!Number.isFinite(ms) || ms < 0) {
+    throw new import_errors.StackAssertionError(`wait() requires a non-negative integer number of milliseconds to wait. (found: ${ms}ms)`);
+  }
+  if (ms >= 2 ** 31) {
+    throw new import_errors.StackAssertionError("The maximum timeout for wait() is 2147483647ms (2**31 - 1). (found: ${ms}ms)");
+  }
+  return await new Promise((resolve) => setTimeout(resolve, ms));
 }
-import.meta.vitest?.test("runAsynchronouslyWithAlert", ({ expect }) => {
-    // Simple test to verify the function calls runAsynchronously
-    // We can't easily test the alert functionality without mocking
-    const testFn = () => Promise.resolve("test");
-    const testOptions = { noErrorLogging: true };
-    // Just verify it doesn't throw
-    expect(() => runAsynchronouslyWithAlert(testFn, testOptions)).not.toThrow();
-    // We can't easily test the error handling without mocking, so we'll
-    // just verify the function exists and can be called
-    expect(typeof runAsynchronouslyWithAlert).toBe("function");
-});
-export function runAsynchronously(promiseOrFunc, options = {}) {
-    if (typeof promiseOrFunc === "function") {
-        promiseOrFunc = promiseOrFunc();
-    }
-    const duringError = new Error();
-    promiseOrFunc?.catch(error => {
-        options.onError?.(error);
-        const newError = new StackAssertionError("Uncaught error in asynchronous function: " + error.toString(), { cause: error });
-        concatStacktraces(newError, duringError);
-        if (!options.noErrorLogging) {
-            captureError("runAsynchronously", newError);
+async function waitUntil(date) {
+  return await wait(date.getTime() - Date.now());
+}
+function runAsynchronouslyWithAlert(...args) {
+  return runAsynchronously(
+    args[0],
+    {
+      ...args[1],
+      onError: (error) => {
+        if (error instanceof import__.KnownError && typeof process !== "undefined" && process.env.NODE_ENV?.includes("production")) {
+          alert(error.message);
+        } else {
+          alert(`An unhandled error occurred. Please ${process.env.NODE_ENV === "development" ? `check the browser console for the full error.` : "report this to the developer."}
+
+${error}`);
         }
-    });
+        args[1]?.onError?.(error);
+      }
+    },
+    ...args.slice(2)
+  );
 }
-import.meta.vitest?.test("runAsynchronously", ({ expect }) => {
-    // Simple test to verify the function exists and can be called
-    const testFn = () => Promise.resolve("test");
-    // Just verify it doesn't throw
-    expect(() => runAsynchronously(testFn)).not.toThrow();
-    expect(() => runAsynchronously(Promise.resolve("test"))).not.toThrow();
-    expect(() => runAsynchronously(undefined)).not.toThrow();
-    // We can't easily test the error handling without mocking, so we'll
-    // just verify the function exists and can be called with options
-    expect(() => runAsynchronously(testFn, { noErrorLogging: true })).not.toThrow();
-    expect(() => runAsynchronously(testFn, { onError: () => { } })).not.toThrow();
-});
-class TimeoutError extends Error {
-    constructor(ms) {
-        super(`Timeout after ${ms}ms`);
-        this.ms = ms;
-        this.name = "TimeoutError";
+function runAsynchronously(promiseOrFunc, options = {}) {
+  if (typeof promiseOrFunc === "function") {
+    promiseOrFunc = promiseOrFunc();
+  }
+  const duringError = new Error();
+  promiseOrFunc?.catch((error) => {
+    options.onError?.(error);
+    const newError = new import_errors.StackAssertionError(
+      "Uncaught error in asynchronous function: " + error.toString(),
+      { cause: error }
+    );
+    (0, import_errors.concatStacktraces)(newError, duringError);
+    if (!options.noErrorLogging) {
+      (0, import_errors.captureError)("runAsynchronously", newError);
     }
+  });
 }
-export async function timeout(promise, ms) {
-    return await Promise.race([
-        promise.then(value => Result.ok(value)),
-        wait(ms).then(() => Result.error(new TimeoutError(ms))),
-    ]);
+var TimeoutError = class extends Error {
+  constructor(ms) {
+    super(`Timeout after ${ms}ms`);
+    this.ms = ms;
+    this.name = "TimeoutError";
+  }
+};
+async function timeout(promise, ms) {
+  return await Promise.race([
+    promise.then((value) => import_results.Result.ok(value)),
+    wait(ms).then(() => import_results.Result.error(new TimeoutError(ms)))
+  ]);
 }
-import.meta.vitest?.test("timeout", async ({ expect }) => {
-    // Test with a promise that resolves quickly
-    const fastPromise = Promise.resolve(42);
-    const fastResult = await timeout(fastPromise, 100);
-    expect(fastResult.status).toBe("ok");
-    if (fastResult.status === "ok") {
-        expect(fastResult.data).toBe(42);
+async function timeoutThrow(promise, ms) {
+  return import_results.Result.orThrow(await timeout(promise, ms));
+}
+function rateLimited(func, options) {
+  let waitUntil2 = performance.now();
+  let queue = [];
+  let addedToQueueCallbacks = /* @__PURE__ */ new Map();
+  const next = async () => {
+    while (true) {
+      if (waitUntil2 > performance.now()) {
+        await wait(Math.max(1, waitUntil2 - performance.now() + 1));
+      } else if (queue.length === 0) {
+        const uuid = (0, import_uuids.generateUuid)();
+        await new Promise((resolve) => {
+          addedToQueueCallbacks.set(uuid, resolve);
+        });
+        addedToQueueCallbacks.delete(uuid);
+      } else {
+        break;
+      }
     }
-    // Test with a promise that takes longer than the timeout
-    const slowPromise = new Promise(resolve => setTimeout(() => resolve("too late"), 50));
-    const slowResult = await timeout(slowPromise, 10);
-    expect(slowResult.status).toBe("error");
-    if (slowResult.status === "error") {
-        expect(slowResult.error).toBeInstanceOf(TimeoutError);
-        expect(slowResult.error.ms).toBe(10);
+    const nextFuncs = options.batchCalls ? queue.splice(0, queue.length) : [queue.shift()];
+    const start = performance.now();
+    const value = await import_results.Result.fromPromise(func());
+    const end = performance.now();
+    waitUntil2 = Math.max(
+      waitUntil2,
+      start + (options.throttleMs ?? 0),
+      end + (options.gapMs ?? 0)
+    );
+    for (const nextFunc of nextFuncs) {
+      if (value.status === "ok") {
+        nextFunc[0](value.data);
+      } else {
+        nextFunc[1](value.error);
+      }
     }
-});
-export async function timeoutThrow(promise, ms) {
-    return Result.orThrow(await timeout(promise, ms));
-}
-import.meta.vitest?.test("timeoutThrow", async ({ expect }) => {
-    // Test with a promise that resolves quickly
-    const fastPromise = Promise.resolve(42);
-    const fastResult = await timeoutThrow(fastPromise, 100);
-    expect(fastResult).toBe(42);
-    // Test with a promise that takes longer than the timeout
-    const slowPromise = new Promise(resolve => setTimeout(() => resolve("too late"), 50));
-    await expect(timeoutThrow(slowPromise, 10)).rejects.toThrow("Timeout after 10ms");
-    await expect(timeoutThrow(slowPromise, 10)).rejects.toBeInstanceOf(TimeoutError);
-});
-export function rateLimited(func, options) {
-    let waitUntil = performance.now();
-    let queue = [];
-    let addedToQueueCallbacks = new Map;
-    const next = async () => {
-        while (true) {
-            if (waitUntil > performance.now()) {
-                await wait(Math.max(1, waitUntil - performance.now() + 1));
-            }
-            else if (queue.length === 0) {
-                const uuid = generateUuid();
-                await new Promise(resolve => {
-                    addedToQueueCallbacks.set(uuid, resolve);
-                });
-                addedToQueueCallbacks.delete(uuid);
-            }
-            else {
-                break;
-            }
-        }
-        const nextFuncs = options.batchCalls ? queue.splice(0, queue.length) : [queue.shift()];
-        const start = performance.now();
-        const value = await Result.fromPromise(func());
-        const end = performance.now();
-        waitUntil = Math.max(waitUntil, start + (options.throttleMs ?? 0), end + (options.gapMs ?? 0));
-        for (const nextFunc of nextFuncs) {
-            if (value.status === "ok") {
-                nextFunc[0](value.data);
-            }
-            else {
-                nextFunc[1](value.error);
-            }
-        }
-    };
-    runAsynchronously(async () => {
-        while (true) {
-            await next();
-        }
+  };
+  runAsynchronously(async () => {
+    while (true) {
+      await next();
+    }
+  });
+  return () => {
+    return new Promise((resolve, reject) => {
+      waitUntil2 = Math.max(
+        waitUntil2,
+        performance.now() + (options.debounceMs ?? 0)
+      );
+      queue.push([resolve, reject]);
+      addedToQueueCallbacks.forEach((cb) => cb());
     });
-    return () => {
-        return new Promise((resolve, reject) => {
-            waitUntil = Math.max(waitUntil, performance.now() + (options.debounceMs ?? 0));
-            queue.push([resolve, reject]);
-            addedToQueueCallbacks.forEach(cb => cb());
-        });
-    };
+  };
 }
-export function throttled(func, delayMs) {
-    let timeout = null;
-    let nextAvailable = null;
-    return async (...args) => {
-        while (nextAvailable !== null) {
-            await nextAvailable;
-        }
-        nextAvailable = new Promise(resolve => {
-            timeout = setTimeout(() => {
-                nextAvailable = null;
-                resolve(func(...args));
-            }, delayMs);
-        });
-        return await nextAvailable;
-    };
+function throttled(func, delayMs) {
+  let timeout2 = null;
+  let nextAvailable = null;
+  return async (...args) => {
+    while (nextAvailable !== null) {
+      await nextAvailable;
+    }
+    nextAvailable = new Promise((resolve) => {
+      timeout2 = setTimeout(() => {
+        nextAvailable = null;
+        resolve(func(...args));
+      }, delayMs);
+    });
+    return await nextAvailable;
+  };
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPromise,
+  ignoreUnhandledRejection,
+  neverResolve,
+  pending,
+  rateLimited,
+  rejected,
+  resolved,
+  runAsynchronously,
+  runAsynchronouslyWithAlert,
+  throttled,
+  timeout,
+  timeoutThrow,
+  wait,
+  waitUntil
+});
+//# sourceMappingURL=promises.js.map