schemas/libraries/zod/mini/download_compiled/compile/unminified.js
function toZod() {
return (schema) => schema;
}
function getEnumValues(entries) {
const numericValues = Object.values(entries).filter((v) => typeof v === "number");
return Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
}
function jsonStringifyReplacer(_, value) {
if (typeof value === "bigint") return value.toString();
return value;
}
var Cached = class {
constructor(getter) {
this._getter = getter;
this._value = void 0;
}
get value() {
const getter = this._getter;
if (getter !== void 0) {
this._value = getter();
this._getter = void 0;
}
return this._value;
}
};
function cached(getter) {
return new Cached(getter);
}
function nullish(input) {
return input === null || input === void 0;
}
function cleanRegex(source) {
const start = source.startsWith("^") ? 1 : 0;
const end = source.endsWith("$") ? source.length - 1 : source.length;
return source.slice(start, end);
}
function floatSafeRemainder(val, step) {
const ratio = val / step;
const roundedRatio = Math.round(ratio);
const tolerance = 4 * Number.EPSILON * Math.max(Math.abs(ratio), 1);
if (Math.abs(ratio - roundedRatio) < tolerance) return 0;
return ratio - roundedRatio;
}
function assignProp(target, prop, value) {
Object.defineProperty(target, prop, {
value,
writable: true,
enumerable: true,
configurable: true
});
}
function rawShape(def) {
const desc = Object.getOwnPropertyDescriptor(def, "shape");
return desc?.get ? desc.get.raw : desc?.value;
}
function esc(str) {
return JSON.stringify(str);
}
const captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
function isObject(data) {
return typeof data === "object" && data !== null && !Array.isArray(data);
}
function isPlainObject(o) {
if (isObject(o) === false) return false;
const ctor = o.constructor;
if (ctor === void 0) return true;
if (typeof ctor !== "function") return true;
const prot = ctor.prototype;
if (isObject(prot) === false) return false;
if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) return false;
return true;
}
function shallowClone(o) {
if (isPlainObject(o)) return { ...o };
if (Array.isArray(o)) return [...o];
if (o instanceof Map) return new Map(o);
if (o instanceof Set) return new Set(o);
return o;
}
const propertyKeyTypes = new Set([
"string",
"number",
"symbol"
]);
function escapeRegex(str) {
return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}
function clone(inst, def, params) {
const cl = new inst._zod.constr(def ?? inst._zod.def);
if (!def || params?.parent) cl._zod.parent = inst;
return cl;
}
function normalizeParams(_params) {
const params = _params;
if (!params) return {};
if (typeof params === "string") return { error: () => params };
if (params?.message !== void 0) {
if (params?.error !== void 0) throw new Error("Cannot specify both `message` and `error` params");
params.error = params.message;
}
delete params.message;
if (typeof params.error === "string") return {
...params,
error: () => params.error
};
return params;
}
function optionalKeys(shape) {
return Object.keys(shape).filter((k) => {
return shape[k]._zod.optin !== void 0 && shape[k]._zod.optout === "optional";
});
}
function aborted(x, startIndex = 0) {
if (x.aborted === true) return true;
for (let i = startIndex; i < x.issues.length; i++) if (x.issues[i]?.continue !== true) return true;
return false;
}
function explicitlyAborted(x, startIndex = 0) {
if (x.aborted === true) return true;
for (let i = startIndex; i < x.issues.length; i++) if (x.issues[i]?.continue === false) return true;
return false;
}
function prefixIssues(path, issues) {
return issues.map((iss) => {
var _a;
(_a = iss).path ?? (_a.path = []);
iss.path.unshift(path);
return iss;
});
}
function unwrapMessage(message) {
return typeof message === "string" ? message : message?.message;
}
function attachSchema(issues, start, inst) {
var _a;
for (let i = start; i < issues.length; i++) (_a = issues[i]).schema ?? (_a.schema = inst);
}
function finalizeIssue(iss, ctx, config) {
var _a;
const traits = iss.inst?._zod?.traits;
if (traits?.has("$ZodType")) {
if (traits.has("$ZodCheck")) (_a = iss).schema ?? (_a.schema = iss.inst);
else iss.schema = iss.inst;
}
const schemaError = iss.schema !== iss.inst ? iss.schema?._zod.def?.error : void 0;
const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(schemaError?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config.customError?.(iss)) ?? unwrapMessage(config.localeError?.(iss)) ?? "Invalid input";
const full = {};
for (const k of Object.keys(iss)) {
if (k === "inst" || k === "schema" || k === "continue" || k === "input" || k === "__proto__") continue;
full[k] = iss[k];
}
full.path ?? (full.path = []);
full.message = message;
if (ctx?.reportInput) full.input = iss.input;
return full;
}
const highSurrogate = /[\uD800-\uDBFF]/;
function codePointLength(str) {
const units = str.length;
if (!highSurrogate.test(str)) return units;
let count = units;
for (let i = 0; i < units - 1; i++) if ((str.charCodeAt(i) & 64512) === 55296 && (str.charCodeAt(i + 1) & 64512) === 56320) {
count--;
i++;
}
return count;
}
function getLengthableOrigin(input) {
if (Array.isArray(input)) return "array";
if (typeof input === "string") return "string";
return "unknown";
}
function members(proto, table) {
for (const key in table) {
const desc = Object.getOwnPropertyDescriptor(table, key);
if (desc.get) Object.defineProperty(proto, key, {
...desc,
enumerable: false
});
else defineBound(proto, key, desc.value);
}
}
function own(inst, key, value, enumerable = true) {
Object.defineProperty(inst, key, {
configurable: true,
writable: true,
enumerable,
value
});
return value;
}
function hide(inst, key, value) {
return own(inst, key, value, false);
}
function defineBound(proto, key, fn) {
Object.defineProperty(proto, key, {
configurable: true,
get() {
return this == null ? fn : own(this, key, fn.bind(this));
},
set(value) {
own(this, key, value);
}
});
}
function claim(inst, sentinel) {
const proto = Object.getPrototypeOf(inst);
return sentinel in proto ? void 0 : proto;
}
let installing;
let broke = false;
const breaker = {
configurable: true,
get() {
broke = true;
}
};
function defineLazyInternal(inst, key, compute) {
const proto = Object.getPrototypeOf(inst._zod);
if (key in proto && installing !== inst._zod) {
installing = void 0;
return;
}
installing = inst._zod;
Object.defineProperty(proto, key, {
configurable: true,
get() {
Object.defineProperty(this, key, breaker);
const outer = broke;
broke = false;
try {
const value = compute(this);
if (broke) delete this[key];
else Object.defineProperty(this, key, {
configurable: true,
writable: true,
value
});
broke = broke || outer;
return value;
} catch (err) {
delete this[key];
broke = broke || outer;
throw err;
}
},
set(value) {
Object.defineProperty(this, key, {
configurable: true,
writable: true,
value
});
}
});
}
function installLazyProp(inst, key, make, enumerable) {
const proto = claim(inst, key);
if (!proto) return;
Object.defineProperty(proto, key, {
configurable: true,
get() {
const desc = {
configurable: true,
writable: true,
enumerable,
value: void 0
};
Object.defineProperty(this, key, desc);
desc.value = make(this);
Object.defineProperty(this, key, desc);
return desc.value;
},
set(value) {
Object.defineProperty(this, key, {
configurable: true,
writable: true,
enumerable,
value
});
}
});
}
var _a;
const _zodDesc = {
value: void 0,
enumerable: false
};
let _E = "captureStackTrace" in Error ? Error : null;
function newError(Definition) {
const E = _E;
if (E) {
const saved = E.stackTraceLimit;
if (typeof saved === "number") {
try {
E.stackTraceLimit = 0;
} catch {
_E = null;
return new Definition();
}
try {
return new Definition();
} finally {
E.stackTraceLimit = saved;
}
}
}
return new Definition();
}
function $constructor(name, initializer, proto, params) {
const zodProto = {};
function Internals(def) {
this.def = def;
this.constr = _;
this.traits = new Set();
}
Internals.prototype = zodProto;
const protoMembers = proto;
const initialized = protoMembers && new WeakSet();
function init(inst, def) {
if (!inst._zod) {
_zodDesc.value = new Internals(def);
try {
Object.defineProperty(inst, "_zod", _zodDesc);
} finally {
_zodDesc.value = void 0;
}
} else if (inst._zod.traits.has(name)) return;
inst._zod.traits.add(name);
initializer(inst, def);
if (initialized) {
const own = Object.getPrototypeOf(inst);
const ctorProto = inst._zod.constr.prototype;
let up = own;
while (up && up !== ctorProto) up = Object.getPrototypeOf(up);
const target = up ?? own;
if (!initialized.has(target)) {
initialized.add(target);
members(target, protoMembers);
}
}
const proto = _.prototype;
for (const k in proto) {
if (!Object.prototype.hasOwnProperty.call(proto, k)) continue;
if (!(k in inst)) inst[k] = proto[k].bind(inst);
}
}
const Parent = params?.Parent ?? Object;
class Definition extends Parent {}
Object.defineProperty(Definition, "name", { value: name });
function _(def) {
const inst = params?.Parent ? newError(Definition) : this;
init(inst, def);
const deferred = inst._zod.deferred;
if (deferred) {
for (const fn of deferred) fn();
inst._zod.deferred = void 0;
}
const pp = globalThis.__zod_globalConfig?.postProcessor;
if (pp) pp(inst);
return inst;
}
Object.defineProperty(_, "init", { value: init });
Object.defineProperty(_, Symbol.hasInstance, { value: (inst) => {
if (params?.Parent && inst instanceof params.Parent) return true;
return inst?._zod?.traits?.has(name);
} });
Object.defineProperty(_, "name", { value: name });
return _;
}
var $ZodAsyncError = class extends Error {
constructor() {
super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
}
};
(_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {});
const globalConfig = globalThis.__zod_globalConfig;
function config(newConfig) {
if (newConfig) Object.assign(globalConfig, newConfig);
return globalConfig;
}
function _getMessage() {
const internals = this._zod;
internals.message ?? (internals.message = JSON.stringify(internals.def, jsonStringifyReplacer, 2));
return internals.message;
}
function _setMessage(value) {
this._zod.message = value;
}
const _messageDesc = {
get: _getMessage,
set: _setMessage,
enumerable: true,
configurable: true
};
const _issuesDesc = {
value: void 0,
enumerable: false
};
const _installedToString = new WeakSet([Object.prototype, Error.prototype]);
const initializer = (inst, def) => {
inst.name = "$ZodError";
_issuesDesc.value = def;
Object.defineProperty(inst, "issues", _issuesDesc);
_issuesDesc.value = void 0;
Object.defineProperty(inst, "message", _messageDesc);
const proto = Object.getPrototypeOf(inst);
if (!_installedToString.has(proto)) {
_installedToString.add(proto);
Object.defineProperty(proto, "toString", {
configurable: true,
enumerable: false,
get() {
const value = () => this.message;
Object.defineProperty(this, "toString", {
value,
configurable: true,
writable: true
});
return value;
},
set(value) {
Object.defineProperty(this, "toString", {
value,
configurable: true,
writable: true
});
}
});
}
};
$constructor("$ZodError", initializer);
const $ZodRealError = $constructor("$ZodError", initializer, void 0, { Parent: Error });
const _parse = (_Err) => {
const fn = (schema, value, _ctx, _params) => {
const ctx = _ctx ? {
..._ctx,
async: false
} : { async: false };
const result = schema._zod.run({
value,
issues: []
}, ctx);
if (result instanceof Promise) throw new $ZodAsyncError();
if (result.issues.length) {
const e = new ((_params?.Err) ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
captureStackTrace(e, _params?.callee ?? fn);
throw e;
}
return result.value;
};
return fn;
};
const parse = _parse($ZodRealError);
const _parseAsync = (_Err) => {
const fn = async (schema, value, _ctx, params) => {
const ctx = _ctx ? {
..._ctx,
async: true
} : { async: true };
let result = schema._zod.run({
value,
issues: []
}, ctx);
if (result instanceof Promise) result = await result;
if (result.issues.length) {
const e = new ((params?.Err) ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
captureStackTrace(e, params?.callee ?? fn);
throw e;
}
return result.value;
};
return fn;
};
const parseAsync = _parseAsync($ZodRealError);
const _safeParse = (_Err) => (schema, value, _ctx) => {
const ctx = _ctx ? {
..._ctx,
async: false
} : { async: false };
const result = schema._zod.run({
value,
issues: []
}, ctx);
if (result instanceof Promise) throw new $ZodAsyncError();
return result.issues.length ? failure(_Err, result.issues, ctx) : {
success: true,
data: result.value
};
};
const safeParse = _safeParse($ZodRealError);
function failure(Err, issues, ctx) {
let error;
return {
success: false,
get error() {
if (!error) {
error = new Err(issues.map((iss) => finalizeIssue(iss, ctx, config())));
issues = void 0;
ctx = void 0;
}
return error;
},
set error(e) {
error = e;
issues = void 0;
ctx = void 0;
}
};
}
const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
const ctx = _ctx ? {
..._ctx,
async: true
} : { async: true };
let result = schema._zod.run({
value,
issues: []
}, ctx);
if (result instanceof Promise) result = await result;
return result.issues.length ? failure(_Err, result.issues, ctx) : {
success: true,
data: result.value
};
};
const safeParseAsync = _safeParseAsync($ZodRealError);
const httpProtocol = /^https?$/;
const creditCard = /^\d(?:[ -]?\d){11,18}$/;
const iban = /^[A-Z]{2}(?!00|01|99)\d{2}[A-Z0-9]{11,30}$/;
const anyString = /^[\s\S]{0,}$/;
const number$1 = /^-?\d+(?:\.\d+)?$/;
const $ZodCheck = $constructor("$ZodCheck", (inst, def) => {
var _a;
inst._zod ?? (inst._zod = {});
inst._zod.def = def;
(_a = inst._zod).onattach ?? (_a.onattach = []);
});
const _whenHasLength = (payload) => {
const val = payload.value;
return !nullish(val) && val.length !== void 0;
};
const numericOriginMap = {
number: "number",
bigint: "bigint",
object: "date"
};
const $ZodCheckLessThan = $constructor("$ZodCheckLessThan", (inst, def) => {
$ZodCheck.init(inst, def);
const origin = numericOriginMap[typeof def.value];
inst._zod.check = (payload) => {
if (def.inclusive ? payload.value <= def.value : payload.value < def.value) return;
payload.issues.push({
origin: numericOriginMap[typeof payload.value] ?? origin,
code: "too_big",
maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
input: payload.value,
inclusive: def.inclusive,
inst,
continue: !def.abort
});
};
});
const $ZodCheckGreaterThan = $constructor("$ZodCheckGreaterThan", (inst, def) => {
$ZodCheck.init(inst, def);
const origin = numericOriginMap[typeof def.value];
inst._zod.check = (payload) => {
if (def.inclusive ? payload.value >= def.value : payload.value > def.value) return;
payload.issues.push({
origin: numericOriginMap[typeof payload.value] ?? origin,
code: "too_small",
minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
input: payload.value,
inclusive: def.inclusive,
inst,
continue: !def.abort
});
};
});
const $ZodCheckMaxLength = $constructor("$ZodCheckMaxLength", (inst, def) => {
var _a;
$ZodCheck.init(inst, def);
(_a = inst._zod.def).when ?? (_a.when = _whenHasLength);
inst._zod.check = (payload) => {
const input = payload.value;
const units = input.length;
if ((typeof input === "string" && units > def.maximum ? codePointLength(input) : units) <= def.maximum) return;
const origin = getLengthableOrigin(input);
payload.issues.push({
origin,
code: "too_big",
maximum: def.maximum,
inclusive: true,
input,
inst,
continue: !def.abort
});
};
});
const $ZodCheckMinLength = $constructor("$ZodCheckMinLength", (inst, def) => {
var _a;
$ZodCheck.init(inst, def);
(_a = inst._zod.def).when ?? (_a.when = _whenHasLength);
inst._zod.check = (payload) => {
const input = payload.value;
const units = input.length;
if ((typeof input === "string" && units >= def.minimum && units < def.minimum * 2 ? codePointLength(input) : units) >= def.minimum) return;
const origin = getLengthableOrigin(input);
payload.issues.push({
origin,
code: "too_small",
minimum: def.minimum,
inclusive: true,
input,
inst,
continue: !def.abort
});
};
});
const $ZodCheckStringFormat = $constructor("$ZodCheckStringFormat", (inst, def) => {
var _a, _b;
$ZodCheck.init(inst, def);
if (def.pattern) (_a = inst._zod).check ?? (_a.check = (payload) => {
def.pattern.lastIndex = 0;
if (def.pattern.test(payload.value)) return;
payload.issues.push({
origin: "string",
code: "invalid_format",
format: def.format,
input: payload.value,
...def.pattern ? { pattern: def.pattern.toString() } : {},
inst,
continue: !def.abort
});
});
else (_b = inst._zod).check ?? (_b.check = () => {});
});
var Doc = class {
constructor(args = [], closed = {}) {
this.content = [];
this.indent = 0;
this.args = args;
this.closed = closed;
}
indented(fn) {
this.indent += 1;
try {
fn(this);
} finally {
this.indent -= 1;
}
}
write(arg) {
if (typeof arg === "function") {
arg(this, { execution: "sync" });
arg(this, { execution: "async" });
return;
}
const lines = arg.split("\n").filter((x) => x);
const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
for (const line of dedented) this.content.push(line);
}
compile() {
const F = Function;
const content = this?.content ?? [``];
return new F(...Object.keys(this.closed), `return function (${this.args.join(", ")}) {\n${content.join("\n")}\n};`)(...Object.values(this.closed));
}
};
const version = {
major: 4,
minor: 6,
patch: 5
};
const $ZodType = $constructor("$ZodType", (inst, def) => {
var _a;
inst ?? (inst = {});
inst._zod.def = def;
inst._zod.bag = inst._zod.bag || {};
inst._zod.version = version;
const defChecks = inst._zod.def.checks;
const checks = inst._zod.traits.has("$ZodCheck") ? [inst, ...defChecks ?? []] : defChecks?.length ? [...defChecks] : [];
for (const ch of checks) for (const fn of ch._zod.onattach) fn(inst);
if (checks.length === 0) {
(_a = inst._zod).deferred ?? (_a.deferred = []);
inst._zod.deferred?.push(() => {
inst._zod.run = inst._zod.parse;
});
} else {
const runChecks = (payload, checks, ctx) => {
if (payload.memo) return payload;
let isAborted = aborted(payload);
let asyncResult;
for (const ch of checks) {
if (ch._zod.def.when) {
if (explicitlyAborted(payload)) continue;
if (!ch._zod.def.when(payload)) continue;
} else if (isAborted) continue;
const currLen = payload.issues.length;
const _ = ch._zod.check(payload);
if (_ instanceof Promise && ctx?.async === false) throw new $ZodAsyncError();
if (asyncResult || _ instanceof Promise) asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
await _;
if (payload.issues.length === currLen) return;
attachSchema(payload.issues, currLen, inst);
if (!isAborted) isAborted = aborted(payload, currLen);
});
else {
if (payload.issues.length === currLen) continue;
attachSchema(payload.issues, currLen, inst);
if (!isAborted) isAborted = aborted(payload, currLen);
}
}
if (asyncResult) return asyncResult.then(() => {
return payload;
});
return payload;
};
const handleCanaryResult = (canary, payload, ctx) => {
if (aborted(canary)) {
canary.aborted = true;
return canary;
}
const checkResult = runChecks(payload, checks, ctx);
if (checkResult instanceof Promise) {
if (ctx.async === false) throw new $ZodAsyncError();
return checkResult.then((checkResult) => inst._zod.parse(checkResult, ctx));
}
return inst._zod.parse(checkResult, ctx);
};
inst._zod.run = (payload, ctx) => {
if (ctx.skipChecks) return inst._zod.parse(payload, ctx);
if (ctx.direction === "backward") {
const canary = inst._zod.parse({
value: payload.value,
issues: []
}, {
...ctx,
skipChecks: true
});
if (canary instanceof Promise) return canary.then((canary) => {
return handleCanaryResult(canary, payload, ctx);
});
return handleCanaryResult(canary, payload, ctx);
}
const result = inst._zod.parse(payload, ctx);
if (result instanceof Promise) {
if (ctx.async === false) throw new $ZodAsyncError();
return result.then((result) => runChecks(result, checks, ctx));
}
return runChecks(result, checks, ctx);
};
}
}, {
get "~standard"() {
return hide(this, "~standard", standardProps(this));
},
set "~standard"(value) {
own(this, "~standard", value);
}
});
const toStandardResult = (r, ctx) => r.issues.length ? { issues: r.issues.map((iss) => finalizeIssue(iss, ctx, config())) } : { value: r.value };
async function validateAsync(inst, value) {
const ctx = { async: true };
return toStandardResult(await inst._zod.run({
value,
issues: []
}, ctx), ctx);
}
function standardProps(inst) {
return {
validate: (value) => {
const ctx = { async: false };
try {
const r = inst._zod.run({
value,
issues: []
}, ctx);
if (!(r instanceof Promise)) return toStandardResult(r, ctx);
} catch (_) {}
return validateAsync(inst, value);
},
vendor: "zod",
version: 1
};
}
const $ZodString = $constructor("$ZodString", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.pattern = def.pattern ?? anyString;
inst._zod.parse = (payload, _) => {
if (def.coerce) try {
payload.value = String(payload.value);
} catch (_) {}
if (typeof payload.value === "string") return payload;
payload.issues.push({
expected: "string",
code: "invalid_type",
input: payload.value,
inst
});
return payload;
};
});
const $ZodStringFormat = $constructor("$ZodStringFormat", (inst, def) => {
$ZodCheckStringFormat.init(inst, def);
$ZodString.init(inst, def);
});
function canParseURL(input) {
try {
if (typeof URL !== "undefined" && typeof URL.canParse === "function") return URL.canParse(input);
new URL(input);
return true;
} catch {
return false;
}
}
function validateURL(trimmed, def) {
if (!("normalize" in def) && !("hostname" in def) && !("protocol" in def)) return canParseURL(trimmed) || 2;
return parseURLObject(trimmed, def);
}
function parseURLObject(trimmed, def) {
if (!def.normalize && def.protocol?.source === httpProtocol.source && !/^https?:\/\//i.test(trimmed)) return 1;
try {
if (typeof URL !== "undefined") {
const URLStatic = URL;
if (typeof URLStatic.parse === "function") return URLStatic.parse(trimmed) ?? 2;
}
return new URL(trimmed);
} catch {
return 2;
}
}
const asciiTabOrNewline = /[\t\n\r]/g;
function stripTabAndNewline(value) {
return value.replace(asciiTabOrNewline, "");
}
function urlHostnameOk(url, hostname) {
hostname.lastIndex = 0;
return hostname.test(url.hostname);
}
function urlProtocolOk(url, protocol) {
protocol.lastIndex = 0;
return protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol);
}
const $ZodURL = $constructor("$ZodURL", (inst, def) => {
$ZodStringFormat.init(inst, def);
inst._zod.check = (payload) => {
try {
const trimmed = payload.value.trim();
const url = validateURL(trimmed, def);
if (url === 1) {
payload.issues.push({
code: "invalid_format",
format: "url",
note: "Invalid URL format",
input: payload.value,
inst,
continue: !def.abort
});
return;
}
if (url === 2) {
payload.issues.push({
code: "invalid_format",
format: "url",
input: payload.value,
inst,
continue: !def.abort
});
return;
}
if (url === true) {
payload.value = stripTabAndNewline(trimmed);
return;
}
if (def.hostname && !urlHostnameOk(url, def.hostname)) payload.issues.push({
code: "invalid_format",
format: "url",
note: "Invalid hostname",
pattern: def.hostname.source,
input: payload.value,
inst,
continue: !def.abort
});
if (def.protocol && !urlProtocolOk(url, def.protocol)) payload.issues.push({
code: "invalid_format",
format: "url",
note: "Invalid protocol",
pattern: def.protocol.source,
input: payload.value,
inst,
continue: !def.abort
});
payload.value = def.normalize ? url.href : stripTabAndNewline(trimmed);
return;
} catch (_) {
payload.issues.push({
code: "invalid_format",
format: "url",
input: payload.value,
inst,
continue: !def.abort
});
}
};
});
const ipv6Alphabet = /^[0-9a-fA-F:.]+$/;
function isValidIPv6(value) {
if (!ipv6Alphabet.test(value)) return false;
return canParseURL(`http://[${value}]`);
}
function isValidCIDRv6(value) {
const parts = value.split("/");
if (parts.length !== 2) return false;
const [address, prefix] = parts;
if (!prefix) return false;
const prefixNum = Number(prefix);
if (`${prefixNum}` !== prefix) return false;
if (prefixNum < 0 || prefixNum > 128) return false;
return isValidIPv6(address);
}
function isValidBase64(data) {
if (data === "") return true;
if (/\s/.test(data)) return false;
if (data.length % 4 !== 0) return false;
try {
atob(data);
return true;
} catch {
return false;
}
}
const base64urlCharset = /^[A-Za-z0-9_-]*$/;
function isValidBase64URL(data) {
if (!base64urlCharset.test(data)) return false;
const base64 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/");
return isValidBase64(base64.padEnd(Math.ceil(base64.length / 4) * 4, "="));
}
const CC_SANITIZE = /[- ]/g;
function isLuhnAlgo(digits) {
let length = digits.length;
let bit = 1;
let sum = 0;
while (length) {
const value = digits.charCodeAt(--length) - 48;
bit ^= 1;
sum += bit ? [
0,
2,
4,
6,
8,
1,
3,
5,
7,
9
][value] : value;
}
return sum % 10 === 0;
}
function isValidCreditCard(input) {
if (!creditCard.test(input)) return false;
return isLuhnAlgo(input.replace(CC_SANITIZE, ""));
}
function isIso7064Mod97(iban) {
let remainder = 0;
const len = iban.length;
for (let i = 4; i < len; i++) {
const code = iban.charCodeAt(i);
remainder = (code >= 65 ? remainder * 100 + (code - 55) : remainder * 10 + (code - 48)) % 97;
}
for (let i = 0; i < 4; i++) {
const code = iban.charCodeAt(i);
remainder = (code >= 65 ? remainder * 100 + (code - 55) : remainder * 10 + (code - 48)) % 97;
}
return remainder === 1;
}
function isValidIBAN(input) {
if (!iban.test(input)) return false;
return isIso7064Mod97(input);
}
function isValidJWT(token, algorithm = null) {
try {
const tokensParts = token.split(".");
if (tokensParts.length !== 3) return false;
const [header] = tokensParts;
if (!header) return false;
const parsedHeader = JSON.parse(atob(header));
if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT") return false;
if (!parsedHeader.alg) return false;
if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm)) return false;
return true;
} catch {
return false;
}
}
const $ZodNumber = $constructor("$ZodNumber", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.pattern = number$1;
inst._zod.parse = (payload, _ctx) => {
if (def.coerce) try {
payload.value = Number(payload.value);
} catch (_) {}
const input = payload.value;
if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) return payload;
const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? String(input) : void 0 : void 0;
payload.issues.push({
expected: "number",
code: "invalid_type",
input,
inst,
...received ? { received } : {}
});
return payload;
};
});
const $ZodDate = $constructor("$ZodDate", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload, _ctx) => {
if (def.coerce) try {
payload.value = new Date(payload.value);
} catch (_err) {}
const input = payload.value;
const isDate = input instanceof Date;
if (isDate && !Number.isNaN(input.getTime())) return payload;
payload.issues.push({
expected: "date",
code: "invalid_type",
input,
...isDate ? { received: "Invalid Date" } : {},
inst
});
return payload;
};
});
function handleArrayResult(result, final, index) {
if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
final.value[index] = result.value;
}
const $ZodArray = $constructor("$ZodArray", (inst, def) => {
$ZodType.init(inst, def);
const memo = globalConfig.memoizer;
memo?.attach(inst);
inst._zod.parse = (payload, ctx) => {
const input = payload.value;
if (!Array.isArray(input)) {
payload.issues.push({
expected: "array",
code: "invalid_type",
input,
inst
});
return payload;
}
payload.value = memo ? memo.alloc(inst, payload, Array(input.length), ctx) : Array(input.length);
const proms = [];
const abortEarly = ctx?.abortEarly;
for (let i = 0; i < input.length; i++) {
const item = input[i];
const result = def.element._zod.run({
value: item,
issues: []
}, ctx);
if (result instanceof Promise) proms.push(result.then((result) => handleArrayResult(result, payload, i)));
else {
handleArrayResult(result, payload, i);
if (abortEarly && result.issues.length !== 0 && aborted(result)) break;
}
}
if (proms.length) return Promise.all(proms).then(() => payload);
return payload;
};
});
function handlePropertyResult(result, final, key, input, optin, optout) {
const isPresent = key in input;
const isOptionalOut = optout === "optional";
if (!isPresent && isOptionalOut && optin === "optional") return;
if (result.issues.length) {
if (optin !== void 0 && isOptionalOut && !isPresent) return;
final.issues.push(...prefixIssues(key, result.issues));
}
if (!isPresent && optin === void 0) {
if (!result.issues.length) final.issues.push({
code: "invalid_type",
expected: "nonoptional",
input: void 0,
path: [key]
});
return;
}
if (result.value === void 0) {
if (isPresent || optin === "defaulted" && !isOptionalOut) final.value[key] = void 0;
} else final.value[key] = result.value;
}
const NO_SYMBOL_KEYS = [];
function normalizeDef(def) {
const keys = Object.keys(def.shape);
const ownSymbols = Object.getOwnPropertySymbols(def.shape);
const symbolKeys = ownSymbols.length ? ownSymbols : NO_SYMBOL_KEYS;
const allKeys = symbolKeys.length ? [...keys, ...symbolKeys] : keys;
for (const k of allKeys) if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) throw new Error(`Invalid element at key "${String(k)}": expected a Zod schema`);
const okeys = optionalKeys(def.shape);
return {
...def,
allKeys,
symbolKeys,
keySet: new Set(keys),
numKeys: keys.length,
optionalKeys: new Set(okeys)
};
}
function handleCatchall(proms, input, payload, ctx, def, inst, abortEarly) {
const unrecognized = [];
const keySet = def.keySet;
const _catchall = def.catchall._zod;
const t = _catchall.def.type;
const optin = _catchall.optin;
const optout = _catchall.optout;
let seen = 0;
for (const key in input) {
if (abortEarly && payload.issues.length !== seen) {
if (aborted(payload, seen)) break;
seen = payload.issues.length;
}
if (keySet.has(key)) continue;
if (key === "__proto__") {
if (t === "never") unrecognized.push(key);
continue;
}
if (t === "never") {
unrecognized.push(key);
continue;
}
const r = _catchall.run({
value: input[key],
issues: []
}, ctx);
if (r instanceof Promise) proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, optin, optout)));
else handlePropertyResult(r, payload, key, input, optin, optout);
}
if (unrecognized.length) payload.issues.push({
code: "unrecognized_keys",
keys: unrecognized,
input,
inst,
continue: true
});
if (!proms.length) return payload;
return Promise.all(proms).then(() => {
return payload;
});
}
const $ZodObject = $constructor("$ZodObject", (inst, def) => {
$ZodType.init(inst, def);
const desc = Object.getOwnPropertyDescriptor(def, "shape");
const sh = desc?.get ? desc.get.raw : def.shape ?? {};
if (sh) {
const get = () => {
const newSh = { ...sh };
Object.defineProperty(def, "shape", { value: newSh });
get.raw = newSh;
return newSh;
};
get.raw = sh;
Object.defineProperty(def, "shape", { get });
}
const _normalized = cached(() => normalizeDef(def));
defineLazyInternal(inst, "propValues", (zod) => {
const shape = zod.def.shape;
const propValues = {};
for (const key in shape) {
const field = shape[key]._zod;
if (field.values) {
if (!Object.prototype.hasOwnProperty.call(propValues, key)) assignProp(propValues, key, new Set());
for (const v of field.values) propValues[key].add(v);
if (field.optin !== void 0) propValues[key].add(void 0);
}
}
return propValues;
});
const isObject$2 = isObject;
const catchall = def.catchall;
let value;
const memo = globalConfig.memoizer;
memo?.attach(inst);
inst._zod.parse = (payload, ctx) => {
value ?? (value = _normalized.value);
const input = payload.value;
if (!isObject$2(input)) {
payload.issues.push({
expected: "object",
code: "invalid_type",
input,
inst
});
return payload;
}
payload.value = memo ? memo.alloc(inst, payload, {}, ctx) : {};
const proms = [];
const shape = value.shape;
const abortEarly = ctx?.abortEarly;
let seen = payload.issues.length;
for (const key of value.allKeys) {
if (abortEarly && payload.issues.length !== seen) {
if (aborted(payload, seen)) break;
seen = payload.issues.length;
}
if (key === "__proto__") continue;
const el = shape[key];
const optin = el._zod.optin;
const optout = el._zod.optout;
const r = el._zod.run({
value: input[key],
issues: []
}, ctx);
if (r instanceof Promise) proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, optin, optout)));
else handlePropertyResult(r, payload, key, input, optin, optout);
}
if (!catchall) return proms.length ? Promise.all(proms).then(() => payload) : payload;
return handleCatchall(proms, input, payload, ctx, _normalized.value, inst, abortEarly === true);
};
});
function mergeValues(a, b) {
if (a === b) return {
valid: true,
data: a
};
if (a instanceof Date && b instanceof Date && +a === +b) return {
valid: true,
data: a
};
if (isPlainObject(a) && isPlainObject(b)) {
const bKeys = Object.keys(b);
const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
const newObj = {
...a,
...b
};
if (Object.prototype.hasOwnProperty.call(newObj, "__proto__")) delete newObj.__proto__;
for (const key of sharedKeys) {
if (key === "__proto__") continue;
const sharedValue = mergeValues(a[key], b[key]);
if (!sharedValue.valid) return {
valid: false,
mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
};
newObj[key] = sharedValue.data;
}
return {
valid: true,
data: newObj
};
}
if (Array.isArray(a) && Array.isArray(b)) {
if (a.length !== b.length) return {
valid: false,
mergeErrorPath: []
};
const newArray = [];
for (let index = 0; index < a.length; index++) {
const itemA = a[index];
const itemB = b[index];
const sharedValue = mergeValues(itemA, itemB);
if (!sharedValue.valid) return {
valid: false,
mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
};
newArray.push(sharedValue.data);
}
return {
valid: true,
data: newArray
};
}
return {
valid: false,
mergeErrorPath: []
};
}
const $ZodEnum = $constructor("$ZodEnum", (inst, def) => {
$ZodType.init(inst, def);
const values = getEnumValues(def.entries);
const valuesSet = new Set(values);
inst._zod.values = valuesSet;
defineLazyInternal(inst, "pattern", (zod) => {
const patternValues = getEnumValues(zod.def.entries).filter((k) => propertyKeyTypes.has(typeof k));
return new RegExp(patternValues.length ? `^(${patternValues.map((o) => escapeRegex(o.toString())).join("|")})$` : "^[^\\s\\S]$");
});
inst._zod.parse = (payload, _ctx) => {
const input = payload.value;
if (valuesSet.has(input)) return payload;
payload.issues.push({
code: "invalid_value",
values,
input,
inst
});
return payload;
};
});
const $ZodNullable = $constructor("$ZodNullable", (inst, def) => {
$ZodType.init(inst, def);
defineLazyInternal(inst, "optin", (zod) => zod.def.innerType._zod.optin);
defineLazyInternal(inst, "optout", (zod) => zod.def.innerType._zod.optout);
defineLazyInternal(inst, "pattern", (zod) => {
const pattern = zod.def.innerType._zod.pattern;
return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;
});
defineLazyInternal(inst, "values", (zod) => {
return zod.def.innerType._zod.values ? new Set([...zod.def.innerType._zod.values, null]) : void 0;
});
inst._zod.parse = (payload, ctx) => {
if (payload.value === null) return payload;
return def.innerType._zod.run(payload, ctx);
};
});
const STATE = "~memo";
function isRef(value) {
return value !== null && typeof value === "object";
}
const recursive = new WeakMap();
const NONE = 0;
const ASSUMED = 1;
const PROVEN = 2;
function isRecursive(inst, stack, resolve) {
const cached = recursive.get(inst);
if (cached !== void 0) return cached ? PROVEN : NONE;
if (stack.has(inst)) return PROVEN;
stack.add(inst);
let result = NONE;
const check = (child) => {
if (result !== PROVEN && child?._zod) {
const answer = isRecursive(child, stack, resolve);
if (answer > result) result = answer;
}
};
const shape = (sh, spread) => {
let answer = NONE;
for (const key of Reflect.ownKeys(sh)) {
const desc = Object.getOwnPropertyDescriptor(sh, key);
if (spread && !desc.enumerable) continue;
const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve) : NONE;
if (child > answer) answer = child;
}
return answer;
};
const merge = (answer) => {
if (answer > result) result = answer;
};
const def = inst._zod.def;
switch (def.type) {
case "object": {
const raw = rawShape(def);
merge(raw ? shape(raw, true) : ASSUMED);
check(def.catchall);
break;
}
case "array":
check(def.element);
break;
case "tuple":
for (const el of def.items) check(el);
check(def.rest);
break;
case "record":
case "map":
check(def.keyType);
check(def.valueType);
break;
case "set":
check(def.valueType);
break;
case "union":
for (const el of def.options) check(el);
break;
case "intersection":
check(def.left);
check(def.right);
break;
case "optional":
case "nullable":
case "default":
case "prefault":
case "catch":
case "readonly":
case "nonoptional":
case "promise":
case "success":
check(def.innerType);
break;
case "pipe":
check(def.in);
check(def.out);
break;
case "function":
check(def.input);
check(def.output);
break;
case "lazy": {
const inner = def._cachedInner ?? (resolve ? inst._zod.innerType : void 0);
merge(inner ? isRecursive(inner, stack, false) : ASSUMED);
break;
}
case "template_literal":
case "string":
case "number":
case "int":
case "boolean":
case "bigint":
case "symbol":
case "undefined":
case "null":
case "void":
case "never":
case "any":
case "unknown":
case "date":
case "nan":
case "enum":
case "literal":
case "file":
case "transform":
case "custom": break;
default: for (const key in def) {
const desc = Object.getOwnPropertyDescriptor(def, key);
if (!desc || desc.get) continue;
const value = desc.value;
if (!value || typeof value !== "object") continue;
if (value._zod) check(value);
else if (Array.isArray(value)) for (const el of value) check(el);
}
}
stack.delete(inst);
return settle(inst, result);
}
function settle(inst, answer) {
if (answer !== ASSUMED) recursive.set(inst, answer === PROVEN);
return answer;
}
function isRecursiveSchema(inst) {
return isRecursive(inst, new Set(), true) !== NONE;
}
function isBackEdge(ctx, value) {
const backEdges = ctx[STATE]?.backEdges;
return backEdges !== void 0 && isRef(value) && backEdges.has(value);
}
const INVALID = Symbol.for("zod.compile.invalid");
const FALLBACK_FLAG = Symbol.for("zod.compile.fallback");
var ZodCompileAsyncError = class extends Error {
constructor(message = "z.compile does not support async refinements, transforms, or checks") {
super(message);
this.name = "ZodCompileAsyncError";
}
};
var ZodCompileUnsupportedError = class extends Error {
constructor(feature, islandable = true) {
super(`z.compile does not support ${feature}; this schema must use the runtime parser`);
this.name = "ZodCompileUnsupportedError";
this.islandable = islandable;
}
};
function compileValidator(schema, parser) {
try {
return compileFn(schema, { assertOnly: true });
} catch {
return parser;
}
}
function compile(schema, options) {
try {
const parser = compileFn(schema);
const clone = withParser(schema, parser);
clone._zod.bag.validator = compileValidator(schema, parser);
return clone;
} catch (err) {
if (options?.strict) throw err;
return schema;
}
}
function withParser(schema, parser) {
if (isRecursiveSchema(schema)) throw new ZodCompileUnsupportedError("a schema whose subtree contains a reference cycle");
const clone$1 = clone(schema);
const liveRun = schema._zod.run;
const originalRun = liveRun.__originalRun ?? liveRun;
const wrapped = (payload, ctx) => {
if (ctx?.async || ctx?.direction === "backward" || ctx?.skipChecks || ctx?.[FALLBACK_FLAG]) return originalRun(payload, ctx);
if (ctx && isBackEdge(ctx, payload.value)) return originalRun(payload, ctx);
const out = parser(payload.value);
if (out !== INVALID) {
payload.value = out;
return payload;
}
if (ctx) ctx[FALLBACK_FLAG] = true;
return originalRun(payload, ctx);
};
wrapped.__originalRun = originalRun;
clone$1._zod.bag.fallbackRun = originalRun;
clone$1._zod.bag.validator = parser;
clone$1._zod.run = wrapped;
if (!liveRun.__originalRun) installCompiledUserMethods(clone$1, schema, parser);
return clone$1;
}
function installCompiledUserMethods(target, source, parser) {
const targetAny = target;
const sourceAny = source;
if (typeof sourceAny.safeParse === "function") {
const originalSafeParse = sourceAny.safeParse;
targetAny.safeParse = (data, params) => {
const out = parser(data);
if (out !== INVALID) return {
success: true,
data: out
};
return originalSafeParse(data, params);
};
}
if (typeof sourceAny.parse === "function") {
const originalParse = sourceAny.parse;
targetAny.parse = (data, params) => {
const out = parser(data);
if (out !== INVALID) return out;
return originalParse(data, params);
};
}
}
function compileFn(schema, options) {
let recursive = true;
try {
recursive = isRecursiveSchema(schema);
} catch {}
if (recursive) throw new ZodCompileUnsupportedError("a schema whose subtree contains a reference cycle");
const ctx = {
constants: new Map(),
constantCounter: 0,
varCounter: 0,
definite: true
};
const doc = new Doc(["input"]);
const outputAccessor = generateCheck(doc, ctx, schema, "input", !options?.assertOnly);
doc.write(outputAccessor === null ? `return true;` : `return ${outputAccessor};`);
const constantNames = ["INVALID", ...ctx.constants.keys()];
const constantValues = [INVALID, ...ctx.constants.values()];
const code = doc.content.join("\n");
const fullCode = options?.debug ? constantNames.length > 0 ? `// Constants: ${constantNames.join(", ")}\n${code}` : code : "";
const F = Function;
const factoryCode = `return (input) => {\n${code}\n}`;
let fn;
try {
fn = new F(...constantNames, factoryCode)(...constantValues);
} catch (err) {
throw new ZodCompileUnsupportedError(`this schema (generated code failed to evaluate: ${err.message})`);
}
if (options?.debug) fn.code = fullCode;
fn.definite = ctx.definite;
return fn;
}
function addConstant(ctx, value) {
for (const [name, v] of ctx.constants) if (v === value) return name;
const name = `c${ctx.constantCounter++}`;
ctx.constants.set(name, value);
return name;
}
function addUserConstant(ctx, fn) {
ctx.definite = false;
return addConstant(ctx, fn);
}
function newVar(ctx) {
return `v${ctx.varCounter++}`;
}
function runtimeRun(schema, value) {
const result = schema._zod.run({
value,
issues: []
}, {});
if (result && typeof result.then === "function") return INVALID;
const r = result;
return r.issues.length === 0 ? r.value : INVALID;
}
function compileChild(doc, ctx, schema, accessor, needsValue = true) {
const contentLen = doc.content.length;
const constantCount = ctx.constants.size;
const constantCounter = ctx.constantCounter;
const varCounter = ctx.varCounter;
try {
return generateCheck(doc, ctx, schema, accessor, needsValue);
} catch (err) {
if (!(err instanceof ZodCompileUnsupportedError) || !err.islandable) throw err;
doc.content.length = contentLen;
if (ctx.constants.size > constantCount) {
const trailing = Array.from(ctx.constants.keys()).slice(constantCount);
for (const k of trailing) ctx.constants.delete(k);
}
ctx.constantCounter = constantCounter;
ctx.varCounter = varCounter;
return emitRuntimeIsland(doc, ctx, schema, accessor);
}
}
function emitRuntimeIsland(doc, ctx, schema, accessor) {
ctx.definite = false;
const schemaConst = addConstant(ctx, schema);
const runConst = addConstant(ctx, runtimeRun);
const outVar = newVar(ctx);
doc.write(`const ${outVar} = ${runConst}(${schemaConst}, ${accessor});`);
doc.write(`if (${outVar} === INVALID) return INVALID;`);
return outVar;
}
const WHEN_DEFAULTED_CHECKS = new Set([
"max_size",
"min_size",
"size_equals",
"max_length",
"min_length",
"length_equals"
]);
function generateChecks(doc, ctx, schema, accessor) {
const schemaChecks = schema._zod.def.checks;
if (!schemaChecks || schemaChecks.length === 0) return accessor;
let currentAccessor = accessor;
for (const check of schemaChecks) {
const def = check._zod.def;
if (def.when && !WHEN_DEFAULTED_CHECKS.has(def.check)) throw new ZodCompileUnsupportedError(`check with a custom "when" condition`);
switch (def.check) {
case "greater_than":
generateGreaterThanCheck(doc, ctx, def, currentAccessor);
break;
case "less_than":
generateLessThanCheck(doc, ctx, def, currentAccessor);
break;
case "multiple_of":
generateMultipleOfCheck(doc, ctx, def, currentAccessor);
break;
case "number_format":
generateNumberFormatCheck(doc, def, currentAccessor);
break;
case "min_length": {
const min = numericOperand(def.minimum, "min_length");
const len = codePointLengthVar(doc, ctx, currentAccessor, `${currentAccessor}.length >= ${min} && ${currentAccessor}.length < ${def.minimum * 2}`);
doc.write(`if (${len} < ${min}) return INVALID;`);
break;
}
case "max_length": {
const max = numericOperand(def.maximum, "max_length");
const len = codePointLengthVar(doc, ctx, currentAccessor, `${currentAccessor}.length > ${max}`);
doc.write(`if (${len} > ${max}) return INVALID;`);
break;
}
case "length_equals": {
const exact = numericOperand(def.length, "length_equals");
const len = codePointLengthVar(doc, ctx, currentAccessor, `${currentAccessor}.length >= ${exact} && ${currentAccessor}.length <= ${def.length * 2}`);
doc.write(`if (${len} !== ${exact}) return INVALID;`);
break;
}
case "min_size":
doc.write(`if (${currentAccessor}.size < ${numericOperand(def.minimum, "min_size")}) return INVALID;`);
break;
case "max_size":
doc.write(`if (${currentAccessor}.size > ${numericOperand(def.maximum, "max_size")}) return INVALID;`);
break;
case "size_equals":
doc.write(`if (${currentAccessor}.size !== ${numericOperand(def.size, "size_equals")}) return INVALID;`);
break;
case "string_format":
currentAccessor = generateStringFormatCheck(doc, ctx, def, currentAccessor);
break;
case "custom":
currentAccessor = generateCustomRefineCheck(doc, ctx, check, currentAccessor);
break;
case "bigint_format":
generateBigIntFormatCheck(doc, def, currentAccessor);
break;
case "mime_type":
generateMimeTypeCheck(doc, ctx, def, currentAccessor);
break;
case "property":
generatePropertyCheck(doc, ctx, def, currentAccessor);
break;
case "properties":
generatePropertiesChecks(doc, ctx, def, currentAccessor);
break;
case "overwrite": {
const newAccessor = newVar(ctx);
generateOverwriteCheck(doc, ctx, check, currentAccessor, newAccessor);
currentAccessor = newAccessor;
break;
}
default: throw new ZodCompileUnsupportedError(`check type ${def.check}`);
}
}
return currentAccessor;
}
function codePointLengthVar(doc, ctx, accessor, inDoubt) {
const cpLen = addConstant(ctx, codePointLength);
const v = newVar(ctx);
doc.write(`const ${v} = typeof ${accessor} === "string" && ${inDoubt} ? ${cpLen}(${accessor}) : ${accessor}.length;`);
return v;
}
function numericOperand(value, label) {
if (typeof value !== "number" || !Number.isFinite(value)) throw new ZodCompileUnsupportedError(`${label} bound of type ${typeof value}`);
return `${value}`;
}
function comparisonOperand(ctx, value) {
if (typeof value === "bigint") return `${value}n`;
if (typeof value === "number") {
if (Number.isNaN(value)) throw new ZodCompileUnsupportedError("comparison check with NaN bound");
return `${value}`;
}
if (value instanceof Date) {
if (Number.isNaN(value.getTime())) throw new ZodCompileUnsupportedError("comparison check with Invalid Date bound");
return addConstant(ctx, value);
}
throw new ZodCompileUnsupportedError(`comparison check bound of type ${typeof value}`);
}
function generateGreaterThanCheck(doc, ctx, def, accessor) {
const op = def.inclusive ? "<" : "<=";
doc.write(`if (${accessor} ${op} ${comparisonOperand(ctx, def.value)}) return INVALID;`);
}
function generateLessThanCheck(doc, ctx, def, accessor) {
const op = def.inclusive ? ">" : ">=";
doc.write(`if (${accessor} ${op} ${comparisonOperand(ctx, def.value)}) return INVALID;`);
}
function generateMultipleOfCheck(doc, ctx, def, accessor) {
if (typeof def.value === "bigint") {
if (def.value === BigInt(0)) throw new ZodCompileUnsupportedError("multiple_of check with a zero divisor");
doc.write(`if (${accessor} % ${def.value}n !== 0n) return INVALID;`);
} else {
const remainder = addConstant(ctx, floatSafeRemainder);
doc.write(`if (${remainder}(${accessor}, ${numericOperand(def.value, "multiple_of")}) !== 0) return INVALID;`);
}
}
function generateNumberFormatCheck(doc, def, accessor) {
const format = def.format;
switch (format) {
case "safeint":
doc.write(`if (!Number.isSafeInteger(${accessor})) return INVALID;`);
break;
case "int32":
doc.write(`if (!Number.isInteger(${accessor}) || ${accessor} < -2147483648 || ${accessor} > 2147483647) return INVALID;`);
break;
case "uint32":
doc.write(`if (!Number.isInteger(${accessor}) || ${accessor} < 0 || ${accessor} > 4294967295) return INVALID;`);
break;
case "float32":
doc.write(`if (!Number.isFinite(${accessor}) || ${accessor} < -3.4028234663852886e38 || ${accessor} > 3.4028234663852886e38) return INVALID;`);
break;
case "float64":
doc.write(`if (!Number.isFinite(${accessor})) return INVALID;`);
break;
default: throw new ZodCompileUnsupportedError(`number format ${format}`);
}
}
function generateBigIntFormatCheck(doc, def, accessor) {
const format = def.format;
if (!format) return;
switch (format) {
case "int64":
doc.write(`if (${accessor} < -9223372036854775808n || ${accessor} > 9223372036854775807n) return INVALID;`);
break;
case "uint64":
doc.write(`if (${accessor} < 0n || ${accessor} > 18446744073709551615n) return INVALID;`);
break;
default: throw new ZodCompileUnsupportedError(`bigint format ${format}`);
}
}
function generateMimeTypeCheck(doc, ctx, def, accessor) {
const mimeTypes = def.mime;
if (mimeTypes && mimeTypes.length > 0) {
const mimeSet = addConstant(ctx, new Set(mimeTypes));
doc.write(`if (!${mimeSet}.has(${accessor}.type)) return INVALID;`);
}
}
function generatePropertiesChecks(doc, ctx, def, accessor) {
if (def.when) throw new ZodCompileUnsupportedError(`check with a custom "when" condition`);
doc.write(`if (${accessor} == null) return INVALID;`);
const shape = def.shape;
for (const key of Reflect.ownKeys(shape)) {
const keyExpr = typeof key === "symbol" ? addConstant(ctx, key) : esc(key);
const inputVar = newVar(ctx);
doc.write(`const ${inputVar} = ${accessor}[${keyExpr}];`);
compileChild(doc, ctx, shape[key], inputVar, false);
}
}
function generatePropertyCheck(doc, ctx, def, accessor) {
const propAccessor = `${accessor}[${JSON.stringify(def.property)}]`;
generateCheck(doc, ctx, def.schema, propAccessor);
}
function generateOverwriteCheck(doc, ctx, check, currentAccessor, newAccessor) {
const tx = check._zod.def.tx;
if (!tx) throw new ZodCompileUnsupportedError("overwrite check without a transform function");
if (isAsyncFunction(tx)) throw new ZodCompileAsyncError("z.compile: async overwrite transforms are not supported");
const txConst = addConstant(ctx, tx);
doc.write(`const ${newAccessor} = ${txConst}(${currentAccessor});`);
}
function throwAsync() {
throw new $ZodAsyncError();
}
function pushIssue(issue) {
this.issues.push(issue);
}
function generateCustomRefineCheck(doc, ctx, check, accessor) {
const def = check._zod.def;
if (def.fn) {
if (isAsyncFunction(def.fn)) throw new ZodCompileAsyncError("z.compile: async .refine() predicates are not supported");
const fnConst = addUserConstant(ctx, def.fn);
const throwAsyncConst = addConstant(ctx, throwAsync);
const resVar = newVar(ctx);
doc.write(`const ${resVar} = ${fnConst}(${accessor});`);
doc.write(`if (${resVar} instanceof Promise) ${throwAsyncConst}();`);
doc.write(`if (!${resVar}) return INVALID;`);
return accessor;
}
if (check._zod.check) {
if (isAsyncFunction(check._zod.check)) throw new ZodCompileAsyncError("z.compile: async .superRefine() / check functions are not supported");
const checkFn = check._zod.check;
const helperFn = (value) => {
const fakePayload = {
value,
issues: [],
addIssue: pushIssue
};
if (checkFn(fakePayload) instanceof Promise) throwAsync();
return fakePayload.issues.length === 0 ? fakePayload.value : INVALID;
};
const helperConst = addUserConstant(ctx, helperFn);
const outVar = newVar(ctx);
doc.write(`const ${outVar} = ${helperConst}(${accessor});`);
doc.write(`if (${outVar} === INVALID) return INVALID;`);
return outVar;
}
throw new ZodCompileUnsupportedError("custom check without a predicate or check function");
}
const PATTERN_IS_COMPLETE = new Set([
"cidrv4",
"cuid",
"cuid2",
"date",
"datetime",
"duration",
"e164",
"email",
"emoji",
"ends_with",
"guid",
"includes",
"ipv4",
"ksuid",
"lowercase",
"mac",
"nanoid",
"regex",
"starts_with",
"time",
"ulid",
"uppercase",
"uuid",
"xid"
]);
function generateStringFormatCheck(doc, ctx, def, accessor, needsValue = true) {
const fmt = def.format;
if (fmt === "base64") {
const validator = addConstant(ctx, isValidBase64);
doc.write(`if (!${validator}(${accessor})) return INVALID;`);
return accessor;
}
if (fmt === "base64url") {
const validator = addConstant(ctx, isValidBase64URL);
doc.write(`if (!${validator}(${accessor})) return INVALID;`);
return accessor;
}
if (fmt === "jwt") {
const validator = addConstant(ctx, isValidJWT);
const alg = addConstant(ctx, def.alg ?? null);
doc.write(`if (!${validator}(${accessor}, ${alg})) return INVALID;`);
return accessor;
}
if (fmt === "ipv6") {
const validator = addConstant(ctx, isValidIPv6);
doc.write(`if (!${validator}(${accessor})) return INVALID;`);
return accessor;
}
if (fmt === "cidrv6") {
const validator = addConstant(ctx, isValidCIDRv6);
doc.write(`if (!${validator}(${accessor})) return INVALID;`);
return accessor;
}
if (fmt === "credit_card") {
const validator = addConstant(ctx, isValidCreditCard);
doc.write(`if (!${validator}(${accessor})) return INVALID;`);
return accessor;
}
if (fmt === "iban") {
const validator = addConstant(ctx, isValidIBAN);
doc.write(`if (!${validator}(${accessor})) return INVALID;`);
return accessor;
}
const formatDef = def;
if (fmt === "url" || fmt === "httpurl" || formatDef.normalize || formatDef.hostname !== void 0 || formatDef.protocol !== void 0) {
const parseConst = addConstant(ctx, validateURL);
const defConst = addConstant(ctx, def);
const trimVar = newVar(ctx);
const urlVar = newVar(ctx);
doc.write(`const ${trimVar} = ${accessor}.trim();`);
doc.write(`const ${urlVar} = ${parseConst}(${trimVar}, ${defConst});`);
doc.write(`if (typeof ${urlVar} === "number") return INVALID;`);
if (formatDef.hostname !== void 0) {
const hostnameConst = addConstant(ctx, urlHostnameOk);
doc.write(`if (!${hostnameConst}(${urlVar}, ${defConst}.hostname)) return INVALID;`);
}
if (formatDef.protocol !== void 0) {
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};`);
return outputVar;
}
const customFn = def.fn;
if (customFn) {
if (isAsyncFunction(customFn)) throw new ZodCompileUnsupportedError(`async string format ${fmt}`);
const fnConst = addConstant(ctx, customFn);
doc.write(`if (!${fnConst}(${accessor})) return INVALID;`);
return accessor;
}
if (PATTERN_IS_COMPLETE.has(fmt) && def.pattern) {
const patternConst = addConstant(ctx, def.pattern);
doc.write(`${patternConst}.lastIndex = 0;`);
doc.write(`if (!${patternConst}.test(${accessor})) return INVALID;`);
return accessor;
}
const format = def.format;
switch (format) {
case "regex": throw new ZodCompileUnsupportedError("regex format without a pattern");
case "lowercase":
doc.write(`if (${accessor} !== ${accessor}.toLowerCase()) return INVALID;`);
break;
case "uppercase":
doc.write(`if (${accessor} !== ${accessor}.toUpperCase()) return INVALID;`);
break;
case "includes":
doc.write(`if (!${accessor}.includes(${esc(def.includes)})) return INVALID;`);
break;
case "starts_with": {
const prefix = def.prefix;
doc.write(`if (${accessor}.slice(0, ${prefix.length}) !== ${esc(prefix)}) return INVALID;`);
break;
}
case "ends_with": {
const suffix = def.suffix;
doc.write(`if (${accessor}.slice(-${suffix.length}) !== ${esc(suffix)}) return INVALID;`);
break;
}
default: throw new ZodCompileUnsupportedError(`string format ${format}`);
}
return accessor;
}
function generateCheck(doc, ctx, schema, accessor, needsValue = true) {
const def = schema._zod.def;
const type = def.type;
if (def.coerce) throw new ZodCompileUnsupportedError(`coercion (z.coerce.${type}())`);
const buildsValue = needsValue || !!def.checks?.length;
let typeAccessor;
switch (type) {
case "string":
typeAccessor = generateStringCheck(doc, ctx, schema, accessor, buildsValue);
break;
case "number":
typeAccessor = generateNumberCheck(doc, schema, accessor);
break;
case "boolean":
typeAccessor = generateBooleanCheck(doc, accessor);
break;
case "bigint":
typeAccessor = generateBigIntCheck(doc, schema, accessor);
break;
case "symbol":
typeAccessor = generateSymbolCheck(doc, accessor);
break;
case "undefined":
typeAccessor = generateUndefinedCheck(doc, accessor);
break;
case "null":
typeAccessor = generateNullCheck(doc, accessor);
break;
case "any":
case "unknown":
typeAccessor = accessor;
break;
case "never":
doc.write("return INVALID;");
typeAccessor = accessor;
break;
case "void":
typeAccessor = generateVoidCheck(doc, accessor);
break;
case "nan":
typeAccessor = generateNaNCheck(doc, accessor);
break;
case "date":
typeAccessor = generateDateCheck(doc, accessor);
break;
case "object":
typeAccessor = generateObjectCheck(doc, ctx, schema, accessor, buildsValue);
break;
case "optional":
typeAccessor = generateOptionalCheck(doc, ctx, schema, accessor, buildsValue);
break;
case "nullable":
typeAccessor = generateNullableCheck(doc, ctx, schema, accessor, buildsValue);
break;
case "array":
typeAccessor = generateArrayCheck(doc, ctx, schema, accessor, buildsValue);
break;
case "literal":
typeAccessor = generateLiteralCheck(doc, ctx, schema, accessor);
break;
case "enum":
typeAccessor = generateEnumCheck(doc, ctx, schema, accessor);
break;
case "readonly": {
const innerOut = generateWrapperCheck(doc, ctx, schema, accessor);
const frozenVar = newVar(ctx);
doc.write(`const ${frozenVar} = Object.freeze(${innerOut});`);
typeAccessor = frozenVar;
break;
}
case "success":
generateWrapperCheck(doc, ctx, schema, accessor);
typeAccessor = "true";
break;
case "default":
case "prefault":
typeAccessor = generateDefaultCheck(doc, ctx, schema, accessor);
break;
case "nonoptional":
typeAccessor = generateNonOptionalCheck(doc, ctx, schema, accessor);
break;
case "tuple":
typeAccessor = generateTupleCheck(doc, ctx, schema, accessor);
break;
case "union":
typeAccessor = generateUnionCheck(doc, ctx, schema, accessor);
break;
case "intersection":
typeAccessor = generateIntersectionCheck(doc, ctx, schema, accessor);
break;
case "record":
typeAccessor = generateRecordCheck(doc, ctx, schema, accessor);
break;
case "map":
typeAccessor = generateMapCheck(doc, ctx, schema, accessor);
break;
case "set":
typeAccessor = generateSetCheck(doc, ctx, schema, accessor);
break;
case "file":
typeAccessor = generateFileCheck(doc, accessor);
break;
case "template_literal":
typeAccessor = generateTemplateLiteralCheck(doc, ctx, schema, accessor);
break;
case "lazy":
typeAccessor = generateLazyCheck(doc, ctx, schema, accessor);
break;
case "pipe":
typeAccessor = generatePipeCheck(doc, ctx, schema, accessor);
break;
case "custom":
typeAccessor = generateCustomCheck(doc, ctx, schema, accessor);
break;
case "transform":
typeAccessor = generateTransformCheck(doc, ctx, schema, accessor);
break;
case "catch":
typeAccessor = generateCatchCheck(doc, ctx, schema, accessor);
break;
default: throw new ZodCompileUnsupportedError(`schema type ${type}`);
}
if (typeAccessor === null) return null;
return generateChecks(doc, ctx, schema, typeAccessor);
}
function generateStringCheck(doc, ctx, schema, accessor, needsValue = true) {
doc.write(`if (typeof ${accessor} !== "string") return INVALID;`);
const def = schema._zod.def;
if (def.format === void 0) return accessor;
return generateStringFormatCheck(doc, ctx, def, accessor, needsValue);
}
function generateNumberCheck(doc, schema, accessor) {
doc.write(`if (typeof ${accessor} !== "number" || !Number.isFinite(${accessor})) return INVALID;`);
const def = schema._zod.def;
if (def.check === "number_format" && def.format) generateNumberFormatCheck(doc, { format: def.format }, accessor);
return accessor;
}
function generateBooleanCheck(doc, accessor) {
doc.write(`if (typeof ${accessor} !== "boolean") return INVALID;`);
return accessor;
}
function generateBigIntCheck(doc, schema, accessor) {
doc.write(`if (typeof ${accessor} !== "bigint") return INVALID;`);
const def = schema._zod.def;
if (def.format) switch (def.format) {
case "int64":
doc.write(`if (${accessor} < -9223372036854775808n || ${accessor} > 9223372036854775807n) return INVALID;`);
break;
case "uint64": doc.write(`if (${accessor} < 0n || ${accessor} > 18446744073709551615n) return INVALID;`);
}
return accessor;
}
function generateSymbolCheck(doc, accessor) {
doc.write(`if (typeof ${accessor} !== "symbol") return INVALID;`);
return accessor;
}
function generateUndefinedCheck(doc, accessor) {
doc.write(`if (${accessor} !== undefined) return INVALID;`);
return accessor;
}
function generateNullCheck(doc, accessor) {
doc.write(`if (${accessor} !== null) return INVALID;`);
return accessor;
}
function generateVoidCheck(doc, accessor) {
doc.write(`if (${accessor} !== undefined) return INVALID;`);
return accessor;
}
function generateNaNCheck(doc, accessor) {
doc.write(`if (typeof ${accessor} !== "number" || !Number.isNaN(${accessor})) return INVALID;`);
return accessor;
}
function generateDateCheck(doc, accessor) {
doc.write(`if (!(${accessor} instanceof Date) || Number.isNaN(${accessor}.getTime())) return INVALID;`);
return accessor;
}
function generateObjectCheck(doc, ctx, schema, accessor, buildsValue = true) {
const def = schema._zod.def;
doc.write(`if (typeof ${accessor} !== "object" || ${accessor} === null || Array.isArray(${accessor})) return INVALID;`);
const shape = def.shape;
const keys = Object.keys(shape);
const symbolKeys = Object.getOwnPropertySymbols(shape);
const allKeys = symbolKeys.length ? [...keys, ...symbolKeys] : keys;
const keyExpr = (k) => typeof k === "symbol" ? addConstant(ctx, k) : esc(k);
const propKey = (k) => typeof k === "symbol" ? `[${keyExpr(k)}]` : esc(k);
const propShape = shape;
if (keys.includes("__proto__")) throw new ZodCompileUnsupportedError("object shape key \"__proto__\"");
const propOutputs = new Map();
for (const key of allKeys) {
const propSchema = propShape[key];
const kx = keyExpr(key);
const inputVar = newVar(ctx);
doc.write(`const ${inputVar} = ${accessor}[${kx}];`);
if (propSchema._zod.optin !== void 0) {
const outputVar = newVar(ctx);
doc.write(`let ${outputVar} = (() => {`);
doc.indented((d) => {
const outputAccessor = compileChild(d, ctx, propSchema, inputVar);
d.write(`return ${outputAccessor};`);
});
doc.write(`})();`);
if (propSchema._zod.optout === "optional") {
doc.write(`if (${outputVar} === INVALID) {`);
doc.indented((d) => {
d.write(`if (${kx} in ${accessor}) return INVALID;`);
d.write(`${outputVar} = undefined;`);
});
doc.write(`}`);
} else doc.write(`if (${outputVar} === INVALID) return INVALID;`);
propOutputs.set(key, outputVar);
} else {
if (requiresPresenceCheck(propSchema)) doc.write(`if (!(${kx} in ${accessor})) return INVALID;`);
const outputAccessor = compileChild(doc, ctx, propSchema, inputVar, buildsValue);
if (outputAccessor !== null) propOutputs.set(key, outputAccessor);
}
}
const catchall = def.catchall;
let unknownKeysMode = "none";
if (catchall) {
const catchallType = catchall._zod.def.type;
if (catchallType === "never") {
const condition = keys.map((k) => `k !== ${esc(k)}`).join(" && ") || "true";
doc.write(`for (const k in ${accessor}) {`);
doc.indented((d) => {
d.write(`if (${condition}) return INVALID;`);
});
doc.write(`}`);
} else if ((catchallType === "unknown" || catchallType === "any") && !catchall._zod.def.checks?.length) unknownKeysMode = "passthrough";
else unknownKeysMode = "schema";
}
const outputVar = newVar(ctx);
const hasConditionalKeys = allKeys.some((k) => mayOmitUndefined(propShape[k]) || dropsWhenAbsent(propShape[k]));
if (!buildsValue) {
if (unknownKeysMode === "schema") {
const knownSet = keys.length > 0 ? addConstant(ctx, new Set(keys)) : null;
doc.write(`for (const k in ${accessor}) {`);
doc.indented((d) => {
d.write(`if (k === "__proto__") continue;`);
if (knownSet) d.write(`if (${knownSet}.has(k)) continue;`);
const valVar = newVar(ctx);
d.write(`const ${valVar} = ${accessor}[k];`);
compileChild(d, ctx, catchall, valVar, false);
});
doc.write(`}`);
}
return null;
}
if (!hasConditionalKeys) {
const propLiterals = allKeys.map((k) => `${propKey(k)}: ${propOutputs.get(k)}`).join(", ");
doc.write(`const ${outputVar} = { ${propLiterals} };`);
} else {
doc.write(`const ${outputVar} = {};`);
for (const k of allKeys) {
const kx = keyExpr(k);
const out = propOutputs.get(k);
if (dropsWhenAbsent(propShape[k])) doc.write(`if (${kx} in ${accessor}) ${outputVar}[${kx}] = ${out};`);
else if (mayOmitUndefined(propShape[k])) doc.write(`if (${out} !== undefined || ${kx} in ${accessor}) ${outputVar}[${kx}] = ${out};`);
else doc.write(`${outputVar}[${kx}] = ${out};`);
}
}
if (unknownKeysMode !== "none") {
const knownSet = keys.length > 0 ? addConstant(ctx, new Set(keys)) : null;
doc.write(`for (const k in ${accessor}) {`);
doc.indented((d) => {
d.write(`if (k === "__proto__") continue;`);
if (knownSet) d.write(`if (${knownSet}.has(k)) continue;`);
if (unknownKeysMode === "passthrough") d.write(`${outputVar}[k] = ${accessor}[k];`);
else {
const valVar = newVar(ctx);
d.write(`const ${valVar} = ${accessor}[k];`);
const catchallOut = compileChild(d, ctx, catchall, valVar);
d.write(`${outputVar}[k] = ${catchallOut};`);
}
});
doc.write(`}`);
}
return outputVar;
}
function generateOptionalCheck(doc, ctx, schema, accessor, buildsValue = true) {
const def = schema._zod.def;
if (isExactOptional(schema)) return generateCheck(doc, ctx, def.innerType, accessor, buildsValue);
if (def.innerType._zod.optin === "defaulted") {
const outputVar = newVar(ctx);
const branchVar = newVar(ctx);
doc.write(`let ${outputVar};`);
doc.write(`if (${accessor} === undefined) {`);
doc.indented((d) => {
d.write(`const ${branchVar} = (() => {`);
d.indented((d2) => {
const innerOutput = generateCheck(d2, ctx, def.innerType, accessor);
d2.write(`return ${innerOutput};`);
});
d.write(`})();`);
d.write(`if (${branchVar} !== INVALID) ${outputVar} = ${branchVar};`);
});
doc.write(`} else {`);
doc.indented((d) => {
const innerOutput = generateCheck(d, ctx, def.innerType, accessor);
d.write(`${outputVar} = ${innerOutput};`);
});
doc.write(`}`);
return outputVar;
}
const outputVar = buildsValue ? newVar(ctx) : null;
if (outputVar) doc.write(`let ${outputVar};`);
doc.write(`if (${accessor} !== undefined) {`);
doc.indented((d) => {
const innerOutput = generateCheck(d, ctx, def.innerType, accessor, buildsValue);
if (outputVar && innerOutput !== null) d.write(`${outputVar} = ${innerOutput};`);
});
doc.write(`}`);
return outputVar;
}
function isExactOptional(schema) {
return schema._zod.traits?.has("$ZodExactOptional") === true;
}
function requiresPresenceCheck(schema) {
return schema._zod.optin === void 0 && fastPathAcceptsAbsence(schema);
}
function fastPathAcceptsAbsence(schema) {
if (schema._zod.def.coerce) return true;
const def = schema._zod.def;
switch (def.type) {
case "any":
case "unknown":
case "undefined":
case "void":
case "default":
case "prefault":
case "transform":
case "custom":
case "lazy": return true;
case "string":
case "number":
case "boolean":
case "bigint":
case "symbol":
case "null":
case "never":
case "nan":
case "date":
case "object":
case "array":
case "tuple":
case "record":
case "map":
case "set":
case "file":
case "template_literal": return false;
case "nonoptional": return def.innerType ? fastPathAcceptsAbsence(def.innerType) : false;
case "literal": return !!def.values?.includes(void 0);
case "enum": return !!schema._zod.values?.has(void 0);
case "optional":
case "nullable":
case "readonly":
case "success": return def.innerType ? fastPathAcceptsAbsence(def.innerType) : true;
case "catch": return true;
case "union": return def.options ? def.options.some(fastPathAcceptsAbsence) : true;
case "intersection":
if (!def.left || !def.right) return true;
return fastPathAcceptsAbsence(def.left) && fastPathAcceptsAbsence(def.right);
case "pipe": return def.in ? fastPathAcceptsAbsence(def.in) : true;
default: return true;
}
}
function dropsWhenAbsent(schema) {
return schema._zod.optin === "optional" && schema._zod.optout === "optional";
}
function mayOmitUndefined(schema) {
return (schema._zod.optin !== "defaulted" || schema._zod.optout === "optional") && mayOutputUndefined(schema);
}
function mayOutputUndefined(schema) {
const def = schema._zod.def;
switch (def.type) {
case "string":
case "number":
case "boolean":
case "bigint":
case "symbol":
case "null":
case "nan":
case "date":
case "object":
case "array":
case "tuple":
case "record":
case "map":
case "set":
case "file":
case "template_literal":
case "never":
case "success": return false;
case "literal": return !!def.values?.includes(void 0);
case "enum": return !!schema._zod.values?.has(void 0);
case "optional": return true;
case "nullable":
case "readonly":
case "nonoptional": return def.innerType ? mayOutputUndefined(def.innerType) : true;
case "union": return def.options ? def.options.some(mayOutputUndefined) : true;
case "intersection": return !def.left || !def.right || mayOutputUndefined(def.left) || mayOutputUndefined(def.right);
case "pipe": return def.out ? mayOutputUndefined(def.out) : true;
default: return true;
}
}
function generateNullableCheck(doc, ctx, schema, accessor, buildsValue = true) {
const def = schema._zod.def;
const outputVar = buildsValue ? newVar(ctx) : null;
if (outputVar) doc.write(`let ${outputVar} = null;`);
doc.write(`if (${accessor} !== null) {`);
doc.indented((d) => {
const innerOutput = generateCheck(d, ctx, def.innerType, accessor, buildsValue);
if (outputVar && innerOutput !== null) d.write(`${outputVar} = ${innerOutput};`);
});
doc.write(`}`);
return outputVar;
}
function generateArrayCheck(doc, ctx, schema, accessor, buildsValue = true) {
const def = schema._zod.def;
doc.write(`if (!Array.isArray(${accessor})) return INVALID;`);
const outputVar = buildsValue ? newVar(ctx) : null;
const iVar = newVar(ctx);
const elemVar = newVar(ctx);
if (outputVar) doc.write(`const ${outputVar} = new Array(${accessor}.length);`);
doc.write(`for (let ${iVar} = 0; ${iVar} < ${accessor}.length; ${iVar}++) {`);
doc.indented((d) => {
d.write(`const ${elemVar} = ${accessor}[${iVar}];`);
const elemOutput = compileChild(d, ctx, def.element, elemVar, buildsValue);
if (outputVar && elemOutput !== null) d.write(`${outputVar}[${iVar}] = ${elemOutput};`);
});
doc.write(`}`);
return outputVar;
}
function generateLiteralCheck(doc, ctx, schema, accessor) {
const values = schema._zod.def.values;
if (values.length !== 1) {
const literalSet = addConstant(ctx, new Set(values));
doc.write(`if (!${literalSet}.has(${accessor})) return INVALID;`);
return accessor;
}
const value = values[0];
if (typeof value === "number" && Number.isNaN(value)) {
const literalSet = addConstant(ctx, new Set(values));
doc.write(`if (!${literalSet}.has(${accessor})) return INVALID;`);
return accessor;
}
if (typeof value === "string") doc.write(`if (${accessor} !== ${esc(value)}) return INVALID;`);
else if (typeof value === "number" || typeof value === "boolean") doc.write(`if (${accessor} !== ${value}) return INVALID;`);
else if (value === null) doc.write(`if (${accessor} !== null) return INVALID;`);
else if (value === void 0) doc.write(`if (${accessor} !== undefined) return INVALID;`);
else if (typeof value === "bigint") doc.write(`if (${accessor} !== ${value}n) return INVALID;`);
else throw new ZodCompileUnsupportedError(`literal type ${typeof value}`);
return accessor;
}
function generateEnumCheck(doc, ctx, schema, accessor) {
const values = schema._zod.values;
if (!values) throw new ZodCompileUnsupportedError("enum schema without enumerated values");
const enumSet = addConstant(ctx, values);
doc.write(`if (!${enumSet}.has(${accessor})) return INVALID;`);
return accessor;
}
function generateWrapperCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
return generateCheck(doc, ctx, def.innerType, accessor);
}
function generateDefaultCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
const defaultGetter = Object.getOwnPropertyDescriptor(schema._zod.def, "defaultValue") ? () => schema._zod.def.defaultValue : void 0;
if (schema._zod.def.type === "prefault") {
if (!defaultGetter) return generateCheck(doc, ctx, def.innerType, accessor);
const defaultFn = addConstant(ctx, defaultGetter);
const inputVar = newVar(ctx);
doc.write(`let ${inputVar} = ${accessor};`);
doc.write(`if (${accessor} === undefined) ${inputVar} = ${defaultFn}();`);
return generateCheck(doc, ctx, def.innerType, inputVar);
}
const outputVar = newVar(ctx);
if (defaultGetter) {
const defaultFn = addConstant(ctx, defaultGetter);
const cloneFn = addConstant(ctx, shallowClone);
doc.write(`let ${outputVar};`);
doc.write(`if (${accessor} === undefined) {`);
doc.indented((d) => {
d.write(`${outputVar} = ${cloneFn}(${defaultFn}());`);
});
doc.write(`} else {`);
doc.indented((d) => {
const innerOutput = generateCheck(d, ctx, def.innerType, accessor);
d.write(`${outputVar} = ${innerOutput} === undefined ? ${cloneFn}(${defaultFn}()) : ${innerOutput};`);
});
doc.write(`}`);
} else {
doc.write(`let ${outputVar};`);
doc.write(`if (${accessor} !== undefined) {`);
doc.indented((d) => {
const innerOutput = generateCheck(d, ctx, def.innerType, accessor);
d.write(`${outputVar} = ${innerOutput};`);
});
doc.write(`}`);
}
return outputVar;
}
function generateNonOptionalCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
const innerOutput = generateCheck(doc, ctx, def.innerType, accessor);
const outputVar = newVar(ctx);
doc.write(`const ${outputVar} = ${innerOutput};`);
doc.write(`if (${outputVar} === undefined) return INVALID;`);
return outputVar;
}
function generateTupleCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
const items = def.items;
const rest = def.rest;
doc.write(`if (!Array.isArray(${accessor})) return INVALID;`);
const optinStart = getTupleOptStart(items, "optin");
const optoutStart = getTupleOptStart(items, "optout");
if (rest) doc.write(`if (${accessor}.length < ${optinStart}) return INVALID;`);
else doc.write(`if (${accessor}.length < ${optinStart} || ${accessor}.length > ${items.length}) return INVALID;`);
const outputVar = newVar(ctx);
doc.write(`const ${outputVar} = [];`);
for (let i = 0; i < items.length; i++) {
const itemSchema = items[i];
if (i >= optoutStart) {
doc.write(`if (${outputVar}.length === ${i}) {`);
doc.indented((d) => {
d.write(`if (${i} < ${accessor}.length) {`);
d.indented((d2) => {
const elemVar = newVar(ctx);
d2.write(`const ${elemVar} = ${accessor}[${i}];`);
const elemOutput = compileChild(d2, ctx, itemSchema, elemVar);
d2.write(`${outputVar}[${i}] = ${elemOutput};`);
});
d.write(`} else {`);
d.indented((d2) => {
if (dropsWhenAbsent(itemSchema)) {
d2.write(`${outputVar}.length = ${i};`);
return;
}
const elemVar = newVar(ctx);
const branchVar = newVar(ctx);
d2.write(`const ${elemVar} = undefined;`);
d2.write(`const ${branchVar} = (() => {`);
d2.indented((d3) => {
const elemOutput = compileChild(d3, ctx, itemSchema, elemVar);
d3.write(`return ${elemOutput};`);
});
d2.write(`})();`);
d2.write(`if (${branchVar} === INVALID || ${branchVar} === undefined) ${outputVar}.length = ${i};`);
d2.write(`else ${outputVar}[${i}] = ${branchVar};`);
});
d.write(`}`);
});
doc.write(`}`);
} else {
const elemVar = newVar(ctx);
doc.write(`const ${elemVar} = ${accessor}[${i}];`);
const elemOutput = compileChild(doc, ctx, itemSchema, elemVar);
doc.write(`${outputVar}[${i}] = ${elemOutput};`);
}
}
if (rest) {
const iVar = newVar(ctx);
const elemVar = newVar(ctx);
doc.write(`for (let ${iVar} = ${items.length}; ${iVar} < ${accessor}.length; ${iVar}++) {`);
doc.indented((d) => {
d.write(`const ${elemVar} = ${accessor}[${iVar}];`);
const elemOutput = compileChild(d, ctx, rest, elemVar);
d.write(`${outputVar}[${iVar}] = ${elemOutput};`);
});
doc.write(`}`);
}
return outputVar;
}
function getTupleOptStart(items, key) {
for (let i = items.length - 1; i >= 0; i--) if (!(key === "optin" ? items[i]._zod.optin !== void 0 : items[i]._zod.optout === "optional")) return i + 1;
return 0;
}
function generateUnionCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
const options = def.options;
if (def.discriminator) return generateDiscriminatedUnionCheck(doc, ctx, def, accessor);
if (def.inclusive === false) throw new ZodCompileUnsupportedError("exclusive unions (z.xor)");
if (options.length === 0) {
doc.write("return INVALID;");
return accessor;
}
if (options.length === 1) return generateCheck(doc, ctx, options[0], accessor);
if (options.every((opt) => opt._zod.def.type === "literal" && !opt._zod.def.checks?.length)) {
const valuesConst = addConstant(ctx, new Set(options.flatMap((opt) => opt._zod.def.values)));
doc.write(`if (!${valuesConst}.has(${accessor})) return INVALID;`);
return accessor;
}
const outputVar = newVar(ctx);
doc.write(`let ${outputVar};`);
for (let i = 0; i < options.length; i++) {
const opt = options[i];
if (i === 0) doc.write(`${outputVar} = (() => {`);
else doc.write(`if (${outputVar} === INVALID) ${outputVar} = (() => {`);
doc.indented((d) => {
const branchOutput = generateCheck(d, ctx, opt, accessor);
d.write(`return ${branchOutput};`);
});
doc.write(`})();`);
}
doc.write(`if (${outputVar} === INVALID) return INVALID;`);
return outputVar;
}
function generateDiscriminatedUnionCheck(doc, ctx, def, accessor) {
if (def.unionFallback) throw new ZodCompileUnsupportedError("discriminated union with unionFallback");
if (def.options.length === 0) {
doc.write("return INVALID;");
return accessor;
}
const discVar = newVar(ctx);
const outputVar = newVar(ctx);
doc.write(`const ${discVar} = ${accessor}?.[${esc(def.discriminator)}];`);
doc.write(`let ${outputVar};`);
let firstBranch = true;
const claimed = new Set();
for (const option of def.options) {
const values = option._zod.propValues?.[def.discriminator];
if (!values || values.size === 0) throw new ZodCompileUnsupportedError("discriminated union option without static discriminator values");
for (const value of values) {
if (claimed.has(value)) throw new ZodCompileUnsupportedError(`duplicate discriminator value ${String(value)}`);
claimed.add(value);
}
const conditions = Array.from(values, (value) => literalEquality(ctx, discVar, value));
const prefix = firstBranch ? "if" : "else if";
doc.write(`${prefix} (${conditions.join(" || ")}) {`);
doc.indented((d) => {
const branchOutput = generateCheck(d, ctx, option, accessor);
d.write(`${outputVar} = ${branchOutput};`);
});
doc.write(`}`);
firstBranch = false;
}
doc.write(`else { return INVALID; }`);
return outputVar;
}
function literalEquality(ctx, accessor, value) {
if (typeof value === "string") return `${accessor} === ${esc(value)}`;
if (typeof value === "number") {
if (Number.isNaN(value)) return `Number.isNaN(${accessor})`;
return `${accessor} === ${value}`;
}
if (typeof value === "boolean") return `${accessor} === ${value}`;
if (value === null) return `${accessor} === null`;
if (value === void 0) return `${accessor} === undefined`;
if (typeof value === "bigint") return `${accessor} === ${value}n`;
if (typeof value === "symbol") return `${accessor} === ${addConstant(ctx, value)}`;
throw new ZodCompileUnsupportedError(`literal discriminator value ${String(value)}`);
}
function generateIntersectionCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
ctx.definite = false;
const leftOutput = compileChild(doc, ctx, def.left, accessor);
const rightOutput = compileChild(doc, ctx, def.right, accessor);
const mergeConst = addConstant(ctx, mergeValues);
const mergedVar = newVar(ctx);
doc.write(`const ${mergedVar} = ${mergeConst}(${leftOutput}, ${rightOutput});`);
doc.write(`if (!${mergedVar}.valid) return INVALID;`);
return `${mergedVar}.data`;
}
function generateRecordCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
const isPlainObjectConst = addConstant(ctx, isPlainObject);
doc.write(`if (!${isPlainObjectConst}(${accessor})) return INVALID;`);
const outputVar = newVar(ctx);
const kVar = newVar(ctx);
const valVar = newVar(ctx);
doc.write(`const ${outputVar} = {};`);
const recordDef = def;
const keyValues = recordDef.partial ? void 0 : def.keyType._zod.values;
if (keyValues) {
const inputKeys = [];
for (const key of keyValues) {
if (!(typeof key === "string" || typeof key === "number" || typeof key === "symbol")) throw new ZodCompileUnsupportedError(`record key value ${String(key)}`);
const inputKey = typeof key === "number" ? key.toString() : key;
if (inputKey === "__proto__") throw new ZodCompileUnsupportedError("record key \"__proto__\"");
inputKeys.push(inputKey);
const keyConst = addConstant(ctx, key);
const outKey = generateCheck(doc, ctx, def.keyType, keyConst);
const valueVar = newVar(ctx);
doc.write(`const ${valueVar} = ${accessor}[${literalPropertyKey(ctx, inputKey)}];`);
const valOutput = compileChild(doc, ctx, def.valueType, valueVar);
doc.write(`${outputVar}[${outKey}] = ${valOutput};`);
}
const knownKeysConst = addConstant(ctx, new Set(inputKeys));
doc.write(`for (const ${kVar} in ${accessor}) {`);
doc.indented((d) => {
d.write(`if (${knownKeysConst}.has(${kVar})) continue;`);
if (recordDef.mode === "loose") d.write(`if (${kVar} !== "__proto__") ${outputVar}[${kVar}] = ${accessor}[${kVar}];`);
else d.write(`return INVALID;`);
});
doc.write(`}`);
return outputVar;
}
const keyDef = def.keyType._zod.def;
if (!(keyDef.type === "string" && keyDef.format === void 0 && !keyDef.coerce && (keyDef.checks?.length ?? 0) === 0)) {
const isLoose = def.mode === "loose";
const keyFn = compileFn(def.keyType);
if (keyFn.definite === false) ctx.definite = false;
const keyFast = addConstant(ctx, keyFn);
const numericConst = addConstant(ctx, number$1);
const outKeyVar = newVar(ctx);
emitOwnKeys(doc, ctx, accessor, kVar, (d) => {
d.write(`let ${outKeyVar} = ${keyFast}(${kVar});`);
d.write(`if (${outKeyVar} === INVALID && typeof ${kVar} === "string" && ${numericConst}.test(${kVar})) ${outKeyVar} = ${keyFast}(Number(${kVar}));`);
if (isLoose) d.write(`if (${outKeyVar} === INVALID) { ${outputVar}[${kVar}] = ${accessor}[${kVar}]; continue; }`);
else d.write(`if (${outKeyVar} === INVALID) return INVALID;`);
d.write(`if (${outKeyVar} === "__proto__") continue;`);
const valueVar = newVar(ctx);
d.write(`const ${valueVar} = ${accessor}[${kVar}];`);
const valOutput = compileChild(d, ctx, def.valueType, valueVar);
d.write(`${outputVar}[${outKeyVar}] = ${valOutput};`);
});
return outputVar;
}
emitOwnKeys(doc, ctx, accessor, kVar, (d) => {
d.write(`const ${valVar} = ${accessor}[${kVar}];`);
const valOutput = compileChild(d, ctx, def.valueType, valVar);
d.write(`${outputVar}[${kVar}] = ${valOutput};`);
}, `return INVALID;`);
return outputVar;
}
function emitOwnKeys(doc, ctx, accessor, kVar, body, onSymbol) {
const propIsEnumerableConst = addConstant(ctx, Object.prototype.propertyIsEnumerable);
const symsVar = newVar(ctx);
const keysVar = newVar(ctx);
const iVar = newVar(ctx);
doc.write(`const ${symsVar} = Object.getOwnPropertySymbols(${accessor});`);
doc.write(`const ${keysVar} = Object.getOwnPropertyNames(${accessor});`);
doc.write(`for (let ${iVar} = 0; ${iVar} < ${keysVar}.length; ${iVar}++) {`);
doc.indented((d) => {
d.write(`const ${kVar} = ${keysVar}[${iVar}];`);
d.write(`if (${kVar} === "__proto__" || !${propIsEnumerableConst}.call(${accessor}, ${kVar})) continue;`);
body(d);
});
doc.write(`}`);
doc.write(`for (let ${iVar} = 0; ${iVar} < ${symsVar}.length; ${iVar}++) {`);
doc.indented((d) => {
d.write(`const ${kVar} = ${symsVar}[${iVar}];`);
d.write(`if (!${propIsEnumerableConst}.call(${accessor}, ${kVar})) continue;`);
if (onSymbol) d.write(onSymbol);
else body(d);
});
doc.write(`}`);
}
function literalPropertyKey(ctx, key) {
if (typeof key === "string") return esc(key);
return addConstant(ctx, key);
}
function generateMapCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
doc.write(`if (!(${accessor} instanceof Map)) return INVALID;`);
const outputVar = newVar(ctx);
const kVar = newVar(ctx);
const valVar = newVar(ctx);
doc.write(`const ${outputVar} = new Map();`);
doc.write(`for (const [${kVar}, ${valVar}] of ${accessor}) {`);
doc.indented((d) => {
const keyOutput = generateCheck(d, ctx, def.keyType, kVar);
const valOutput = generateCheck(d, ctx, def.valueType, valVar);
d.write(`${outputVar}.set(${keyOutput}, ${valOutput});`);
});
doc.write(`}`);
return outputVar;
}
function generateSetCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
doc.write(`if (!(${accessor} instanceof Set)) return INVALID;`);
const outputVar = newVar(ctx);
const valVar = newVar(ctx);
doc.write(`const ${outputVar} = new Set();`);
doc.write(`for (const ${valVar} of ${accessor}) {`);
doc.indented((d) => {
const valOutput = generateCheck(d, ctx, def.valueType, valVar);
d.write(`${outputVar}.add(${valOutput});`);
});
doc.write(`}`);
return outputVar;
}
function generateFileCheck(doc, accessor) {
doc.write(`if (!(${accessor} instanceof File)) return INVALID;`);
return accessor;
}
function generateTemplateLiteralCheck(doc, ctx, schema, accessor) {
doc.write(`if (typeof ${accessor} !== "string") return INVALID;`);
const pattern = schema._zod.pattern;
if (pattern) {
const patternConst = addConstant(ctx, pattern);
doc.write(`${patternConst}.lastIndex = 0;`);
doc.write(`if (!${patternConst}.test(${accessor})) return INVALID;`);
}
return accessor;
}
function generateLazyCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
const getterConst = addUserConstant(ctx, def.getter);
const cacheConst = addConstant(ctx, { parser: null });
doc.write(`if (!${cacheConst}.parser) {`);
doc.indented((d) => {
d.write(`const inner = ${getterConst}();`);
d.write(`${cacheConst}.parser = function(input) {`);
d.indented((d2) => {
d2.write(`const result = inner._zod.run({ value: input, issues: [] }, {});`);
d2.write(`return result.issues.length === 0 ? result.value : INVALID;`);
});
d.write(`};`);
});
doc.write(`}`);
const outputVar = newVar(ctx);
doc.write(`const ${outputVar} = ${cacheConst}.parser(${accessor});`);
doc.write(`if (${outputVar} === INVALID) return INVALID;`);
return outputVar;
}
function generatePipeCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
const inputOutput = generateCheck(doc, ctx, def.in, accessor);
if (def.transform) {
if (isAsyncFunction(def.transform)) throw new ZodCompileAsyncError("z.compile: async transforms in pipes are not supported");
const transformFn = def.transform;
const helperFn = (value) => {
const fakePayload = {
value,
issues: [],
addIssue: pushIssue
};
const result = transformFn(value, fakePayload);
if (result instanceof Promise) return INVALID;
return fakePayload.issues.length === 0 ? result : INVALID;
};
const helperConst = addUserConstant(ctx, helperFn);
const transformedVar = newVar(ctx);
doc.write(`const ${transformedVar} = ${helperConst}(${inputOutput});`);
doc.write(`if (${transformedVar} === INVALID) return INVALID;`);
return generateCheck(doc, ctx, def.out, transformedVar);
} else return generateCheck(doc, ctx, def.out, inputOutput);
}
function isAsyncFunction(fn) {
return typeof fn === "function" && (fn.constructor.name === "AsyncFunction" || fn[Symbol.toStringTag] === "AsyncFunction");
}
function generateCustomCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
if (def.fn) {
if (isAsyncFunction(def.fn)) throw new ZodCompileAsyncError("z.compile: async custom predicates are not supported");
const fnConst = addUserConstant(ctx, def.fn);
const throwAsyncConst = addConstant(ctx, throwAsync);
const resVar = newVar(ctx);
doc.write(`const ${resVar} = ${fnConst}(${accessor});`);
doc.write(`if (${resVar} instanceof Promise) ${throwAsyncConst}();`);
doc.write(`if (!${resVar}) return INVALID;`);
} else throw new ZodCompileUnsupportedError("custom schema without a predicate function");
return accessor;
}
function runtimeCatch(innerSchema, catchValue, value) {
const result = innerSchema._zod.run({
value,
issues: []
}, {});
if (result && typeof result.then === "function") return INVALID;
const r = result;
if (r.issues.length === 0) return r.value;
return catchValue();
}
function generateCatchCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
if (!def.catchValue["~constantCatch"]) throw new ZodCompileUnsupportedError("catch with a callback (only a constant catch value compiles)", false);
const outputVar = newVar(ctx);
doc.write(`let ${outputVar} = (() => {`);
doc.indented((d) => {
const innerOut = compileChild(d, ctx, def.innerType, accessor);
d.write(`return ${innerOut};`);
});
doc.write(`})();`);
const innerConst = addConstant(ctx, def.innerType);
const catchConst = addUserConstant(ctx, def.catchValue);
const catchHelperConst = addConstant(ctx, runtimeCatch);
doc.write(`if (${outputVar} === INVALID) {`);
doc.indented((d) => {
d.write(`${outputVar} = ${catchHelperConst}(${innerConst}, ${catchConst}, ${accessor});`);
d.write(`if (${outputVar} === INVALID) return INVALID;`);
});
doc.write(`}`);
return outputVar;
}
function generateTransformCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
if (def.transform) {
if (isAsyncFunction(def.transform)) throw new ZodCompileAsyncError("z.compile: async transforms are not supported");
const transformFn = def.transform;
const helperFn = (value) => {
const fakePayload = {
value,
issues: [],
addIssue: pushIssue
};
const result = transformFn(value, fakePayload);
if (result instanceof Promise) return INVALID;
return fakePayload.issues.length === 0 ? result : INVALID;
};
const helperConst = addUserConstant(ctx, helperFn);
const outputVar = newVar(ctx);
doc.write(`const ${outputVar} = ${helperConst}(${accessor});`);
doc.write(`if (${outputVar} === INVALID) return INVALID;`);
return outputVar;
}
return accessor;
}
function snapshotChecks(def) {
if (def.checks) def.checks = [...def.checks];
return def;
}
function _string(Class, params) {
return new Class(snapshotChecks({
type: "string",
...normalizeParams(params)
}));
}
function _url(Class, params) {
return new Class({
type: "string",
format: "url",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
function _number(Class, params) {
return new Class(snapshotChecks({
type: "number",
checks: [],
...normalizeParams(params)
}));
}
function _date(Class, params) {
return new Class({
type: "date",
...normalizeParams(params)
});
}
function _lte(value, params) {
return new $ZodCheckLessThan({
check: "less_than",
...normalizeParams(params),
value,
inclusive: true
});
}
function _gte(value, params) {
return new $ZodCheckGreaterThan({
check: "greater_than",
...normalizeParams(params),
value,
inclusive: true
});
}
function _maxLength(maximum, params) {
return new $ZodCheckMaxLength({
check: "max_length",
...normalizeParams(params),
maximum
});
}
function _minLength(minimum, params) {
return new $ZodCheckMinLength({
check: "min_length",
...normalizeParams(params),
minimum
});
}
const ZodMiniType = $constructor("ZodMiniType", (inst, def) => {
if (!inst._zod) throw new Error("Uninitialized schema in ZodMiniType.");
$ZodType.init(inst, def);
inst.def = def;
inst.type = def.type;
}, {
get with() {
return this.check;
},
set with(value) {
own(this, "with", value);
},
parse(data, params) {
return parse(this, data, params, { callee: this.parse });
},
parseAsync(data, params) {
return parseAsync(this, data, params, { callee: this.parseAsync });
},
safeParse(data, params) {
return safeParse(this, data, params);
},
safeParseAsync(data, params) {
return safeParseAsync(this, data, params);
},
check(...checks) {
const def = this.def;
return this.clone({
...def,
checks: [...def.checks ?? [], ...checks.map((ch) => typeof ch === "function" ? { _zod: {
check: ch,
def: { check: "custom" },
onattach: []
} } : ch)]
}, { parent: true });
},
clone(_def, params) {
return clone(this, _def, params);
},
brand() {
return this;
},
register(reg, meta) {
reg.add(this, meta);
return this;
},
apply(fn, ...args) {
return args.length === 0 ? fn(this) : fn(this, ...args);
}
});
const ZodMiniString = $constructor("ZodMiniString", (inst, def) => {
$ZodString.init(inst, def);
ZodMiniType.init(inst, def);
});
function string(params) {
return _string(ZodMiniString, params);
}
const ZodMiniStringFormat = $constructor("ZodMiniStringFormat", (inst, def) => {
$ZodStringFormat.init(inst, def);
ZodMiniString.init(inst, def);
});
const ZodMiniURL = $constructor("ZodMiniURL", (inst, def) => {
$ZodURL.init(inst, def);
ZodMiniStringFormat.init(inst, def);
});
function url(params) {
return _url(ZodMiniURL, params);
}
const ZodMiniNumber = $constructor("ZodMiniNumber", (inst, def) => {
$ZodNumber.init(inst, def);
ZodMiniType.init(inst, def);
});
function number(params) {
return _number(ZodMiniNumber, params);
}
const ZodMiniDate = $constructor("ZodMiniDate", (inst, def) => {
$ZodDate.init(inst, def);
ZodMiniType.init(inst, def);
});
function date(params) {
return _date(ZodMiniDate, params);
}
const ZodMiniArray = $constructor("ZodMiniArray", (inst, def) => {
$ZodArray.init(inst, def);
ZodMiniType.init(inst, def);
});
function array(element, params) {
return new ZodMiniArray({
type: "array",
element,
...normalizeParams(params)
});
}
const ZodMiniObject = $constructor("ZodMiniObject", (inst, def) => {
$ZodObject.init(inst, def);
ZodMiniType.init(inst, def);
installLazyProp(inst, "shape", (self) => self._zod.def.shape, false);
});
function object(shape, params) {
const def = {
type: "object",
shape: shape ?? {},
...normalizeParams(params)
};
return new ZodMiniObject(def);
}
const ZodMiniEnum = $constructor("ZodMiniEnum", (inst, def) => {
$ZodEnum.init(inst, def);
ZodMiniType.init(inst, def);
inst.options = [...inst._zod.values];
});
function _enum(values, params) {
const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
return new ZodMiniEnum({
type: "enum",
entries,
...normalizeParams(params)
});
}
const ZodMiniNullable = $constructor("ZodMiniNullable", (inst, def) => {
$ZodNullable.init(inst, def);
ZodMiniType.init(inst, def);
});
function nullable(innerType) {
return new ZodMiniNullable({
type: "nullable",
innerType
});
}
const imageSchema = object({
id: number(),
created: date(),
title: ( string()).check( _minLength(1), _maxLength(100)),
type: _enum(["jpg", "png"]),
size: number(),
url: url()
});
const ratingSchema = object({
id: number(),
stars: ( number()).check( _gte(1), _lte(5)),
title: ( string()).check( _minLength(1), _maxLength(100)),
text: ( string()).check( _minLength(1), _maxLength(1e3)),
images: array(imageSchema)
});
compile(toZod()( object({
id: number(),
created: date(),
title: ( string()).check( _minLength(1), _maxLength(100)),
brand: ( string()).check( _minLength(1), _maxLength(30)),
description: ( string()).check( _minLength(1), _maxLength(500)),
price: ( number()).check( _gte(1), _lte(1e4)),
discount: nullable(( number()).check( _gte(1), _lte(100))),
quantity: ( number()).check( _gte(0), _lte(10)),
tags: array(( string()).check( _minLength(1), _maxLength(30))),
images: array(imageSchema),
ratings: array(ratingSchema)
})), { strict: true }).parse({});