@orpc/client 0.0.0-next.b45a533 → 0.0.0-next.b4897a0

package/dist/shared/client.DhcDs8zZ.mjs

@@ -0,0 +1,171 @@
+import { resolveMaybeOptionalOptions, getConstructor, isObject } from '@orpc/shared';
+
+const ORPC_CLIENT_PACKAGE_NAME = "@orpc/client";
+const ORPC_CLIENT_PACKAGE_VERSION = "0.0.0-next.b4897a0";
+
+const 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;
+}
+const GLOBAL_ORPC_ERROR_CONSTRUCTORS_SYMBOL = Symbol.for(`__${ORPC_CLIENT_PACKAGE_NAME}@${ORPC_CLIENT_PACKAGE_VERSION}/error/ORPC_ERROR_CONSTRUCTORS__`);
+void (globalThis[GLOBAL_ORPC_ERROR_CONSTRUCTORS_SYMBOL] ??= /* @__PURE__ */ new WeakSet());
+const globalORPCErrorConstructors = globalThis[GLOBAL_ORPC_ERROR_CONSTRUCTORS_SYMBOL];
+class ORPCError extends Error {
+  defined;
+  code;
+  status;
+  data;
+  constructor(code, ...rest) {
+    const options = resolveMaybeOptionalOptions(rest);
+    if (options.status !== void 0 && !isORPCErrorStatus(options.status)) {
+      throw new Error("[ORPCError] Invalid error status code.");
+    }
+    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
+    };
+  }
+  /**
+   * Workaround for Next.js where different contexts use separate
+   * dependency graphs, causing multiple ORPCError constructors existing and breaking
+   * `instanceof` checks across contexts.
+   *
+   * This is particularly problematic with "Optimized SSR", where orpc-client
+   * executes in one context but is invoked from another. When an error is thrown
+   * in the execution context, `instanceof ORPCError` checks fail in the
+   * invocation context due to separate class constructors.
+   *
+   * @todo Remove this and related code if Next.js resolves the multiple dependency graph issue.
+   */
+  static [Symbol.hasInstance](instance) {
+    if (globalORPCErrorConstructors.has(this)) {
+      const constructor = getConstructor(instance);
+      if (constructor && globalORPCErrorConstructors.has(constructor)) {
+        return true;
+      }
+    }
+    return super[Symbol.hasInstance](instance);
+  }
+}
+globalORPCErrorConstructors.add(ORPCError);
+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
+  });
+}
+function isORPCErrorStatus(status) {
+  return status < 200 || status >= 400;
+}
+function isORPCErrorJson(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" && isORPCErrorStatus(json.status) && "message" in json && typeof json.message === "string";
+}
+function createORPCErrorFromJson(json, options = {}) {
+  return new ORPCError(json.code, {
+    ...options,
+    ...json
+  });
+}
+
+export { COMMON_ORPC_ERROR_DEFS as C, ORPC_CLIENT_PACKAGE_NAME as O, ORPC_CLIENT_PACKAGE_VERSION as a, fallbackORPCErrorMessage as b, ORPCError as c, isORPCErrorStatus as d, isORPCErrorJson as e, fallbackORPCErrorStatus as f, createORPCErrorFromJson as g, isDefinedError as i, toORPCError as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "0.0.0-next.b45a533",
+  "version": "0.0.0-next.b4897a0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -19,6 +19,11 @@
       "import": "./dist/index.mjs",
       "default": "./dist/index.mjs"
     },
