zod-compare 1.0.0 → 2.0.0

package/README.md

@@ -5,7 +5,7 @@
 
 Compare two [Zod](https://zod.dev/) schemas recursively.
 
-`zod-compare` provides functions to compare Zod schemas, allowing you to determine whether two schemas are the same or compatible.
+`zod-compare` provides functions to compare Zod schemas, allowing you to determine whether two schemas are the same or compatible. Supports both Zod v3 and Zod v4.
 
 ## Installation
 
@@ -41,6 +41,26 @@ isCompatibleType(
 // true
 ```
 
+Use the top-level helpers to compare schemas:
+
+- `isSameType(a, b)`: true only if the two schemas have the same shape and types (ignores refinements like min/max/length, transforms, etc.)
+- `isCompatibleType(higherType, lowerType)`: true if the looser schema (higherType) can be accepted wherever the stricter schema (lowerType) is expected
+
+### Versions and entry points
+
+The top-level APIs accept inputs from Zod v3 or v4 and automatically route to the right comparison engine when both inputs are from the same major. If inputs are mixed (v3 vs v4), both functions throw.
+
+If you’re on Zod v4, import from the v4 entry for the best types/inference:
+
+```ts
+import { isSameType } from "zod-compare/zod4";
+import { z } from "zod/v4";
+
+isSameType(z.string(), z.string()); // true
+```
+
+If you use Zod v3 exclusively, import from `zod-compare/zod3`.
+
 ## Advanced Usage
 
 ### Custom Rules
@@ -104,7 +124,7 @@ Compares two Zod schemas and returns `true` if they are the same.
 ```ts
 import { isSameType } from "zod-compare";
 
-type isSameType: (a: ZodType, b: ZodType, context?: CompareContext) => boolean;
+type isSameType: (a: $ZodType, b: $ZodType, context?: CompareContext) => boolean;
 ```
 
 ### `createCompareFn`
@@ -137,7 +157,7 @@ Compares two Zod schemas and returns `true` if they are compatible.
 import { isCompatibleType } from "zod-compare";
 // The `higherType` should be a looser type
 // The `lowerType` should be a stricter type
-type isCompatibleType: (higherType: ZodType, lowerType: ZodType) => boolean;
+type isCompatibleType: (higherType: $ZodType, lowerType: $ZodType) => boolean;
 ```
 
 ### Preset Rules
@@ -160,15 +180,16 @@ const yourIsSameType = createCompareFn([customRule, ...isSameTypePresetRules]);
 type CompareContext = {
   stacks?: {
     name: string;
-    target: [a: ZodType, b: ZodType];
+    target: [a: $ZodTypes, b: $ZodTypes];
+    result: boolean;
   }[];
 } & Record<string, unknown>;
 
 type CompareFn = (
-  a: ZodType,
-  b: ZodType,
+  a: $ZodTypes,
+  b: $ZodTypes,
   next: () => boolean,
-  recheck: (a: ZodType, b: ZodType) => boolean,
+  recheck: (a: $ZodType, b: $ZodType) => boolean,
   context: CompareContext,
 ) => boolean;
 

package/dist/index.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("zod"),m=e=>{const n=(t,o,a={})=>{let i=-1;const s=f=>{if(f===e.length)throw new Error("Failed to compare type! "+t+" "+o);if(f===i)throw new Error("next() called multiple times");i=f;const u=e[f],d=u.compare(t,o,()=>s(f+1),(y,_)=>n(y,_,a),a);return"stacks"in a&&Array.isArray(a.stacks)&&a.stacks.push({name:u.name,target:[t,o],result:d}),d};return s(0)};return n},h=m,p=e=>e instanceof r.z.ZodString||e instanceof r.z.ZodNumber||e instanceof r.z.ZodNaN||e instanceof r.z.ZodBigInt||e instanceof r.z.ZodBoolean||e instanceof r.z.ZodDate||e instanceof r.z.ZodSymbol||e instanceof r.z.ZodUndefined||e instanceof r.z.ZodNull||e instanceof r.z.ZodAny||e instanceof r.z.ZodUnknown||e instanceof r.z.ZodNever||e instanceof r.z.ZodVoid,c=e=>e.options.flatMap(n=>n instanceof r.z.ZodUnion?c(n):n),l=[{name:"undefined check",compare:(e,n,t)=>{if(e===void 0||n===void 0)throw new Error("Failed to compare type! "+e+" "+n);return t()}},{name:"compare reference",compare:(e,n,t)=>e===n?!0:t()},{name:"compare constructor",compare:(e,n,t)=>e.constructor!==n.constructor?!1:t()},{name:"compare typeName",compare:(e,n,t)=>{if(!("typeName"in e._def)||!("typeName"in n._def))throw new Error("Failed to compare type! "+e._def+" "+n._def);return e._def.typeName!==n._def.typeName?!1:t()}},{name:"compare ZodBranded",compare:(e,n,t)=>e instanceof r.z.ZodBranded||n instanceof r.z.ZodBranded?!1:t()},{name:"unwrap ZodType",compare:(e,n,t,o)=>"unwrap"in e&&typeof e.unwrap=="function"?"unwrap"in n&&typeof n.unwrap=="function"?o(e.unwrap(),n.unwrap()):!1:t()},{name:"is same primitive",compare:(e,n,t)=>p(e)&&p(n)&&e.constructor===n.constructor?!0:t()},{name:"compare ZodObject",compare:(e,n,t,o)=>{if(e instanceof r.z.ZodObject&&n instanceof r.z.ZodObject){const a=e.shape,i=n.shape;if(Object.keys(a).length!==Object.keys(i).length)return!1;for(const s in a)if(!(s in i)||!o(a[s],i[s]))return!1;return!0}return t()}},{name:"compare ZodArray",compare:(e,n,t,o)=>e instanceof r.z.ZodArray&&n instanceof r.z.ZodArray?o(e.element,n.element):t()},{name:"compare ZodTuple",compare:(e,n,t,o)=>{if(e instanceof r.z.ZodTuple&&n instanceof r.z.ZodTuple){if(e.items.length!==n.items.length)return!1;for(let a=0;a<e.items.length;a++)if(!o(e.items[a],n.items[a]))return!1;return e._def.rest||n._def.rest?!e._def.rest||!n._def.rest?!1:o(e._def.rest,n._def.rest):!0}return t()}},{name:"compare ZodLiteral",compare:(e,n,t)=>e instanceof r.z.ZodLiteral&&n instanceof r.z.ZodLiteral?e.value===n.value:t()},{name:"compare ZodIntersection",compare:(e,n,t,o)=>e instanceof r.z.ZodIntersection&&n instanceof r.z.ZodIntersection?o(e._def.left,n._def.left)&&o(e._def.right,n._def.right)||o(e._def.left,n._def.right)&&o(e._def.right,n._def.left):t()},{name:"compare ZodUnion",compare:(e,n,t,o)=>{if(e instanceof r.z.ZodUnion&&n instanceof r.z.ZodUnion){const a=c(e),i=c(n);if(a.length!==i.length)return!1;for(let s of a){let f=i.findIndex(u=>o(s,u));if(f===-1)return!1;i.splice(f,1)}return i.length===0}return t()}},{name:"compare ZodReadonly",compare:(e,n,t,o)=>e instanceof r.z.ZodReadonly&&n instanceof r.z.ZodReadonly?o(e._def.innerType,n._def.innerType):t()},{name:"compare ZodRecord",compare:(e,n,t,o)=>e instanceof r.z.ZodRecord&&n instanceof r.z.ZodRecord?o(e.keySchema,n.keySchema)&&o(e.valueSchema,n.valueSchema):t()},{name:"compare ZodMap",compare:(e,n,t,o)=>e instanceof r.z.ZodMap&&n instanceof r.z.ZodMap?o(e.keySchema,n.keySchema)&&o(e.valueSchema,n.valueSchema):t()},{name:"compare ZodSet",compare:(e,n,t,o)=>e instanceof r.z.ZodSet&&n instanceof r.z.ZodSet?o(e._def.valueType,n._def.valueType):t()},{name:"compare ZodFunction",compare:(e,n,t,o)=>e instanceof r.z.ZodFunction&&n instanceof r.z.ZodFunction?o(e.parameters(),n.parameters())&&o(e.returnType(),n.returnType()):t()},{name:"compare ZodEnum",compare:(e,n,t)=>{if(e instanceof r.z.ZodEnum&&n instanceof r.z.ZodEnum){const o=e.options,a=n.options;if(o.length!==a.length)return!1;for(let i=0;i<o.length;i++)if(o[i]!==a[i])return!1;return!0}return t()}},{name:"compare ZodNativeEnum",compare:(e,n,t)=>{if(e instanceof r.z.ZodNativeEnum&&n instanceof r.z.ZodNativeEnum){const o=e.enum,a=n.enum;if(Object.keys(o).length!==Object.keys(a).length)return!1;for(const i in o)if(o[i]!==a[i])return!1;return!0}return t()}}],Z=m(l),z=[{name:"is same type",compare:(e,n,t)=>Z(e,n)?!0:t()},{name:"check typeName",compare:(e,n,t)=>{if(!("typeName"in e._def)||!("typeName"in n._def))throw new Error("Failed to compare type! "+e._def+" "+n._def);return t()}},{name:"check ZodOptional/ZodNullable",compare:(e,n,t,o)=>n instanceof r.z.ZodOptional||n instanceof r.z.ZodNullable?o(e,n.unwrap()):t()},{name:"check ZodUnion",compare:(e,n,t,o)=>{if(e instanceof r.z.ZodUnion&&n instanceof r.z.ZodUnion){const a=c(e),i=c(n);for(let s=0;s<a.length;s++)if(!i.some(u=>o(a[s],u)))return!1;return!0}return e instanceof r.z.ZodUnion?c(e).every(i=>o(i,n)):n instanceof r.z.ZodUnion?c(n).some(i=>o(e,i)):t()}},{name:"compare constructor",compare:(e,n,t)=>e.constructor!==n.constructor?!1:t()},{name:"check ZodObject",compare:(e,n,t,o)=>{if(e instanceof r.z.ZodObject&&n instanceof r.z.ZodObject){const a=e.shape,i=n.shape;if(Object.keys(a).length<Object.keys(i).length)return!1;for(const s in i)if(!(s in a)||!o(a[s],i[s]))return!1;return!0}return t()}},{name:"check ZodArray",compare:(e,n,t,o)=>e instanceof r.z.ZodArray&&n instanceof r.z.ZodArray?o(e.element,n.element):t()},{name:"check ZodTuple",compare:(e,n,t,o)=>{if(e instanceof r.z.ZodTuple&&n instanceof r.z.ZodTuple){if(e.items.length<n.items.length)return!1;for(let a=0;a<n.items.length;a++)if(!o(e.items[a],n.items[a]))return!1;return n._def.rest?e._def.rest?o(e._def.rest,n._def.rest):!1:!0}return t()}}],S=m(z),O=(e,n)=>({name:e,rule:n});exports.createCompareFn=m;exports.createIsSameTypeFn=h;exports.defineCompareRule=O;exports.isCompatibleType=S;exports.isCompatibleTypePresetRules=z;exports.isSameType=Z;exports.isSameTypePresetRules=l;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("./is-compatible-type-BA3YzVJ3.cjs"),s=require("./is-compatible-type-CN9ljc9s.cjs"),i=e=>!!(o.isLegacyZodFunction(e)||"_zod"in e),t=e=>!i(e),n=(e,r)=>!!(t(e)&&t(r)||i(e)&&i(r)),p=(e,r)=>{if(i(e)&&i(r))return o.isSameType(e,r);if(t(e)&&t(r))return s.isSameType(e,r);throw new Error("Failed to compare types: different Zod versions")},a=(e,r)=>{if(i(e)&&i(r))return o.isCompatibleType(e,r);if(t(e)&&t(r))return s.isCompatibleType(e,r);throw new Error("Failed to compare types: different Zod versions")};exports.haveSameZodMajor=n;exports.isCompatibleType=a;exports.isSameType=p;exports.isZod3Schema=t;exports.isZod4Schema=i;
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":["../src/create-compare-fn.ts","../src/utils.ts","../src/is-same-type.ts","../src/is-compatible-type.ts","../src/rules.ts"],"sourcesContent":["import type { ZodType } from \"zod\";\nimport { type CompareContext, type CompareRule } from \"./types.ts\";\n\nexport const createCompareFn = (rules: CompareRule[]) => {\n  const isSameTypeFn = (\n    a: ZodType,\n    b: ZodType,\n    context: CompareContext = {},\n  ): boolean => {\n    let prevIndex = -1;\n    const runner = (index: number): boolean => {\n      if (index === rules.length) {\n        throw new Error(\"Failed to compare type! \" + a + \" \" + b);\n      }\n      if (index === prevIndex) {\n        throw new Error(\"next() called multiple times\");\n      }\n      prevIndex = index;\n      const rule = rules[index];\n\n      const compareResult = rule.compare(\n        a,\n        b,\n        () => runner(index + 1),\n        (a, b) => isSameTypeFn(a, b, context),\n        context,\n      );\n\n      if (\"stacks\" in context && Array.isArray(context.stacks)) {\n        context.stacks.push({\n          name: rule.name,\n          target: [a, b],\n          result: compareResult,\n        });\n      }\n\n      return compareResult;\n    };\n\n    return runner(0);\n  };\n  return isSameTypeFn;\n};\n\n/**\n * @deprecated Use {@link createCompareFn} instead.\n */\nexport const createIsSameTypeFn = createCompareFn;\n","import { z, type ZodType } from \"zod\";\n\n// See ZodFirstPartyTypeKind\nexport const isPrimitiveType = (a: ZodType): boolean => {\n  return (\n    a instanceof z.ZodString ||\n    a instanceof z.ZodNumber ||\n    a instanceof z.ZodNaN ||\n    a instanceof z.ZodBigInt ||\n    a instanceof z.ZodBoolean ||\n    a instanceof z.ZodDate ||\n    a instanceof z.ZodSymbol ||\n    a instanceof z.ZodUndefined ||\n    a instanceof z.ZodNull ||\n    a instanceof z.ZodAny ||\n    a instanceof z.ZodUnknown ||\n    a instanceof z.ZodNever ||\n    a instanceof z.ZodVoid\n  );\n};\n\ntype Mutable<T> = { -readonly [k in keyof T]: T[k] };\n\nexport const flatUnwrapUnion = <\n  T extends z.ZodUnionOptions = readonly [z.ZodTypeAny, ...z.ZodTypeAny[]],\n>(\n  t: z.ZodUnion<T>,\n): Mutable<T> => {\n  return t.options.flatMap((x) => {\n    if (x instanceof z.ZodUnion) {\n      return flatUnwrapUnion(x);\n    }\n    return x;\n  }) as unknown as T;\n};\n","import { z } from \"zod\";\nimport { createCompareFn } from \"./create-compare-fn.ts\";\nimport type { CompareRule } from \"./types.ts\";\nimport { flatUnwrapUnion, isPrimitiveType } from \"./utils.ts\";\n\nexport const isSameTypePresetRules = [\n  {\n    name: \"undefined check\",\n    compare: (a, b, next) => {\n      if (a === undefined || b === undefined) {\n        throw new Error(\"Failed to compare type! \" + a + \" \" + b);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare reference\",\n    compare: (a, b, next) => {\n      if (a === b) {\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare constructor\",\n    compare: (a, b, next) => {\n      // https://stackoverflow.com/questions/24959862/how-to-tell-if-two-javascript-instances-are-of-the-same-class-type\n      if (a.constructor !== b.constructor) {\n        return false;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare typeName\",\n    compare: (a, b, next) => {\n      if (!(\"typeName\" in a._def) || !(\"typeName\" in b._def)) {\n        throw new Error(\"Failed to compare type! \" + a._def + \" \" + b._def);\n      }\n      if (a._def.typeName !== b._def.typeName) {\n        return false;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare ZodBranded\",\n    compare: (a, b, next) => {\n      if (a instanceof z.ZodBranded || b instanceof z.ZodBranded) {\n        // We can not distinguish different branded type\n        // throw new Error(\"Can not distinguish different branded type!\");\n        return false;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"unwrap ZodType\",\n    // ZodPromise ZodOptional ZodNullable ZodBranded\n    compare: (a, b, next, recheck) => {\n      if (\"unwrap\" in a && typeof a.unwrap === \"function\") {\n        if (!(\"unwrap\" in b && typeof b.unwrap === \"function\")) {\n          return false;\n        }\n        return recheck(a.unwrap(), b.unwrap());\n      }\n      return next();\n    },\n  },\n  {\n    name: \"is same primitive\",\n    compare: (a, b, next) => {\n      if (\n        isPrimitiveType(a) &&\n        isPrimitiveType(b) &&\n        a.constructor === b.constructor\n      ) {\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare ZodObject\",\n    compare: (a, b, next, recheck) => {\n      if (a instanceof z.ZodObject && b instanceof z.ZodObject) {\n        const aShape = a.shape;\n        const bShape = b.shape;\n        if (Object.keys(aShape).length !== Object.keys(bShape).length)\n          return false;\n        for (const key in aShape) {\n          if (!(key in bShape)) return false;\n          if (!recheck(aShape[key], bShape[key])) return false;\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare ZodArray\",\n    compare: (a, b, next, recheck) => {\n      if (a instanceof z.ZodArray && b instanceof z.ZodArray) {\n        return recheck(a.element, b.element);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare ZodTuple\",\n    compare: (a, b, next, recheck) => {\n      if (a instanceof z.ZodTuple && b instanceof z.ZodTuple) {\n        if (a.items.length !== b.items.length) return false;\n        for (let i = 0; i < a.items.length; i++) {\n          if (!recheck(a.items[i], b.items[i])) return false;\n        }\n        // Compare rest\n        if (a._def.rest || b._def.rest) {\n          // If one has rest, the other must have rest\n          if (!a._def.rest || !b._def.rest) return false;\n          return recheck(a._def.rest, b._def.rest);\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare ZodLiteral\",\n    compare: (a, b, next) => {\n      if (a instanceof z.ZodLiteral && b instanceof z.ZodLiteral) {\n        return a.value === b.value;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare ZodIntersection\",\n    compare: (a, b, next, recheck) => {\n      // ZodIntersection aka and\n      if (a instanceof z.ZodIntersection && b instanceof z.ZodIntersection) {\n        return (\n          (recheck(a._def.left, b._def.left) &&\n            recheck(a._def.right, b._def.right)) ||\n          (recheck(a._def.left, b._def.right) &&\n            recheck(a._def.right, b._def.left))\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare ZodUnion\",\n    compare: (a, b, next, recheck) => {\n      // ZodUnion aka or\n      if (a instanceof z.ZodUnion && b instanceof z.ZodUnion) {\n        const aOptions = flatUnwrapUnion(a as z.ZodUnion<z.ZodUnionOptions>);\n        const bOptions = flatUnwrapUnion(b as z.ZodUnion<z.ZodUnionOptions>);\n        if (aOptions.length !== bOptions.length) return false;\n        for (let optionA of aOptions) {\n          let matchIndex = bOptions.findIndex((optionB) =>\n            recheck(optionA, optionB),\n          );\n          if (matchIndex === -1) return false;\n          bOptions.splice(matchIndex, 1);\n        }\n        return bOptions.length === 0;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare ZodReadonly\",\n    compare: (a, b, next, recheck) => {\n      if (a instanceof z.ZodReadonly && b instanceof z.ZodReadonly) {\n        return recheck(a._def.innerType, b._def.innerType);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare ZodRecord\",\n    compare: (a, b, next, recheck) => {\n      if (a instanceof z.ZodRecord && b instanceof z.ZodRecord) {\n        return (\n          recheck(a.keySchema, b.keySchema) &&\n          recheck(a.valueSchema, b.valueSchema)\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare ZodMap\",\n    compare: (a, b, next, recheck) => {\n      if (a instanceof z.ZodMap && b instanceof z.ZodMap) {\n        return (\n          recheck(a.keySchema, b.keySchema) &&\n          recheck(a.valueSchema, b.valueSchema)\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare ZodSet\",\n    compare: (a, b, next, recheck) => {\n      if (a instanceof z.ZodSet && b instanceof z.ZodSet) {\n        return recheck(a._def.valueType, b._def.valueType);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare ZodFunction\",\n    compare: (a, b, next, recheck) => {\n      if (a instanceof z.ZodFunction && b instanceof z.ZodFunction) {\n        return (\n          recheck(a.parameters(), b.parameters()) &&\n          recheck(a.returnType(), b.returnType())\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare ZodEnum\",\n    compare: (a, b, next) => {\n      if (a instanceof z.ZodEnum && b instanceof z.ZodEnum) {\n        const optionsA: [string, ...string[]] = a.options;\n        const optionsB: [string, ...string[]] = b.options;\n        if (optionsA.length !== optionsB.length) return false;\n        for (let i = 0; i < optionsA.length; i++) {\n          if (optionsA[i] !== optionsB[i]) return false;\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare ZodNativeEnum\",\n    compare: (a, b, next) => {\n      if (a instanceof z.ZodNativeEnum && b instanceof z.ZodNativeEnum) {\n        const enumA: z.EnumLike = a.enum;\n        const enumB: z.EnumLike = b.enum;\n        if (Object.keys(enumA).length !== Object.keys(enumB).length)\n          return false;\n        for (const key in enumA) {\n          if (enumA[key] !== enumB[key]) return false;\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n] as const satisfies CompareRule[];\n\nexport const strictIsSameTypeRules = [\n  {\n    name: \"compare optional\",\n    compare: (a, b, next) => {\n      if (a.isOptional() !== b.isOptional()) return false;\n      return next();\n    },\n  },\n  {\n    name: \"compare nullable\",\n    compare: (a, b, next) => {\n      if (a.isNullable() !== b.isNullable()) return false;\n      return next();\n    },\n  },\n  {\n    name: \"compare corece\",\n    compare: (a, b, next) => {\n      if (\"corece\" in a._def && \"corece\" in b._def) {\n        if (a._def.corece !== b._def.corece) {\n          return false;\n        }\n      }\n      if (\"corece\" in a._def) {\n        return false;\n      }\n      if (\"corece\" in b._def) {\n        return false;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare description\",\n    compare: (a, b, next) => {\n      if (a.description !== b.description) {\n        return false;\n      }\n      return next();\n    },\n  },\n] as const satisfies CompareRule[];\n\n/**\n * isSameType is a function that checks if two ZodTypes are the same.\n *\n * Caveats:\n * - The function does not validate specific criteria such as min or max values, length, email, etc.\n * - It excludes comparisons involving methods like .describe(), .catch(), .default(), .refine(), and .transform().\n *\n * @param a - The first ZodType to compare.\n * @param b - The second ZodType to compare.\n * @returns A boolean indicating whether the two types are the same.\n *\n * @throws Will throw an error if it encounters an unknown type.\n *\n * @example\n * ```ts\n * isSameType(z.string(), z.string()); // true\n * isSameType(z.string(), z.number()); // false\n * ```\n */\nexport const isSameType = createCompareFn(isSameTypePresetRules);\n","import { z, type ZodType } from \"zod\";\nimport { createCompareFn } from \"./create-compare-fn.ts\";\nimport { isSameType } from \"./is-same-type.ts\";\nimport type { CompareRule } from \"./types.ts\";\nimport { flatUnwrapUnion } from \"./utils.ts\";\n\nexport const isCompatibleTypePresetRules = [\n  {\n    name: \"is same type\",\n    compare: (higherType, lowerType, next) => {\n      if (isSameType(higherType, lowerType)) {\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check typeName\",\n    compare: (higherType, lowerType, next) => {\n      if (!(\"typeName\" in higherType._def) || !(\"typeName\" in lowerType._def)) {\n        throw new Error(\n          \"Failed to compare type! \" + higherType._def + \" \" + lowerType._def,\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check ZodOptional/ZodNullable\",\n    compare: (higherType, lowerType, next, recheck) => {\n      if (\n        lowerType instanceof z.ZodOptional ||\n        lowerType instanceof z.ZodNullable\n      ) {\n        return recheck(higherType, lowerType.unwrap());\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check ZodUnion\",\n    compare: (higherType, lowerType, next, recheck) => {\n      if (higherType instanceof z.ZodUnion && lowerType instanceof z.ZodUnion) {\n        const higherOptions = flatUnwrapUnion(higherType);\n        const lowerOptions = flatUnwrapUnion(lowerType);\n        for (let i = 0; i < higherOptions.length; i++) {\n          const match = lowerOptions.some((option: ZodType) =>\n            recheck(higherOptions[i], option),\n          );\n          if (!match) return false;\n        }\n        return true;\n      }\n      if (higherType instanceof z.ZodUnion) {\n        const higherOptions = flatUnwrapUnion(higherType);\n        return higherOptions.every((option: ZodType) =>\n          recheck(option, lowerType),\n        );\n      }\n      if (lowerType instanceof z.ZodUnion) {\n        const lowerOptions = flatUnwrapUnion(lowerType);\n        return lowerOptions.some((option: ZodType) =>\n          recheck(higherType, option),\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare constructor\",\n    compare: (higherType, lowerType, next) => {\n      // We have already checked if the types are ZodUnion or ZodOptional/ZodNullable before\n      if (higherType.constructor !== lowerType.constructor) {\n        return false;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check ZodObject\",\n    compare: (higherType, lowerType, next, recheck) => {\n      if (\n        higherType instanceof z.ZodObject &&\n        lowerType instanceof z.ZodObject\n      ) {\n        const superTypeShape = higherType.shape;\n        const subTypeShape = lowerType.shape;\n        if (\n          Object.keys(superTypeShape).length < Object.keys(subTypeShape).length\n        )\n          return false;\n        for (const key in subTypeShape) {\n          if (!(key in superTypeShape)) return false;\n          if (!recheck(superTypeShape[key], subTypeShape[key])) {\n            return false;\n          }\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check ZodArray\",\n    compare: (higherType, lowerType, next, recheck) => {\n      if (higherType instanceof z.ZodArray && lowerType instanceof z.ZodArray) {\n        return recheck(higherType.element, lowerType.element);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check ZodTuple\",\n    compare: (higherType, lowerType, next, recheck) => {\n      if (higherType instanceof z.ZodTuple && lowerType instanceof z.ZodTuple) {\n        if (higherType.items.length < lowerType.items.length) return false;\n        for (let i = 0; i < lowerType.items.length; i++) {\n          if (!recheck(higherType.items[i], lowerType.items[i])) {\n            return false;\n          }\n        }\n        // Check rest\n        if (lowerType._def.rest) {\n          if (!higherType._def.rest) return false;\n          return recheck(higherType._def.rest, lowerType._def.rest);\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n] as const satisfies CompareRule[];\n\n/**\n * Check if a the higherType matches the lowerType\n *\n * @deprecated This a unstable API and still in development\n *\n * @param higherType The looser type\n * @param lowerType The stricter type\n *\n * @example\n * ```ts\n * isCompatibleType(z.string(), z.string()); // true\n *\n * isCompatibleType(\n *   z.object({ name: z.string(), other: z.number() }),\n *   z.object({ name: z.string() })\n * );\n * // true\n * ```\n */\nexport const isCompatibleType = createCompareFn(isCompatibleTypePresetRules);\n","import type { CompareFn } from \"./types.ts\";\n\nexport const defineCompareRule = (name: string, rule: CompareFn) => ({\n  name,\n  rule,\n});\n"],"names":["createCompareFn","rules","isSameTypeFn","a","b","context","prevIndex","runner","index","rule","compareResult","createIsSameTypeFn","isPrimitiveType","z","flatUnwrapUnion","t","x","isSameTypePresetRules","next","recheck","aShape","bShape","key","i","aOptions","bOptions","optionA","matchIndex","optionB","optionsA","optionsB","enumA","enumB","isSameType","isCompatibleTypePresetRules","higherType","lowerType","higherOptions","lowerOptions","option","superTypeShape","subTypeShape","isCompatibleType","defineCompareRule","name"],"mappings":"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"}
+{"version":3,"file":"index.cjs","sources":["../src/utils.ts","../src/index.ts"],"sourcesContent":["import type * as z3 from \"zod/v3\";\nimport type * as z4 from \"zod/v4/core\";\nimport { isLegacyZodFunction, type LegacyZodFunction } from \"./zod4/compat.ts\";\n\n/**\n * See https://zod.dev/library-authors?id=how-to-support-zod-3-and-zod-4-simultaneously\n */\nexport const isZod4Schema = (\n  schema: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n): schema is z4.$ZodType => {\n  if (isLegacyZodFunction(schema)) {\n    // version >= v4.0 && <4.1\n    return true;\n  }\n  if (\"_zod\" in schema) {\n    // This is a Zod 4 schema\n    // You can access the schema definition using `schema._zod.def`\n    return true;\n  } else {\n    // This is a Zod 3 schema\n    // You can access the schema definition using `schema._def`\n    return false;\n  }\n};\n\nexport const isZod3Schema = (\n  schema: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n): schema is z3.ZodTypeAny => !isZod4Schema(schema);\n\nexport const haveSameZodMajor = (\n  schemaA: z3.ZodTypeAny | z4.$ZodType,\n  schemaB: z3.ZodTypeAny | z4.$ZodType,\n): boolean => {\n  if (isZod3Schema(schemaA) && isZod3Schema(schemaB)) {\n    return true; // Both are Zod 3 schemas\n  }\n  if (isZod4Schema(schemaA) && isZod4Schema(schemaB)) {\n    return true; // Both are Zod 4 schemas\n  }\n  return false; // One is Zod 3 and the other is Zod 4\n};\n","import type * as z3 from \"zod/v3\";\nimport type * as z4 from \"zod/v4/core\";\nimport { haveSameZodMajor, isZod3Schema, isZod4Schema } from \"./utils.ts\";\nimport {\n  isCompatibleType as isCompatibleZod3Type,\n  isSameType as isSameZod3Type,\n} from \"./zod3/index.ts\";\nimport type { LegacyZodFunction } from \"./zod4/compat.ts\";\nimport {\n  isCompatibleType as isCompatibleZod4Type,\n  isSameType as isSameZod4Type,\n} from \"./zod4/index.ts\";\n\n// Export versions checking utilities\nexport { haveSameZodMajor, isZod3Schema, isZod4Schema };\n\n/**\n * isSameType is a function that checks if two ZodTypes are the same.\n *\n * Caveats:\n * - The function does not validate specific criteria such as min or max values, length, email, etc.\n * - It excludes comparisons involving methods like .describe(), .catch(), .default(), .refine(), and .transform().\n *\n * @param a - The first ZodType to compare.\n * @param b - The second ZodType to compare.\n * @returns A boolean indicating whether the two types are the same.\n *\n * @throws Will throw an error if it encounters an unknown type.\n *\n * @example\n * ```ts\n * isSameType(z.string(), z.string()); // true\n * isSameType(z.string(), z.number()); // false\n * ```\n */\nexport const isSameType = (\n  a: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n  b: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n): boolean => {\n  if (isZod4Schema(a) && isZod4Schema(b)) {\n    return isSameZod4Type(a, b);\n  }\n  if (isZod3Schema(a) && isZod3Schema(b)) {\n    return isSameZod3Type(a, b);\n  }\n  throw new Error(\"Failed to compare types: different Zod versions\");\n};\n\n/**\n * Check if a the higherType matches the lowerType\n *\n * @deprecated This a unstable API and still in development\n *\n * @param higherType The looser type\n * @param lowerType The stricter type\n *\n * @example\n * ```ts\n * isCompatibleType(z.string(), z.string()); // true\n *\n * isCompatibleType(\n *   z.object({ name: z.string(), other: z.number() }),\n *   z.object({ name: z.string() })\n * );\n * // true\n * ```\n */\nexport const isCompatibleType = (\n  a: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n  b: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n): boolean => {\n  if (isZod4Schema(a) && isZod4Schema(b)) {\n    return isCompatibleZod4Type(a, b);\n  }\n  if (isZod3Schema(a) && isZod3Schema(b)) {\n    return isCompatibleZod3Type(a, b);\n  }\n  throw new Error(\"Failed to compare types: different Zod versions\");\n};\n"],"names":["isZod4Schema","schema","isLegacyZodFunction","isZod3Schema","haveSameZodMajor","schemaA","schemaB","isSameType","a","b","isSameZod4Type","isSameZod3Type","isCompatibleType","isCompatibleZod4Type","isCompatibleZod3Type"],"mappings":"oLAOaA,EACXC,GAEIC,GAAAA,EAAAA,oBAAoBD,CAAM,GAI1B,SAAUA,GAWHE,EACXF,GAC4B,CAACD,EAAaC,CAAM,EAErCG,EAAmB,CAC9BC,EACAC,IAEI,GAAAH,EAAaE,CAAO,GAAKF,EAAaG,CAAO,GAG7CN,EAAaK,CAAO,GAAKL,EAAaM,CAAO,GCDtCC,EAAa,CACxBC,EACAC,IACY,CACZ,GAAIT,EAAaQ,CAAC,GAAKR,EAAaS,CAAC,EACnC,OAAOC,EAAAA,WAAeF,EAAGC,CAAC,EAE5B,GAAIN,EAAaK,CAAC,GAAKL,EAAaM,CAAC,EACnC,OAAOE,EAAAA,WAAeH,EAAGC,CAAC,EAE5B,MAAM,IAAI,MAAM,iDAAiD,CACnE,EAqBaG,EAAmB,CAC9BJ,EACAC,IACY,CACZ,GAAIT,EAAaQ,CAAC,GAAKR,EAAaS,CAAC,EACnC,OAAOI,EAAAA,iBAAqBL,EAAGC,CAAC,EAElC,GAAIN,EAAaK,CAAC,GAAKL,EAAaM,CAAC,EACnC,OAAOK,EAAAA,iBAAqBN,EAAGC,CAAC,EAElC,MAAM,IAAI,MAAM,iDAAiD,CACnE"}

