@temporary-name/server 1.9.3-alpha.26612c2cf6a7177d2b500d984d282309d8320ca3 → 1.9.3-alpha.2957dbc009ec31fa21575f028b83c96651cba827

package/dist/openapi/index.mjs

@@ -1,7 +1,7 @@
-import { isProcedure, resolveContractProcedures, ORPCError, createRouterClient } from '@temporary-name/server';
-import { fallbackContractConfig, getEventIteratorSchemaDetails } from '@temporary-name/contract';
-import { isObject, stringifyJSON, findDeepMatches, toArray, clone, value, toHttpPath, isORPCErrorStatus, fallbackORPCErrorStatus, fallbackORPCErrorMessage, resolveMaybeOptionalOptions, createORPCErrorFromJson } from '@temporary-name/shared';
-import { a as standardizeHTTPPath, j as jsonSerialize, g as getDynamicParams, d as deserialize, s as serialize } from '../shared/server.Kxw442A9.mjs';
+import { standardizeHTTPPath, fallbackContractConfig, getDynamicParams, getEventIteratorSchemaDetails } from '@temporary-name/contract';
+import { resolveContractProcedures } from '@temporary-name/server';
+import { isObject, stringifyJSON, findDeepMatches, toArray, clone, value, toHttpPath, isORPCErrorStatus } from '@temporary-name/shared';
+import { j as jsonSerialize } from '../shared/server.CQIFwyhc.mjs';
 import '@temporary-name/standard-server';
 import { TypeName } from '@temporary-name/interop/json-schema-typed/draft-2020-12';
 export { ContentEncoding as JSONSchemaContentEncoding, Format as JSONSchemaFormat, TypeName as JSONSchemaTypeName } from '@temporary-name/interop/json-schema-typed/draft-2020-12';
