jiayiyan
4523 lines
136 KiB
JavaScript
4523 lines
136 KiB
JavaScript
var __defProp = Object.defineProperty;
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, {
|
|
get: all[name],
|
|
enumerable: true,
|
|
configurable: true,
|
|
set: (newValue) => all[name] = () => newValue
|
|
});
|
|
};
|
|
|
|
// workflows/document-editor-entry.ts
|
|
import { createOfficeAgent } from "@uncaged/workflow-agent-office";
|
|
import { createWorkflow } from "@uncaged/workflow-runtime";
|
|
import { env } from "@uncaged/workflow-util";
|
|
|
|
// templates/document-editor/src/moderator.ts
|
|
import { END, START } from "@uncaged/workflow-runtime";
|
|
var officeIsEdit = {
|
|
name: "officeIsEdit",
|
|
description: "The office step produced an edited document (not a generated one)",
|
|
check: (ctx) => {
|
|
const officeStep = ctx.steps.find((s) => s.role === "office");
|
|
if (officeStep === undefined)
|
|
return false;
|
|
return officeStep.meta.mode === "edit";
|
|
}
|
|
};
|
|
var documentEditorTable = {
|
|
[START]: [{ condition: "FALLBACK", role: "office" }],
|
|
office: [
|
|
{ condition: officeIsEdit, role: "differ" },
|
|
{ condition: "FALLBACK", role: END }
|
|
],
|
|
differ: [{ condition: "FALLBACK", role: END }]
|
|
};
|
|
|
|
// node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/core.js
|
|
var _a;
|
|
function $constructor(name, initializer, params) {
|
|
function init(inst, def) {
|
|
if (!inst._zod) {
|
|
Object.defineProperty(inst, "_zod", {
|
|
value: {
|
|
def,
|
|
constr: _,
|
|
traits: new Set
|
|
},
|
|
enumerable: false
|
|
});
|
|
}
|
|
if (inst._zod.traits.has(name)) {
|
|
return;
|
|
}
|
|
inst._zod.traits.add(name);
|
|
initializer(inst, def);
|
|
const proto = _.prototype;
|
|
const keys = Object.keys(proto);
|
|
for (let i = 0;i < keys.length; i++) {
|
|
const k = keys[i];
|
|
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) {
|
|
var _a2;
|
|
const inst = params?.Parent ? new Definition : this;
|
|
init(inst, def);
|
|
(_a2 = inst._zod).deferred ?? (_a2.deferred = []);
|
|
for (const fn of inst._zod.deferred) {
|
|
fn();
|
|
}
|
|
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 $brand = Symbol("zod_brand");
|
|
|
|
class $ZodAsyncError extends Error {
|
|
constructor() {
|
|
super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
|
|
}
|
|
}
|
|
|
|
class $ZodEncodeError extends Error {
|
|
constructor(name) {
|
|
super(`Encountered unidirectional transform during encode: ${name}`);
|
|
this.name = "ZodEncodeError";
|
|
}
|
|
}
|
|
(_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {});
|
|
var globalConfig = globalThis.__zod_globalConfig;
|
|
function config(newConfig) {
|
|
if (newConfig)
|
|
Object.assign(globalConfig, newConfig);
|
|
return globalConfig;
|
|
}
|
|
// node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/util.js
|
|
var exports_util = {};
|
|
__export(exports_util, {
|
|
unwrapMessage: () => unwrapMessage,
|
|
uint8ArrayToHex: () => uint8ArrayToHex,
|
|
uint8ArrayToBase64url: () => uint8ArrayToBase64url,
|
|
uint8ArrayToBase64: () => uint8ArrayToBase64,
|
|
stringifyPrimitive: () => stringifyPrimitive,
|
|
slugify: () => slugify,
|
|
shallowClone: () => shallowClone,
|
|
safeExtend: () => safeExtend,
|
|
required: () => required,
|
|
randomString: () => randomString,
|
|
propertyKeyTypes: () => propertyKeyTypes,
|
|
promiseAllObject: () => promiseAllObject,
|
|
primitiveTypes: () => primitiveTypes,
|
|
prefixIssues: () => prefixIssues,
|
|
pick: () => pick,
|
|
partial: () => partial,
|
|
parsedType: () => parsedType,
|
|
optionalKeys: () => optionalKeys,
|
|
omit: () => omit,
|
|
objectClone: () => objectClone,
|
|
numKeys: () => numKeys,
|
|
nullish: () => nullish,
|
|
normalizeParams: () => normalizeParams,
|
|
mergeDefs: () => mergeDefs,
|
|
merge: () => merge,
|
|
jsonStringifyReplacer: () => jsonStringifyReplacer,
|
|
joinValues: () => joinValues,
|
|
issue: () => issue,
|
|
isPlainObject: () => isPlainObject,
|
|
isObject: () => isObject,
|
|
hexToUint8Array: () => hexToUint8Array,
|
|
getSizableOrigin: () => getSizableOrigin,
|
|
getParsedType: () => getParsedType,
|
|
getLengthableOrigin: () => getLengthableOrigin,
|
|
getEnumValues: () => getEnumValues,
|
|
getElementAtPath: () => getElementAtPath,
|
|
floatSafeRemainder: () => floatSafeRemainder,
|
|
finalizeIssue: () => finalizeIssue,
|
|
extend: () => extend,
|
|
explicitlyAborted: () => explicitlyAborted,
|
|
escapeRegex: () => escapeRegex,
|
|
esc: () => esc,
|
|
defineLazy: () => defineLazy,
|
|
createTransparentProxy: () => createTransparentProxy,
|
|
cloneDef: () => cloneDef,
|
|
clone: () => clone,
|
|
cleanRegex: () => cleanRegex,
|
|
cleanEnum: () => cleanEnum,
|
|
captureStackTrace: () => captureStackTrace,
|
|
cached: () => cached,
|
|
base64urlToUint8Array: () => base64urlToUint8Array,
|
|
base64ToUint8Array: () => base64ToUint8Array,
|
|
assignProp: () => assignProp,
|
|
assertNotEqual: () => assertNotEqual,
|
|
assertNever: () => assertNever,
|
|
assertIs: () => assertIs,
|
|
assertEqual: () => assertEqual,
|
|
assert: () => assert,
|
|
allowsEval: () => allowsEval,
|
|
aborted: () => aborted,
|
|
NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
|
|
Class: () => Class,
|
|
BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES
|
|
});
|
|
function assertEqual(val) {
|
|
return val;
|
|
}
|
|
function assertNotEqual(val) {
|
|
return val;
|
|
}
|
|
function assertIs(_arg) {}
|
|
function assertNever(_x) {
|
|
throw new Error("Unexpected value in exhaustive check");
|
|
}
|
|
function assert(_) {}
|
|
function getEnumValues(entries) {
|
|
const numericValues = Object.values(entries).filter((v) => typeof v === "number");
|
|
const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
|
|
return values;
|
|
}
|
|
function joinValues(array, separator = "|") {
|
|
return array.map((val) => stringifyPrimitive(val)).join(separator);
|
|
}
|
|
function jsonStringifyReplacer(_, value) {
|
|
if (typeof value === "bigint")
|
|
return value.toString();
|
|
return value;
|
|
}
|
|
function cached(getter) {
|
|
const set = false;
|
|
return {
|
|
get value() {
|
|
if (!set) {
|
|
const value = getter();
|
|
Object.defineProperty(this, "value", { value });
|
|
return value;
|
|
}
|
|
throw new Error("cached value already set");
|
|
}
|
|
};
|
|
}
|
|
function nullish(input) {
|
|
return input === null || input === undefined;
|
|
}
|
|
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 = Number.EPSILON * Math.max(Math.abs(ratio), 1);
|
|
if (Math.abs(ratio - roundedRatio) < tolerance)
|
|
return 0;
|
|
return ratio - roundedRatio;
|
|
}
|
|
var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
|
|
function defineLazy(object, key, getter) {
|
|
let value = undefined;
|
|
Object.defineProperty(object, key, {
|
|
get() {
|
|
if (value === EVALUATING) {
|
|
return;
|
|
}
|
|
if (value === undefined) {
|
|
value = EVALUATING;
|
|
value = getter();
|
|
}
|
|
return value;
|
|
},
|
|
set(v) {
|
|
Object.defineProperty(object, key, {
|
|
value: v
|
|
});
|
|
},
|
|
configurable: true
|
|
});
|
|
}
|
|
function objectClone(obj) {
|
|
return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
|
|
}
|
|
function assignProp(target, prop, value) {
|
|
Object.defineProperty(target, prop, {
|
|
value,
|
|
writable: true,
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
}
|
|
function mergeDefs(...defs) {
|
|
const mergedDescriptors = {};
|
|
for (const def of defs) {
|
|
const descriptors = Object.getOwnPropertyDescriptors(def);
|
|
Object.assign(mergedDescriptors, descriptors);
|
|
}
|
|
return Object.defineProperties({}, mergedDescriptors);
|
|
}
|
|
function cloneDef(schema) {
|
|
return mergeDefs(schema._zod.def);
|
|
}
|
|
function getElementAtPath(obj, path) {
|
|
if (!path)
|
|
return obj;
|
|
return path.reduce((acc, key) => acc?.[key], obj);
|
|
}
|
|
function promiseAllObject(promisesObj) {
|
|
const keys = Object.keys(promisesObj);
|
|
const promises = keys.map((key) => promisesObj[key]);
|
|
return Promise.all(promises).then((results) => {
|
|
const resolvedObj = {};
|
|
for (let i = 0;i < keys.length; i++) {
|
|
resolvedObj[keys[i]] = results[i];
|
|
}
|
|
return resolvedObj;
|
|
});
|
|
}
|
|
function randomString(length = 10) {
|
|
const chars = "abcdefghijklmnopqrstuvwxyz";
|
|
let str = "";
|
|
for (let i = 0;i < length; i++) {
|
|
str += chars[Math.floor(Math.random() * chars.length)];
|
|
}
|
|
return str;
|
|
}
|
|
function esc(str) {
|
|
return JSON.stringify(str);
|
|
}
|
|
function slugify(input) {
|
|
return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
|
|
}
|
|
var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
|
|
function isObject(data) {
|
|
return typeof data === "object" && data !== null && !Array.isArray(data);
|
|
}
|
|
var allowsEval = /* @__PURE__ */ cached(() => {
|
|
if (globalConfig.jitless) {
|
|
return false;
|
|
}
|
|
if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
|
|
return false;
|
|
}
|
|
try {
|
|
const F = Function;
|
|
new F("");
|
|
return true;
|
|
} catch (_) {
|
|
return false;
|
|
}
|
|
});
|
|
function isPlainObject(o) {
|
|
if (isObject(o) === false)
|
|
return false;
|
|
const ctor = o.constructor;
|
|
if (ctor === undefined)
|
|
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;
|
|
}
|
|
function numKeys(data) {
|
|
let keyCount = 0;
|
|
for (const key in data) {
|
|
if (Object.prototype.hasOwnProperty.call(data, key)) {
|
|
keyCount++;
|
|
}
|
|
}
|
|
return keyCount;
|
|
}
|
|
var getParsedType = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "undefined":
|
|
return "undefined";
|
|
case "string":
|
|
return "string";
|
|
case "number":
|
|
return Number.isNaN(data) ? "nan" : "number";
|
|
case "boolean":
|
|
return "boolean";
|
|
case "function":
|
|
return "function";
|
|
case "bigint":
|
|
return "bigint";
|
|
case "symbol":
|
|
return "symbol";
|
|
case "object":
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
|
|
return "promise";
|
|
}
|
|
if (typeof Map !== "undefined" && data instanceof Map) {
|
|
return "map";
|
|
}
|
|
if (typeof Set !== "undefined" && data instanceof Set) {
|
|
return "set";
|
|
}
|
|
if (typeof Date !== "undefined" && data instanceof Date) {
|
|
return "date";
|
|
}
|
|
if (typeof File !== "undefined" && data instanceof File) {
|
|
return "file";
|
|
}
|
|
return "object";
|
|
default:
|
|
throw new Error(`Unknown data type: ${t}`);
|
|
}
|
|
};
|
|
var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
|
|
var primitiveTypes = /* @__PURE__ */ new Set([
|
|
"string",
|
|
"number",
|
|
"bigint",
|
|
"boolean",
|
|
"symbol",
|
|
"undefined"
|
|
]);
|
|
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 !== undefined) {
|
|
if (params?.error !== undefined)
|
|
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 createTransparentProxy(getter) {
|
|
let target;
|
|
return new Proxy({}, {
|
|
get(_, prop, receiver) {
|
|
target ?? (target = getter());
|
|
return Reflect.get(target, prop, receiver);
|
|
},
|
|
set(_, prop, value, receiver) {
|
|
target ?? (target = getter());
|
|
return Reflect.set(target, prop, value, receiver);
|
|
},
|
|
has(_, prop) {
|
|
target ?? (target = getter());
|
|
return Reflect.has(target, prop);
|
|
},
|
|
deleteProperty(_, prop) {
|
|
target ?? (target = getter());
|
|
return Reflect.deleteProperty(target, prop);
|
|
},
|
|
ownKeys(_) {
|
|
target ?? (target = getter());
|
|
return Reflect.ownKeys(target);
|
|
},
|
|
getOwnPropertyDescriptor(_, prop) {
|
|
target ?? (target = getter());
|
|
return Reflect.getOwnPropertyDescriptor(target, prop);
|
|
},
|
|
defineProperty(_, prop, descriptor) {
|
|
target ?? (target = getter());
|
|
return Reflect.defineProperty(target, prop, descriptor);
|
|
}
|
|
});
|
|
}
|
|
function stringifyPrimitive(value) {
|
|
if (typeof value === "bigint")
|
|
return value.toString() + "n";
|
|
if (typeof value === "string")
|
|
return `"${value}"`;
|
|
return `${value}`;
|
|
}
|
|
function optionalKeys(shape) {
|
|
return Object.keys(shape).filter((k) => {
|
|
return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
|
|
});
|
|
}
|
|
var NUMBER_FORMAT_RANGES = {
|
|
safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
|
|
int32: [-2147483648, 2147483647],
|
|
uint32: [0, 4294967295],
|
|
float32: [-340282346638528860000000000000000000000, 340282346638528860000000000000000000000],
|
|
float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
|
|
};
|
|
var BIGINT_FORMAT_RANGES = {
|
|
int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")],
|
|
uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")]
|
|
};
|
|
function pick(schema, mask) {
|
|
const currDef = schema._zod.def;
|
|
const checks = currDef.checks;
|
|
const hasChecks = checks && checks.length > 0;
|
|
if (hasChecks) {
|
|
throw new Error(".pick() cannot be used on object schemas containing refinements");
|
|
}
|
|
const def = mergeDefs(schema._zod.def, {
|
|
get shape() {
|
|
const newShape = {};
|
|
for (const key in mask) {
|
|
if (!(key in currDef.shape)) {
|
|
throw new Error(`Unrecognized key: "${key}"`);
|
|
}
|
|
if (!mask[key])
|
|
continue;
|
|
newShape[key] = currDef.shape[key];
|
|
}
|
|
assignProp(this, "shape", newShape);
|
|
return newShape;
|
|
},
|
|
checks: []
|
|
});
|
|
return clone(schema, def);
|
|
}
|
|
function omit(schema, mask) {
|
|
const currDef = schema._zod.def;
|
|
const checks = currDef.checks;
|
|
const hasChecks = checks && checks.length > 0;
|
|
if (hasChecks) {
|
|
throw new Error(".omit() cannot be used on object schemas containing refinements");
|
|
}
|
|
const def = mergeDefs(schema._zod.def, {
|
|
get shape() {
|
|
const newShape = { ...schema._zod.def.shape };
|
|
for (const key in mask) {
|
|
if (!(key in currDef.shape)) {
|
|
throw new Error(`Unrecognized key: "${key}"`);
|
|
}
|
|
if (!mask[key])
|
|
continue;
|
|
delete newShape[key];
|
|
}
|
|
assignProp(this, "shape", newShape);
|
|
return newShape;
|
|
},
|
|
checks: []
|
|
});
|
|
return clone(schema, def);
|
|
}
|
|
function extend(schema, shape) {
|
|
if (!isPlainObject(shape)) {
|
|
throw new Error("Invalid input to extend: expected a plain object");
|
|
}
|
|
const checks = schema._zod.def.checks;
|
|
const hasChecks = checks && checks.length > 0;
|
|
if (hasChecks) {
|
|
const existingShape = schema._zod.def.shape;
|
|
for (const key in shape) {
|
|
if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {
|
|
throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
|
|
}
|
|
}
|
|
}
|
|
const def = mergeDefs(schema._zod.def, {
|
|
get shape() {
|
|
const _shape = { ...schema._zod.def.shape, ...shape };
|
|
assignProp(this, "shape", _shape);
|
|
return _shape;
|
|
}
|
|
});
|
|
return clone(schema, def);
|
|
}
|
|
function safeExtend(schema, shape) {
|
|
if (!isPlainObject(shape)) {
|
|
throw new Error("Invalid input to safeExtend: expected a plain object");
|
|
}
|
|
const def = mergeDefs(schema._zod.def, {
|
|
get shape() {
|
|
const _shape = { ...schema._zod.def.shape, ...shape };
|
|
assignProp(this, "shape", _shape);
|
|
return _shape;
|
|
}
|
|
});
|
|
return clone(schema, def);
|
|
}
|
|
function merge(a, b) {
|
|
if (a._zod.def.checks?.length) {
|
|
throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
|
|
}
|
|
const def = mergeDefs(a._zod.def, {
|
|
get shape() {
|
|
const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
|
|
assignProp(this, "shape", _shape);
|
|
return _shape;
|
|
},
|
|
get catchall() {
|
|
return b._zod.def.catchall;
|
|
},
|
|
checks: b._zod.def.checks ?? []
|
|
});
|
|
return clone(a, def);
|
|
}
|
|
function partial(Class, schema, mask) {
|
|
const currDef = schema._zod.def;
|
|
const checks = currDef.checks;
|
|
const hasChecks = checks && checks.length > 0;
|
|
if (hasChecks) {
|
|
throw new Error(".partial() cannot be used on object schemas containing refinements");
|
|
}
|
|
const def = mergeDefs(schema._zod.def, {
|
|
get shape() {
|
|
const oldShape = schema._zod.def.shape;
|
|
const shape = { ...oldShape };
|
|
if (mask) {
|
|
for (const key in mask) {
|
|
if (!(key in oldShape)) {
|
|
throw new Error(`Unrecognized key: "${key}"`);
|
|
}
|
|
if (!mask[key])
|
|
continue;
|
|
shape[key] = Class ? new Class({
|
|
type: "optional",
|
|
innerType: oldShape[key]
|
|
}) : oldShape[key];
|
|
}
|
|
} else {
|
|
for (const key in oldShape) {
|
|
shape[key] = Class ? new Class({
|
|
type: "optional",
|
|
innerType: oldShape[key]
|
|
}) : oldShape[key];
|
|
}
|
|
}
|
|
assignProp(this, "shape", shape);
|
|
return shape;
|
|
},
|
|
checks: []
|
|
});
|
|
return clone(schema, def);
|
|
}
|
|
function required(Class, schema, mask) {
|
|
const def = mergeDefs(schema._zod.def, {
|
|
get shape() {
|
|
const oldShape = schema._zod.def.shape;
|
|
const shape = { ...oldShape };
|
|
if (mask) {
|
|
for (const key in mask) {
|
|
if (!(key in shape)) {
|
|
throw new Error(`Unrecognized key: "${key}"`);
|
|
}
|
|
if (!mask[key])
|
|
continue;
|
|
shape[key] = new Class({
|
|
type: "nonoptional",
|
|
innerType: oldShape[key]
|
|
});
|
|
}
|
|
} else {
|
|
for (const key in oldShape) {
|
|
shape[key] = new Class({
|
|
type: "nonoptional",
|
|
innerType: oldShape[key]
|
|
});
|
|
}
|
|
}
|
|
assignProp(this, "shape", shape);
|
|
return shape;
|
|
}
|
|
});
|
|
return clone(schema, def);
|
|
}
|
|
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 _a2;
|
|
(_a2 = iss).path ?? (_a2.path = []);
|
|
iss.path.unshift(path);
|
|
return iss;
|
|
});
|
|
}
|
|
function unwrapMessage(message) {
|
|
return typeof message === "string" ? message : message?.message;
|
|
}
|
|
function finalizeIssue(iss, ctx, config2) {
|
|
const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
|
|
const { inst: _inst, continue: _continue, input: _input, ...rest } = iss;
|
|
rest.path ?? (rest.path = []);
|
|
rest.message = message;
|
|
if (ctx?.reportInput) {
|
|
rest.input = _input;
|
|
}
|
|
return rest;
|
|
}
|
|
function getSizableOrigin(input) {
|
|
if (input instanceof Set)
|
|
return "set";
|
|
if (input instanceof Map)
|
|
return "map";
|
|
if (input instanceof File)
|
|
return "file";
|
|
return "unknown";
|
|
}
|
|
function getLengthableOrigin(input) {
|
|
if (Array.isArray(input))
|
|
return "array";
|
|
if (typeof input === "string")
|
|
return "string";
|
|
return "unknown";
|
|
}
|
|
function parsedType(data) {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "nan" : "number";
|
|
}
|
|
case "object": {
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
const obj = data;
|
|
if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
|
|
return obj.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
}
|
|
function issue(...args) {
|
|
const [iss, input, inst] = args;
|
|
if (typeof iss === "string") {
|
|
return {
|
|
message: iss,
|
|
code: "custom",
|
|
input,
|
|
inst
|
|
};
|
|
}
|
|
return { ...iss };
|
|
}
|
|
function cleanEnum(obj) {
|
|
return Object.entries(obj).filter(([k, _]) => {
|
|
return Number.isNaN(Number.parseInt(k, 10));
|
|
}).map((el) => el[1]);
|
|
}
|
|
function base64ToUint8Array(base64) {
|
|
const binaryString = atob(base64);
|
|
const bytes = new Uint8Array(binaryString.length);
|
|
for (let i = 0;i < binaryString.length; i++) {
|
|
bytes[i] = binaryString.charCodeAt(i);
|
|
}
|
|
return bytes;
|
|
}
|
|
function uint8ArrayToBase64(bytes) {
|
|
let binaryString = "";
|
|
for (let i = 0;i < bytes.length; i++) {
|
|
binaryString += String.fromCharCode(bytes[i]);
|
|
}
|
|
return btoa(binaryString);
|
|
}
|
|
function base64urlToUint8Array(base64url) {
|
|
const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
|
|
const padding = "=".repeat((4 - base64.length % 4) % 4);
|
|
return base64ToUint8Array(base64 + padding);
|
|
}
|
|
function uint8ArrayToBase64url(bytes) {
|
|
return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
|
|
}
|
|
function hexToUint8Array(hex) {
|
|
const cleanHex = hex.replace(/^0x/, "");
|
|
if (cleanHex.length % 2 !== 0) {
|
|
throw new Error("Invalid hex string length");
|
|
}
|
|
const bytes = new Uint8Array(cleanHex.length / 2);
|
|
for (let i = 0;i < cleanHex.length; i += 2) {
|
|
bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);
|
|
}
|
|
return bytes;
|
|
}
|
|
function uint8ArrayToHex(bytes) {
|
|
return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
|
|
}
|
|
|
|
class Class {
|
|
constructor(..._args) {}
|
|
}
|
|
|
|
// node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/errors.js
|
|
var initializer = (inst, def) => {
|
|
inst.name = "$ZodError";
|
|
Object.defineProperty(inst, "_zod", {
|
|
value: inst._zod,
|
|
enumerable: false
|
|
});
|
|
Object.defineProperty(inst, "issues", {
|
|
value: def,
|
|
enumerable: false
|
|
});
|
|
inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);
|
|
Object.defineProperty(inst, "toString", {
|
|
value: () => inst.message,
|
|
enumerable: false
|
|
});
|
|
};
|
|
var $ZodError = $constructor("$ZodError", initializer);
|
|
var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
|
|
function flattenError(error, mapper = (issue2) => issue2.message) {
|
|
const fieldErrors = {};
|
|
const formErrors = [];
|
|
for (const sub of error.issues) {
|
|
if (sub.path.length > 0) {
|
|
fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
|
|
fieldErrors[sub.path[0]].push(mapper(sub));
|
|
} else {
|
|
formErrors.push(mapper(sub));
|
|
}
|
|
}
|
|
return { formErrors, fieldErrors };
|
|
}
|
|
function formatError(error, mapper = (issue2) => issue2.message) {
|
|
const fieldErrors = { _errors: [] };
|
|
const processError = (error2, path = []) => {
|
|
for (const issue2 of error2.issues) {
|
|
if (issue2.code === "invalid_union" && issue2.errors.length) {
|
|
issue2.errors.map((issues) => processError({ issues }, [...path, ...issue2.path]));
|
|
} else if (issue2.code === "invalid_key") {
|
|
processError({ issues: issue2.issues }, [...path, ...issue2.path]);
|
|
} else if (issue2.code === "invalid_element") {
|
|
processError({ issues: issue2.issues }, [...path, ...issue2.path]);
|
|
} else {
|
|
const fullpath = [...path, ...issue2.path];
|
|
if (fullpath.length === 0) {
|
|
fieldErrors._errors.push(mapper(issue2));
|
|
} else {
|
|
let curr = fieldErrors;
|
|
let i = 0;
|
|
while (i < fullpath.length) {
|
|
const el = fullpath[i];
|
|
const terminal = i === fullpath.length - 1;
|
|
if (!terminal) {
|
|
curr[el] = curr[el] || { _errors: [] };
|
|
} else {
|
|
curr[el] = curr[el] || { _errors: [] };
|
|
curr[el]._errors.push(mapper(issue2));
|
|
}
|
|
curr = curr[el];
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
processError(error);
|
|
return fieldErrors;
|
|
}
|
|
|
|
// node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/parse.js
|
|
var _parse = (_Err) => (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);
|
|
throw e;
|
|
}
|
|
return result.value;
|
|
};
|
|
var _parseAsync = (_Err) => 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);
|
|
throw e;
|
|
}
|
|
return result.value;
|
|
};
|
|
var _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 ? {
|
|
success: false,
|
|
error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
|
|
} : { success: true, data: result.value };
|
|
};
|
|
var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
|
|
var _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 ? {
|
|
success: false,
|
|
error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
|
|
} : { success: true, data: result.value };
|
|
};
|
|
var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
|
|
var _encode = (_Err) => (schema, value, _ctx) => {
|
|
const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
|
|
return _parse(_Err)(schema, value, ctx);
|
|
};
|
|
var _decode = (_Err) => (schema, value, _ctx) => {
|
|
return _parse(_Err)(schema, value, _ctx);
|
|
};
|
|
var _encodeAsync = (_Err) => async (schema, value, _ctx) => {
|
|
const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
|
|
return _parseAsync(_Err)(schema, value, ctx);
|
|
};
|
|
var _decodeAsync = (_Err) => async (schema, value, _ctx) => {
|
|
return _parseAsync(_Err)(schema, value, _ctx);
|
|
};
|
|
var _safeEncode = (_Err) => (schema, value, _ctx) => {
|
|
const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
|
|
return _safeParse(_Err)(schema, value, ctx);
|
|
};
|
|
var _safeDecode = (_Err) => (schema, value, _ctx) => {
|
|
return _safeParse(_Err)(schema, value, _ctx);
|
|
};
|
|
var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
|
|
const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
|
|
return _safeParseAsync(_Err)(schema, value, ctx);
|
|
};
|
|
var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
|
|
return _safeParseAsync(_Err)(schema, value, _ctx);
|
|
};
|
|
// node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/regexes.js
|
|
var cuid = /^[cC][0-9a-z]{6,}$/;
|
|
var cuid2 = /^[0-9a-z]+$/;
|
|
var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
|
|
var xid = /^[0-9a-vA-V]{20}$/;
|
|
var ksuid = /^[A-Za-z0-9]{27}$/;
|
|
var nanoid = /^[a-zA-Z0-9_-]{21}$/;
|
|
var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
|
|
var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
|
|
var uuid = (version) => {
|
|
if (!version)
|
|
return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
|
|
return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
|
|
};
|
|
var email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
|
|
var _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
|
|
function emoji() {
|
|
return new RegExp(_emoji, "u");
|
|
}
|
|
var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
|
|
var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
|
|
var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
|
|
var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
|
|
var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
|
|
var base64url = /^[A-Za-z0-9_-]*$/;
|
|
var httpProtocol = /^https?$/;
|
|
var e164 = /^\+[1-9]\d{6,14}$/;
|
|
var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
|
|
var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
|
|
function timeSource(args) {
|
|
const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
|
|
const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
|
|
return regex;
|
|
}
|
|
function time(args) {
|
|
return new RegExp(`^${timeSource(args)}$`);
|
|
}
|
|
function datetime(args) {
|
|
const time2 = timeSource({ precision: args.precision });
|
|
const opts = ["Z"];
|
|
if (args.local)
|
|
opts.push("");
|
|
if (args.offset)
|
|
opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
|
|
const timeRegex = `${time2}(?:${opts.join("|")})`;
|
|
return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
|
|
}
|
|
var string = (params) => {
|
|
const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
|
|
return new RegExp(`^${regex}$`);
|
|
};
|
|
var _null = /^null$/i;
|
|
var lowercase = /^[^A-Z]*$/;
|
|
var uppercase = /^[^a-z]*$/;
|
|
|
|
// node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/checks.js
|
|
var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
|
|
var _a2;
|
|
inst._zod ?? (inst._zod = {});
|
|
inst._zod.def = def;
|
|
(_a2 = inst._zod).onattach ?? (_a2.onattach = []);
|
|
});
|
|
var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
|
|
var _a2;
|
|
$ZodCheck.init(inst, def);
|
|
(_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
|
|
const val = payload.value;
|
|
return !nullish(val) && val.length !== undefined;
|
|
});
|
|
inst._zod.onattach.push((inst2) => {
|
|
const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
|
|
if (def.maximum < curr)
|
|
inst2._zod.bag.maximum = def.maximum;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const length = input.length;
|
|
if (length <= def.maximum)
|
|
return;
|
|
const origin = getLengthableOrigin(input);
|
|
payload.issues.push({
|
|
origin,
|
|
code: "too_big",
|
|
maximum: def.maximum,
|
|
inclusive: true,
|
|
input,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
|
|
var _a2;
|
|
$ZodCheck.init(inst, def);
|
|
(_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
|
|
const val = payload.value;
|
|
return !nullish(val) && val.length !== undefined;
|
|
});
|
|
inst._zod.onattach.push((inst2) => {
|
|
const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
|
|
if (def.minimum > curr)
|
|
inst2._zod.bag.minimum = def.minimum;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const length = input.length;
|
|
if (length >= def.minimum)
|
|
return;
|
|
const origin = getLengthableOrigin(input);
|
|
payload.issues.push({
|
|
origin,
|
|
code: "too_small",
|
|
minimum: def.minimum,
|
|
inclusive: true,
|
|
input,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
|
|
var _a2;
|
|
$ZodCheck.init(inst, def);
|
|
(_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
|
|
const val = payload.value;
|
|
return !nullish(val) && val.length !== undefined;
|
|
});
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.minimum = def.length;
|
|
bag.maximum = def.length;
|
|
bag.length = def.length;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const length = input.length;
|
|
if (length === def.length)
|
|
return;
|
|
const origin = getLengthableOrigin(input);
|
|
const tooBig = length > def.length;
|
|
payload.issues.push({
|
|
origin,
|
|
...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length },
|
|
inclusive: true,
|
|
exact: true,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
|
|
var _a2, _b;
|
|
$ZodCheck.init(inst, def);
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.format = def.format;
|
|
if (def.pattern) {
|
|
bag.patterns ?? (bag.patterns = new Set);
|
|
bag.patterns.add(def.pattern);
|
|
}
|
|
});
|
|
if (def.pattern)
|
|
(_a2 = inst._zod).check ?? (_a2.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 $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => {
|
|
$ZodCheckStringFormat.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
def.pattern.lastIndex = 0;
|
|
if (def.pattern.test(payload.value))
|
|
return;
|
|
payload.issues.push({
|
|
origin: "string",
|
|
code: "invalid_format",
|
|
format: "regex",
|
|
input: payload.value,
|
|
pattern: def.pattern.toString(),
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (inst, def) => {
|
|
def.pattern ?? (def.pattern = lowercase);
|
|
$ZodCheckStringFormat.init(inst, def);
|
|
});
|
|
var $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (inst, def) => {
|
|
def.pattern ?? (def.pattern = uppercase);
|
|
$ZodCheckStringFormat.init(inst, def);
|
|
});
|
|
var $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
const escapedRegex = escapeRegex(def.includes);
|
|
const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);
|
|
def.pattern = pattern;
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.patterns ?? (bag.patterns = new Set);
|
|
bag.patterns.add(pattern);
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (payload.value.includes(def.includes, def.position))
|
|
return;
|
|
payload.issues.push({
|
|
origin: "string",
|
|
code: "invalid_format",
|
|
format: "includes",
|
|
includes: def.includes,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`);
|
|
def.pattern ?? (def.pattern = pattern);
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.patterns ?? (bag.patterns = new Set);
|
|
bag.patterns.add(pattern);
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (payload.value.startsWith(def.prefix))
|
|
return;
|
|
payload.issues.push({
|
|
origin: "string",
|
|
code: "invalid_format",
|
|
format: "starts_with",
|
|
prefix: def.prefix,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`);
|
|
def.pattern ?? (def.pattern = pattern);
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.patterns ?? (bag.patterns = new Set);
|
|
bag.patterns.add(pattern);
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (payload.value.endsWith(def.suffix))
|
|
return;
|
|
payload.issues.push({
|
|
origin: "string",
|
|
code: "invalid_format",
|
|
format: "ends_with",
|
|
suffix: def.suffix,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
payload.value = def.tx(payload.value);
|
|
};
|
|
});
|
|
|
|
// node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/doc.js
|
|
class Doc {
|
|
constructor(args = []) {
|
|
this.content = [];
|
|
this.indent = 0;
|
|
if (this)
|
|
this.args = args;
|
|
}
|
|
indented(fn) {
|
|
this.indent += 1;
|
|
fn(this);
|
|
this.indent -= 1;
|
|
}
|
|
write(arg) {
|
|
if (typeof arg === "function") {
|
|
arg(this, { execution: "sync" });
|
|
arg(this, { execution: "async" });
|
|
return;
|
|
}
|
|
const content = arg;
|
|
const lines = content.split(`
|
|
`).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 args = this?.args;
|
|
const content = this?.content ?? [``];
|
|
const lines = [...content.map((x) => ` ${x}`)];
|
|
return new F(...args, lines.join(`
|
|
`));
|
|
}
|
|
}
|
|
|
|
// node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/versions.js
|
|
var version = {
|
|
major: 4,
|
|
minor: 4,
|
|
patch: 3
|
|
};
|
|
|
|
// node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/schemas.js
|
|
var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
|
|
var _a2;
|
|
inst ?? (inst = {});
|
|
inst._zod.def = def;
|
|
inst._zod.bag = inst._zod.bag || {};
|
|
inst._zod.version = version;
|
|
const checks = [...inst._zod.def.checks ?? []];
|
|
if (inst._zod.traits.has("$ZodCheck")) {
|
|
checks.unshift(inst);
|
|
}
|
|
for (const ch of checks) {
|
|
for (const fn of ch._zod.onattach) {
|
|
fn(inst);
|
|
}
|
|
}
|
|
if (checks.length === 0) {
|
|
(_a2 = inst._zod).deferred ?? (_a2.deferred = []);
|
|
inst._zod.deferred?.push(() => {
|
|
inst._zod.run = inst._zod.parse;
|
|
});
|
|
} else {
|
|
const runChecks = (payload, checks2, ctx) => {
|
|
let isAborted = aborted(payload);
|
|
let asyncResult;
|
|
for (const ch of checks2) {
|
|
if (ch._zod.def.when) {
|
|
if (explicitlyAborted(payload))
|
|
continue;
|
|
const shouldRun = ch._zod.def.when(payload);
|
|
if (!shouldRun)
|
|
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 _;
|
|
const nextLen = payload.issues.length;
|
|
if (nextLen === currLen)
|
|
return;
|
|
if (!isAborted)
|
|
isAborted = aborted(payload, currLen);
|
|
});
|
|
} else {
|
|
const nextLen = payload.issues.length;
|
|
if (nextLen === currLen)
|
|
continue;
|
|
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((checkResult2) => inst._zod.parse(checkResult2, 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((canary2) => {
|
|
return handleCanaryResult(canary2, 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((result2) => runChecks(result2, checks, ctx));
|
|
}
|
|
return runChecks(result, checks, ctx);
|
|
};
|
|
}
|
|
defineLazy(inst, "~standard", () => ({
|
|
validate: (value) => {
|
|
try {
|
|
const r = safeParse(inst, value);
|
|
return r.success ? { value: r.data } : { issues: r.error?.issues };
|
|
} catch (_) {
|
|
return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
|
|
}
|
|
},
|
|
vendor: "zod",
|
|
version: 1
|
|
}));
|
|
});
|
|
var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string(inst._zod.bag);
|
|
inst._zod.parse = (payload, _) => {
|
|
if (def.coerce)
|
|
try {
|
|
payload.value = String(payload.value);
|
|
} catch (_2) {}
|
|
if (typeof payload.value === "string")
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "string",
|
|
code: "invalid_type",
|
|
input: payload.value,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodStringFormat = /* @__PURE__ */ $constructor("$ZodStringFormat", (inst, def) => {
|
|
$ZodCheckStringFormat.init(inst, def);
|
|
$ZodString.init(inst, def);
|
|
});
|
|
var $ZodGUID = /* @__PURE__ */ $constructor("$ZodGUID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = guid);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => {
|
|
if (def.version) {
|
|
const versionMap = {
|
|
v1: 1,
|
|
v2: 2,
|
|
v3: 3,
|
|
v4: 4,
|
|
v5: 5,
|
|
v6: 6,
|
|
v7: 7,
|
|
v8: 8
|
|
};
|
|
const v = versionMap[def.version];
|
|
if (v === undefined)
|
|
throw new Error(`Invalid UUID version: "${def.version}"`);
|
|
def.pattern ?? (def.pattern = uuid(v));
|
|
} else
|
|
def.pattern ?? (def.pattern = uuid());
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodEmail = /* @__PURE__ */ $constructor("$ZodEmail", (inst, def) => {
|
|
def.pattern ?? (def.pattern = email);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
|
|
$ZodStringFormat.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
try {
|
|
const trimmed = payload.value.trim();
|
|
if (!def.normalize && def.protocol?.source === httpProtocol.source) {
|
|
if (!/^https?:\/\//i.test(trimmed)) {
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "url",
|
|
note: "Invalid URL format",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
return;
|
|
}
|
|
}
|
|
const url = new URL(trimmed);
|
|
if (def.hostname) {
|
|
def.hostname.lastIndex = 0;
|
|
if (!def.hostname.test(url.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) {
|
|
def.protocol.lastIndex = 0;
|
|
if (!def.protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol)) {
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "url",
|
|
note: "Invalid protocol",
|
|
pattern: def.protocol.source,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
}
|
|
if (def.normalize) {
|
|
payload.value = url.href;
|
|
} else {
|
|
payload.value = trimmed;
|
|
}
|
|
return;
|
|
} catch (_) {
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "url",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
};
|
|
});
|
|
var $ZodEmoji = /* @__PURE__ */ $constructor("$ZodEmoji", (inst, def) => {
|
|
def.pattern ?? (def.pattern = emoji());
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodNanoID = /* @__PURE__ */ $constructor("$ZodNanoID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = nanoid);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodCUID = /* @__PURE__ */ $constructor("$ZodCUID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = cuid);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodCUID2 = /* @__PURE__ */ $constructor("$ZodCUID2", (inst, def) => {
|
|
def.pattern ?? (def.pattern = cuid2);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodULID = /* @__PURE__ */ $constructor("$ZodULID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = ulid);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodXID = /* @__PURE__ */ $constructor("$ZodXID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = xid);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodKSUID = /* @__PURE__ */ $constructor("$ZodKSUID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = ksuid);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (inst, def) => {
|
|
def.pattern ?? (def.pattern = datetime(def));
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodISODate = /* @__PURE__ */ $constructor("$ZodISODate", (inst, def) => {
|
|
def.pattern ?? (def.pattern = date);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => {
|
|
def.pattern ?? (def.pattern = time(def));
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (inst, def) => {
|
|
def.pattern ?? (def.pattern = duration);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodIPv4 = /* @__PURE__ */ $constructor("$ZodIPv4", (inst, def) => {
|
|
def.pattern ?? (def.pattern = ipv4);
|
|
$ZodStringFormat.init(inst, def);
|
|
inst._zod.bag.format = `ipv4`;
|
|
});
|
|
var $ZodIPv6 = /* @__PURE__ */ $constructor("$ZodIPv6", (inst, def) => {
|
|
def.pattern ?? (def.pattern = ipv6);
|
|
$ZodStringFormat.init(inst, def);
|
|
inst._zod.bag.format = `ipv6`;
|
|
inst._zod.check = (payload) => {
|
|
try {
|
|
new URL(`http://[${payload.value}]`);
|
|
} catch {
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "ipv6",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
};
|
|
});
|
|
var $ZodCIDRv4 = /* @__PURE__ */ $constructor("$ZodCIDRv4", (inst, def) => {
|
|
def.pattern ?? (def.pattern = cidrv4);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => {
|
|
def.pattern ?? (def.pattern = cidrv6);
|
|
$ZodStringFormat.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
const parts = payload.value.split("/");
|
|
try {
|
|
if (parts.length !== 2)
|
|
throw new Error;
|
|
const [address, prefix] = parts;
|
|
if (!prefix)
|
|
throw new Error;
|
|
const prefixNum = Number(prefix);
|
|
if (`${prefixNum}` !== prefix)
|
|
throw new Error;
|
|
if (prefixNum < 0 || prefixNum > 128)
|
|
throw new Error;
|
|
new URL(`http://[${address}]`);
|
|
} catch {
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "cidrv6",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
};
|
|
});
|
|
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;
|
|
}
|
|
}
|
|
var $ZodBase64 = /* @__PURE__ */ $constructor("$ZodBase64", (inst, def) => {
|
|
def.pattern ?? (def.pattern = base64);
|
|
$ZodStringFormat.init(inst, def);
|
|
inst._zod.bag.contentEncoding = "base64";
|
|
inst._zod.check = (payload) => {
|
|
if (isValidBase64(payload.value))
|
|
return;
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "base64",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
function isValidBase64URL(data) {
|
|
if (!base64url.test(data))
|
|
return false;
|
|
const base642 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/");
|
|
const padded = base642.padEnd(Math.ceil(base642.length / 4) * 4, "=");
|
|
return isValidBase64(padded);
|
|
}
|
|
var $ZodBase64URL = /* @__PURE__ */ $constructor("$ZodBase64URL", (inst, def) => {
|
|
def.pattern ?? (def.pattern = base64url);
|
|
$ZodStringFormat.init(inst, def);
|
|
inst._zod.bag.contentEncoding = "base64url";
|
|
inst._zod.check = (payload) => {
|
|
if (isValidBase64URL(payload.value))
|
|
return;
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "base64url",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodE164 = /* @__PURE__ */ $constructor("$ZodE164", (inst, def) => {
|
|
def.pattern ?? (def.pattern = e164);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
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;
|
|
}
|
|
}
|
|
var $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => {
|
|
$ZodStringFormat.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
if (isValidJWT(payload.value, def.alg))
|
|
return;
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "jwt",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.pattern = _null;
|
|
inst._zod.values = new Set([null]);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (input === null)
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "null",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload) => payload;
|
|
});
|
|
var $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
payload.issues.push({
|
|
expected: "never",
|
|
code: "invalid_type",
|
|
input: payload.value,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
function handleArrayResult(result, final, index) {
|
|
if (result.issues.length) {
|
|
final.issues.push(...prefixIssues(index, result.issues));
|
|
}
|
|
final.value[index] = result.value;
|
|
}
|
|
var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
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 = Array(input.length);
|
|
const proms = [];
|
|
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((result2) => handleArrayResult(result2, payload, i)));
|
|
} else {
|
|
handleArrayResult(result, payload, i);
|
|
}
|
|
}
|
|
if (proms.length) {
|
|
return Promise.all(proms).then(() => payload);
|
|
}
|
|
return payload;
|
|
};
|
|
});
|
|
function handlePropertyResult(result, final, key, input, isOptionalIn, isOptionalOut) {
|
|
const isPresent = key in input;
|
|
if (result.issues.length) {
|
|
if (isOptionalIn && isOptionalOut && !isPresent) {
|
|
return;
|
|
}
|
|
final.issues.push(...prefixIssues(key, result.issues));
|
|
}
|
|
if (!isPresent && !isOptionalIn) {
|
|
if (!result.issues.length) {
|
|
final.issues.push({
|
|
code: "invalid_type",
|
|
expected: "nonoptional",
|
|
input: undefined,
|
|
path: [key]
|
|
});
|
|
}
|
|
return;
|
|
}
|
|
if (result.value === undefined) {
|
|
if (isPresent) {
|
|
final.value[key] = undefined;
|
|
}
|
|
} else {
|
|
final.value[key] = result.value;
|
|
}
|
|
}
|
|
function normalizeDef(def) {
|
|
const keys = Object.keys(def.shape);
|
|
for (const k of keys) {
|
|
if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) {
|
|
throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
|
|
}
|
|
}
|
|
const okeys = optionalKeys(def.shape);
|
|
return {
|
|
...def,
|
|
keys,
|
|
keySet: new Set(keys),
|
|
numKeys: keys.length,
|
|
optionalKeys: new Set(okeys)
|
|
};
|
|
}
|
|
function handleCatchall(proms, input, payload, ctx, def, inst) {
|
|
const unrecognized = [];
|
|
const keySet = def.keySet;
|
|
const _catchall = def.catchall._zod;
|
|
const t = _catchall.def.type;
|
|
const isOptionalIn = _catchall.optin === "optional";
|
|
const isOptionalOut = _catchall.optout === "optional";
|
|
for (const key in input) {
|
|
if (key === "__proto__")
|
|
continue;
|
|
if (keySet.has(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((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut)));
|
|
} else {
|
|
handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
|
|
}
|
|
}
|
|
if (unrecognized.length) {
|
|
payload.issues.push({
|
|
code: "unrecognized_keys",
|
|
keys: unrecognized,
|
|
input,
|
|
inst
|
|
});
|
|
}
|
|
if (!proms.length)
|
|
return payload;
|
|
return Promise.all(proms).then(() => {
|
|
return payload;
|
|
});
|
|
}
|
|
var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
const desc = Object.getOwnPropertyDescriptor(def, "shape");
|
|
if (!desc?.get) {
|
|
const sh = def.shape;
|
|
Object.defineProperty(def, "shape", {
|
|
get: () => {
|
|
const newSh = { ...sh };
|
|
Object.defineProperty(def, "shape", {
|
|
value: newSh
|
|
});
|
|
return newSh;
|
|
}
|
|
});
|
|
}
|
|
const _normalized = cached(() => normalizeDef(def));
|
|
defineLazy(inst._zod, "propValues", () => {
|
|
const shape = def.shape;
|
|
const propValues = {};
|
|
for (const key in shape) {
|
|
const field = shape[key]._zod;
|
|
if (field.values) {
|
|
propValues[key] ?? (propValues[key] = new Set);
|
|
for (const v of field.values)
|
|
propValues[key].add(v);
|
|
}
|
|
}
|
|
return propValues;
|
|
});
|
|
const isObject2 = isObject;
|
|
const catchall = def.catchall;
|
|
let value;
|
|
inst._zod.parse = (payload, ctx) => {
|
|
value ?? (value = _normalized.value);
|
|
const input = payload.value;
|
|
if (!isObject2(input)) {
|
|
payload.issues.push({
|
|
expected: "object",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
}
|
|
payload.value = {};
|
|
const proms = [];
|
|
const shape = value.shape;
|
|
for (const key of value.keys) {
|
|
const el = shape[key];
|
|
const isOptionalIn = el._zod.optin === "optional";
|
|
const isOptionalOut = el._zod.optout === "optional";
|
|
const r = el._zod.run({ value: input[key], issues: [] }, ctx);
|
|
if (r instanceof Promise) {
|
|
proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut)));
|
|
} else {
|
|
handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
|
|
}
|
|
}
|
|
if (!catchall) {
|
|
return proms.length ? Promise.all(proms).then(() => payload) : payload;
|
|
}
|
|
return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
|
|
};
|
|
});
|
|
var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) => {
|
|
$ZodObject.init(inst, def);
|
|
const superParse = inst._zod.parse;
|
|
const _normalized = cached(() => normalizeDef(def));
|
|
const generateFastpass = (shape) => {
|
|
const doc = new Doc(["shape", "payload", "ctx"]);
|
|
const normalized = _normalized.value;
|
|
const parseStr = (key) => {
|
|
const k = esc(key);
|
|
return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
|
|
};
|
|
doc.write(`const input = payload.value;`);
|
|
const ids = Object.create(null);
|
|
let counter = 0;
|
|
for (const key of normalized.keys) {
|
|
ids[key] = `key_${counter++}`;
|
|
}
|
|
doc.write(`const newResult = {};`);
|
|
for (const key of normalized.keys) {
|
|
const id = ids[key];
|
|
const k = esc(key);
|
|
const schema = shape[key];
|
|
const isOptionalIn = schema?._zod?.optin === "optional";
|
|
const isOptionalOut = schema?._zod?.optout === "optional";
|
|
doc.write(`const ${id} = ${parseStr(key)};`);
|
|
if (isOptionalIn && isOptionalOut) {
|
|
doc.write(`
|
|
if (${id}.issues.length) {
|
|
if (${k} in input) {
|
|
payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
|
|
...iss,
|
|
path: iss.path ? [${k}, ...iss.path] : [${k}]
|
|
})));
|
|
}
|
|
}
|
|
|
|
if (${id}.value === undefined) {
|
|
if (${k} in input) {
|
|
newResult[${k}] = undefined;
|
|
}
|
|
} else {
|
|
newResult[${k}] = ${id}.value;
|
|
}
|
|
|
|
`);
|
|
} else if (!isOptionalIn) {
|
|
doc.write(`
|
|
const ${id}_present = ${k} in input;
|
|
if (${id}.issues.length) {
|
|
payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
|
|
...iss,
|
|
path: iss.path ? [${k}, ...iss.path] : [${k}]
|
|
})));
|
|
}
|
|
if (!${id}_present && !${id}.issues.length) {
|
|
payload.issues.push({
|
|
code: "invalid_type",
|
|
expected: "nonoptional",
|
|
input: undefined,
|
|
path: [${k}]
|
|
});
|
|
}
|
|
|
|
if (${id}_present) {
|
|
if (${id}.value === undefined) {
|
|
newResult[${k}] = undefined;
|
|
} else {
|
|
newResult[${k}] = ${id}.value;
|
|
}
|
|
}
|
|
|
|
`);
|
|
} else {
|
|
doc.write(`
|
|
if (${id}.issues.length) {
|
|
payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
|
|
...iss,
|
|
path: iss.path ? [${k}, ...iss.path] : [${k}]
|
|
})));
|
|
}
|
|
|
|
if (${id}.value === undefined) {
|
|
if (${k} in input) {
|
|
newResult[${k}] = undefined;
|
|
}
|
|
} else {
|
|
newResult[${k}] = ${id}.value;
|
|
}
|
|
|
|
`);
|
|
}
|
|
}
|
|
doc.write(`payload.value = newResult;`);
|
|
doc.write(`return payload;`);
|
|
const fn = doc.compile();
|
|
return (payload, ctx) => fn(shape, payload, ctx);
|
|
};
|
|
let fastpass;
|
|
const isObject2 = isObject;
|
|
const jit = !globalConfig.jitless;
|
|
const allowsEval2 = allowsEval;
|
|
const fastEnabled = jit && allowsEval2.value;
|
|
const catchall = def.catchall;
|
|
let value;
|
|
inst._zod.parse = (payload, ctx) => {
|
|
value ?? (value = _normalized.value);
|
|
const input = payload.value;
|
|
if (!isObject2(input)) {
|
|
payload.issues.push({
|
|
expected: "object",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
}
|
|
if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
|
|
if (!fastpass)
|
|
fastpass = generateFastpass(def.shape);
|
|
payload = fastpass(payload, ctx);
|
|
if (!catchall)
|
|
return payload;
|
|
return handleCatchall([], input, payload, ctx, value, inst);
|
|
}
|
|
return superParse(payload, ctx);
|
|
};
|
|
});
|
|
function handleUnionResults(results, final, inst, ctx) {
|
|
for (const result of results) {
|
|
if (result.issues.length === 0) {
|
|
final.value = result.value;
|
|
return final;
|
|
}
|
|
}
|
|
const nonaborted = results.filter((r) => !aborted(r));
|
|
if (nonaborted.length === 1) {
|
|
final.value = nonaborted[0].value;
|
|
return nonaborted[0];
|
|
}
|
|
final.issues.push({
|
|
code: "invalid_union",
|
|
input: final.value,
|
|
inst,
|
|
errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
|
|
});
|
|
return final;
|
|
}
|
|
var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : undefined);
|
|
defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : undefined);
|
|
defineLazy(inst._zod, "values", () => {
|
|
if (def.options.every((o) => o._zod.values)) {
|
|
return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
|
|
}
|
|
return;
|
|
});
|
|
defineLazy(inst._zod, "pattern", () => {
|
|
if (def.options.every((o) => o._zod.pattern)) {
|
|
const patterns = def.options.map((o) => o._zod.pattern);
|
|
return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
|
|
}
|
|
return;
|
|
});
|
|
const first = def.options.length === 1 ? def.options[0]._zod.run : null;
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (first) {
|
|
return first(payload, ctx);
|
|
}
|
|
let async = false;
|
|
const results = [];
|
|
for (const option of def.options) {
|
|
const result = option._zod.run({
|
|
value: payload.value,
|
|
issues: []
|
|
}, ctx);
|
|
if (result instanceof Promise) {
|
|
results.push(result);
|
|
async = true;
|
|
} else {
|
|
if (result.issues.length === 0)
|
|
return result;
|
|
results.push(result);
|
|
}
|
|
}
|
|
if (!async)
|
|
return handleUnionResults(results, payload, inst, ctx);
|
|
return Promise.all(results).then((results2) => {
|
|
return handleUnionResults(results2, payload, inst, ctx);
|
|
});
|
|
};
|
|
});
|
|
var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
|
|
def.inclusive = false;
|
|
$ZodUnion.init(inst, def);
|
|
const _super = inst._zod.parse;
|
|
defineLazy(inst._zod, "propValues", () => {
|
|
const propValues = {};
|
|
for (const option of def.options) {
|
|
const pv = option._zod.propValues;
|
|
if (!pv || Object.keys(pv).length === 0)
|
|
throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
|
|
for (const [k, v] of Object.entries(pv)) {
|
|
if (!propValues[k])
|
|
propValues[k] = new Set;
|
|
for (const val of v) {
|
|
propValues[k].add(val);
|
|
}
|
|
}
|
|
}
|
|
return propValues;
|
|
});
|
|
const disc = cached(() => {
|
|
const opts = def.options;
|
|
const map = new Map;
|
|
for (const o of opts) {
|
|
const values = o._zod.propValues?.[def.discriminator];
|
|
if (!values || values.size === 0)
|
|
throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
|
|
for (const v of values) {
|
|
if (map.has(v)) {
|
|
throw new Error(`Duplicate discriminator value "${String(v)}"`);
|
|
}
|
|
map.set(v, o);
|
|
}
|
|
}
|
|
return map;
|
|
});
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
if (!isObject(input)) {
|
|
payload.issues.push({
|
|
code: "invalid_type",
|
|
expected: "object",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
}
|
|
const opt = disc.value.get(input?.[def.discriminator]);
|
|
if (opt) {
|
|
return opt._zod.run(payload, ctx);
|
|
}
|
|
if (def.unionFallback || ctx.direction === "backward") {
|
|
return _super(payload, ctx);
|
|
}
|
|
payload.issues.push({
|
|
code: "invalid_union",
|
|
errors: [],
|
|
note: "No matching discriminator",
|
|
discriminator: def.discriminator,
|
|
options: Array.from(disc.value.keys()),
|
|
input,
|
|
path: [def.discriminator],
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
const left = def.left._zod.run({ value: input, issues: [] }, ctx);
|
|
const right = def.right._zod.run({ value: input, issues: [] }, ctx);
|
|
const async = left instanceof Promise || right instanceof Promise;
|
|
if (async) {
|
|
return Promise.all([left, right]).then(([left2, right2]) => {
|
|
return handleIntersectionResults(payload, left2, right2);
|
|
});
|
|
}
|
|
return handleIntersectionResults(payload, left, right);
|
|
};
|
|
});
|
|
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 };
|
|
for (const key of sharedKeys) {
|
|
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: [] };
|
|
}
|
|
function handleIntersectionResults(result, left, right) {
|
|
const unrecKeys = new Map;
|
|
let unrecIssue;
|
|
for (const iss of left.issues) {
|
|
if (iss.code === "unrecognized_keys") {
|
|
unrecIssue ?? (unrecIssue = iss);
|
|
for (const k of iss.keys) {
|
|
if (!unrecKeys.has(k))
|
|
unrecKeys.set(k, {});
|
|
unrecKeys.get(k).l = true;
|
|
}
|
|
} else {
|
|
result.issues.push(iss);
|
|
}
|
|
}
|
|
for (const iss of right.issues) {
|
|
if (iss.code === "unrecognized_keys") {
|
|
for (const k of iss.keys) {
|
|
if (!unrecKeys.has(k))
|
|
unrecKeys.set(k, {});
|
|
unrecKeys.get(k).r = true;
|
|
}
|
|
} else {
|
|
result.issues.push(iss);
|
|
}
|
|
}
|
|
const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
|
|
if (bothKeys.length && unrecIssue) {
|
|
result.issues.push({ ...unrecIssue, keys: bothKeys });
|
|
}
|
|
if (aborted(result))
|
|
return result;
|
|
const merged = mergeValues(left.value, right.value);
|
|
if (!merged.valid) {
|
|
throw new Error(`Unmergable intersection. Error path: ` + `${JSON.stringify(merged.mergeErrorPath)}`);
|
|
}
|
|
result.value = merged.data;
|
|
return result;
|
|
}
|
|
var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
const values = getEnumValues(def.entries);
|
|
const valuesSet = new Set(values);
|
|
inst._zod.values = valuesSet;
|
|
inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
|
|
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;
|
|
};
|
|
});
|
|
var $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
if (def.values.length === 0) {
|
|
throw new Error("Cannot create literal schema with no valid values");
|
|
}
|
|
const values = new Set(def.values);
|
|
inst._zod.values = values;
|
|
inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)).join("|")})$`);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (values.has(input)) {
|
|
return payload;
|
|
}
|
|
payload.issues.push({
|
|
code: "invalid_value",
|
|
values: def.values,
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.optin = "optional";
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
throw new $ZodEncodeError(inst.constructor.name);
|
|
}
|
|
const _out = def.transform(payload.value, payload);
|
|
if (ctx.async) {
|
|
const output = _out instanceof Promise ? _out : Promise.resolve(_out);
|
|
return output.then((output2) => {
|
|
payload.value = output2;
|
|
payload.fallback = true;
|
|
return payload;
|
|
});
|
|
}
|
|
if (_out instanceof Promise) {
|
|
throw new $ZodAsyncError;
|
|
}
|
|
payload.value = _out;
|
|
payload.fallback = true;
|
|
return payload;
|
|
};
|
|
});
|
|
function handleOptionalResult(result, input) {
|
|
if (input === undefined && (result.issues.length || result.fallback)) {
|
|
return { issues: [], value: undefined };
|
|
}
|
|
return result;
|
|
}
|
|
var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.optin = "optional";
|
|
inst._zod.optout = "optional";
|
|
defineLazy(inst._zod, "values", () => {
|
|
return def.innerType._zod.values ? new Set([...def.innerType._zod.values, undefined]) : undefined;
|
|
});
|
|
defineLazy(inst._zod, "pattern", () => {
|
|
const pattern = def.innerType._zod.pattern;
|
|
return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : undefined;
|
|
});
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (def.innerType._zod.optin === "optional") {
|
|
const input = payload.value;
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise)
|
|
return result.then((r) => handleOptionalResult(r, input));
|
|
return handleOptionalResult(result, input);
|
|
}
|
|
if (payload.value === undefined) {
|
|
return payload;
|
|
}
|
|
return def.innerType._zod.run(payload, ctx);
|
|
};
|
|
});
|
|
var $ZodExactOptional = /* @__PURE__ */ $constructor("$ZodExactOptional", (inst, def) => {
|
|
$ZodOptional.init(inst, def);
|
|
defineLazy(inst._zod, "values", () => def.innerType._zod.values);
|
|
defineLazy(inst._zod, "pattern", () => def.innerType._zod.pattern);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
return def.innerType._zod.run(payload, ctx);
|
|
};
|
|
});
|
|
var $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
|
|
defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
|
|
defineLazy(inst._zod, "pattern", () => {
|
|
const pattern = def.innerType._zod.pattern;
|
|
return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : undefined;
|
|
});
|
|
defineLazy(inst._zod, "values", () => {
|
|
return def.innerType._zod.values ? new Set([...def.innerType._zod.values, null]) : undefined;
|
|
});
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (payload.value === null)
|
|
return payload;
|
|
return def.innerType._zod.run(payload, ctx);
|
|
};
|
|
});
|
|
var $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.optin = "optional";
|
|
defineLazy(inst._zod, "values", () => def.innerType._zod.values);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
return def.innerType._zod.run(payload, ctx);
|
|
}
|
|
if (payload.value === undefined) {
|
|
payload.value = def.defaultValue;
|
|
return payload;
|
|
}
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
return result.then((result2) => handleDefaultResult(result2, def));
|
|
}
|
|
return handleDefaultResult(result, def);
|
|
};
|
|
});
|
|
function handleDefaultResult(payload, def) {
|
|
if (payload.value === undefined) {
|
|
payload.value = def.defaultValue;
|
|
}
|
|
return payload;
|
|
}
|
|
var $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.optin = "optional";
|
|
defineLazy(inst._zod, "values", () => def.innerType._zod.values);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
return def.innerType._zod.run(payload, ctx);
|
|
}
|
|
if (payload.value === undefined) {
|
|
payload.value = def.defaultValue;
|
|
}
|
|
return def.innerType._zod.run(payload, ctx);
|
|
};
|
|
});
|
|
var $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
defineLazy(inst._zod, "values", () => {
|
|
const v = def.innerType._zod.values;
|
|
return v ? new Set([...v].filter((x) => x !== undefined)) : undefined;
|
|
});
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
return result.then((result2) => handleNonOptionalResult(result2, inst));
|
|
}
|
|
return handleNonOptionalResult(result, inst);
|
|
};
|
|
});
|
|
function handleNonOptionalResult(payload, inst) {
|
|
if (!payload.issues.length && payload.value === undefined) {
|
|
payload.issues.push({
|
|
code: "invalid_type",
|
|
expected: "nonoptional",
|
|
input: payload.value,
|
|
inst
|
|
});
|
|
}
|
|
return payload;
|
|
}
|
|
var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.optin = "optional";
|
|
defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
|
|
defineLazy(inst._zod, "values", () => def.innerType._zod.values);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
return def.innerType._zod.run(payload, ctx);
|
|
}
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
return result.then((result2) => {
|
|
payload.value = result2.value;
|
|
if (result2.issues.length) {
|
|
payload.value = def.catchValue({
|
|
...payload,
|
|
error: {
|
|
issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config()))
|
|
},
|
|
input: payload.value
|
|
});
|
|
payload.issues = [];
|
|
payload.fallback = true;
|
|
}
|
|
return payload;
|
|
});
|
|
}
|
|
payload.value = result.value;
|
|
if (result.issues.length) {
|
|
payload.value = def.catchValue({
|
|
...payload,
|
|
error: {
|
|
issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config()))
|
|
},
|
|
input: payload.value
|
|
});
|
|
payload.issues = [];
|
|
payload.fallback = true;
|
|
}
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
defineLazy(inst._zod, "values", () => def.in._zod.values);
|
|
defineLazy(inst._zod, "optin", () => def.in._zod.optin);
|
|
defineLazy(inst._zod, "optout", () => def.out._zod.optout);
|
|
defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
const right = def.out._zod.run(payload, ctx);
|
|
if (right instanceof Promise) {
|
|
return right.then((right2) => handlePipeResult(right2, def.in, ctx));
|
|
}
|
|
return handlePipeResult(right, def.in, ctx);
|
|
}
|
|
const left = def.in._zod.run(payload, ctx);
|
|
if (left instanceof Promise) {
|
|
return left.then((left2) => handlePipeResult(left2, def.out, ctx));
|
|
}
|
|
return handlePipeResult(left, def.out, ctx);
|
|
};
|
|
});
|
|
function handlePipeResult(left, next, ctx) {
|
|
if (left.issues.length) {
|
|
left.aborted = true;
|
|
return left;
|
|
}
|
|
return next._zod.run({ value: left.value, issues: left.issues, fallback: left.fallback }, ctx);
|
|
}
|
|
var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
|
|
defineLazy(inst._zod, "values", () => def.innerType._zod.values);
|
|
defineLazy(inst._zod, "optin", () => def.innerType?._zod?.optin);
|
|
defineLazy(inst._zod, "optout", () => def.innerType?._zod?.optout);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
return def.innerType._zod.run(payload, ctx);
|
|
}
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
return result.then(handleReadonlyResult);
|
|
}
|
|
return handleReadonlyResult(result);
|
|
};
|
|
});
|
|
function handleReadonlyResult(payload) {
|
|
payload.value = Object.freeze(payload.value);
|
|
return payload;
|
|
}
|
|
var $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, _) => {
|
|
return payload;
|
|
};
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const r = def.fn(input);
|
|
if (r instanceof Promise) {
|
|
return r.then((r2) => handleRefineResult(r2, payload, input, inst));
|
|
}
|
|
handleRefineResult(r, payload, input, inst);
|
|
return;
|
|
};
|
|
});
|
|
function handleRefineResult(result, payload, input, inst) {
|
|
if (!result) {
|
|
const _iss = {
|
|
code: "custom",
|
|
input,
|
|
inst,
|
|
path: [...inst._zod.def.path ?? []],
|
|
continue: !inst._zod.def.abort
|
|
};
|
|
if (inst._zod.def.params)
|
|
_iss.params = inst._zod.def.params;
|
|
payload.issues.push(issue(_iss));
|
|
}
|
|
}
|
|
// node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/registries.js
|
|
var _a2;
|
|
var $output = Symbol("ZodOutput");
|
|
var $input = Symbol("ZodInput");
|
|
|
|
class $ZodRegistry {
|
|
constructor() {
|
|
this._map = new WeakMap;
|
|
this._idmap = new Map;
|
|
}
|
|
add(schema, ..._meta) {
|
|
const meta = _meta[0];
|
|
this._map.set(schema, meta);
|
|
if (meta && typeof meta === "object" && "id" in meta) {
|
|
this._idmap.set(meta.id, schema);
|
|
}
|
|
return this;
|
|
}
|
|
clear() {
|
|
this._map = new WeakMap;
|
|
this._idmap = new Map;
|
|
return this;
|
|
}
|
|
remove(schema) {
|
|
const meta = this._map.get(schema);
|
|
if (meta && typeof meta === "object" && "id" in meta) {
|
|
this._idmap.delete(meta.id);
|
|
}
|
|
this._map.delete(schema);
|
|
return this;
|
|
}
|
|
get(schema) {
|
|
const p = schema._zod.parent;
|
|
if (p) {
|
|
const pm = { ...this.get(p) ?? {} };
|
|
delete pm.id;
|
|
const f = { ...pm, ...this._map.get(schema) };
|
|
return Object.keys(f).length ? f : undefined;
|
|
}
|
|
return this._map.get(schema);
|
|
}
|
|
has(schema) {
|
|
return this._map.has(schema);
|
|
}
|
|
}
|
|
function registry() {
|
|
return new $ZodRegistry;
|
|
}
|
|
(_a2 = globalThis).__zod_globalRegistry ?? (_a2.__zod_globalRegistry = registry());
|
|
var globalRegistry = globalThis.__zod_globalRegistry;
|
|
// node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/api.js
|
|
function _string(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _email(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "email",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _guid(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "guid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _uuid(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "uuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _uuidv4(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "uuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
version: "v4",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _uuidv6(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "uuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
version: "v6",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _uuidv7(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "uuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
version: "v7",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _url(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "url",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _emoji2(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "emoji",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _nanoid(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "nanoid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _cuid(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "cuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _cuid2(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "cuid2",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _ulid(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "ulid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _xid(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "xid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _ksuid(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "ksuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _ipv4(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "ipv4",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _ipv6(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "ipv6",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _cidrv4(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "cidrv4",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _cidrv6(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "cidrv6",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _base64(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "base64",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _base64url(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "base64url",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _e164(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "e164",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _jwt(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "jwt",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _isoDateTime(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "datetime",
|
|
check: "string_format",
|
|
offset: false,
|
|
local: false,
|
|
precision: null,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _isoDate(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "date",
|
|
check: "string_format",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _isoTime(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "time",
|
|
check: "string_format",
|
|
precision: null,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _isoDuration(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "duration",
|
|
check: "string_format",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _null2(Class2, params) {
|
|
return new Class2({
|
|
type: "null",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _unknown(Class2) {
|
|
return new Class2({
|
|
type: "unknown"
|
|
});
|
|
}
|
|
function _never(Class2, params) {
|
|
return new Class2({
|
|
type: "never",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _maxLength(maximum, params) {
|
|
const ch = new $ZodCheckMaxLength({
|
|
check: "max_length",
|
|
...normalizeParams(params),
|
|
maximum
|
|
});
|
|
return ch;
|
|
}
|
|
function _minLength(minimum, params) {
|
|
return new $ZodCheckMinLength({
|
|
check: "min_length",
|
|
...normalizeParams(params),
|
|
minimum
|
|
});
|
|
}
|
|
function _length(length, params) {
|
|
return new $ZodCheckLengthEquals({
|
|
check: "length_equals",
|
|
...normalizeParams(params),
|
|
length
|
|
});
|
|
}
|
|
function _regex(pattern, params) {
|
|
return new $ZodCheckRegex({
|
|
check: "string_format",
|
|
format: "regex",
|
|
...normalizeParams(params),
|
|
pattern
|
|
});
|
|
}
|
|
function _lowercase(params) {
|
|
return new $ZodCheckLowerCase({
|
|
check: "string_format",
|
|
format: "lowercase",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _uppercase(params) {
|
|
return new $ZodCheckUpperCase({
|
|
check: "string_format",
|
|
format: "uppercase",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _includes(includes, params) {
|
|
return new $ZodCheckIncludes({
|
|
check: "string_format",
|
|
format: "includes",
|
|
...normalizeParams(params),
|
|
includes
|
|
});
|
|
}
|
|
function _startsWith(prefix, params) {
|
|
return new $ZodCheckStartsWith({
|
|
check: "string_format",
|
|
format: "starts_with",
|
|
...normalizeParams(params),
|
|
prefix
|
|
});
|
|
}
|
|
function _endsWith(suffix, params) {
|
|
return new $ZodCheckEndsWith({
|
|
check: "string_format",
|
|
format: "ends_with",
|
|
...normalizeParams(params),
|
|
suffix
|
|
});
|
|
}
|
|
function _overwrite(tx) {
|
|
return new $ZodCheckOverwrite({
|
|
check: "overwrite",
|
|
tx
|
|
});
|
|
}
|
|
function _normalize(form) {
|
|
return _overwrite((input) => input.normalize(form));
|
|
}
|
|
function _trim() {
|
|
return _overwrite((input) => input.trim());
|
|
}
|
|
function _toLowerCase() {
|
|
return _overwrite((input) => input.toLowerCase());
|
|
}
|
|
function _toUpperCase() {
|
|
return _overwrite((input) => input.toUpperCase());
|
|
}
|
|
function _slugify() {
|
|
return _overwrite((input) => slugify(input));
|
|
}
|
|
function _array(Class2, element, params) {
|
|
return new Class2({
|
|
type: "array",
|
|
element,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _refine(Class2, fn, _params) {
|
|
const schema = new Class2({
|
|
type: "custom",
|
|
check: "custom",
|
|
fn,
|
|
...normalizeParams(_params)
|
|
});
|
|
return schema;
|
|
}
|
|
function _superRefine(fn, params) {
|
|
const ch = _check((payload) => {
|
|
payload.addIssue = (issue2) => {
|
|
if (typeof issue2 === "string") {
|
|
payload.issues.push(issue(issue2, payload.value, ch._zod.def));
|
|
} else {
|
|
const _issue = issue2;
|
|
if (_issue.fatal)
|
|
_issue.continue = false;
|
|
_issue.code ?? (_issue.code = "custom");
|
|
_issue.input ?? (_issue.input = payload.value);
|
|
_issue.inst ?? (_issue.inst = ch);
|
|
_issue.continue ?? (_issue.continue = !ch._zod.def.abort);
|
|
payload.issues.push(issue(_issue));
|
|
}
|
|
};
|
|
return fn(payload.value, payload);
|
|
}, params);
|
|
return ch;
|
|
}
|
|
function _check(fn, params) {
|
|
const ch = new $ZodCheck({
|
|
check: "custom",
|
|
...normalizeParams(params)
|
|
});
|
|
ch._zod.check = fn;
|
|
return ch;
|
|
}
|
|
// node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/to-json-schema.js
|
|
function initializeContext(params) {
|
|
let target = params?.target ?? "draft-2020-12";
|
|
if (target === "draft-4")
|
|
target = "draft-04";
|
|
if (target === "draft-7")
|
|
target = "draft-07";
|
|
return {
|
|
processors: params.processors ?? {},
|
|
metadataRegistry: params?.metadata ?? globalRegistry,
|
|
target,
|
|
unrepresentable: params?.unrepresentable ?? "throw",
|
|
override: params?.override ?? (() => {}),
|
|
io: params?.io ?? "output",
|
|
counter: 0,
|
|
seen: new Map,
|
|
cycles: params?.cycles ?? "ref",
|
|
reused: params?.reused ?? "inline",
|
|
external: params?.external ?? undefined
|
|
};
|
|
}
|
|
function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
|
|
var _a3;
|
|
const def = schema._zod.def;
|
|
const seen = ctx.seen.get(schema);
|
|
if (seen) {
|
|
seen.count++;
|
|
const isCycle = _params.schemaPath.includes(schema);
|
|
if (isCycle) {
|
|
seen.cycle = _params.path;
|
|
}
|
|
return seen.schema;
|
|
}
|
|
const result = { schema: {}, count: 1, cycle: undefined, path: _params.path };
|
|
ctx.seen.set(schema, result);
|
|
const overrideSchema = schema._zod.toJSONSchema?.();
|
|
if (overrideSchema) {
|
|
result.schema = overrideSchema;
|
|
} else {
|
|
const params = {
|
|
..._params,
|
|
schemaPath: [..._params.schemaPath, schema],
|
|
path: _params.path
|
|
};
|
|
if (schema._zod.processJSONSchema) {
|
|
schema._zod.processJSONSchema(ctx, result.schema, params);
|
|
} else {
|
|
const _json = result.schema;
|
|
const processor = ctx.processors[def.type];
|
|
if (!processor) {
|
|
throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
|
|
}
|
|
processor(schema, ctx, _json, params);
|
|
}
|
|
const parent = schema._zod.parent;
|
|
if (parent) {
|
|
if (!result.ref)
|
|
result.ref = parent;
|
|
process(parent, ctx, params);
|
|
ctx.seen.get(parent).isParent = true;
|
|
}
|
|
}
|
|
const meta = ctx.metadataRegistry.get(schema);
|
|
if (meta)
|
|
Object.assign(result.schema, meta);
|
|
if (ctx.io === "input" && isTransforming(schema)) {
|
|
delete result.schema.examples;
|
|
delete result.schema.default;
|
|
}
|
|
if (ctx.io === "input" && "_prefault" in result.schema)
|
|
(_a3 = result.schema).default ?? (_a3.default = result.schema._prefault);
|
|
delete result.schema._prefault;
|
|
const _result = ctx.seen.get(schema);
|
|
return _result.schema;
|
|
}
|
|
function extractDefs(ctx, schema) {
|
|
const root = ctx.seen.get(schema);
|
|
if (!root)
|
|
throw new Error("Unprocessed schema. This is a bug in Zod.");
|
|
const idToSchema = new Map;
|
|
for (const entry of ctx.seen.entries()) {
|
|
const id = ctx.metadataRegistry.get(entry[0])?.id;
|
|
if (id) {
|
|
const existing = idToSchema.get(id);
|
|
if (existing && existing !== entry[0]) {
|
|
throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
|
|
}
|
|
idToSchema.set(id, entry[0]);
|
|
}
|
|
}
|
|
const makeURI = (entry) => {
|
|
const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
|
|
if (ctx.external) {
|
|
const externalId = ctx.external.registry.get(entry[0])?.id;
|
|
const uriGenerator = ctx.external.uri ?? ((id2) => id2);
|
|
if (externalId) {
|
|
return { ref: uriGenerator(externalId) };
|
|
}
|
|
const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
|
|
entry[1].defId = id;
|
|
return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
|
|
}
|
|
if (entry[1] === root) {
|
|
return { ref: "#" };
|
|
}
|
|
const uriPrefix = `#`;
|
|
const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
|
|
const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
|
|
return { defId, ref: defUriPrefix + defId };
|
|
};
|
|
const extractToDef = (entry) => {
|
|
if (entry[1].schema.$ref) {
|
|
return;
|
|
}
|
|
const seen = entry[1];
|
|
const { ref, defId } = makeURI(entry);
|
|
seen.def = { ...seen.schema };
|
|
if (defId)
|
|
seen.defId = defId;
|
|
const schema2 = seen.schema;
|
|
for (const key in schema2) {
|
|
delete schema2[key];
|
|
}
|
|
schema2.$ref = ref;
|
|
};
|
|
if (ctx.cycles === "throw") {
|
|
for (const entry of ctx.seen.entries()) {
|
|
const seen = entry[1];
|
|
if (seen.cycle) {
|
|
throw new Error("Cycle detected: " + `#/${seen.cycle?.join("/")}/<root>` + '\n\nSet the `cycles` parameter to `"ref"` to resolve cyclical schemas with defs.');
|
|
}
|
|
}
|
|
}
|
|
for (const entry of ctx.seen.entries()) {
|
|
const seen = entry[1];
|
|
if (schema === entry[0]) {
|
|
extractToDef(entry);
|
|
continue;
|
|
}
|
|
if (ctx.external) {
|
|
const ext = ctx.external.registry.get(entry[0])?.id;
|
|
if (schema !== entry[0] && ext) {
|
|
extractToDef(entry);
|
|
continue;
|
|
}
|
|
}
|
|
const id = ctx.metadataRegistry.get(entry[0])?.id;
|
|
if (id) {
|
|
extractToDef(entry);
|
|
continue;
|
|
}
|
|
if (seen.cycle) {
|
|
extractToDef(entry);
|
|
continue;
|
|
}
|
|
if (seen.count > 1) {
|
|
if (ctx.reused === "ref") {
|
|
extractToDef(entry);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function finalize(ctx, schema) {
|
|
const root = ctx.seen.get(schema);
|
|
if (!root)
|
|
throw new Error("Unprocessed schema. This is a bug in Zod.");
|
|
const flattenRef = (zodSchema) => {
|
|
const seen = ctx.seen.get(zodSchema);
|
|
if (seen.ref === null)
|
|
return;
|
|
const schema2 = seen.def ?? seen.schema;
|
|
const _cached = { ...schema2 };
|
|
const ref = seen.ref;
|
|
seen.ref = null;
|
|
if (ref) {
|
|
flattenRef(ref);
|
|
const refSeen = ctx.seen.get(ref);
|
|
const refSchema = refSeen.schema;
|
|
if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
|
|
schema2.allOf = schema2.allOf ?? [];
|
|
schema2.allOf.push(refSchema);
|
|
} else {
|
|
Object.assign(schema2, refSchema);
|
|
}
|
|
Object.assign(schema2, _cached);
|
|
const isParentRef = zodSchema._zod.parent === ref;
|
|
if (isParentRef) {
|
|
for (const key in schema2) {
|
|
if (key === "$ref" || key === "allOf")
|
|
continue;
|
|
if (!(key in _cached)) {
|
|
delete schema2[key];
|
|
}
|
|
}
|
|
}
|
|
if (refSchema.$ref && refSeen.def) {
|
|
for (const key in schema2) {
|
|
if (key === "$ref" || key === "allOf")
|
|
continue;
|
|
if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) {
|
|
delete schema2[key];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const parent = zodSchema._zod.parent;
|
|
if (parent && parent !== ref) {
|
|
flattenRef(parent);
|
|
const parentSeen = ctx.seen.get(parent);
|
|
if (parentSeen?.schema.$ref) {
|
|
schema2.$ref = parentSeen.schema.$ref;
|
|
if (parentSeen.def) {
|
|
for (const key in schema2) {
|
|
if (key === "$ref" || key === "allOf")
|
|
continue;
|
|
if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) {
|
|
delete schema2[key];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ctx.override({
|
|
zodSchema,
|
|
jsonSchema: schema2,
|
|
path: seen.path ?? []
|
|
});
|
|
};
|
|
for (const entry of [...ctx.seen.entries()].reverse()) {
|
|
flattenRef(entry[0]);
|
|
}
|
|
const result = {};
|
|
if (ctx.target === "draft-2020-12") {
|
|
result.$schema = "https://json-schema.org/draft/2020-12/schema";
|
|
} else if (ctx.target === "draft-07") {
|
|
result.$schema = "http://json-schema.org/draft-07/schema#";
|
|
} else if (ctx.target === "draft-04") {
|
|
result.$schema = "http://json-schema.org/draft-04/schema#";
|
|
} else if (ctx.target === "openapi-3.0") {} else {}
|
|
if (ctx.external?.uri) {
|
|
const id = ctx.external.registry.get(schema)?.id;
|
|
if (!id)
|
|
throw new Error("Schema is missing an `id` property");
|
|
result.$id = ctx.external.uri(id);
|
|
}
|
|
Object.assign(result, root.def ?? root.schema);
|
|
const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
|
|
if (rootMetaId !== undefined && result.id === rootMetaId)
|
|
delete result.id;
|
|
const defs = ctx.external?.defs ?? {};
|
|
for (const entry of ctx.seen.entries()) {
|
|
const seen = entry[1];
|
|
if (seen.def && seen.defId) {
|
|
if (seen.def.id === seen.defId)
|
|
delete seen.def.id;
|
|
defs[seen.defId] = seen.def;
|
|
}
|
|
}
|
|
if (ctx.external) {} else {
|
|
if (Object.keys(defs).length > 0) {
|
|
if (ctx.target === "draft-2020-12") {
|
|
result.$defs = defs;
|
|
} else {
|
|
result.definitions = defs;
|
|
}
|
|
}
|
|
}
|
|
try {
|
|
const finalized = JSON.parse(JSON.stringify(result));
|
|
Object.defineProperty(finalized, "~standard", {
|
|
value: {
|
|
...schema["~standard"],
|
|
jsonSchema: {
|
|
input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
|
|
output: createStandardJSONSchemaMethod(schema, "output", ctx.processors)
|
|
}
|
|
},
|
|
enumerable: false,
|
|
writable: false
|
|
});
|
|
return finalized;
|
|
} catch (_err) {
|
|
throw new Error("Error converting schema to JSON.");
|
|
}
|
|
}
|
|
function isTransforming(_schema, _ctx) {
|
|
const ctx = _ctx ?? { seen: new Set };
|
|
if (ctx.seen.has(_schema))
|
|
return false;
|
|
ctx.seen.add(_schema);
|
|
const def = _schema._zod.def;
|
|
if (def.type === "transform")
|
|
return true;
|
|
if (def.type === "array")
|
|
return isTransforming(def.element, ctx);
|
|
if (def.type === "set")
|
|
return isTransforming(def.valueType, ctx);
|
|
if (def.type === "lazy")
|
|
return isTransforming(def.getter(), ctx);
|
|
if (def.type === "promise" || def.type === "optional" || def.type === "nonoptional" || def.type === "nullable" || def.type === "readonly" || def.type === "default" || def.type === "prefault") {
|
|
return isTransforming(def.innerType, ctx);
|
|
}
|
|
if (def.type === "intersection") {
|
|
return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
|
|
}
|
|
if (def.type === "record" || def.type === "map") {
|
|
return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
|
|
}
|
|
if (def.type === "pipe") {
|
|
if (_schema._zod.traits.has("$ZodCodec"))
|
|
return true;
|
|
return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
|
|
}
|
|
if (def.type === "object") {
|
|
for (const key in def.shape) {
|
|
if (isTransforming(def.shape[key], ctx))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
if (def.type === "union") {
|
|
for (const option of def.options) {
|
|
if (isTransforming(option, ctx))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
if (def.type === "tuple") {
|
|
for (const item of def.items) {
|
|
if (isTransforming(item, ctx))
|
|
return true;
|
|
}
|
|
if (def.rest && isTransforming(def.rest, ctx))
|
|
return true;
|
|
return false;
|
|
}
|
|
return false;
|
|
}
|
|
var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
|
|
const ctx = initializeContext({ ...params, processors });
|
|
process(schema, ctx);
|
|
extractDefs(ctx, schema);
|
|
return finalize(ctx, schema);
|
|
};
|
|
var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
|
|
const { libraryOptions, target } = params ?? {};
|
|
const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
|
|
process(schema, ctx);
|
|
extractDefs(ctx, schema);
|
|
return finalize(ctx, schema);
|
|
};
|
|
// node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/json-schema-processors.js
|
|
var formatMap = {
|
|
guid: "uuid",
|
|
url: "uri",
|
|
datetime: "date-time",
|
|
json_string: "json-string",
|
|
regex: ""
|
|
};
|
|
var stringProcessor = (schema, ctx, _json, _params) => {
|
|
const json = _json;
|
|
json.type = "string";
|
|
const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
|
|
if (typeof minimum === "number")
|
|
json.minLength = minimum;
|
|
if (typeof maximum === "number")
|
|
json.maxLength = maximum;
|
|
if (format) {
|
|
json.format = formatMap[format] ?? format;
|
|
if (json.format === "")
|
|
delete json.format;
|
|
if (format === "time") {
|
|
delete json.format;
|
|
}
|
|
}
|
|
if (contentEncoding)
|
|
json.contentEncoding = contentEncoding;
|
|
if (patterns && patterns.size > 0) {
|
|
const regexes = [...patterns];
|
|
if (regexes.length === 1)
|
|
json.pattern = regexes[0].source;
|
|
else if (regexes.length > 1) {
|
|
json.allOf = [
|
|
...regexes.map((regex) => ({
|
|
...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
|
|
pattern: regex.source
|
|
}))
|
|
];
|
|
}
|
|
}
|
|
};
|
|
var nullProcessor = (_schema, ctx, json, _params) => {
|
|
if (ctx.target === "openapi-3.0") {
|
|
json.type = "string";
|
|
json.nullable = true;
|
|
json.enum = [null];
|
|
} else {
|
|
json.type = "null";
|
|
}
|
|
};
|
|
var neverProcessor = (_schema, _ctx, json, _params) => {
|
|
json.not = {};
|
|
};
|
|
var unknownProcessor = (_schema, _ctx, _json, _params) => {};
|
|
var enumProcessor = (schema, _ctx, json, _params) => {
|
|
const def = schema._zod.def;
|
|
const values = getEnumValues(def.entries);
|
|
if (values.every((v) => typeof v === "number"))
|
|
json.type = "number";
|
|
if (values.every((v) => typeof v === "string"))
|
|
json.type = "string";
|
|
json.enum = values;
|
|
};
|
|
var literalProcessor = (schema, ctx, json, _params) => {
|
|
const def = schema._zod.def;
|
|
const vals = [];
|
|
for (const val of def.values) {
|
|
if (val === undefined) {
|
|
if (ctx.unrepresentable === "throw") {
|
|
throw new Error("Literal `undefined` cannot be represented in JSON Schema");
|
|
} else {}
|
|
} else if (typeof val === "bigint") {
|
|
if (ctx.unrepresentable === "throw") {
|
|
throw new Error("BigInt literals cannot be represented in JSON Schema");
|
|
} else {
|
|
vals.push(Number(val));
|
|
}
|
|
} else {
|
|
vals.push(val);
|
|
}
|
|
}
|
|
if (vals.length === 0) {} else if (vals.length === 1) {
|
|
const val = vals[0];
|
|
json.type = val === null ? "null" : typeof val;
|
|
if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
|
|
json.enum = [val];
|
|
} else {
|
|
json.const = val;
|
|
}
|
|
} else {
|
|
if (vals.every((v) => typeof v === "number"))
|
|
json.type = "number";
|
|
if (vals.every((v) => typeof v === "string"))
|
|
json.type = "string";
|
|
if (vals.every((v) => typeof v === "boolean"))
|
|
json.type = "boolean";
|
|
if (vals.every((v) => v === null))
|
|
json.type = "null";
|
|
json.enum = vals;
|
|
}
|
|
};
|
|
var customProcessor = (_schema, ctx, _json, _params) => {
|
|
if (ctx.unrepresentable === "throw") {
|
|
throw new Error("Custom types cannot be represented in JSON Schema");
|
|
}
|
|
};
|
|
var transformProcessor = (_schema, ctx, _json, _params) => {
|
|
if (ctx.unrepresentable === "throw") {
|
|
throw new Error("Transforms cannot be represented in JSON Schema");
|
|
}
|
|
};
|
|
var arrayProcessor = (schema, ctx, _json, params) => {
|
|
const json = _json;
|
|
const def = schema._zod.def;
|
|
const { minimum, maximum } = schema._zod.bag;
|
|
if (typeof minimum === "number")
|
|
json.minItems = minimum;
|
|
if (typeof maximum === "number")
|
|
json.maxItems = maximum;
|
|
json.type = "array";
|
|
json.items = process(def.element, ctx, {
|
|
...params,
|
|
path: [...params.path, "items"]
|
|
});
|
|
};
|
|
var objectProcessor = (schema, ctx, _json, params) => {
|
|
const json = _json;
|
|
const def = schema._zod.def;
|
|
json.type = "object";
|
|
json.properties = {};
|
|
const shape = def.shape;
|
|
for (const key in shape) {
|
|
json.properties[key] = process(shape[key], ctx, {
|
|
...params,
|
|
path: [...params.path, "properties", key]
|
|
});
|
|
}
|
|
const allKeys = new Set(Object.keys(shape));
|
|
const requiredKeys = new Set([...allKeys].filter((key) => {
|
|
const v = def.shape[key]._zod;
|
|
if (ctx.io === "input") {
|
|
return v.optin === undefined;
|
|
} else {
|
|
return v.optout === undefined;
|
|
}
|
|
}));
|
|
if (requiredKeys.size > 0) {
|
|
json.required = Array.from(requiredKeys);
|
|
}
|
|
if (def.catchall?._zod.def.type === "never") {
|
|
json.additionalProperties = false;
|
|
} else if (!def.catchall) {
|
|
if (ctx.io === "output")
|
|
json.additionalProperties = false;
|
|
} else if (def.catchall) {
|
|
json.additionalProperties = process(def.catchall, ctx, {
|
|
...params,
|
|
path: [...params.path, "additionalProperties"]
|
|
});
|
|
}
|
|
};
|
|
var unionProcessor = (schema, ctx, json, params) => {
|
|
const def = schema._zod.def;
|
|
const isExclusive = def.inclusive === false;
|
|
const options = def.options.map((x, i) => process(x, ctx, {
|
|
...params,
|
|
path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
|
|
}));
|
|
if (isExclusive) {
|
|
json.oneOf = options;
|
|
} else {
|
|
json.anyOf = options;
|
|
}
|
|
};
|
|
var intersectionProcessor = (schema, ctx, json, params) => {
|
|
const def = schema._zod.def;
|
|
const a = process(def.left, ctx, {
|
|
...params,
|
|
path: [...params.path, "allOf", 0]
|
|
});
|
|
const b = process(def.right, ctx, {
|
|
...params,
|
|
path: [...params.path, "allOf", 1]
|
|
});
|
|
const isSimpleIntersection = (val) => ("allOf" in val) && Object.keys(val).length === 1;
|
|
const allOf = [
|
|
...isSimpleIntersection(a) ? a.allOf : [a],
|
|
...isSimpleIntersection(b) ? b.allOf : [b]
|
|
];
|
|
json.allOf = allOf;
|
|
};
|
|
var nullableProcessor = (schema, ctx, json, params) => {
|
|
const def = schema._zod.def;
|
|
const inner = process(def.innerType, ctx, params);
|
|
const seen = ctx.seen.get(schema);
|
|
if (ctx.target === "openapi-3.0") {
|
|
seen.ref = def.innerType;
|
|
json.nullable = true;
|
|
} else {
|
|
json.anyOf = [inner, { type: "null" }];
|
|
}
|
|
};
|
|
var nonoptionalProcessor = (schema, ctx, _json, params) => {
|
|
const def = schema._zod.def;
|
|
process(def.innerType, ctx, params);
|
|
const seen = ctx.seen.get(schema);
|
|
seen.ref = def.innerType;
|
|
};
|
|
var defaultProcessor = (schema, ctx, json, params) => {
|
|
const def = schema._zod.def;
|
|
process(def.innerType, ctx, params);
|
|
const seen = ctx.seen.get(schema);
|
|
seen.ref = def.innerType;
|
|
json.default = JSON.parse(JSON.stringify(def.defaultValue));
|
|
};
|
|
var prefaultProcessor = (schema, ctx, json, params) => {
|
|
const def = schema._zod.def;
|
|
process(def.innerType, ctx, params);
|
|
const seen = ctx.seen.get(schema);
|
|
seen.ref = def.innerType;
|
|
if (ctx.io === "input")
|
|
json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
|
|
};
|
|
var catchProcessor = (schema, ctx, json, params) => {
|
|
const def = schema._zod.def;
|
|
process(def.innerType, ctx, params);
|
|
const seen = ctx.seen.get(schema);
|
|
seen.ref = def.innerType;
|
|
let catchValue;
|
|
try {
|
|
catchValue = def.catchValue(undefined);
|
|
} catch {
|
|
throw new Error("Dynamic catch values are not supported in JSON Schema");
|
|
}
|
|
json.default = catchValue;
|
|
};
|
|
var pipeProcessor = (schema, ctx, _json, params) => {
|
|
const def = schema._zod.def;
|
|
const inIsTransform = def.in._zod.traits.has("$ZodTransform");
|
|
const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
|
|
process(innerType, ctx, params);
|
|
const seen = ctx.seen.get(schema);
|
|
seen.ref = innerType;
|
|
};
|
|
var readonlyProcessor = (schema, ctx, json, params) => {
|
|
const def = schema._zod.def;
|
|
process(def.innerType, ctx, params);
|
|
const seen = ctx.seen.get(schema);
|
|
seen.ref = def.innerType;
|
|
json.readOnly = true;
|
|
};
|
|
var optionalProcessor = (schema, ctx, _json, params) => {
|
|
const def = schema._zod.def;
|
|
process(def.innerType, ctx, params);
|
|
const seen = ctx.seen.get(schema);
|
|
seen.ref = def.innerType;
|
|
};
|
|
// node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/iso.js
|
|
var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
|
|
$ZodISODateTime.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function datetime2(params) {
|
|
return _isoDateTime(ZodISODateTime, params);
|
|
}
|
|
var ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => {
|
|
$ZodISODate.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function date2(params) {
|
|
return _isoDate(ZodISODate, params);
|
|
}
|
|
var ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => {
|
|
$ZodISOTime.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function time2(params) {
|
|
return _isoTime(ZodISOTime, params);
|
|
}
|
|
var ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (inst, def) => {
|
|
$ZodISODuration.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function duration2(params) {
|
|
return _isoDuration(ZodISODuration, params);
|
|
}
|
|
|
|
// node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/errors.js
|
|
var initializer2 = (inst, issues) => {
|
|
$ZodError.init(inst, issues);
|
|
inst.name = "ZodError";
|
|
Object.defineProperties(inst, {
|
|
format: {
|
|
value: (mapper) => formatError(inst, mapper)
|
|
},
|
|
flatten: {
|
|
value: (mapper) => flattenError(inst, mapper)
|
|
},
|
|
addIssue: {
|
|
value: (issue2) => {
|
|
inst.issues.push(issue2);
|
|
inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
|
|
}
|
|
},
|
|
addIssues: {
|
|
value: (issues2) => {
|
|
inst.issues.push(...issues2);
|
|
inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
|
|
}
|
|
},
|
|
isEmpty: {
|
|
get() {
|
|
return inst.issues.length === 0;
|
|
}
|
|
}
|
|
});
|
|
};
|
|
var ZodRealError = /* @__PURE__ */ $constructor("ZodError", initializer2, {
|
|
Parent: Error
|
|
});
|
|
|
|
// node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/parse.js
|
|
var parse3 = /* @__PURE__ */ _parse(ZodRealError);
|
|
var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
|
|
var safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
|
|
var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
|
|
var encode = /* @__PURE__ */ _encode(ZodRealError);
|
|
var decode = /* @__PURE__ */ _decode(ZodRealError);
|
|
var encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError);
|
|
var decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError);
|
|
var safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError);
|
|
var safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);
|
|
var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
|
|
var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
|
|
|
|
// node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/schemas.js
|
|
var _installedGroups = /* @__PURE__ */ new WeakMap;
|
|
function _installLazyMethods(inst, group, methods) {
|
|
const proto = Object.getPrototypeOf(inst);
|
|
let installed = _installedGroups.get(proto);
|
|
if (!installed) {
|
|
installed = new Set;
|
|
_installedGroups.set(proto, installed);
|
|
}
|
|
if (installed.has(group))
|
|
return;
|
|
installed.add(group);
|
|
for (const key in methods) {
|
|
const fn = methods[key];
|
|
Object.defineProperty(proto, key, {
|
|
configurable: true,
|
|
enumerable: false,
|
|
get() {
|
|
const bound = fn.bind(this);
|
|
Object.defineProperty(this, key, {
|
|
configurable: true,
|
|
writable: true,
|
|
enumerable: true,
|
|
value: bound
|
|
});
|
|
return bound;
|
|
},
|
|
set(v) {
|
|
Object.defineProperty(this, key, {
|
|
configurable: true,
|
|
writable: true,
|
|
enumerable: true,
|
|
value: v
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}
|
|
var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
Object.assign(inst["~standard"], {
|
|
jsonSchema: {
|
|
input: createStandardJSONSchemaMethod(inst, "input"),
|
|
output: createStandardJSONSchemaMethod(inst, "output")
|
|
}
|
|
});
|
|
inst.toJSONSchema = createToJSONSchemaMethod(inst, {});
|
|
inst.def = def;
|
|
inst.type = def.type;
|
|
Object.defineProperty(inst, "_def", { value: def });
|
|
inst.parse = (data, params) => parse3(inst, data, params, { callee: inst.parse });
|
|
inst.safeParse = (data, params) => safeParse2(inst, data, params);
|
|
inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
|
|
inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);
|
|
inst.spa = inst.safeParseAsync;
|
|
inst.encode = (data, params) => encode(inst, data, params);
|
|
inst.decode = (data, params) => decode(inst, data, params);
|
|
inst.encodeAsync = async (data, params) => encodeAsync(inst, data, params);
|
|
inst.decodeAsync = async (data, params) => decodeAsync(inst, data, params);
|
|
inst.safeEncode = (data, params) => safeEncode(inst, data, params);
|
|
inst.safeDecode = (data, params) => safeDecode(inst, data, params);
|
|
inst.safeEncodeAsync = async (data, params) => safeEncodeAsync(inst, data, params);
|
|
inst.safeDecodeAsync = async (data, params) => safeDecodeAsync(inst, data, params);
|
|
_installLazyMethods(inst, "ZodType", {
|
|
check(...chks) {
|
|
const def2 = this.def;
|
|
return this.clone(exports_util.mergeDefs(def2, {
|
|
checks: [
|
|
...def2.checks ?? [],
|
|
...chks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
|
|
]
|
|
}), { parent: true });
|
|
},
|
|
with(...chks) {
|
|
return this.check(...chks);
|
|
},
|
|
clone(def2, params) {
|
|
return clone(this, def2, params);
|
|
},
|
|
brand() {
|
|
return this;
|
|
},
|
|
register(reg, meta2) {
|
|
reg.add(this, meta2);
|
|
return this;
|
|
},
|
|
refine(check, params) {
|
|
return this.check(refine(check, params));
|
|
},
|
|
superRefine(refinement, params) {
|
|
return this.check(superRefine(refinement, params));
|
|
},
|
|
overwrite(fn) {
|
|
return this.check(_overwrite(fn));
|
|
},
|
|
optional() {
|
|
return optional(this);
|
|
},
|
|
exactOptional() {
|
|
return exactOptional(this);
|
|
},
|
|
nullable() {
|
|
return nullable(this);
|
|
},
|
|
nullish() {
|
|
return optional(nullable(this));
|
|
},
|
|
nonoptional(params) {
|
|
return nonoptional(this, params);
|
|
},
|
|
array() {
|
|
return array(this);
|
|
},
|
|
or(arg) {
|
|
return union([this, arg]);
|
|
},
|
|
and(arg) {
|
|
return intersection(this, arg);
|
|
},
|
|
transform(tx) {
|
|
return pipe(this, transform(tx));
|
|
},
|
|
default(d) {
|
|
return _default(this, d);
|
|
},
|
|
prefault(d) {
|
|
return prefault(this, d);
|
|
},
|
|
catch(params) {
|
|
return _catch(this, params);
|
|
},
|
|
pipe(target) {
|
|
return pipe(this, target);
|
|
},
|
|
readonly() {
|
|
return readonly(this);
|
|
},
|
|
describe(description) {
|
|
const cl = this.clone();
|
|
globalRegistry.add(cl, { description });
|
|
return cl;
|
|
},
|
|
meta(...args) {
|
|
if (args.length === 0)
|
|
return globalRegistry.get(this);
|
|
const cl = this.clone();
|
|
globalRegistry.add(cl, args[0]);
|
|
return cl;
|
|
},
|
|
isOptional() {
|
|
return this.safeParse(undefined).success;
|
|
},
|
|
isNullable() {
|
|
return this.safeParse(null).success;
|
|
},
|
|
apply(fn) {
|
|
return fn(this);
|
|
}
|
|
});
|
|
Object.defineProperty(inst, "description", {
|
|
get() {
|
|
return globalRegistry.get(inst)?.description;
|
|
},
|
|
configurable: true
|
|
});
|
|
return inst;
|
|
});
|
|
var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
|
|
$ZodString.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => stringProcessor(inst, ctx, json, params);
|
|
const bag = inst._zod.bag;
|
|
inst.format = bag.format ?? null;
|
|
inst.minLength = bag.minimum ?? null;
|
|
inst.maxLength = bag.maximum ?? null;
|
|
_installLazyMethods(inst, "_ZodString", {
|
|
regex(...args) {
|
|
return this.check(_regex(...args));
|
|
},
|
|
includes(...args) {
|
|
return this.check(_includes(...args));
|
|
},
|
|
startsWith(...args) {
|
|
return this.check(_startsWith(...args));
|
|
},
|
|
endsWith(...args) {
|
|
return this.check(_endsWith(...args));
|
|
},
|
|
min(...args) {
|
|
return this.check(_minLength(...args));
|
|
},
|
|
max(...args) {
|
|
return this.check(_maxLength(...args));
|
|
},
|
|
length(...args) {
|
|
return this.check(_length(...args));
|
|
},
|
|
nonempty(...args) {
|
|
return this.check(_minLength(1, ...args));
|
|
},
|
|
lowercase(params) {
|
|
return this.check(_lowercase(params));
|
|
},
|
|
uppercase(params) {
|
|
return this.check(_uppercase(params));
|
|
},
|
|
trim() {
|
|
return this.check(_trim());
|
|
},
|
|
normalize(...args) {
|
|
return this.check(_normalize(...args));
|
|
},
|
|
toLowerCase() {
|
|
return this.check(_toLowerCase());
|
|
},
|
|
toUpperCase() {
|
|
return this.check(_toUpperCase());
|
|
},
|
|
slugify() {
|
|
return this.check(_slugify());
|
|
}
|
|
});
|
|
});
|
|
var ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
|
|
$ZodString.init(inst, def);
|
|
_ZodString.init(inst, def);
|
|
inst.email = (params) => inst.check(_email(ZodEmail, params));
|
|
inst.url = (params) => inst.check(_url(ZodURL, params));
|
|
inst.jwt = (params) => inst.check(_jwt(ZodJWT, params));
|
|
inst.emoji = (params) => inst.check(_emoji2(ZodEmoji, params));
|
|
inst.guid = (params) => inst.check(_guid(ZodGUID, params));
|
|
inst.uuid = (params) => inst.check(_uuid(ZodUUID, params));
|
|
inst.uuidv4 = (params) => inst.check(_uuidv4(ZodUUID, params));
|
|
inst.uuidv6 = (params) => inst.check(_uuidv6(ZodUUID, params));
|
|
inst.uuidv7 = (params) => inst.check(_uuidv7(ZodUUID, params));
|
|
inst.nanoid = (params) => inst.check(_nanoid(ZodNanoID, params));
|
|
inst.guid = (params) => inst.check(_guid(ZodGUID, params));
|
|
inst.cuid = (params) => inst.check(_cuid(ZodCUID, params));
|
|
inst.cuid2 = (params) => inst.check(_cuid2(ZodCUID2, params));
|
|
inst.ulid = (params) => inst.check(_ulid(ZodULID, params));
|
|
inst.base64 = (params) => inst.check(_base64(ZodBase64, params));
|
|
inst.base64url = (params) => inst.check(_base64url(ZodBase64URL, params));
|
|
inst.xid = (params) => inst.check(_xid(ZodXID, params));
|
|
inst.ksuid = (params) => inst.check(_ksuid(ZodKSUID, params));
|
|
inst.ipv4 = (params) => inst.check(_ipv4(ZodIPv4, params));
|
|
inst.ipv6 = (params) => inst.check(_ipv6(ZodIPv6, params));
|
|
inst.cidrv4 = (params) => inst.check(_cidrv4(ZodCIDRv4, params));
|
|
inst.cidrv6 = (params) => inst.check(_cidrv6(ZodCIDRv6, params));
|
|
inst.e164 = (params) => inst.check(_e164(ZodE164, params));
|
|
inst.datetime = (params) => inst.check(datetime2(params));
|
|
inst.date = (params) => inst.check(date2(params));
|
|
inst.time = (params) => inst.check(time2(params));
|
|
inst.duration = (params) => inst.check(duration2(params));
|
|
});
|
|
function string2(params) {
|
|
return _string(ZodString, params);
|
|
}
|
|
var ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (inst, def) => {
|
|
$ZodStringFormat.init(inst, def);
|
|
_ZodString.init(inst, def);
|
|
});
|
|
var ZodEmail = /* @__PURE__ */ $constructor("ZodEmail", (inst, def) => {
|
|
$ZodEmail.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
var ZodGUID = /* @__PURE__ */ $constructor("ZodGUID", (inst, def) => {
|
|
$ZodGUID.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
var ZodUUID = /* @__PURE__ */ $constructor("ZodUUID", (inst, def) => {
|
|
$ZodUUID.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
var ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => {
|
|
$ZodURL.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
var ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => {
|
|
$ZodEmoji.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
var ZodNanoID = /* @__PURE__ */ $constructor("ZodNanoID", (inst, def) => {
|
|
$ZodNanoID.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
var ZodCUID = /* @__PURE__ */ $constructor("ZodCUID", (inst, def) => {
|
|
$ZodCUID.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
var ZodCUID2 = /* @__PURE__ */ $constructor("ZodCUID2", (inst, def) => {
|
|
$ZodCUID2.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
var ZodULID = /* @__PURE__ */ $constructor("ZodULID", (inst, def) => {
|
|
$ZodULID.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
var ZodXID = /* @__PURE__ */ $constructor("ZodXID", (inst, def) => {
|
|
$ZodXID.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
var ZodKSUID = /* @__PURE__ */ $constructor("ZodKSUID", (inst, def) => {
|
|
$ZodKSUID.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
var ZodIPv4 = /* @__PURE__ */ $constructor("ZodIPv4", (inst, def) => {
|
|
$ZodIPv4.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
var ZodIPv6 = /* @__PURE__ */ $constructor("ZodIPv6", (inst, def) => {
|
|
$ZodIPv6.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
var ZodCIDRv4 = /* @__PURE__ */ $constructor("ZodCIDRv4", (inst, def) => {
|
|
$ZodCIDRv4.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
var ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (inst, def) => {
|
|
$ZodCIDRv6.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
var ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => {
|
|
$ZodBase64.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
var ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => {
|
|
$ZodBase64URL.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
var ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => {
|
|
$ZodE164.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
var ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
|
|
$ZodJWT.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
var ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
|
|
$ZodNull.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => nullProcessor(inst, ctx, json, params);
|
|
});
|
|
function _null3(params) {
|
|
return _null2(ZodNull, params);
|
|
}
|
|
var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
|
|
$ZodUnknown.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => unknownProcessor(inst, ctx, json, params);
|
|
});
|
|
function unknown() {
|
|
return _unknown(ZodUnknown);
|
|
}
|
|
var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
|
|
$ZodNever.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => neverProcessor(inst, ctx, json, params);
|
|
});
|
|
function never(params) {
|
|
return _never(ZodNever, params);
|
|
}
|
|
var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
|
|
$ZodArray.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => arrayProcessor(inst, ctx, json, params);
|
|
inst.element = def.element;
|
|
_installLazyMethods(inst, "ZodArray", {
|
|
min(n, params) {
|
|
return this.check(_minLength(n, params));
|
|
},
|
|
nonempty(params) {
|
|
return this.check(_minLength(1, params));
|
|
},
|
|
max(n, params) {
|
|
return this.check(_maxLength(n, params));
|
|
},
|
|
length(n, params) {
|
|
return this.check(_length(n, params));
|
|
},
|
|
unwrap() {
|
|
return this.element;
|
|
}
|
|
});
|
|
});
|
|
function array(element, params) {
|
|
return _array(ZodArray, element, params);
|
|
}
|
|
var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
|
|
$ZodObjectJIT.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => objectProcessor(inst, ctx, json, params);
|
|
exports_util.defineLazy(inst, "shape", () => {
|
|
return def.shape;
|
|
});
|
|
_installLazyMethods(inst, "ZodObject", {
|
|
keyof() {
|
|
return _enum(Object.keys(this._zod.def.shape));
|
|
},
|
|
catchall(catchall) {
|
|
return this.clone({ ...this._zod.def, catchall });
|
|
},
|
|
passthrough() {
|
|
return this.clone({ ...this._zod.def, catchall: unknown() });
|
|
},
|
|
loose() {
|
|
return this.clone({ ...this._zod.def, catchall: unknown() });
|
|
},
|
|
strict() {
|
|
return this.clone({ ...this._zod.def, catchall: never() });
|
|
},
|
|
strip() {
|
|
return this.clone({ ...this._zod.def, catchall: undefined });
|
|
},
|
|
extend(incoming) {
|
|
return exports_util.extend(this, incoming);
|
|
},
|
|
safeExtend(incoming) {
|
|
return exports_util.safeExtend(this, incoming);
|
|
},
|
|
merge(other) {
|
|
return exports_util.merge(this, other);
|
|
},
|
|
pick(mask) {
|
|
return exports_util.pick(this, mask);
|
|
},
|
|
omit(mask) {
|
|
return exports_util.omit(this, mask);
|
|
},
|
|
partial(...args) {
|
|
return exports_util.partial(ZodOptional, this, args[0]);
|
|
},
|
|
required(...args) {
|
|
return exports_util.required(ZodNonOptional, this, args[0]);
|
|
}
|
|
});
|
|
});
|
|
function object(shape, params) {
|
|
const def = {
|
|
type: "object",
|
|
shape: shape ?? {},
|
|
...exports_util.normalizeParams(params)
|
|
};
|
|
return new ZodObject(def);
|
|
}
|
|
var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
|
|
$ZodUnion.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => unionProcessor(inst, ctx, json, params);
|
|
inst.options = def.options;
|
|
});
|
|
function union(options, params) {
|
|
return new ZodUnion({
|
|
type: "union",
|
|
options,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("ZodDiscriminatedUnion", (inst, def) => {
|
|
ZodUnion.init(inst, def);
|
|
$ZodDiscriminatedUnion.init(inst, def);
|
|
});
|
|
function discriminatedUnion(discriminator, options, params) {
|
|
return new ZodDiscriminatedUnion({
|
|
type: "union",
|
|
options,
|
|
discriminator,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
|
|
$ZodIntersection.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => intersectionProcessor(inst, ctx, json, params);
|
|
});
|
|
function intersection(left, right) {
|
|
return new ZodIntersection({
|
|
type: "intersection",
|
|
left,
|
|
right
|
|
});
|
|
}
|
|
var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
|
|
$ZodEnum.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => enumProcessor(inst, ctx, json, params);
|
|
inst.enum = def.entries;
|
|
inst.options = Object.values(def.entries);
|
|
const keys = new Set(Object.keys(def.entries));
|
|
inst.extract = (values, params) => {
|
|
const newEntries = {};
|
|
for (const value of values) {
|
|
if (keys.has(value)) {
|
|
newEntries[value] = def.entries[value];
|
|
} else
|
|
throw new Error(`Key ${value} not found in enum`);
|
|
}
|
|
return new ZodEnum({
|
|
...def,
|
|
checks: [],
|
|
...exports_util.normalizeParams(params),
|
|
entries: newEntries
|
|
});
|
|
};
|
|
inst.exclude = (values, params) => {
|
|
const newEntries = { ...def.entries };
|
|
for (const value of values) {
|
|
if (keys.has(value)) {
|
|
delete newEntries[value];
|
|
} else
|
|
throw new Error(`Key ${value} not found in enum`);
|
|
}
|
|
return new ZodEnum({
|
|
...def,
|
|
checks: [],
|
|
...exports_util.normalizeParams(params),
|
|
entries: newEntries
|
|
});
|
|
};
|
|
});
|
|
function _enum(values, params) {
|
|
const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
|
|
return new ZodEnum({
|
|
type: "enum",
|
|
entries,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
|
|
$ZodLiteral.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => literalProcessor(inst, ctx, json, params);
|
|
inst.values = new Set(def.values);
|
|
Object.defineProperty(inst, "value", {
|
|
get() {
|
|
if (def.values.length > 1) {
|
|
throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
|
|
}
|
|
return def.values[0];
|
|
}
|
|
});
|
|
});
|
|
function literal(value, params) {
|
|
return new ZodLiteral({
|
|
type: "literal",
|
|
values: Array.isArray(value) ? value : [value],
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
|
|
$ZodTransform.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => transformProcessor(inst, ctx, json, params);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (_ctx.direction === "backward") {
|
|
throw new $ZodEncodeError(inst.constructor.name);
|
|
}
|
|
payload.addIssue = (issue2) => {
|
|
if (typeof issue2 === "string") {
|
|
payload.issues.push(exports_util.issue(issue2, payload.value, def));
|
|
} else {
|
|
const _issue = issue2;
|
|
if (_issue.fatal)
|
|
_issue.continue = false;
|
|
_issue.code ?? (_issue.code = "custom");
|
|
_issue.input ?? (_issue.input = payload.value);
|
|
_issue.inst ?? (_issue.inst = inst);
|
|
payload.issues.push(exports_util.issue(_issue));
|
|
}
|
|
};
|
|
const output = def.transform(payload.value, payload);
|
|
if (output instanceof Promise) {
|
|
return output.then((output2) => {
|
|
payload.value = output2;
|
|
payload.fallback = true;
|
|
return payload;
|
|
});
|
|
}
|
|
payload.value = output;
|
|
payload.fallback = true;
|
|
return payload;
|
|
};
|
|
});
|
|
function transform(fn) {
|
|
return new ZodTransform({
|
|
type: "transform",
|
|
transform: fn
|
|
});
|
|
}
|
|
var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
|
|
$ZodOptional.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function optional(innerType) {
|
|
return new ZodOptional({
|
|
type: "optional",
|
|
innerType
|
|
});
|
|
}
|
|
var ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
|
|
$ZodExactOptional.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function exactOptional(innerType) {
|
|
return new ZodExactOptional({
|
|
type: "optional",
|
|
innerType
|
|
});
|
|
}
|
|
var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
|
|
$ZodNullable.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => nullableProcessor(inst, ctx, json, params);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function nullable(innerType) {
|
|
return new ZodNullable({
|
|
type: "nullable",
|
|
innerType
|
|
});
|
|
}
|
|
var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
|
|
$ZodDefault.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => defaultProcessor(inst, ctx, json, params);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
inst.removeDefault = inst.unwrap;
|
|
});
|
|
function _default(innerType, defaultValue) {
|
|
return new ZodDefault({
|
|
type: "default",
|
|
innerType,
|
|
get defaultValue() {
|
|
return typeof defaultValue === "function" ? defaultValue() : exports_util.shallowClone(defaultValue);
|
|
}
|
|
});
|
|
}
|
|
var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
|
|
$ZodPrefault.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => prefaultProcessor(inst, ctx, json, params);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function prefault(innerType, defaultValue) {
|
|
return new ZodPrefault({
|
|
type: "prefault",
|
|
innerType,
|
|
get defaultValue() {
|
|
return typeof defaultValue === "function" ? defaultValue() : exports_util.shallowClone(defaultValue);
|
|
}
|
|
});
|
|
}
|
|
var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
|
|
$ZodNonOptional.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => nonoptionalProcessor(inst, ctx, json, params);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function nonoptional(innerType, params) {
|
|
return new ZodNonOptional({
|
|
type: "nonoptional",
|
|
innerType,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
|
|
$ZodCatch.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => catchProcessor(inst, ctx, json, params);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
inst.removeCatch = inst.unwrap;
|
|
});
|
|
function _catch(innerType, catchValue) {
|
|
return new ZodCatch({
|
|
type: "catch",
|
|
innerType,
|
|
catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
|
|
});
|
|
}
|
|
var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
|
|
$ZodPipe.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => pipeProcessor(inst, ctx, json, params);
|
|
inst.in = def.in;
|
|
inst.out = def.out;
|
|
});
|
|
function pipe(in_, out) {
|
|
return new ZodPipe({
|
|
type: "pipe",
|
|
in: in_,
|
|
out
|
|
});
|
|
}
|
|
var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
|
|
$ZodReadonly.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => readonlyProcessor(inst, ctx, json, params);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function readonly(innerType) {
|
|
return new ZodReadonly({
|
|
type: "readonly",
|
|
innerType
|
|
});
|
|
}
|
|
var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
|
|
$ZodCustom.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => customProcessor(inst, ctx, json, params);
|
|
});
|
|
function refine(fn, _params = {}) {
|
|
return _refine(ZodCustom, fn, _params);
|
|
}
|
|
function superRefine(fn, params) {
|
|
return _superRefine(fn, params);
|
|
}
|
|
|
|
// templates/document-editor/src/roles.ts
|
|
var officeMetaSchema = discriminatedUnion("mode", [
|
|
object({ mode: literal("generate"), outputDocx: string2(), sourceDocx: _null3() }),
|
|
object({ mode: literal("edit"), outputDocx: string2(), sourceDocx: string2() })
|
|
]);
|
|
var officeRole = {
|
|
description: "Generates or edits a Word document via the office-agent CLI.",
|
|
systemPrompt: "",
|
|
schema: officeMetaSchema
|
|
};
|
|
var differMetaSchema = object({
|
|
outputDocx: string2(),
|
|
sourceDocx: string2(),
|
|
diffReport: string2()
|
|
});
|
|
var differRole = {
|
|
description: "Runs docx-diff on original and edited documents and produces an HTML diff report.",
|
|
systemPrompt: "",
|
|
schema: differMetaSchema
|
|
};
|
|
var DOCUMENT_EDITOR_DESCRIPTION = "Generate or edit a Word document via office-agent; for edits, produce an HTML diff report with docx-diff.";
|
|
var documentEditorRoles = {
|
|
office: officeRole,
|
|
differ: differRole
|
|
};
|
|
|
|
// templates/document-editor/src/descriptor.ts
|
|
import { buildDescriptor } from "@uncaged/workflow-register";
|
|
function buildDocumentEditorDescriptor() {
|
|
return buildDescriptor({
|
|
description: DOCUMENT_EDITOR_DESCRIPTION,
|
|
roles: documentEditorRoles,
|
|
table: documentEditorTable
|
|
});
|
|
}
|
|
|
|
// templates/document-editor/src/index.ts
|
|
var documentEditorDefinition = {
|
|
description: DOCUMENT_EDITOR_DESCRIPTION,
|
|
roles: documentEditorRoles,
|
|
table: documentEditorTable
|
|
};
|
|
|
|
// workflows/adapters/differ-adapter.ts
|
|
import { stat } from "node:fs/promises";
|
|
import { dirname, join } from "node:path";
|
|
import { spawnCli } from "@uncaged/workflow-util-agent";
|
|
function createDifferAdapter(config2, spawnCliFn = spawnCli) {
|
|
const command = config2.command ?? "docx-diff";
|
|
return (_systemPrompt, schema) => async (ctx, _runtime) => {
|
|
const officeStep = ctx.steps.find((s) => s.role === "office");
|
|
if (officeStep === undefined) {
|
|
throw new Error("differ: office step not found in ctx.steps (invariant violation)");
|
|
}
|
|
const officeMeta = officeStep.meta;
|
|
const { outputDocx, sourceDocx } = officeMeta;
|
|
const reportPath = join(dirname(outputDocx), "diff_report.html");
|
|
const result = await spawnCliFn(command, [sourceDocx, outputDocx, "-o", "html", "--out-file", reportPath], { cwd: null, timeoutMs: config2.timeout });
|
|
if (!result.ok) {
|
|
const e = result.error;
|
|
if (e.kind === "non_zero_exit" && e.exitCode === 1) {} else if (e.kind === "non_zero_exit") {
|
|
throw new Error(`differ: docx-diff failed (exit ${e.exitCode}): ${e.stderr}`);
|
|
} else if (e.kind === "timeout") {
|
|
throw new Error("differ: timed out");
|
|
} else {
|
|
throw new Error(`differ: spawn failed: ${e.message}`);
|
|
}
|
|
}
|
|
try {
|
|
await stat(reportPath);
|
|
} catch {
|
|
throw new Error(`differ: report file not found: ${reportPath}`);
|
|
}
|
|
const raw = JSON.stringify({ outputDocx, sourceDocx, diffReport: reportPath });
|
|
const meta2 = schema.parse(JSON.parse(raw));
|
|
return { meta: meta2, childThread: null };
|
|
};
|
|
}
|
|
|
|
// workflows/document-editor-entry.ts
|
|
var officeAdapter = createOfficeAgent({
|
|
outputDir: env("OFFICE_OUTPUT_DIR", "/tmp/office-workflow"),
|
|
command: env("OFFICE_AGENT_COMMAND", "") || null,
|
|
timeout: Number(env("OFFICE_AGENT_TIMEOUT", "0")) || null
|
|
});
|
|
var differAdapter = createDifferAdapter({
|
|
command: env("DOCX_DIFF_COMMAND", "") || null,
|
|
timeout: Number(env("DOCX_DIFF_TIMEOUT", "0")) || null
|
|
});
|
|
var run = createWorkflow(documentEditorDefinition, {
|
|
adapter: officeAdapter,
|
|
overrides: { differ: differAdapter }
|
|
});
|
|
var descriptor = buildDocumentEditorDescriptor();
|
|
export {
|
|
run,
|
|
descriptor
|
|
};
|