package/dist/index.d.ts

@@ -1,162 +1,45 @@
-import { CompareContext as CompareContext_2 } from './types.ts';
-import { z } from 'zod';
-import { ZodType } from 'zod';
-
-export declare type CompareContext = {
-    stacks?: {
-        name: string;
-        target: [a: ZodType, b: ZodType];
-        result: boolean;
-    }[];
-} & Record<string, unknown>;
-
-export declare type CompareFn = (a: ZodType, b: ZodType, next: () => boolean, recheck: (a: ZodType, b: ZodType) => boolean, context: CompareContext) => boolean;
-
-export declare type CompareRule = {
-    name: string;
-    compare: CompareFn;
-};
-
-export declare const createCompareFn: (rules: CompareRule[]) => (a: ZodType, b: ZodType, context?: CompareContext) => boolean;
-
-/**
- * @deprecated Use {@link createCompareFn} instead.
- */
-export declare const createIsSameTypeFn: (rules: CompareRule[]) => (a: ZodType, b: ZodType, context?: CompareContext) => boolean;
-
-export declare const defineCompareRule: (name: string, rule: CompareFn) => {
-    name: string;
-    rule: CompareFn;
-};
-
-/**
- * Check if a the higherType matches the lowerType
- *
- * @deprecated This a unstable API and still in development
- *
- * @param higherType The looser type
- * @param lowerType The stricter type
- *
- * @example
- * ```ts
- * isCompatibleType(z.string(), z.string()); // true
- *
- * isCompatibleType(
- *   z.object({ name: z.string(), other: z.number() }),
- *   z.object({ name: z.string() })
- * );
- * // true
- * ```
- */
-export declare const isCompatibleType: (a: ZodType, b: ZodType, context?: CompareContext_2) => boolean;
-
-export declare const isCompatibleTypePresetRules: [{
-    readonly name: "is same type";
-    readonly compare: (higherType: z.ZodType<any, z.ZodTypeDef, any>, lowerType: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean) => boolean;
-}, {
-    readonly name: "check typeName";
-    readonly compare: (higherType: z.ZodType<any, z.ZodTypeDef, any>, lowerType: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean) => boolean;
-}, {
-    readonly name: "check ZodOptional/ZodNullable";
-    readonly compare: (higherType: z.ZodType<any, z.ZodTypeDef, any>, lowerType: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean, recheck: (a: ZodType, b: ZodType) => boolean) => boolean;
-}, {
-    readonly name: "check ZodUnion";
-    readonly compare: (higherType: z.ZodType<any, z.ZodTypeDef, any>, lowerType: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean, recheck: (a: ZodType, b: ZodType) => boolean) => any;
-}, {
-    readonly name: "compare constructor";
-    readonly compare: (higherType: z.ZodType<any, z.ZodTypeDef, any>, lowerType: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean) => boolean;
-}, {
-    readonly name: "check ZodObject";
-    readonly compare: (higherType: z.ZodType<any, z.ZodTypeDef, any>, lowerType: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean, recheck: (a: ZodType, b: ZodType) => boolean) => boolean;
-}, {
-    readonly name: "check ZodArray";
-    readonly compare: (higherType: z.ZodType<any, z.ZodTypeDef, any>, lowerType: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean, recheck: (a: ZodType, b: ZodType) => boolean) => boolean;
-}, {
-    readonly name: "check ZodTuple";
-    readonly compare: (higherType: z.ZodType<any, z.ZodTypeDef, any>, lowerType: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean, recheck: (a: ZodType, b: ZodType) => boolean) => boolean;
-}];
-
-/**
- * isSameType is a function that checks if two ZodTypes are the same.
- *
- * Caveats:
- * - The function does not validate specific criteria such as min or max values, length, email, etc.
- * - It excludes comparisons involving methods like .describe(), .catch(), .default(), .refine(), and .transform().
- *
- * @param a - The first ZodType to compare.
- * @param b - The second ZodType to compare.
- * @returns A boolean indicating whether the two types are the same.
- *
- * @throws Will throw an error if it encounters an unknown type.
- *
- * @example
- * ```ts
- * isSameType(z.string(), z.string()); // true
- * isSameType(z.string(), z.number()); // false
- * ```
- */
-export declare const isSameType: (a: z.ZodType, b: z.ZodType, context?: CompareContext_2) => boolean;
-
-export declare const isSameTypePresetRules: [{
-    readonly name: "undefined check";
-    readonly compare: (a: z.ZodType<any, z.ZodTypeDef, any>, b: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean) => boolean;
-}, {
-    readonly name: "compare reference";
-    readonly compare: (a: z.ZodType<any, z.ZodTypeDef, any>, b: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean) => boolean;
-}, {
-    readonly name: "compare constructor";
-    readonly compare: (a: z.ZodType<any, z.ZodTypeDef, any>, b: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean) => boolean;
-}, {
-    readonly name: "compare typeName";
-    readonly compare: (a: z.ZodType<any, z.ZodTypeDef, any>, b: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean) => boolean;
-}, {
-    readonly name: "compare ZodBranded";
-    readonly compare: (a: z.ZodType<any, z.ZodTypeDef, any>, b: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean) => boolean;
-}, {
-    readonly name: "unwrap ZodType";
-    readonly compare: (a: z.ZodType<any, z.ZodTypeDef, any>, b: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean, recheck: (a: z.ZodType, b: z.ZodType) => boolean) => boolean;
-}, {
-    readonly name: "is same primitive";
-    readonly compare: (a: z.ZodType<any, z.ZodTypeDef, any>, b: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean) => boolean;
-}, {
-    readonly name: "compare ZodObject";
-    readonly compare: (a: z.ZodType<any, z.ZodTypeDef, any>, b: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean, recheck: (a: z.ZodType, b: z.ZodType) => boolean) => boolean;
-}, {
-    readonly name: "compare ZodArray";
-    readonly compare: (a: z.ZodType<any, z.ZodTypeDef, any>, b: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean, recheck: (a: z.ZodType, b: z.ZodType) => boolean) => boolean;
-}, {
-    readonly name: "compare ZodTuple";
-    readonly compare: (a: z.ZodType<any, z.ZodTypeDef, any>, b: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean, recheck: (a: z.ZodType, b: z.ZodType) => boolean) => boolean;
-}, {
-    readonly name: "compare ZodLiteral";
-    readonly compare: (a: z.ZodType<any, z.ZodTypeDef, any>, b: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean) => boolean;
-}, {
-    readonly name: "compare ZodIntersection";
-    readonly compare: (a: z.ZodType<any, z.ZodTypeDef, any>, b: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean, recheck: (a: z.ZodType, b: z.ZodType) => boolean) => boolean;
-}, {
-    readonly name: "compare ZodUnion";
-    readonly compare: (a: z.ZodType<any, z.ZodTypeDef, any>, b: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean, recheck: (a: z.ZodType, b: z.ZodType) => boolean) => boolean;
-}, {
-    readonly name: "compare ZodReadonly";
-    readonly compare: (a: z.ZodType<any, z.ZodTypeDef, any>, b: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean, recheck: (a: z.ZodType, b: z.ZodType) => boolean) => boolean;
-}, {
-    readonly name: "compare ZodRecord";
-    readonly compare: (a: z.ZodType<any, z.ZodTypeDef, any>, b: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean, recheck: (a: z.ZodType, b: z.ZodType) => boolean) => boolean;
-}, {
-    readonly name: "compare ZodMap";
-    readonly compare: (a: z.ZodType<any, z.ZodTypeDef, any>, b: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean, recheck: (a: z.ZodType, b: z.ZodType) => boolean) => boolean;
-}, {
-    readonly name: "compare ZodSet";
-    readonly compare: (a: z.ZodType<any, z.ZodTypeDef, any>, b: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean, recheck: (a: z.ZodType, b: z.ZodType) => boolean) => boolean;
-}, {
-    readonly name: "compare ZodFunction";
-    readonly compare: (a: z.ZodType<any, z.ZodTypeDef, any>, b: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean, recheck: (a: z.ZodType, b: z.ZodType) => boolean) => boolean;
-}, {
-    readonly name: "compare ZodEnum";
-    readonly compare: (a: z.ZodType<any, z.ZodTypeDef, any>, b: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean) => boolean;
-}, {
-    readonly name: "compare ZodNativeEnum";
-    readonly compare: (a: z.ZodType<any, z.ZodTypeDef, any>, b: z.ZodType<any, z.ZodTypeDef, any>, next: () => boolean) => boolean;
-}];
-
-export { }
+import { haveSameZodMajor, isZod3Schema, isZod4Schema } from './utils.ts';
+import { LegacyZodFunction } from './zod4/compat.ts';
+import type * as z3 from "zod/v3";
+import type * as z4 from "zod/v4/core";
+export { haveSameZodMajor, isZod3Schema, isZod4Schema };
+/**
+ * isSameType is a function that checks if two ZodTypes are the same.
+ *
+ * Caveats:
+ * - The function does not validate specific criteria such as min or max values, length, email, etc.
+ * - It excludes comparisons involving methods like .describe(), .catch(), .default(), .refine(), and .transform().
+ *
+ * @param a - The first ZodType to compare.
+ * @param b - The second ZodType to compare.
+ * @returns A boolean indicating whether the two types are the same.
+ *
+ * @throws Will throw an error if it encounters an unknown type.
+ *
+ * @example
+ * ```ts
+ * isSameType(z.string(), z.string()); // true
+ * isSameType(z.string(), z.number()); // false
+ * ```
+ */
+export declare const isSameType: (a: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction, b: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction) => boolean;
+/**
+ * Check if a the higherType matches the lowerType
+ *
+ * @deprecated This a unstable API and still in development
+ *
+ * @param higherType The looser type
+ * @param lowerType The stricter type
+ *
+ * @example
+ * ```ts
+ * isCompatibleType(z.string(), z.string()); // true
+ *
+ * isCompatibleType(
+ *   z.object({ name: z.string(), other: z.number() }),
+ *   z.object({ name: z.string() })
+ * );
+ * // true
+ * ```
+ */
+export declare const isCompatibleType: (a: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction, b: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction) => boolean;