@@ -22,20 +22,12 @@ function getCustomOpenAPIOperation(o) {
 }
 function applyCustomOpenAPIOperation(operation, contract) {
   const operationCustoms = [];
-  for (const errorItem of Object.values(contract["~orpc"].errorMap)) {
-    const maybeExtender = errorItem ? getCustomOpenAPIOperation(errorItem) : void 0;
+  for (const middleware of contract["~orpc"].middlewares) {
+    const maybeExtender = getCustomOpenAPIOperation(middleware);
     if (maybeExtender) {
       operationCustoms.push(maybeExtender);
     }
   }
-  if (isProcedure(contract)) {
-    for (const middleware of contract["~orpc"].middlewares) {
-      const maybeExtender = getCustomOpenAPIOperation(middleware);
-      if (maybeExtender) {
-        operationCustoms.push(maybeExtender);
-      }
-    }
-  }
   let currentOperation = operation;
   for (const custom of operationCustoms) {
     if (typeof custom === "function") {
@@ -432,12 +424,6 @@ class OpenAPIGenerator {
           };
           await this.#request(doc, operationObjectRef, def, baseSchemaConvertOptions);
           await this.#successResponse(doc, operationObjectRef, def, baseSchemaConvertOptions);
-          await this.#errorResponse(
-            operationObjectRef,
-            def,
-            baseSchemaConvertOptions,
-            undefinedErrorJsonSchema
-          );
         }
         if (typeof def.route.spec === "function") {
           operationObjectRef = def.route.spec(operationObjectRef);
@@ -530,60 +516,77 @@ ${errors.join("\n\n")}`
   }
   async #request(doc, ref, def, baseSchemaConvertOptions) {
     const method = fallbackContractConfig("defaultMethod", def.route.method);
-    const details = getEventIteratorSchemaDetails(def.inputSchema);
-    if (details) {
-      ref.requestBody = {
-        required: true,
-        content: toOpenAPIEventIteratorContent(
-          await this.converter.convert(details.yields, { ...baseSchemaConvertOptions, strategy: "input" }),
-          await this.converter.convert(details.returns, { ...baseSchemaConvertOptions, strategy: "input" })
-        )
-      };
-      return;
-    }
     const dynamicParams = getDynamicParams(def.route.path)?.map((v) => v.name);
-    let [required, schema] = await this.converter.convert(def.inputSchema, {
+    const [_pathRequired, pathSchema] = await this.converter.convert(def.schemas.pathSchema, {
       ...baseSchemaConvertOptions,
       strategy: "input",
-      minStructureDepthForRef: dynamicParams?.length ? 1 : 0
+      minStructureDepthForRef: 1
     });
-    if (isAnySchema(schema) && !dynamicParams?.length) {
-      return;
-    }
     if (dynamicParams?.length) {
       const error = new OpenAPIGeneratorError(
+        // TODO: fix this error
         'When input structure is "compact", and path has dynamic params, input schema must be an object with all dynamic params as required.'
       );
-      if (!isObjectSchema(schema)) {
+      if (!isObjectSchema(pathSchema)) {
         throw error;
       }
-      const [paramsSchema, rest] = separateObjectSchema(schema, dynamicParams);
-      schema = rest;
-      required = rest.required ? rest.required.length !== 0 : false;
-      if (!checkParamsSchema(paramsSchema, dynamicParams)) {
+      if (!checkParamsSchema(pathSchema, dynamicParams)) {
         throw error;
       }
       ref.parameters ??= [];
-      ref.parameters.push(...toOpenAPIParameters(paramsSchema, "path"));
+      ref.parameters.push(...toOpenAPIParameters(pathSchema, "path"));
+    } else {
+      const error = new OpenAPIGeneratorError("Params set via path do not match those on the route");
+      if (!isObjectSchema(pathSchema)) {
+        console.log("FOO", pathSchema);
+        throw error;
+      }
+      if (!checkParamsSchema(pathSchema, [])) {
+        console.log("BAR", pathSchema);
+        throw error;
+      }
     }
-    if (method === "GET") {
-      const resolvedSchema = resolveOpenAPIJsonSchemaRef(doc, schema);
+    const [_queryRequired, querySchema] = await this.converter.convert(def.schemas.querySchema, {
+      ...baseSchemaConvertOptions,
+      strategy: "input",
+      minStructureDepthForRef: 0
+    });
+    if (!isAnySchema(querySchema)) {
+      const resolvedSchema = resolveOpenAPIJsonSchemaRef(doc, querySchema);
       if (!isObjectSchema(resolvedSchema)) {
-        throw new OpenAPIGeneratorError(
-          'When method is "GET", input schema must satisfy: object | any | unknown'
-        );
+        throw new OpenAPIGeneratorError("Query param schema must satisfy: object | any | unknown");
       }
       ref.parameters ??= [];
       ref.parameters.push(...toOpenAPIParameters(resolvedSchema, "query"));
-    } else {
-      ref.requestBody = {
-        required,
-        content: toOpenAPIContent(schema)
-      };
+    }
+    if (method !== "GET") {
+      const details = getEventIteratorSchemaDetails(def.schemas.bodySchema);
+      if (details) {
+        ref.requestBody = {
+          required: true,
+          content: toOpenAPIEventIteratorContent(
+            await this.converter.convert(details.yields, { ...baseSchemaConvertOptions, strategy: "input" }),
+            await this.converter.convert(details.returns, { ...baseSchemaConvertOptions, strategy: "input" })
+          )
+        };
+      } else {
+        const [bodyRequired, bodySchema] = await this.converter.convert(def.schemas.bodySchema, {
+          ...baseSchemaConvertOptions,
+          strategy: "input",
+          minStructureDepthForRef: 0
+        });
+        if (isAnySchema(bodySchema)) {
+          return;
+        }
+        ref.requestBody = {
+          required: bodyRequired,
+          content: toOpenAPIContent(bodySchema)
+        };
+      }
     }
   }
   async #successResponse(doc, ref, def, baseSchemaConvertOptions) {
-    const outputSchema = def.outputSchema;
+    const outputSchema = def.schemas.outputSchema;
     const status = fallbackContractConfig("defaultSuccessStatus", def.route.successStatus);
     const description = fallbackContractConfig("defaultSuccessDescription", def.route?.successDescription);
     const eventIteratorSchemaDetails = getEventIteratorSchemaDetails(outputSchema);
@@ -679,64 +682,10 @@ ${errors.join("\n\n")}`
       }
     }
   }
