@orpc/client 0.0.0-next.3cb80cf → 0.0.0-next.3ee2e95

package/dist/shared/client.vy3P78P6.mjs

@@ -0,0 +1,348 @@
+import { toArray, intercept, isObject, value, isAsyncIteratorObject, stringifyJSON } from '@orpc/shared';
+import { mergeStandardHeaders, ErrorEvent } from '@orpc/standard-server';
+import { C as COMMON_ORPC_ERROR_DEFS, b as isORPCErrorStatus, c as isORPCErrorJson, d as createORPCErrorFromJson, O as ORPCError, m as mapEventIterator, t as toORPCError } from './client.CRWEpqLB.mjs';
+
+class CompositeStandardLinkPlugin {
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = [...plugins].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  }
+  init(options) {
+    for (const plugin of this.plugins) {
+      plugin.init?.(options);
+    }
+  }
+}
+
+class InvalidEventIteratorRetryResponse extends Error {
+}
+class StandardLink {
+  constructor(codec, sender, options = {}) {
+    this.codec = codec;
+    this.sender = sender;
+    const plugin = new CompositeStandardLinkPlugin(options.plugins);
+    plugin.init(options);
+    this.interceptors = toArray(options.interceptors);
+    this.clientInterceptors = toArray(options.clientInterceptors);
+  }
+  interceptors;
+  clientInterceptors;
+  call(path, input, options) {
+    return intercept(this.interceptors, { ...options, path, input }, async ({ path: path2, input: input2, ...options2 }) => {
+      const output = await this.#call(path2, input2, options2);
+      return output;
+    });
+  }
+  async #call(path, input, options) {
+    const request = await this.codec.encode(path, input, options);
+    const response = await intercept(
+      this.clientInterceptors,
+      { ...options, input, path, request },
+      ({ input: input2, path: path2, request: request2, ...options2 }) => this.sender.call(request2, options2, path2, input2)
+    );
+    const output = await this.codec.decode(response, options, path, input);
+    return output;
+  }
+}
+
+const STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES = {
+  BIGINT: 0,
+  DATE: 1,
+  NAN: 2,
+  UNDEFINED: 3,
+  URL: 4,
+  REGEXP: 5,
+  SET: 6,
+  MAP: 7
+};
+class StandardRPCJsonSerializer {
+  customSerializers;
+  constructor(options = {}) {
+    this.customSerializers = options.customJsonSerializers ?? [];
+    if (this.customSerializers.length !== new Set(this.customSerializers.map((custom) => custom.type)).size) {
+      throw new Error("Custom serializer type must be unique.");
+    }
+  }
+  serialize(data, segments = [], meta = [], maps = [], blobs = []) {
+    for (const custom of this.customSerializers) {
+      if (custom.condition(data)) {
+        const result = this.serialize(custom.serialize(data), segments, meta, maps, blobs);
+        meta.push([custom.type, ...segments]);
+        return result;
+      }
+    }
+    if (data instanceof Blob) {
+      maps.push(segments);
+      blobs.push(data);
+      return [data, meta, maps, blobs];
+    }
+    if (typeof data === "bigint") {
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.BIGINT, ...segments]);
+      return [data.toString(), meta, maps, blobs];
+    }
+    if (data instanceof Date) {
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.DATE, ...segments]);
+      if (Number.isNaN(data.getTime())) {
+        return [null, meta, maps, blobs];
+      }
+      return [data.toISOString(), meta, maps, blobs];
+    }
+    if (Number.isNaN(data)) {
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.NAN, ...segments]);
+      return [null, meta, maps, blobs];
+    }
+    if (data instanceof URL) {
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.URL, ...segments]);
+      return [data.toString(), meta, maps, blobs];
+    }
+    if (data instanceof RegExp) {
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.REGEXP, ...segments]);
+      return [data.toString(), meta, maps, blobs];
+    }
+    if (data instanceof Set) {
+      const result = this.serialize(Array.from(data), segments, meta, maps, blobs);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.SET, ...segments]);
+      return result;
+    }
+    if (data instanceof Map) {
+      const result = this.serialize(Array.from(data.entries()), segments, meta, maps, blobs);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.MAP, ...segments]);
+      return result;
+    }
+    if (Array.isArray(data)) {
+      const json = data.map((v, i) => {
+        if (v === void 0) {
+          meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.UNDEFINED, ...segments, i]);
+          return v;
+        }
+        return this.serialize(v, [...segments, i], meta, maps, blobs)[0];
+      });
+      return [json, meta, maps, blobs];
+    }
+    if (isObject(data)) {
+      const json = {};
+      for (const k in data) {
+        if (k === "toJSON" && typeof data[k] === "function") {
+          continue;
+        }
+        json[k] = this.serialize(data[k], [...segments, k], meta, maps, blobs)[0];
+      }
+      return [json, meta, maps, blobs];
+    }
+    return [data, meta, maps, blobs];
+  }
+  deserialize(json, meta, maps, getBlob) {
+    const ref = { data: json };
+    if (maps && getBlob) {
+      maps.forEach((segments, i) => {
+        let currentRef = ref;
+        let preSegment = "data";
+        segments.forEach((segment) => {
+          currentRef = currentRef[preSegment];
+          preSegment = segment;
+        });
+        currentRef[preSegment] = getBlob(i);
+      });
+    }
+    for (const item of meta) {
+      const type = item[0];
+      let currentRef = ref;
+      let preSegment = "data";
+      for (let i = 1; i < item.length; i++) {
+        currentRef = currentRef[preSegment];
+        preSegment = item[i];
+      }
+      for (const custom of this.customSerializers) {
+        if (custom.type === type) {
+          currentRef[preSegment] = custom.deserialize(currentRef[preSegment]);
+          break;
+        }
+      }
+      switch (type) {
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.BIGINT:
+          currentRef[preSegment] = BigInt(currentRef[preSegment]);
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.DATE:
+          currentRef[preSegment] = new Date(currentRef[preSegment] ?? "Invalid Date");
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.NAN:
+          currentRef[preSegment] = Number.NaN;
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.UNDEFINED:
+          currentRef[preSegment] = void 0;
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.URL:
+          currentRef[preSegment] = new URL(currentRef[preSegment]);
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.REGEXP: {
+          const [, pattern, flags] = currentRef[preSegment].match(/^\/(.*)\/([a-z]*)$/);
+          currentRef[preSegment] = new RegExp(pattern, flags);
+          break;
+        }
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.SET:
+          currentRef[preSegment] = new Set(currentRef[preSegment]);
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.MAP:
+          currentRef[preSegment] = new Map(currentRef[preSegment]);
+          break;
+      }
+    }
+    return ref.data;
+  }
+}
+
+function toHttpPath(path) {
+  return `/${path.map(encodeURIComponent).join("/")}`;
+}
+function getMalformedResponseErrorCode(status) {
+  return Object.entries(COMMON_ORPC_ERROR_DEFS).find(([, def]) => def.status === status)?.[0] ?? "MALFORMED_ORPC_ERROR_RESPONSE";
+}
+
+class StandardRPCLinkCodec {
+  constructor(serializer, options) {
+    this.serializer = serializer;
+    this.baseUrl = options.url;
+    this.maxUrlLength = options.maxUrlLength ?? 2083;
+    this.fallbackMethod = options.fallbackMethod ?? "POST";
+    this.expectedMethod = options.method ?? this.fallbackMethod;
+    this.headers = options.headers ?? {};
+  }
+  baseUrl;
+  maxUrlLength;
+  fallbackMethod;
+  expectedMethod;
+  headers;
+  async encode(path, input, options) {
+    const expectedMethod = await value(this.expectedMethod, options, path, input);
+    let headers = await value(this.headers, options, path, input);
+    const baseUrl = await value(this.baseUrl, options, path, input);
+    const url = new URL(baseUrl);
+    url.pathname = `${url.pathname.replace(/\/$/, "")}${toHttpPath(path)}`;
+    if (options.lastEventId !== void 0) {
+      headers = mergeStandardHeaders(headers, { "last-event-id": options.lastEventId });
+    }
+    const serialized = this.serializer.serialize(input);
+    if (expectedMethod === "GET" && !(serialized instanceof FormData) && !isAsyncIteratorObject(serialized)) {
+      const maxUrlLength = await value(this.maxUrlLength, options, path, input);
+      const getUrl = new URL(url);
+      getUrl.searchParams.append("data", stringifyJSON(serialized));
+      if (getUrl.toString().length <= maxUrlLength) {
+        return {
+          body: void 0,
+          method: expectedMethod,
+          headers,
+          url: getUrl,
+          signal: options.signal
+        };
+      }
+    }
+    return {
+      url,
+      method: expectedMethod === "GET" ? this.fallbackMethod : expectedMethod,
+      headers,
+      body: serialized,
+      signal: options.signal
+    };
+  }
+  async decode(response) {
+    const isOk = !isORPCErrorStatus(response.status);
+    const deserialized = await (async () => {
+      let isBodyOk = false;
+      try {
+        const body = await response.body();
+        isBodyOk = true;
+        return this.serializer.deserialize(body);
+      } catch (error) {
+        if (!isBodyOk) {
+          throw new Error("Cannot parse response body, please check the response body and content-type.", {
+            cause: error
+          });
+        }
+        throw new Error("Invalid RPC response format.", {
+          cause: error
+        });
+      }
+    })();
+    if (!isOk) {
+      if (isORPCErrorJson(deserialized)) {
+        throw createORPCErrorFromJson(deserialized);
+      }
+      throw new ORPCError(getMalformedResponseErrorCode(response.status), {
+        status: response.status,
+        data: { ...response, body: deserialized }
+      });
+    }
+    return deserialized;
+  }
+}
+
+class StandardRPCSerializer {
+  constructor(jsonSerializer) {
+    this.jsonSerializer = jsonSerializer;
+  }
+  serialize(data) {
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
+        value: async (value) => this.#serialize(value, false),
+        error: async (e) => {
+          return new ErrorEvent({
+            data: this.#serialize(toORPCError(e).toJSON(), false),
+            cause: e
+          });
+        }
+      });
+    }
+    return this.#serialize(data, true);
+  }
+  #serialize(data, enableFormData) {
+    const [json, meta_, maps, blobs] = this.jsonSerializer.serialize(data);
+    const meta = meta_.length === 0 ? void 0 : meta_;
+    if (!enableFormData || blobs.length === 0) {
+      return {
+        json,
+        meta
+      };
+    }
+    const form = new FormData();
+    form.set("data", stringifyJSON({ json, meta, maps }));
+    blobs.forEach((blob, i) => {
+      form.set(i.toString(), blob);
+    });
+    return form;
+  }
+  deserialize(data) {
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
+        value: async (value) => this.#deserialize(value),
+        error: async (e) => {
+          if (!(e instanceof ErrorEvent)) {
+            return e;
+          }
+          const deserialized = this.#deserialize(e.data);
+          if (isORPCErrorJson(deserialized)) {
+            return createORPCErrorFromJson(deserialized, { cause: e });
+          }
+          return new ErrorEvent({
+            data: deserialized,
+            cause: e
+          });
+        }
+      });
+    }
+    return this.#deserialize(data);
+  }
+  #deserialize(data) {
+    if (!(data instanceof FormData)) {
+      return this.jsonSerializer.deserialize(data.json, data.meta ?? []);
+    }
+    const serialized = JSON.parse(data.get("data"));
+    return this.jsonSerializer.deserialize(
+      serialized.json,
+      serialized.meta ?? [],
+      serialized.maps,
+      (i) => data.get(i.toString())
+    );
+  }
+}
+
+export { CompositeStandardLinkPlugin as C, InvalidEventIteratorRetryResponse as I, StandardLink as S, STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as a, StandardRPCJsonSerializer as b, StandardRPCLinkCodec as c, StandardRPCSerializer as d, getMalformedResponseErrorCode as g, toHttpPath as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "0.0.0-next.3cb80cf",
+  "version": "0.0.0-next.3ee2e95",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -15,44 +15,39 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
     },