package/dist/index.js

@@ -1,254 +1,23 @@
-import { z as r } from "zod";
-const m = (e) => {
-  const n = (t, o, a = {}) => {
-    let i = -1;
-    const s = (f) => {
-      if (f === e.length)
-        throw new Error("Failed to compare type! " + t + " " + o);
-      if (f === i)
-        throw new Error("next() called multiple times");
-      i = f;
-      const u = e[f], d = u.compare(
-        t,
-        o,
-        () => s(f + 1),
-        (l, Z) => n(l, Z, a),
-        a
-      );
-      return "stacks" in a && Array.isArray(a.stacks) && a.stacks.push({
-        name: u.name,
-        target: [t, o],
-        result: d
-      }), d;
-    };
-    return s(0);
-  };
-  return n;
-}, S = m, p = (e) => e instanceof r.ZodString || e instanceof r.ZodNumber || e instanceof r.ZodNaN || e instanceof r.ZodBigInt || e instanceof r.ZodBoolean || e instanceof r.ZodDate || e instanceof r.ZodSymbol || e instanceof r.ZodUndefined || e instanceof r.ZodNull || e instanceof r.ZodAny || e instanceof r.ZodUnknown || e instanceof r.ZodNever || e instanceof r.ZodVoid, c = (e) => e.options.flatMap((n) => n instanceof r.ZodUnion ? c(n) : n), y = [
-  {
-    name: "undefined check",
-    compare: (e, n, t) => {
-      if (e === void 0 || n === void 0)
-        throw new Error("Failed to compare type! " + e + " " + n);
-      return t();
-    }
-  },
-  {
-    name: "compare reference",
-    compare: (e, n, t) => e === n ? !0 : t()
-  },
-  {
-    name: "compare constructor",
-    compare: (e, n, t) => e.constructor !== n.constructor ? !1 : t()
-  },
-  {
-    name: "compare typeName",
-    compare: (e, n, t) => {
-      if (!("typeName" in e._def) || !("typeName" in n._def))
-        throw new Error("Failed to compare type! " + e._def + " " + n._def);
-      return e._def.typeName !== n._def.typeName ? !1 : t();
-    }
-  },
-  {
-    name: "compare ZodBranded",
-    compare: (e, n, t) => e instanceof r.ZodBranded || n instanceof r.ZodBranded ? !1 : t()
-  },
-  {
-    name: "unwrap ZodType",
-    // ZodPromise ZodOptional ZodNullable ZodBranded
-    compare: (e, n, t, o) => "unwrap" in e && typeof e.unwrap == "function" ? "unwrap" in n && typeof n.unwrap == "function" ? o(e.unwrap(), n.unwrap()) : !1 : t()
-  },
-  {
-    name: "is same primitive",
-    compare: (e, n, t) => p(e) && p(n) && e.constructor === n.constructor ? !0 : t()
-  },
-  {
-    name: "compare ZodObject",
-    compare: (e, n, t, o) => {
-      if (e instanceof r.ZodObject && n instanceof r.ZodObject) {
-        const a = e.shape, i = n.shape;
-        if (Object.keys(a).length !== Object.keys(i).length)
-          return !1;
-        for (const s in a)
-          if (!(s in i) || !o(a[s], i[s])) return !1;
-        return !0;
-      }
-      return t();
-    }
-  },
-  {
-    name: "compare ZodArray",
-    compare: (e, n, t, o) => e instanceof r.ZodArray && n instanceof r.ZodArray ? o(e.element, n.element) : t()
-  },
-  {
-    name: "compare ZodTuple",
-    compare: (e, n, t, o) => {
-      if (e instanceof r.ZodTuple && n instanceof r.ZodTuple) {
-        if (e.items.length !== n.items.length) return !1;
-        for (let a = 0; a < e.items.length; a++)
-          if (!o(e.items[a], n.items[a])) return !1;
-        return e._def.rest || n._def.rest ? !e._def.rest || !n._def.rest ? !1 : o(e._def.rest, n._def.rest) : !0;
-      }
-      return t();
-    }
-  },
-  {
-    name: "compare ZodLiteral",
-    compare: (e, n, t) => e instanceof r.ZodLiteral && n instanceof r.ZodLiteral ? e.value === n.value : t()
-  },
-  {
-    name: "compare ZodIntersection",
-    compare: (e, n, t, o) => e instanceof r.ZodIntersection && n instanceof r.ZodIntersection ? o(e._def.left, n._def.left) && o(e._def.right, n._def.right) || o(e._def.left, n._def.right) && o(e._def.right, n._def.left) : t()
-  },
-  {
-    name: "compare ZodUnion",
-    compare: (e, n, t, o) => {
-      if (e instanceof r.ZodUnion && n instanceof r.ZodUnion) {
-        const a = c(e), i = c(n);
-        if (a.length !== i.length) return !1;
-        for (let s of a) {
-          let f = i.findIndex(
-            (u) => o(s, u)
-          );
-          if (f === -1) return !1;
-          i.splice(f, 1);
-        }
-        return i.length === 0;
-      }
-      return t();
-    }
-  },
-  {
-    name: "compare ZodReadonly",
-    compare: (e, n, t, o) => e instanceof r.ZodReadonly && n instanceof r.ZodReadonly ? o(e._def.innerType, n._def.innerType) : t()
-  },
-  {
-    name: "compare ZodRecord",
-    compare: (e, n, t, o) => e instanceof r.ZodRecord && n instanceof r.ZodRecord ? o(e.keySchema, n.keySchema) && o(e.valueSchema, n.valueSchema) : t()
-  },
-  {
-    name: "compare ZodMap",
-    compare: (e, n, t, o) => e instanceof r.ZodMap && n instanceof r.ZodMap ? o(e.keySchema, n.keySchema) && o(e.valueSchema, n.valueSchema) : t()
-  },
-  {
-    name: "compare ZodSet",
-    compare: (e, n, t, o) => e instanceof r.ZodSet && n instanceof r.ZodSet ? o(e._def.valueType, n._def.valueType) : t()
-  },
-  {
-    name: "compare ZodFunction",
-    compare: (e, n, t, o) => e instanceof r.ZodFunction && n instanceof r.ZodFunction ? o(e.parameters(), n.parameters()) && o(e.returnType(), n.returnType()) : t()
-  },
-  {
-    name: "compare ZodEnum",
-    compare: (e, n, t) => {
-      if (e instanceof r.ZodEnum && n instanceof r.ZodEnum) {
-        const o = e.options, a = n.options;
-        if (o.length !== a.length) return !1;
-        for (let i = 0; i < o.length; i++)
-          if (o[i] !== a[i]) return !1;
-        return !0;
-      }
-      return t();
-    }
-  },
-  {
-    name: "compare ZodNativeEnum",
-    compare: (e, n, t) => {
-      if (e instanceof r.ZodNativeEnum && n instanceof r.ZodNativeEnum) {
-        const o = e.enum, a = n.enum;
-        if (Object.keys(o).length !== Object.keys(a).length)
-          return !1;
-        for (const i in o)
-          if (o[i] !== a[i]) return !1;
-        return !0;
-      }
-      return t();
-    }
-  }
-], _ = m(y), h = [
-  {
-    name: "is same type",
-    compare: (e, n, t) => _(e, n) ? !0 : t()
-  },
-  {
-    name: "check typeName",
-    compare: (e, n, t) => {
-      if (!("typeName" in e._def) || !("typeName" in n._def))
-        throw new Error(
-          "Failed to compare type! " + e._def + " " + n._def
-        );
-      return t();
-    }
-  },
-  {
-    name: "check ZodOptional/ZodNullable",
-    compare: (e, n, t, o) => n instanceof r.ZodOptional || n instanceof r.ZodNullable ? o(e, n.unwrap()) : t()
-  },
-  {
-    name: "check ZodUnion",
-    compare: (e, n, t, o) => {
-      if (e instanceof r.ZodUnion && n instanceof r.ZodUnion) {
-        const a = c(e), i = c(n);
-        for (let s = 0; s < a.length; s++)
-          if (!i.some(
-            (u) => o(a[s], u)
-          )) return !1;
-        return !0;
-      }
-      return e instanceof r.ZodUnion ? c(e).every(
-        (i) => o(i, n)
-      ) : n instanceof r.ZodUnion ? c(n).some(
-        (i) => o(e, i)
-      ) : t();
-    }
-  },
-  {
-    name: "compare constructor",
-    compare: (e, n, t) => e.constructor !== n.constructor ? !1 : t()
-  },
-  {
-    name: "check ZodObject",
-    compare: (e, n, t, o) => {
-      if (e instanceof r.ZodObject && n instanceof r.ZodObject) {
-        const a = e.shape, i = n.shape;
-        if (Object.keys(a).length < Object.keys(i).length)
-          return !1;
-        for (const s in i)
-          if (!(s in a) || !o(a[s], i[s]))
-            return !1;
-        return !0;
-      }
-      return t();
-    }
-  },
-  {
-    name: "check ZodArray",
-    compare: (e, n, t, o) => e instanceof r.ZodArray && n instanceof r.ZodArray ? o(e.element, n.element) : t()
-  },
-  {
-    name: "check ZodTuple",
-    compare: (e, n, t, o) => {
-      if (e instanceof r.ZodTuple && n instanceof r.ZodTuple) {
-        if (e.items.length < n.items.length) return !1;
-        for (let a = 0; a < n.items.length; a++)
-          if (!o(e.items[a], n.items[a]))
-            return !1;
-        return n._def.rest ? e._def.rest ? o(e._def.rest, n._def.rest) : !1 : !0;
-      }
-      return t();
-    }
-  }
-], g = m(h), v = (e, n) => ({
-  name: e,
-  rule: n
-});
+import { i as o, a as s, b as n } from "./is-compatible-type-DEERQsQI.js";
+import { i as a, a as f } from "./is-compatible-type-CA7-IozU.js";
+const t = (e) => !!(o(e) || "_zod" in e), i = (e) => !t(e), m = (e, r) => !!(i(e) && i(r) || t(e) && t(r)), d = (e, r) => {
+  if (t(e) && t(r))
+    return s(e, r);
+  if (i(e) && i(r))
+    return a(e, r);
+  throw new Error("Failed to compare types: different Zod versions");
+}, y = (e, r) => {
+  if (t(e) && t(r))
+    return n(e, r);
+  if (i(e) && i(r))
+    return f(e, r);
+  throw new Error("Failed to compare types: different Zod versions");
+};
 export {
-  m as createCompareFn,
-  S as createIsSameTypeFn,
-  v as defineCompareRule,
-  g as isCompatibleType,
-  h as isCompatibleTypePresetRules,
-  _ as isSameType,
-  y as isSameTypePresetRules
+  m as haveSameZodMajor,
+  y as isCompatibleType,
+  d as isSameType,
+  i as isZod3Schema,
+  t as isZod4Schema
 };
 //# sourceMappingURL=index.js.map