-  async #errorResponse(ref, def, baseSchemaConvertOptions, undefinedErrorSchema) {
-    const errorMap = def.errorMap;
-    const errors = {};
-    for (const code in errorMap) {
-      const config = errorMap[code];
-      if (!config) {
-        continue;
-      }
-      const status = fallbackORPCErrorStatus(code, config.status);
-      const message = fallbackORPCErrorMessage(code, config.message);
-      const [dataRequired, dataSchema] = await this.converter.convert(config.data, {
-        ...baseSchemaConvertOptions,
-        strategy: "output"
-      });
-      errors[status] ??= [];
-      errors[status].push({
-        type: "object",
-        properties: {
-          defined: { const: true },
-          code: { const: code },
-          status: { const: status },
-          message: { type: "string", default: message },
-          data: dataSchema
-        },
-        required: dataRequired ? ["defined", "code", "status", "message", "data"] : ["defined", "code", "status", "message"]
-      });
-    }
-    ref.responses ??= {};
-    for (const status in errors) {
-      const schemas = errors[status];
-      ref.responses[status] = {
-        description: status,
-        content: toOpenAPIContent({
-          oneOf: [...schemas, undefinedErrorSchema]
-        })
-      };
-    }
-  }
-}
-
-function createJsonifiedRouterClient(router, ...rest) {
-  const options = resolveMaybeOptionalOptions(rest);
-  options.interceptors ??= [];
-  options.interceptors.unshift(async (options2) => {
-    try {
-      return deserialize(serialize(await options2.next()));
-    } catch (e) {
-      if (e instanceof ORPCError) {
-        throw createORPCErrorFromJson(deserialize(serialize(e.toJSON(), { outputFormat: "plain" })));
-      }
-      throw e;
-    }
-  });
-  return createRouterClient(router, options);
 }
 
 const oo = {
   spec: customOpenAPIOperation
 };
 
-export { CompositeSchemaConverter, LOGIC_KEYWORDS, OpenAPIGenerator, applyCustomOpenAPIOperation, applySchemaOptionality, checkParamsSchema, createJsonifiedRouterClient, customOpenAPIOperation, expandArrayableSchema, expandUnionSchema, filterSchemaBranches, getCustomOpenAPIOperation, isAnySchema, isFileSchema, isObjectSchema, isPrimitiveSchema, oo, resolveOpenAPIJsonSchemaRef, separateObjectSchema, toOpenAPIContent, toOpenAPIEventIteratorContent, toOpenAPIMethod, toOpenAPIParameters, toOpenAPIPath, toOpenAPISchema };
+export { CompositeSchemaConverter, LOGIC_KEYWORDS, OpenAPIGenerator, applyCustomOpenAPIOperation, applySchemaOptionality, checkParamsSchema, customOpenAPIOperation, expandArrayableSchema, expandUnionSchema, filterSchemaBranches, getCustomOpenAPIOperation, isAnySchema, isFileSchema, isObjectSchema, isPrimitiveSchema, oo, resolveOpenAPIJsonSchemaRef, separateObjectSchema, toOpenAPIContent, toOpenAPIEventIteratorContent, toOpenAPIMethod, toOpenAPIParameters, toOpenAPIPath, toOpenAPISchema };

package/dist/shared/{server.CjkiSCui.mjs → server.B7tjiDal.mjs}

@@ -1,7 +1,7 @@
-import { isContractProcedure, mergePrefix, mergeErrorMap, enhanceRoute, validateORPCError, ValidationError } from '@temporary-name/contract';
-import { resolveMaybeOptionalOptions, ORPCError, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, overlayProxy, asyncIteratorWithSpan } from '@temporary-name/shared';
+import { mergePrefix, enhanceRoute, ValidationError } from '@temporary-name/contract';
+import { resolveMaybeOptionalOptions, toArray, value, runWithSpan, isAsyncIteratorObject, overlayProxy, asyncIteratorWithSpan, ORPCError } from '@temporary-name/shared';
 import { HibernationEventIterator, mapEventIterator } from '@temporary-name/standard-server';
