every-plugin 0.4.3 → 0.4.5

package/dist/zod4-BXTBR1od.cjs

@@ -0,0 +1,318 @@
+const require_chunk = require('./chunk-zltIcp7o.cjs');
+const require_standard = require('./standard-eUgUkWaf.cjs');
+const require_openapi_DrTcell5 = require('./openapi.DrTcell5-DDf4D5V3.cjs');
+let __orpc_server = require("@orpc/server");
+let __orpc_contract = require("@orpc/contract");
+let zod_v4_core = require("zod/v4/core");
+
+//#region ../../node_modules/.bun/@orpc+json-schema@1.10.4/node_modules/@orpc/json-schema/dist/index.mjs
+var JsonSchemaXNativeType = /* @__PURE__ */ ((JsonSchemaXNativeType2) => {
+	JsonSchemaXNativeType2["BigInt"] = "bigint";
+	JsonSchemaXNativeType2["RegExp"] = "regexp";
+	JsonSchemaXNativeType2["Date"] = "date";
+	JsonSchemaXNativeType2["Url"] = "url";
+	JsonSchemaXNativeType2["Set"] = "set";
+	JsonSchemaXNativeType2["Map"] = "map";
+	return JsonSchemaXNativeType2;
+})(JsonSchemaXNativeType || {});
+
+//#endregion
+//#region ../../node_modules/.bun/@orpc+zod@1.10.4+b4e43a763b4e0453/node_modules/@orpc/zod/dist/zod4/index.mjs
+const JSON_SCHEMA_REGISTRY = (0, zod_v4_core.registry)();
+const JSON_SCHEMA_INPUT_REGISTRY = (0, zod_v4_core.registry)();
+const JSON_SCHEMA_OUTPUT_REGISTRY = (0, zod_v4_core.registry)();
+var ZodToJsonSchemaConverter = class {
+	maxLazyDepth;
+	maxStructureDepth;
+	anyJsonSchema;
+	unsupportedJsonSchema;
+	undefinedJsonSchema;
+	interceptors;
+	constructor(options = {}) {
+		this.maxLazyDepth = options.maxLazyDepth ?? 2;
+		this.maxStructureDepth = options.maxStructureDepth ?? 10;
+		this.anyJsonSchema = options.anyJsonSchema ?? {};
+		this.unsupportedJsonSchema = options.unsupportedJsonSchema ?? { not: {} };
+		this.undefinedJsonSchema = options.undefinedJsonSchema ?? { not: {} };
+		this.interceptors = options.interceptors ?? [];
+	}
+	condition(schema) {
+		return schema !== void 0 && schema["~standard"].vendor === "zod" && "_zod" in schema;
+	}
+	convert(schema, options) {
+		return this.#convert(schema, options, 0, 0);
+	}
+	#convert(schema, options, lazyDepth, structureDepth, isHandledCustomJSONSchema = false) {
+		return require_standard.intercept(this.interceptors, {
+			schema,
+			options,
+			lazyDepth,
+			isHandledCustomJSONSchema
+		}, ({ schema: schema2, options: options2, lazyDepth: lazyDepth2, isHandledCustomJSONSchema: isHandledCustomJSONSchema2 }) => {
+			if (structureDepth > this.maxStructureDepth) return [false, this.anyJsonSchema];
+			if (!options2.minStructureDepthForRef || options2.minStructureDepthForRef <= structureDepth) {
+				const components = require_standard.toArray(options2.components);
+				for (const component of components) if (component.schema === schema2 && component.allowedStrategies.includes(options2.strategy)) return [component.required, { $ref: component.ref }];
+			}
+			if (!isHandledCustomJSONSchema2) {
+				const customJSONSchema = this.#getCustomJsonSchema(schema2, options2);
+				if (customJSONSchema) {
+					const [required, json] = this.#convert(schema2, options2, lazyDepth2, structureDepth, true);
+					return [required, {
+						...json,
+						...customJSONSchema
+					}];
+				}
+			}
+			switch (schema2._zod.def.type) {
+				case "string": {
+					const string = schema2;
+					const json = { type: "string" };
+					const { minimum, maximum, format, patterns, contentEncoding } = string._zod.bag;
+					if (typeof minimum === "number") json.minLength = minimum;
+					if (typeof maximum === "number") json.maxLength = maximum;
+					if (typeof contentEncoding === "string") json.contentEncoding = this.#handleContentEncoding(contentEncoding);
+					if (typeof format === "string" && format !== "regex" && json.contentEncoding === void 0) json.format = this.#handleStringFormat(format);
+					if (patterns instanceof Set && json.contentEncoding === void 0 && json.format === void 0) for (const pattern of patterns) if (json.pattern === void 0) json.pattern = pattern.source;
+					else {
+						json.allOf ??= [];
+						json.allOf.push({ pattern: pattern.source });
+					}
+					if (format === "jwt" && json.contentEncoding === void 0 && json.format === void 0 && json.pattern === void 0) json.pattern = /^[\w-]+\.[\w-]+\.[\w-]+$/.source;
+					return [true, json];
+				}
+				case "number": {
+					const number = schema2;
+					const json = { type: "number" };
+					const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = number._zod.bag;
+					if (typeof format === "string" && format?.includes("int")) json.type = "integer";
+					if (typeof minimum === "number") json.minimum = minimum;
+					if (typeof maximum === "number") json.maximum = maximum;
+					if (typeof exclusiveMinimum === "number") json.exclusiveMinimum = exclusiveMinimum;
+					if (typeof exclusiveMaximum === "number") json.exclusiveMaximum = exclusiveMaximum;
+					if (typeof multipleOf === "number") json.multipleOf = multipleOf;
+					return [true, json];
+				}
+				case "boolean": return [true, { type: "boolean" }];
+				case "bigint": return [true, {
+					"type": "string",
+					"pattern": "^-?[0-9]+$",
+					"x-native-type": JsonSchemaXNativeType.BigInt
+				}];
+				case "date": return [true, {
+					"type": "string",
+					"format": require_openapi_DrTcell5.Format.DateTime,
+					"x-native-type": JsonSchemaXNativeType.Date
+				}];
+				case "null": return [true, { type: "null" }];
+				case "undefined":
+				case "void": return [false, this.undefinedJsonSchema];
+				case "any": return [false, this.anyJsonSchema];
+				case "unknown": return [false, this.anyJsonSchema];
+				case "never": return [true, this.unsupportedJsonSchema];
+				case "array": {
+					const array = schema2;
+					const json = { type: "array" };
+					const { minimum, maximum } = array._zod.bag;
+					if (typeof minimum === "number") json.minItems = minimum;
+					if (typeof maximum === "number") json.maxItems = maximum;
+					json.items = this.#handleArrayItemJsonSchema(this.#convert(array._zod.def.element, options2, lazyDepth2, structureDepth + 1), options2);
+					return [true, json];
+				}
+				case "object": {
+					const object = schema2;
+					const json = { type: "object" };
+					for (const [key, value] of Object.entries(object._zod.def.shape)) {
+						const [itemRequired, itemJson] = this.#convert(value, options2, lazyDepth2, structureDepth + 1);
+						json.properties ??= {};
+						json.properties[key] = itemJson;
+						if (itemRequired) {
+							json.required ??= [];
+							json.required.push(key);
+						}
+					}
+					if (object._zod.def.catchall) if (object._zod.def.catchall._zod.def.type === "never") json.additionalProperties = false;
+					else {
+						const [_, addJson] = this.#convert(object._zod.def.catchall, options2, lazyDepth2, structureDepth + 1);
+						json.additionalProperties = addJson;
+					}
+					return [true, json];
+				}
+				case "union": {
+					const union = schema2;
+					const anyOf = [];
+					let required = true;
+					for (const item of union._zod.def.options) {
+						const [itemRequired, itemJson] = this.#convert(item, options2, lazyDepth2, structureDepth + 1);
+						if (!itemRequired) required = false;
+						if (options2.strategy === "input") {
+							if (itemJson !== this.undefinedJsonSchema && itemJson !== this.unsupportedJsonSchema) anyOf.push(itemJson);
+						} else if (itemJson !== this.undefinedJsonSchema) anyOf.push(itemJson);
+					}
+					return [required, { anyOf }];
+				}
+				case "intersection": {
+					const intersection = schema2;
+					const json = { allOf: [] };
+					let required = false;
+					for (const item of [intersection._zod.def.left, intersection._zod.def.right]) {
+						const [itemRequired, itemJson] = this.#convert(item, options2, lazyDepth2, structureDepth + 1);
+						json.allOf.push(itemJson);
+						if (itemRequired) required = true;
+					}
+					return [required, json];
+				}
+				case "tuple": {
+					const tuple = schema2;
+					const json = {
+						type: "array",
+						prefixItems: []
+					};
+					for (const item of tuple._zod.def.items) json.prefixItems.push(this.#handleArrayItemJsonSchema(this.#convert(item, options2, lazyDepth2, structureDepth + 1), options2));
+					if (tuple._zod.def.rest) json.items = this.#handleArrayItemJsonSchema(this.#convert(tuple._zod.def.rest, options2, lazyDepth2, structureDepth + 1), options2);
+					const { minimum, maximum } = tuple._zod.bag;
+					if (typeof minimum === "number") json.minItems = minimum;
+					if (typeof maximum === "number") json.maxItems = maximum;
+					return [true, json];
+				}
+				case "record": {
+					const record = schema2;
+					const json = { type: "object" };
+					json.propertyNames = this.#convert(record._zod.def.keyType, options2, lazyDepth2, structureDepth + 1)[1];
+					json.additionalProperties = this.#convert(record._zod.def.valueType, options2, lazyDepth2, structureDepth + 1)[1];
+					return [true, json];
+				}
+				case "map": {
+					const map = schema2;
+					return [true, {
+						"type": "array",
+						"items": {
+							type: "array",
+							prefixItems: [this.#handleArrayItemJsonSchema(this.#convert(map._zod.def.keyType, options2, lazyDepth2, structureDepth + 1), options2), this.#handleArrayItemJsonSchema(this.#convert(map._zod.def.valueType, options2, lazyDepth2, structureDepth + 1), options2)],
+							maxItems: 2,
+							minItems: 2
+						},
+						"x-native-type": JsonSchemaXNativeType.Map
+					}];
+				}
+				case "set": {
+					const set = schema2;
+					return [true, {
+						"type": "array",
+						"uniqueItems": true,
+						"items": this.#handleArrayItemJsonSchema(this.#convert(set._zod.def.valueType, options2, lazyDepth2, structureDepth + 1), options2),
+						"x-native-type": JsonSchemaXNativeType.Set
+					}];
+				}
+				case "enum": {
+					const enum_ = schema2;
+					return [true, { enum: Object.values(enum_._zod.def.entries) }];
+				}
+				case "literal": {
+					const literal = schema2;
+					let required = true;
+					const values = /* @__PURE__ */ new Set();
+					for (const value of literal._zod.def.values) if (value === void 0) required = false;
+					else values.add(typeof value === "bigint" ? value.toString() : value);
+					const json = values.size === 0 ? this.undefinedJsonSchema : values.size === 1 ? { const: values.values().next().value } : { enum: Array.from(values) };
+					return [required, json];
+				}
+				case "file": {
+					const file = schema2;
+					const oneOf = [];
+					const { mime } = file._zod.bag;
+					if (mime === void 0 || Array.isArray(mime) && mime.every((m) => typeof m === "string")) for (const type of mime ?? ["*/*"]) oneOf.push({
+						type: "string",
+						contentMediaType: type
+					});
+					return [true, oneOf.length === 1 ? oneOf[0] : { anyOf: oneOf }];
+				}
+				case "transform": return [false, this.anyJsonSchema];
+				case "nullable": {
+					const nullable = schema2;
+					const [required, json] = this.#convert(nullable._zod.def.innerType, options2, lazyDepth2, structureDepth);
+					return [required, { anyOf: [json, { type: "null" }] }];
+				}
+				case "nonoptional": {
+					const nonoptional = schema2;
+					const [, json] = this.#convert(nonoptional._zod.def.innerType, options2, lazyDepth2, structureDepth);
+					return [true, json];
+				}
+				case "success": return [true, { type: "boolean" }];
+				case "default":
+				case "prefault": {
+					const default_ = schema2;
+					const [, json] = this.#convert(default_._zod.def.innerType, options2, lazyDepth2, structureDepth);
+					return [false, {
+						...json,
+						default: default_._zod.def.defaultValue
+					}];
+				}
+				case "catch": {
+					const catch_ = schema2;
+					return this.#convert(catch_._zod.def.innerType, options2, lazyDepth2, structureDepth);
+				}
+				case "nan": return [true, options2.strategy === "input" ? this.unsupportedJsonSchema : { type: "null" }];
+				case "pipe": {
+					const pipe = schema2;
+					return this.#convert(options2.strategy === "input" ? pipe._zod.def.in : pipe._zod.def.out, options2, lazyDepth2, structureDepth);
+				}
+				case "readonly": {
+					const readonly_ = schema2;
+					const [required, json] = this.#convert(readonly_._zod.def.innerType, options2, lazyDepth2, structureDepth);
+					return [required, {
+						...json,
+						readOnly: true
+					}];
+				}
+				case "template_literal": return [true, {
+					type: "string",
+					pattern: schema2._zod.pattern.source
+				}];
+				case "optional": {
+					const optional = schema2;
+					const [, json] = this.#convert(optional._zod.def.innerType, options2, lazyDepth2, structureDepth);
+					return [false, json];
+				}
+				case "lazy": {
+					const lazy = schema2;
+					const currentLazyDepth = lazyDepth2 + 1;
+					if (currentLazyDepth > this.maxLazyDepth) return [false, this.anyJsonSchema];
+					return this.#convert(lazy._zod.def.getter(), options2, currentLazyDepth, structureDepth);
+				}
+				default:
+					schema2._zod.def.type;
+					return [true, this.unsupportedJsonSchema];
+			}
+		});
+	}
+	#getCustomJsonSchema(schema, options) {
+		if (options.strategy === "input" && JSON_SCHEMA_INPUT_REGISTRY.has(schema)) return JSON_SCHEMA_INPUT_REGISTRY.get(schema);
+		if (options.strategy === "output" && JSON_SCHEMA_OUTPUT_REGISTRY.has(schema)) return JSON_SCHEMA_OUTPUT_REGISTRY.get(schema);
+		if (JSON_SCHEMA_REGISTRY.has(schema)) return JSON_SCHEMA_REGISTRY.get(schema);
+		const global = zod_v4_core.globalRegistry.get(schema);
+		if (global) return {
+			title: global.title,
+			description: global.description,
+			examples: Array.isArray(global.examples) ? global.examples : void 0
+		};
+	}
+	#handleArrayItemJsonSchema([required, schema], options) {
+		if (required || options.strategy === "input" || schema.default !== void 0) return schema;
+		if (schema === this.undefinedJsonSchema) return { type: "null" };
+		return { anyOf: [schema, { type: "null" }] };
+	}
+	#handleStringFormat(format) {
+		if (format === "guid") return require_openapi_DrTcell5.Format.UUID;
+		if (format === "url") return require_openapi_DrTcell5.Format.URI;
+		if (format === "datetime") return require_openapi_DrTcell5.Format.DateTime;
+		return Object.values(require_openapi_DrTcell5.Format).includes(format) ? format : void 0;
+	}
+	#handleContentEncoding(contentEncoding) {
+		return Object.values(require_openapi_DrTcell5.ContentEncoding).includes(contentEncoding) ? contentEncoding : void 0;
+	}
+};
+
+//#endregion
+exports.ZodToJsonSchemaConverter = ZodToJsonSchemaConverter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"zod4-BXTBR1od.cjs","names":["#convert","intercept","toArray","#getCustomJsonSchema","#handleContentEncoding","#handleStringFormat","JSONSchemaFormat","#handleArrayItemJsonSchema","globalRegistry","JSONSchemaContentEncoding"],"sources":["../../../node_modules/.bun/@orpc+json-schema@1.10.4/node_modules/@orpc/json-schema/dist/index.mjs","../../../node_modules/.bun/@orpc+zod@1.10.4+b4e43a763b4e0453/node_modules/@orpc/zod/dist/zod4/index.mjs"],"sourcesContent":["import { isObject, toArray, guard } from '@orpc/shared';\nimport { CompositeSchemaConverter } from '@orpc/openapi';\n\nvar JsonSchemaXNativeType = /* @__PURE__ */ ((JsonSchemaXNativeType2) => {\n  JsonSchemaXNativeType2[\"BigInt\"] = \"bigint\";\n  JsonSchemaXNativeType2[\"RegExp\"] = \"regexp\";\n  JsonSchemaXNativeType2[\"Date\"] = \"date\";\n  JsonSchemaXNativeType2[\"Url\"] = \"url\";\n  JsonSchemaXNativeType2[\"Set\"] = \"set\";\n  JsonSchemaXNativeType2[\"Map\"] = \"map\";\n  return JsonSchemaXNativeType2;\n})(JsonSchemaXNativeType || {});\n\nconst FLEXIBLE_DATE_FORMAT_REGEX = /^[^-]+-[^-]+-[^-]+$/;\nclass experimental_JsonSchemaCoercer {\n  coerce(schema, value, options = {}) {\n    const [, coerced] = this.#coerce(schema, value, options);\n    return coerced;\n  }\n  #coerce(schema, originalValue, options) {\n    if (typeof schema === \"boolean\") {\n      return [schema, originalValue];\n    }\n    if (Array.isArray(schema.type)) {\n      return this.#coerce({\n        anyOf: schema.type.map((type) => ({ ...schema, type }))\n      }, originalValue, options);\n    }\n    let coerced = originalValue;\n    let satisfied = true;\n    if (typeof schema.$ref === \"string\") {\n      const refSchema = options?.components?.[schema.$ref];\n      if (refSchema !== void 0) {\n        const [subSatisfied, subCoerced] = this.#coerce(refSchema, coerced, options);\n        coerced = subCoerced;\n        satisfied = subSatisfied;\n      }\n    }\n    const enumValues = schema.const !== void 0 ? [schema.const] : schema.enum;\n    if (enumValues !== void 0 && !enumValues.includes(coerced)) {\n      if (typeof coerced === \"string\") {\n        const numberValue = this.#stringToNumber(coerced);\n        if (enumValues.includes(numberValue)) {\n          coerced = numberValue;\n        } else {\n          const booleanValue = this.#stringToBoolean(coerced);\n          if (enumValues.includes(booleanValue)) {\n            coerced = booleanValue;\n          } else {\n            satisfied = false;\n          }\n        }\n      } else {\n        satisfied = false;\n      }\n    }\n    if (typeof schema.type === \"string\") {\n      switch (schema.type) {\n        case \"null\": {\n          if (coerced !== null) {\n            satisfied = false;\n          }\n          break;\n        }\n        case \"string\": {\n          if (typeof coerced !== \"string\") {\n            satisfied = false;\n          }\n          break;\n        }\n        case \"number\": {\n          if (typeof coerced === \"string\") {\n            coerced = this.#stringToNumber(coerced);\n          }\n          if (typeof coerced !== \"number\") {\n            satisfied = false;\n          }\n          break;\n        }\n        case \"integer\": {\n          if (typeof coerced === \"string\") {\n            coerced = this.#stringToInteger(coerced);\n          }\n          if (typeof coerced !== \"number\" || !Number.isInteger(coerced)) {\n            satisfied = false;\n          }\n          break;\n        }\n        case \"boolean\": {\n          if (typeof coerced === \"string\") {\n            coerced = this.#stringToBoolean(coerced);\n          }\n          if (typeof coerced !== \"boolean\") {\n            satisfied = false;\n          }\n          break;\n        }\n        case \"array\": {\n          if (Array.isArray(coerced)) {\n            const prefixItemSchemas = \"prefixItems\" in schema ? toArray(schema.prefixItems) : Array.isArray(schema.items) ? schema.items : [];\n            const itemSchema = Array.isArray(schema.items) ? schema.additionalItems : schema.items;\n            let shouldUseCoercedItems = false;\n            const coercedItems = coerced.map((item, i) => {\n              const subSchema = prefixItemSchemas[i] ?? itemSchema;\n              if (subSchema === void 0) {\n                satisfied = false;\n                return item;\n              }\n              const [subSatisfied, subCoerced] = this.#coerce(subSchema, item, options);\n              if (!subSatisfied) {\n                satisfied = false;\n              }\n              if (subCoerced !== item) {\n                shouldUseCoercedItems = true;\n              }\n              return subCoerced;\n            });\n            if (coercedItems.length < prefixItemSchemas.length) {\n              satisfied = false;\n            }\n            if (shouldUseCoercedItems) {\n              coerced = coercedItems;\n            }\n          } else {\n            satisfied = false;\n          }\n          break;\n        }\n        case \"object\": {\n          if (Array.isArray(coerced)) {\n            coerced = { ...coerced };\n          }\n          if (isObject(coerced)) {\n            let shouldUseCoercedItems = false;\n            const coercedItems = {};\n            const patternProperties = Object.entries(schema.patternProperties ?? {}).map(([key, value]) => [new RegExp(key), value]);\n            for (const key in coerced) {\n              const value = coerced[key];\n              const subSchema = schema.properties?.[key] ?? patternProperties.find(([pattern]) => pattern.test(key))?.[1] ?? schema.additionalProperties;\n              if (value === void 0 && !schema.required?.includes(key)) {\n                coercedItems[key] = value;\n              } else if (subSchema === void 0) {\n                coercedItems[key] = value;\n                satisfied = false;\n              } else {\n                const [subSatisfied, subCoerced] = this.#coerce(subSchema, value, options);\n                coercedItems[key] = subCoerced;\n                if (!subSatisfied) {\n                  satisfied = false;\n                }\n                if (subCoerced !== value) {\n                  shouldUseCoercedItems = true;\n                }\n              }\n            }\n            if (schema.required?.some((key) => !Object.hasOwn(coercedItems, key))) {\n              satisfied = false;\n            }\n            if (shouldUseCoercedItems) {\n              coerced = coercedItems;\n            }\n          } else {\n            satisfied = false;\n          }\n          break;\n        }\n      }\n    }\n    if (\"x-native-type\" in schema && typeof schema[\"x-native-type\"] === \"string\") {\n      switch (schema[\"x-native-type\"]) {\n        case JsonSchemaXNativeType.Date: {\n          if (typeof coerced === \"string\") {\n            coerced = this.#stringToDate(coerced);\n          }\n          if (!(coerced instanceof Date)) {\n            satisfied = false;\n          }\n          break;\n        }\n        case JsonSchemaXNativeType.BigInt: {\n          switch (typeof coerced) {\n            case \"string\":\n              coerced = this.#stringToBigInt(coerced);\n              break;\n            case \"number\":\n              coerced = this.#numberToBigInt(coerced);\n              break;\n          }\n          if (typeof coerced !== \"bigint\") {\n            satisfied = false;\n          }\n          break;\n        }\n        case JsonSchemaXNativeType.RegExp: {\n          if (typeof coerced === \"string\") {\n            coerced = this.#stringToRegExp(coerced);\n          }\n          if (!(coerced instanceof RegExp)) {\n            satisfied = false;\n          }\n          break;\n        }\n        case JsonSchemaXNativeType.Url: {\n          if (typeof coerced === \"string\") {\n            coerced = this.#stringToURL(coerced);\n          }\n          if (!(coerced instanceof URL)) {\n            satisfied = false;\n          }\n          break;\n        }\n        case JsonSchemaXNativeType.Set: {\n          if (Array.isArray(coerced)) {\n            coerced = this.#arrayToSet(coerced);\n          }\n          if (!(coerced instanceof Set)) {\n            satisfied = false;\n          }\n          break;\n        }\n        case JsonSchemaXNativeType.Map: {\n          if (Array.isArray(coerced)) {\n            coerced = this.#arrayToMap(coerced);\n          }\n          if (!(coerced instanceof Map)) {\n            satisfied = false;\n          }\n          break;\n        }\n      }\n    }\n    if (schema.allOf) {\n      for (const subSchema of schema.allOf) {\n        const [subSatisfied, subCoerced] = this.#coerce(subSchema, coerced, options);\n        coerced = subCoerced;\n        if (!subSatisfied) {\n          satisfied = false;\n        }\n      }\n    }\n    for (const key of [\"anyOf\", \"oneOf\"]) {\n      if (schema[key]) {\n        let bestOptions;\n        for (const subSchema of schema[key]) {\n          const [subSatisfied, subCoerced] = this.#coerce(subSchema, coerced, options);\n          if (subSatisfied) {\n            if (!bestOptions || subCoerced === coerced) {\n              bestOptions = { coerced: subCoerced, satisfied: subSatisfied };\n            }\n            if (subCoerced === coerced) {\n              break;\n            }\n          }\n        }\n        coerced = bestOptions ? bestOptions.coerced : coerced;\n        satisfied = bestOptions ? bestOptions.satisfied : false;\n      }\n    }\n    if (typeof schema.not !== \"undefined\") {\n      const [notSatisfied] = this.#coerce(schema.not, coerced, options);\n      if (notSatisfied) {\n        satisfied = false;\n      }\n    }\n    return [satisfied, coerced];\n  }\n  #stringToNumber(value) {\n    const num = Number.parseFloat(value);\n    if (Number.isNaN(num) || num !== Number(value)) {\n      return value;\n    }\n    return num;\n  }\n  #stringToInteger(value) {\n    const num = Number.parseInt(value);\n    if (Number.isNaN(num) || num !== Number(value)) {\n      return value;\n    }\n    return num;\n  }\n  #stringToBoolean(value) {\n    const lower = value.toLowerCase();\n    if (lower === \"false\" || lower === \"off\") {\n      return false;\n    }\n    if (lower === \"true\" || lower === \"on\") {\n      return true;\n    }\n    return value;\n  }\n  #stringToBigInt(value) {\n    return guard(() => BigInt(value)) ?? value;\n  }\n  #numberToBigInt(value) {\n    return guard(() => BigInt(value)) ?? value;\n  }\n  #stringToDate(value) {\n    const date = new Date(value);\n    if (Number.isNaN(date.getTime()) || !FLEXIBLE_DATE_FORMAT_REGEX.test(value)) {\n      return value;\n    }\n    return date;\n  }\n  #stringToRegExp(value) {\n    const match = value.match(/^\\/(.*)\\/([a-z]*)$/);\n    if (match) {\n      const [, pattern, flags] = match;\n      return guard(() => new RegExp(pattern, flags)) ?? value;\n    }\n    return value;\n  }\n  #stringToURL(value) {\n    return guard(() => new URL(value)) ?? value;\n  }\n  #arrayToSet(value) {\n    const set = new Set(value);\n    if (set.size !== value.length) {\n      return value;\n    }\n    return set;\n  }\n  #arrayToMap(value) {\n    if (value.some((item) => !Array.isArray(item) || item.length !== 2)) {\n      return value;\n    }\n    const result = new Map(value);\n    if (result.size !== value.length) {\n      return value;\n    }\n    return result;\n  }\n}\n\nclass experimental_SmartCoercionPlugin {\n  converter;\n  coercer;\n  cache = /* @__PURE__ */ new WeakMap();\n  constructor(options = {}) {\n    this.converter = new CompositeSchemaConverter(toArray(options.schemaConverters));\n    this.coercer = new experimental_JsonSchemaCoercer();\n  }\n  init(options) {\n    options.clientInterceptors ??= [];\n    options.clientInterceptors.unshift(async (options2) => {\n      const inputSchema = options2.procedure[\"~orpc\"].inputSchema;\n      if (!inputSchema) {\n        return options2.next();\n      }\n      const coercedInput = await this.#coerce(inputSchema, options2.input);\n      return options2.next({ ...options2, input: coercedInput });\n    });\n  }\n  async #coerce(schema, value) {\n    let jsonSchema = this.cache.get(schema);\n    if (!jsonSchema) {\n      jsonSchema = (await this.converter.convert(schema, { strategy: \"input\" }))[1];\n      this.cache.set(schema, jsonSchema);\n    }\n    return this.coercer.coerce(jsonSchema, value);\n  }\n}\n\nexport { JsonSchemaXNativeType, experimental_JsonSchemaCoercer, experimental_SmartCoercionPlugin };\n","import { isObject, guard, intercept, toArray } from '@orpc/shared';\nimport { JsonSchemaXNativeType } from '@orpc/json-schema';\nimport { JSONSchemaFormat, JSONSchemaContentEncoding } from '@orpc/openapi';\nimport { registry, globalRegistry } from 'zod/v4/core';\n\nclass experimental_ZodSmartCoercionPlugin {\n  init(options) {\n    options.clientInterceptors ??= [];\n    options.clientInterceptors.unshift((options2) => {\n      const inputSchema = options2.procedure[\"~orpc\"].inputSchema;\n      if (!inputSchema || inputSchema[\"~standard\"].vendor !== \"zod\" || !(\"_zod\" in inputSchema)) {\n        return options2.next();\n      }\n      const coercedInput = this.#coerce(inputSchema, options2.input);\n      return options2.next({ ...options2, input: coercedInput });\n    });\n  }\n  #coerce(schema, value) {\n    switch (schema._zod.def.type) {\n      case \"number\": {\n        if (typeof value === \"string\") {\n          return this.#stringToNumber(value);\n        }\n        return value;\n      }\n      case \"bigint\": {\n        if (typeof value === \"string\") {\n          return this.#stringToBigInt(value);\n        }\n        return value;\n      }\n      case \"boolean\":\n      case \"success\": {\n        if (typeof value === \"string\") {\n          return this.#stringToBoolean(value);\n        }\n        return value;\n      }\n      case \"date\": {\n        if (typeof value === \"string\") {\n          return this.#stringToDate(value);\n        }\n        return value;\n      }\n      case \"literal\":\n      case \"enum\": {\n        const literal = schema;\n        if (!literal._zod.values.has(value) && typeof value === \"string\") {\n          const num = this.#stringToNumber(value);\n          if (literal._zod.values.has(num)) {\n            return num;\n          }\n          const bool = this.#stringToBoolean(value);\n          if (literal._zod.values.has(bool)) {\n            return bool;\n          }\n          const bigint = this.#stringToBigInt(value);\n          if (literal._zod.values.has(bigint)) {\n            return bigint;\n          }\n        }\n        return value;\n      }\n      case \"array\": {\n        const array = schema;\n        if (value === void 0) {\n          return [];\n        }\n        if (Array.isArray(value)) {\n          return value.map((v) => this.#coerce(array._zod.def.element, v));\n        }\n        return value;\n      }\n      case \"tuple\": {\n        const tuple = schema;\n        if (value === void 0) {\n          return [];\n        }\n        if (Array.isArray(value)) {\n          return value.map((v, i) => {\n            const s = tuple._zod.def.items[i] ?? tuple._zod.def.rest;\n            return s ? this.#coerce(s, v) : v;\n          });\n        }\n        return value;\n      }\n      case \"set\": {\n        const set = schema;\n        if (value === void 0) {\n          return /* @__PURE__ */ new Set();\n        }\n        if (Array.isArray(value)) {\n          return new Set(\n            value.map((v) => this.#coerce(set._zod.def.valueType, v))\n          );\n        }\n        if (value instanceof Set) {\n          return new Set(\n            Array.from(value).map((v) => this.#coerce(set._zod.def.valueType, v))\n          );\n        }\n        return value;\n      }\n      case \"object\": {\n        const object = schema;\n        if (value === void 0) {\n          return {};\n        }\n        if (isObject(value)) {\n          const newObj = {};\n          const keys = /* @__PURE__ */ new Set([\n            ...Object.keys(value),\n            ...Object.keys(object._zod.def.shape)\n          ]);\n          for (const k of keys) {\n            const s = object._zod.def.shape[k] ?? object._zod.def.catchall;\n            newObj[k] = s ? this.#coerce(s, value[k]) : value[k];\n          }\n          return newObj;\n        }\n        return value;\n      }\n      case \"record\": {\n        const record = schema;\n        if (value === void 0) {\n          return {};\n        }\n        if (isObject(value)) {\n          const newObj = {};\n          for (const [k, v] of Object.entries(value)) {\n            const key = this.#coerce(record._zod.def.keyType, k);\n            const val = this.#coerce(record._zod.def.valueType, v);\n            newObj[key] = val;\n          }\n          return newObj;\n        }\n        return value;\n      }\n      case \"map\": {\n        const map = schema;\n        if (value === void 0) {\n          return /* @__PURE__ */ new Map();\n        }\n        if (Array.isArray(value) && value.every((i) => Array.isArray(i) && i.length <= 2)) {\n          return new Map(\n            value.map(([k, v]) => [\n              this.#coerce(map._zod.def.keyType, k),\n              this.#coerce(map._zod.def.valueType, v)\n            ])\n          );\n        }\n        if (value instanceof Map) {\n          return new Map(\n            Array.from(value).map(([k, v]) => [\n              this.#coerce(map._zod.def.keyType, k),\n              this.#coerce(map._zod.def.valueType, v)\n            ])\n          );\n        }\n        return value;\n      }\n      case \"union\": {\n        const union = schema;\n        if (union._zod.def.options.length === 1) {\n          return this.#coerce(union._zod.def.options[0], value);\n        }\n        if (isObject(value)) {\n          const discriminator = \"discriminator\" in union._zod.def && typeof union._zod.def.discriminator === \"string\" ? union._zod.def.discriminator : void 0;\n          for (const option of union._zod.def.options) {\n            if (!option._zod.propValues) {\n              continue;\n            }\n            if (discriminator !== void 0) {\n              if (option._zod.propValues[discriminator]?.has(value[discriminator])) {\n                return this.#coerce(option, value);\n              }\n            } else {\n              for (const key in option._zod.propValues) {\n                if (option._zod.propValues[key]?.has(value[key])) {\n                  return this.#coerce(option, value);\n                }\n              }\n            }\n          }\n        }\n        return value;\n      }\n      case \"intersection\": {\n        const intersection = schema;\n        return this.#coerce(\n          intersection._zod.def.right,\n          this.#coerce(intersection._zod.def.left, value)\n        );\n      }\n      case \"optional\": {\n        const optional = schema;\n        if (value === void 0) {\n          return void 0;\n        }\n        return this.#coerce(optional._zod.def.innerType, value);\n      }\n      case \"nonoptional\": {\n        const nonoptional = schema;\n        return this.#coerce(nonoptional._zod.def.innerType, value);\n      }\n      case \"nullable\": {\n        const nullable = schema;\n        if (value === null) {\n          return null;\n        }\n        return this.#coerce(nullable._zod.def.innerType, value);\n      }\n      case \"readonly\": {\n        const readonly_ = schema;\n        return this.#coerce(readonly_._zod.def.innerType, value);\n      }\n      case \"pipe\": {\n        const pipe = schema;\n        return this.#coerce(pipe._zod.def.in, value);\n      }\n      case \"default\":\n      case \"prefault\": {\n        const default_ = schema;\n        if (value === void 0) {\n          return value;\n        }\n        return this.#coerce(default_._zod.def.innerType, value);\n      }\n      case \"catch\": {\n        const catch_ = schema;\n        return this.#coerce(catch_._zod.def.innerType, value);\n      }\n      case \"lazy\": {\n        const lazy = schema;\n        if (value !== void 0) {\n          return this.#coerce(lazy._zod.def.getter(), value);\n        }\n        return value;\n      }\n      default: {\n        schema._zod.def.type;\n        return value;\n      }\n    }\n  }\n  #stringToNumber(value) {\n    const num = Number(value);\n    return Number.isNaN(num) || num.toString() !== value ? value : num;\n  }\n  #stringToBigInt(value) {\n    return guard(() => BigInt(value)) ?? value;\n  }\n  #stringToBoolean(value) {\n    const lower = value.toLowerCase();\n    if (lower === \"false\" || lower === \"off\" || lower === \"f\") {\n      return false;\n    }\n    if (lower === \"true\" || lower === \"on\" || lower === \"t\") {\n      return true;\n    }\n    return value;\n  }\n  #stringToDate(value) {\n    const date = new Date(value);\n    if (!Number.isNaN(date.getTime()) && date.toISOString().startsWith(value)) {\n      return date;\n    }\n    return value;\n  }\n}\n\nconst JSON_SCHEMA_REGISTRY = registry();\nconst JSON_SCHEMA_INPUT_REGISTRY = registry();\nconst JSON_SCHEMA_OUTPUT_REGISTRY = registry();\n\nclass ZodToJsonSchemaConverter {\n  maxLazyDepth;\n  maxStructureDepth;\n  anyJsonSchema;\n  unsupportedJsonSchema;\n  undefinedJsonSchema;\n  interceptors;\n  constructor(options = {}) {\n    this.maxLazyDepth = options.maxLazyDepth ?? 2;\n    this.maxStructureDepth = options.maxStructureDepth ?? 10;\n    this.anyJsonSchema = options.anyJsonSchema ?? {};\n    this.unsupportedJsonSchema = options.unsupportedJsonSchema ?? { not: {} };\n    this.undefinedJsonSchema = options.undefinedJsonSchema ?? { not: {} };\n    this.interceptors = options.interceptors ?? [];\n  }\n  condition(schema) {\n    return schema !== void 0 && schema[\"~standard\"].vendor === \"zod\" && \"_zod\" in schema;\n  }\n  convert(schema, options) {\n    return this.#convert(schema, options, 0, 0);\n  }\n  #convert(schema, options, lazyDepth, structureDepth, isHandledCustomJSONSchema = false) {\n    return intercept(\n      this.interceptors,\n      { schema, options, lazyDepth, isHandledCustomJSONSchema },\n      ({ schema: schema2, options: options2, lazyDepth: lazyDepth2, isHandledCustomJSONSchema: isHandledCustomJSONSchema2 }) => {\n        if (structureDepth > this.maxStructureDepth) {\n          return [false, this.anyJsonSchema];\n        }\n        if (!options2.minStructureDepthForRef || options2.minStructureDepthForRef <= structureDepth) {\n          const components = toArray(options2.components);\n          for (const component of components) {\n            if (component.schema === schema2 && component.allowedStrategies.includes(options2.strategy)) {\n              return [component.required, { $ref: component.ref }];\n            }\n          }\n        }\n        if (!isHandledCustomJSONSchema2) {\n          const customJSONSchema = this.#getCustomJsonSchema(schema2, options2);\n          if (customJSONSchema) {\n            const [required, json] = this.#convert(schema2, options2, lazyDepth2, structureDepth, true);\n            return [required, { ...json, ...customJSONSchema }];\n          }\n        }\n        switch (schema2._zod.def.type) {\n          case \"string\": {\n            const string = schema2;\n            const json = { type: \"string\" };\n            const { minimum, maximum, format, patterns, contentEncoding } = string._zod.bag;\n            if (typeof minimum === \"number\") {\n              json.minLength = minimum;\n            }\n            if (typeof maximum === \"number\") {\n              json.maxLength = maximum;\n            }\n            if (typeof contentEncoding === \"string\") {\n              json.contentEncoding = this.#handleContentEncoding(contentEncoding);\n            }\n            if (typeof format === \"string\" && format !== \"regex\" && json.contentEncoding === void 0) {\n              json.format = this.#handleStringFormat(format);\n            }\n            if (patterns instanceof Set && json.contentEncoding === void 0 && json.format === void 0) {\n              for (const pattern of patterns) {\n                if (json.pattern === void 0) {\n                  json.pattern = pattern.source;\n                } else {\n                  json.allOf ??= [];\n                  json.allOf.push({ pattern: pattern.source });\n                }\n              }\n            }\n            if (format === \"jwt\" && json.contentEncoding === void 0 && json.format === void 0 && json.pattern === void 0) {\n              json.pattern = /^[\\w-]+\\.[\\w-]+\\.[\\w-]+$/.source;\n            }\n            return [true, json];\n          }\n          case \"number\": {\n            const number = schema2;\n            const json = { type: \"number\" };\n            const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = number._zod.bag;\n            if (typeof format === \"string\" && format?.includes(\"int\")) {\n              json.type = \"integer\";\n            }\n            if (typeof minimum === \"number\") {\n              json.minimum = minimum;\n            }\n            if (typeof maximum === \"number\") {\n              json.maximum = maximum;\n            }\n            if (typeof exclusiveMinimum === \"number\") {\n              json.exclusiveMinimum = exclusiveMinimum;\n            }\n            if (typeof exclusiveMaximum === \"number\") {\n              json.exclusiveMaximum = exclusiveMaximum;\n            }\n            if (typeof multipleOf === \"number\") {\n              json.multipleOf = multipleOf;\n            }\n            return [true, json];\n          }\n          case \"boolean\": {\n            return [true, { type: \"boolean\" }];\n          }\n          case \"bigint\": {\n            return [true, {\n              \"type\": \"string\",\n              \"pattern\": \"^-?[0-9]+$\",\n              \"x-native-type\": JsonSchemaXNativeType.BigInt\n            }];\n          }\n          case \"date\": {\n            return [true, {\n              \"type\": \"string\",\n              \"format\": JSONSchemaFormat.DateTime,\n              \"x-native-type\": JsonSchemaXNativeType.Date\n            }];\n          }\n          case \"null\": {\n            return [true, { type: \"null\" }];\n          }\n          case \"undefined\":\n          case \"void\": {\n            return [false, this.undefinedJsonSchema];\n          }\n          case \"any\": {\n            return [false, this.anyJsonSchema];\n          }\n          case \"unknown\": {\n            return [false, this.anyJsonSchema];\n          }\n          case \"never\": {\n            return [true, this.unsupportedJsonSchema];\n          }\n          case \"array\": {\n            const array = schema2;\n            const json = { type: \"array\" };\n            const { minimum, maximum } = array._zod.bag;\n            if (typeof minimum === \"number\") {\n              json.minItems = minimum;\n            }\n            if (typeof maximum === \"number\") {\n              json.maxItems = maximum;\n            }\n            json.items = this.#handleArrayItemJsonSchema(this.#convert(array._zod.def.element, options2, lazyDepth2, structureDepth + 1), options2);\n            return [true, json];\n          }\n          case \"object\": {\n            const object = schema2;\n            const json = { type: \"object\" };\n            for (const [key, value] of Object.entries(object._zod.def.shape)) {\n              const [itemRequired, itemJson] = this.#convert(value, options2, lazyDepth2, structureDepth + 1);\n              json.properties ??= {};\n              json.properties[key] = itemJson;\n              if (itemRequired) {\n                json.required ??= [];\n                json.required.push(key);\n              }\n            }\n            if (object._zod.def.catchall) {\n              if (object._zod.def.catchall._zod.def.type === \"never\") {\n                json.additionalProperties = false;\n              } else {\n                const [_, addJson] = this.#convert(object._zod.def.catchall, options2, lazyDepth2, structureDepth + 1);\n                json.additionalProperties = addJson;\n              }\n            }\n            return [true, json];\n          }\n          case \"union\": {\n            const union = schema2;\n            const anyOf = [];\n            let required = true;\n            for (const item of union._zod.def.options) {\n              const [itemRequired, itemJson] = this.#convert(item, options2, lazyDepth2, structureDepth + 1);\n              if (!itemRequired) {\n                required = false;\n              }\n              if (options2.strategy === \"input\") {\n                if (itemJson !== this.undefinedJsonSchema && itemJson !== this.unsupportedJsonSchema) {\n                  anyOf.push(itemJson);\n                }\n              } else {\n                if (itemJson !== this.undefinedJsonSchema) {\n                  anyOf.push(itemJson);\n                }\n              }\n            }\n            return [required, { anyOf }];\n          }\n          case \"intersection\": {\n            const intersection = schema2;\n            const json = { allOf: [] };\n            let required = false;\n            for (const item of [intersection._zod.def.left, intersection._zod.def.right]) {\n              const [itemRequired, itemJson] = this.#convert(item, options2, lazyDepth2, structureDepth + 1);\n              json.allOf.push(itemJson);\n              if (itemRequired) {\n                required = true;\n              }\n            }\n            return [required, json];\n          }\n          case \"tuple\": {\n            const tuple = schema2;\n            const json = { type: \"array\", prefixItems: [] };\n            for (const item of tuple._zod.def.items) {\n              json.prefixItems.push(this.#handleArrayItemJsonSchema(this.#convert(item, options2, lazyDepth2, structureDepth + 1), options2));\n            }\n            if (tuple._zod.def.rest) {\n              json.items = this.#handleArrayItemJsonSchema(this.#convert(tuple._zod.def.rest, options2, lazyDepth2, structureDepth + 1), options2);\n            }\n            const { minimum, maximum } = tuple._zod.bag;\n            if (typeof minimum === \"number\") {\n              json.minItems = minimum;\n            }\n            if (typeof maximum === \"number\") {\n              json.maxItems = maximum;\n            }\n            return [true, json];\n          }\n          case \"record\": {\n            const record = schema2;\n            const json = { type: \"object\" };\n            json.propertyNames = this.#convert(record._zod.def.keyType, options2, lazyDepth2, structureDepth + 1)[1];\n            json.additionalProperties = this.#convert(record._zod.def.valueType, options2, lazyDepth2, structureDepth + 1)[1];\n            return [true, json];\n          }\n          case \"map\": {\n            const map = schema2;\n            return [true, {\n              \"type\": \"array\",\n              \"items\": {\n                type: \"array\",\n                prefixItems: [\n                  this.#handleArrayItemJsonSchema(this.#convert(map._zod.def.keyType, options2, lazyDepth2, structureDepth + 1), options2),\n                  this.#handleArrayItemJsonSchema(this.#convert(map._zod.def.valueType, options2, lazyDepth2, structureDepth + 1), options2)\n                ],\n                maxItems: 2,\n                minItems: 2\n              },\n              \"x-native-type\": JsonSchemaXNativeType.Map\n            }];\n          }\n          case \"set\": {\n            const set = schema2;\n            return [true, {\n              \"type\": \"array\",\n              \"uniqueItems\": true,\n              \"items\": this.#handleArrayItemJsonSchema(this.#convert(set._zod.def.valueType, options2, lazyDepth2, structureDepth + 1), options2),\n              \"x-native-type\": JsonSchemaXNativeType.Set\n            }];\n          }\n          case \"enum\": {\n            const enum_ = schema2;\n            return [true, { enum: Object.values(enum_._zod.def.entries) }];\n          }\n          case \"literal\": {\n            const literal = schema2;\n            let required = true;\n            const values = /* @__PURE__ */ new Set();\n            for (const value of literal._zod.def.values) {\n              if (value === void 0) {\n                required = false;\n              } else {\n                values.add(typeof value === \"bigint\" ? value.toString() : value);\n              }\n            }\n            const json = values.size === 0 ? this.undefinedJsonSchema : values.size === 1 ? { const: values.values().next().value } : { enum: Array.from(values) };\n            return [required, json];\n          }\n          case \"file\": {\n            const file = schema2;\n            const oneOf = [];\n            const { mime } = file._zod.bag;\n            if (mime === void 0 || Array.isArray(mime) && mime.every((m) => typeof m === \"string\")) {\n              for (const type of mime ?? [\"*/*\"]) {\n                oneOf.push({\n                  type: \"string\",\n                  contentMediaType: type\n                });\n              }\n            }\n            return [true, oneOf.length === 1 ? oneOf[0] : { anyOf: oneOf }];\n          }\n          case \"transform\": {\n            return [false, this.anyJsonSchema];\n          }\n          case \"nullable\": {\n            const nullable = schema2;\n            const [required, json] = this.#convert(nullable._zod.def.innerType, options2, lazyDepth2, structureDepth);\n            return [required, { anyOf: [json, { type: \"null\" }] }];\n          }\n          case \"nonoptional\": {\n            const nonoptional = schema2;\n            const [, json] = this.#convert(nonoptional._zod.def.innerType, options2, lazyDepth2, structureDepth);\n            return [true, json];\n          }\n          case \"success\": {\n            return [true, { type: \"boolean\" }];\n          }\n          case \"default\":\n          case \"prefault\": {\n            const default_ = schema2;\n            const [, json] = this.#convert(default_._zod.def.innerType, options2, lazyDepth2, structureDepth);\n            return [false, {\n              ...json,\n              default: default_._zod.def.defaultValue\n            }];\n          }\n          case \"catch\": {\n            const catch_ = schema2;\n            return this.#convert(catch_._zod.def.innerType, options2, lazyDepth2, structureDepth);\n          }\n          case \"nan\": {\n            return [true, options2.strategy === \"input\" ? this.unsupportedJsonSchema : { type: \"null\" }];\n          }\n          case \"pipe\": {\n            const pipe = schema2;\n            return this.#convert(options2.strategy === \"input\" ? pipe._zod.def.in : pipe._zod.def.out, options2, lazyDepth2, structureDepth);\n          }\n          case \"readonly\": {\n            const readonly_ = schema2;\n            const [required, json] = this.#convert(readonly_._zod.def.innerType, options2, lazyDepth2, structureDepth);\n            return [required, { ...json, readOnly: true }];\n          }\n          case \"template_literal\": {\n            const templateLiteral = schema2;\n            return [true, {\n              type: \"string\",\n              pattern: templateLiteral._zod.pattern.source\n            }];\n          }\n          case \"optional\": {\n            const optional = schema2;\n            const [, json] = this.#convert(optional._zod.def.innerType, options2, lazyDepth2, structureDepth);\n            return [false, json];\n          }\n          case \"lazy\": {\n            const lazy = schema2;\n            const currentLazyDepth = lazyDepth2 + 1;\n            if (currentLazyDepth > this.maxLazyDepth) {\n              return [false, this.anyJsonSchema];\n            }\n            return this.#convert(lazy._zod.def.getter(), options2, currentLazyDepth, structureDepth);\n          }\n          default: {\n            schema2._zod.def.type;\n            return [true, this.unsupportedJsonSchema];\n          }\n        }\n      }\n    );\n  }\n  #getCustomJsonSchema(schema, options) {\n    if (options.strategy === \"input\" && JSON_SCHEMA_INPUT_REGISTRY.has(schema)) {\n      return JSON_SCHEMA_INPUT_REGISTRY.get(schema);\n    }\n    if (options.strategy === \"output\" && JSON_SCHEMA_OUTPUT_REGISTRY.has(schema)) {\n      return JSON_SCHEMA_OUTPUT_REGISTRY.get(schema);\n    }\n    if (JSON_SCHEMA_REGISTRY.has(schema)) {\n      return JSON_SCHEMA_REGISTRY.get(schema);\n    }\n    const global = globalRegistry.get(schema);\n    if (global) {\n      return {\n        title: global.title,\n        description: global.description,\n        examples: Array.isArray(global.examples) ? global.examples : void 0\n      };\n    }\n  }\n  #handleArrayItemJsonSchema([required, schema], options) {\n    if (required || options.strategy === \"input\" || schema.default !== void 0) {\n      return schema;\n    }\n    if (schema === this.undefinedJsonSchema) {\n      return { type: \"null\" };\n    }\n    return {\n      anyOf: [\n        // schema can contain { type: 'null' } so we should use anyOf instead of oneOf\n        schema,\n        { type: \"null\" }\n      ]\n    };\n  }\n  #handleStringFormat(format) {\n    if (format === \"guid\") {\n      return JSONSchemaFormat.UUID;\n    }\n    if (format === \"url\") {\n      return JSONSchemaFormat.URI;\n    }\n    if (format === \"datetime\") {\n      return JSONSchemaFormat.DateTime;\n    }\n    return Object.values(JSONSchemaFormat).includes(format) ? format : void 0;\n  }\n  #handleContentEncoding(contentEncoding) {\n    return Object.values(JSONSchemaContentEncoding).includes(contentEncoding) ? contentEncoding : void 0;\n  }\n}\n\nexport { JSON_SCHEMA_INPUT_REGISTRY, JSON_SCHEMA_OUTPUT_REGISTRY, JSON_SCHEMA_REGISTRY, ZodToJsonSchemaConverter, experimental_ZodSmartCoercionPlugin };\n"],"x_google_ignoreList":[0,1],"mappings":"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"}