+    "./plugins": {
+      "types": "./dist/plugins/index.d.mts",
+      "import": "./dist/plugins/index.mjs",
+      "default": "./dist/plugins/index.mjs"
+    },
     "./standard": {
       "types": "./dist/adapters/standard/index.d.mts",
       "import": "./dist/adapters/standard/index.mjs",
@@ -28,18 +33,29 @@
       "types": "./dist/adapters/fetch/index.d.mts",
       "import": "./dist/adapters/fetch/index.mjs",
       "default": "./dist/adapters/fetch/index.mjs"
+    },
+    "./websocket": {
+      "types": "./dist/adapters/websocket/index.d.mts",
+      "import": "./dist/adapters/websocket/index.mjs",
+      "default": "./dist/adapters/websocket/index.mjs"
+    },
+    "./message-port": {
+      "types": "./dist/adapters/message-port/index.d.mts",
+      "import": "./dist/adapters/message-port/index.mjs",
+      "default": "./dist/adapters/message-port/index.mjs"
     }
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@orpc/shared": "0.0.0-next.b45a533",
-    "@orpc/standard-server": "0.0.0-next.b45a533",
-    "@orpc/standard-server-fetch": "0.0.0-next.b45a533"
+    "@orpc/shared": "0.0.0-next.b4897a0",
+    "@orpc/standard-server": "0.0.0-next.b4897a0",
+    "@orpc/standard-server-peer": "0.0.0-next.b4897a0",
+    "@orpc/standard-server-fetch": "0.0.0-next.b4897a0"
   },
   "devDependencies": {
-    "zod": "^3.24.2"
+    "zod": "^4.1.12"
   },
   "scripts": {
     "build": "unbuild",

package/dist/shared/client.D_CzLDyB.d.mts

@@ -1,42 +0,0 @@
-type ClientContext = Record<string, any>;
-type ClientOptions<TClientContext extends ClientContext> = {
-    signal?: AbortSignal;
-    lastEventId?: string | undefined;
-} & (Record<never, never> extends TClientContext ? {
-    context?: TClientContext;
-} : {
-    context: TClientContext;
-});
-type ClientRest<TClientContext extends ClientContext, TInput> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options: ClientOptions<TClientContext>];
-type ClientPromiseResult<TOutput, TError extends Error> = Promise<TOutput> & {
-    __error?: {
-        type: TError;
-    };
-};
-interface Client<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> {
-    (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
-}
-type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
-    [k: string]: NestedClient<TClientContext>;
-};
-type InferClientContext<T extends NestedClient<any>> = T extends NestedClient<infer U> ? U : never;
-type ClientOptionsOut<TClientContext extends ClientContext> = ClientOptions<TClientContext> & {
-    context: TClientContext;
-};
-interface ClientLink<TClientContext extends ClientContext> {
-    call: (path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>) => Promise<unknown>;
-}
-
-declare function mapEventIterator<TYield, TReturn, TNext, TMap = TYield | TReturn>(iterator: AsyncIterator<TYield, TReturn, TNext>, maps: {
-    value: (value: NoInfer<TYield | TReturn>, done: boolean | undefined) => Promise<TMap>;
-    error: (error: unknown) => Promise<unknown>;
-}): AsyncGenerator<TMap, TMap, TNext>;
-interface EventIteratorReconnectOptions {
-    lastRetry: number | undefined;
-    lastEventId: string | undefined;
-    retryTimes: number;
-    error: unknown;
-}
-declare function createAutoRetryEventIterator<TYield, TReturn>(initial: AsyncIterator<TYield, TReturn, void>, reconnect: (options: EventIteratorReconnectOptions) => Promise<AsyncIterator<TYield, TReturn, void> | null>, initialLastEventId: string | undefined): AsyncGenerator<TYield, TReturn, void>;
-
-export { type ClientContext as C, type EventIteratorReconnectOptions as E, type InferClientContext as I, type NestedClient as N, type ClientOptionsOut as a, type ClientLink as b, type ClientPromiseResult as c, createAutoRetryEventIterator as d, type ClientOptions as e, type ClientRest as f, type Client as g, mapEventIterator as m };

package/dist/shared/client.D_CzLDyB.d.ts

