@stackframe/stack-shared 2.8.8 → 2.8.11

package/dist/utils/react.js

@@ -1,109 +1,77 @@
-import React from "react";
-import { isBrowserLike } from "./env";
-import { neverResolve } from "./promises";
-import { deindent } from "./strings";
-export function forwardRefIfNeeded(render) {
-    // TODO: when we drop support for react 18, remove this
-    const version = React.version;
-    const major = parseInt(version.split(".")[0]);
-    if (major < 19) {
-        return React.forwardRef(render);
-    }
-    else {
-        return ((props) => render(props, props.ref));
-    }
-}
-import.meta.vitest?.test("forwardRefIfNeeded", ({ expect }) => {
-    // Mock React.version and React.forwardRef
-    const originalVersion = React.version;
-    const originalForwardRef = React.forwardRef;
-    try {
-        // Test with React version < 19
-        Object.defineProperty(React, 'version', { value: '18.2.0', writable: true });
-        // Create a render function
-        const renderFn = (props, ref) => null;
-        // Call forwardRefIfNeeded
-        const result = forwardRefIfNeeded(renderFn);
-        // Verify the function returns something
-        expect(result).toBeDefined();
-        // Test with React version >= 19
-        Object.defineProperty(React, 'version', { value: '19.0.0', writable: true });
-        // Call forwardRefIfNeeded again with React 19
-        const result19 = forwardRefIfNeeded(renderFn);
-        // Verify the function returns something
-        expect(result19).toBeDefined();
-    }
-    finally {
-        // Restore original values
-        Object.defineProperty(React, 'version', { value: originalVersion });
-        React.forwardRef = originalForwardRef;
-    }
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/react.tsx
+var react_exports = {};
+__export(react_exports, {
+  NoSuspenseBoundaryError: () => NoSuspenseBoundaryError,
+  forwardRefIfNeeded: () => forwardRefIfNeeded,
+  getNodeText: () => getNodeText,
+  suspend: () => suspend,
+  suspendIfSsr: () => suspendIfSsr
 });
-export function getNodeText(node) {
-    if (["number", "string"].includes(typeof node)) {
-        return `${node}`;
-    }
-    if (!node) {
-        return "";
-    }
-    if (Array.isArray(node)) {
-        return node.map(getNodeText).join("");
-    }
-    if (typeof node === "object" && "props" in node) {
-        return getNodeText(node.props.children);
-    }
-    throw new Error(`Unknown node type: ${typeof node}`);
+module.exports = __toCommonJS(react_exports);
+var import_react = __toESM(require("react"), 1);
+var import_env = require("./env");
+var import_promises = require("./promises");
+var import_strings = require("./strings");
+function forwardRefIfNeeded(render) {
+  const version = import_react.default.version;
+  const major = parseInt(version.split(".")[0]);
+  if (major < 19) {
+    return import_react.default.forwardRef(render);
+  } else {
+    return (props) => render(props, props.ref);
+  }
 }
-import.meta.vitest?.test("getNodeText", ({ expect }) => {
-    // Test with string
-    expect(getNodeText("hello")).toBe("hello");
-    // Test with number
-    expect(getNodeText(42)).toBe("42");
-    // Test with null/undefined
-    expect(getNodeText(null)).toBe("");
-    expect(getNodeText(undefined)).toBe("");
-    // Test with array
-    expect(getNodeText(["hello", " ", "world"])).toBe("hello world");
-    expect(getNodeText([1, 2, 3])).toBe("123");
-    // Test with mixed array
-    expect(getNodeText(["hello", 42, null])).toBe("hello42");
-    // Test with React element (mocked)
-    const mockElement = {
-        props: {
-            children: "child text"
-        }
-    };
-    expect(getNodeText(mockElement)).toBe("child text");
-    // Test with nested React elements
-    const nestedElement = {
-        props: {
-            children: {
-                props: {
-                    children: "nested text"
-                }
-            }
-        }
-    };
-    expect(getNodeText(nestedElement)).toBe("nested text");
-    // Test with array of React elements
-    const arrayOfElements = [
-        { props: { children: "first" } },
-        { props: { children: "second" } }
-    ];
-    expect(getNodeText(arrayOfElements)).toBe("firstsecond");
-});
-/**
- * Suspends the currently rendered component indefinitely. Will not unsuspend unless the component rerenders.
- *
- * You can use this to translate older query- or AsyncResult-based code to new the Suspense system, for example: `if (query.isLoading) suspend();`
- */
-export function suspend() {
-    React.use(neverResolve());
-    throw new Error("Somehow a Promise that never resolves was resolved?");
+function getNodeText(node) {
+  if (["number", "string"].includes(typeof node)) {
+    return `${node}`;
+  }
+  if (!node) {
+    return "";
+  }
+  if (Array.isArray(node)) {
+    return node.map(getNodeText).join("");
+  }
+  if (typeof node === "object" && "props" in node) {
+    return getNodeText(node.props.children);
+  }
+  throw new Error(`Unknown node type: ${typeof node}`);
 }
-export class NoSuspenseBoundaryError extends Error {
-    constructor(options) {
-        super(deindent `
+function suspend() {
+  import_react.default.use((0, import_promises.neverResolve)());
+  throw new Error("Somehow a Promise that never resolves was resolved?");
+}
+var NoSuspenseBoundaryError = class extends Error {
+  constructor(options) {
+    super(import_strings.deindent`
       ${options.caller ?? "This code path"} attempted to display a loading indicator, but didn't find a Suspense boundary above it. Please read the error message below carefully.
       
       The fix depends on which of the 3 scenarios caused it:
@@ -128,36 +96,22 @@ export class NoSuspenseBoundaryError extends Error {
 
       More information on SSR and Suspense boundaries: https://react.dev/reference/react/Suspense#providing-a-fallback-for-server-errors-and-client-only-content
     `);
-        this.name = "NoSuspenseBoundaryError";
-        this.reason = options.caller ?? "suspendIfSsr()";
-        // set the digest so nextjs doesn't log the error
-        // https://github.com/vercel/next.js/blob/d01d6d9c35a8c2725b3d74c1402ab76d4779a6cf/packages/next/src/shared/lib/lazy-dynamic/bailout-to-csr.ts#L14
-        this.digest = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
-    }
+    this.name = "NoSuspenseBoundaryError";
+    this.reason = options.caller ?? "suspendIfSsr()";
+    this.digest = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
+  }
+};
+function suspendIfSsr(caller) {
+  if (!(0, import_env.isBrowserLike)()) {
+    throw new NoSuspenseBoundaryError({ caller });
+  }
 }
-import.meta.vitest?.test("NoSuspenseBoundaryError", ({ expect }) => {
-    // Test with default options
-    const defaultError = new NoSuspenseBoundaryError({});
-    expect(defaultError.name).toBe("NoSuspenseBoundaryError");
-    expect(defaultError.reason).toBe("suspendIfSsr()");
-    expect(defaultError.digest).toBe("BAILOUT_TO_CLIENT_SIDE_RENDERING");
-    expect(defaultError.message).toContain("This code path attempted to display a loading indicator");
-    // Test with custom caller
-    const customError = new NoSuspenseBoundaryError({ caller: "CustomComponent" });
-    expect(customError.name).toBe("NoSuspenseBoundaryError");
-    expect(customError.reason).toBe("CustomComponent");
-    expect(customError.digest).toBe("BAILOUT_TO_CLIENT_SIDE_RENDERING");
-    expect(customError.message).toContain("CustomComponent attempted to display a loading indicator");
-    // Verify error message contains all the necessary information
-    expect(customError.message).toContain("loading.tsx");
-    expect(customError.message).toContain("route groups");
-    expect(customError.message).toContain("https://nextjs.org/docs/messages/missing-suspense-with-csr-bailout");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NoSuspenseBoundaryError,
+  forwardRefIfNeeded,
+  getNodeText,
+  suspend,
+  suspendIfSsr
 });
-/**
- * Use this in a component or a hook to disable SSR. Should be wrapped in a Suspense boundary, or it will throw an error.
- */
-export function suspendIfSsr(caller) {
-    if (!isBrowserLike()) {
-        throw new NoSuspenseBoundaryError({ caller });
-    }
-}
+//# sourceMappingURL=react.js.map

package/dist/utils/react.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/react.tsx"],"sourcesContent":["import React from \"react\";\nimport { isBrowserLike } from \"./env\";\nimport { neverResolve } from \"./promises\";\nimport { deindent } from \"./strings\";\n\nexport function forwardRefIfNeeded<T, P = {}>(render: React.ForwardRefRenderFunction<T, P>): React.FC<P & { ref?: React.Ref<T> }> {\n  // TODO: when we drop support for react 18, remove this\n\n  const version = React.version;\n  const major = parseInt(version.split(\".\")[0]);\n  if (major < 19) {\n    return React.forwardRef<T, P>(render as any) as any;\n  } else {\n    return ((props: P) => render(props, (props as any).ref)) as any;\n  }\n}\nundefined?.test(\"forwardRefIfNeeded\", ({ expect }) => {\n  // Mock React.version and React.forwardRef\n  const originalVersion = React.version;\n  const originalForwardRef = React.forwardRef;\n\n  try {\n    // Test with React version < 19\n    Object.defineProperty(React, 'version', { value: '18.2.0', writable: true });\n\n    // Create a render function\n    const renderFn = (props: any, ref: any) => null;\n\n    // Call forwardRefIfNeeded\n    const result = forwardRefIfNeeded(renderFn);\n\n    // Verify the function returns something\n    expect(result).toBeDefined();\n\n    // Test with React version >= 19\n    Object.defineProperty(React, 'version', { value: '19.0.0', writable: true });\n\n    // Call forwardRefIfNeeded again with React 19\n    const result19 = forwardRefIfNeeded(renderFn);\n\n    // Verify the function returns something\n    expect(result19).toBeDefined();\n  } finally {\n    // Restore original values\n    Object.defineProperty(React, 'version', { value: originalVersion });\n    React.forwardRef = originalForwardRef;\n  }\n});\n\nexport function getNodeText(node: React.ReactNode): string {\n  if ([\"number\", \"string\"].includes(typeof node)) {\n    return `${node}`;\n  }\n  if (!node) {\n    return \"\";\n  }\n  if (Array.isArray(node)) {\n    return node.map(getNodeText).join(\"\");\n  }\n  if (typeof node === \"object\" && \"props\" in node) {\n    return getNodeText(node.props.children);\n  }\n  throw new Error(`Unknown node type: ${typeof node}`);\n}\nundefined?.test(\"getNodeText\", ({ expect }) => {\n  // Test with string\n  expect(getNodeText(\"hello\")).toBe(\"hello\");\n\n  // Test with number\n  expect(getNodeText(42)).toBe(\"42\");\n\n  // Test with null/undefined\n  expect(getNodeText(null)).toBe(\"\");\n  expect(getNodeText(undefined)).toBe(\"\");\n\n  // Test with array\n  expect(getNodeText([\"hello\", \" \", \"world\"])).toBe(\"hello world\");\n  expect(getNodeText([1, 2, 3])).toBe(\"123\");\n\n  // Test with mixed array\n  expect(getNodeText([\"hello\", 42, null])).toBe(\"hello42\");\n\n  // Test with React element (mocked)\n  const mockElement = {\n    props: {\n      children: \"child text\"\n    }\n  } as React.ReactElement;\n  expect(getNodeText(mockElement)).toBe(\"child text\");\n\n  // Test with nested React elements\n  const nestedElement = {\n    props: {\n      children: {\n        props: {\n          children: \"nested text\"\n        }\n      } as React.ReactElement\n    }\n  } as React.ReactElement;\n  expect(getNodeText(nestedElement)).toBe(\"nested text\");\n\n  // Test with array of React elements\n  const arrayOfElements = [\n    { props: { children: \"first\" } } as React.ReactElement,\n    { props: { children: \"second\" } } as React.ReactElement\n  ];\n  expect(getNodeText(arrayOfElements)).toBe(\"firstsecond\");\n});\n\n/**\n * Suspends the currently rendered component indefinitely. Will not unsuspend unless the component rerenders.\n *\n * You can use this to translate older query- or AsyncResult-based code to new the Suspense system, for example: `if (query.isLoading) suspend();`\n */\nexport function suspend(): never {\n  React.use(neverResolve());\n  throw new Error(\"Somehow a Promise that never resolves was resolved?\");\n}\n\nexport class NoSuspenseBoundaryError extends Error {\n  digest: string;\n  reason: string;\n\n  constructor(options: { caller?: string }) {\n    super(deindent`\n      ${options.caller ?? \"This code path\"} attempted to display a loading indicator, but didn't find a Suspense boundary above it. Please read the error message below carefully.\n      \n      The fix depends on which of the 3 scenarios caused it:\n      \n      1. You are missing a loading.tsx file in your app directory. Fix it by adding a loading.tsx file in your app directory.\n\n      2. The component is rendered in the root (outermost) layout.tsx or template.tsx file. Next.js does not wrap those files in a Suspense boundary, even if there is a loading.tsx file in the same folder. To fix it, wrap your layout inside a route group like this:\n\n        - app\n        - - layout.tsx  // contains <html> and <body>, alongside providers and other components that don't need ${options.caller ?? \"this code path\"}\n        - - loading.tsx  // required for suspense\n        - - (main)\n        - - - layout.tsx  // contains the main layout of your app, like a sidebar or a header, and can use ${options.caller ?? \"this code path\"}\n        - - - route.tsx  // your actual main page\n        - - - the rest of your app\n\n        For more information on this approach, see Next's documentation on route groups: https://nextjs.org/docs/app/building-your-application/routing/route-groups\n      \n      3. You caught this error with try-catch or a custom error boundary. Fix this by rethrowing the error or not catching it in the first place.\n\n      See: https://nextjs.org/docs/messages/missing-suspense-with-csr-bailout\n\n      More information on SSR and Suspense boundaries: https://react.dev/reference/react/Suspense#providing-a-fallback-for-server-errors-and-client-only-content\n    `);\n\n    this.name = \"NoSuspenseBoundaryError\";\n    this.reason = options.caller ?? \"suspendIfSsr()\";\n\n    // set the digest so nextjs doesn't log the error\n    // https://github.com/vercel/next.js/blob/d01d6d9c35a8c2725b3d74c1402ab76d4779a6cf/packages/next/src/shared/lib/lazy-dynamic/bailout-to-csr.ts#L14\n    this.digest = \"BAILOUT_TO_CLIENT_SIDE_RENDERING\";\n  }\n}\nundefined?.test(\"NoSuspenseBoundaryError\", ({ expect }) => {\n  // Test with default options\n  const defaultError = new NoSuspenseBoundaryError({});\n  expect(defaultError.name).toBe(\"NoSuspenseBoundaryError\");\n  expect(defaultError.reason).toBe(\"suspendIfSsr()\");\n  expect(defaultError.digest).toBe(\"BAILOUT_TO_CLIENT_SIDE_RENDERING\");\n  expect(defaultError.message).toContain(\"This code path attempted to display a loading indicator\");\n\n  // Test with custom caller\n  const customError = new NoSuspenseBoundaryError({ caller: \"CustomComponent\" });\n  expect(customError.name).toBe(\"NoSuspenseBoundaryError\");\n  expect(customError.reason).toBe(\"CustomComponent\");\n  expect(customError.digest).toBe(\"BAILOUT_TO_CLIENT_SIDE_RENDERING\");\n  expect(customError.message).toContain(\"CustomComponent attempted to display a loading indicator\");\n\n  // Verify error message contains all the necessary information\n  expect(customError.message).toContain(\"loading.tsx\");\n  expect(customError.message).toContain(\"route groups\");\n  expect(customError.message).toContain(\"https://nextjs.org/docs/messages/missing-suspense-with-csr-bailout\");\n});\n\n\n/**\n * Use this in a component or a hook to disable SSR. Should be wrapped in a Suspense boundary, or it will throw an error.\n */\nexport function suspendIfSsr(caller?: string) {\n  if (!isBrowserLike()) {\n    throw new NoSuspenseBoundaryError({ caller });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAkB;AAClB,iBAA8B;AAC9B,sBAA6B;AAC7B,qBAAyB;AAElB,SAAS,mBAA8B,QAAoF;AAGhI,QAAM,UAAU,aAAAA,QAAM;AACtB,QAAM,QAAQ,SAAS,QAAQ,MAAM,GAAG,EAAE,CAAC,CAAC;AAC5C,MAAI,QAAQ,IAAI;AACd,WAAO,aAAAA,QAAM,WAAiB,MAAa;AAAA,EAC7C,OAAO;AACL,WAAQ,CAAC,UAAa,OAAO,OAAQ,MAAc,GAAG;AAAA,EACxD;AACF;AAkCO,SAAS,YAAY,MAA+B;AACzD,MAAI,CAAC,UAAU,QAAQ,EAAE,SAAS,OAAO,IAAI,GAAG;AAC9C,WAAO,GAAG,IAAI;AAAA,EAChB;AACA,MAAI,CAAC,MAAM;AACT,WAAO;AAAA,EACT;AACA,MAAI,MAAM,QAAQ,IAAI,GAAG;AACvB,WAAO,KAAK,IAAI,WAAW,EAAE,KAAK,EAAE;AAAA,EACtC;AACA,MAAI,OAAO,SAAS,YAAY,WAAW,MAAM;AAC/C,WAAO,YAAY,KAAK,MAAM,QAAQ;AAAA,EACxC;AACA,QAAM,IAAI,MAAM,sBAAsB,OAAO,IAAI,EAAE;AACrD;AAoDO,SAAS,UAAiB;AAC/B,eAAAA,QAAM,QAAI,8BAAa,CAAC;AACxB,QAAM,IAAI,MAAM,qDAAqD;AACvE;AAEO,IAAM,0BAAN,cAAsC,MAAM;AAAA,EAIjD,YAAY,SAA8B;AACxC,UAAM;AAAA,QACF,QAAQ,UAAU,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kHASwE,QAAQ,UAAU,gBAAgB;AAAA;AAAA;AAAA,6GAGvC,QAAQ,UAAU,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAW1I;AAED,SAAK,OAAO;AACZ,SAAK,SAAS,QAAQ,UAAU;AAIhC,SAAK,SAAS;AAAA,EAChB;AACF;AA0BO,SAAS,aAAa,QAAiB;AAC5C,MAAI,KAAC,0BAAc,GAAG;AACpB,UAAM,IAAI,wBAAwB,EAAE,OAAO,CAAC;AAAA,EAC9C;AACF;","names":["React"]}

package/dist/utils/results.d.cts

@@ -0,0 +1,78 @@
+type Result<T, E = unknown> = {
+    status: "ok";
+    data: T;
+} | {
+    status: "error";
+    error: E;
+};
+declare const Result: {
+    fromThrowing: typeof fromThrowing;
+    fromThrowingAsync: typeof fromThrowingAsync;
+    fromPromise: typeof promiseToResult;
+    ok<T>(data: T): {
+        status: "ok";
+        data: T;
+    } & {
+        status: "ok";
+    };
+    error<E>(error: E): {
+        status: "error";
+        error: E;
+    } & {
+        status: "error";
+    };
+    map: typeof mapResult;
+    or: <T_1, E_1, U>(result: Result<T_1, E_1>, fallback: U) => T_1 | U;
+    orThrow: <T_2, E_2>(result: Result<T_2, E_2>) => T_2;
+    orThrowAsync: <T_3, E_3>(result: Promise<Result<T_3, E_3>>) => Promise<T_3>;
+    retry: typeof retry;
+};
+type AsyncResult<T, E = unknown, P = void> = Result<T, E> | ({
+    status: "pending";
+} & {
+    progress: P;
+});
+declare const AsyncResult: {
+    fromThrowing: typeof fromThrowing;
+    fromPromise: typeof promiseToResult;
+    ok: <T>(data: T) => {
+        status: "ok";
+        data: T;
+    } & {
+        status: "ok";
+    };
+    error: <E>(error: E) => {
+        status: "error";
+        error: E;
+    } & {
+        status: "error";
+    };
+    pending: typeof pending;
+    map: typeof mapResult;
+    or: <T_1, E_1, P, U>(result: AsyncResult<T_1, E_1, P>, fallback: U) => T_1 | U;
+    orThrow: <T_2, E_2, P_1>(result: AsyncResult<T_2, E_2, P_1>) => T_2;
+    retry: typeof retry;
+};
+declare function pending(): AsyncResult<never, never, void> & {
+    status: "pending";
+};
+declare function pending<P>(progress: P): AsyncResult<never, never, P> & {
+    status: "pending";
+};
+declare function promiseToResult<T>(promise: Promise<T>): Promise<Result<T>>;
+declare function fromThrowing<T>(fn: () => T): Result<T, unknown>;
+declare function fromThrowingAsync<T>(fn: () => Promise<T>): Promise<Result<T, unknown>>;
+declare function mapResult<T, U, E = unknown, P = unknown>(result: Result<T, E>, fn: (data: T) => U): Result<U, E>;
+declare function mapResult<T, U, E = unknown, P = unknown>(result: AsyncResult<T, E, P>, fn: (data: T) => U): AsyncResult<U, E, P>;
+declare class RetryError extends AggregateError {
+    readonly errors: unknown[];
+    constructor(errors: unknown[]);
+    get attempts(): number;
+}
+declare function retry<T>(fn: (attemptIndex: number) => Result<T> | Promise<Result<T>>, totalAttempts: number, { exponentialDelayBase }?: {
+    exponentialDelayBase?: number | undefined;
+}): Promise<Result<T, RetryError> & {
+    attempts: number;
+}>;
+
+export { AsyncResult, Result };

package/dist/utils/results.d.ts

@@ -1,16 +1,11 @@
-export type Result<T, E = unknown> = {
+type Result<T, E = unknown> = {
     status: "ok";
     data: T;
 } | {
     status: "error";
     error: E;
 };
-export type AsyncResult<T, E = unknown, P = void> = Result<T, E> | ({
-    status: "pending";
-} & {
-    progress: P;
-});
-export declare const Result: {
+declare const Result: {
     fromThrowing: typeof fromThrowing;
     fromThrowingAsync: typeof fromThrowingAsync;
     fromPromise: typeof promiseToResult;
@@ -32,7 +27,12 @@ export declare const Result: {
     orThrowAsync: <T_3, E_3>(result: Promise<Result<T_3, E_3>>) => Promise<T_3>;
     retry: typeof retry;
 };
-export declare const AsyncResult: {
+type AsyncResult<T, E = unknown, P = void> = Result<T, E> | ({
+    status: "pending";
+} & {
+    progress: P;
+});
+declare const AsyncResult: {
     fromThrowing: typeof fromThrowing;
     fromPromise: typeof promiseToResult;
     ok: <T>(data: T) => {
@@ -74,4 +74,5 @@ declare function retry<T>(fn: (attemptIndex: number) => Result<T> | Promise<Resu
 }): Promise<Result<T, RetryError> & {
     attempts: number;
 }>;
-export {};
+
+export { AsyncResult, Result };