@es-joy/jsoe 0.26.0 → 0.27.0

package/vendor/zod/classic/from-json-schema.js

@@ -123,12 +123,13 @@ function resolveRef(ref, ctx) {
     throw new Error(`Reference not found: ${ref}`);
 }
 /**
- * Rejects every own key that fails `keySchema`, before `objectSchema` runs. The
- * guard has to see the raw input: an object parse drops `__proto__` and can add
- * keys from a property `default`, so its output is not the set of names the
- * instance actually carried.
+ * Enforces the keywords that constrain an object's own keys — `propertyNames`,
+ * `minProperties`, `maxProperties` — before `objectSchema` runs. The guard has
+ * to see the raw input: an object parse drops `__proto__` and can add keys from
+ * a property `default`, so its output is not the set of names the instance
+ * actually carried.
  */
-function checkPropertyNames(objectSchema, keySchema) {
+function checkObjectGuards(objectSchema, guards) {
     // An identity transform, not z.any(), so `toJSONSchema` reports the object on both the input and the output side of the pipe.
     const guard = z
         .transform((value) => value)
@@ -136,22 +137,209 @@ function checkPropertyNames(objectSchema, keySchema) {
         const value = payload.value;
         if (typeof value !== "object" || value === null || Array.isArray(value))
             return;
-        for (const key of Object.getOwnPropertyNames(value)) {
-            const result = keySchema.safeParse(key);
-            if (result.success)
-                continue;
+        const keys = Object.getOwnPropertyNames(value);
+        if (guards.minProperties !== undefined && keys.length < guards.minProperties) {
             payload.issues.push({
-                code: "invalid_key",
-                origin: "record",
-                issues: result.error.issues,
-                input: key,
-                path: [key],
+                origin: "object",
+                code: "too_small",
+                minimum: guards.minProperties,
+                inclusive: true,
+                message: `Too small: expected object to have >=${guards.minProperties} properties`,
+                input: value,
+                inst: objectSchema,
                 continue: true,
             });
         }
+        if (guards.maxProperties !== undefined && keys.length > guards.maxProperties) {
+            payload.issues.push({
+                origin: "object",
+                code: "too_big",
+                maximum: guards.maxProperties,
+                inclusive: true,
+                message: `Too big: expected object to have <=${guards.maxProperties} properties`,
+                input: value,
+                inst: objectSchema,
+                continue: true,
+            });
+        }
+        if (guards.keySchema) {
+            for (const key of keys) {
+                const result = guards.keySchema.safeParse(key);
+                if (result.success)
+                    continue;
+                payload.issues.push({
+                    code: "invalid_key",
+                    origin: "record",
+                    issues: result.error.issues,
+                    input: key,
+                    path: [key],
+                    continue: true,
+                });
+            }
+        }
     });
     return guard.pipe(objectSchema);
 }
+/**
+ * An injective string for JSON data: two values share a key exactly when `uniqueItems` calls them
+ * equal, so duplicate detection is a Map lookup rather than a pairwise walk. Strings and keys are
+ * length-prefixed so no value can spell another one. `null` means "never equal to anything" — a
+ * cycle or a NaN, neither of which JSON can express.
+ */
+function canonicalKey(value, seen) {
+    if (value === null)
+        return "z";
+    const type = typeof value;
+    if (type !== "object") {
+        if (type === "number" && Number.isNaN(value))
+            return null;
+        const raw = String(value);
+        return `${type[0]}${raw.length}:${raw}`;
+    }
+    if (seen.has(value))
+        return null;
+    seen.add(value);
+    try {
+        if (Array.isArray(value)) {
+            const parts = [];
+            for (const item of value) {
+                const key = canonicalKey(item, seen);
+                if (key === null)
+                    return null;
+                parts.push(key);
+            }
+            return `a${parts.length}:[${parts.join(",")}]`;
+        }
+        const keys = Object.keys(value).sort();
+        const parts = [];
+        for (const k of keys) {
+            const key = canonicalKey(value[k], seen);
+            if (key === null)
+                return null;
+            parts.push(`${k.length}:${k}=${key}`);
+        }
+        return `o${parts.length}:{${parts.join(",")}}`;
+    }
+    finally {
+        seen.delete(value);
+    }
+}
+// keywords whose value is a schema or an array of them
+const SCHEMA_KEYWORDS = /*@__PURE__*/ new Set([
+    "items",
+    "prefixItems",
+    "additionalItems",
+    "additionalProperties",
+    "contains",
+    "propertyNames",
+    "not",
+    "if",
+    "then",
+    "else",
+    "allOf",
+    "anyOf",
+    "oneOf",
+    "unevaluatedItems",
+    "unevaluatedProperties",
+    "contentSchema",
+]);
+// keywords whose value maps names to schemas. draft-7 `dependencies` also allows an array of property names, which holds no schema to walk
+const SCHEMA_MAP_KEYWORDS = /*@__PURE__*/ new Set([
+    "properties",
+    "patternProperties",
+    "dependentSchemas",
+    "dependencies",
+    "$defs",
+    "definitions",
+]);
+/**
+ * True when a subschema holds a `$ref` anywhere a schema can appear. Only those positions are
+ * walked: `$ref` under `default` or an `x-` annotation is instance data with an ordinary key, and
+ * reading it as a reference would drop a constraint that resolves perfectly well.
+ */
+function containsRef(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    if (Array.isArray(value))
+        return value.some(containsRef);
+    if (typeof value.$ref === "string")
+        return true;
+    return Object.entries(value).some(([key, sub]) => {
+        if (SCHEMA_KEYWORDS.has(key))
+            return containsRef(sub);
+        if (!SCHEMA_MAP_KEYWORDS.has(key) || typeof sub !== "object" || sub === null)
+            return false;
+        return Object.values(sub).some(containsRef);
+    });
+}
+function plural(n) {
+    return n === 1 ? "element" : "elements";
+}
+/**
+ * Enforces `uniqueItems` and the `contains` family before `arraySchema` runs, for the same reason
+ * `checkObjectGuards` runs pre-pipe: an item parse can apply a nested `default`, so the parsed
+ * array is not the instance the keywords are defined over. A guard issue aborts the pipe, so
+ * `minItems`/`maxItems` are not also reported on the same parse — instance correctness is worth
+ * more than co-reporting two issues.
+ */
+function checkArrayGuards(arraySchema, guards) {
+    // An identity transform, not z.any(), so `toJSONSchema` reports the array on both the input and the output side of the pipe.
+    const guard = z
+        .transform((value) => value)
+        .check((payload) => {
+        const items = payload.value;
+        if (!Array.isArray(items))
+            return;
+        if (guards.uniqueItems === true) {
+            const firstSeen = new Map();
+            for (let i = 0; i < items.length; i++) {
+                const key = canonicalKey(items[i], new Set());
+                if (key === null)
+                    continue;
+                const first = firstSeen.get(key);
+                if (first === undefined) {
+                    firstSeen.set(key, i);
+                    continue;
+                }
+                payload.issues.push({
+                    code: "custom",
+                    message: `Array items must be unique: element at index ${i} duplicates the one at index ${first}`,
+                    input: items,
+                    path: [i],
+                    continue: true,
+                });
+            }
+        }
+        if (guards.containsSchema) {
+            const minContains = guards.minContains ?? 1;
+            // one past the ceiling already proves the failure, and nothing above it changes the verdict
+            const ceiling = guards.maxContains !== undefined ? guards.maxContains + 1 : Number.POSITIVE_INFINITY;
+            let matches = 0;
+            for (const item of items) {
+                if (guards.containsSchema.safeParse(item).success && ++matches >= ceiling)
+                    break;
+            }
+            if (matches < minContains) {
+                // the scan ran to the end, so this count is exact
+                payload.issues.push({
+                    code: "custom",
+                    message: `Array must contain at least ${minContains} matching ${plural(minContains)}; found ${matches}`,
+                    input: items,
+                    continue: true,
+                });
+            }
+            if (guards.maxContains !== undefined && matches > guards.maxContains) {
+                payload.issues.push({
+                    code: "custom",
+                    message: `Array must contain at most ${guards.maxContains} matching ${plural(guards.maxContains)}`,
+                    input: items,
+                    continue: true,
+                });
+            }
+        }
+    });
+    return guard.pipe(arraySchema);
+}
 function getTupleRest(restSchema, ctx) {
     if (restSchema === false) {
         return undefined;
@@ -316,6 +504,9 @@ function convertBaseSchema(schema, ctx) {
                 else if (format === "credit_card") {
                     stringSchema = stringSchema.check(z.creditCard());
                 }
+                else if (format === "iban") {
+                    stringSchema = stringSchema.check(z.iban());
+                }
                 else if (format === "jwt") {
                     stringSchema = stringSchema.check(z.jwt());
                 }
@@ -483,17 +674,23 @@ function convertBaseSchema(schema, ctx) {
                 }
             }
             // propertyNames constrains key *names* only, and says nothing about which keys are required or how their values validate. Layering it on top of the result keeps properties/patternProperties/additionalProperties composing underneath. `true` allows every name, so it needs no guard.
-            if (schema.propertyNames !== undefined && schema.propertyNames !== true) {
-                // Keys are always strings, so a propertyNames subschema that omits `type` still constrains them — without this it would convert to z.any().
-                const keyJSONSchema = typeof schema.propertyNames === "object" && schema.propertyNames.type === undefined
-                    ? { type: "string", ...schema.propertyNames }
-                    : schema.propertyNames;
-                zodSchema = checkPropertyNames(zodSchema, convertSchema(keyJSONSchema, ctx));
+            const hasKeyGuard = schema.propertyNames !== undefined && schema.propertyNames !== true;
+            const minProperties = typeof schema.minProperties === "number" ? schema.minProperties : undefined;
+            const maxProperties = typeof schema.maxProperties === "number" ? schema.maxProperties : undefined;
+            if (hasKeyGuard || minProperties !== undefined || maxProperties !== undefined) {
+                let keySchema;
+                if (hasKeyGuard) {
+                    // Keys are always strings, so a propertyNames subschema that omits `type` still constrains them — without this it would convert to z.any().
+                    const keyJSONSchema = typeof schema.propertyNames === "object" && schema.propertyNames.type === undefined
+                        ? { type: "string", ...schema.propertyNames }
+                        : schema.propertyNames;
+                    keySchema = convertSchema(keyJSONSchema, ctx);
+                }
+                zodSchema = checkObjectGuards(zodSchema, { keySchema, minProperties, maxProperties });
             }
             break;
         }
         case "array": {
-            // TODO: uniqueItems and contains/minContains/maxContains are not supported
             // Check if this is a tuple (prefixItems or items as array)
             const prefixItems = schema.prefixItems;
             const items = schema.items;
@@ -546,6 +743,15 @@ function convertBaseSchema(schema, ctx) {
                 // No items specified - array of any
                 zodSchema = z.array(z.any());
             }
+            // minContains/maxContains only constrain anything when `contains` itself is present
+            if (schema.uniqueItems === true || schema.contains !== undefined) {
+                zodSchema = checkArrayGuards(zodSchema, {
+                    uniqueItems: schema.uniqueItems === true,
+                    containsSchema: schema.contains !== undefined ? convertSchema(schema.contains, ctx) : undefined,
+                    minContains: typeof schema.minContains === "number" ? schema.minContains : undefined,
+                    maxContains: typeof schema.maxContains === "number" ? schema.maxContains : undefined,
+                });
+            }
             break;
         }
         default:
@@ -613,9 +819,24 @@ function convertSchema(schema, ctx) {
             extraMeta[key] = schema[key];
         }
     }
-    // `propertyNames` is enforced by a key guard, which `toJSONSchema` cannot infer, so the original keyword is carried as metadata to keep the round-trip lossless. Only where it was actually applied: on any other type it is inert, and on a `$ref` the metadata would land on the target every reference shares.
-    if (schema.propertyNames !== undefined && schema.type === "object" && schema.$ref === undefined) {
-        extraMeta.propertyNames = schema.propertyNames;
+    // `propertyNames` and `contains` are enforced by a guard, which `toJSONSchema` cannot infer, so the original keyword is carried as metadata to keep the round-trip lossless. Only where it was actually applied: on any other type it is inert, and on a `$ref` the metadata would land on the target every reference shares. A carried subschema is copied verbatim while the root `$defs` stay behind, so one holding a `$ref` is dropped rather than emitted as a dangling reference.
+    if (schema.type === "object" && schema.$ref === undefined) {
+        if (schema.propertyNames !== undefined && !containsRef(schema.propertyNames)) {
+            extraMeta.propertyNames = schema.propertyNames;
+        }
+        for (const key of ["minProperties", "maxProperties"]) {
+            if (schema[key] !== undefined)
+                extraMeta[key] = schema[key];
+        }
+    }
+    if (schema.type === "array" && schema.$ref === undefined) {
+        if (schema.contains !== undefined && !containsRef(schema.contains)) {
+            extraMeta.contains = schema.contains;
+        }
+        for (const key of ["uniqueItems", "minContains", "maxContains"]) {
+            if (schema[key] !== undefined)
+                extraMeta[key] = schema[key];
+        }
     }
     for (const key of Object.keys(schema)) {
         if (!RECOGNIZED_KEYS.has(key)) {

package/vendor/zod/classic/schemas.d.ts

@@ -28,6 +28,8 @@ export interface ZodType<out Output = unknown, out Input = unknown, out Internal
     parseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;
     safeParseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<parse.ZodSafeParseResult<core.output<this>>>;
     spa: (data: unknown, params?: core.ParseContext<core.$ZodIssue>) => Promise<parse.ZodSafeParseResult<core.output<this>>>;
+    validate(data: unknown, params?: core.ParseContext<core.$ZodIssue>): data is core.input<this>;
+    validateAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<boolean>;
     encode(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): core.input<this>;
     decode(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): core.output<this>;
     encodeAsync(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<core.input<this>>;
@@ -310,6 +312,11 @@ export interface ZodCreditCard extends ZodStringFormat<"credit_card"> {
 }
 export declare const ZodCreditCard: core.$constructor<ZodCreditCard>;
 export declare function creditCard(params?: string | core.$ZodCreditCardParams): ZodCreditCard;
+export interface ZodIBAN extends ZodStringFormat<"iban"> {
+    _zod: core.$ZodIBANInternals;
+}
+export declare const ZodIBAN: core.$constructor<ZodIBAN>;
+export declare function iban(params?: string | core.$ZodIBANParams): ZodIBAN;
 export interface ZodJWT extends ZodStringFormat<"jwt"> {
     _zod: core.$ZodJWTInternals;
 }
@@ -772,6 +779,11 @@ export interface ZodCustom<O = unknown, I = unknown> extends _ZodType<core.$ZodC
     "~standard": ZodStandardSchemaWithJSON<this>;
 }
 export declare const ZodCustom: core.$constructor<ZodCustom>;
+export interface ZodProperties<Shape extends core.$ZodShape = core.$ZodShape> extends _ZodType<core.$ZodPropertiesInternals<Shape>>, core.$ZodProperties<Shape> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
+}
+export declare const ZodProperties: core.$constructor<ZodProperties>;
+export declare function properties<Shape extends core.$ZodShape>(shape: Shape, params?: string | core.$ZodPropertiesParams): ZodProperties<Shape>;
 export declare function check<O = unknown>(fn: core.CheckFn<O>): core.$ZodCheck<O>;
 export declare function custom<O>(fn?: (data: unknown) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodCustom<O, O>;
 export declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
@@ -779,7 +791,11 @@ export declare function superRefine<T>(fn: (arg: T, payload: core.$RefinementCtx
 export declare const describe: typeof core.describe;
 export declare const meta: typeof core.meta;
 type ZodInstanceOfParams = core.Params<ZodCustom, core.$ZodIssueCustom, "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path">;
-declare function _instanceof<T extends typeof util.Class>(cls: T, params?: ZodInstanceOfParams): ZodCustom<InstanceType<T>, InstanceType<T>>;
+export interface ZodInstanceOf<T = unknown> extends ZodCustom<T, T> {
+    properties<Shape extends core.$ZodShape>(shape: Shape, params?: string | core.$ZodPropertiesParams): ZodInstanceOf<T & core.$InferObjectInput<Shape, {}>>;
+}
+export declare const ZodInstanceOf: core.$constructor<ZodInstanceOf>;
+declare function _instanceof<T extends typeof util.Class>(cls: T, params?: ZodInstanceOfParams): ZodInstanceOf<InstanceType<T>>;
 export { _instanceof as instanceof };
 export declare const stringbool: (_params?: string | core.$ZodStringBoolParams) => ZodCodec<ZodString, ZodBoolean>;
 type _ZodJSONSchema = ZodUnion<[

package/vendor/zod/classic/schemas.js

@@ -149,6 +149,12 @@ export const ZodType = /*@__PURE__*/ core.$constructor("ZodType", (inst, def) =>
     set spa(value) {
         util.own(this, "spa", value);
     },
+    validate(data, params) {
+        return parse.validate(this, data, params);
+    },
+    validateAsync(data, params) {
+        return parse.validateAsync(this, data, params);
+    },
     encode: function _encode(data, params) {
         return parse.encode(this, data, params, { callee: _encode });
     },
@@ -190,10 +196,11 @@ export const _ZodString = /*@__PURE__*/ core.$constructor("_ZodString", (inst, d
     core.$ZodString.init(inst, def);
     ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json, params) => processors.stringProcessor(inst, ctx, json, params);
-    const bag = inst._zod.bag;
-    inst.format = bag.format ?? null;
-    inst.minLength = bag.minimum ?? null;
-    inst.maxLength = bag.maximum ?? null;
+}, 
+/*@__PURE__*/ util.derived({
+    format: (inst) => processors.aggregateChecks(inst).format ?? null,
+    minLength: (inst) => processors.aggregateChecks(inst).minimum ?? null,
+    maxLength: (inst) => processors.aggregateChecks(inst).maximum ?? null,
 }, {
     regex(...args) {
         return this.check(checks.regex(...args));
@@ -240,7 +247,7 @@ export const _ZodString = /*@__PURE__*/ core.$constructor("_ZodString", (inst, d
     slugify() {
         return this.check(checks.slugify());
     },
-});
+}));
 export const ZodString = /*@__PURE__*/ core.$constructor("ZodString", (inst, def) => {
     core.$ZodString.init(inst, def);
     _ZodString.init(inst, def);
@@ -534,6 +541,13 @@ export const ZodCreditCard = /*@__PURE__*/ core.$constructor("ZodCreditCard", (i
 export function creditCard(params) {
     return core._creditCard(ZodCreditCard, params);
 }
+export const ZodIBAN = /*@__PURE__*/ core.$constructor("ZodIBAN", (inst, def) => {
+    core.$ZodIBAN.init(inst, def);
+    ZodStringFormat.init(inst, def);
+});
+export function iban(params) {
+    return core._iban(ZodIBAN, params);
+}
 export const ZodJWT = /*@__PURE__*/ core.$constructor("ZodJWT", (inst, def) => {
     // ZodStringFormat.init(inst, def);
     core.$ZodJWT.init(inst, def);
@@ -568,14 +582,22 @@ export const ZodNumber = /*@__PURE__*/ core.$constructor("ZodNumber", (inst, def
     core.$ZodNumber.init(inst, def);
     ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json, params) => processors.numberProcessor(inst, ctx, json, params);
-    const bag = inst._zod.bag;
-    inst.minValue =
-        Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
-    inst.maxValue =
-        Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
-    inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
     inst.isFinite = true;
-    inst.format = bag.format ?? null;
+}, 
+/*@__PURE__*/ util.derived({
+    minValue: (inst) => {
+        const { minimum, exclusiveMinimum } = processors.aggregateChecks(inst);
+        return Math.max(minimum ?? Number.NEGATIVE_INFINITY, exclusiveMinimum ?? Number.NEGATIVE_INFINITY);
+    },
+    maxValue: (inst) => {
+        const { maximum, exclusiveMaximum } = processors.aggregateChecks(inst);
+        return Math.min(maximum ?? Number.POSITIVE_INFINITY, exclusiveMaximum ?? Number.POSITIVE_INFINITY);
+    },
+    isInt: (inst) => {
+        const { isInt, multipleOf } = processors.aggregateChecks(inst);
+        return !!isInt || !!multipleOf?.some(Number.isSafeInteger);
+    },
+    format: (inst) => processors.aggregateChecks(inst).format ?? null,
 }, {
     gt(value, params) {
         return this.check(checks.gt(value, params));
@@ -622,7 +644,7 @@ export const ZodNumber = /*@__PURE__*/ core.$constructor("ZodNumber", (inst, def
     finite() {
         return this;
     },
-});
+}));
 export function number(params) {
     return core._number(ZodNumber, params);
 }
@@ -657,10 +679,11 @@ export const ZodBigInt = /*@__PURE__*/ core.$constructor("ZodBigInt", (inst, def
     core.$ZodBigInt.init(inst, def);
     ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json, params) => processors.bigintProcessor(inst, ctx, json, params);
-    const bag = inst._zod.bag;
-    inst.minValue = bag.minimum ?? null;
-    inst.maxValue = bag.maximum ?? null;
-    inst.format = bag.format ?? null;
+}, 
+/*@__PURE__*/ util.derived({
+    minValue: (inst) => processors.aggregateChecks(inst).minimum ?? null,
+    maxValue: (inst) => processors.aggregateChecks(inst).maximum ?? null,
+    format: (inst) => processors.aggregateChecks(inst).format ?? null,
 }, {
     gte(value, params) {
         return this.check(checks.gte(value, params));
@@ -695,7 +718,7 @@ export const ZodBigInt = /*@__PURE__*/ core.$constructor("ZodBigInt", (inst, def
     multipleOf(value, params) {
         return this.check(checks.multipleOf(value, params));
     },
-});
+}));
 export function bigint(params) {
     return core._bigint(ZodBigInt, params);
 }
@@ -774,10 +797,17 @@ export const ZodDate = /*@__PURE__*/ core.$constructor("ZodDate", (inst, def) =>
     inst._zod.processJSONSchema = (ctx, json, params) => processors.dateProcessor(inst, ctx, json, params);
     inst.min = (value, params) => inst.check(checks.gte(value, params));
     inst.max = (value, params) => inst.check(checks.lte(value, params));
-    const c = inst._zod.bag;
-    inst.minDate = c.minimum ? new Date(c.minimum) : null;
-    inst.maxDate = c.maximum ? new Date(c.maximum) : null;
-});
+}, 
+/*@__PURE__*/ util.derived({
+    minDate: (inst) => {
+        const { minimum } = processors.aggregateChecks(inst);
+        return minimum ? new Date(minimum) : null;
+    },
+    maxDate: (inst) => {
+        const { maximum } = processors.aggregateChecks(inst);
+        return maximum ? new Date(maximum) : null;
+    },
+}, {}));
 export function date(params) {
     return core._date(ZodDate, params);
 }
@@ -823,19 +853,20 @@ export const ZodObject = /*@__PURE__*/ core.$constructor("ZodObject", (inst, def
         return _enum(Object.keys(this._zod.def.shape));
     },
     catchall(catchall) {
-        return this.clone({ ...this._zod.def, catchall: catchall });
+        // `mergeDefs` rather than a spread: spreading reads `shape`, and resolving it can mint a whole fresh subtree
+        return this.clone(util.mergeDefs(this._zod.def, { catchall: catchall }));
     },
     passthrough() {
-        return this.clone({ ...this._zod.def, catchall: unknown() });
+        return this.clone(util.mergeDefs(this._zod.def, { catchall: unknown() }));
     },
     loose() {
-        return this.clone({ ...this._zod.def, catchall: unknown() });
+        return this.clone(util.mergeDefs(this._zod.def, { catchall: unknown() }));
     },
     strict() {
-        return this.clone({ ...this._zod.def, catchall: never() });
+        return this.clone(util.mergeDefs(this._zod.def, { catchall: never() }));
     },
     strip() {
-        return this.clone({ ...this._zod.def, catchall: undefined });
+        return this.clone(util.mergeDefs(this._zod.def, { catchall: undefined }));
     },
     extend(incoming) {
         return util.extend(this, incoming);
@@ -1063,7 +1094,8 @@ export const ZodEnum = /*@__PURE__*/ core.$constructor("ZodEnum", (inst, def) =>
     ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json, params) => processors.enumProcessor(inst, ctx, json, params);
     inst.enum = def.entries;
-    inst.options = Object.values(def.entries);
+    // reuse the parsed value set so a numeric TS enum's reverse-mapping keys stay out
+    inst.options = [...inst._zod.values];
     const keys = new Set(Object.keys(def.entries));
     inst.extract = (values, params) => {
         const newEntries = {};
@@ -1423,6 +1455,14 @@ export const ZodCustom = /*@__PURE__*/ core.$constructor("ZodCustom", (inst, def
     ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json, params) => processors.customProcessor(inst, ctx, json, params);
 });
+export const ZodProperties = /*@__PURE__*/ core.$constructor("ZodProperties", (inst, def) => {
+    _ensureDefaultMemoizer();
+    core.$ZodProperties.init(inst, def);
+    ZodType.init(inst, def);
+});
+export function properties(shape, params) {
+    return core._properties(ZodProperties, shape, params);
+}
 // custom checks
 export function check(fn) {
     const ch = new core.$ZodCheck({
@@ -1445,8 +1485,16 @@ export function superRefine(fn, params) {
 // Re-export describe and meta from core
 export const describe = core.describe;
 export const meta = core.meta;
+export const ZodInstanceOf = /*@__PURE__*/ core.$constructor("ZodInstanceOf", (inst, def) => {
+    ZodCustom.init(inst, def);
+}, {
+    properties(shape, params) {
+        // asserts in place, so the narrowed output type is truthful without a wrapper
+        return this.check(properties(shape, params));
+    },
+});
 function _instanceof(cls, params = {}) {
-    const inst = new ZodCustom({
+    const inst = new ZodInstanceOf({
         type: "custom",
         check: "custom",
         fn: (data) => data instanceof cls,

package/vendor/zod/core/api.d.ts

@@ -106,6 +106,9 @@ export declare function _e164<T extends schemas.$ZodE164>(Class: util.SchemaClas
 export type $ZodCreditCardParams = StringFormatParams<schemas.$ZodCreditCard, "pattern" | "when">;
 export type $ZodCheckCreditCardParams = CheckStringFormatParams<schemas.$ZodCreditCard, "pattern" | "when">;
 export declare function _creditCard<T extends schemas.$ZodCreditCard>(Class: util.SchemaClass<T>, params?: string | $ZodCreditCardParams | $ZodCheckCreditCardParams): T;
+export type $ZodIBANParams = StringFormatParams<schemas.$ZodIBAN, "pattern" | "when">;
+export type $ZodCheckIBANParams = CheckStringFormatParams<schemas.$ZodIBAN, "pattern" | "when">;
+export declare function _iban<T extends schemas.$ZodIBAN>(Class: util.SchemaClass<T>, params?: string | $ZodIBANParams | $ZodCheckIBANParams): T;
 export type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
 export type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
 export declare function _jwt<T extends schemas.$ZodJWT>(Class: util.SchemaClass<T>, params?: string | $ZodJWTParams | $ZodCheckJWTParams): T;
@@ -211,11 +214,10 @@ export type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, "suf
 export declare function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithParams): checks.$ZodCheckEndsWith;
 export type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, "property" | "schema" | "when">;
 export declare function _property<K extends string, T extends schemas.$ZodType>(property: K, schema: T, params?: string | $ZodCheckPropertyParams): checks.$ZodCheckProperty<{
-    [k in K]: core.output<T>;
+    [k in K]: util.Widen<core.input<T>>;
 }>;
-export declare function _properties<Shape extends schemas.$ZodShape>(shape: Shape): checks.$ZodCheckProperty<{
-    -readonly [k in keyof Shape]: core.output<Shape[k]>;
-}>[];
+export type $ZodPropertiesParams = CheckTypeParams<schemas.$ZodProperties, "shape" | "when">;
+export declare function _properties<Shape extends schemas.$ZodShape>(Class: util.SchemaClass<schemas.$ZodProperties>, shape: Shape, params?: string | $ZodPropertiesParams): schemas.$ZodProperties<Shape>;
 export type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, "mime" | "when">;
 export declare function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType;
 export declare function _overwrite<T>(tx: (input: T) => T): checks.$ZodCheckOverwrite<T>;

package/vendor/zod/core/api.js

@@ -256,6 +256,16 @@ export function _creditCard(Class, params) {
     });
 }
 // @__NO_SIDE_EFFECTS__
+export function _iban(Class, params) {
+    return new Class({
+        type: "string",
+        format: "iban",
+        check: "string_format",
+        abort: false,
+        ...util.normalizeParams(params),
+    });
+}
+// @__NO_SIDE_EFFECTS__
 export function _jwt(Class, params) {
     return new Class({
         type: "string",
@@ -678,8 +688,13 @@ export function _property(property, schema, params) {
     });
 }
 // @__NO_SIDE_EFFECTS__
-export function _properties(shape) {
-    return Object.entries(shape).map(([property, schema]) => new checks.$ZodCheckProperty({ check: "property", property, schema }));
+export function _properties(Class, shape, params) {
+    return new Class({
+        type: "properties",
+        check: "properties",
+        shape,
+        ...util.normalizeParams(params),
+    });
 }
 // @__NO_SIDE_EFFECTS__
 export function _mime(types, params) {

package/vendor/zod/core/checks.d.ts

@@ -157,7 +157,7 @@ export interface $ZodCheckLengthEquals<T extends util.HasLength = util.HasLength
     _zod: $ZodCheckLengthEqualsInternals<T>;
 }
 export declare const $ZodCheckLengthEquals: core.$constructor<$ZodCheckLengthEquals>;
-export type $ZodStringFormats = "email" | "url" | "emoji" | "uuid" | "guid" | "nanoid" | "cuid" | "cuid2" | "ulid" | "xid" | "ksuid" | "datetime" | "date" | "time" | "duration" | "ipv4" | "ipv6" | "cidrv4" | "cidrv6" | "base64" | "base64url" | "json_string" | "e164" | "credit_card" | "lowercase" | "uppercase" | "regex" | "jwt" | "starts_with" | "ends_with" | "includes";
+export type $ZodStringFormats = "email" | "url" | "emoji" | "uuid" | "guid" | "nanoid" | "cuid" | "cuid2" | "ulid" | "xid" | "ksuid" | "datetime" | "date" | "time" | "duration" | "ipv4" | "ipv6" | "cidrv4" | "cidrv6" | "base64" | "base64url" | "json_string" | "e164" | "credit_card" | "iban" | "lowercase" | "uppercase" | "regex" | "jwt" | "starts_with" | "ends_with" | "includes";
 export interface $ZodCheckStringFormatDef<Format extends string = string> extends $ZodCheckDef {
     check: "string_format";
     format: Format;