@@ -1,42 +0,0 @@
-type ClientContext = Record<string, any>;
-type ClientOptions<TClientContext extends ClientContext> = {
-    signal?: AbortSignal;
-    lastEventId?: string | undefined;
-} & (Record<never, never> extends TClientContext ? {
-    context?: TClientContext;
-} : {
-    context: TClientContext;
-});
-type ClientRest<TClientContext extends ClientContext, TInput> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options: ClientOptions<TClientContext>];
-type ClientPromiseResult<TOutput, TError extends Error> = Promise<TOutput> & {
-    __error?: {
-        type: TError;
-    };
-};
-interface Client<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> {
-    (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
-}
-type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
-    [k: string]: NestedClient<TClientContext>;
-};
-type InferClientContext<T extends NestedClient<any>> = T extends NestedClient<infer U> ? U : never;
-type ClientOptionsOut<TClientContext extends ClientContext> = ClientOptions<TClientContext> & {
-    context: TClientContext;
-};
-interface ClientLink<TClientContext extends ClientContext> {
-    call: (path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>) => Promise<unknown>;
-}
-
-declare function mapEventIterator<TYield, TReturn, TNext, TMap = TYield | TReturn>(iterator: AsyncIterator<TYield, TReturn, TNext>, maps: {
-    value: (value: NoInfer<TYield | TReturn>, done: boolean | undefined) => Promise<TMap>;
-    error: (error: unknown) => Promise<unknown>;
-}): AsyncGenerator<TMap, TMap, TNext>;
-interface EventIteratorReconnectOptions {
-    lastRetry: number | undefined;
-    lastEventId: string | undefined;
-    retryTimes: number;
-    error: unknown;
-}
-declare function createAutoRetryEventIterator<TYield, TReturn>(initial: AsyncIterator<TYield, TReturn, void>, reconnect: (options: EventIteratorReconnectOptions) => Promise<AsyncIterator<TYield, TReturn, void> | null>, initialLastEventId: string | undefined): AsyncGenerator<TYield, TReturn, void>;
-
-export { type ClientContext as C, type EventIteratorReconnectOptions as E, type InferClientContext as I, type NestedClient as N, type ClientOptionsOut as a, type ClientLink as b, type ClientPromiseResult as c, createAutoRetryEventIterator as d, type ClientOptions as e, type ClientRest as f, type Client as g, mapEventIterator as m };

package/dist/shared/client.Df5pd75N.mjs

