@signe/schema-to-zod 2.9.0 → 2.9.2

package/dist/index.js

@@ -1,18 +1,13 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
 // ../../node_modules/.pnpm/zod@3.23.8/node_modules/zod/lib/index.mjs
 var util;
 (function(util2) {
   util2.assertEqual = (val) => val;
   function assertIs(_arg) {
   }
-  __name(assertIs, "assertIs");
   util2.assertIs = assertIs;
   function assertNever(_x) {
     throw new Error();
   }
-  __name(assertNever, "assertNever");
   util2.assertNever = assertNever;
   util2.arrayToEnum = (items) => {
     const obj = {};
@@ -54,7 +49,6 @@ var util;
   function joinValues(array, separator = " | ") {
     return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
   }
-  __name(joinValues, "joinValues");
   util2.joinValues = joinValues;
   util2.jsonStringifyReplacer = (_, value) => {
     if (typeof value === "bigint") {
@@ -95,7 +89,7 @@ var ZodParsedType = util.arrayToEnum([
   "map",
   "set"
 ]);
-var getParsedType = /* @__PURE__ */ __name((data) => {
+var getParsedType = (data) => {
   const t = typeof data;
   switch (t) {
     case "undefined":
@@ -135,7 +129,7 @@ var getParsedType = /* @__PURE__ */ __name((data) => {
     default:
       return ZodParsedType.unknown;
   }
-}, "getParsedType");
+};
 var ZodIssueCode = util.arrayToEnum([
   "invalid_type",
   "invalid_literal",
@@ -154,14 +148,11 @@ var ZodIssueCode = util.arrayToEnum([
   "not_multiple_of",
   "not_finite"
 ]);
-var quotelessJson = /* @__PURE__ */ __name((obj) => {
+var quotelessJson = (obj) => {
   const json = JSON.stringify(obj, null, 2);
   return json.replace(/"([^"]+)":/g, "$1:");
-}, "quotelessJson");
+};
 var ZodError = class _ZodError extends Error {
-  static {
-    __name(this, "ZodError");
-  }
   constructor(issues) {
     super();
     this.issues = [];
@@ -188,7 +179,7 @@ var ZodError = class _ZodError extends Error {
       return issue.message;
     };
     const fieldErrors = { _errors: [] };
-    const processError = /* @__PURE__ */ __name((error) => {
+    const processError = (error) => {
       for (const issue of error.issues) {
         if (issue.code === "invalid_union") {
           issue.unionErrors.map(processError);
@@ -215,7 +206,7 @@ var ZodError = class _ZodError extends Error {
           }
         }
       }
-    }, "processError");
+    };
     processError(this);
     return fieldErrors;
   }
@@ -254,7 +245,7 @@ ZodError.create = (issues) => {
   const error = new ZodError(issues);
   return error;
 };
-var errorMap = /* @__PURE__ */ __name((issue, _ctx) => {
+var errorMap = (issue, _ctx) => {
   let message;
   switch (issue.code) {
     case ZodIssueCode.invalid_type:
@@ -351,17 +342,15 @@ var errorMap = /* @__PURE__ */ __name((issue, _ctx) => {
       util.assertNever(issue);
   }
   return { message };
-}, "errorMap");
+};
 var overrideErrorMap = errorMap;
 function setErrorMap(map) {
   overrideErrorMap = map;
 }
-__name(setErrorMap, "setErrorMap");
 function getErrorMap() {
   return overrideErrorMap;
 }
-__name(getErrorMap, "getErrorMap");
-var makeIssue = /* @__PURE__ */ __name((params) => {
+var makeIssue = (params) => {
   const { data, path, errorMaps, issueData } = params;
   const fullPath = [...path, ...issueData.path || []];
   const fullIssue = {
@@ -385,7 +374,7 @@ var makeIssue = /* @__PURE__ */ __name((params) => {
     path: fullPath,
     message: errorMessage
   };
-}, "makeIssue");
+};
 var EMPTY_PATH = [];
 function addIssueToContext(ctx, issueData) {
   const overrideMap = getErrorMap();
@@ -403,11 +392,7 @@ function addIssueToContext(ctx, issueData) {
   });
   ctx.common.issues.push(issue);
 }
-__name(addIssueToContext, "addIssueToContext");
 var ParseStatus = class _ParseStatus {
-  static {
-    __name(this, "ParseStatus");
-  }
   constructor() {
     this.value = "valid";
   }
@@ -464,25 +449,23 @@ var ParseStatus = class _ParseStatus {
 var INVALID = Object.freeze({
   status: "aborted"
 });
-var DIRTY = /* @__PURE__ */ __name((value) => ({ status: "dirty", value }), "DIRTY");
-var OK = /* @__PURE__ */ __name((value) => ({ status: "valid", value }), "OK");
-var isAborted = /* @__PURE__ */ __name((x) => x.status === "aborted", "isAborted");
-var isDirty = /* @__PURE__ */ __name((x) => x.status === "dirty", "isDirty");
-var isValid = /* @__PURE__ */ __name((x) => x.status === "valid", "isValid");
-var isAsync = /* @__PURE__ */ __name((x) => typeof Promise !== "undefined" && x instanceof Promise, "isAsync");
+var DIRTY = (value) => ({ status: "dirty", value });
+var OK = (value) => ({ status: "valid", value });
+var isAborted = (x) => x.status === "aborted";
+var isDirty = (x) => x.status === "dirty";
+var isValid = (x) => x.status === "valid";
+var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
 function __classPrivateFieldGet(receiver, state, kind, f) {
   if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
   if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
   return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 }
-__name(__classPrivateFieldGet, "__classPrivateFieldGet");
 function __classPrivateFieldSet(receiver, state, value, kind, f) {
   if (kind === "m") throw new TypeError("Private method is not writable");
   if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
   if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
   return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
 }
-__name(__classPrivateFieldSet, "__classPrivateFieldSet");
 var errorUtil;
 (function(errorUtil2) {
   errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
@@ -491,9 +474,6 @@ var errorUtil;
 var _ZodEnum_cache;
 var _ZodNativeEnum_cache;
 var ParseInputLazyPath = class {
-  static {
-    __name(this, "ParseInputLazyPath");
-  }
   constructor(parent, value, path, key) {
     this._cachedPath = [];
     this.parent = parent;
@@ -512,7 +492,7 @@ var ParseInputLazyPath = class {
     return this._cachedPath;
   }
 };
-var handleResult = /* @__PURE__ */ __name((ctx, result) => {
+var handleResult = (ctx, result) => {
   if (isValid(result)) {
     return { success: true, data: result.value };
   } else {
@@ -530,7 +510,7 @@ var handleResult = /* @__PURE__ */ __name((ctx, result) => {
       }
     };
   }
-}, "handleResult");
+};
 function processCreateParams(params) {
   if (!params)
     return {};
@@ -540,7 +520,7 @@ function processCreateParams(params) {
   }
   if (errorMap2)
     return { errorMap: errorMap2, description };
-  const customMap = /* @__PURE__ */ __name((iss, ctx) => {
+  const customMap = (iss, ctx) => {
     var _a, _b;
     const { message } = params;
     if (iss.code === "invalid_enum_value") {
@@ -552,14 +532,10 @@ function processCreateParams(params) {
     if (iss.code !== "invalid_type")
       return { message: ctx.defaultError };
     return { message: (_b = message !== null && message !== void 0 ? message : invalid_type_error) !== null && _b !== void 0 ? _b : ctx.defaultError };
-  }, "customMap");
+  };
   return { errorMap: customMap, description };
 }
-__name(processCreateParams, "processCreateParams");
 var ZodType = class {
-  static {
-    __name(this, "ZodType");
-  }
   constructor(def) {
     this.spa = this.safeParseAsync;
     this._def = def;
@@ -675,7 +651,7 @@ var ZodType = class {
     return handleResult(ctx, result);
   }
   refine(check, message) {
-    const getIssueProperties = /* @__PURE__ */ __name((val) => {
+    const getIssueProperties = (val) => {
       if (typeof message === "string" || typeof message === "undefined") {
         return { message };
       } else if (typeof message === "function") {
@@ -683,13 +659,13 @@ var ZodType = class {
       } else {
         return message;
       }
-    }, "getIssueProperties");
+    };
     return this._refinement((val, ctx) => {
       const result = check(val);
-      const setError = /* @__PURE__ */ __name(() => ctx.addIssue({
+      const setError = () => ctx.addIssue({
         code: ZodIssueCode.custom,
         ...getIssueProperties(val)
-      }), "setError");
+      });
       if (typeof Promise !== "undefined" && result instanceof Promise) {
         return result.then((data) => {
           if (!data) {
@@ -825,11 +801,9 @@ function timeRegexSource(args) {
   }
   return regex;
 }
-__name(timeRegexSource, "timeRegexSource");
 function timeRegex(args) {
   return new RegExp(`^${timeRegexSource(args)}$`);
 }
-__name(timeRegex, "timeRegex");
 function datetimeRegex(args) {
   let regex = `${dateRegexSource}T${timeRegexSource(args)}`;
   const opts = [];
@@ -839,7 +813,6 @@ function datetimeRegex(args) {
   regex = `${regex}(${opts.join("|")})`;
   return new RegExp(`^${regex}$`);
 }
-__name(datetimeRegex, "datetimeRegex");
 function isValidIP(ip, version) {
   if ((version === "v4" || !version) && ipv4Regex.test(ip)) {
     return true;
@@ -849,11 +822,7 @@ function isValidIP(ip, version) {
   }
   return false;
 }
-__name(isValidIP, "isValidIP");
 var ZodString = class _ZodString extends ZodType {
-  static {
-    __name(this, "ZodString");
-  }
   _parse(input) {
     if (this._def.coerce) {
       input.data = String(input.data);
@@ -1362,11 +1331,7 @@ function floatSafeRemainder(val, step) {
   const stepInt = parseInt(step.toFixed(decCount).replace(".", ""));
   return valInt % stepInt / Math.pow(10, decCount);
 }
-__name(floatSafeRemainder, "floatSafeRemainder");
 var ZodNumber = class _ZodNumber extends ZodType {
-  static {
-    __name(this, "ZodNumber");
-  }
   constructor() {
     super(...arguments);
     this.min = this.gte;
@@ -1598,9 +1563,6 @@ ZodNumber.create = (params) => {
   });
 };
 var ZodBigInt = class _ZodBigInt extends ZodType {
-  static {
-    __name(this, "ZodBigInt");
-  }
   constructor() {
     super(...arguments);
     this.min = this.gte;
@@ -1767,9 +1729,6 @@ ZodBigInt.create = (params) => {
   });
 };
 var ZodBoolean = class extends ZodType {
-  static {
-    __name(this, "ZodBoolean");
-  }
   _parse(input) {
     if (this._def.coerce) {
       input.data = Boolean(input.data);
@@ -1795,9 +1754,6 @@ ZodBoolean.create = (params) => {
   });
 };
 var ZodDate = class _ZodDate extends ZodType {
-  static {
-    __name(this, "ZodDate");
-  }
   _parse(input) {
     if (this._def.coerce) {
       input.data = new Date(input.data);
@@ -1907,9 +1863,6 @@ ZodDate.create = (params) => {
   });
 };
 var ZodSymbol = class extends ZodType {
-  static {
-    __name(this, "ZodSymbol");
-  }
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.symbol) {
@@ -1931,9 +1884,6 @@ ZodSymbol.create = (params) => {
   });
 };
 var ZodUndefined = class extends ZodType {
-  static {
-    __name(this, "ZodUndefined");
-  }
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.undefined) {
@@ -1955,9 +1905,6 @@ ZodUndefined.create = (params) => {
   });
 };
 var ZodNull = class extends ZodType {
-  static {
-    __name(this, "ZodNull");
-  }
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.null) {
@@ -1979,9 +1926,6 @@ ZodNull.create = (params) => {
   });
 };
 var ZodAny = class extends ZodType {
-  static {
-    __name(this, "ZodAny");
-  }
   constructor() {
     super(...arguments);
     this._any = true;
@@ -1997,9 +1941,6 @@ ZodAny.create = (params) => {
   });
 };
 var ZodUnknown = class extends ZodType {
-  static {
-    __name(this, "ZodUnknown");
-  }
   constructor() {
     super(...arguments);
     this._unknown = true;
@@ -2015,9 +1956,6 @@ ZodUnknown.create = (params) => {
   });
 };
 var ZodNever = class extends ZodType {
-  static {
-    __name(this, "ZodNever");
-  }
   _parse(input) {
     const ctx = this._getOrReturnCtx(input);
     addIssueToContext(ctx, {
@@ -2035,9 +1973,6 @@ ZodNever.create = (params) => {
   });
 };
 var ZodVoid = class extends ZodType {
-  static {
-    __name(this, "ZodVoid");
-  }
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.undefined) {
@@ -2059,9 +1994,6 @@ ZodVoid.create = (params) => {
   });
 };
 var ZodArray = class _ZodArray extends ZodType {
-  static {
-    __name(this, "ZodArray");
-  }
   _parse(input) {
     const { ctx, status } = this._processInputParams(input);
     const def = this._def;
@@ -2171,7 +2103,7 @@ function deepPartialify(schema) {
     }
     return new ZodObject({
       ...schema._def,
-      shape: /* @__PURE__ */ __name(() => newShape, "shape")
+      shape: () => newShape
     });
   } else if (schema instanceof ZodArray) {
     return new ZodArray({
@@ -2188,11 +2120,7 @@ function deepPartialify(schema) {
     return schema;
   }
 }
-__name(deepPartialify, "deepPartialify");
 var ZodObject = class _ZodObject extends ZodType {
-  static {
-    __name(this, "ZodObject");
-  }
   constructor() {
     super(...arguments);
     this._cached = null;
@@ -2301,7 +2229,7 @@ var ZodObject = class _ZodObject extends ZodType {
       ...this._def,
       unknownKeys: "strict",
       ...message !== void 0 ? {
-        errorMap: /* @__PURE__ */ __name((issue, ctx) => {
+        errorMap: (issue, ctx) => {
           var _a, _b, _c, _d;
           const defaultError = (_c = (_b = (_a = this._def).errorMap) === null || _b === void 0 ? void 0 : _b.call(_a, issue, ctx).message) !== null && _c !== void 0 ? _c : ctx.defaultError;
           if (issue.code === "unrecognized_keys")
@@ -2311,7 +2239,7 @@ var ZodObject = class _ZodObject extends ZodType {
           return {
             message: defaultError
           };
-        }, "errorMap")
+        }
       } : {}
     });
   }
@@ -2347,10 +2275,10 @@ var ZodObject = class _ZodObject extends ZodType {
   extend(augmentation) {
     return new _ZodObject({
       ...this._def,
-      shape: /* @__PURE__ */ __name(() => ({
+      shape: () => ({
         ...this._def.shape(),
         ...augmentation
-      }), "shape")
+      })
     });
   }
   /**
@@ -2362,10 +2290,10 @@ var ZodObject = class _ZodObject extends ZodType {
     const merged = new _ZodObject({
       unknownKeys: merging._def.unknownKeys,
       catchall: merging._def.catchall,
-      shape: /* @__PURE__ */ __name(() => ({
+      shape: () => ({
         ...this._def.shape(),
         ...merging._def.shape()
-      }), "shape"),
+      }),
       typeName: ZodFirstPartyTypeKind.ZodObject
     });
     return merged;
@@ -2444,7 +2372,7 @@ var ZodObject = class _ZodObject extends ZodType {
     });
     return new _ZodObject({
       ...this._def,
-      shape: /* @__PURE__ */ __name(() => shape, "shape")
+      shape: () => shape
     });
   }
   omit(mask) {
@@ -2456,7 +2384,7 @@ var ZodObject = class _ZodObject extends ZodType {
     });
     return new _ZodObject({
       ...this._def,
-      shape: /* @__PURE__ */ __name(() => shape, "shape")
+      shape: () => shape
     });
   }
   /**
@@ -2477,7 +2405,7 @@ var ZodObject = class _ZodObject extends ZodType {
     });
     return new _ZodObject({
       ...this._def,
-      shape: /* @__PURE__ */ __name(() => newShape, "shape")
+      shape: () => newShape
     });
   }
   required(mask) {
@@ -2496,7 +2424,7 @@ var ZodObject = class _ZodObject extends ZodType {
     });
     return new _ZodObject({
       ...this._def,
-      shape: /* @__PURE__ */ __name(() => newShape, "shape")
+      shape: () => newShape
     });
   }
   keyof() {
@@ -2505,7 +2433,7 @@ var ZodObject = class _ZodObject extends ZodType {
 };
 ZodObject.create = (shape, params) => {
   return new ZodObject({
-    shape: /* @__PURE__ */ __name(() => shape, "shape"),
+    shape: () => shape,
     unknownKeys: "strip",
     catchall: ZodNever.create(),
     typeName: ZodFirstPartyTypeKind.ZodObject,
@@ -2514,7 +2442,7 @@ ZodObject.create = (shape, params) => {
 };
 ZodObject.strictCreate = (shape, params) => {
   return new ZodObject({
-    shape: /* @__PURE__ */ __name(() => shape, "shape"),
+    shape: () => shape,
     unknownKeys: "strict",
     catchall: ZodNever.create(),
     typeName: ZodFirstPartyTypeKind.ZodObject,
@@ -2531,9 +2459,6 @@ ZodObject.lazycreate = (shape, params) => {
   });
 };
 var ZodUnion = class extends ZodType {
-  static {
-    __name(this, "ZodUnion");
-  }
   _parse(input) {
     const { ctx } = this._processInputParams(input);
     const options = this._def.options;
@@ -2556,7 +2481,6 @@ var ZodUnion = class extends ZodType {
       });
       return INVALID;
     }
-    __name(handleResults, "handleResults");
     if (ctx.common.async) {
       return Promise.all(options.map(async (option) => {
         const childCtx = {
@@ -2625,7 +2549,7 @@ ZodUnion.create = (types, params) => {
     ...processCreateParams(params)
   });
 };
-var getDiscriminator = /* @__PURE__ */ __name((type) => {
+var getDiscriminator = (type) => {
   if (type instanceof ZodLazy) {
     return getDiscriminator(type.schema);
   } else if (type instanceof ZodEffects) {
@@ -2655,11 +2579,8 @@ var getDiscriminator = /* @__PURE__ */ __name((type) => {
   } else {
     return [];
   }
-}, "getDiscriminator");
+};
 var ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType {
-  static {
-    __name(this, "ZodDiscriminatedUnion");
-  }
   _parse(input) {
     const { ctx } = this._processInputParams(input);
     if (ctx.parsedType !== ZodParsedType.object) {
@@ -2773,14 +2694,10 @@ function mergeValues(a, b) {
     return { valid: false };
   }
 }
-__name(mergeValues, "mergeValues");
 var ZodIntersection = class extends ZodType {
-  static {
-    __name(this, "ZodIntersection");
-  }
   _parse(input) {
     const { status, ctx } = this._processInputParams(input);
-    const handleParsed = /* @__PURE__ */ __name((parsedLeft, parsedRight) => {
+    const handleParsed = (parsedLeft, parsedRight) => {
       if (isAborted(parsedLeft) || isAborted(parsedRight)) {
         return INVALID;
       }
@@ -2795,7 +2712,7 @@ var ZodIntersection = class extends ZodType {
         status.dirty();
       }
       return { status: status.value, value: merged.data };
-    }, "handleParsed");
+    };
     if (ctx.common.async) {
       return Promise.all([
         this._def.left._parseAsync({
@@ -2831,9 +2748,6 @@ ZodIntersection.create = (left, right, params) => {
   });
 };
 var ZodTuple = class _ZodTuple extends ZodType {
-  static {
-    __name(this, "ZodTuple");
-  }
   _parse(input) {
     const { status, ctx } = this._processInputParams(input);
     if (ctx.parsedType !== ZodParsedType.array) {
@@ -2901,9 +2815,6 @@ ZodTuple.create = (schemas, params) => {
   });
 };
 var ZodRecord = class _ZodRecord extends ZodType {
-  static {
-    __name(this, "ZodRecord");
-  }
   get keySchema() {
     return this._def.keyType;
   }
@@ -2957,9 +2868,6 @@ var ZodRecord = class _ZodRecord extends ZodType {
   }
 };
 var ZodMap = class extends ZodType {
-  static {
-    __name(this, "ZodMap");
-  }
   get keySchema() {
     return this._def.keyType;
   }
@@ -3026,9 +2934,6 @@ ZodMap.create = (keyType, valueType, params) => {
   });
 };
 var ZodSet = class _ZodSet extends ZodType {
-  static {
-    __name(this, "ZodSet");
-  }
   _parse(input) {
     const { status, ctx } = this._processInputParams(input);
     if (ctx.parsedType !== ZodParsedType.set) {
@@ -3078,7 +2983,6 @@ var ZodSet = class _ZodSet extends ZodType {
       }
       return { status: status.value, value: parsedSet };
     }
-    __name(finalizeSet, "finalizeSet");
     const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
     if (ctx.common.async) {
       return Promise.all(elements).then((elements2) => finalizeSet(elements2));
@@ -3115,9 +3019,6 @@ ZodSet.create = (valueType, params) => {
   });
 };
 var ZodFunction = class _ZodFunction extends ZodType {
-  static {
-    __name(this, "ZodFunction");
-  }
   constructor() {
     super(...arguments);
     this.validate = this.implement;
@@ -3148,7 +3049,6 @@ var ZodFunction = class _ZodFunction extends ZodType {
         }
       });
     }
-    __name(makeArgsIssue, "makeArgsIssue");
     function makeReturnsIssue(returns, error) {
       return makeIssue({
         data: returns,
@@ -3165,7 +3065,6 @@ var ZodFunction = class _ZodFunction extends ZodType {
         }
       });
     }
-    __name(makeReturnsIssue, "makeReturnsIssue");
     const params = { errorMap: ctx.common.contextualErrorMap };
     const fn = ctx.data;
     if (this._def.returns instanceof ZodPromise) {
@@ -3235,9 +3134,6 @@ var ZodFunction = class _ZodFunction extends ZodType {
   }
 };
 var ZodLazy = class extends ZodType {
-  static {
-    __name(this, "ZodLazy");
-  }
   get schema() {
     return this._def.getter();
   }
@@ -3255,9 +3151,6 @@ ZodLazy.create = (getter, params) => {
   });
 };
 var ZodLiteral = class extends ZodType {
-  static {
-    __name(this, "ZodLiteral");
-  }
   _parse(input) {
     if (input.data !== this._def.value) {
       const ctx = this._getOrReturnCtx(input);
@@ -3288,11 +3181,7 @@ function createZodEnum(values, params) {
     ...processCreateParams(params)
   });
 }
-__name(createZodEnum, "createZodEnum");
 var ZodEnum = class _ZodEnum extends ZodType {
-  static {
-    __name(this, "ZodEnum");
-  }
   constructor() {
     super(...arguments);
     _ZodEnum_cache.set(this, void 0);
@@ -3363,9 +3252,6 @@ var ZodEnum = class _ZodEnum extends ZodType {
 _ZodEnum_cache = /* @__PURE__ */ new WeakMap();
 ZodEnum.create = createZodEnum;
 var ZodNativeEnum = class extends ZodType {
-  static {
-    __name(this, "ZodNativeEnum");
-  }
   constructor() {
     super(...arguments);
     _ZodNativeEnum_cache.set(this, void 0);
@@ -3409,9 +3295,6 @@ ZodNativeEnum.create = (values, params) => {
   });
 };
 var ZodPromise = class extends ZodType {
-  static {
-    __name(this, "ZodPromise");
-  }
   unwrap() {
     return this._def.type;
   }
@@ -3442,9 +3325,6 @@ ZodPromise.create = (schema, params) => {
   });
 };
 var ZodEffects = class extends ZodType {
-  static {
-    __name(this, "ZodEffects");
-  }
   innerType() {
     return this._def.schema;
   }
@@ -3455,14 +3335,14 @@ var ZodEffects = class extends ZodType {
     const { status, ctx } = this._processInputParams(input);
     const effect = this._def.effect || null;
     const checkCtx = {
-      addIssue: /* @__PURE__ */ __name((arg) => {
+      addIssue: (arg) => {
         addIssueToContext(ctx, arg);
         if (arg.fatal) {
           status.abort();
         } else {
           status.dirty();
         }
-      }, "addIssue"),
+      },
       get path() {
         return ctx.path;
       }
@@ -3505,7 +3385,7 @@ var ZodEffects = class extends ZodType {
       }
     }
     if (effect.type === "refinement") {
-      const executeRefinement = /* @__PURE__ */ __name((acc) => {
+      const executeRefinement = (acc) => {
         const result = effect.refinement(acc, checkCtx);
         if (ctx.common.async) {
           return Promise.resolve(result);
@@ -3514,7 +3394,7 @@ var ZodEffects = class extends ZodType {
           throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
         }
         return acc;
-      }, "executeRefinement");
+      };
       if (ctx.common.async === false) {
         const inner = this._def.schema._parseSync({
           data: ctx.data,
@@ -3581,9 +3461,6 @@ ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
   });
 };
 var ZodOptional = class extends ZodType {
-  static {
-    __name(this, "ZodOptional");
-  }
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType === ZodParsedType.undefined) {
@@ -3603,9 +3480,6 @@ ZodOptional.create = (type, params) => {
   });
 };
 var ZodNullable = class extends ZodType {
-  static {
-    __name(this, "ZodNullable");
-  }
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType === ZodParsedType.null) {
@@ -3625,9 +3499,6 @@ ZodNullable.create = (type, params) => {
   });
 };
 var ZodDefault = class extends ZodType {
-  static {
-    __name(this, "ZodDefault");
-  }
   _parse(input) {
     const { ctx } = this._processInputParams(input);
     let data = ctx.data;
@@ -3653,9 +3524,6 @@ ZodDefault.create = (type, params) => {
   });
 };
 var ZodCatch = class extends ZodType {
-  static {
-    __name(this, "ZodCatch");
-  }
   _parse(input) {
     const { ctx } = this._processInputParams(input);
     const newCtx = {
@@ -3709,9 +3577,6 @@ ZodCatch.create = (type, params) => {
   });
 };
 var ZodNaN = class extends ZodType {
-  static {
-    __name(this, "ZodNaN");
-  }
   _parse(input) {
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.nan) {
@@ -3734,9 +3599,6 @@ ZodNaN.create = (params) => {
 };
 var BRAND = Symbol("zod_brand");
 var ZodBranded = class extends ZodType {
-  static {
-    __name(this, "ZodBranded");
-  }
   _parse(input) {
     const { ctx } = this._processInputParams(input);
     const data = ctx.data;
@@ -3751,13 +3613,10 @@ var ZodBranded = class extends ZodType {
   }
 };
 var ZodPipeline = class _ZodPipeline extends ZodType {
-  static {
-    __name(this, "ZodPipeline");
-  }
   _parse(input) {
     const { status, ctx } = this._processInputParams(input);
     if (ctx.common.async) {
-      const handleAsync = /* @__PURE__ */ __name(async () => {
+      const handleAsync = async () => {
         const inResult = await this._def.in._parseAsync({
           data: ctx.data,
           path: ctx.path,
@@ -3775,7 +3634,7 @@ var ZodPipeline = class _ZodPipeline extends ZodType {
             parent: ctx
           });
         }
-      }, "handleAsync");
+      };
       return handleAsync();
     } else {
       const inResult = this._def.in._parseSync({
@@ -3809,17 +3668,14 @@ var ZodPipeline = class _ZodPipeline extends ZodType {
   }
 };
 var ZodReadonly = class extends ZodType {
-  static {
-    __name(this, "ZodReadonly");
-  }
   _parse(input) {
     const result = this._def.innerType._parse(input);
-    const freeze = /* @__PURE__ */ __name((data) => {
+    const freeze = (data) => {
       if (isValid(data)) {
         data.value = Object.freeze(data.value);
       }
       return data;
-    }, "freeze");
+    };
     return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
   }
   unwrap() {
@@ -3846,7 +3702,6 @@ function custom(check, params = {}, fatal) {
     });
   return ZodAny.create();
 }
-__name(custom, "custom");
 var late = {
   object: ZodObject.lazycreate
 };
@@ -3889,9 +3744,9 @@ var ZodFirstPartyTypeKind;
   ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
   ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
 })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
-var instanceOfType = /* @__PURE__ */ __name((cls, params = {
+var instanceOfType = (cls, params = {
   message: `Input not instance of ${cls.name}`
-}) => custom((data) => data instanceof cls, params), "instanceOfType");
+}) => custom((data) => data instanceof cls, params);
 var stringType = ZodString.create;
 var numberType = ZodNumber.create;
 var nanType = ZodNaN.create;
@@ -3926,18 +3781,18 @@ var optionalType = ZodOptional.create;
 var nullableType = ZodNullable.create;
 var preprocessType = ZodEffects.createWithPreprocess;
 var pipelineType = ZodPipeline.create;
-var ostring = /* @__PURE__ */ __name(() => stringType().optional(), "ostring");
-var onumber = /* @__PURE__ */ __name(() => numberType().optional(), "onumber");
-var oboolean = /* @__PURE__ */ __name(() => booleanType().optional(), "oboolean");
+var ostring = () => stringType().optional();
+var onumber = () => numberType().optional();
+var oboolean = () => booleanType().optional();
 var coerce = {
-  string: /* @__PURE__ */ __name((arg) => ZodString.create({ ...arg, coerce: true }), "string"),
-  number: /* @__PURE__ */ __name((arg) => ZodNumber.create({ ...arg, coerce: true }), "number"),
-  boolean: /* @__PURE__ */ __name((arg) => ZodBoolean.create({
+  string: (arg) => ZodString.create({ ...arg, coerce: true }),
+  number: (arg) => ZodNumber.create({ ...arg, coerce: true }),
+  boolean: (arg) => ZodBoolean.create({
     ...arg,
     coerce: true
-  }), "boolean"),
-  bigint: /* @__PURE__ */ __name((arg) => ZodBigInt.create({ ...arg, coerce: true }), "bigint"),
-  date: /* @__PURE__ */ __name((arg) => ZodDate.create({ ...arg, coerce: true }), "date")
+  }),
+  bigint: (arg) => ZodBigInt.create({ ...arg, coerce: true }),
+  date: (arg) => ZodDate.create({ ...arg, coerce: true })
 };
 var NEVER = INVALID;
 var z = /* @__PURE__ */ Object.freeze({
@@ -4060,25 +3915,14 @@ var z = /* @__PURE__ */ Object.freeze({
 // src/index.ts
 function isValidSchemaType(type) {
   if (typeof type !== "string") return false;
-  return [
-    "string",
-    "number",
-    "boolean",
-    "integer",
-    "array",
-    "object",
-    "null"
-  ].includes(type);
+  return ["string", "number", "boolean", "integer", "array", "object", "null"].includes(type);
 }
-__name(isValidSchemaType, "isValidSchemaType");
 function isJSONSchema7(schema) {
   return typeof schema !== "boolean";
 }
-__name(isJSONSchema7, "isJSONSchema7");
 function asExtendedJSONSchema7(schema) {
   return schema;
 }
-__name(asExtendedJSONSchema7, "asExtendedJSONSchema7");
 function unwrapSchemaDefinition(schema) {
   if (typeof schema === "boolean") {
     return schema;
@@ -4091,11 +3935,9 @@ function unwrapSchemaDefinition(schema) {
   }
   return schema;
 }
-__name(unwrapSchemaDefinition, "unwrapSchemaDefinition");
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-__name(isPlainObject, "isPlainObject");
 function areValuesEqual(left, right) {
   if (Object.is(left, right)) {
     return true;
@@ -4116,30 +3958,24 @@ function areValuesEqual(left, right) {
   }
   return false;
 }
-__name(areValuesEqual, "areValuesEqual");
 var percent = z.number().min(0).max(100);
 var formatMap = {
-  "date": /* @__PURE__ */ __name(() => z.string().regex(/^\d{4}-\d{2}-\d{2}$/), "date"),
-  "date-time": /* @__PURE__ */ __name(() => z.string().datetime(), "date-time"),
-  "email": /* @__PURE__ */ __name(() => z.string().email(), "email"),
-  "hostname": /* @__PURE__ */ __name(() => z.string(), "hostname"),
-  "ipv4": /* @__PURE__ */ __name(() => z.string().ip({
-    version: "v4"
-  }), "ipv4"),
-  "ipv6": /* @__PURE__ */ __name(() => z.string().ip({
-    version: "v6"
-  }), "ipv6"),
-  "uri": /* @__PURE__ */ __name(() => z.string().url(), "uri"),
-  "uuid": /* @__PURE__ */ __name(() => z.string().uuid(), "uuid"),
-  "color": /* @__PURE__ */ __name(() => z.string().regex(/^#(?:[0-9a-fA-F]{3}){1,2}$/), "color"),
-  "password": /* @__PURE__ */ __name(() => z.string(), "password"),
-  "code": /* @__PURE__ */ __name(() => z.string(), "code"),
-  "percent": /* @__PURE__ */ __name(() => percent, "percent")
+  "date": () => z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  "date-time": () => z.string().datetime(),
+  "email": () => z.string().email(),
+  "hostname": () => z.string(),
+  "ipv4": () => z.string().ip({ version: "v4" }),
+  "ipv6": () => z.string().ip({ version: "v6" }),
+  "uri": () => z.string().url(),
+  "uuid": () => z.string().uuid(),
+  "color": () => z.string().regex(/^#(?:[0-9a-fA-F]{3}){1,2}$/),
+  "password": () => z.string(),
+  "code": () => z.string(),
+  "percent": () => percent
 };
 function createRequiredUnknownSchema() {
   return z.custom((value) => value !== void 0);
 }
-__name(createRequiredUnknownSchema, "createRequiredUnknownSchema");
 function inferSchemaType(schema) {
   if (schema.type !== void 0 && !isValidSchemaType(schema.type)) {
     throw new Error(`Unsupported type: ${schema.type}`);
@@ -4161,7 +3997,6 @@ function inferSchemaType(schema) {
   }
   return null;
 }
-__name(inferSchemaType, "inferSchemaType");
 function applyValidators(zodType, schema, required) {
   let zodTypeWithValidators = zodType;
   if (schema.type === "string" && required) {
@@ -4193,18 +4028,23 @@ function applyValidators(zodType, schema, required) {
     zodTypeWithValidators = zodTypeWithValidators.regex(new RegExp(schema.pattern));
   }
   if (schema.const !== void 0) {
-    zodTypeWithValidators = zodTypeWithValidators.refine((value) => areValuesEqual(value, schema.const), {
-      message: `Must be equal to: ${JSON.stringify(schema.const)}`
-    });
+    zodTypeWithValidators = zodTypeWithValidators.refine(
+      (value) => areValuesEqual(value, schema.const),
+      {
+        message: `Must be equal to: ${JSON.stringify(schema.const)}`
+      }
+    );
   }
   if (schema.enum) {
-    zodTypeWithValidators = zodTypeWithValidators.refine((value) => schema.enum.some((enumValue) => areValuesEqual(value, enumValue)), {
-      message: `Must be one of: ${schema.enum.map((value) => JSON.stringify(value)).join(", ")}`
-    });
+    zodTypeWithValidators = zodTypeWithValidators.refine(
+      (value) => schema.enum.some((enumValue) => areValuesEqual(value, enumValue)),
+      {
+        message: `Must be one of: ${schema.enum.map((value) => JSON.stringify(value)).join(", ")}`
+      }
+    );
   }
   return zodTypeWithValidators;
 }
-__name(applyValidators, "applyValidators");
 function applyLogicalCompositionValidators(zodType, schema) {
   let composedType = zodType;
   if (schema.anyOf && schema.anyOf.length > 0) {
@@ -4230,14 +4070,12 @@ function applyLogicalCompositionValidators(zodType, schema) {
   }
   return composedType;
 }
-__name(applyLogicalCompositionValidators, "applyLogicalCompositionValidators");
 function matchesSchemaDefinition(schema, value) {
   if (!isJSONSchema7(schema)) {
     return schema;
   }
   return jsonSchemaDefinitionToZod(schema).safeParse(value).success;
 }
-__name(matchesSchemaDefinition, "matchesSchemaDefinition");
 function addSchemaIssues(schema, value, context) {
   if (!isJSONSchema7(schema)) {
     if (!schema) {
@@ -4256,11 +4094,10 @@ function addSchemaIssues(schema, value, context) {
     context.addIssue(issue);
   }
 }
-__name(addSchemaIssues, "addSchemaIssues");
 function collectComposablePropertyKeys(schema) {
   const extendedSchema = asExtendedJSONSchema7(schema);
   const keys = /* @__PURE__ */ new Set();
-  const visit = /* @__PURE__ */ __name((definition) => {
+  const visit = (definition) => {
     if (!definition || !isJSONSchema7(definition)) {
       return;
     }
@@ -4303,16 +4140,16 @@ function collectComposablePropertyKeys(schema) {
     visit(extendedDefinition.if);
     visit(extendedDefinition.then);
     visit(extendedDefinition.else);
-  }, "visit");
+  };
   visit(extendedSchema);
   return keys;
 }
-__name(collectComposablePropertyKeys, "collectComposablePropertyKeys");
 function hasComposableValidation(schema) {
   const extendedSchema = asExtendedJSONSchema7(schema);
-  return Boolean(extendedSchema.dependentRequired || extendedSchema.dependentSchemas || extendedSchema.if || extendedSchema.then || extendedSchema.else || Array.isArray(extendedSchema.allOf) && extendedSchema.allOf.length > 0);
+  return Boolean(
+    extendedSchema.dependentRequired || extendedSchema.dependentSchemas || extendedSchema.if || extendedSchema.then || extendedSchema.else || Array.isArray(extendedSchema.allOf) && extendedSchema.allOf.length > 0
+  );
 }
-__name(hasComposableValidation, "hasComposableValidation");
 function createPrimitiveType(schema, type) {
   switch (type) {
     case "string":
@@ -4333,7 +4170,6 @@ function createPrimitiveType(schema, type) {
       return z.null();
   }
 }
-__name(createPrimitiveType, "createPrimitiveType");
 function buildObjectSchema(schema) {
   const extendedSchema = asExtendedJSONSchema7(schema);
   const shape = {};
@@ -4372,9 +4208,7 @@ function buildObjectSchema(schema) {
             context.addIssue({
               code: z.ZodIssueCode.custom,
               message: `Property "${requiredKey}" is required when "${triggerKey}" is present`,
-              path: [
-                requiredKey
-              ]
+              path: [requiredKey]
             });
           }
         }
@@ -4404,14 +4238,12 @@ function buildObjectSchema(schema) {
     }
   });
 }
-__name(buildObjectSchema, "buildObjectSchema");
 function buildArraySchema(schema) {
   if (!schema.items || Array.isArray(schema.items)) {
     throw new Error("Invalid array items");
   }
   return applyValidators(z.array(jsonSchemaDefinitionToZod(schema.items, true)), schema, true);
 }
-__name(buildArraySchema, "buildArraySchema");
 function jsonSchemaDefinitionToZod(schema, required = true) {
   if (!isJSONSchema7(schema)) {
     return schema ? z.any() : z.never();
@@ -4427,19 +4259,21 @@ function jsonSchemaDefinitionToZod(schema, required = true) {
     return applyLogicalCompositionValidators(zodType, schema);
   }
   if (inferredType) {
-    zodType = applyValidators(createPrimitiveType(schema, inferredType), schema, required);
+    zodType = applyValidators(
+      createPrimitiveType(schema, inferredType),
+      schema,
+      required
+    );
     return applyLogicalCompositionValidators(zodType, schema);
   }
   zodType = applyValidators(z.any(), schema, required);
   return applyLogicalCompositionValidators(zodType, schema);
 }
-__name(jsonSchemaDefinitionToZod, "jsonSchemaDefinitionToZod");
 function convertPropertyToZod(schema, key, parentSchema) {
   const required = Array.isArray(parentSchema.required) && parentSchema.required.includes(key);
   const propertySchema = jsonSchemaDefinitionToZod(schema, required);
   return required ? propertySchema : propertySchema.optional();
 }
-__name(convertPropertyToZod, "convertPropertyToZod");
 function jsonSchemaToZodSchema(schema) {
   if (Array.isArray(schema)) {
     const definitions = schema.map(unwrapSchemaDefinition).filter((definition) => definition !== null);
@@ -4450,7 +4284,6 @@ function jsonSchemaToZodSchema(schema) {
   }
   return jsonSchemaDefinitionToZod(schema);
 }
-__name(jsonSchemaToZodSchema, "jsonSchemaToZodSchema");
 function jsonSchemaToZod(schema) {
   const zodSchema = {};
   if (Array.isArray(schema)) {
@@ -4469,7 +4302,6 @@ function jsonSchemaToZod(schema) {
   }
   return zodSchema;
 }
-__name(jsonSchemaToZod, "jsonSchemaToZod");
 export {
   jsonSchemaToZod,
   jsonSchemaToZodSchema