-import { safeParseAsync } from '@temporary-name/zod';
+import { safeDecodeAsync, safeEncodeAsync } from '@temporary-name/zod';
 
 function isStartWithMiddlewares(middlewares, compare) {
   if (compare.length > middlewares.length) {
@@ -27,7 +27,7 @@ function addMiddleware(middlewares, addition) {
   return [...middlewares, addition];
 }
 
-class Procedure {
+class Contract {
   /**
    * This property holds the defined options.
    */
@@ -36,55 +36,17 @@ class Procedure {
     this["~orpc"] = def;
   }
 }
+class Procedure extends Contract {
+}
 function isProcedure(item) {
-  if (item instanceof Procedure) {
-    return true;
-  }
-  return isContractProcedure(item) && "middlewares" in item["~orpc"] && "handler" in item["~orpc"];
+  return item instanceof Procedure || // This is so we'll return true for Proxy-wrapped Procedures e.g. as returned by `callable`
+  (typeof item === "object" || typeof item === "function") && item !== null && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "route" in item["~orpc"] && "meta" in item["~orpc"] && "middlewares" in item["~orpc"] && "inputValidationIndex" in item["~orpc"] && "outputValidationIndex" in item["~orpc"] && "handler" in item["~orpc"];
 }
 
 function mergeCurrentContext(context, other) {
   return { ...context, ...other };
 }
 
-function createORPCErrorConstructorMap(errors) {
-  const proxy = new Proxy(errors, {
-    get(target, code) {
-      if (typeof code !== "string") {
-        return Reflect.get(target, code);
-      }
-      const item = (...rest) => {
-        const options = resolveMaybeOptionalOptions(rest);
-        const config = errors[code];
-        return new ORPCError(code, {
-          defined: Boolean(config),
-          status: config?.status,
-          message: options.message ?? config?.message,
-          data: options.data,
-          cause: options.cause
-        });
-      };
-      return item;
-    }
-  });
-  return proxy;
-}
-
-const HIDDEN_ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_HIDDEN_ROUTER_CONTRACT");
-function setHiddenRouterContract(router, contract) {
-  return new Proxy(router, {
-    get(target, key) {
-      if (key === HIDDEN_ROUTER_CONTRACT_SYMBOL) {
-        return contract;
-      }
-      return Reflect.get(target, key);
-    }
-  });
-}
-function getHiddenRouterContract(router) {
-  return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
-}
-
 function getRouter(router, path) {
   let current = router;
   for (let i = 0; i < path.length; i++) {
@@ -147,7 +109,6 @@ function enhanceRouter(router, options) {
     const enhanced2 = new Procedure({
       ...router["~orpc"],
       route: enhanceRoute(router["~orpc"].route, options),
-      errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
       middlewares: newMiddlewares,
       inputValidationIndex: router["~orpc"].inputValidationIndex + newMiddlewareAdded,
       outputValidationIndex: router["~orpc"].outputValidationIndex + newMiddlewareAdded
@@ -161,21 +122,19 @@ function enhanceRouter(router, options) {
   return enhanced;
 }
 function traverseContractProcedures(options, callback, lazyOptions = []) {
-  let currentRouter = options.router;
-  const hiddenContract = getHiddenRouterContract(options.router);
-  if (hiddenContract !== void 0) {
-    currentRouter = hiddenContract;
-  }
+  const currentRouter = options.router;
   if (isLazy(currentRouter)) {
     lazyOptions.push({
       router: currentRouter,
       path: options.path
     });
-  } else if (isContractProcedure(currentRouter)) {
+  } else if (currentRouter instanceof Contract) {
     callback({
       contract: currentRouter,
       path: options.path
     });
+  } else if (typeof currentRouter === "string") {
+    throw new Error("Unexpected: got string instead of router");
   } else {
     for (const key in currentRouter) {
       traverseContractProcedures(
@@ -228,7 +187,6 @@ function lazyInternal(loader, meta = {}) {
 function lazy(prefix, loader) {
   return enhanceRouter(lazyInternal(loader), {
     middlewares: [],
-    errorMap: {},
     dedupeLeadingMiddlewares: true,
     prefix
   });
@@ -254,85 +212,82 @@ function createProcedureClient(lazyableProcedure, ...rest) {
     const { default: procedure } = await unlazy(lazyableProcedure);
     const clientContext = callerOptions?.context ?? {};
     const context = await value(options.context ?? {}, clientContext);
-    const errors = createORPCErrorConstructorMap(procedure["~orpc"].errorMap);
-    const validateError = async (e) => {
-      if (e instanceof ORPCError) {
-        return await validateORPCError(procedure["~orpc"].errorMap, e);
-      }
-      return e;
-    };
-    try {
-      const output = await runWithSpan({ name: "call_procedure", signal: callerOptions?.signal }, (span) => {
-        span?.setAttribute("procedure.path", [...path]);
-        return intercept(
-          toArray(options.interceptors),
-          {
-            context,
-            input,
-            // input only optional when it undefinable so we can safely cast it
-            errors,
-            path,
-            procedure,
-            signal: callerOptions?.signal,
-            lastEventId: callerOptions?.lastEventId
-          },
-          (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions)
-        );
+    const output = await runWithSpan({ name: "call_procedure", signal: callerOptions?.signal }, (span) => {
+      span?.setAttribute("procedure.path", [...path]);
+      return executeProcedureInternal(procedure, input, {
+        context,
+        path,
+        procedure,
+        request: callerOptions?.request,
+        signal: callerOptions?.signal,
+        lastEventId: callerOptions?.lastEventId
       });
-      if (isAsyncIteratorObject(output)) {
-        if (output instanceof HibernationEventIterator) {
-          return output;
-        }
-        return overlayProxy(
-          output,
-          mapEventIterator(
-            asyncIteratorWithSpan(
-              { name: "consume_event_iterator_output", signal: callerOptions?.signal },
-              output
-            ),
-            {
-              value: (v) => v,
-              error: (e) => validateError(e)
-            }
-          )
-        );
+    });
+    if (isAsyncIteratorObject(output)) {
+      if (output instanceof HibernationEventIterator) {
+        return output;
       }
-      return output;
-    } catch (e) {
-      throw await validateError(e);
+      return overlayProxy(
+        output,
+        mapEventIterator(
+          asyncIteratorWithSpan(
+            { name: "consume_event_iterator_output", signal: callerOptions?.signal },
+            output
+          ),
+          {
+            value: (v) => v,
+            error: async (e) => e
+          }
+        )
+      );
     }
+    return output;
   };
 }
 async function validateInput(procedure, input) {
-  const schema = procedure["~orpc"].inputSchema;
-  if (!schema) {
-    return input;
-  }
+  const schemas = procedure["~orpc"].schemas;
   return runWithSpan({ name: "validate_input" }, async () => {
-    const result = await safeParseAsync(schema, input);
-    if (!result.success) {
+    const resultBody = await safeDecodeAsync(schemas.bodySchema, input.body, { parseType: "body" });
+    const resultPath = await safeDecodeAsync(schemas.pathSchema, input.path, { parseType: "path" });
+    const resultQuery = await safeDecodeAsync(schemas.querySchema, input.query, { parseType: "query" });
+    const issues = [];
+    if (!resultBody.success) {
+      issues.push(...resultBody.error.issues.map((i) => ({ ...i, path: ["body", ...i.path] })));
+    }
+    if (!resultPath.success) {
+      issues.push(...resultPath.error.issues.map((i) => ({ ...i, path: ["path", ...i.path] })));
+    }
+    if (!resultQuery.success) {
+      issues.push(...resultQuery.error.issues.map((i) => ({ ...i, path: ["query", ...i.path] })));
+    }
+    if (issues.length > 0) {
       throw new ORPCError("BAD_REQUEST", {
         message: "Input validation failed",
         data: {
-          issues: result.error.issues
+          issues
         },
         cause: new ValidationError({
           message: "Input validation failed",
-          issues: result.error.issues,
+          issues,
           data: input
         })
       });
     }
-    return result.data;
+    const results = {
+      body: resultBody.data,
+      path: resultPath.data,
+      query: resultQuery.data
+    };
+    return results;
   });
 }
 async function validateOutput(procedure, output) {
-  const schema = procedure["~orpc"].outputSchema;
+  const schema = procedure["~orpc"].schemas.outputSchema;
   if (!schema) {
     return output;
   }
   return runWithSpan({ name: "validate_output" }, async () => {
-    const result = await safeParseAsync(schema, output);
+    const result = await safeEncodeAsync(schema, output, { parseType: "output" });
     if (!result.success) {
       throw new ORPCError("INTERNAL_SERVER_ERROR", {
         message: "Output validation failed",
@@ -346,7 +301,7 @@ async function validateOutput(procedure, output) {
     return result.data;
   });
 }
-async function executeProcedureInternal(procedure, options) {
+async function executeProcedureInternal(procedure, input, options) {
   const middlewares = procedure["~orpc"].middlewares;
   const inputValidationIndex = Math.min(
     Math.max(0, procedure["~orpc"].inputValidationIndex),
@@ -356,8 +311,8 @@ async function executeProcedureInternal(procedure, options) {
     Math.max(0, procedure["~orpc"].outputValidationIndex),
     middlewares.length
   );
-  const next = async (index, context, input) => {
-    let currentInput = input;
+  const next = async (index, context, input2) => {
+    let currentInput = input2;
     if (index === inputValidationIndex) {
       currentInput = await validateInput(procedure, currentInput);
     }
@@ -373,6 +328,9 @@ async function executeProcedureInternal(procedure, options) {
             const nextContext = nextOptions?.context ?? {};
             return {
               output: await next(index + 1, mergeCurrentContext(context, nextContext), currentInput),
+              // NB: Pretty sure this isn't used (or meant to be used) at runtime, it's just there
+              // to get type inference in the builder (via the caller returning the output of next() in
+              // the middleware function)
               context: nextContext
             };
           }
@@ -383,14 +341,14 @@ async function executeProcedureInternal(procedure, options) {
       return result.output;
     }) : await runWithSpan(
       { name: "handler", signal: options.signal },
-      () => procedure["~orpc"].handler({ ...options, context, input: currentInput })
+      () => procedure["~orpc"].handler(currentInput, { ...options, context })
     );
     if (index === outputValidationIndex) {
       return await validateOutput(procedure, output);
     }
     return output;
   };
-  return next(0, options.context, options.input);
+  return next(0, options.context, input);
 }
 
-export { LAZY_SYMBOL as L, Procedure as P, addMiddleware as a, isLazy as b, createProcedureClient as c, getRouter as d, enhanceRouter as e, createORPCErrorConstructorMap as f, getLazyMeta as g, lazy as h, isProcedure as i, middlewareOutputFn as j, isStartWithMiddlewares as k, lazyInternal as l, mergeCurrentContext as m, mergeMiddlewares as n, getHiddenRouterContract as o, createAccessibleLazyRouter as p, unlazyRouter as q, resolveContractProcedures as r, setHiddenRouterContract as s, traverseContractProcedures as t, unlazy as u };
+export { Contract as C, LAZY_SYMBOL as L, Procedure as P, addMiddleware as a, isLazy as b, createProcedureClient as c, getRouter as d, enhanceRouter as e, lazy as f, getLazyMeta as g, middlewareOutputFn as h, isProcedure as i, isStartWithMiddlewares as j, mergeMiddlewares as k, lazyInternal as l, mergeCurrentContext as m, createAccessibleLazyRouter as n, unlazyRouter as o, resolveContractProcedures as r, traverseContractProcedures as t, unlazy as u };

package/dist/shared/server.C1RJffw4.mjs

@@ -0,0 +1,30 @@
+import { parse, serialize } from 'cookie';
+
+function setCookie(headers, name, value, options = {}) {
+  if (headers === void 0) {
+    return;
+  }
+  const cookieString = serialize(name, value, {
+    path: "/",
+    ...options
+  });
+  headers.append("Set-Cookie", cookieString);
+}
+function getCookie(headers, name, options = {}) {
+  if (headers === void 0) {
+    return void 0;
+  }
+  const cookieHeader = headers.get("cookie");
+  if (cookieHeader === null) {
+    return void 0;
+  }
+  return parse(cookieHeader, options)[name];
+}
+function deleteCookie(headers, name, options = {}) {
+  return setCookie(headers, name, "", {
+    ...options,
+    maxAge: 0
+  });
+}
+
+export { deleteCookie as d, getCookie as g, setCookie as s };

package/dist/shared/server.CQIFwyhc.mjs

@@ -0,0 +1,40 @@
+import { isObject } from '@temporary-name/shared';
+
+function jsonSerialize(data, hasBlobRef = { value: false }) {
+  if (data instanceof Blob) {
+    hasBlobRef.value = true;
+    return [data, hasBlobRef.value];
+  }
+  if (data instanceof Set) {
+    return jsonSerialize(Array.from(data), hasBlobRef);
+  }
+  if (data instanceof Map) {
+    return jsonSerialize(Array.from(data.entries()), hasBlobRef);
+  }
+  if (Array.isArray(data)) {
+    const json = data.map((v) => v === void 0 ? null : jsonSerialize(v, hasBlobRef)[0]);
+    return [json, hasBlobRef.value];
+  }
+  if (isObject(data)) {
+    const json = {};
+    for (const k in data) {
+      if (k === "toJSON" && typeof data[k] === "function") {
+        continue;
+      }
+      json[k] = jsonSerialize(data[k], hasBlobRef)[0];
+    }
+    return [json, hasBlobRef.value];
+  }
+  if (typeof data === "bigint" || data instanceof RegExp || data instanceof URL) {
+    return [data.toString(), hasBlobRef.value];
+  }
+  if (data instanceof Date) {
+    return [Number.isNaN(data.getTime()) ? null : data.toISOString(), hasBlobRef.value];
+  }
+  if (Number.isNaN(data)) {
+    return [null, hasBlobRef.value];
+  }
+  return [data, hasBlobRef.value];
+}
+
+export { jsonSerialize as j };