@@ -1,320 +0,0 @@
-import { intercept, isAsyncIteratorObject, value, isObject, trim, stringifyJSON } from '@orpc/shared';
-import { c as createAutoRetryEventIterator, O as ORPCError, m as mapEventIterator, t as toORPCError } from './client.XAn8cDTM.mjs';
-import { ErrorEvent } from '@orpc/standard-server';
-
-class InvalidEventIteratorRetryResponse extends Error {
-}
-class StandardLink {
-  constructor(codec, sender, options) {
-    this.codec = codec;
-    this.sender = sender;
-    this.eventIteratorMaxRetries = options.eventIteratorMaxRetries ?? 5;
-    this.eventIteratorRetryDelay = options.eventIteratorRetryDelay ?? ((o) => o.lastRetry ?? 1e3 * 2 ** o.retryTimes);
-    this.eventIteratorShouldRetry = options.eventIteratorShouldRetry ?? true;
-    this.interceptors = options.interceptors ?? [];
-    this.clientInterceptors = options.clientInterceptors ?? [];
-  }
-  eventIteratorMaxRetries;
-  eventIteratorRetryDelay;
-  eventIteratorShouldRetry;
-  interceptors;
-  clientInterceptors;
-  call(path, input, options) {
-    return intercept(this.interceptors, { path, input, options }, async ({ path: path2, input: input2, options: options2 }) => {
-      const output = await this.#call(path2, input2, options2);
-      if (!isAsyncIteratorObject(output)) {
-        return output;
-      }
-      return createAutoRetryEventIterator(output, async (reconnectOptions) => {
-        const maxRetries = await value(this.eventIteratorMaxRetries, reconnectOptions, options2, path2, input2);
-        if (options2.signal?.aborted || reconnectOptions.retryTimes > maxRetries) {
-          return null;
-        }
-        const shouldRetry = await value(this.eventIteratorShouldRetry, reconnectOptions, options2, path2, input2);
-        if (!shouldRetry) {
-          return null;
-        }
-        const retryDelay = await value(this.eventIteratorRetryDelay, reconnectOptions, options2, path2, input2);
-        await new Promise((resolve) => setTimeout(resolve, retryDelay));
-        const updatedOptions = { ...options2, lastEventId: reconnectOptions.lastEventId };
-        const maybeIterator = await this.#call(path2, input2, updatedOptions);
-        if (!isAsyncIteratorObject(maybeIterator)) {
-          throw new InvalidEventIteratorRetryResponse("Invalid Event Iterator retry response");
-        }
-        return maybeIterator;
-      }, options2.lastEventId);
-    });
-  }
-  async #call(path, input, options) {
-    const request = await this.codec.encode(path, input, options);
-    const response = await intercept(
-      this.clientInterceptors,
-      { request },
-      ({ request: request2 }) => this.sender.call(request2, options, path, input)
-    );
-    const output = await this.codec.decode(response, options, path, input);
-    return output;
-  }
-}
-
-class RPCJsonSerializer {
-  serialize(data, segments = [], meta = [], maps = [], blobs = []) {
-    if (data instanceof Blob) {
-      maps.push(segments);
-      blobs.push(data);
-      return [data, meta, maps, blobs];
-    }
-    if (typeof data === "bigint") {
-      meta.push([0, segments]);
-      return [data.toString(), meta, maps, blobs];
-    }
-    if (data instanceof Date) {
-      meta.push([1, segments]);
-      if (Number.isNaN(data.getTime())) {
-        return [null, meta, maps, blobs];
-      }
-      return [data.toISOString(), meta, maps, blobs];
-    }
-    if (Number.isNaN(data)) {
-      meta.push([2, segments]);
-      return [null, meta, maps, blobs];
-    }
-    if (data instanceof URL) {
-      meta.push([4, segments]);
-      return [data.toString(), meta, maps, blobs];
-    }
-    if (data instanceof RegExp) {
-      meta.push([5, segments]);
-      return [data.toString(), meta, maps, blobs];
-    }
-    if (data instanceof Set) {
-      const result = this.serialize(Array.from(data), segments, meta, maps, blobs);
-      meta.push([6, segments]);
-      return result;
-    }
-    if (data instanceof Map) {
-      const result = this.serialize(Array.from(data.entries()), segments, meta, maps, blobs);
-      meta.push([7, segments]);
-      return result;
-    }
-    if (Array.isArray(data)) {
-      const json = data.map((v, i) => {
-        if (v === void 0) {
-          meta.push([3, [...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) {
-        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 [type, segments] of meta) {
-      let currentRef = ref;
-      let preSegment = "data";
-      segments.forEach((segment) => {
-        currentRef = currentRef[preSegment];
-        preSegment = segment;
-      });
-      switch (type) {
-        case 0:
-          currentRef[preSegment] = BigInt(currentRef[preSegment]);
-          break;
-        case 1:
-          currentRef[preSegment] = new Date(currentRef[preSegment] ?? "Invalid Date");
-          break;
-        case 2:
-          currentRef[preSegment] = Number.NaN;
-          break;
-        case 3:
-          currentRef[preSegment] = void 0;
-          break;
-        case 4:
-          currentRef[preSegment] = new URL(currentRef[preSegment]);
-          break;
-        case 5: {
-          const [, pattern, flags] = currentRef[preSegment].match(/^\/(.*)\/([a-z]*)$/);
-          currentRef[preSegment] = new RegExp(pattern, flags);
-          break;
-        }
-        case 6:
-          currentRef[preSegment] = new Set(currentRef[preSegment]);
-          break;
-        case 7:
-          currentRef[preSegment] = new Map(currentRef[preSegment]);
-          break;
-      }
-    }
-    return ref.data;
-  }
-}
-
-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);
-    const headers = await value(this.headers, options, path, input);
-    const baseUrl = await value(this.baseUrl, options, path, input);
-    const url = new URL(`${trim(baseUrl.toString(), "/")}/${path.map(encodeURIComponent).join("/")}`);
-    const serialized = this.serializer.serialize(input);
-    if (expectedMethod === "GET" && !(serialized instanceof FormData) && !(serialized instanceof Blob) && !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 = response.status >= 200 && response.status < 300;
-    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 (ORPCError.isValidJSON(deserialized)) {
-        throw ORPCError.fromJSON(deserialized);
-      }
-      throw new Error("Invalid RPC error response format.", {
-        cause: deserialized
-      });
-    }
-    return deserialized;
-  }
-}
-
-class RPCSerializer {
-  constructor(jsonSerializer = new RPCJsonSerializer()) {
-    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) {
-    if (data === void 0 || data instanceof Blob) {
-      return data;
-    }
-    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 (ORPCError.isValidJSON(deserialized)) {
-            return ORPCError.fromJSON(deserialized, { cause: e });
-          }
-          return new ErrorEvent({
-            data: deserialized,
-            cause: e
-          });
-        }
-      });
-    }
-    return this.#deserialize(data);
-  }
-  #deserialize(data) {
-    if (data === void 0 || data instanceof Blob) {
-      return 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 { InvalidEventIteratorRetryResponse as I, RPCJsonSerializer as R, StandardLink as S, StandardRPCLinkCodec as a, RPCSerializer as b };