@es-joy/jsoe 0.27.0 → 0.28.1

package/vendor/zod/core/compile.js

@@ -2,7 +2,7 @@ import { $ZodAsyncError } from "./core.js";
 import { Doc } from "./doc.js";
 import { isBackEdge, isRecursiveSchema } from "./memoizer.js";
 import * as regexes from "./regexes.js";
-import { isValidBase64, isValidBase64URL, isValidCIDRv6, isValidCreditCard, isValidIBAN, isValidIPv6, isValidJWT, mergeValues, parseURLObject, stripTabAndNewline, urlHostnameOk, urlProtocolOk, } from "./schemas.js";
+import { isValidBase64, isValidBase64URL, isValidCIDRv6, isValidCreditCard, isValidIBAN, isValidIPv6, isValidJWT, mergeValues, stripTabAndNewline, urlHostnameOk, urlProtocolOk, validateURL, } from "./schemas.js";
 import * as util from "./util.js";
 /** @internal Sentinel the compiled fast path returns when validation fails. */
 export const INVALID = Symbol.for("zod.compile.invalid");
@@ -330,7 +330,7 @@ function generateChecks(doc, ctx, schema, accessor) {
                 generatePropertyCheck(doc, ctx, def, currentAccessor);
                 break;
             case "properties":
-                generatePropertiesChecks(doc, ctx, def, currentAccessor, false);
+                generatePropertiesChecks(doc, ctx, def, currentAccessor);
                 break;
             case "overwrite": {
                 // Overwrite transforms the value - create new variable for transformed result
@@ -458,15 +458,13 @@ function generateMimeTypeCheck(doc, ctx, def, accessor) {
     }
 }
 // asserts each named property in place; children compile assert-only because z.properties never rebuilds its input
-function generatePropertiesChecks(doc, ctx, def, accessor, schemaRole) {
-    // a custom `when` gates the assertion at runtime; inside a union a wrongly-run branch is absorbed as a branch failure rather than falling back, so refuse at codegen the way the check role does
+function generatePropertiesChecks(doc, ctx, def, accessor) {
+    // a custom `when` gates the assertion at runtime; inside a union a wrongly-run branch is absorbed as a branch failure rather than falling back, so refuse at codegen
     if (def.when) {
         throw new ZodCompileUnsupportedError(`check with a custom "when" condition`);
     }
-    // matches the runtime gate for whichever role this is: a schema rejects a primitive outright, a check only a nullish value
-    doc.write(schemaRole
-        ? `if (${accessor} === null || (typeof ${accessor} !== "object" && typeof ${accessor} !== "function")) return INVALID;`
-        : `if (${accessor} == null) return INVALID;`);
+    // matches the runtime gate: the base schema already typed the value, so only a nullish one is rejected
+    doc.write(`if (${accessor} == null) return INVALID;`);
     const shape = def.shape;
     for (const key of Reflect.ownKeys(shape)) {
         // a symbol has no source literal, so it is hoisted as a constant
@@ -579,8 +577,7 @@ const PATTERN_IS_COMPLETE = new Set([
     "uuid",
     "xid",
 ]);
-// Returns the accessor holding the (possibly normalized) value after the check — url/normalize formats produce a new value like overwrite does. Never assigns to the incoming accessor: it may be a `const` or a property expression on user input.
-function generateStringFormatCheck(doc, ctx, def, accessor) {
+function generateStringFormatCheck(doc, ctx, def, accessor, needsValue = true) {
     // Some string formats do runtime validation beyond their advertised pattern. For cheap pure utility checks, hoist the runtime function and call it so the fast path stays correct without cloning the utility logic into codegen.
     const fmt = def.format;
     if (fmt === "base64") {
@@ -626,7 +623,7 @@ function generateStringFormatCheck(doc, ctx, def, accessor) {
         formatDef.hostname !== undefined ||
         formatDef.protocol !== undefined) {
         // Same three predicates the runtime calls, in the same order, so there is no second URL implementation to drift. Which options exist is known now, so the calls the runtime makes conditionally are emitted conditionally instead.
-        const parseConst = addConstant(ctx, parseURLObject);
+        const parseConst = addConstant(ctx, validateURL);
         const defConst = addConstant(ctx, def);
         const trimVar = newVar(ctx);
         const urlVar = newVar(ctx);
@@ -641,6 +638,8 @@ function generateStringFormatCheck(doc, ctx, def, accessor) {
             const protocolConst = addConstant(ctx, urlProtocolOk);
             doc.write(`if (!${protocolConst}(${urlVar}, ${defConst}.protocol)) return INVALID;`);
         }
+        if (!needsValue)
+            return null;
         const outputVar = newVar(ctx);
         const outputExpr = formatDef.normalize ? `${urlVar}.href` : `${addConstant(ctx, stripTabAndNewline)}(${trimVar})`;
         doc.write(`const ${outputVar} = ${outputExpr};`);
@@ -705,7 +704,7 @@ function generateCheck(doc, ctx, schema, accessor, needsValue = true) {
     let typeAccessor;
     switch (type) {
         case "string":
-            typeAccessor = generateStringCheck(doc, ctx, schema, accessor);
+            typeAccessor = generateStringCheck(doc, ctx, schema, accessor, buildsValue);
             break;
         case "number":
             typeAccessor = generateNumberCheck(doc, schema, accessor);
@@ -817,10 +816,6 @@ function generateCheck(doc, ctx, schema, accessor, needsValue = true) {
         case "custom":
             typeAccessor = generateCustomCheck(doc, ctx, schema, accessor);
             break;
-        case "properties":
-            generatePropertiesChecks(doc, ctx, schema._zod.def, accessor, true);
-            typeAccessor = accessor;
-            break;
         case "transform":
             typeAccessor = generateTransformCheck(doc, ctx, schema, accessor);
             break;
@@ -838,13 +833,13 @@ function generateCheck(doc, ctx, schema, accessor, needsValue = true) {
     // Generate checks after the type-specific validation (may transform value)
     return generateChecks(doc, ctx, schema, typeAccessor);
 }
-function generateStringCheck(doc, ctx, schema, accessor) {
+function generateStringCheck(doc, ctx, schema, accessor, needsValue = true) {
     doc.write(`if (typeof ${accessor} !== "string") return INVALID;`);
     // z.email() carries its format on the def, z.string().email() in def.checks; both route here so the format table has no second copy to drift from.
     const def = schema._zod.def;
     if (def.format === undefined)
         return accessor;
-    return generateStringFormatCheck(doc, ctx, def, accessor);
+    return generateStringFormatCheck(doc, ctx, def, accessor, needsValue);
 }
 function generateNumberCheck(doc, schema, accessor) {
     // Runtime z.number() rejects NaN and ±Infinity. Number.isFinite covers both.
@@ -979,9 +974,9 @@ function generateObjectCheck(doc, ctx, schema, accessor, buildsValue = true) {
         }
     }
     // else: strip mode (no catchall) - unknown keys ignored, only include known keys
-    // Shape keys in declared order, then unknown keys in for...in order. A middle-rung key is included iff present on the input, else iff its output is not undefined.
+    // defaulted required outputs keep their keys even when undefined
     const outputVar = newVar(ctx);
-    const hasConditionalKeys = allKeys.some((k) => mayOutputUndefined(propShape[k]) || dropsWhenAbsent(propShape[k]));
+    const hasConditionalKeys = allKeys.some((k) => mayOmitUndefined(propShape[k]) || dropsWhenAbsent(propShape[k]));
     // Assert mode: every declared key is validated above, so the output literal and the unknown-key copy are pure waste. A `never` catchall already emitted its rejection loop; a schema catchall still has to validate the values it would otherwise have stored.
     if (!buildsValue) {
         if (unknownKeysMode === "schema") {
@@ -1011,7 +1006,7 @@ function generateObjectCheck(doc, ctx, schema, accessor, buildsValue = true) {
             if (dropsWhenAbsent(propShape[k])) {
                 doc.write(`if (${kx} in ${accessor}) ${outputVar}[${kx}] = ${out};`);
             }
-            else if (mayOutputUndefined(propShape[k])) {
+            else if (mayOmitUndefined(propShape[k])) {
                 doc.write(`if (${out} !== undefined || ${kx} in ${accessor}) ${outputVar}[${kx}] = ${out};`);
             }
             else {
@@ -1154,9 +1149,10 @@ function fastPathAcceptsAbsence(schema) {
 function dropsWhenAbsent(schema) {
     return schema._zod.optin === "optional" && schema._zod.optout === "optional";
 }
-// Whether a schema's success-path output can be `undefined`. Object output
-// assembly gives such props the runtime's value-or-presence inclusion rule;
-// everything else keeps the unconditional object-literal slot.
+function mayOmitUndefined(schema) {
+    return (schema._zod.optin !== "defaulted" || schema._zod.optout === "optional") && mayOutputUndefined(schema);
+}
+// whether a schema's success-path output can be undefined
 function mayOutputUndefined(schema) {
     const def = schema._zod.def;
     switch (def.type) {

package/vendor/zod/core/core.js

@@ -58,7 +58,7 @@ proto, params) {
                 _zodDesc.value = undefined;
             }
         }
-        if (inst._zod.traits.has(name)) {
+        else if (inst._zod.traits.has(name)) {
             return;
         }
         inst._zod.traits.add(name);

package/vendor/zod/core/json-schema-processors.d.ts

@@ -41,7 +41,6 @@ export declare const mapProcessor: Processor<schemas.$ZodMap>;
 export declare const setProcessor: Processor<schemas.$ZodSet>;
 export declare const arrayProcessor: Processor<schemas.$ZodArray>;
 export declare const objectProcessor: Processor<schemas.$ZodObject>;
-export declare const propertiesProcessor: Processor<schemas.$ZodProperties>;
 export declare const unionProcessor: Processor<schemas.$ZodUnion>;
 export declare const intersectionProcessor: Processor<schemas.$ZodIntersection>;
 export declare const tupleProcessor: Processor<schemas.$ZodTuple>;

package/vendor/zod/core/json-schema-processors.js

@@ -1,6 +1,6 @@
 import * as regexes from "./regexes.js";
 import { base64Charset, base64urlCharset } from "./schemas.js";
-import { extractDefs, finalize, handleUnrepresentable, initializeContext, isTransforming, processSchema, } from "./to-json-schema.js";
+import { extractDefs, finalize, handleUnrepresentable, initializeContext, processSchema, } from "./to-json-schema.js";
 import { BIGINT_FORMAT_RANGES, NUMBER_FORMAT_RANGES, assignProp, getEnumValues } from "./util.js";
 const narrowMin = (agg, key, value) => {
     if (agg[key] === undefined || value > agg[key])
@@ -395,18 +395,15 @@ export const objectProcessor = (schema, ctx, _json, params) => {
         }));
     }
     // required keys
-    const allKeys = new Set(Object.keys(shape));
-    const requiredKeys = new Set([...allKeys].filter((key) => {
+    const requiredKeys = [];
+    for (const key of Object.keys(shape)) {
         const field = def.shape[key];
-        if (ctx.io === "input") {
-            return inputOptin(field) === undefined;
+        if (ctx.io === "input" ? inputOptin(field) === undefined : field._zod.optout === undefined) {
+            requiredKeys.push(key);
         }
-        else {
-            return field._zod.optout === undefined;
-        }
-    }));
-    if (requiredKeys.size > 0) {
-        json.required = Array.from(requiredKeys);
+    }
+    if (requiredKeys.length > 0) {
+        json.required = requiredKeys;
     }
     // catchall
     if (def.catchall?._zod.def.type === "never") {
@@ -425,37 +422,6 @@ export const objectProcessor = (schema, ctx, _json, params) => {
         });
     }
 };
-// asserts named properties in place and passes everything else through, so no additionalProperties constraint is emitted
-export const propertiesProcessor = (schema, ctx, _json, params) => {
-    const json = _json;
-    const def = schema._zod.def;
-    // dropping a symbol key silently would emit a schema that asserts less than this one does
-    if (Object.getOwnPropertySymbols(def.shape).length &&
-        handleUnrepresentable(schema, ctx, json, params, "Symbol keys cannot be represented in JSON Schema")) {
-        return;
-    }
-    // the parsed value is the input, so an output-mode emission would describe a transformed value this schema never returns
-    if (ctx.io === "output") {
-        for (const key in def.shape) {
-            if (isTransforming(def.shape[key]) &&
-                handleUnrepresentable(schema, ctx, json, params, `z.properties() returns its input, so the output of a transforming schema at key "${key}" cannot be represented in JSON Schema`)) {
-                return;
-            }
-        }
-    }
-    json.type = "object";
-    json.properties = {};
-    for (const key in def.shape) {
-        assignProp(json.properties, key, processSchema(def.shape[key], ctx, {
-            ...params,
-            path: [...params.path, "properties", key],
-        }));
-    }
-    // input-side optionality in both modes: the parsed value is the input, so a defaulted key that stays absent must not be required of the output either
-    const required = Object.keys(def.shape).filter((key) => inputOptin(def.shape[key]) === undefined);
-    if (required.length > 0)
-        json.required = required;
-};
 export const unionProcessor = (schema, ctx, json, params) => {
     const def = schema._zod.def;
     // Exclusive unions (inclusive === false) use oneOf (exactly one match) instead of anyOf (one or more matches). This includes both z.xor() and discriminated unions
@@ -815,7 +781,6 @@ export const allProcessors = {
     file: fileProcessor,
     success: successProcessor,
     custom: customProcessor,
-    properties: propertiesProcessor,
     function: functionProcessor,
     transform: transformProcessor,
     map: mapProcessor,

package/vendor/zod/core/memoizer.js

@@ -8,9 +8,9 @@ export class $ZodCyclicError extends Error {
 /** Keyed off the context object every schema in one parse call already shares. */
 const STATE = "~memo";
 const NO_ISSUES = [];
-// a value a cycle can close through; callables count, since z.properties asserts on one
+// a value a cycle can close through
 function isRef(value) {
-    return value !== null && (typeof value === "object" || typeof value === "function");
+    return value !== null && typeof value === "object";
 }
 // Receivers prefix paths in place, so the cache and every hand-out need their own copies.
 function cloneIssues(issues) {
@@ -67,9 +67,6 @@ function isRecursive(inst, stack, resolve) {
             check(def.catchall);
             break;
         }
-        case "properties":
-            merge(shape(def.shape, false));
-            break;
         case "array":
             check(def.element);
             break;

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

@@ -46,6 +46,7 @@ export declare const domain: RegExp;
 export declare const httpProtocol: RegExp;
 export declare const e164: RegExp;
 export declare const creditCard: RegExp;
+export declare const currencyCode: RegExp;
 export declare const iban: RegExp;
 export declare const date: RegExp;
 export declare function time(args: {

package/vendor/zod/core/regexes.js

@@ -66,6 +66,8 @@ export const httpProtocol = /^https?$/;
 export const e164 = /^\+[1-9]\d{6,14}$/;
 // Credit card shape: 12–19 digits, optionally separated by single spaces or single hyphens. ISO/IEC 7812 caps the PAN at 19 digits; 12 is the shortest issued length (Maestro).
 export const creditCard = /^\d(?:[ -]?\d){11,18}$/;
+// ISO 4217 alpha codes from the SIX list, regenerated by scripts/update-iso-4217.ts
+export const currencyCode = /^(?:AED|AFN|ALL|AMD|AOA|ARS|AUD|AWG|AZN|BAM|BBD|BDT|BHD|BIF|BMD|BND|BOB|BOV|BRL|BSD|BTN|BWP|BYN|BZD|CAD|CDF|CHE|CHF|CHW|CLF|CLP|CNY|COP|COU|CRC|CUP|CVE|CZK|DJF|DKK|DOP|DZD|EGP|ERN|ETB|EUR|FJD|FKP|GBP|GEL|GHS|GIP|GMD|GNF|GTQ|GYD|HKD|HNL|HTG|HUF|IDR|ILS|INR|IQD|IRR|ISK|JMD|JOD|JPY|KES|KGS|KHR|KMF|KPW|KRW|KWD|KYD|KZT|LAK|LBP|LKR|LRD|LSL|LYD|MAD|MDL|MGA|MKD|MMK|MNT|MOP|MRU|MUR|MVR|MWK|MXN|MXV|MYR|MZN|NAD|NGN|NIO|NOK|NPR|NZD|OMR|PAB|PEN|PGK|PHP|PKR|PLN|PYG|QAR|RON|RSD|RUB|RWF|SAR|SBD|SCR|SDG|SEK|SGD|SHP|SLE|SOS|SRD|SSP|STN|SVC|SYP|SZL|THB|TJS|TMT|TND|TOP|TRY|TTD|TWD|TZS|UAH|UGX|USD|USN|UYI|UYU|UYW|UZS|VED|VES|VND|VUV|WST|XAD|XAF|XAG|XAU|XBA|XBB|XBC|XBD|XCD|XCG|XDR|XOF|XPD|XPF|XPT|XSU|XTS|XUA|XXX|YER|ZAR|ZMW|ZWG)$/;
 // iban electronic format: 2-letter country, check digits 02-98 (the only values `98 - remainder` can produce), 11-30 bban characters
 export const iban = /^[A-Z]{2}(?!00|01|99)\d{2}[A-Z0-9]{11,30}$/;
 const dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;

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

@@ -41,7 +41,7 @@ export interface ParsePayload<T = unknown> {
 }
 export type CheckFn<T> = (input: ParsePayload<T>) => util.MaybeAsync<void>;
 export interface $ZodTypeDef {
-    type: "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "null" | "undefined" | "void" | "never" | "any" | "unknown" | "date" | "object" | "record" | "file" | "array" | "tuple" | "union" | "intersection" | "map" | "set" | "enum" | "literal" | "nullable" | "optional" | "nonoptional" | "success" | "transform" | "default" | "prefault" | "catch" | "nan" | "pipe" | "readonly" | "template_literal" | "promise" | "lazy" | "function" | "custom" | "properties";
+    type: "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "null" | "undefined" | "void" | "never" | "any" | "unknown" | "date" | "object" | "record" | "file" | "array" | "tuple" | "union" | "intersection" | "map" | "set" | "enum" | "literal" | "nullable" | "optional" | "nonoptional" | "success" | "transform" | "default" | "prefault" | "catch" | "nan" | "pipe" | "readonly" | "template_literal" | "promise" | "lazy" | "function" | "custom";
     error?: errors.$ZodErrorMap<never> | undefined;
     checks?: checks.$ZodCheck<never>[];
 }
@@ -188,9 +188,11 @@ export interface $ZodURL extends $ZodType {
 }
 /** The `://` guard rejected the input before the URL constructor saw it. */
 export declare const URL_BAD_FORMAT = 1;
-/** The URL constructor rejected the input. */
+/** The URL parser rejected the input. */
 export declare const URL_UNPARSEABLE = 2;
-/** Parses a URL for `$ZodURL`, applying the one guard the URL constructor cannot express. Returns the parsed URL, or a code naming the stage that rejected it — the runtime needs that distinction to pick an issue note, and compiled code only needs to know it is not a URL. */
+export declare function canParseURL(input: string): boolean;
+export declare function validateURL(trimmed: string, def: Pick<$ZodURLDef, "protocol" | "hostname" | "normalize">): URL | true | typeof URL_BAD_FORMAT | typeof URL_UNPARSEABLE;
+/** Parses a URL while preserving the non-normalizing HTTP guard. */
 export declare function parseURLObject(trimmed: string, def: Pick<$ZodURLDef, "protocol" | "normalize">): URL | typeof URL_BAD_FORMAT | typeof URL_UNPARSEABLE;
 /** The URL parser deletes every ASCII tab, LF and CR from its input before it parses, so `new URL("https://exa\nmple.com")` reports on `example.com`. Applying the same deletion to the returned value closes the half of that divergence which can move the host; the parser's other rewrite, stripping C0 controls at the edges, cannot. */
 export declare function stripTabAndNewline(value: string): string;
@@ -1010,7 +1012,7 @@ export interface $ZodPrefaultDef<T extends SomeType = $ZodType> extends $ZodType
     /** The default value. May be a getter. */
     defaultValue: core.input<T>;
 }
-export interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, core.input<T> | undefined> {
+export interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T>, core.input<T> | undefined> {
     def: $ZodPrefaultDef<T>;
     optin: "defaulted";
     optout?: "optional" | undefined;
@@ -1267,22 +1269,5 @@ export interface $ZodCustom<O = unknown, I = unknown> extends $ZodType {
     _zod: $ZodCustomInternals<O, I>;
 }
 export declare const $ZodCustom: core.$constructor<$ZodCustom>;
-export interface $ZodPropertiesDef<Shape extends $ZodShape = $ZodShape> extends $ZodTypeDef, checks.$ZodCheckDef {
-    type: "properties";
-    check: "properties";
-    shape: Shape;
-}
-export interface $ZodPropertiesInternals<Shape extends $ZodShape = $ZodShape> extends $ZodTypeInternals<$InferObjectInput<Shape, {}>, $InferObjectInput<Shape, {}>>, checks.$ZodCheckInternals<{
-    -readonly [k in keyof Shape]: util.Widen<core.input<Shape[k]>>;
-}> {
-    def: $ZodPropertiesDef<Shape>;
-    isst: errors.$ZodIssueInvalidType;
-    issc: errors.$ZodIssue;
-}
-export interface $ZodProperties<Shape extends $ZodShape = $ZodShape> extends $ZodType {
-    _zod: $ZodPropertiesInternals<Shape>;
-    [Symbol.iterator](): Iterator<this>;
-}
-export declare const $ZodProperties: core.$constructor<$ZodProperties>;
-export type $ZodTypes = $ZodString | $ZodNumber | $ZodBigInt | $ZodBoolean | $ZodDate | $ZodSymbol | $ZodUndefined | $ZodNullable | $ZodNull | $ZodAny | $ZodUnknown | $ZodNever | $ZodVoid | $ZodArray | $ZodObject | $ZodUnion | $ZodIntersection | $ZodTuple | $ZodRecord | $ZodMap | $ZodSet | $ZodLiteral | $ZodEnum | $ZodFunction | $ZodPromise | $ZodLazy | $ZodOptional | $ZodDefault | $ZodPrefault | $ZodTemplateLiteral | $ZodCustom | $ZodProperties | $ZodTransform | $ZodNonOptional | $ZodReadonly | $ZodNaN | $ZodPipe | $ZodSuccess | $ZodCatch | $ZodFile;
-export type $ZodStringFormatTypes = $ZodGUID | $ZodUUID | $ZodEmail | $ZodURL | $ZodEmoji | $ZodNanoID | $ZodCUID | $ZodCUID2 | $ZodULID | $ZodXID | $ZodKSUID | $ZodISODateTime | $ZodISODate | $ZodISOTime | $ZodISODuration | $ZodIPv4 | $ZodIPv6 | $ZodMAC | $ZodCIDRv4 | $ZodCIDRv6 | $ZodBase64 | $ZodBase64URL | $ZodE164 | $ZodCreditCard | $ZodIBAN | $ZodJWT | $ZodCustomStringFormat<"hex"> | $ZodCustomStringFormat<util.HashFormat> | $ZodCustomStringFormat<"hostname">;
+export type $ZodTypes = $ZodString | $ZodNumber | $ZodBigInt | $ZodBoolean | $ZodDate | $ZodSymbol | $ZodUndefined | $ZodNullable | $ZodNull | $ZodAny | $ZodUnknown | $ZodNever | $ZodVoid | $ZodArray | $ZodObject | $ZodUnion | $ZodIntersection | $ZodTuple | $ZodRecord | $ZodMap | $ZodSet | $ZodLiteral | $ZodEnum | $ZodFunction | $ZodPromise | $ZodLazy | $ZodOptional | $ZodDefault | $ZodPrefault | $ZodTemplateLiteral | $ZodCustom | $ZodTransform | $ZodNonOptional | $ZodReadonly | $ZodNaN | $ZodPipe | $ZodSuccess | $ZodCatch | $ZodFile;
+export type $ZodStringFormatTypes = $ZodGUID | $ZodUUID | $ZodEmail | $ZodURL | $ZodEmoji | $ZodNanoID | $ZodCUID | $ZodCUID2 | $ZodULID | $ZodXID | $ZodKSUID | $ZodISODateTime | $ZodISODate | $ZodISOTime | $ZodISODuration | $ZodIPv4 | $ZodIPv6 | $ZodMAC | $ZodCIDRv4 | $ZodCIDRv6 | $ZodBase64 | $ZodBase64URL | $ZodE164 | $ZodCreditCard | $ZodIBAN | $ZodJWT | $ZodCustomStringFormat<"hex"> | $ZodCustomStringFormat<util.HashFormat> | $ZodCustomStringFormat<"hostname"> | $ZodCustomStringFormat<"currency_code">;

package/vendor/zod/core/schemas.js

@@ -209,15 +209,37 @@ export const $ZodEmail = /*@__PURE__*/ core.$constructor("$ZodEmail", (inst, def
 });
 /** The `://` guard rejected the input before the URL constructor saw it. */
 export const URL_BAD_FORMAT = 1;
-/** The URL constructor rejected the input. */
+/** The URL parser rejected the input. */
 export const URL_UNPARSEABLE = 2;
-/** Parses a URL for `$ZodURL`, applying the one guard the URL constructor cannot express. Returns the parsed URL, or a code naming the stage that rejected it — the runtime needs that distinction to pick an issue note, and compiled code only needs to know it is not a URL. */
+export function canParseURL(input) {
+    try {
+        if (typeof URL !== "undefined" && typeof URL.canParse === "function")
+            return URL.canParse(input);
+        new URL(input);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function validateURL(trimmed, def) {
+    if (!("normalize" in def) && !("hostname" in def) && !("protocol" in def)) {
+        return canParseURL(trimmed) || URL_UNPARSEABLE;
+    }
+    return parseURLObject(trimmed, def);
+}
+/** Parses a URL while preserving the non-normalizing HTTP guard. */
 export function parseURLObject(trimmed, def) {
     // When normalize is off, require :// for http/https URLs. This prevents strings like "http:example.com" or "https:/path" from being silently accepted
     if (!def.normalize && def.protocol?.source === regexes.httpProtocol.source && !/^https?:\/\//i.test(trimmed)) {
         return URL_BAD_FORMAT;
     }
     try {
+        if (typeof URL !== "undefined") {
+            const URLStatic = URL;
+            if (typeof URLStatic.parse === "function")
+                return URLStatic.parse(trimmed) ?? URL_UNPARSEABLE;
+        }
         // @ts-ignore
         return new URL(trimmed);
     }
@@ -244,7 +266,7 @@ export const $ZodURL = /*@__PURE__*/ core.$constructor("$ZodURL", (inst, def) =>
         try {
             // Trim whitespace from input
             const trimmed = payload.value.trim();
-            const url = parseURLObject(trimmed, def);
+            const url = validateURL(trimmed, def);
             if (url === URL_BAD_FORMAT) {
                 payload.issues.push({
                     code: "invalid_format",
@@ -266,6 +288,10 @@ export const $ZodURL = /*@__PURE__*/ core.$constructor("$ZodURL", (inst, def) =>
                 });
                 return;
             }
+            if (url === true) {
+                payload.value = stripTabAndNewline(trimmed);
+                return;
+            }
             if (def.hostname && !urlHostnameOk(url, def.hostname)) {
                 payload.issues.push({
                     code: "invalid_format",
@@ -363,14 +389,7 @@ const ipv6Alphabet = /^[0-9a-fA-F:.]+$/;
 export function isValidIPv6(value) {
     if (!ipv6Alphabet.test(value))
         return false;
-    try {
-        // @ts-ignore
-        new URL(`http://[${value}]`);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return canParseURL(`http://[${value}]`);
 }
 export const $ZodIPv6 = /*@__PURE__*/ core.$constructor("$ZodIPv6", (inst, def) => {
     def.pattern ?? (def.pattern = regexes.ipv6);
@@ -869,7 +888,7 @@ function handlePropertyResult(result, final, key, input, optin, optout) {
         return;
     }
     if (result.value === undefined) {
-        if (isPresent) {
+        if (isPresent || (optin === "defaulted" && !isOptionalOut)) {
             final.value[key] = undefined;
         }
     }
@@ -1124,16 +1143,17 @@ export const $ZodObjectJIT = /*@__PURE__*/ core.$constructor("$ZodObjectJIT", (i
                 doc.write(`
         if (${id}.issues.length) {${prefixStr(id, k)}
         }
-        
-        if (${id}.value === undefined) {
-          if (${isPresent}) {
-            newResult[${k}] = undefined;
-          }
-        } else {
+      `);
+                if (optin === "defaulted") {
+                    doc.write(`newResult[${k}] = ${id}.value;`);
+                }
+                else {
+                    doc.write(`
+        if (${id}.value !== undefined || ${isPresent}) {
           newResult[${k}] = ${id}.value;
         }
-
       `);
+                }
             }
         }
         doc.write(`payload.value = newResult;`);
@@ -2584,64 +2604,3 @@ function handleRefineResult(result, payload, input, inst) {
         payload.issues.push(util.issue(_iss));
     }
 }
-// asserts in place: the child result's value is discarded, matching z.property(), because a nested object or array schema rebuilds its output even when nothing transformed
-function handlePropertiesResult(result, payload, key) {
-    if (result.issues.length) {
-        payload.issues.push(...util.prefixIssues(key, result.issues));
-    }
-}
-export const $ZodProperties = /*@__PURE__*/ core.$constructor("$ZodProperties", (inst, def) => {
-    // $ZodType.init prepends an instance that already carries the $ZodCheck trait to its own `checks`, which would run the shape a second time and cost the parse context. Initializing the check trait after it keeps the schema role in `parse`, where the context arrives.
-    $ZodType.init(inst, def);
-    checks.$ZodCheck.init(inst, def);
-    const memo = core.globalConfig.memoizer;
-    memo?.attach(inst);
-    // key and schema snapshotted together: reading one live and the other cached lets a later mutation of the caller's shape object pair a stale key with a missing schema
-    let entries;
-    const runShape = (payload, ctx) => {
-        entries ?? (entries = Reflect.ownKeys(def.shape).map((key) => [key, def.shape[key]]));
-        const input = payload.value;
-        let proms;
-        for (const [key, schema] of entries) {
-            const result = schema._zod.run({ value: input[key], issues: [] }, ctx);
-            if (result instanceof Promise) {
-                proms ?? (proms = []);
-                proms.push(result.then((result) => handlePropertiesResult(result, payload, key)));
-            }
-            else {
-                handlePropertiesResult(result, payload, key);
-            }
-        }
-        if (proms)
-            return Promise.all(proms).then(() => undefined);
-        return undefined;
-    };
-    inst._zod.parse = (payload, ctx) => {
-        const input = payload.value;
-        // as a schema this is the type gate, and it infers an object shape, so a primitive is a type error. A function passes: its properties read like any other object's, and z.instanceof allows one.
-        if (input === null || (typeof input !== "object" && typeof input !== "function")) {
-            payload.issues.push({ expected: "object", code: "invalid_type", input, inst });
-            return payload;
-        }
-        // both sides declare the shape's input type, so the assertion runs forward in either direction; encoding the children backward would reject the very type this schema claims to take
-        if (ctx.direction === "backward")
-            ctx = { ...ctx, direction: "forward" };
-        // the input is its own output here, so it registers as its own memo entry: a cycle re-entering this node hits the bucket instead of recursing forever
-        if (memo)
-            memo.alloc(inst, payload, input, ctx);
-        const result = runShape(payload, ctx);
-        return result instanceof Promise ? result.then(() => payload) : payload;
-    };
-    // as a check the base schema already typed the value, so this only asserts the properties — which read on a primitive too, matching z.property() on a string's length. It gets no context of its own, so a cycle through a spread schema is not tracked.
-    inst._zod.check = (payload) => {
-        if (payload.value == null) {
-            payload.issues.push({ expected: "object", code: "invalid_type", input: payload.value, inst });
-            return undefined;
-        }
-        return runShape(payload, {});
-    };
-}, {
-    *[Symbol.iterator]() {
-        yield this;
-    },
-});

package/vendor/zod/core/to-json-schema.d.ts

@@ -137,9 +137,6 @@ export declare function processSchema<T extends schemas.$ZodType>(schema: T, ctx
 export { processSchema as process };
 export declare function extractDefs<T extends schemas.$ZodType>(ctx: ToJSONSchemaContext, schema: T): void;
 export declare function finalize<T extends schemas.$ZodType>(ctx: ToJSONSchemaContext, schema: T): ZodStandardJSONSchemaPayload<T>;
-export declare function isTransforming(_schema: schemas.$ZodType, _ctx?: {
-    seen: Set<schemas.$ZodType>;
-}): boolean;
 export type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<core.input<T>, core.output<T>>;
 export interface ZodStandardJSONSchemaPayload<T> extends JSONSchema.BaseSchema {
     "~standard": ZodStandardSchemaWithJSON<T>;

package/vendor/zod/core/to-json-schema.js

@@ -572,7 +572,7 @@ export function finalize(ctx, schema) {
         throw new Error("Error converting schema to JSON.");
     }
 }
-export function isTransforming(_schema, _ctx) {
+function isTransforming(_schema, _ctx) {
     const ctx = _ctx ?? { seen: new Set() };
     if (ctx.seen.has(_schema))
         return false;

package/vendor/zod/core/util.js

@@ -725,10 +725,6 @@ export function members(proto, table) {
         else
             defineBound(proto, key, desc.value);
     }
-    // for..in sees no symbol keys, so well-known members like Symbol.iterator install here
-    for (const sym of Object.getOwnPropertySymbols(table)) {
-        defineBound(proto, sym, table[sym]);
-    }
 }
 /** Shadows a prototype member with an own value, so a getter that builds from the instance runs once. */
 export function own(inst, key, value, enumerable = true) {

package/vendor/zod/core/versions.js

@@ -1,5 +1,5 @@
 export const version = {
     major: 4,
     minor: 6,
-    patch: 1,
+    patch: 4,
 };

package/vendor/zod/core/visit.js

@@ -135,18 +135,6 @@ export function visit(schema, fnOrHandlers) {
                 const { _cachedInner, ...rest } = def;
                 return clone(s, { ...rest, getter: () => run(original()) });
             }
-            case "properties": {
-                const oldShape = def.shape;
-                let changed = false;
-                const newShape = {};
-                for (const k of Reflect.ownKeys(oldShape)) {
-                    const mapped = run(oldShape[k]);
-                    if (mapped !== oldShape[k])
-                        changed = true;
-                    newShape[k] = mapped;
-                }
-                return changed ? clone(s, { ...def, shape: newShape }) : s;
-            }
             // A leaf by choice: `parts` are regex fragments, not data positions.
             case "template_literal":
             // Leaves.

package/vendor/zod/locales/ar.js

@@ -39,6 +39,7 @@ const error = () => {
         json_string: "نَص على هيئة JSON",
         e164: "رقم هاتف بمعيار E.164",
         credit_card: "رقم بطاقة الائتمان",
+        currency_code: "رمز العملة",
         iban: "IBAN",
         jwt: "JWT",
         template_literal: "مدخل",

package/vendor/zod/locales/az.js

@@ -39,6 +39,7 @@ const error = () => {
         json_string: "JSON string",
         e164: "E.164 number",
         credit_card: "kredit kartı nömrəsi",
+        currency_code: "valyuta kodu",
         iban: "IBAN",
         jwt: "JWT",
         template_literal: "input",

package/vendor/zod/locales/be.js

@@ -89,6 +89,7 @@ const error = () => {
         json_string: "JSON радок",
         e164: "нумар E.164",
         credit_card: "нумар крэдытнай карты",
+        currency_code: "код валюты",
         iban: "IBAN",
         jwt: "JWT",
         template_literal: "увод",

package/vendor/zod/locales/bg.js

@@ -39,6 +39,7 @@ const error = () => {
         json_string: "JSON низ",
         e164: "E.164 номер",
         credit_card: "номер на кредитна карта",
+        currency_code: "код на валута",
         iban: "IBAN",
         jwt: "JWT",
         template_literal: "вход",

package/vendor/zod/locales/bn.js

@@ -39,6 +39,7 @@ const error = () => {
         json_string: "JSON স্ট্রিং",
         e164: "E.164 নম্বর",
         credit_card: "ক্রেডিট কার্ড নম্বর",
+        currency_code: "মুদ্রা কোড",
         iban: "IBAN",
         jwt: "JWT",
         template_literal: "ইনপুট",

package/vendor/zod/locales/ca.js

@@ -39,6 +39,7 @@ const error = () => {
         json_string: "cadena JSON",
         e164: "número E.164",
         credit_card: "número de targeta de crèdit",
+        currency_code: "codi de moneda",
         iban: "IBAN",
         jwt: "JWT",
         template_literal: "entrada",

package/vendor/zod/locales/ckb.js

@@ -39,6 +39,7 @@ const error = () => {
         json_string: "دەقی JSON",
         e164: "ژمارەی E.164",
         credit_card: "ژمارەی کارتی کرێدیت",
+        currency_code: "کۆدی دراو",
         iban: "IBAN",
         jwt: "JWT",
         template_literal: "تێکردە",