-    "./openapi": {
-      "types": "./dist/src/openapi/index.d.ts",
-      "import": "./dist/openapi.js",
-      "default": "./dist/openapi.js"
+    "./plugins": {
+      "types": "./dist/plugins/index.d.mts",
+      "import": "./dist/plugins/index.mjs",
+      "default": "./dist/plugins/index.mjs"
     },
-    "./rpc": {
-      "types": "./dist/src/rpc/index.d.ts",
-      "import": "./dist/rpc.js",
-      "default": "./dist/rpc.js"
+    "./standard": {
+      "types": "./dist/adapters/standard/index.d.mts",
+      "import": "./dist/adapters/standard/index.mjs",
+      "default": "./dist/adapters/standard/index.mjs"
     },
     "./fetch": {
-      "types": "./dist/src/adapters/fetch/index.d.ts",
-      "import": "./dist/fetch.js",
-      "default": "./dist/fetch.js"
-    },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+      "types": "./dist/adapters/fetch/index.d.mts",
+      "import": "./dist/adapters/fetch/index.mjs",
+      "default": "./dist/adapters/fetch/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
   "dependencies": {
-    "@orpc/server-standard": "^0.4.0",
-    "@orpc/server-standard-fetch": "^0.4.0",
-    "@orpc/shared": "0.0.0-next.3cb80cf"
+    "@orpc/shared": "0.0.0-next.3ee2e95",
+    "@orpc/standard-server-fetch": "0.0.0-next.3ee2e95",
+    "@orpc/standard-server": "0.0.0-next.3ee2e95"
   },
   "devDependencies": {
-    "zod": "^3.24.1"
+    "zod": "^3.24.2"
   },
   "scripts": {
-    "build": "tsup --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/chunk-2UPNYYFF.js

@@ -1,288 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/error.ts
-import { isObject } from "@orpc/shared";
-var COMMON_ORPC_ERROR_DEFS = {
-  BAD_REQUEST: {
-    status: 400,
-    message: "Bad Request"
-  },
-  UNAUTHORIZED: {
-    status: 401,
-    message: "Unauthorized"
-  },
-  FORBIDDEN: {
-    status: 403,
-    message: "Forbidden"
-  },
-  NOT_FOUND: {
-    status: 404,
-    message: "Not Found"
-  },
-  METHOD_NOT_SUPPORTED: {
-    status: 405,
-    message: "Method Not Supported"
-  },
-  NOT_ACCEPTABLE: {
-    status: 406,
-    message: "Not Acceptable"
-  },
-  TIMEOUT: {
-    status: 408,
-    message: "Request Timeout"
-  },
-  CONFLICT: {
-    status: 409,
-    message: "Conflict"
-  },
-  PRECONDITION_FAILED: {
-    status: 412,
-    message: "Precondition Failed"
-  },
-  PAYLOAD_TOO_LARGE: {
-    status: 413,
-    message: "Payload Too Large"
-  },
-  UNSUPPORTED_MEDIA_TYPE: {
-    status: 415,
-    message: "Unsupported Media Type"
-  },
-  UNPROCESSABLE_CONTENT: {
-    status: 422,
-    message: "Unprocessable Content"
-  },
-  TOO_MANY_REQUESTS: {
-    status: 429,
-    message: "Too Many Requests"
-  },
-  CLIENT_CLOSED_REQUEST: {
-    status: 499,
-    message: "Client Closed Request"
-  },
-  INTERNAL_SERVER_ERROR: {
-    status: 500,
-    message: "Internal Server Error"
-  },
-  NOT_IMPLEMENTED: {
-    status: 501,
-    message: "Not Implemented"
-  },
-  BAD_GATEWAY: {
-    status: 502,
-    message: "Bad Gateway"
-  },
-  SERVICE_UNAVAILABLE: {
-    status: 503,
-    message: "Service Unavailable"
-  },
-  GATEWAY_TIMEOUT: {
-    status: 504,
-    message: "Gateway Timeout"
-  }
-};
-function fallbackORPCErrorStatus(code, status) {
-  return status ?? COMMON_ORPC_ERROR_DEFS[code]?.status ?? 500;
-}
-function fallbackORPCErrorMessage(code, message) {
-  return message || COMMON_ORPC_ERROR_DEFS[code]?.message || code;
-}
-var ORPCError = class _ORPCError extends Error {
-  defined;
-  code;
-  status;
-  data;
-  constructor(code, ...[options]) {
-    if (options?.status && (options.status < 400 || options.status >= 600)) {
-      throw new Error("[ORPCError] The error status code must be in the 400-599 range.");
-    }
-    const message = fallbackORPCErrorMessage(code, options?.message);
-    super(message, options);
-    this.code = code;
-    this.status = fallbackORPCErrorStatus(code, options?.status);
-    this.defined = options?.defined ?? false;
-    this.data = options?.data;
-  }
-  toJSON() {
-    return {
-      defined: this.defined,
-      code: this.code,
-      status: this.status,
-      message: this.message,
-      data: this.data
-    };
-  }
-  static fromJSON(json, options) {
-    return new _ORPCError(json.code, {
-      ...options,
-      ...json
-    });
-  }
-  static isValidJSON(json) {
-    if (!isObject(json)) {
-      return false;
-    }
-    const validKeys = ["defined", "code", "status", "message", "data"];
-    if (Object.keys(json).some((k) => !validKeys.includes(k))) {
-      return false;
-    }
-    return "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && "message" in json && typeof json.message === "string";
-  }
-};
-function isDefinedError(error) {
-  return error instanceof ORPCError && error.defined;
-}
-function toORPCError(error) {
-  return error instanceof ORPCError ? error : new ORPCError("INTERNAL_SERVER_ERROR", {
-    message: "Internal server error",
-    cause: error
-  });
-}
-
-// src/event-iterator-state.ts
-var iteratorStates = /* @__PURE__ */ new WeakMap();
-function registerEventIteratorState(iterator, state) {
-  iteratorStates.set(iterator, state);
-}
-function updateEventIteratorStatus(state, status) {
-  if (state.status !== status) {
-    state.status = status;
-    state.listeners.forEach((cb) => cb(status));
-  }
-}
-function onEventIteratorStatusChange(iterator, callback, notifyImmediately = true) {
-  const state = iteratorStates.get(iterator);
-  if (!state) {
-    throw new Error("Iterator is not registered.");
-  }
-  if (notifyImmediately) {
-    callback(state.status);
-  }
-  state.listeners.push(callback);
-  return () => {
-    const index = state.listeners.indexOf(callback);
-    if (index !== -1) {
-      state.listeners.splice(index, 1);
-    }
-  };
-}
-
-// src/event-iterator.ts
-import { getEventMeta, isEventMetaContainer, withEventMeta } from "@orpc/server-standard";
-import { retry } from "@orpc/shared";
-function mapEventIterator(iterator, maps) {
-  return async function* () {
-    try {
-      while (true) {
-        const { done, value } = await iterator.next();
-        let mappedValue = await maps.value(value, done);
-        if (mappedValue !== value) {
-          const meta = getEventMeta(value);
-          if (meta && isEventMetaContainer(mappedValue)) {
-            mappedValue = withEventMeta(mappedValue, meta);
-          }
-        }
-        if (done) {
-          return mappedValue;
-        }
-        yield mappedValue;
-      }
-    } catch (error) {
-      let mappedError = await maps.error(error);
-      if (mappedError !== error) {
-        const meta = getEventMeta(error);
-        if (meta && isEventMetaContainer(mappedError)) {
-          mappedError = withEventMeta(mappedError, meta);
-        }
-      }
-      throw mappedError;
-    } finally {
-      await iterator.return?.();
-    }
-  }();
-}
-var MAX_ALLOWED_RETRY_TIMES = 99;
-function createAutoRetryEventIterator(initial, reconnect, initialLastEventId) {
-  const state = {
-    status: "connected",
-    listeners: []
-  };
-  const iterator = async function* () {
-    let current = initial;
-    let lastEventId = initialLastEventId;
-    let lastRetry;
-    let retryTimes = 0;
-    try {
-      while (true) {
-        try {
-          updateEventIteratorStatus(state, "connected");
-          const { done, value } = await current.next();
-          const meta = getEventMeta(value);
-          lastEventId = meta?.id ?? lastEventId;
-          lastRetry = meta?.retry ?? lastRetry;
-          retryTimes = 0;
-          if (done) {
-            return value;
-          }
-          yield value;
-        } catch (e) {
-          updateEventIteratorStatus(state, "reconnecting");
-          const meta = getEventMeta(e);
-          lastEventId = meta?.id ?? lastEventId;
-          lastRetry = meta?.retry ?? lastRetry;
-          let currentError = e;
-          current = await retry({ times: MAX_ALLOWED_RETRY_TIMES }, async (exit) => {
-            retryTimes += 1;
-            if (retryTimes > MAX_ALLOWED_RETRY_TIMES) {
-              throw exit(new Error(
-                `Exceeded maximum retry attempts (${MAX_ALLOWED_RETRY_TIMES}) for event source. Possible infinite retry loop detected. Please review the retry logic.`,
-                { cause: currentError }
-              ));
-            }
-            const reconnected = await (async () => {
-              try {
-                return await reconnect({
-                  lastRetry,
-                  lastEventId,
-                  retryTimes,
-                  error: currentError
-                });
-              } catch (e2) {
-                currentError = e2;
-                throw e2;
-              }
-            })();
-            if (!reconnected) {
-              throw exit(currentError);
-            }
-            return reconnected;
-          });
-        }
-      }
-    } finally {
-      updateEventIteratorStatus(state, "closed");
-      await current.return?.();
-    }
-  }();
-  registerEventIteratorState(iterator, state);
-  return iterator;
-}
-
-export {
-  __export,
-  COMMON_ORPC_ERROR_DEFS,
-  fallbackORPCErrorStatus,
-  fallbackORPCErrorMessage,
-  ORPCError,
-  isDefinedError,
-  toORPCError,
-  registerEventIteratorState,
-  updateEventIteratorStatus,
-  onEventIteratorStatusChange,
-  mapEventIterator,
-  createAutoRetryEventIterator
-};
-//# sourceMappingURL=chunk-2UPNYYFF.js.map