21494 lines
704 KiB
JavaScript
21494 lines
704 KiB
JavaScript
#!/usr/bin/env node
|
|
// (c) Anthropic PBC. All rights reserved. Use is subject to the Legal Agreements outlined here: https://code.claude.com/docs/en/legal-and-compliance.
|
|
|
|
// Version: 0.1.77
|
|
|
|
// Want to see the unminified source? We're hiring!
|
|
// https://job-boards.greenhouse.io/anthropic/jobs/4816199008
|
|
var __create = Object.create;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __toESM = (mod, isNodeMode, target) => {
|
|
target = mod != null ? __create(__getProtoOf(mod)) : {};
|
|
const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
|
|
for (let key of __getOwnPropNames(mod))
|
|
if (!__hasOwnProp.call(to, key))
|
|
__defProp(to, key, {
|
|
get: () => mod[key],
|
|
enumerable: true
|
|
});
|
|
return to;
|
|
};
|
|
var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, {
|
|
get: all[name],
|
|
enumerable: true,
|
|
configurable: true,
|
|
set: (newValue) => all[name] = () => newValue
|
|
});
|
|
};
|
|
var __dispose = Symbol.dispose || /* @__PURE__ */ Symbol.for("Symbol.dispose");
|
|
var __asyncDispose = Symbol.asyncDispose || /* @__PURE__ */ Symbol.for("Symbol.asyncDispose");
|
|
var __using = (stack, value, async) => {
|
|
if (value != null) {
|
|
if (typeof value !== "object" && typeof value !== "function")
|
|
throw TypeError('Object expected to be assigned to "using" declaration');
|
|
var dispose;
|
|
if (async)
|
|
dispose = value[__asyncDispose];
|
|
if (dispose === undefined)
|
|
dispose = value[__dispose];
|
|
if (typeof dispose !== "function")
|
|
throw TypeError("Object not disposable");
|
|
stack.push([async, dispose, value]);
|
|
} else if (async) {
|
|
stack.push([async]);
|
|
}
|
|
return value;
|
|
};
|
|
var __callDispose = (stack, error, hasError) => {
|
|
var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
|
|
return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
|
|
}, fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e), next = (it) => {
|
|
while (it = stack.pop()) {
|
|
try {
|
|
var result = it[1] && it[1].call(it[2]);
|
|
if (it[0])
|
|
return Promise.resolve(result).then(next, (e) => (fail(e), next()));
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
if (hasError)
|
|
throw error;
|
|
};
|
|
return next();
|
|
};
|
|
|
|
// ../node_modules/ajv/dist/compile/codegen/code.js
|
|
var require_code = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.regexpCode = exports.getEsmExportName = exports.getProperty = exports.safeStringify = exports.stringify = exports.strConcat = exports.addCodeArg = exports.str = exports._ = exports.nil = exports._Code = exports.Name = exports.IDENTIFIER = exports._CodeOrName = undefined;
|
|
|
|
class _CodeOrName {
|
|
}
|
|
exports._CodeOrName = _CodeOrName;
|
|
exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
|
|
|
|
class Name extends _CodeOrName {
|
|
constructor(s) {
|
|
super();
|
|
if (!exports.IDENTIFIER.test(s))
|
|
throw new Error("CodeGen: name must be a valid identifier");
|
|
this.str = s;
|
|
}
|
|
toString() {
|
|
return this.str;
|
|
}
|
|
emptyStr() {
|
|
return false;
|
|
}
|
|
get names() {
|
|
return { [this.str]: 1 };
|
|
}
|
|
}
|
|
exports.Name = Name;
|
|
|
|
class _Code extends _CodeOrName {
|
|
constructor(code) {
|
|
super();
|
|
this._items = typeof code === "string" ? [code] : code;
|
|
}
|
|
toString() {
|
|
return this.str;
|
|
}
|
|
emptyStr() {
|
|
if (this._items.length > 1)
|
|
return false;
|
|
const item = this._items[0];
|
|
return item === "" || item === '""';
|
|
}
|
|
get str() {
|
|
var _a;
|
|
return (_a = this._str) !== null && _a !== undefined ? _a : this._str = this._items.reduce((s, c) => `${s}${c}`, "");
|
|
}
|
|
get names() {
|
|
var _a;
|
|
return (_a = this._names) !== null && _a !== undefined ? _a : this._names = this._items.reduce((names, c) => {
|
|
if (c instanceof Name)
|
|
names[c.str] = (names[c.str] || 0) + 1;
|
|
return names;
|
|
}, {});
|
|
}
|
|
}
|
|
exports._Code = _Code;
|
|
exports.nil = new _Code("");
|
|
function _(strs, ...args) {
|
|
const code = [strs[0]];
|
|
let i = 0;
|
|
while (i < args.length) {
|
|
addCodeArg(code, args[i]);
|
|
code.push(strs[++i]);
|
|
}
|
|
return new _Code(code);
|
|
}
|
|
exports._ = _;
|
|
var plus = new _Code("+");
|
|
function str(strs, ...args) {
|
|
const expr = [safeStringify(strs[0])];
|
|
let i = 0;
|
|
while (i < args.length) {
|
|
expr.push(plus);
|
|
addCodeArg(expr, args[i]);
|
|
expr.push(plus, safeStringify(strs[++i]));
|
|
}
|
|
optimize(expr);
|
|
return new _Code(expr);
|
|
}
|
|
exports.str = str;
|
|
function addCodeArg(code, arg) {
|
|
if (arg instanceof _Code)
|
|
code.push(...arg._items);
|
|
else if (arg instanceof Name)
|
|
code.push(arg);
|
|
else
|
|
code.push(interpolate(arg));
|
|
}
|
|
exports.addCodeArg = addCodeArg;
|
|
function optimize(expr) {
|
|
let i = 1;
|
|
while (i < expr.length - 1) {
|
|
if (expr[i] === plus) {
|
|
const res = mergeExprItems(expr[i - 1], expr[i + 1]);
|
|
if (res !== undefined) {
|
|
expr.splice(i - 1, 3, res);
|
|
continue;
|
|
}
|
|
expr[i++] = "+";
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
function mergeExprItems(a, b) {
|
|
if (b === '""')
|
|
return a;
|
|
if (a === '""')
|
|
return b;
|
|
if (typeof a == "string") {
|
|
if (b instanceof Name || a[a.length - 1] !== '"')
|
|
return;
|
|
if (typeof b != "string")
|
|
return `${a.slice(0, -1)}${b}"`;
|
|
if (b[0] === '"')
|
|
return a.slice(0, -1) + b.slice(1);
|
|
return;
|
|
}
|
|
if (typeof b == "string" && b[0] === '"' && !(a instanceof Name))
|
|
return `"${a}${b.slice(1)}`;
|
|
return;
|
|
}
|
|
function strConcat(c1, c2) {
|
|
return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str`${c1}${c2}`;
|
|
}
|
|
exports.strConcat = strConcat;
|
|
function interpolate(x) {
|
|
return typeof x == "number" || typeof x == "boolean" || x === null ? x : safeStringify(Array.isArray(x) ? x.join(",") : x);
|
|
}
|
|
function stringify(x) {
|
|
return new _Code(safeStringify(x));
|
|
}
|
|
exports.stringify = stringify;
|
|
function safeStringify(x) {
|
|
return JSON.stringify(x).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
|
|
}
|
|
exports.safeStringify = safeStringify;
|
|
function getProperty(key) {
|
|
return typeof key == "string" && exports.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _`[${key}]`;
|
|
}
|
|
exports.getProperty = getProperty;
|
|
function getEsmExportName(key) {
|
|
if (typeof key == "string" && exports.IDENTIFIER.test(key)) {
|
|
return new _Code(`${key}`);
|
|
}
|
|
throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`);
|
|
}
|
|
exports.getEsmExportName = getEsmExportName;
|
|
function regexpCode(rx) {
|
|
return new _Code(rx.toString());
|
|
}
|
|
exports.regexpCode = regexpCode;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/compile/codegen/scope.js
|
|
var require_scope = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.ValueScope = exports.ValueScopeName = exports.Scope = exports.varKinds = exports.UsedValueState = undefined;
|
|
var code_1 = require_code();
|
|
|
|
class ValueError extends Error {
|
|
constructor(name) {
|
|
super(`CodeGen: "code" for ${name} not defined`);
|
|
this.value = name.value;
|
|
}
|
|
}
|
|
var UsedValueState;
|
|
(function(UsedValueState2) {
|
|
UsedValueState2[UsedValueState2["Started"] = 0] = "Started";
|
|
UsedValueState2[UsedValueState2["Completed"] = 1] = "Completed";
|
|
})(UsedValueState || (exports.UsedValueState = UsedValueState = {}));
|
|
exports.varKinds = {
|
|
const: new code_1.Name("const"),
|
|
let: new code_1.Name("let"),
|
|
var: new code_1.Name("var")
|
|
};
|
|
|
|
class Scope {
|
|
constructor({ prefixes, parent } = {}) {
|
|
this._names = {};
|
|
this._prefixes = prefixes;
|
|
this._parent = parent;
|
|
}
|
|
toName(nameOrPrefix) {
|
|
return nameOrPrefix instanceof code_1.Name ? nameOrPrefix : this.name(nameOrPrefix);
|
|
}
|
|
name(prefix) {
|
|
return new code_1.Name(this._newName(prefix));
|
|
}
|
|
_newName(prefix) {
|
|
const ng = this._names[prefix] || this._nameGroup(prefix);
|
|
return `${prefix}${ng.index++}`;
|
|
}
|
|
_nameGroup(prefix) {
|
|
var _a, _b;
|
|
if (((_b = (_a = this._parent) === null || _a === undefined ? undefined : _a._prefixes) === null || _b === undefined ? undefined : _b.has(prefix)) || this._prefixes && !this._prefixes.has(prefix)) {
|
|
throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`);
|
|
}
|
|
return this._names[prefix] = { prefix, index: 0 };
|
|
}
|
|
}
|
|
exports.Scope = Scope;
|
|
|
|
class ValueScopeName extends code_1.Name {
|
|
constructor(prefix, nameStr) {
|
|
super(nameStr);
|
|
this.prefix = prefix;
|
|
}
|
|
setValue(value, { property, itemIndex }) {
|
|
this.value = value;
|
|
this.scopePath = (0, code_1._)`.${new code_1.Name(property)}[${itemIndex}]`;
|
|
}
|
|
}
|
|
exports.ValueScopeName = ValueScopeName;
|
|
var line = (0, code_1._)`\n`;
|
|
|
|
class ValueScope extends Scope {
|
|
constructor(opts) {
|
|
super(opts);
|
|
this._values = {};
|
|
this._scope = opts.scope;
|
|
this.opts = { ...opts, _n: opts.lines ? line : code_1.nil };
|
|
}
|
|
get() {
|
|
return this._scope;
|
|
}
|
|
name(prefix) {
|
|
return new ValueScopeName(prefix, this._newName(prefix));
|
|
}
|
|
value(nameOrPrefix, value) {
|
|
var _a;
|
|
if (value.ref === undefined)
|
|
throw new Error("CodeGen: ref must be passed in value");
|
|
const name = this.toName(nameOrPrefix);
|
|
const { prefix } = name;
|
|
const valueKey = (_a = value.key) !== null && _a !== undefined ? _a : value.ref;
|
|
let vs = this._values[prefix];
|
|
if (vs) {
|
|
const _name = vs.get(valueKey);
|
|
if (_name)
|
|
return _name;
|
|
} else {
|
|
vs = this._values[prefix] = new Map;
|
|
}
|
|
vs.set(valueKey, name);
|
|
const s = this._scope[prefix] || (this._scope[prefix] = []);
|
|
const itemIndex = s.length;
|
|
s[itemIndex] = value.ref;
|
|
name.setValue(value, { property: prefix, itemIndex });
|
|
return name;
|
|
}
|
|
getValue(prefix, keyOrRef) {
|
|
const vs = this._values[prefix];
|
|
if (!vs)
|
|
return;
|
|
return vs.get(keyOrRef);
|
|
}
|
|
scopeRefs(scopeName, values = this._values) {
|
|
return this._reduceValues(values, (name) => {
|
|
if (name.scopePath === undefined)
|
|
throw new Error(`CodeGen: name "${name}" has no value`);
|
|
return (0, code_1._)`${scopeName}${name.scopePath}`;
|
|
});
|
|
}
|
|
scopeCode(values = this._values, usedValues, getCode) {
|
|
return this._reduceValues(values, (name) => {
|
|
if (name.value === undefined)
|
|
throw new Error(`CodeGen: name "${name}" has no value`);
|
|
return name.value.code;
|
|
}, usedValues, getCode);
|
|
}
|
|
_reduceValues(values, valueCode, usedValues = {}, getCode) {
|
|
let code = code_1.nil;
|
|
for (const prefix in values) {
|
|
const vs = values[prefix];
|
|
if (!vs)
|
|
continue;
|
|
const nameSet = usedValues[prefix] = usedValues[prefix] || new Map;
|
|
vs.forEach((name) => {
|
|
if (nameSet.has(name))
|
|
return;
|
|
nameSet.set(name, UsedValueState.Started);
|
|
let c = valueCode(name);
|
|
if (c) {
|
|
const def = this.opts.es5 ? exports.varKinds.var : exports.varKinds.const;
|
|
code = (0, code_1._)`${code}${def} ${name} = ${c};${this.opts._n}`;
|
|
} else if (c = getCode === null || getCode === undefined ? undefined : getCode(name)) {
|
|
code = (0, code_1._)`${code}${c}${this.opts._n}`;
|
|
} else {
|
|
throw new ValueError(name);
|
|
}
|
|
nameSet.set(name, UsedValueState.Completed);
|
|
});
|
|
}
|
|
return code;
|
|
}
|
|
}
|
|
exports.ValueScope = ValueScope;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/compile/codegen/index.js
|
|
var require_codegen = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.or = exports.and = exports.not = exports.CodeGen = exports.operators = exports.varKinds = exports.ValueScopeName = exports.ValueScope = exports.Scope = exports.Name = exports.regexpCode = exports.stringify = exports.getProperty = exports.nil = exports.strConcat = exports.str = exports._ = undefined;
|
|
var code_1 = require_code();
|
|
var scope_1 = require_scope();
|
|
var code_2 = require_code();
|
|
Object.defineProperty(exports, "_", { enumerable: true, get: function() {
|
|
return code_2._;
|
|
} });
|
|
Object.defineProperty(exports, "str", { enumerable: true, get: function() {
|
|
return code_2.str;
|
|
} });
|
|
Object.defineProperty(exports, "strConcat", { enumerable: true, get: function() {
|
|
return code_2.strConcat;
|
|
} });
|
|
Object.defineProperty(exports, "nil", { enumerable: true, get: function() {
|
|
return code_2.nil;
|
|
} });
|
|
Object.defineProperty(exports, "getProperty", { enumerable: true, get: function() {
|
|
return code_2.getProperty;
|
|
} });
|
|
Object.defineProperty(exports, "stringify", { enumerable: true, get: function() {
|
|
return code_2.stringify;
|
|
} });
|
|
Object.defineProperty(exports, "regexpCode", { enumerable: true, get: function() {
|
|
return code_2.regexpCode;
|
|
} });
|
|
Object.defineProperty(exports, "Name", { enumerable: true, get: function() {
|
|
return code_2.Name;
|
|
} });
|
|
var scope_2 = require_scope();
|
|
Object.defineProperty(exports, "Scope", { enumerable: true, get: function() {
|
|
return scope_2.Scope;
|
|
} });
|
|
Object.defineProperty(exports, "ValueScope", { enumerable: true, get: function() {
|
|
return scope_2.ValueScope;
|
|
} });
|
|
Object.defineProperty(exports, "ValueScopeName", { enumerable: true, get: function() {
|
|
return scope_2.ValueScopeName;
|
|
} });
|
|
Object.defineProperty(exports, "varKinds", { enumerable: true, get: function() {
|
|
return scope_2.varKinds;
|
|
} });
|
|
exports.operators = {
|
|
GT: new code_1._Code(">"),
|
|
GTE: new code_1._Code(">="),
|
|
LT: new code_1._Code("<"),
|
|
LTE: new code_1._Code("<="),
|
|
EQ: new code_1._Code("==="),
|
|
NEQ: new code_1._Code("!=="),
|
|
NOT: new code_1._Code("!"),
|
|
OR: new code_1._Code("||"),
|
|
AND: new code_1._Code("&&"),
|
|
ADD: new code_1._Code("+")
|
|
};
|
|
|
|
class Node {
|
|
optimizeNodes() {
|
|
return this;
|
|
}
|
|
optimizeNames(_names, _constants) {
|
|
return this;
|
|
}
|
|
}
|
|
|
|
class Def extends Node {
|
|
constructor(varKind, name, rhs) {
|
|
super();
|
|
this.varKind = varKind;
|
|
this.name = name;
|
|
this.rhs = rhs;
|
|
}
|
|
render({ es5, _n }) {
|
|
const varKind = es5 ? scope_1.varKinds.var : this.varKind;
|
|
const rhs = this.rhs === undefined ? "" : ` = ${this.rhs}`;
|
|
return `${varKind} ${this.name}${rhs};` + _n;
|
|
}
|
|
optimizeNames(names, constants) {
|
|
if (!names[this.name.str])
|
|
return;
|
|
if (this.rhs)
|
|
this.rhs = optimizeExpr(this.rhs, names, constants);
|
|
return this;
|
|
}
|
|
get names() {
|
|
return this.rhs instanceof code_1._CodeOrName ? this.rhs.names : {};
|
|
}
|
|
}
|
|
|
|
class Assign extends Node {
|
|
constructor(lhs, rhs, sideEffects) {
|
|
super();
|
|
this.lhs = lhs;
|
|
this.rhs = rhs;
|
|
this.sideEffects = sideEffects;
|
|
}
|
|
render({ _n }) {
|
|
return `${this.lhs} = ${this.rhs};` + _n;
|
|
}
|
|
optimizeNames(names, constants) {
|
|
if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
|
|
return;
|
|
this.rhs = optimizeExpr(this.rhs, names, constants);
|
|
return this;
|
|
}
|
|
get names() {
|
|
const names = this.lhs instanceof code_1.Name ? {} : { ...this.lhs.names };
|
|
return addExprNames(names, this.rhs);
|
|
}
|
|
}
|
|
|
|
class AssignOp extends Assign {
|
|
constructor(lhs, op, rhs, sideEffects) {
|
|
super(lhs, rhs, sideEffects);
|
|
this.op = op;
|
|
}
|
|
render({ _n }) {
|
|
return `${this.lhs} ${this.op}= ${this.rhs};` + _n;
|
|
}
|
|
}
|
|
|
|
class Label extends Node {
|
|
constructor(label) {
|
|
super();
|
|
this.label = label;
|
|
this.names = {};
|
|
}
|
|
render({ _n }) {
|
|
return `${this.label}:` + _n;
|
|
}
|
|
}
|
|
|
|
class Break extends Node {
|
|
constructor(label) {
|
|
super();
|
|
this.label = label;
|
|
this.names = {};
|
|
}
|
|
render({ _n }) {
|
|
const label = this.label ? ` ${this.label}` : "";
|
|
return `break${label};` + _n;
|
|
}
|
|
}
|
|
|
|
class Throw extends Node {
|
|
constructor(error2) {
|
|
super();
|
|
this.error = error2;
|
|
}
|
|
render({ _n }) {
|
|
return `throw ${this.error};` + _n;
|
|
}
|
|
get names() {
|
|
return this.error.names;
|
|
}
|
|
}
|
|
|
|
class AnyCode extends Node {
|
|
constructor(code) {
|
|
super();
|
|
this.code = code;
|
|
}
|
|
render({ _n }) {
|
|
return `${this.code};` + _n;
|
|
}
|
|
optimizeNodes() {
|
|
return `${this.code}` ? this : undefined;
|
|
}
|
|
optimizeNames(names, constants) {
|
|
this.code = optimizeExpr(this.code, names, constants);
|
|
return this;
|
|
}
|
|
get names() {
|
|
return this.code instanceof code_1._CodeOrName ? this.code.names : {};
|
|
}
|
|
}
|
|
|
|
class ParentNode extends Node {
|
|
constructor(nodes = []) {
|
|
super();
|
|
this.nodes = nodes;
|
|
}
|
|
render(opts) {
|
|
return this.nodes.reduce((code, n) => code + n.render(opts), "");
|
|
}
|
|
optimizeNodes() {
|
|
const { nodes } = this;
|
|
let i = nodes.length;
|
|
while (i--) {
|
|
const n = nodes[i].optimizeNodes();
|
|
if (Array.isArray(n))
|
|
nodes.splice(i, 1, ...n);
|
|
else if (n)
|
|
nodes[i] = n;
|
|
else
|
|
nodes.splice(i, 1);
|
|
}
|
|
return nodes.length > 0 ? this : undefined;
|
|
}
|
|
optimizeNames(names, constants) {
|
|
const { nodes } = this;
|
|
let i = nodes.length;
|
|
while (i--) {
|
|
const n = nodes[i];
|
|
if (n.optimizeNames(names, constants))
|
|
continue;
|
|
subtractNames(names, n.names);
|
|
nodes.splice(i, 1);
|
|
}
|
|
return nodes.length > 0 ? this : undefined;
|
|
}
|
|
get names() {
|
|
return this.nodes.reduce((names, n) => addNames(names, n.names), {});
|
|
}
|
|
}
|
|
|
|
class BlockNode extends ParentNode {
|
|
render(opts) {
|
|
return "{" + opts._n + super.render(opts) + "}" + opts._n;
|
|
}
|
|
}
|
|
|
|
class Root extends ParentNode {
|
|
}
|
|
|
|
class Else extends BlockNode {
|
|
}
|
|
Else.kind = "else";
|
|
|
|
class If extends BlockNode {
|
|
constructor(condition, nodes) {
|
|
super(nodes);
|
|
this.condition = condition;
|
|
}
|
|
render(opts) {
|
|
let code = `if(${this.condition})` + super.render(opts);
|
|
if (this.else)
|
|
code += "else " + this.else.render(opts);
|
|
return code;
|
|
}
|
|
optimizeNodes() {
|
|
super.optimizeNodes();
|
|
const cond = this.condition;
|
|
if (cond === true)
|
|
return this.nodes;
|
|
let e = this.else;
|
|
if (e) {
|
|
const ns = e.optimizeNodes();
|
|
e = this.else = Array.isArray(ns) ? new Else(ns) : ns;
|
|
}
|
|
if (e) {
|
|
if (cond === false)
|
|
return e instanceof If ? e : e.nodes;
|
|
if (this.nodes.length)
|
|
return this;
|
|
return new If(not(cond), e instanceof If ? [e] : e.nodes);
|
|
}
|
|
if (cond === false || !this.nodes.length)
|
|
return;
|
|
return this;
|
|
}
|
|
optimizeNames(names, constants) {
|
|
var _a;
|
|
this.else = (_a = this.else) === null || _a === undefined ? undefined : _a.optimizeNames(names, constants);
|
|
if (!(super.optimizeNames(names, constants) || this.else))
|
|
return;
|
|
this.condition = optimizeExpr(this.condition, names, constants);
|
|
return this;
|
|
}
|
|
get names() {
|
|
const names = super.names;
|
|
addExprNames(names, this.condition);
|
|
if (this.else)
|
|
addNames(names, this.else.names);
|
|
return names;
|
|
}
|
|
}
|
|
If.kind = "if";
|
|
|
|
class For extends BlockNode {
|
|
}
|
|
For.kind = "for";
|
|
|
|
class ForLoop extends For {
|
|
constructor(iteration) {
|
|
super();
|
|
this.iteration = iteration;
|
|
}
|
|
render(opts) {
|
|
return `for(${this.iteration})` + super.render(opts);
|
|
}
|
|
optimizeNames(names, constants) {
|
|
if (!super.optimizeNames(names, constants))
|
|
return;
|
|
this.iteration = optimizeExpr(this.iteration, names, constants);
|
|
return this;
|
|
}
|
|
get names() {
|
|
return addNames(super.names, this.iteration.names);
|
|
}
|
|
}
|
|
|
|
class ForRange extends For {
|
|
constructor(varKind, name, from, to) {
|
|
super();
|
|
this.varKind = varKind;
|
|
this.name = name;
|
|
this.from = from;
|
|
this.to = to;
|
|
}
|
|
render(opts) {
|
|
const varKind = opts.es5 ? scope_1.varKinds.var : this.varKind;
|
|
const { name, from, to } = this;
|
|
return `for(${varKind} ${name}=${from}; ${name}<${to}; ${name}++)` + super.render(opts);
|
|
}
|
|
get names() {
|
|
const names = addExprNames(super.names, this.from);
|
|
return addExprNames(names, this.to);
|
|
}
|
|
}
|
|
|
|
class ForIter extends For {
|
|
constructor(loop, varKind, name, iterable) {
|
|
super();
|
|
this.loop = loop;
|
|
this.varKind = varKind;
|
|
this.name = name;
|
|
this.iterable = iterable;
|
|
}
|
|
render(opts) {
|
|
return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
|
|
}
|
|
optimizeNames(names, constants) {
|
|
if (!super.optimizeNames(names, constants))
|
|
return;
|
|
this.iterable = optimizeExpr(this.iterable, names, constants);
|
|
return this;
|
|
}
|
|
get names() {
|
|
return addNames(super.names, this.iterable.names);
|
|
}
|
|
}
|
|
|
|
class Func extends BlockNode {
|
|
constructor(name, args, async) {
|
|
super();
|
|
this.name = name;
|
|
this.args = args;
|
|
this.async = async;
|
|
}
|
|
render(opts) {
|
|
const _async = this.async ? "async " : "";
|
|
return `${_async}function ${this.name}(${this.args})` + super.render(opts);
|
|
}
|
|
}
|
|
Func.kind = "func";
|
|
|
|
class Return extends ParentNode {
|
|
render(opts) {
|
|
return "return " + super.render(opts);
|
|
}
|
|
}
|
|
Return.kind = "return";
|
|
|
|
class Try extends BlockNode {
|
|
render(opts) {
|
|
let code = "try" + super.render(opts);
|
|
if (this.catch)
|
|
code += this.catch.render(opts);
|
|
if (this.finally)
|
|
code += this.finally.render(opts);
|
|
return code;
|
|
}
|
|
optimizeNodes() {
|
|
var _a, _b;
|
|
super.optimizeNodes();
|
|
(_a = this.catch) === null || _a === undefined || _a.optimizeNodes();
|
|
(_b = this.finally) === null || _b === undefined || _b.optimizeNodes();
|
|
return this;
|
|
}
|
|
optimizeNames(names, constants) {
|
|
var _a, _b;
|
|
super.optimizeNames(names, constants);
|
|
(_a = this.catch) === null || _a === undefined || _a.optimizeNames(names, constants);
|
|
(_b = this.finally) === null || _b === undefined || _b.optimizeNames(names, constants);
|
|
return this;
|
|
}
|
|
get names() {
|
|
const names = super.names;
|
|
if (this.catch)
|
|
addNames(names, this.catch.names);
|
|
if (this.finally)
|
|
addNames(names, this.finally.names);
|
|
return names;
|
|
}
|
|
}
|
|
|
|
class Catch extends BlockNode {
|
|
constructor(error2) {
|
|
super();
|
|
this.error = error2;
|
|
}
|
|
render(opts) {
|
|
return `catch(${this.error})` + super.render(opts);
|
|
}
|
|
}
|
|
Catch.kind = "catch";
|
|
|
|
class Finally extends BlockNode {
|
|
render(opts) {
|
|
return "finally" + super.render(opts);
|
|
}
|
|
}
|
|
Finally.kind = "finally";
|
|
|
|
class CodeGen {
|
|
constructor(extScope, opts = {}) {
|
|
this._values = {};
|
|
this._blockStarts = [];
|
|
this._constants = {};
|
|
this.opts = { ...opts, _n: opts.lines ? `
|
|
` : "" };
|
|
this._extScope = extScope;
|
|
this._scope = new scope_1.Scope({ parent: extScope });
|
|
this._nodes = [new Root];
|
|
}
|
|
toString() {
|
|
return this._root.render(this.opts);
|
|
}
|
|
name(prefix) {
|
|
return this._scope.name(prefix);
|
|
}
|
|
scopeName(prefix) {
|
|
return this._extScope.name(prefix);
|
|
}
|
|
scopeValue(prefixOrName, value) {
|
|
const name = this._extScope.value(prefixOrName, value);
|
|
const vs = this._values[name.prefix] || (this._values[name.prefix] = new Set);
|
|
vs.add(name);
|
|
return name;
|
|
}
|
|
getScopeValue(prefix, keyOrRef) {
|
|
return this._extScope.getValue(prefix, keyOrRef);
|
|
}
|
|
scopeRefs(scopeName) {
|
|
return this._extScope.scopeRefs(scopeName, this._values);
|
|
}
|
|
scopeCode() {
|
|
return this._extScope.scopeCode(this._values);
|
|
}
|
|
_def(varKind, nameOrPrefix, rhs, constant) {
|
|
const name = this._scope.toName(nameOrPrefix);
|
|
if (rhs !== undefined && constant)
|
|
this._constants[name.str] = rhs;
|
|
this._leafNode(new Def(varKind, name, rhs));
|
|
return name;
|
|
}
|
|
const(nameOrPrefix, rhs, _constant) {
|
|
return this._def(scope_1.varKinds.const, nameOrPrefix, rhs, _constant);
|
|
}
|
|
let(nameOrPrefix, rhs, _constant) {
|
|
return this._def(scope_1.varKinds.let, nameOrPrefix, rhs, _constant);
|
|
}
|
|
var(nameOrPrefix, rhs, _constant) {
|
|
return this._def(scope_1.varKinds.var, nameOrPrefix, rhs, _constant);
|
|
}
|
|
assign(lhs, rhs, sideEffects) {
|
|
return this._leafNode(new Assign(lhs, rhs, sideEffects));
|
|
}
|
|
add(lhs, rhs) {
|
|
return this._leafNode(new AssignOp(lhs, exports.operators.ADD, rhs));
|
|
}
|
|
code(c) {
|
|
if (typeof c == "function")
|
|
c();
|
|
else if (c !== code_1.nil)
|
|
this._leafNode(new AnyCode(c));
|
|
return this;
|
|
}
|
|
object(...keyValues) {
|
|
const code = ["{"];
|
|
for (const [key, value] of keyValues) {
|
|
if (code.length > 1)
|
|
code.push(",");
|
|
code.push(key);
|
|
if (key !== value || this.opts.es5) {
|
|
code.push(":");
|
|
(0, code_1.addCodeArg)(code, value);
|
|
}
|
|
}
|
|
code.push("}");
|
|
return new code_1._Code(code);
|
|
}
|
|
if(condition, thenBody, elseBody) {
|
|
this._blockNode(new If(condition));
|
|
if (thenBody && elseBody) {
|
|
this.code(thenBody).else().code(elseBody).endIf();
|
|
} else if (thenBody) {
|
|
this.code(thenBody).endIf();
|
|
} else if (elseBody) {
|
|
throw new Error('CodeGen: "else" body without "then" body');
|
|
}
|
|
return this;
|
|
}
|
|
elseIf(condition) {
|
|
return this._elseNode(new If(condition));
|
|
}
|
|
else() {
|
|
return this._elseNode(new Else);
|
|
}
|
|
endIf() {
|
|
return this._endBlockNode(If, Else);
|
|
}
|
|
_for(node, forBody) {
|
|
this._blockNode(node);
|
|
if (forBody)
|
|
this.code(forBody).endFor();
|
|
return this;
|
|
}
|
|
for(iteration, forBody) {
|
|
return this._for(new ForLoop(iteration), forBody);
|
|
}
|
|
forRange(nameOrPrefix, from, to, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.let) {
|
|
const name = this._scope.toName(nameOrPrefix);
|
|
return this._for(new ForRange(varKind, name, from, to), () => forBody(name));
|
|
}
|
|
forOf(nameOrPrefix, iterable, forBody, varKind = scope_1.varKinds.const) {
|
|
const name = this._scope.toName(nameOrPrefix);
|
|
if (this.opts.es5) {
|
|
const arr = iterable instanceof code_1.Name ? iterable : this.var("_arr", iterable);
|
|
return this.forRange("_i", 0, (0, code_1._)`${arr}.length`, (i) => {
|
|
this.var(name, (0, code_1._)`${arr}[${i}]`);
|
|
forBody(name);
|
|
});
|
|
}
|
|
return this._for(new ForIter("of", varKind, name, iterable), () => forBody(name));
|
|
}
|
|
forIn(nameOrPrefix, obj, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.const) {
|
|
if (this.opts.ownProperties) {
|
|
return this.forOf(nameOrPrefix, (0, code_1._)`Object.keys(${obj})`, forBody);
|
|
}
|
|
const name = this._scope.toName(nameOrPrefix);
|
|
return this._for(new ForIter("in", varKind, name, obj), () => forBody(name));
|
|
}
|
|
endFor() {
|
|
return this._endBlockNode(For);
|
|
}
|
|
label(label) {
|
|
return this._leafNode(new Label(label));
|
|
}
|
|
break(label) {
|
|
return this._leafNode(new Break(label));
|
|
}
|
|
return(value) {
|
|
const node = new Return;
|
|
this._blockNode(node);
|
|
this.code(value);
|
|
if (node.nodes.length !== 1)
|
|
throw new Error('CodeGen: "return" should have one node');
|
|
return this._endBlockNode(Return);
|
|
}
|
|
try(tryBody, catchCode, finallyCode) {
|
|
if (!catchCode && !finallyCode)
|
|
throw new Error('CodeGen: "try" without "catch" and "finally"');
|
|
const node = new Try;
|
|
this._blockNode(node);
|
|
this.code(tryBody);
|
|
if (catchCode) {
|
|
const error2 = this.name("e");
|
|
this._currNode = node.catch = new Catch(error2);
|
|
catchCode(error2);
|
|
}
|
|
if (finallyCode) {
|
|
this._currNode = node.finally = new Finally;
|
|
this.code(finallyCode);
|
|
}
|
|
return this._endBlockNode(Catch, Finally);
|
|
}
|
|
throw(error2) {
|
|
return this._leafNode(new Throw(error2));
|
|
}
|
|
block(body, nodeCount) {
|
|
this._blockStarts.push(this._nodes.length);
|
|
if (body)
|
|
this.code(body).endBlock(nodeCount);
|
|
return this;
|
|
}
|
|
endBlock(nodeCount) {
|
|
const len = this._blockStarts.pop();
|
|
if (len === undefined)
|
|
throw new Error("CodeGen: not in self-balancing block");
|
|
const toClose = this._nodes.length - len;
|
|
if (toClose < 0 || nodeCount !== undefined && toClose !== nodeCount) {
|
|
throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`);
|
|
}
|
|
this._nodes.length = len;
|
|
return this;
|
|
}
|
|
func(name, args = code_1.nil, async, funcBody) {
|
|
this._blockNode(new Func(name, args, async));
|
|
if (funcBody)
|
|
this.code(funcBody).endFunc();
|
|
return this;
|
|
}
|
|
endFunc() {
|
|
return this._endBlockNode(Func);
|
|
}
|
|
optimize(n = 1) {
|
|
while (n-- > 0) {
|
|
this._root.optimizeNodes();
|
|
this._root.optimizeNames(this._root.names, this._constants);
|
|
}
|
|
}
|
|
_leafNode(node) {
|
|
this._currNode.nodes.push(node);
|
|
return this;
|
|
}
|
|
_blockNode(node) {
|
|
this._currNode.nodes.push(node);
|
|
this._nodes.push(node);
|
|
}
|
|
_endBlockNode(N1, N2) {
|
|
const n = this._currNode;
|
|
if (n instanceof N1 || N2 && n instanceof N2) {
|
|
this._nodes.pop();
|
|
return this;
|
|
}
|
|
throw new Error(`CodeGen: not in block "${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}"`);
|
|
}
|
|
_elseNode(node) {
|
|
const n = this._currNode;
|
|
if (!(n instanceof If)) {
|
|
throw new Error('CodeGen: "else" without "if"');
|
|
}
|
|
this._currNode = n.else = node;
|
|
return this;
|
|
}
|
|
get _root() {
|
|
return this._nodes[0];
|
|
}
|
|
get _currNode() {
|
|
const ns = this._nodes;
|
|
return ns[ns.length - 1];
|
|
}
|
|
set _currNode(node) {
|
|
const ns = this._nodes;
|
|
ns[ns.length - 1] = node;
|
|
}
|
|
}
|
|
exports.CodeGen = CodeGen;
|
|
function addNames(names, from) {
|
|
for (const n in from)
|
|
names[n] = (names[n] || 0) + (from[n] || 0);
|
|
return names;
|
|
}
|
|
function addExprNames(names, from) {
|
|
return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
|
|
}
|
|
function optimizeExpr(expr, names, constants) {
|
|
if (expr instanceof code_1.Name)
|
|
return replaceName(expr);
|
|
if (!canOptimize(expr))
|
|
return expr;
|
|
return new code_1._Code(expr._items.reduce((items, c) => {
|
|
if (c instanceof code_1.Name)
|
|
c = replaceName(c);
|
|
if (c instanceof code_1._Code)
|
|
items.push(...c._items);
|
|
else
|
|
items.push(c);
|
|
return items;
|
|
}, []));
|
|
function replaceName(n) {
|
|
const c = constants[n.str];
|
|
if (c === undefined || names[n.str] !== 1)
|
|
return n;
|
|
delete names[n.str];
|
|
return c;
|
|
}
|
|
function canOptimize(e) {
|
|
return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants[c.str] !== undefined);
|
|
}
|
|
}
|
|
function subtractNames(names, from) {
|
|
for (const n in from)
|
|
names[n] = (names[n] || 0) - (from[n] || 0);
|
|
}
|
|
function not(x) {
|
|
return typeof x == "boolean" || typeof x == "number" || x === null ? !x : (0, code_1._)`!${par(x)}`;
|
|
}
|
|
exports.not = not;
|
|
var andCode = mappend(exports.operators.AND);
|
|
function and(...args) {
|
|
return args.reduce(andCode);
|
|
}
|
|
exports.and = and;
|
|
var orCode = mappend(exports.operators.OR);
|
|
function or(...args) {
|
|
return args.reduce(orCode);
|
|
}
|
|
exports.or = or;
|
|
function mappend(op) {
|
|
return (x, y) => x === code_1.nil ? y : y === code_1.nil ? x : (0, code_1._)`${par(x)} ${op} ${par(y)}`;
|
|
}
|
|
function par(x) {
|
|
return x instanceof code_1.Name ? x : (0, code_1._)`(${x})`;
|
|
}
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/compile/util.js
|
|
var require_util = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.checkStrictMode = exports.getErrorPath = exports.Type = exports.useFunc = exports.setEvaluated = exports.evaluatedPropsToName = exports.mergeEvaluated = exports.eachItem = exports.unescapeJsonPointer = exports.escapeJsonPointer = exports.escapeFragment = exports.unescapeFragment = exports.schemaRefOrVal = exports.schemaHasRulesButRef = exports.schemaHasRules = exports.checkUnknownRules = exports.alwaysValidSchema = exports.toHash = undefined;
|
|
var codegen_1 = require_codegen();
|
|
var code_1 = require_code();
|
|
function toHash(arr) {
|
|
const hash = {};
|
|
for (const item of arr)
|
|
hash[item] = true;
|
|
return hash;
|
|
}
|
|
exports.toHash = toHash;
|
|
function alwaysValidSchema(it, schema) {
|
|
if (typeof schema == "boolean")
|
|
return schema;
|
|
if (Object.keys(schema).length === 0)
|
|
return true;
|
|
checkUnknownRules(it, schema);
|
|
return !schemaHasRules(schema, it.self.RULES.all);
|
|
}
|
|
exports.alwaysValidSchema = alwaysValidSchema;
|
|
function checkUnknownRules(it, schema = it.schema) {
|
|
const { opts, self: self2 } = it;
|
|
if (!opts.strictSchema)
|
|
return;
|
|
if (typeof schema === "boolean")
|
|
return;
|
|
const rules = self2.RULES.keywords;
|
|
for (const key in schema) {
|
|
if (!rules[key])
|
|
checkStrictMode(it, `unknown keyword: "${key}"`);
|
|
}
|
|
}
|
|
exports.checkUnknownRules = checkUnknownRules;
|
|
function schemaHasRules(schema, rules) {
|
|
if (typeof schema == "boolean")
|
|
return !schema;
|
|
for (const key in schema)
|
|
if (rules[key])
|
|
return true;
|
|
return false;
|
|
}
|
|
exports.schemaHasRules = schemaHasRules;
|
|
function schemaHasRulesButRef(schema, RULES) {
|
|
if (typeof schema == "boolean")
|
|
return !schema;
|
|
for (const key in schema)
|
|
if (key !== "$ref" && RULES.all[key])
|
|
return true;
|
|
return false;
|
|
}
|
|
exports.schemaHasRulesButRef = schemaHasRulesButRef;
|
|
function schemaRefOrVal({ topSchemaRef, schemaPath }, schema, keyword, $data) {
|
|
if (!$data) {
|
|
if (typeof schema == "number" || typeof schema == "boolean")
|
|
return schema;
|
|
if (typeof schema == "string")
|
|
return (0, codegen_1._)`${schema}`;
|
|
}
|
|
return (0, codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
|
|
}
|
|
exports.schemaRefOrVal = schemaRefOrVal;
|
|
function unescapeFragment(str) {
|
|
return unescapeJsonPointer(decodeURIComponent(str));
|
|
}
|
|
exports.unescapeFragment = unescapeFragment;
|
|
function escapeFragment(str) {
|
|
return encodeURIComponent(escapeJsonPointer(str));
|
|
}
|
|
exports.escapeFragment = escapeFragment;
|
|
function escapeJsonPointer(str) {
|
|
if (typeof str == "number")
|
|
return `${str}`;
|
|
return str.replace(/~/g, "~0").replace(/\//g, "~1");
|
|
}
|
|
exports.escapeJsonPointer = escapeJsonPointer;
|
|
function unescapeJsonPointer(str) {
|
|
return str.replace(/~1/g, "/").replace(/~0/g, "~");
|
|
}
|
|
exports.unescapeJsonPointer = unescapeJsonPointer;
|
|
function eachItem(xs, f) {
|
|
if (Array.isArray(xs)) {
|
|
for (const x of xs)
|
|
f(x);
|
|
} else {
|
|
f(xs);
|
|
}
|
|
}
|
|
exports.eachItem = eachItem;
|
|
function makeMergeEvaluated({ mergeNames, mergeToName, mergeValues: mergeValues3, resultToName }) {
|
|
return (gen, from, to, toName) => {
|
|
const res = to === undefined ? from : to instanceof codegen_1.Name ? (from instanceof codegen_1.Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to) : from instanceof codegen_1.Name ? (mergeToName(gen, to, from), from) : mergeValues3(from, to);
|
|
return toName === codegen_1.Name && !(res instanceof codegen_1.Name) ? resultToName(gen, res) : res;
|
|
};
|
|
}
|
|
exports.mergeEvaluated = {
|
|
props: makeMergeEvaluated({
|
|
mergeNames: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () => {
|
|
gen.if((0, codegen_1._)`${from} === true`, () => gen.assign(to, true), () => gen.assign(to, (0, codegen_1._)`${to} || {}`).code((0, codegen_1._)`Object.assign(${to}, ${from})`));
|
|
}),
|
|
mergeToName: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true`, () => {
|
|
if (from === true) {
|
|
gen.assign(to, true);
|
|
} else {
|
|
gen.assign(to, (0, codegen_1._)`${to} || {}`);
|
|
setEvaluated(gen, to, from);
|
|
}
|
|
}),
|
|
mergeValues: (from, to) => from === true ? true : { ...from, ...to },
|
|
resultToName: evaluatedPropsToName
|
|
}),
|
|
items: makeMergeEvaluated({
|
|
mergeNames: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () => gen.assign(to, (0, codegen_1._)`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`)),
|
|
mergeToName: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true`, () => gen.assign(to, from === true ? true : (0, codegen_1._)`${to} > ${from} ? ${to} : ${from}`)),
|
|
mergeValues: (from, to) => from === true ? true : Math.max(from, to),
|
|
resultToName: (gen, items) => gen.var("items", items)
|
|
})
|
|
};
|
|
function evaluatedPropsToName(gen, ps) {
|
|
if (ps === true)
|
|
return gen.var("props", true);
|
|
const props = gen.var("props", (0, codegen_1._)`{}`);
|
|
if (ps !== undefined)
|
|
setEvaluated(gen, props, ps);
|
|
return props;
|
|
}
|
|
exports.evaluatedPropsToName = evaluatedPropsToName;
|
|
function setEvaluated(gen, props, ps) {
|
|
Object.keys(ps).forEach((p) => gen.assign((0, codegen_1._)`${props}${(0, codegen_1.getProperty)(p)}`, true));
|
|
}
|
|
exports.setEvaluated = setEvaluated;
|
|
var snippets = {};
|
|
function useFunc(gen, f) {
|
|
return gen.scopeValue("func", {
|
|
ref: f,
|
|
code: snippets[f.code] || (snippets[f.code] = new code_1._Code(f.code))
|
|
});
|
|
}
|
|
exports.useFunc = useFunc;
|
|
var Type;
|
|
(function(Type2) {
|
|
Type2[Type2["Num"] = 0] = "Num";
|
|
Type2[Type2["Str"] = 1] = "Str";
|
|
})(Type || (exports.Type = Type = {}));
|
|
function getErrorPath(dataProp, dataPropType, jsPropertySyntax) {
|
|
if (dataProp instanceof codegen_1.Name) {
|
|
const isNumber = dataPropType === Type.Num;
|
|
return jsPropertySyntax ? isNumber ? (0, codegen_1._)`"[" + ${dataProp} + "]"` : (0, codegen_1._)`"['" + ${dataProp} + "']"` : isNumber ? (0, codegen_1._)`"/" + ${dataProp}` : (0, codegen_1._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
|
|
}
|
|
return jsPropertySyntax ? (0, codegen_1.getProperty)(dataProp).toString() : "/" + escapeJsonPointer(dataProp);
|
|
}
|
|
exports.getErrorPath = getErrorPath;
|
|
function checkStrictMode(it, msg, mode = it.opts.strictSchema) {
|
|
if (!mode)
|
|
return;
|
|
msg = `strict mode: ${msg}`;
|
|
if (mode === true)
|
|
throw new Error(msg);
|
|
it.self.logger.warn(msg);
|
|
}
|
|
exports.checkStrictMode = checkStrictMode;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/compile/names.js
|
|
var require_names = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var codegen_1 = require_codegen();
|
|
var names = {
|
|
data: new codegen_1.Name("data"),
|
|
valCxt: new codegen_1.Name("valCxt"),
|
|
instancePath: new codegen_1.Name("instancePath"),
|
|
parentData: new codegen_1.Name("parentData"),
|
|
parentDataProperty: new codegen_1.Name("parentDataProperty"),
|
|
rootData: new codegen_1.Name("rootData"),
|
|
dynamicAnchors: new codegen_1.Name("dynamicAnchors"),
|
|
vErrors: new codegen_1.Name("vErrors"),
|
|
errors: new codegen_1.Name("errors"),
|
|
this: new codegen_1.Name("this"),
|
|
self: new codegen_1.Name("self"),
|
|
scope: new codegen_1.Name("scope"),
|
|
json: new codegen_1.Name("json"),
|
|
jsonPos: new codegen_1.Name("jsonPos"),
|
|
jsonLen: new codegen_1.Name("jsonLen"),
|
|
jsonPart: new codegen_1.Name("jsonPart")
|
|
};
|
|
exports.default = names;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/compile/errors.js
|
|
var require_errors = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.extendErrors = exports.resetErrorsCount = exports.reportExtraError = exports.reportError = exports.keyword$DataError = exports.keywordError = undefined;
|
|
var codegen_1 = require_codegen();
|
|
var util_1 = require_util();
|
|
var names_1 = require_names();
|
|
exports.keywordError = {
|
|
message: ({ keyword }) => (0, codegen_1.str)`must pass "${keyword}" keyword validation`
|
|
};
|
|
exports.keyword$DataError = {
|
|
message: ({ keyword, schemaType }) => schemaType ? (0, codegen_1.str)`"${keyword}" keyword must be ${schemaType} ($data)` : (0, codegen_1.str)`"${keyword}" keyword is invalid ($data)`
|
|
};
|
|
function reportError(cxt, error2 = exports.keywordError, errorPaths, overrideAllErrors) {
|
|
const { it } = cxt;
|
|
const { gen, compositeRule, allErrors } = it;
|
|
const errObj = errorObjectCode(cxt, error2, errorPaths);
|
|
if (overrideAllErrors !== null && overrideAllErrors !== undefined ? overrideAllErrors : compositeRule || allErrors) {
|
|
addError(gen, errObj);
|
|
} else {
|
|
returnErrors(it, (0, codegen_1._)`[${errObj}]`);
|
|
}
|
|
}
|
|
exports.reportError = reportError;
|
|
function reportExtraError(cxt, error2 = exports.keywordError, errorPaths) {
|
|
const { it } = cxt;
|
|
const { gen, compositeRule, allErrors } = it;
|
|
const errObj = errorObjectCode(cxt, error2, errorPaths);
|
|
addError(gen, errObj);
|
|
if (!(compositeRule || allErrors)) {
|
|
returnErrors(it, names_1.default.vErrors);
|
|
}
|
|
}
|
|
exports.reportExtraError = reportExtraError;
|
|
function resetErrorsCount(gen, errsCount) {
|
|
gen.assign(names_1.default.errors, errsCount);
|
|
gen.if((0, codegen_1._)`${names_1.default.vErrors} !== null`, () => gen.if(errsCount, () => gen.assign((0, codegen_1._)`${names_1.default.vErrors}.length`, errsCount), () => gen.assign(names_1.default.vErrors, null)));
|
|
}
|
|
exports.resetErrorsCount = resetErrorsCount;
|
|
function extendErrors({ gen, keyword, schemaValue, data, errsCount, it }) {
|
|
if (errsCount === undefined)
|
|
throw new Error("ajv implementation error");
|
|
const err = gen.name("err");
|
|
gen.forRange("i", errsCount, names_1.default.errors, (i) => {
|
|
gen.const(err, (0, codegen_1._)`${names_1.default.vErrors}[${i}]`);
|
|
gen.if((0, codegen_1._)`${err}.instancePath === undefined`, () => gen.assign((0, codegen_1._)`${err}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath)));
|
|
gen.assign((0, codegen_1._)`${err}.schemaPath`, (0, codegen_1.str)`${it.errSchemaPath}/${keyword}`);
|
|
if (it.opts.verbose) {
|
|
gen.assign((0, codegen_1._)`${err}.schema`, schemaValue);
|
|
gen.assign((0, codegen_1._)`${err}.data`, data);
|
|
}
|
|
});
|
|
}
|
|
exports.extendErrors = extendErrors;
|
|
function addError(gen, errObj) {
|
|
const err = gen.const("err", errObj);
|
|
gen.if((0, codegen_1._)`${names_1.default.vErrors} === null`, () => gen.assign(names_1.default.vErrors, (0, codegen_1._)`[${err}]`), (0, codegen_1._)`${names_1.default.vErrors}.push(${err})`);
|
|
gen.code((0, codegen_1._)`${names_1.default.errors}++`);
|
|
}
|
|
function returnErrors(it, errs) {
|
|
const { gen, validateName, schemaEnv } = it;
|
|
if (schemaEnv.$async) {
|
|
gen.throw((0, codegen_1._)`new ${it.ValidationError}(${errs})`);
|
|
} else {
|
|
gen.assign((0, codegen_1._)`${validateName}.errors`, errs);
|
|
gen.return(false);
|
|
}
|
|
}
|
|
var E = {
|
|
keyword: new codegen_1.Name("keyword"),
|
|
schemaPath: new codegen_1.Name("schemaPath"),
|
|
params: new codegen_1.Name("params"),
|
|
propertyName: new codegen_1.Name("propertyName"),
|
|
message: new codegen_1.Name("message"),
|
|
schema: new codegen_1.Name("schema"),
|
|
parentSchema: new codegen_1.Name("parentSchema")
|
|
};
|
|
function errorObjectCode(cxt, error2, errorPaths) {
|
|
const { createErrors } = cxt.it;
|
|
if (createErrors === false)
|
|
return (0, codegen_1._)`{}`;
|
|
return errorObject(cxt, error2, errorPaths);
|
|
}
|
|
function errorObject(cxt, error2, errorPaths = {}) {
|
|
const { gen, it } = cxt;
|
|
const keyValues = [
|
|
errorInstancePath(it, errorPaths),
|
|
errorSchemaPath(cxt, errorPaths)
|
|
];
|
|
extraErrorProps(cxt, error2, keyValues);
|
|
return gen.object(...keyValues);
|
|
}
|
|
function errorInstancePath({ errorPath }, { instancePath }) {
|
|
const instPath = instancePath ? (0, codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(instancePath, util_1.Type.Str)}` : errorPath;
|
|
return [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, instPath)];
|
|
}
|
|
function errorSchemaPath({ keyword, it: { errSchemaPath } }, { schemaPath, parentSchema }) {
|
|
let schPath = parentSchema ? errSchemaPath : (0, codegen_1.str)`${errSchemaPath}/${keyword}`;
|
|
if (schemaPath) {
|
|
schPath = (0, codegen_1.str)`${schPath}${(0, util_1.getErrorPath)(schemaPath, util_1.Type.Str)}`;
|
|
}
|
|
return [E.schemaPath, schPath];
|
|
}
|
|
function extraErrorProps(cxt, { params, message }, keyValues) {
|
|
const { keyword, data, schemaValue, it } = cxt;
|
|
const { opts, propertyName, topSchemaRef, schemaPath } = it;
|
|
keyValues.push([E.keyword, keyword], [E.params, typeof params == "function" ? params(cxt) : params || (0, codegen_1._)`{}`]);
|
|
if (opts.messages) {
|
|
keyValues.push([E.message, typeof message == "function" ? message(cxt) : message]);
|
|
}
|
|
if (opts.verbose) {
|
|
keyValues.push([E.schema, schemaValue], [E.parentSchema, (0, codegen_1._)`${topSchemaRef}${schemaPath}`], [names_1.default.data, data]);
|
|
}
|
|
if (propertyName)
|
|
keyValues.push([E.propertyName, propertyName]);
|
|
}
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/compile/validate/boolSchema.js
|
|
var require_boolSchema = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.boolOrEmptySchema = exports.topBoolOrEmptySchema = undefined;
|
|
var errors_1 = require_errors();
|
|
var codegen_1 = require_codegen();
|
|
var names_1 = require_names();
|
|
var boolError = {
|
|
message: "boolean schema is false"
|
|
};
|
|
function topBoolOrEmptySchema(it) {
|
|
const { gen, schema, validateName } = it;
|
|
if (schema === false) {
|
|
falseSchemaError(it, false);
|
|
} else if (typeof schema == "object" && schema.$async === true) {
|
|
gen.return(names_1.default.data);
|
|
} else {
|
|
gen.assign((0, codegen_1._)`${validateName}.errors`, null);
|
|
gen.return(true);
|
|
}
|
|
}
|
|
exports.topBoolOrEmptySchema = topBoolOrEmptySchema;
|
|
function boolOrEmptySchema(it, valid) {
|
|
const { gen, schema } = it;
|
|
if (schema === false) {
|
|
gen.var(valid, false);
|
|
falseSchemaError(it);
|
|
} else {
|
|
gen.var(valid, true);
|
|
}
|
|
}
|
|
exports.boolOrEmptySchema = boolOrEmptySchema;
|
|
function falseSchemaError(it, overrideAllErrors) {
|
|
const { gen, data } = it;
|
|
const cxt = {
|
|
gen,
|
|
keyword: "false schema",
|
|
data,
|
|
schema: false,
|
|
schemaCode: false,
|
|
schemaValue: false,
|
|
params: {},
|
|
it
|
|
};
|
|
(0, errors_1.reportError)(cxt, boolError, undefined, overrideAllErrors);
|
|
}
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/compile/rules.js
|
|
var require_rules = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.getRules = exports.isJSONType = undefined;
|
|
var _jsonTypes = ["string", "number", "integer", "boolean", "null", "object", "array"];
|
|
var jsonTypes = new Set(_jsonTypes);
|
|
function isJSONType(x) {
|
|
return typeof x == "string" && jsonTypes.has(x);
|
|
}
|
|
exports.isJSONType = isJSONType;
|
|
function getRules() {
|
|
const groups = {
|
|
number: { type: "number", rules: [] },
|
|
string: { type: "string", rules: [] },
|
|
array: { type: "array", rules: [] },
|
|
object: { type: "object", rules: [] }
|
|
};
|
|
return {
|
|
types: { ...groups, integer: true, boolean: true, null: true },
|
|
rules: [{ rules: [] }, groups.number, groups.string, groups.array, groups.object],
|
|
post: { rules: [] },
|
|
all: {},
|
|
keywords: {}
|
|
};
|
|
}
|
|
exports.getRules = getRules;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/compile/validate/applicability.js
|
|
var require_applicability = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.shouldUseRule = exports.shouldUseGroup = exports.schemaHasRulesForType = undefined;
|
|
function schemaHasRulesForType({ schema, self: self2 }, type) {
|
|
const group = self2.RULES.types[type];
|
|
return group && group !== true && shouldUseGroup(schema, group);
|
|
}
|
|
exports.schemaHasRulesForType = schemaHasRulesForType;
|
|
function shouldUseGroup(schema, group) {
|
|
return group.rules.some((rule) => shouldUseRule(schema, rule));
|
|
}
|
|
exports.shouldUseGroup = shouldUseGroup;
|
|
function shouldUseRule(schema, rule) {
|
|
var _a;
|
|
return schema[rule.keyword] !== undefined || ((_a = rule.definition.implements) === null || _a === undefined ? undefined : _a.some((kwd) => schema[kwd] !== undefined));
|
|
}
|
|
exports.shouldUseRule = shouldUseRule;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/compile/validate/dataType.js
|
|
var require_dataType = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.reportTypeError = exports.checkDataTypes = exports.checkDataType = exports.coerceAndCheckDataType = exports.getJSONTypes = exports.getSchemaTypes = exports.DataType = undefined;
|
|
var rules_1 = require_rules();
|
|
var applicability_1 = require_applicability();
|
|
var errors_1 = require_errors();
|
|
var codegen_1 = require_codegen();
|
|
var util_1 = require_util();
|
|
var DataType;
|
|
(function(DataType2) {
|
|
DataType2[DataType2["Correct"] = 0] = "Correct";
|
|
DataType2[DataType2["Wrong"] = 1] = "Wrong";
|
|
})(DataType || (exports.DataType = DataType = {}));
|
|
function getSchemaTypes(schema) {
|
|
const types = getJSONTypes(schema.type);
|
|
const hasNull = types.includes("null");
|
|
if (hasNull) {
|
|
if (schema.nullable === false)
|
|
throw new Error("type: null contradicts nullable: false");
|
|
} else {
|
|
if (!types.length && schema.nullable !== undefined) {
|
|
throw new Error('"nullable" cannot be used without "type"');
|
|
}
|
|
if (schema.nullable === true)
|
|
types.push("null");
|
|
}
|
|
return types;
|
|
}
|
|
exports.getSchemaTypes = getSchemaTypes;
|
|
function getJSONTypes(ts) {
|
|
const types = Array.isArray(ts) ? ts : ts ? [ts] : [];
|
|
if (types.every(rules_1.isJSONType))
|
|
return types;
|
|
throw new Error("type must be JSONType or JSONType[]: " + types.join(","));
|
|
}
|
|
exports.getJSONTypes = getJSONTypes;
|
|
function coerceAndCheckDataType(it, types) {
|
|
const { gen, data, opts } = it;
|
|
const coerceTo = coerceToTypes(types, opts.coerceTypes);
|
|
const checkTypes = types.length > 0 && !(coerceTo.length === 0 && types.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types[0]));
|
|
if (checkTypes) {
|
|
const wrongType = checkDataTypes(types, data, opts.strictNumbers, DataType.Wrong);
|
|
gen.if(wrongType, () => {
|
|
if (coerceTo.length)
|
|
coerceData(it, types, coerceTo);
|
|
else
|
|
reportTypeError(it);
|
|
});
|
|
}
|
|
return checkTypes;
|
|
}
|
|
exports.coerceAndCheckDataType = coerceAndCheckDataType;
|
|
var COERCIBLE = new Set(["string", "number", "integer", "boolean", "null"]);
|
|
function coerceToTypes(types, coerceTypes) {
|
|
return coerceTypes ? types.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : [];
|
|
}
|
|
function coerceData(it, types, coerceTo) {
|
|
const { gen, data, opts } = it;
|
|
const dataType = gen.let("dataType", (0, codegen_1._)`typeof ${data}`);
|
|
const coerced = gen.let("coerced", (0, codegen_1._)`undefined`);
|
|
if (opts.coerceTypes === "array") {
|
|
gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types, data, opts.strictNumbers), () => gen.assign(coerced, data)));
|
|
}
|
|
gen.if((0, codegen_1._)`${coerced} !== undefined`);
|
|
for (const t of coerceTo) {
|
|
if (COERCIBLE.has(t) || t === "array" && opts.coerceTypes === "array") {
|
|
coerceSpecificType(t);
|
|
}
|
|
}
|
|
gen.else();
|
|
reportTypeError(it);
|
|
gen.endIf();
|
|
gen.if((0, codegen_1._)`${coerced} !== undefined`, () => {
|
|
gen.assign(data, coerced);
|
|
assignParentData(it, coerced);
|
|
});
|
|
function coerceSpecificType(t) {
|
|
switch (t) {
|
|
case "string":
|
|
gen.elseIf((0, codegen_1._)`${dataType} == "number" || ${dataType} == "boolean"`).assign(coerced, (0, codegen_1._)`"" + ${data}`).elseIf((0, codegen_1._)`${data} === null`).assign(coerced, (0, codegen_1._)`""`);
|
|
return;
|
|
case "number":
|
|
gen.elseIf((0, codegen_1._)`${dataType} == "boolean" || ${data} === null
|
|
|| (${dataType} == "string" && ${data} && ${data} == +${data})`).assign(coerced, (0, codegen_1._)`+${data}`);
|
|
return;
|
|
case "integer":
|
|
gen.elseIf((0, codegen_1._)`${dataType} === "boolean" || ${data} === null
|
|
|| (${dataType} === "string" && ${data} && ${data} == +${data} && !(${data} % 1))`).assign(coerced, (0, codegen_1._)`+${data}`);
|
|
return;
|
|
case "boolean":
|
|
gen.elseIf((0, codegen_1._)`${data} === "false" || ${data} === 0 || ${data} === null`).assign(coerced, false).elseIf((0, codegen_1._)`${data} === "true" || ${data} === 1`).assign(coerced, true);
|
|
return;
|
|
case "null":
|
|
gen.elseIf((0, codegen_1._)`${data} === "" || ${data} === 0 || ${data} === false`);
|
|
gen.assign(coerced, null);
|
|
return;
|
|
case "array":
|
|
gen.elseIf((0, codegen_1._)`${dataType} === "string" || ${dataType} === "number"
|
|
|| ${dataType} === "boolean" || ${data} === null`).assign(coerced, (0, codegen_1._)`[${data}]`);
|
|
}
|
|
}
|
|
}
|
|
function assignParentData({ gen, parentData, parentDataProperty }, expr) {
|
|
gen.if((0, codegen_1._)`${parentData} !== undefined`, () => gen.assign((0, codegen_1._)`${parentData}[${parentDataProperty}]`, expr));
|
|
}
|
|
function checkDataType(dataType, data, strictNums, correct = DataType.Correct) {
|
|
const EQ = correct === DataType.Correct ? codegen_1.operators.EQ : codegen_1.operators.NEQ;
|
|
let cond;
|
|
switch (dataType) {
|
|
case "null":
|
|
return (0, codegen_1._)`${data} ${EQ} null`;
|
|
case "array":
|
|
cond = (0, codegen_1._)`Array.isArray(${data})`;
|
|
break;
|
|
case "object":
|
|
cond = (0, codegen_1._)`${data} && typeof ${data} == "object" && !Array.isArray(${data})`;
|
|
break;
|
|
case "integer":
|
|
cond = numCond((0, codegen_1._)`!(${data} % 1) && !isNaN(${data})`);
|
|
break;
|
|
case "number":
|
|
cond = numCond();
|
|
break;
|
|
default:
|
|
return (0, codegen_1._)`typeof ${data} ${EQ} ${dataType}`;
|
|
}
|
|
return correct === DataType.Correct ? cond : (0, codegen_1.not)(cond);
|
|
function numCond(_cond = codegen_1.nil) {
|
|
return (0, codegen_1.and)((0, codegen_1._)`typeof ${data} == "number"`, _cond, strictNums ? (0, codegen_1._)`isFinite(${data})` : codegen_1.nil);
|
|
}
|
|
}
|
|
exports.checkDataType = checkDataType;
|
|
function checkDataTypes(dataTypes, data, strictNums, correct) {
|
|
if (dataTypes.length === 1) {
|
|
return checkDataType(dataTypes[0], data, strictNums, correct);
|
|
}
|
|
let cond;
|
|
const types = (0, util_1.toHash)(dataTypes);
|
|
if (types.array && types.object) {
|
|
const notObj = (0, codegen_1._)`typeof ${data} != "object"`;
|
|
cond = types.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
|
|
delete types.null;
|
|
delete types.array;
|
|
delete types.object;
|
|
} else {
|
|
cond = codegen_1.nil;
|
|
}
|
|
if (types.number)
|
|
delete types.integer;
|
|
for (const t in types)
|
|
cond = (0, codegen_1.and)(cond, checkDataType(t, data, strictNums, correct));
|
|
return cond;
|
|
}
|
|
exports.checkDataTypes = checkDataTypes;
|
|
var typeError = {
|
|
message: ({ schema }) => `must be ${schema}`,
|
|
params: ({ schema, schemaValue }) => typeof schema == "string" ? (0, codegen_1._)`{type: ${schema}}` : (0, codegen_1._)`{type: ${schemaValue}}`
|
|
};
|
|
function reportTypeError(it) {
|
|
const cxt = getTypeErrorContext(it);
|
|
(0, errors_1.reportError)(cxt, typeError);
|
|
}
|
|
exports.reportTypeError = reportTypeError;
|
|
function getTypeErrorContext(it) {
|
|
const { gen, data, schema } = it;
|
|
const schemaCode = (0, util_1.schemaRefOrVal)(it, schema, "type");
|
|
return {
|
|
gen,
|
|
keyword: "type",
|
|
data,
|
|
schema: schema.type,
|
|
schemaCode,
|
|
schemaValue: schemaCode,
|
|
parentSchema: schema,
|
|
params: {},
|
|
it
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/compile/validate/defaults.js
|
|
var require_defaults = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.assignDefaults = undefined;
|
|
var codegen_1 = require_codegen();
|
|
var util_1 = require_util();
|
|
function assignDefaults(it, ty) {
|
|
const { properties, items } = it.schema;
|
|
if (ty === "object" && properties) {
|
|
for (const key in properties) {
|
|
assignDefault(it, key, properties[key].default);
|
|
}
|
|
} else if (ty === "array" && Array.isArray(items)) {
|
|
items.forEach((sch, i) => assignDefault(it, i, sch.default));
|
|
}
|
|
}
|
|
exports.assignDefaults = assignDefaults;
|
|
function assignDefault(it, prop, defaultValue) {
|
|
const { gen, compositeRule, data, opts } = it;
|
|
if (defaultValue === undefined)
|
|
return;
|
|
const childData = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(prop)}`;
|
|
if (compositeRule) {
|
|
(0, util_1.checkStrictMode)(it, `default is ignored for: ${childData}`);
|
|
return;
|
|
}
|
|
let condition = (0, codegen_1._)`${childData} === undefined`;
|
|
if (opts.useDefaults === "empty") {
|
|
condition = (0, codegen_1._)`${condition} || ${childData} === null || ${childData} === ""`;
|
|
}
|
|
gen.if(condition, (0, codegen_1._)`${childData} = ${(0, codegen_1.stringify)(defaultValue)}`);
|
|
}
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/code.js
|
|
var require_code2 = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.validateUnion = exports.validateArray = exports.usePattern = exports.callValidateCode = exports.schemaProperties = exports.allSchemaProperties = exports.noPropertyInData = exports.propertyInData = exports.isOwnProperty = exports.hasPropFunc = exports.reportMissingProp = exports.checkMissingProp = exports.checkReportMissingProp = undefined;
|
|
var codegen_1 = require_codegen();
|
|
var util_1 = require_util();
|
|
var names_1 = require_names();
|
|
var util_2 = require_util();
|
|
function checkReportMissingProp(cxt, prop) {
|
|
const { gen, data, it } = cxt;
|
|
gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => {
|
|
cxt.setParams({ missingProperty: (0, codegen_1._)`${prop}` }, true);
|
|
cxt.error();
|
|
});
|
|
}
|
|
exports.checkReportMissingProp = checkReportMissingProp;
|
|
function checkMissingProp({ gen, data, it: { opts } }, properties, missing) {
|
|
return (0, codegen_1.or)(...properties.map((prop) => (0, codegen_1.and)(noPropertyInData(gen, data, prop, opts.ownProperties), (0, codegen_1._)`${missing} = ${prop}`)));
|
|
}
|
|
exports.checkMissingProp = checkMissingProp;
|
|
function reportMissingProp(cxt, missing) {
|
|
cxt.setParams({ missingProperty: missing }, true);
|
|
cxt.error();
|
|
}
|
|
exports.reportMissingProp = reportMissingProp;
|
|
function hasPropFunc(gen) {
|
|
return gen.scopeValue("func", {
|
|
ref: Object.prototype.hasOwnProperty,
|
|
code: (0, codegen_1._)`Object.prototype.hasOwnProperty`
|
|
});
|
|
}
|
|
exports.hasPropFunc = hasPropFunc;
|
|
function isOwnProperty(gen, data, property) {
|
|
return (0, codegen_1._)`${hasPropFunc(gen)}.call(${data}, ${property})`;
|
|
}
|
|
exports.isOwnProperty = isOwnProperty;
|
|
function propertyInData(gen, data, property, ownProperties) {
|
|
const cond = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} !== undefined`;
|
|
return ownProperties ? (0, codegen_1._)`${cond} && ${isOwnProperty(gen, data, property)}` : cond;
|
|
}
|
|
exports.propertyInData = propertyInData;
|
|
function noPropertyInData(gen, data, property, ownProperties) {
|
|
const cond = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} === undefined`;
|
|
return ownProperties ? (0, codegen_1.or)(cond, (0, codegen_1.not)(isOwnProperty(gen, data, property))) : cond;
|
|
}
|
|
exports.noPropertyInData = noPropertyInData;
|
|
function allSchemaProperties(schemaMap) {
|
|
return schemaMap ? Object.keys(schemaMap).filter((p) => p !== "__proto__") : [];
|
|
}
|
|
exports.allSchemaProperties = allSchemaProperties;
|
|
function schemaProperties(it, schemaMap) {
|
|
return allSchemaProperties(schemaMap).filter((p) => !(0, util_1.alwaysValidSchema)(it, schemaMap[p]));
|
|
}
|
|
exports.schemaProperties = schemaProperties;
|
|
function callValidateCode({ schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it }, func, context, passSchema) {
|
|
const dataAndSchema = passSchema ? (0, codegen_1._)`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data;
|
|
const valCxt = [
|
|
[names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, errorPath)],
|
|
[names_1.default.parentData, it.parentData],
|
|
[names_1.default.parentDataProperty, it.parentDataProperty],
|
|
[names_1.default.rootData, names_1.default.rootData]
|
|
];
|
|
if (it.opts.dynamicRef)
|
|
valCxt.push([names_1.default.dynamicAnchors, names_1.default.dynamicAnchors]);
|
|
const args = (0, codegen_1._)`${dataAndSchema}, ${gen.object(...valCxt)}`;
|
|
return context !== codegen_1.nil ? (0, codegen_1._)`${func}.call(${context}, ${args})` : (0, codegen_1._)`${func}(${args})`;
|
|
}
|
|
exports.callValidateCode = callValidateCode;
|
|
var newRegExp = (0, codegen_1._)`new RegExp`;
|
|
function usePattern({ gen, it: { opts } }, pattern) {
|
|
const u = opts.unicodeRegExp ? "u" : "";
|
|
const { regExp } = opts.code;
|
|
const rx = regExp(pattern, u);
|
|
return gen.scopeValue("pattern", {
|
|
key: rx.toString(),
|
|
ref: rx,
|
|
code: (0, codegen_1._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern}, ${u})`
|
|
});
|
|
}
|
|
exports.usePattern = usePattern;
|
|
function validateArray(cxt) {
|
|
const { gen, data, keyword, it } = cxt;
|
|
const valid = gen.name("valid");
|
|
if (it.allErrors) {
|
|
const validArr = gen.let("valid", true);
|
|
validateItems(() => gen.assign(validArr, false));
|
|
return validArr;
|
|
}
|
|
gen.var(valid, true);
|
|
validateItems(() => gen.break());
|
|
return valid;
|
|
function validateItems(notValid) {
|
|
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
|
|
gen.forRange("i", 0, len, (i) => {
|
|
cxt.subschema({
|
|
keyword,
|
|
dataProp: i,
|
|
dataPropType: util_1.Type.Num
|
|
}, valid);
|
|
gen.if((0, codegen_1.not)(valid), notValid);
|
|
});
|
|
}
|
|
}
|
|
exports.validateArray = validateArray;
|
|
function validateUnion(cxt) {
|
|
const { gen, schema, keyword, it } = cxt;
|
|
if (!Array.isArray(schema))
|
|
throw new Error("ajv implementation error");
|
|
const alwaysValid = schema.some((sch) => (0, util_1.alwaysValidSchema)(it, sch));
|
|
if (alwaysValid && !it.opts.unevaluated)
|
|
return;
|
|
const valid = gen.let("valid", false);
|
|
const schValid = gen.name("_valid");
|
|
gen.block(() => schema.forEach((_sch, i) => {
|
|
const schCxt = cxt.subschema({
|
|
keyword,
|
|
schemaProp: i,
|
|
compositeRule: true
|
|
}, schValid);
|
|
gen.assign(valid, (0, codegen_1._)`${valid} || ${schValid}`);
|
|
const merged = cxt.mergeValidEvaluated(schCxt, schValid);
|
|
if (!merged)
|
|
gen.if((0, codegen_1.not)(valid));
|
|
}));
|
|
cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
|
|
}
|
|
exports.validateUnion = validateUnion;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/compile/validate/keyword.js
|
|
var require_keyword = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.validateKeywordUsage = exports.validSchemaType = exports.funcKeywordCode = exports.macroKeywordCode = undefined;
|
|
var codegen_1 = require_codegen();
|
|
var names_1 = require_names();
|
|
var code_1 = require_code2();
|
|
var errors_1 = require_errors();
|
|
function macroKeywordCode(cxt, def) {
|
|
const { gen, keyword, schema, parentSchema, it } = cxt;
|
|
const macroSchema = def.macro.call(it.self, schema, parentSchema, it);
|
|
const schemaRef = useKeyword(gen, keyword, macroSchema);
|
|
if (it.opts.validateSchema !== false)
|
|
it.self.validateSchema(macroSchema, true);
|
|
const valid = gen.name("valid");
|
|
cxt.subschema({
|
|
schema: macroSchema,
|
|
schemaPath: codegen_1.nil,
|
|
errSchemaPath: `${it.errSchemaPath}/${keyword}`,
|
|
topSchemaRef: schemaRef,
|
|
compositeRule: true
|
|
}, valid);
|
|
cxt.pass(valid, () => cxt.error(true));
|
|
}
|
|
exports.macroKeywordCode = macroKeywordCode;
|
|
function funcKeywordCode(cxt, def) {
|
|
var _a;
|
|
const { gen, keyword, schema, parentSchema, $data, it } = cxt;
|
|
checkAsyncKeyword(it, def);
|
|
const validate = !$data && def.compile ? def.compile.call(it.self, schema, parentSchema, it) : def.validate;
|
|
const validateRef = useKeyword(gen, keyword, validate);
|
|
const valid = gen.let("valid");
|
|
cxt.block$data(valid, validateKeyword);
|
|
cxt.ok((_a = def.valid) !== null && _a !== undefined ? _a : valid);
|
|
function validateKeyword() {
|
|
if (def.errors === false) {
|
|
assignValid();
|
|
if (def.modifying)
|
|
modifyData(cxt);
|
|
reportErrs(() => cxt.error());
|
|
} else {
|
|
const ruleErrs = def.async ? validateAsync() : validateSync();
|
|
if (def.modifying)
|
|
modifyData(cxt);
|
|
reportErrs(() => addErrs(cxt, ruleErrs));
|
|
}
|
|
}
|
|
function validateAsync() {
|
|
const ruleErrs = gen.let("ruleErrs", null);
|
|
gen.try(() => assignValid((0, codegen_1._)`await `), (e) => gen.assign(valid, false).if((0, codegen_1._)`${e} instanceof ${it.ValidationError}`, () => gen.assign(ruleErrs, (0, codegen_1._)`${e}.errors`), () => gen.throw(e)));
|
|
return ruleErrs;
|
|
}
|
|
function validateSync() {
|
|
const validateErrs = (0, codegen_1._)`${validateRef}.errors`;
|
|
gen.assign(validateErrs, null);
|
|
assignValid(codegen_1.nil);
|
|
return validateErrs;
|
|
}
|
|
function assignValid(_await = def.async ? (0, codegen_1._)`await ` : codegen_1.nil) {
|
|
const passCxt = it.opts.passContext ? names_1.default.this : names_1.default.self;
|
|
const passSchema = !(("compile" in def) && !$data || def.schema === false);
|
|
gen.assign(valid, (0, codegen_1._)`${_await}${(0, code_1.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`, def.modifying);
|
|
}
|
|
function reportErrs(errors3) {
|
|
var _a2;
|
|
gen.if((0, codegen_1.not)((_a2 = def.valid) !== null && _a2 !== undefined ? _a2 : valid), errors3);
|
|
}
|
|
}
|
|
exports.funcKeywordCode = funcKeywordCode;
|
|
function modifyData(cxt) {
|
|
const { gen, data, it } = cxt;
|
|
gen.if(it.parentData, () => gen.assign(data, (0, codegen_1._)`${it.parentData}[${it.parentDataProperty}]`));
|
|
}
|
|
function addErrs(cxt, errs) {
|
|
const { gen } = cxt;
|
|
gen.if((0, codegen_1._)`Array.isArray(${errs})`, () => {
|
|
gen.assign(names_1.default.vErrors, (0, codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`).assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`);
|
|
(0, errors_1.extendErrors)(cxt);
|
|
}, () => cxt.error());
|
|
}
|
|
function checkAsyncKeyword({ schemaEnv }, def) {
|
|
if (def.async && !schemaEnv.$async)
|
|
throw new Error("async keyword in sync schema");
|
|
}
|
|
function useKeyword(gen, keyword, result) {
|
|
if (result === undefined)
|
|
throw new Error(`keyword "${keyword}" failed to compile`);
|
|
return gen.scopeValue("keyword", typeof result == "function" ? { ref: result } : { ref: result, code: (0, codegen_1.stringify)(result) });
|
|
}
|
|
function validSchemaType(schema, schemaType, allowUndefined = false) {
|
|
return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema) : st === "object" ? schema && typeof schema == "object" && !Array.isArray(schema) : typeof schema == st || allowUndefined && typeof schema == "undefined");
|
|
}
|
|
exports.validSchemaType = validSchemaType;
|
|
function validateKeywordUsage({ schema, opts, self: self2, errSchemaPath }, def, keyword) {
|
|
if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword) {
|
|
throw new Error("ajv implementation error");
|
|
}
|
|
const deps = def.dependencies;
|
|
if (deps === null || deps === undefined ? undefined : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema, kwd))) {
|
|
throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(",")}`);
|
|
}
|
|
if (def.validateSchema) {
|
|
const valid = def.validateSchema(schema[keyword]);
|
|
if (!valid) {
|
|
const msg = `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` + self2.errorsText(def.validateSchema.errors);
|
|
if (opts.validateSchema === "log")
|
|
self2.logger.error(msg);
|
|
else
|
|
throw new Error(msg);
|
|
}
|
|
}
|
|
}
|
|
exports.validateKeywordUsage = validateKeywordUsage;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/compile/validate/subschema.js
|
|
var require_subschema = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = undefined;
|
|
var codegen_1 = require_codegen();
|
|
var util_1 = require_util();
|
|
function getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {
|
|
if (keyword !== undefined && schema !== undefined) {
|
|
throw new Error('both "keyword" and "schema" passed, only one allowed');
|
|
}
|
|
if (keyword !== undefined) {
|
|
const sch = it.schema[keyword];
|
|
return schemaProp === undefined ? {
|
|
schema: sch,
|
|
schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}`,
|
|
errSchemaPath: `${it.errSchemaPath}/${keyword}`
|
|
} : {
|
|
schema: sch[schemaProp],
|
|
schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}${(0, codegen_1.getProperty)(schemaProp)}`,
|
|
errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}`
|
|
};
|
|
}
|
|
if (schema !== undefined) {
|
|
if (schemaPath === undefined || errSchemaPath === undefined || topSchemaRef === undefined) {
|
|
throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"');
|
|
}
|
|
return {
|
|
schema,
|
|
schemaPath,
|
|
topSchemaRef,
|
|
errSchemaPath
|
|
};
|
|
}
|
|
throw new Error('either "keyword" or "schema" must be passed');
|
|
}
|
|
exports.getSubschema = getSubschema;
|
|
function extendSubschemaData(subschema, it, { dataProp, dataPropType: dpType, data, dataTypes, propertyName }) {
|
|
if (data !== undefined && dataProp !== undefined) {
|
|
throw new Error('both "data" and "dataProp" passed, only one allowed');
|
|
}
|
|
const { gen } = it;
|
|
if (dataProp !== undefined) {
|
|
const { errorPath, dataPathArr, opts } = it;
|
|
const nextData = gen.let("data", (0, codegen_1._)`${it.data}${(0, codegen_1.getProperty)(dataProp)}`, true);
|
|
dataContextProps(nextData);
|
|
subschema.errorPath = (0, codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`;
|
|
subschema.parentDataProperty = (0, codegen_1._)`${dataProp}`;
|
|
subschema.dataPathArr = [...dataPathArr, subschema.parentDataProperty];
|
|
}
|
|
if (data !== undefined) {
|
|
const nextData = data instanceof codegen_1.Name ? data : gen.let("data", data, true);
|
|
dataContextProps(nextData);
|
|
if (propertyName !== undefined)
|
|
subschema.propertyName = propertyName;
|
|
}
|
|
if (dataTypes)
|
|
subschema.dataTypes = dataTypes;
|
|
function dataContextProps(_nextData) {
|
|
subschema.data = _nextData;
|
|
subschema.dataLevel = it.dataLevel + 1;
|
|
subschema.dataTypes = [];
|
|
it.definedProperties = new Set;
|
|
subschema.parentData = it.data;
|
|
subschema.dataNames = [...it.dataNames, _nextData];
|
|
}
|
|
}
|
|
exports.extendSubschemaData = extendSubschemaData;
|
|
function extendSubschemaMode(subschema, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }) {
|
|
if (compositeRule !== undefined)
|
|
subschema.compositeRule = compositeRule;
|
|
if (createErrors !== undefined)
|
|
subschema.createErrors = createErrors;
|
|
if (allErrors !== undefined)
|
|
subschema.allErrors = allErrors;
|
|
subschema.jtdDiscriminator = jtdDiscriminator;
|
|
subschema.jtdMetadata = jtdMetadata;
|
|
}
|
|
exports.extendSubschemaMode = extendSubschemaMode;
|
|
});
|
|
|
|
// ../node_modules/fast-deep-equal/index.js
|
|
var require_fast_deep_equal = __commonJS((exports, module) => {
|
|
module.exports = function equal(a, b) {
|
|
if (a === b)
|
|
return true;
|
|
if (a && b && typeof a == "object" && typeof b == "object") {
|
|
if (a.constructor !== b.constructor)
|
|
return false;
|
|
var length, i, keys;
|
|
if (Array.isArray(a)) {
|
|
length = a.length;
|
|
if (length != b.length)
|
|
return false;
|
|
for (i = length;i-- !== 0; )
|
|
if (!equal(a[i], b[i]))
|
|
return false;
|
|
return true;
|
|
}
|
|
if (a.constructor === RegExp)
|
|
return a.source === b.source && a.flags === b.flags;
|
|
if (a.valueOf !== Object.prototype.valueOf)
|
|
return a.valueOf() === b.valueOf();
|
|
if (a.toString !== Object.prototype.toString)
|
|
return a.toString() === b.toString();
|
|
keys = Object.keys(a);
|
|
length = keys.length;
|
|
if (length !== Object.keys(b).length)
|
|
return false;
|
|
for (i = length;i-- !== 0; )
|
|
if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
|
|
return false;
|
|
for (i = length;i-- !== 0; ) {
|
|
var key = keys[i];
|
|
if (!equal(a[key], b[key]))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
return a !== a && b !== b;
|
|
};
|
|
});
|
|
|
|
// ../node_modules/json-schema-traverse/index.js
|
|
var require_json_schema_traverse = __commonJS((exports, module) => {
|
|
var traverse = module.exports = function(schema, opts, cb) {
|
|
if (typeof opts == "function") {
|
|
cb = opts;
|
|
opts = {};
|
|
}
|
|
cb = opts.cb || cb;
|
|
var pre = typeof cb == "function" ? cb : cb.pre || function() {};
|
|
var post = cb.post || function() {};
|
|
_traverse(opts, pre, post, schema, "", schema);
|
|
};
|
|
traverse.keywords = {
|
|
additionalItems: true,
|
|
items: true,
|
|
contains: true,
|
|
additionalProperties: true,
|
|
propertyNames: true,
|
|
not: true,
|
|
if: true,
|
|
then: true,
|
|
else: true
|
|
};
|
|
traverse.arrayKeywords = {
|
|
items: true,
|
|
allOf: true,
|
|
anyOf: true,
|
|
oneOf: true
|
|
};
|
|
traverse.propsKeywords = {
|
|
$defs: true,
|
|
definitions: true,
|
|
properties: true,
|
|
patternProperties: true,
|
|
dependencies: true
|
|
};
|
|
traverse.skipKeywords = {
|
|
default: true,
|
|
enum: true,
|
|
const: true,
|
|
required: true,
|
|
maximum: true,
|
|
minimum: true,
|
|
exclusiveMaximum: true,
|
|
exclusiveMinimum: true,
|
|
multipleOf: true,
|
|
maxLength: true,
|
|
minLength: true,
|
|
pattern: true,
|
|
format: true,
|
|
maxItems: true,
|
|
minItems: true,
|
|
uniqueItems: true,
|
|
maxProperties: true,
|
|
minProperties: true
|
|
};
|
|
function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
|
|
if (schema && typeof schema == "object" && !Array.isArray(schema)) {
|
|
pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
|
|
for (var key in schema) {
|
|
var sch = schema[key];
|
|
if (Array.isArray(sch)) {
|
|
if (key in traverse.arrayKeywords) {
|
|
for (var i = 0;i < sch.length; i++)
|
|
_traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema, i);
|
|
}
|
|
} else if (key in traverse.propsKeywords) {
|
|
if (sch && typeof sch == "object") {
|
|
for (var prop in sch)
|
|
_traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
|
|
}
|
|
} else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) {
|
|
_traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema);
|
|
}
|
|
}
|
|
post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
|
|
}
|
|
}
|
|
function escapeJsonPtr(str) {
|
|
return str.replace(/~/g, "~0").replace(/\//g, "~1");
|
|
}
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/compile/resolve.js
|
|
var require_resolve = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.getSchemaRefs = exports.resolveUrl = exports.normalizeId = exports._getFullPath = exports.getFullPath = exports.inlineRef = undefined;
|
|
var util_1 = require_util();
|
|
var equal = require_fast_deep_equal();
|
|
var traverse = require_json_schema_traverse();
|
|
var SIMPLE_INLINED = new Set([
|
|
"type",
|
|
"format",
|
|
"pattern",
|
|
"maxLength",
|
|
"minLength",
|
|
"maxProperties",
|
|
"minProperties",
|
|
"maxItems",
|
|
"minItems",
|
|
"maximum",
|
|
"minimum",
|
|
"uniqueItems",
|
|
"multipleOf",
|
|
"required",
|
|
"enum",
|
|
"const"
|
|
]);
|
|
function inlineRef(schema, limit = true) {
|
|
if (typeof schema == "boolean")
|
|
return true;
|
|
if (limit === true)
|
|
return !hasRef(schema);
|
|
if (!limit)
|
|
return false;
|
|
return countKeys(schema) <= limit;
|
|
}
|
|
exports.inlineRef = inlineRef;
|
|
var REF_KEYWORDS = new Set([
|
|
"$ref",
|
|
"$recursiveRef",
|
|
"$recursiveAnchor",
|
|
"$dynamicRef",
|
|
"$dynamicAnchor"
|
|
]);
|
|
function hasRef(schema) {
|
|
for (const key in schema) {
|
|
if (REF_KEYWORDS.has(key))
|
|
return true;
|
|
const sch = schema[key];
|
|
if (Array.isArray(sch) && sch.some(hasRef))
|
|
return true;
|
|
if (typeof sch == "object" && hasRef(sch))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function countKeys(schema) {
|
|
let count = 0;
|
|
for (const key in schema) {
|
|
if (key === "$ref")
|
|
return Infinity;
|
|
count++;
|
|
if (SIMPLE_INLINED.has(key))
|
|
continue;
|
|
if (typeof schema[key] == "object") {
|
|
(0, util_1.eachItem)(schema[key], (sch) => count += countKeys(sch));
|
|
}
|
|
if (count === Infinity)
|
|
return Infinity;
|
|
}
|
|
return count;
|
|
}
|
|
function getFullPath(resolver, id = "", normalize) {
|
|
if (normalize !== false)
|
|
id = normalizeId(id);
|
|
const p = resolver.parse(id);
|
|
return _getFullPath(resolver, p);
|
|
}
|
|
exports.getFullPath = getFullPath;
|
|
function _getFullPath(resolver, p) {
|
|
const serialized = resolver.serialize(p);
|
|
return serialized.split("#")[0] + "#";
|
|
}
|
|
exports._getFullPath = _getFullPath;
|
|
var TRAILING_SLASH_HASH = /#\/?$/;
|
|
function normalizeId(id) {
|
|
return id ? id.replace(TRAILING_SLASH_HASH, "") : "";
|
|
}
|
|
exports.normalizeId = normalizeId;
|
|
function resolveUrl(resolver, baseId, id) {
|
|
id = normalizeId(id);
|
|
return resolver.resolve(baseId, id);
|
|
}
|
|
exports.resolveUrl = resolveUrl;
|
|
var ANCHOR = /^[a-z_][-a-z0-9._]*$/i;
|
|
function getSchemaRefs(schema, baseId) {
|
|
if (typeof schema == "boolean")
|
|
return {};
|
|
const { schemaId, uriResolver } = this.opts;
|
|
const schId = normalizeId(schema[schemaId] || baseId);
|
|
const baseIds = { "": schId };
|
|
const pathPrefix = getFullPath(uriResolver, schId, false);
|
|
const localRefs = {};
|
|
const schemaRefs = new Set;
|
|
traverse(schema, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
|
|
if (parentJsonPtr === undefined)
|
|
return;
|
|
const fullPath = pathPrefix + jsonPtr;
|
|
let innerBaseId = baseIds[parentJsonPtr];
|
|
if (typeof sch[schemaId] == "string")
|
|
innerBaseId = addRef.call(this, sch[schemaId]);
|
|
addAnchor.call(this, sch.$anchor);
|
|
addAnchor.call(this, sch.$dynamicAnchor);
|
|
baseIds[jsonPtr] = innerBaseId;
|
|
function addRef(ref) {
|
|
const _resolve = this.opts.uriResolver.resolve;
|
|
ref = normalizeId(innerBaseId ? _resolve(innerBaseId, ref) : ref);
|
|
if (schemaRefs.has(ref))
|
|
throw ambiguos(ref);
|
|
schemaRefs.add(ref);
|
|
let schOrRef = this.refs[ref];
|
|
if (typeof schOrRef == "string")
|
|
schOrRef = this.refs[schOrRef];
|
|
if (typeof schOrRef == "object") {
|
|
checkAmbiguosRef(sch, schOrRef.schema, ref);
|
|
} else if (ref !== normalizeId(fullPath)) {
|
|
if (ref[0] === "#") {
|
|
checkAmbiguosRef(sch, localRefs[ref], ref);
|
|
localRefs[ref] = sch;
|
|
} else {
|
|
this.refs[ref] = fullPath;
|
|
}
|
|
}
|
|
return ref;
|
|
}
|
|
function addAnchor(anchor) {
|
|
if (typeof anchor == "string") {
|
|
if (!ANCHOR.test(anchor))
|
|
throw new Error(`invalid anchor "${anchor}"`);
|
|
addRef.call(this, `#${anchor}`);
|
|
}
|
|
}
|
|
});
|
|
return localRefs;
|
|
function checkAmbiguosRef(sch1, sch2, ref) {
|
|
if (sch2 !== undefined && !equal(sch1, sch2))
|
|
throw ambiguos(ref);
|
|
}
|
|
function ambiguos(ref) {
|
|
return new Error(`reference "${ref}" resolves to more than one schema`);
|
|
}
|
|
}
|
|
exports.getSchemaRefs = getSchemaRefs;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/compile/validate/index.js
|
|
var require_validate = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.getData = exports.KeywordCxt = exports.validateFunctionCode = undefined;
|
|
var boolSchema_1 = require_boolSchema();
|
|
var dataType_1 = require_dataType();
|
|
var applicability_1 = require_applicability();
|
|
var dataType_2 = require_dataType();
|
|
var defaults_1 = require_defaults();
|
|
var keyword_1 = require_keyword();
|
|
var subschema_1 = require_subschema();
|
|
var codegen_1 = require_codegen();
|
|
var names_1 = require_names();
|
|
var resolve_1 = require_resolve();
|
|
var util_1 = require_util();
|
|
var errors_1 = require_errors();
|
|
function validateFunctionCode(it) {
|
|
if (isSchemaObj(it)) {
|
|
checkKeywords(it);
|
|
if (schemaCxtHasRules(it)) {
|
|
topSchemaObjCode(it);
|
|
return;
|
|
}
|
|
}
|
|
validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it));
|
|
}
|
|
exports.validateFunctionCode = validateFunctionCode;
|
|
function validateFunction({ gen, validateName, schema, schemaEnv, opts }, body) {
|
|
if (opts.code.es5) {
|
|
gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`, schemaEnv.$async, () => {
|
|
gen.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema, opts)}`);
|
|
destructureValCxtES5(gen, opts);
|
|
gen.code(body);
|
|
});
|
|
} else {
|
|
gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body));
|
|
}
|
|
}
|
|
function destructureValCxt(opts) {
|
|
return (0, codegen_1._)`{${names_1.default.instancePath}="", ${names_1.default.parentData}, ${names_1.default.parentDataProperty}, ${names_1.default.rootData}=${names_1.default.data}${opts.dynamicRef ? (0, codegen_1._)`, ${names_1.default.dynamicAnchors}={}` : codegen_1.nil}}={}`;
|
|
}
|
|
function destructureValCxtES5(gen, opts) {
|
|
gen.if(names_1.default.valCxt, () => {
|
|
gen.var(names_1.default.instancePath, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.instancePath}`);
|
|
gen.var(names_1.default.parentData, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentData}`);
|
|
gen.var(names_1.default.parentDataProperty, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentDataProperty}`);
|
|
gen.var(names_1.default.rootData, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.rootData}`);
|
|
if (opts.dynamicRef)
|
|
gen.var(names_1.default.dynamicAnchors, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.dynamicAnchors}`);
|
|
}, () => {
|
|
gen.var(names_1.default.instancePath, (0, codegen_1._)`""`);
|
|
gen.var(names_1.default.parentData, (0, codegen_1._)`undefined`);
|
|
gen.var(names_1.default.parentDataProperty, (0, codegen_1._)`undefined`);
|
|
gen.var(names_1.default.rootData, names_1.default.data);
|
|
if (opts.dynamicRef)
|
|
gen.var(names_1.default.dynamicAnchors, (0, codegen_1._)`{}`);
|
|
});
|
|
}
|
|
function topSchemaObjCode(it) {
|
|
const { schema, opts, gen } = it;
|
|
validateFunction(it, () => {
|
|
if (opts.$comment && schema.$comment)
|
|
commentKeyword(it);
|
|
checkNoDefault(it);
|
|
gen.let(names_1.default.vErrors, null);
|
|
gen.let(names_1.default.errors, 0);
|
|
if (opts.unevaluated)
|
|
resetEvaluated(it);
|
|
typeAndKeywords(it);
|
|
returnResults(it);
|
|
});
|
|
return;
|
|
}
|
|
function resetEvaluated(it) {
|
|
const { gen, validateName } = it;
|
|
it.evaluated = gen.const("evaluated", (0, codegen_1._)`${validateName}.evaluated`);
|
|
gen.if((0, codegen_1._)`${it.evaluated}.dynamicProps`, () => gen.assign((0, codegen_1._)`${it.evaluated}.props`, (0, codegen_1._)`undefined`));
|
|
gen.if((0, codegen_1._)`${it.evaluated}.dynamicItems`, () => gen.assign((0, codegen_1._)`${it.evaluated}.items`, (0, codegen_1._)`undefined`));
|
|
}
|
|
function funcSourceUrl(schema, opts) {
|
|
const schId = typeof schema == "object" && schema[opts.schemaId];
|
|
return schId && (opts.code.source || opts.code.process) ? (0, codegen_1._)`/*# sourceURL=${schId} */` : codegen_1.nil;
|
|
}
|
|
function subschemaCode(it, valid) {
|
|
if (isSchemaObj(it)) {
|
|
checkKeywords(it);
|
|
if (schemaCxtHasRules(it)) {
|
|
subSchemaObjCode(it, valid);
|
|
return;
|
|
}
|
|
}
|
|
(0, boolSchema_1.boolOrEmptySchema)(it, valid);
|
|
}
|
|
function schemaCxtHasRules({ schema, self: self2 }) {
|
|
if (typeof schema == "boolean")
|
|
return !schema;
|
|
for (const key in schema)
|
|
if (self2.RULES.all[key])
|
|
return true;
|
|
return false;
|
|
}
|
|
function isSchemaObj(it) {
|
|
return typeof it.schema != "boolean";
|
|
}
|
|
function subSchemaObjCode(it, valid) {
|
|
const { schema, gen, opts } = it;
|
|
if (opts.$comment && schema.$comment)
|
|
commentKeyword(it);
|
|
updateContext(it);
|
|
checkAsyncSchema(it);
|
|
const errsCount = gen.const("_errs", names_1.default.errors);
|
|
typeAndKeywords(it, errsCount);
|
|
gen.var(valid, (0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
|
|
}
|
|
function checkKeywords(it) {
|
|
(0, util_1.checkUnknownRules)(it);
|
|
checkRefsAndKeywords(it);
|
|
}
|
|
function typeAndKeywords(it, errsCount) {
|
|
if (it.opts.jtd)
|
|
return schemaKeywords(it, [], false, errsCount);
|
|
const types = (0, dataType_1.getSchemaTypes)(it.schema);
|
|
const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types);
|
|
schemaKeywords(it, types, !checkedTypes, errsCount);
|
|
}
|
|
function checkRefsAndKeywords(it) {
|
|
const { schema, errSchemaPath, opts, self: self2 } = it;
|
|
if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema, self2.RULES)) {
|
|
self2.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
|
|
}
|
|
}
|
|
function checkNoDefault(it) {
|
|
const { schema, opts } = it;
|
|
if (schema.default !== undefined && opts.useDefaults && opts.strictSchema) {
|
|
(0, util_1.checkStrictMode)(it, "default is ignored in the schema root");
|
|
}
|
|
}
|
|
function updateContext(it) {
|
|
const schId = it.schema[it.opts.schemaId];
|
|
if (schId)
|
|
it.baseId = (0, resolve_1.resolveUrl)(it.opts.uriResolver, it.baseId, schId);
|
|
}
|
|
function checkAsyncSchema(it) {
|
|
if (it.schema.$async && !it.schemaEnv.$async)
|
|
throw new Error("async schema in sync schema");
|
|
}
|
|
function commentKeyword({ gen, schemaEnv, schema, errSchemaPath, opts }) {
|
|
const msg = schema.$comment;
|
|
if (opts.$comment === true) {
|
|
gen.code((0, codegen_1._)`${names_1.default.self}.logger.log(${msg})`);
|
|
} else if (typeof opts.$comment == "function") {
|
|
const schemaPath = (0, codegen_1.str)`${errSchemaPath}/$comment`;
|
|
const rootName = gen.scopeValue("root", { ref: schemaEnv.root });
|
|
gen.code((0, codegen_1._)`${names_1.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`);
|
|
}
|
|
}
|
|
function returnResults(it) {
|
|
const { gen, schemaEnv, validateName, ValidationError, opts } = it;
|
|
if (schemaEnv.$async) {
|
|
gen.if((0, codegen_1._)`${names_1.default.errors} === 0`, () => gen.return(names_1.default.data), () => gen.throw((0, codegen_1._)`new ${ValidationError}(${names_1.default.vErrors})`));
|
|
} else {
|
|
gen.assign((0, codegen_1._)`${validateName}.errors`, names_1.default.vErrors);
|
|
if (opts.unevaluated)
|
|
assignEvaluated(it);
|
|
gen.return((0, codegen_1._)`${names_1.default.errors} === 0`);
|
|
}
|
|
}
|
|
function assignEvaluated({ gen, evaluated, props, items }) {
|
|
if (props instanceof codegen_1.Name)
|
|
gen.assign((0, codegen_1._)`${evaluated}.props`, props);
|
|
if (items instanceof codegen_1.Name)
|
|
gen.assign((0, codegen_1._)`${evaluated}.items`, items);
|
|
}
|
|
function schemaKeywords(it, types, typeErrors, errsCount) {
|
|
const { gen, schema, data, allErrors, opts, self: self2 } = it;
|
|
const { RULES } = self2;
|
|
if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))) {
|
|
gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
|
|
return;
|
|
}
|
|
if (!opts.jtd)
|
|
checkStrictTypes(it, types);
|
|
gen.block(() => {
|
|
for (const group of RULES.rules)
|
|
groupKeywords(group);
|
|
groupKeywords(RULES.post);
|
|
});
|
|
function groupKeywords(group) {
|
|
if (!(0, applicability_1.shouldUseGroup)(schema, group))
|
|
return;
|
|
if (group.type) {
|
|
gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
|
|
iterateKeywords(it, group);
|
|
if (types.length === 1 && types[0] === group.type && typeErrors) {
|
|
gen.else();
|
|
(0, dataType_2.reportTypeError)(it);
|
|
}
|
|
gen.endIf();
|
|
} else {
|
|
iterateKeywords(it, group);
|
|
}
|
|
if (!allErrors)
|
|
gen.if((0, codegen_1._)`${names_1.default.errors} === ${errsCount || 0}`);
|
|
}
|
|
}
|
|
function iterateKeywords(it, group) {
|
|
const { gen, schema, opts: { useDefaults } } = it;
|
|
if (useDefaults)
|
|
(0, defaults_1.assignDefaults)(it, group.type);
|
|
gen.block(() => {
|
|
for (const rule of group.rules) {
|
|
if ((0, applicability_1.shouldUseRule)(schema, rule)) {
|
|
keywordCode(it, rule.keyword, rule.definition, group.type);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function checkStrictTypes(it, types) {
|
|
if (it.schemaEnv.meta || !it.opts.strictTypes)
|
|
return;
|
|
checkContextTypes(it, types);
|
|
if (!it.opts.allowUnionTypes)
|
|
checkMultipleTypes(it, types);
|
|
checkKeywordTypes(it, it.dataTypes);
|
|
}
|
|
function checkContextTypes(it, types) {
|
|
if (!types.length)
|
|
return;
|
|
if (!it.dataTypes.length) {
|
|
it.dataTypes = types;
|
|
return;
|
|
}
|
|
types.forEach((t) => {
|
|
if (!includesType(it.dataTypes, t)) {
|
|
strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`);
|
|
}
|
|
});
|
|
narrowSchemaTypes(it, types);
|
|
}
|
|
function checkMultipleTypes(it, ts) {
|
|
if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) {
|
|
strictTypesError(it, "use allowUnionTypes to allow union type keyword");
|
|
}
|
|
}
|
|
function checkKeywordTypes(it, ts) {
|
|
const rules = it.self.RULES.all;
|
|
for (const keyword in rules) {
|
|
const rule = rules[keyword];
|
|
if (typeof rule == "object" && (0, applicability_1.shouldUseRule)(it.schema, rule)) {
|
|
const { type } = rule.definition;
|
|
if (type.length && !type.some((t) => hasApplicableType(ts, t))) {
|
|
strictTypesError(it, `missing type "${type.join(",")}" for keyword "${keyword}"`);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function hasApplicableType(schTs, kwdT) {
|
|
return schTs.includes(kwdT) || kwdT === "number" && schTs.includes("integer");
|
|
}
|
|
function includesType(ts, t) {
|
|
return ts.includes(t) || t === "integer" && ts.includes("number");
|
|
}
|
|
function narrowSchemaTypes(it, withTypes) {
|
|
const ts = [];
|
|
for (const t of it.dataTypes) {
|
|
if (includesType(withTypes, t))
|
|
ts.push(t);
|
|
else if (withTypes.includes("integer") && t === "number")
|
|
ts.push("integer");
|
|
}
|
|
it.dataTypes = ts;
|
|
}
|
|
function strictTypesError(it, msg) {
|
|
const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
|
|
msg += ` at "${schemaPath}" (strictTypes)`;
|
|
(0, util_1.checkStrictMode)(it, msg, it.opts.strictTypes);
|
|
}
|
|
|
|
class KeywordCxt {
|
|
constructor(it, def, keyword) {
|
|
(0, keyword_1.validateKeywordUsage)(it, def, keyword);
|
|
this.gen = it.gen;
|
|
this.allErrors = it.allErrors;
|
|
this.keyword = keyword;
|
|
this.data = it.data;
|
|
this.schema = it.schema[keyword];
|
|
this.$data = def.$data && it.opts.$data && this.schema && this.schema.$data;
|
|
this.schemaValue = (0, util_1.schemaRefOrVal)(it, this.schema, keyword, this.$data);
|
|
this.schemaType = def.schemaType;
|
|
this.parentSchema = it.schema;
|
|
this.params = {};
|
|
this.it = it;
|
|
this.def = def;
|
|
if (this.$data) {
|
|
this.schemaCode = it.gen.const("vSchema", getData(this.$data, it));
|
|
} else {
|
|
this.schemaCode = this.schemaValue;
|
|
if (!(0, keyword_1.validSchemaType)(this.schema, def.schemaType, def.allowUndefined)) {
|
|
throw new Error(`${keyword} value must be ${JSON.stringify(def.schemaType)}`);
|
|
}
|
|
}
|
|
if ("code" in def ? def.trackErrors : def.errors !== false) {
|
|
this.errsCount = it.gen.const("_errs", names_1.default.errors);
|
|
}
|
|
}
|
|
result(condition, successAction, failAction) {
|
|
this.failResult((0, codegen_1.not)(condition), successAction, failAction);
|
|
}
|
|
failResult(condition, successAction, failAction) {
|
|
this.gen.if(condition);
|
|
if (failAction)
|
|
failAction();
|
|
else
|
|
this.error();
|
|
if (successAction) {
|
|
this.gen.else();
|
|
successAction();
|
|
if (this.allErrors)
|
|
this.gen.endIf();
|
|
} else {
|
|
if (this.allErrors)
|
|
this.gen.endIf();
|
|
else
|
|
this.gen.else();
|
|
}
|
|
}
|
|
pass(condition, failAction) {
|
|
this.failResult((0, codegen_1.not)(condition), undefined, failAction);
|
|
}
|
|
fail(condition) {
|
|
if (condition === undefined) {
|
|
this.error();
|
|
if (!this.allErrors)
|
|
this.gen.if(false);
|
|
return;
|
|
}
|
|
this.gen.if(condition);
|
|
this.error();
|
|
if (this.allErrors)
|
|
this.gen.endIf();
|
|
else
|
|
this.gen.else();
|
|
}
|
|
fail$data(condition) {
|
|
if (!this.$data)
|
|
return this.fail(condition);
|
|
const { schemaCode } = this;
|
|
this.fail((0, codegen_1._)`${schemaCode} !== undefined && (${(0, codegen_1.or)(this.invalid$data(), condition)})`);
|
|
}
|
|
error(append, errorParams, errorPaths) {
|
|
if (errorParams) {
|
|
this.setParams(errorParams);
|
|
this._error(append, errorPaths);
|
|
this.setParams({});
|
|
return;
|
|
}
|
|
this._error(append, errorPaths);
|
|
}
|
|
_error(append, errorPaths) {
|
|
(append ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths);
|
|
}
|
|
$dataError() {
|
|
(0, errors_1.reportError)(this, this.def.$dataError || errors_1.keyword$DataError);
|
|
}
|
|
reset() {
|
|
if (this.errsCount === undefined)
|
|
throw new Error('add "trackErrors" to keyword definition');
|
|
(0, errors_1.resetErrorsCount)(this.gen, this.errsCount);
|
|
}
|
|
ok(cond) {
|
|
if (!this.allErrors)
|
|
this.gen.if(cond);
|
|
}
|
|
setParams(obj, assign) {
|
|
if (assign)
|
|
Object.assign(this.params, obj);
|
|
else
|
|
this.params = obj;
|
|
}
|
|
block$data(valid, codeBlock, $dataValid = codegen_1.nil) {
|
|
this.gen.block(() => {
|
|
this.check$data(valid, $dataValid);
|
|
codeBlock();
|
|
});
|
|
}
|
|
check$data(valid = codegen_1.nil, $dataValid = codegen_1.nil) {
|
|
if (!this.$data)
|
|
return;
|
|
const { gen, schemaCode, schemaType, def } = this;
|
|
gen.if((0, codegen_1.or)((0, codegen_1._)`${schemaCode} === undefined`, $dataValid));
|
|
if (valid !== codegen_1.nil)
|
|
gen.assign(valid, true);
|
|
if (schemaType.length || def.validateSchema) {
|
|
gen.elseIf(this.invalid$data());
|
|
this.$dataError();
|
|
if (valid !== codegen_1.nil)
|
|
gen.assign(valid, false);
|
|
}
|
|
gen.else();
|
|
}
|
|
invalid$data() {
|
|
const { gen, schemaCode, schemaType, def, it } = this;
|
|
return (0, codegen_1.or)(wrong$DataType(), invalid$DataSchema());
|
|
function wrong$DataType() {
|
|
if (schemaType.length) {
|
|
if (!(schemaCode instanceof codegen_1.Name))
|
|
throw new Error("ajv implementation error");
|
|
const st = Array.isArray(schemaType) ? schemaType : [schemaType];
|
|
return (0, codegen_1._)`${(0, dataType_2.checkDataTypes)(st, schemaCode, it.opts.strictNumbers, dataType_2.DataType.Wrong)}`;
|
|
}
|
|
return codegen_1.nil;
|
|
}
|
|
function invalid$DataSchema() {
|
|
if (def.validateSchema) {
|
|
const validateSchemaRef = gen.scopeValue("validate$data", { ref: def.validateSchema });
|
|
return (0, codegen_1._)`!${validateSchemaRef}(${schemaCode})`;
|
|
}
|
|
return codegen_1.nil;
|
|
}
|
|
}
|
|
subschema(appl, valid) {
|
|
const subschema = (0, subschema_1.getSubschema)(this.it, appl);
|
|
(0, subschema_1.extendSubschemaData)(subschema, this.it, appl);
|
|
(0, subschema_1.extendSubschemaMode)(subschema, appl);
|
|
const nextContext = { ...this.it, ...subschema, items: undefined, props: undefined };
|
|
subschemaCode(nextContext, valid);
|
|
return nextContext;
|
|
}
|
|
mergeEvaluated(schemaCxt, toName) {
|
|
const { it, gen } = this;
|
|
if (!it.opts.unevaluated)
|
|
return;
|
|
if (it.props !== true && schemaCxt.props !== undefined) {
|
|
it.props = util_1.mergeEvaluated.props(gen, schemaCxt.props, it.props, toName);
|
|
}
|
|
if (it.items !== true && schemaCxt.items !== undefined) {
|
|
it.items = util_1.mergeEvaluated.items(gen, schemaCxt.items, it.items, toName);
|
|
}
|
|
}
|
|
mergeValidEvaluated(schemaCxt, valid) {
|
|
const { it, gen } = this;
|
|
if (it.opts.unevaluated && (it.props !== true || it.items !== true)) {
|
|
gen.if(valid, () => this.mergeEvaluated(schemaCxt, codegen_1.Name));
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
exports.KeywordCxt = KeywordCxt;
|
|
function keywordCode(it, keyword, def, ruleType) {
|
|
const cxt = new KeywordCxt(it, def, keyword);
|
|
if ("code" in def) {
|
|
def.code(cxt, ruleType);
|
|
} else if (cxt.$data && def.validate) {
|
|
(0, keyword_1.funcKeywordCode)(cxt, def);
|
|
} else if ("macro" in def) {
|
|
(0, keyword_1.macroKeywordCode)(cxt, def);
|
|
} else if (def.compile || def.validate) {
|
|
(0, keyword_1.funcKeywordCode)(cxt, def);
|
|
}
|
|
}
|
|
var JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/;
|
|
var RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
|
|
function getData($data, { dataLevel, dataNames, dataPathArr }) {
|
|
let jsonPointer;
|
|
let data;
|
|
if ($data === "")
|
|
return names_1.default.rootData;
|
|
if ($data[0] === "/") {
|
|
if (!JSON_POINTER.test($data))
|
|
throw new Error(`Invalid JSON-pointer: ${$data}`);
|
|
jsonPointer = $data;
|
|
data = names_1.default.rootData;
|
|
} else {
|
|
const matches = RELATIVE_JSON_POINTER.exec($data);
|
|
if (!matches)
|
|
throw new Error(`Invalid JSON-pointer: ${$data}`);
|
|
const up = +matches[1];
|
|
jsonPointer = matches[2];
|
|
if (jsonPointer === "#") {
|
|
if (up >= dataLevel)
|
|
throw new Error(errorMsg("property/index", up));
|
|
return dataPathArr[dataLevel - up];
|
|
}
|
|
if (up > dataLevel)
|
|
throw new Error(errorMsg("data", up));
|
|
data = dataNames[dataLevel - up];
|
|
if (!jsonPointer)
|
|
return data;
|
|
}
|
|
let expr = data;
|
|
const segments = jsonPointer.split("/");
|
|
for (const segment of segments) {
|
|
if (segment) {
|
|
data = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)((0, util_1.unescapeJsonPointer)(segment))}`;
|
|
expr = (0, codegen_1._)`${expr} && ${data}`;
|
|
}
|
|
}
|
|
return expr;
|
|
function errorMsg(pointerType, up) {
|
|
return `Cannot access ${pointerType} ${up} levels up, current level is ${dataLevel}`;
|
|
}
|
|
}
|
|
exports.getData = getData;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/runtime/validation_error.js
|
|
var require_validation_error = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
|
class ValidationError extends Error {
|
|
constructor(errors3) {
|
|
super("validation failed");
|
|
this.errors = errors3;
|
|
this.ajv = this.validation = true;
|
|
}
|
|
}
|
|
exports.default = ValidationError;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/compile/ref_error.js
|
|
var require_ref_error = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var resolve_1 = require_resolve();
|
|
|
|
class MissingRefError extends Error {
|
|
constructor(resolver, baseId, ref, msg) {
|
|
super(msg || `can't resolve reference ${ref} from id ${baseId}`);
|
|
this.missingRef = (0, resolve_1.resolveUrl)(resolver, baseId, ref);
|
|
this.missingSchema = (0, resolve_1.normalizeId)((0, resolve_1.getFullPath)(resolver, this.missingRef));
|
|
}
|
|
}
|
|
exports.default = MissingRefError;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/compile/index.js
|
|
var require_compile = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.resolveSchema = exports.getCompilingSchema = exports.resolveRef = exports.compileSchema = exports.SchemaEnv = undefined;
|
|
var codegen_1 = require_codegen();
|
|
var validation_error_1 = require_validation_error();
|
|
var names_1 = require_names();
|
|
var resolve_1 = require_resolve();
|
|
var util_1 = require_util();
|
|
var validate_1 = require_validate();
|
|
|
|
class SchemaEnv {
|
|
constructor(env) {
|
|
var _a;
|
|
this.refs = {};
|
|
this.dynamicAnchors = {};
|
|
let schema;
|
|
if (typeof env.schema == "object")
|
|
schema = env.schema;
|
|
this.schema = env.schema;
|
|
this.schemaId = env.schemaId;
|
|
this.root = env.root || this;
|
|
this.baseId = (_a = env.baseId) !== null && _a !== undefined ? _a : (0, resolve_1.normalizeId)(schema === null || schema === undefined ? undefined : schema[env.schemaId || "$id"]);
|
|
this.schemaPath = env.schemaPath;
|
|
this.localRefs = env.localRefs;
|
|
this.meta = env.meta;
|
|
this.$async = schema === null || schema === undefined ? undefined : schema.$async;
|
|
this.refs = {};
|
|
}
|
|
}
|
|
exports.SchemaEnv = SchemaEnv;
|
|
function compileSchema(sch) {
|
|
const _sch = getCompilingSchema.call(this, sch);
|
|
if (_sch)
|
|
return _sch;
|
|
const rootId = (0, resolve_1.getFullPath)(this.opts.uriResolver, sch.root.baseId);
|
|
const { es5, lines } = this.opts.code;
|
|
const { ownProperties } = this.opts;
|
|
const gen = new codegen_1.CodeGen(this.scope, { es5, lines, ownProperties });
|
|
let _ValidationError;
|
|
if (sch.$async) {
|
|
_ValidationError = gen.scopeValue("Error", {
|
|
ref: validation_error_1.default,
|
|
code: (0, codegen_1._)`require("ajv/dist/runtime/validation_error").default`
|
|
});
|
|
}
|
|
const validateName = gen.scopeName("validate");
|
|
sch.validateName = validateName;
|
|
const schemaCxt = {
|
|
gen,
|
|
allErrors: this.opts.allErrors,
|
|
data: names_1.default.data,
|
|
parentData: names_1.default.parentData,
|
|
parentDataProperty: names_1.default.parentDataProperty,
|
|
dataNames: [names_1.default.data],
|
|
dataPathArr: [codegen_1.nil],
|
|
dataLevel: 0,
|
|
dataTypes: [],
|
|
definedProperties: new Set,
|
|
topSchemaRef: gen.scopeValue("schema", this.opts.code.source === true ? { ref: sch.schema, code: (0, codegen_1.stringify)(sch.schema) } : { ref: sch.schema }),
|
|
validateName,
|
|
ValidationError: _ValidationError,
|
|
schema: sch.schema,
|
|
schemaEnv: sch,
|
|
rootId,
|
|
baseId: sch.baseId || rootId,
|
|
schemaPath: codegen_1.nil,
|
|
errSchemaPath: sch.schemaPath || (this.opts.jtd ? "" : "#"),
|
|
errorPath: (0, codegen_1._)`""`,
|
|
opts: this.opts,
|
|
self: this
|
|
};
|
|
let sourceCode;
|
|
try {
|
|
this._compilations.add(sch);
|
|
(0, validate_1.validateFunctionCode)(schemaCxt);
|
|
gen.optimize(this.opts.code.optimize);
|
|
const validateCode = gen.toString();
|
|
sourceCode = `${gen.scopeRefs(names_1.default.scope)}return ${validateCode}`;
|
|
if (this.opts.code.process)
|
|
sourceCode = this.opts.code.process(sourceCode, sch);
|
|
const makeValidate = new Function(`${names_1.default.self}`, `${names_1.default.scope}`, sourceCode);
|
|
const validate = makeValidate(this, this.scope.get());
|
|
this.scope.value(validateName, { ref: validate });
|
|
validate.errors = null;
|
|
validate.schema = sch.schema;
|
|
validate.schemaEnv = sch;
|
|
if (sch.$async)
|
|
validate.$async = true;
|
|
if (this.opts.code.source === true) {
|
|
validate.source = { validateName, validateCode, scopeValues: gen._values };
|
|
}
|
|
if (this.opts.unevaluated) {
|
|
const { props, items } = schemaCxt;
|
|
validate.evaluated = {
|
|
props: props instanceof codegen_1.Name ? undefined : props,
|
|
items: items instanceof codegen_1.Name ? undefined : items,
|
|
dynamicProps: props instanceof codegen_1.Name,
|
|
dynamicItems: items instanceof codegen_1.Name
|
|
};
|
|
if (validate.source)
|
|
validate.source.evaluated = (0, codegen_1.stringify)(validate.evaluated);
|
|
}
|
|
sch.validate = validate;
|
|
return sch;
|
|
} catch (e) {
|
|
delete sch.validate;
|
|
delete sch.validateName;
|
|
if (sourceCode)
|
|
this.logger.error("Error compiling schema, function code:", sourceCode);
|
|
throw e;
|
|
} finally {
|
|
this._compilations.delete(sch);
|
|
}
|
|
}
|
|
exports.compileSchema = compileSchema;
|
|
function resolveRef(root2, baseId, ref) {
|
|
var _a;
|
|
ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
|
|
const schOrFunc = root2.refs[ref];
|
|
if (schOrFunc)
|
|
return schOrFunc;
|
|
let _sch = resolve.call(this, root2, ref);
|
|
if (_sch === undefined) {
|
|
const schema = (_a = root2.localRefs) === null || _a === undefined ? undefined : _a[ref];
|
|
const { schemaId } = this.opts;
|
|
if (schema)
|
|
_sch = new SchemaEnv({ schema, schemaId, root: root2, baseId });
|
|
}
|
|
if (_sch === undefined)
|
|
return;
|
|
return root2.refs[ref] = inlineOrCompile.call(this, _sch);
|
|
}
|
|
exports.resolveRef = resolveRef;
|
|
function inlineOrCompile(sch) {
|
|
if ((0, resolve_1.inlineRef)(sch.schema, this.opts.inlineRefs))
|
|
return sch.schema;
|
|
return sch.validate ? sch : compileSchema.call(this, sch);
|
|
}
|
|
function getCompilingSchema(schEnv) {
|
|
for (const sch of this._compilations) {
|
|
if (sameSchemaEnv(sch, schEnv))
|
|
return sch;
|
|
}
|
|
}
|
|
exports.getCompilingSchema = getCompilingSchema;
|
|
function sameSchemaEnv(s1, s2) {
|
|
return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
|
|
}
|
|
function resolve(root2, ref) {
|
|
let sch;
|
|
while (typeof (sch = this.refs[ref]) == "string")
|
|
ref = sch;
|
|
return sch || this.schemas[ref] || resolveSchema.call(this, root2, ref);
|
|
}
|
|
function resolveSchema(root2, ref) {
|
|
const p = this.opts.uriResolver.parse(ref);
|
|
const refPath = (0, resolve_1._getFullPath)(this.opts.uriResolver, p);
|
|
let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root2.baseId, undefined);
|
|
if (Object.keys(root2.schema).length > 0 && refPath === baseId) {
|
|
return getJsonPointer.call(this, p, root2);
|
|
}
|
|
const id = (0, resolve_1.normalizeId)(refPath);
|
|
const schOrRef = this.refs[id] || this.schemas[id];
|
|
if (typeof schOrRef == "string") {
|
|
const sch = resolveSchema.call(this, root2, schOrRef);
|
|
if (typeof (sch === null || sch === undefined ? undefined : sch.schema) !== "object")
|
|
return;
|
|
return getJsonPointer.call(this, p, sch);
|
|
}
|
|
if (typeof (schOrRef === null || schOrRef === undefined ? undefined : schOrRef.schema) !== "object")
|
|
return;
|
|
if (!schOrRef.validate)
|
|
compileSchema.call(this, schOrRef);
|
|
if (id === (0, resolve_1.normalizeId)(ref)) {
|
|
const { schema } = schOrRef;
|
|
const { schemaId } = this.opts;
|
|
const schId = schema[schemaId];
|
|
if (schId)
|
|
baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
|
|
return new SchemaEnv({ schema, schemaId, root: root2, baseId });
|
|
}
|
|
return getJsonPointer.call(this, p, schOrRef);
|
|
}
|
|
exports.resolveSchema = resolveSchema;
|
|
var PREVENT_SCOPE_CHANGE = new Set([
|
|
"properties",
|
|
"patternProperties",
|
|
"enum",
|
|
"dependencies",
|
|
"definitions"
|
|
]);
|
|
function getJsonPointer(parsedRef, { baseId, schema, root: root2 }) {
|
|
var _a;
|
|
if (((_a = parsedRef.fragment) === null || _a === undefined ? undefined : _a[0]) !== "/")
|
|
return;
|
|
for (const part of parsedRef.fragment.slice(1).split("/")) {
|
|
if (typeof schema === "boolean")
|
|
return;
|
|
const partSchema = schema[(0, util_1.unescapeFragment)(part)];
|
|
if (partSchema === undefined)
|
|
return;
|
|
schema = partSchema;
|
|
const schId = typeof schema === "object" && schema[this.opts.schemaId];
|
|
if (!PREVENT_SCOPE_CHANGE.has(part) && schId) {
|
|
baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
|
|
}
|
|
}
|
|
let env;
|
|
if (typeof schema != "boolean" && schema.$ref && !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)) {
|
|
const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref);
|
|
env = resolveSchema.call(this, root2, $ref);
|
|
}
|
|
const { schemaId } = this.opts;
|
|
env = env || new SchemaEnv({ schema, schemaId, root: root2, baseId });
|
|
if (env.schema !== env.root.schema)
|
|
return env;
|
|
return;
|
|
}
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/refs/data.json
|
|
var require_data = __commonJS((exports, module) => {
|
|
module.exports = {
|
|
$id: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#",
|
|
description: "Meta-schema for $data reference (JSON AnySchema extension proposal)",
|
|
type: "object",
|
|
required: ["$data"],
|
|
properties: {
|
|
$data: {
|
|
type: "string",
|
|
anyOf: [{ format: "relative-json-pointer" }, { format: "json-pointer" }]
|
|
}
|
|
},
|
|
additionalProperties: false
|
|
};
|
|
});
|
|
|
|
// ../node_modules/fast-uri/lib/scopedChars.js
|
|
var require_scopedChars = __commonJS((exports, module) => {
|
|
var HEX = {
|
|
0: 0,
|
|
1: 1,
|
|
2: 2,
|
|
3: 3,
|
|
4: 4,
|
|
5: 5,
|
|
6: 6,
|
|
7: 7,
|
|
8: 8,
|
|
9: 9,
|
|
a: 10,
|
|
A: 10,
|
|
b: 11,
|
|
B: 11,
|
|
c: 12,
|
|
C: 12,
|
|
d: 13,
|
|
D: 13,
|
|
e: 14,
|
|
E: 14,
|
|
f: 15,
|
|
F: 15
|
|
};
|
|
module.exports = {
|
|
HEX
|
|
};
|
|
});
|
|
|
|
// ../node_modules/fast-uri/lib/utils.js
|
|
var require_utils = __commonJS((exports, module) => {
|
|
var { HEX } = require_scopedChars();
|
|
var IPV4_REG = /^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u;
|
|
function normalizeIPv4(host) {
|
|
if (findToken(host, ".") < 3) {
|
|
return { host, isIPV4: false };
|
|
}
|
|
const matches = host.match(IPV4_REG) || [];
|
|
const [address] = matches;
|
|
if (address) {
|
|
return { host: stripLeadingZeros(address, "."), isIPV4: true };
|
|
} else {
|
|
return { host, isIPV4: false };
|
|
}
|
|
}
|
|
function stringArrayToHexStripped(input, keepZero = false) {
|
|
let acc = "";
|
|
let strip = true;
|
|
for (const c of input) {
|
|
if (HEX[c] === undefined)
|
|
return;
|
|
if (c !== "0" && strip === true)
|
|
strip = false;
|
|
if (!strip)
|
|
acc += c;
|
|
}
|
|
if (keepZero && acc.length === 0)
|
|
acc = "0";
|
|
return acc;
|
|
}
|
|
function getIPV6(input) {
|
|
let tokenCount = 0;
|
|
const output = { error: false, address: "", zone: "" };
|
|
const address = [];
|
|
const buffer = [];
|
|
let isZone = false;
|
|
let endipv6Encountered = false;
|
|
let endIpv6 = false;
|
|
function consume() {
|
|
if (buffer.length) {
|
|
if (isZone === false) {
|
|
const hex = stringArrayToHexStripped(buffer);
|
|
if (hex !== undefined) {
|
|
address.push(hex);
|
|
} else {
|
|
output.error = true;
|
|
return false;
|
|
}
|
|
}
|
|
buffer.length = 0;
|
|
}
|
|
return true;
|
|
}
|
|
for (let i = 0;i < input.length; i++) {
|
|
const cursor = input[i];
|
|
if (cursor === "[" || cursor === "]") {
|
|
continue;
|
|
}
|
|
if (cursor === ":") {
|
|
if (endipv6Encountered === true) {
|
|
endIpv6 = true;
|
|
}
|
|
if (!consume()) {
|
|
break;
|
|
}
|
|
tokenCount++;
|
|
address.push(":");
|
|
if (tokenCount > 7) {
|
|
output.error = true;
|
|
break;
|
|
}
|
|
if (i - 1 >= 0 && input[i - 1] === ":") {
|
|
endipv6Encountered = true;
|
|
}
|
|
continue;
|
|
} else if (cursor === "%") {
|
|
if (!consume()) {
|
|
break;
|
|
}
|
|
isZone = true;
|
|
} else {
|
|
buffer.push(cursor);
|
|
continue;
|
|
}
|
|
}
|
|
if (buffer.length) {
|
|
if (isZone) {
|
|
output.zone = buffer.join("");
|
|
} else if (endIpv6) {
|
|
address.push(buffer.join(""));
|
|
} else {
|
|
address.push(stringArrayToHexStripped(buffer));
|
|
}
|
|
}
|
|
output.address = address.join("");
|
|
return output;
|
|
}
|
|
function normalizeIPv6(host) {
|
|
if (findToken(host, ":") < 2) {
|
|
return { host, isIPV6: false };
|
|
}
|
|
const ipv62 = getIPV6(host);
|
|
if (!ipv62.error) {
|
|
let newHost = ipv62.address;
|
|
let escapedHost = ipv62.address;
|
|
if (ipv62.zone) {
|
|
newHost += "%" + ipv62.zone;
|
|
escapedHost += "%25" + ipv62.zone;
|
|
}
|
|
return { host: newHost, escapedHost, isIPV6: true };
|
|
} else {
|
|
return { host, isIPV6: false };
|
|
}
|
|
}
|
|
function stripLeadingZeros(str, token) {
|
|
let out = "";
|
|
let skip = true;
|
|
const l = str.length;
|
|
for (let i = 0;i < l; i++) {
|
|
const c = str[i];
|
|
if (c === "0" && skip) {
|
|
if (i + 1 <= l && str[i + 1] === token || i + 1 === l) {
|
|
out += c;
|
|
skip = false;
|
|
}
|
|
} else {
|
|
if (c === token) {
|
|
skip = true;
|
|
} else {
|
|
skip = false;
|
|
}
|
|
out += c;
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
function findToken(str, token) {
|
|
let ind = 0;
|
|
for (let i = 0;i < str.length; i++) {
|
|
if (str[i] === token)
|
|
ind++;
|
|
}
|
|
return ind;
|
|
}
|
|
var RDS1 = /^\.\.?\//u;
|
|
var RDS2 = /^\/\.(?:\/|$)/u;
|
|
var RDS3 = /^\/\.\.(?:\/|$)/u;
|
|
var RDS5 = /^\/?(?:.|\n)*?(?=\/|$)/u;
|
|
function removeDotSegments(input) {
|
|
const output = [];
|
|
while (input.length) {
|
|
if (input.match(RDS1)) {
|
|
input = input.replace(RDS1, "");
|
|
} else if (input.match(RDS2)) {
|
|
input = input.replace(RDS2, "/");
|
|
} else if (input.match(RDS3)) {
|
|
input = input.replace(RDS3, "/");
|
|
output.pop();
|
|
} else if (input === "." || input === "..") {
|
|
input = "";
|
|
} else {
|
|
const im = input.match(RDS5);
|
|
if (im) {
|
|
const s = im[0];
|
|
input = input.slice(s.length);
|
|
output.push(s);
|
|
} else {
|
|
throw new Error("Unexpected dot segment condition");
|
|
}
|
|
}
|
|
}
|
|
return output.join("");
|
|
}
|
|
function normalizeComponentEncoding(components, esc2) {
|
|
const func = esc2 !== true ? escape : unescape;
|
|
if (components.scheme !== undefined) {
|
|
components.scheme = func(components.scheme);
|
|
}
|
|
if (components.userinfo !== undefined) {
|
|
components.userinfo = func(components.userinfo);
|
|
}
|
|
if (components.host !== undefined) {
|
|
components.host = func(components.host);
|
|
}
|
|
if (components.path !== undefined) {
|
|
components.path = func(components.path);
|
|
}
|
|
if (components.query !== undefined) {
|
|
components.query = func(components.query);
|
|
}
|
|
if (components.fragment !== undefined) {
|
|
components.fragment = func(components.fragment);
|
|
}
|
|
return components;
|
|
}
|
|
function recomposeAuthority(components) {
|
|
const uriTokens = [];
|
|
if (components.userinfo !== undefined) {
|
|
uriTokens.push(components.userinfo);
|
|
uriTokens.push("@");
|
|
}
|
|
if (components.host !== undefined) {
|
|
let host = unescape(components.host);
|
|
const ipV4res = normalizeIPv4(host);
|
|
if (ipV4res.isIPV4) {
|
|
host = ipV4res.host;
|
|
} else {
|
|
const ipV6res = normalizeIPv6(ipV4res.host);
|
|
if (ipV6res.isIPV6 === true) {
|
|
host = `[${ipV6res.escapedHost}]`;
|
|
} else {
|
|
host = components.host;
|
|
}
|
|
}
|
|
uriTokens.push(host);
|
|
}
|
|
if (typeof components.port === "number" || typeof components.port === "string") {
|
|
uriTokens.push(":");
|
|
uriTokens.push(String(components.port));
|
|
}
|
|
return uriTokens.length ? uriTokens.join("") : undefined;
|
|
}
|
|
module.exports = {
|
|
recomposeAuthority,
|
|
normalizeComponentEncoding,
|
|
removeDotSegments,
|
|
normalizeIPv4,
|
|
normalizeIPv6,
|
|
stringArrayToHexStripped
|
|
};
|
|
});
|
|
|
|
// ../node_modules/fast-uri/lib/schemes.js
|
|
var require_schemes = __commonJS((exports, module) => {
|
|
var UUID_REG = /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu;
|
|
var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
|
|
function isSecure(wsComponents) {
|
|
return typeof wsComponents.secure === "boolean" ? wsComponents.secure : String(wsComponents.scheme).toLowerCase() === "wss";
|
|
}
|
|
function httpParse(components) {
|
|
if (!components.host) {
|
|
components.error = components.error || "HTTP URIs must have a host.";
|
|
}
|
|
return components;
|
|
}
|
|
function httpSerialize(components) {
|
|
const secure = String(components.scheme).toLowerCase() === "https";
|
|
if (components.port === (secure ? 443 : 80) || components.port === "") {
|
|
components.port = undefined;
|
|
}
|
|
if (!components.path) {
|
|
components.path = "/";
|
|
}
|
|
return components;
|
|
}
|
|
function wsParse(wsComponents) {
|
|
wsComponents.secure = isSecure(wsComponents);
|
|
wsComponents.resourceName = (wsComponents.path || "/") + (wsComponents.query ? "?" + wsComponents.query : "");
|
|
wsComponents.path = undefined;
|
|
wsComponents.query = undefined;
|
|
return wsComponents;
|
|
}
|
|
function wsSerialize(wsComponents) {
|
|
if (wsComponents.port === (isSecure(wsComponents) ? 443 : 80) || wsComponents.port === "") {
|
|
wsComponents.port = undefined;
|
|
}
|
|
if (typeof wsComponents.secure === "boolean") {
|
|
wsComponents.scheme = wsComponents.secure ? "wss" : "ws";
|
|
wsComponents.secure = undefined;
|
|
}
|
|
if (wsComponents.resourceName) {
|
|
const [path, query] = wsComponents.resourceName.split("?");
|
|
wsComponents.path = path && path !== "/" ? path : undefined;
|
|
wsComponents.query = query;
|
|
wsComponents.resourceName = undefined;
|
|
}
|
|
wsComponents.fragment = undefined;
|
|
return wsComponents;
|
|
}
|
|
function urnParse(urnComponents, options) {
|
|
if (!urnComponents.path) {
|
|
urnComponents.error = "URN can not be parsed";
|
|
return urnComponents;
|
|
}
|
|
const matches = urnComponents.path.match(URN_REG);
|
|
if (matches) {
|
|
const scheme = options.scheme || urnComponents.scheme || "urn";
|
|
urnComponents.nid = matches[1].toLowerCase();
|
|
urnComponents.nss = matches[2];
|
|
const urnScheme = `${scheme}:${options.nid || urnComponents.nid}`;
|
|
const schemeHandler = SCHEMES[urnScheme];
|
|
urnComponents.path = undefined;
|
|
if (schemeHandler) {
|
|
urnComponents = schemeHandler.parse(urnComponents, options);
|
|
}
|
|
} else {
|
|
urnComponents.error = urnComponents.error || "URN can not be parsed.";
|
|
}
|
|
return urnComponents;
|
|
}
|
|
function urnSerialize(urnComponents, options) {
|
|
const scheme = options.scheme || urnComponents.scheme || "urn";
|
|
const nid = urnComponents.nid.toLowerCase();
|
|
const urnScheme = `${scheme}:${options.nid || nid}`;
|
|
const schemeHandler = SCHEMES[urnScheme];
|
|
if (schemeHandler) {
|
|
urnComponents = schemeHandler.serialize(urnComponents, options);
|
|
}
|
|
const uriComponents = urnComponents;
|
|
const nss = urnComponents.nss;
|
|
uriComponents.path = `${nid || options.nid}:${nss}`;
|
|
options.skipEscape = true;
|
|
return uriComponents;
|
|
}
|
|
function urnuuidParse(urnComponents, options) {
|
|
const uuidComponents = urnComponents;
|
|
uuidComponents.uuid = uuidComponents.nss;
|
|
uuidComponents.nss = undefined;
|
|
if (!options.tolerant && (!uuidComponents.uuid || !UUID_REG.test(uuidComponents.uuid))) {
|
|
uuidComponents.error = uuidComponents.error || "UUID is not valid.";
|
|
}
|
|
return uuidComponents;
|
|
}
|
|
function urnuuidSerialize(uuidComponents) {
|
|
const urnComponents = uuidComponents;
|
|
urnComponents.nss = (uuidComponents.uuid || "").toLowerCase();
|
|
return urnComponents;
|
|
}
|
|
var http = {
|
|
scheme: "http",
|
|
domainHost: true,
|
|
parse: httpParse,
|
|
serialize: httpSerialize
|
|
};
|
|
var https = {
|
|
scheme: "https",
|
|
domainHost: http.domainHost,
|
|
parse: httpParse,
|
|
serialize: httpSerialize
|
|
};
|
|
var ws = {
|
|
scheme: "ws",
|
|
domainHost: true,
|
|
parse: wsParse,
|
|
serialize: wsSerialize
|
|
};
|
|
var wss = {
|
|
scheme: "wss",
|
|
domainHost: ws.domainHost,
|
|
parse: ws.parse,
|
|
serialize: ws.serialize
|
|
};
|
|
var urn = {
|
|
scheme: "urn",
|
|
parse: urnParse,
|
|
serialize: urnSerialize,
|
|
skipNormalize: true
|
|
};
|
|
var urnuuid = {
|
|
scheme: "urn:uuid",
|
|
parse: urnuuidParse,
|
|
serialize: urnuuidSerialize,
|
|
skipNormalize: true
|
|
};
|
|
var SCHEMES = {
|
|
http,
|
|
https,
|
|
ws,
|
|
wss,
|
|
urn,
|
|
"urn:uuid": urnuuid
|
|
};
|
|
module.exports = SCHEMES;
|
|
});
|
|
|
|
// ../node_modules/fast-uri/index.js
|
|
var require_fast_uri = __commonJS((exports, module) => {
|
|
var { normalizeIPv6, normalizeIPv4, removeDotSegments, recomposeAuthority, normalizeComponentEncoding } = require_utils();
|
|
var SCHEMES = require_schemes();
|
|
function normalize(uri, options) {
|
|
if (typeof uri === "string") {
|
|
uri = serialize(parse6(uri, options), options);
|
|
} else if (typeof uri === "object") {
|
|
uri = parse6(serialize(uri, options), options);
|
|
}
|
|
return uri;
|
|
}
|
|
function resolve(baseURI, relativeURI, options) {
|
|
const schemelessOptions = Object.assign({ scheme: "null" }, options);
|
|
const resolved = resolveComponents(parse6(baseURI, schemelessOptions), parse6(relativeURI, schemelessOptions), schemelessOptions, true);
|
|
return serialize(resolved, { ...schemelessOptions, skipEscape: true });
|
|
}
|
|
function resolveComponents(base, relative, options, skipNormalization) {
|
|
const target = {};
|
|
if (!skipNormalization) {
|
|
base = parse6(serialize(base, options), options);
|
|
relative = parse6(serialize(relative, options), options);
|
|
}
|
|
options = options || {};
|
|
if (!options.tolerant && relative.scheme) {
|
|
target.scheme = relative.scheme;
|
|
target.userinfo = relative.userinfo;
|
|
target.host = relative.host;
|
|
target.port = relative.port;
|
|
target.path = removeDotSegments(relative.path || "");
|
|
target.query = relative.query;
|
|
} else {
|
|
if (relative.userinfo !== undefined || relative.host !== undefined || relative.port !== undefined) {
|
|
target.userinfo = relative.userinfo;
|
|
target.host = relative.host;
|
|
target.port = relative.port;
|
|
target.path = removeDotSegments(relative.path || "");
|
|
target.query = relative.query;
|
|
} else {
|
|
if (!relative.path) {
|
|
target.path = base.path;
|
|
if (relative.query !== undefined) {
|
|
target.query = relative.query;
|
|
} else {
|
|
target.query = base.query;
|
|
}
|
|
} else {
|
|
if (relative.path.charAt(0) === "/") {
|
|
target.path = removeDotSegments(relative.path);
|
|
} else {
|
|
if ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {
|
|
target.path = "/" + relative.path;
|
|
} else if (!base.path) {
|
|
target.path = relative.path;
|
|
} else {
|
|
target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
|
|
}
|
|
target.path = removeDotSegments(target.path);
|
|
}
|
|
target.query = relative.query;
|
|
}
|
|
target.userinfo = base.userinfo;
|
|
target.host = base.host;
|
|
target.port = base.port;
|
|
}
|
|
target.scheme = base.scheme;
|
|
}
|
|
target.fragment = relative.fragment;
|
|
return target;
|
|
}
|
|
function equal(uriA, uriB, options) {
|
|
if (typeof uriA === "string") {
|
|
uriA = unescape(uriA);
|
|
uriA = serialize(normalizeComponentEncoding(parse6(uriA, options), true), { ...options, skipEscape: true });
|
|
} else if (typeof uriA === "object") {
|
|
uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
|
|
}
|
|
if (typeof uriB === "string") {
|
|
uriB = unescape(uriB);
|
|
uriB = serialize(normalizeComponentEncoding(parse6(uriB, options), true), { ...options, skipEscape: true });
|
|
} else if (typeof uriB === "object") {
|
|
uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
|
|
}
|
|
return uriA.toLowerCase() === uriB.toLowerCase();
|
|
}
|
|
function serialize(cmpts, opts) {
|
|
const components = {
|
|
host: cmpts.host,
|
|
scheme: cmpts.scheme,
|
|
userinfo: cmpts.userinfo,
|
|
port: cmpts.port,
|
|
path: cmpts.path,
|
|
query: cmpts.query,
|
|
nid: cmpts.nid,
|
|
nss: cmpts.nss,
|
|
uuid: cmpts.uuid,
|
|
fragment: cmpts.fragment,
|
|
reference: cmpts.reference,
|
|
resourceName: cmpts.resourceName,
|
|
secure: cmpts.secure,
|
|
error: ""
|
|
};
|
|
const options = Object.assign({}, opts);
|
|
const uriTokens = [];
|
|
const schemeHandler = SCHEMES[(options.scheme || components.scheme || "").toLowerCase()];
|
|
if (schemeHandler && schemeHandler.serialize)
|
|
schemeHandler.serialize(components, options);
|
|
if (components.path !== undefined) {
|
|
if (!options.skipEscape) {
|
|
components.path = escape(components.path);
|
|
if (components.scheme !== undefined) {
|
|
components.path = components.path.split("%3A").join(":");
|
|
}
|
|
} else {
|
|
components.path = unescape(components.path);
|
|
}
|
|
}
|
|
if (options.reference !== "suffix" && components.scheme) {
|
|
uriTokens.push(components.scheme, ":");
|
|
}
|
|
const authority = recomposeAuthority(components);
|
|
if (authority !== undefined) {
|
|
if (options.reference !== "suffix") {
|
|
uriTokens.push("//");
|
|
}
|
|
uriTokens.push(authority);
|
|
if (components.path && components.path.charAt(0) !== "/") {
|
|
uriTokens.push("/");
|
|
}
|
|
}
|
|
if (components.path !== undefined) {
|
|
let s = components.path;
|
|
if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
|
|
s = removeDotSegments(s);
|
|
}
|
|
if (authority === undefined) {
|
|
s = s.replace(/^\/\//u, "/%2F");
|
|
}
|
|
uriTokens.push(s);
|
|
}
|
|
if (components.query !== undefined) {
|
|
uriTokens.push("?", components.query);
|
|
}
|
|
if (components.fragment !== undefined) {
|
|
uriTokens.push("#", components.fragment);
|
|
}
|
|
return uriTokens.join("");
|
|
}
|
|
var hexLookUp = Array.from({ length: 127 }, (_v, k) => /[^!"$&'()*+,\-.;=_`a-z{}~]/u.test(String.fromCharCode(k)));
|
|
function nonSimpleDomain(value) {
|
|
let code = 0;
|
|
for (let i = 0, len = value.length;i < len; ++i) {
|
|
code = value.charCodeAt(i);
|
|
if (code > 126 || hexLookUp[code]) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
|
|
function parse6(uri, opts) {
|
|
const options = Object.assign({}, opts);
|
|
const parsed = {
|
|
scheme: undefined,
|
|
userinfo: undefined,
|
|
host: "",
|
|
port: undefined,
|
|
path: "",
|
|
query: undefined,
|
|
fragment: undefined
|
|
};
|
|
const gotEncoding = uri.indexOf("%") !== -1;
|
|
let isIP = false;
|
|
if (options.reference === "suffix")
|
|
uri = (options.scheme ? options.scheme + ":" : "") + "//" + uri;
|
|
const matches = uri.match(URI_PARSE);
|
|
if (matches) {
|
|
parsed.scheme = matches[1];
|
|
parsed.userinfo = matches[3];
|
|
parsed.host = matches[4];
|
|
parsed.port = parseInt(matches[5], 10);
|
|
parsed.path = matches[6] || "";
|
|
parsed.query = matches[7];
|
|
parsed.fragment = matches[8];
|
|
if (isNaN(parsed.port)) {
|
|
parsed.port = matches[5];
|
|
}
|
|
if (parsed.host) {
|
|
const ipv4result = normalizeIPv4(parsed.host);
|
|
if (ipv4result.isIPV4 === false) {
|
|
const ipv6result = normalizeIPv6(ipv4result.host);
|
|
parsed.host = ipv6result.host.toLowerCase();
|
|
isIP = ipv6result.isIPV6;
|
|
} else {
|
|
parsed.host = ipv4result.host;
|
|
isIP = true;
|
|
}
|
|
}
|
|
if (parsed.scheme === undefined && parsed.userinfo === undefined && parsed.host === undefined && parsed.port === undefined && parsed.query === undefined && !parsed.path) {
|
|
parsed.reference = "same-document";
|
|
} else if (parsed.scheme === undefined) {
|
|
parsed.reference = "relative";
|
|
} else if (parsed.fragment === undefined) {
|
|
parsed.reference = "absolute";
|
|
} else {
|
|
parsed.reference = "uri";
|
|
}
|
|
if (options.reference && options.reference !== "suffix" && options.reference !== parsed.reference) {
|
|
parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
|
|
}
|
|
const schemeHandler = SCHEMES[(options.scheme || parsed.scheme || "").toLowerCase()];
|
|
if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
|
|
if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
|
|
try {
|
|
parsed.host = URL.domainToASCII(parsed.host.toLowerCase());
|
|
} catch (e) {
|
|
parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
|
|
}
|
|
}
|
|
}
|
|
if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
|
|
if (gotEncoding && parsed.scheme !== undefined) {
|
|
parsed.scheme = unescape(parsed.scheme);
|
|
}
|
|
if (gotEncoding && parsed.host !== undefined) {
|
|
parsed.host = unescape(parsed.host);
|
|
}
|
|
if (parsed.path) {
|
|
parsed.path = escape(unescape(parsed.path));
|
|
}
|
|
if (parsed.fragment) {
|
|
parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
|
|
}
|
|
}
|
|
if (schemeHandler && schemeHandler.parse) {
|
|
schemeHandler.parse(parsed, options);
|
|
}
|
|
} else {
|
|
parsed.error = parsed.error || "URI can not be parsed.";
|
|
}
|
|
return parsed;
|
|
}
|
|
var fastUri = {
|
|
SCHEMES,
|
|
normalize,
|
|
resolve,
|
|
resolveComponents,
|
|
equal,
|
|
serialize,
|
|
parse: parse6
|
|
};
|
|
module.exports = fastUri;
|
|
module.exports.default = fastUri;
|
|
module.exports.fastUri = fastUri;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/runtime/uri.js
|
|
var require_uri = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var uri = require_fast_uri();
|
|
uri.code = 'require("ajv/dist/runtime/uri").default';
|
|
exports.default = uri;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/core.js
|
|
var require_core = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = undefined;
|
|
var validate_1 = require_validate();
|
|
Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
|
|
return validate_1.KeywordCxt;
|
|
} });
|
|
var codegen_1 = require_codegen();
|
|
Object.defineProperty(exports, "_", { enumerable: true, get: function() {
|
|
return codegen_1._;
|
|
} });
|
|
Object.defineProperty(exports, "str", { enumerable: true, get: function() {
|
|
return codegen_1.str;
|
|
} });
|
|
Object.defineProperty(exports, "stringify", { enumerable: true, get: function() {
|
|
return codegen_1.stringify;
|
|
} });
|
|
Object.defineProperty(exports, "nil", { enumerable: true, get: function() {
|
|
return codegen_1.nil;
|
|
} });
|
|
Object.defineProperty(exports, "Name", { enumerable: true, get: function() {
|
|
return codegen_1.Name;
|
|
} });
|
|
Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function() {
|
|
return codegen_1.CodeGen;
|
|
} });
|
|
var validation_error_1 = require_validation_error();
|
|
var ref_error_1 = require_ref_error();
|
|
var rules_1 = require_rules();
|
|
var compile_1 = require_compile();
|
|
var codegen_2 = require_codegen();
|
|
var resolve_1 = require_resolve();
|
|
var dataType_1 = require_dataType();
|
|
var util_1 = require_util();
|
|
var $dataRefSchema = require_data();
|
|
var uri_1 = require_uri();
|
|
var defaultRegExp = (str, flags) => new RegExp(str, flags);
|
|
defaultRegExp.code = "new RegExp";
|
|
var META_IGNORE_OPTIONS = ["removeAdditional", "useDefaults", "coerceTypes"];
|
|
var EXT_SCOPE_NAMES = new Set([
|
|
"validate",
|
|
"serialize",
|
|
"parse",
|
|
"wrapper",
|
|
"root",
|
|
"schema",
|
|
"keyword",
|
|
"pattern",
|
|
"formats",
|
|
"validate$data",
|
|
"func",
|
|
"obj",
|
|
"Error"
|
|
]);
|
|
var removedOptions = {
|
|
errorDataPath: "",
|
|
format: "`validateFormats: false` can be used instead.",
|
|
nullable: '"nullable" keyword is supported by default.',
|
|
jsonPointers: "Deprecated jsPropertySyntax can be used instead.",
|
|
extendRefs: "Deprecated ignoreKeywordsWithRef can be used instead.",
|
|
missingRefs: "Pass empty schema with $id that should be ignored to ajv.addSchema.",
|
|
processCode: "Use option `code: {process: (code, schemaEnv: object) => string}`",
|
|
sourceCode: "Use option `code: {source: true}`",
|
|
strictDefaults: "It is default now, see option `strict`.",
|
|
strictKeywords: "It is default now, see option `strict`.",
|
|
uniqueItems: '"uniqueItems" keyword is always validated.',
|
|
unknownFormats: "Disable strict mode or pass `true` to `ajv.addFormat` (or `formats` option).",
|
|
cache: "Map is used as cache, schema object as key.",
|
|
serialize: "Map is used as cache, schema object as key.",
|
|
ajvErrors: "It is default now."
|
|
};
|
|
var deprecatedOptions = {
|
|
ignoreKeywordsWithRef: "",
|
|
jsPropertySyntax: "",
|
|
unicode: '"minLength"/"maxLength" account for unicode characters by default.'
|
|
};
|
|
var MAX_EXPRESSION = 200;
|
|
function requiredOptions(o) {
|
|
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
|
|
const s = o.strict;
|
|
const _optz = (_a = o.code) === null || _a === undefined ? undefined : _a.optimize;
|
|
const optimize = _optz === true || _optz === undefined ? 1 : _optz || 0;
|
|
const regExp = (_c = (_b = o.code) === null || _b === undefined ? undefined : _b.regExp) !== null && _c !== undefined ? _c : defaultRegExp;
|
|
const uriResolver = (_d = o.uriResolver) !== null && _d !== undefined ? _d : uri_1.default;
|
|
return {
|
|
strictSchema: (_f = (_e = o.strictSchema) !== null && _e !== undefined ? _e : s) !== null && _f !== undefined ? _f : true,
|
|
strictNumbers: (_h = (_g = o.strictNumbers) !== null && _g !== undefined ? _g : s) !== null && _h !== undefined ? _h : true,
|
|
strictTypes: (_k = (_j = o.strictTypes) !== null && _j !== undefined ? _j : s) !== null && _k !== undefined ? _k : "log",
|
|
strictTuples: (_m = (_l = o.strictTuples) !== null && _l !== undefined ? _l : s) !== null && _m !== undefined ? _m : "log",
|
|
strictRequired: (_p = (_o = o.strictRequired) !== null && _o !== undefined ? _o : s) !== null && _p !== undefined ? _p : false,
|
|
code: o.code ? { ...o.code, optimize, regExp } : { optimize, regExp },
|
|
loopRequired: (_q = o.loopRequired) !== null && _q !== undefined ? _q : MAX_EXPRESSION,
|
|
loopEnum: (_r = o.loopEnum) !== null && _r !== undefined ? _r : MAX_EXPRESSION,
|
|
meta: (_s = o.meta) !== null && _s !== undefined ? _s : true,
|
|
messages: (_t = o.messages) !== null && _t !== undefined ? _t : true,
|
|
inlineRefs: (_u = o.inlineRefs) !== null && _u !== undefined ? _u : true,
|
|
schemaId: (_v = o.schemaId) !== null && _v !== undefined ? _v : "$id",
|
|
addUsedSchema: (_w = o.addUsedSchema) !== null && _w !== undefined ? _w : true,
|
|
validateSchema: (_x = o.validateSchema) !== null && _x !== undefined ? _x : true,
|
|
validateFormats: (_y = o.validateFormats) !== null && _y !== undefined ? _y : true,
|
|
unicodeRegExp: (_z = o.unicodeRegExp) !== null && _z !== undefined ? _z : true,
|
|
int32range: (_0 = o.int32range) !== null && _0 !== undefined ? _0 : true,
|
|
uriResolver
|
|
};
|
|
}
|
|
|
|
class Ajv {
|
|
constructor(opts = {}) {
|
|
this.schemas = {};
|
|
this.refs = {};
|
|
this.formats = {};
|
|
this._compilations = new Set;
|
|
this._loading = {};
|
|
this._cache = new Map;
|
|
opts = this.opts = { ...opts, ...requiredOptions(opts) };
|
|
const { es5, lines } = this.opts.code;
|
|
this.scope = new codegen_2.ValueScope({ scope: {}, prefixes: EXT_SCOPE_NAMES, es5, lines });
|
|
this.logger = getLogger(opts.logger);
|
|
const formatOpt = opts.validateFormats;
|
|
opts.validateFormats = false;
|
|
this.RULES = (0, rules_1.getRules)();
|
|
checkOptions.call(this, removedOptions, opts, "NOT SUPPORTED");
|
|
checkOptions.call(this, deprecatedOptions, opts, "DEPRECATED", "warn");
|
|
this._metaOpts = getMetaSchemaOptions.call(this);
|
|
if (opts.formats)
|
|
addInitialFormats.call(this);
|
|
this._addVocabularies();
|
|
this._addDefaultMetaSchema();
|
|
if (opts.keywords)
|
|
addInitialKeywords.call(this, opts.keywords);
|
|
if (typeof opts.meta == "object")
|
|
this.addMetaSchema(opts.meta);
|
|
addInitialSchemas.call(this);
|
|
opts.validateFormats = formatOpt;
|
|
}
|
|
_addVocabularies() {
|
|
this.addKeyword("$async");
|
|
}
|
|
_addDefaultMetaSchema() {
|
|
const { $data, meta, schemaId } = this.opts;
|
|
let _dataRefSchema = $dataRefSchema;
|
|
if (schemaId === "id") {
|
|
_dataRefSchema = { ...$dataRefSchema };
|
|
_dataRefSchema.id = _dataRefSchema.$id;
|
|
delete _dataRefSchema.$id;
|
|
}
|
|
if (meta && $data)
|
|
this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false);
|
|
}
|
|
defaultMeta() {
|
|
const { meta, schemaId } = this.opts;
|
|
return this.opts.defaultMeta = typeof meta == "object" ? meta[schemaId] || meta : undefined;
|
|
}
|
|
validate(schemaKeyRef, data) {
|
|
let v;
|
|
if (typeof schemaKeyRef == "string") {
|
|
v = this.getSchema(schemaKeyRef);
|
|
if (!v)
|
|
throw new Error(`no schema with key or ref "${schemaKeyRef}"`);
|
|
} else {
|
|
v = this.compile(schemaKeyRef);
|
|
}
|
|
const valid = v(data);
|
|
if (!("$async" in v))
|
|
this.errors = v.errors;
|
|
return valid;
|
|
}
|
|
compile(schema, _meta) {
|
|
const sch = this._addSchema(schema, _meta);
|
|
return sch.validate || this._compileSchemaEnv(sch);
|
|
}
|
|
compileAsync(schema, meta) {
|
|
if (typeof this.opts.loadSchema != "function") {
|
|
throw new Error("options.loadSchema should be a function");
|
|
}
|
|
const { loadSchema } = this.opts;
|
|
return runCompileAsync.call(this, schema, meta);
|
|
async function runCompileAsync(_schema, _meta) {
|
|
await loadMetaSchema.call(this, _schema.$schema);
|
|
const sch = this._addSchema(_schema, _meta);
|
|
return sch.validate || _compileAsync.call(this, sch);
|
|
}
|
|
async function loadMetaSchema($ref) {
|
|
if ($ref && !this.getSchema($ref)) {
|
|
await runCompileAsync.call(this, { $ref }, true);
|
|
}
|
|
}
|
|
async function _compileAsync(sch) {
|
|
try {
|
|
return this._compileSchemaEnv(sch);
|
|
} catch (e) {
|
|
if (!(e instanceof ref_error_1.default))
|
|
throw e;
|
|
checkLoaded.call(this, e);
|
|
await loadMissingSchema.call(this, e.missingSchema);
|
|
return _compileAsync.call(this, sch);
|
|
}
|
|
}
|
|
function checkLoaded({ missingSchema: ref, missingRef }) {
|
|
if (this.refs[ref]) {
|
|
throw new Error(`AnySchema ${ref} is loaded but ${missingRef} cannot be resolved`);
|
|
}
|
|
}
|
|
async function loadMissingSchema(ref) {
|
|
const _schema = await _loadSchema.call(this, ref);
|
|
if (!this.refs[ref])
|
|
await loadMetaSchema.call(this, _schema.$schema);
|
|
if (!this.refs[ref])
|
|
this.addSchema(_schema, ref, meta);
|
|
}
|
|
async function _loadSchema(ref) {
|
|
const p = this._loading[ref];
|
|
if (p)
|
|
return p;
|
|
try {
|
|
return await (this._loading[ref] = loadSchema(ref));
|
|
} finally {
|
|
delete this._loading[ref];
|
|
}
|
|
}
|
|
}
|
|
addSchema(schema, key, _meta, _validateSchema = this.opts.validateSchema) {
|
|
if (Array.isArray(schema)) {
|
|
for (const sch of schema)
|
|
this.addSchema(sch, undefined, _meta, _validateSchema);
|
|
return this;
|
|
}
|
|
let id;
|
|
if (typeof schema === "object") {
|
|
const { schemaId } = this.opts;
|
|
id = schema[schemaId];
|
|
if (id !== undefined && typeof id != "string") {
|
|
throw new Error(`schema ${schemaId} must be string`);
|
|
}
|
|
}
|
|
key = (0, resolve_1.normalizeId)(key || id);
|
|
this._checkUnique(key);
|
|
this.schemas[key] = this._addSchema(schema, _meta, key, _validateSchema, true);
|
|
return this;
|
|
}
|
|
addMetaSchema(schema, key, _validateSchema = this.opts.validateSchema) {
|
|
this.addSchema(schema, key, true, _validateSchema);
|
|
return this;
|
|
}
|
|
validateSchema(schema, throwOrLogError) {
|
|
if (typeof schema == "boolean")
|
|
return true;
|
|
let $schema;
|
|
$schema = schema.$schema;
|
|
if ($schema !== undefined && typeof $schema != "string") {
|
|
throw new Error("$schema must be a string");
|
|
}
|
|
$schema = $schema || this.opts.defaultMeta || this.defaultMeta();
|
|
if (!$schema) {
|
|
this.logger.warn("meta-schema not available");
|
|
this.errors = null;
|
|
return true;
|
|
}
|
|
const valid = this.validate($schema, schema);
|
|
if (!valid && throwOrLogError) {
|
|
const message = "schema is invalid: " + this.errorsText();
|
|
if (this.opts.validateSchema === "log")
|
|
this.logger.error(message);
|
|
else
|
|
throw new Error(message);
|
|
}
|
|
return valid;
|
|
}
|
|
getSchema(keyRef) {
|
|
let sch;
|
|
while (typeof (sch = getSchEnv.call(this, keyRef)) == "string")
|
|
keyRef = sch;
|
|
if (sch === undefined) {
|
|
const { schemaId } = this.opts;
|
|
const root2 = new compile_1.SchemaEnv({ schema: {}, schemaId });
|
|
sch = compile_1.resolveSchema.call(this, root2, keyRef);
|
|
if (!sch)
|
|
return;
|
|
this.refs[keyRef] = sch;
|
|
}
|
|
return sch.validate || this._compileSchemaEnv(sch);
|
|
}
|
|
removeSchema(schemaKeyRef) {
|
|
if (schemaKeyRef instanceof RegExp) {
|
|
this._removeAllSchemas(this.schemas, schemaKeyRef);
|
|
this._removeAllSchemas(this.refs, schemaKeyRef);
|
|
return this;
|
|
}
|
|
switch (typeof schemaKeyRef) {
|
|
case "undefined":
|
|
this._removeAllSchemas(this.schemas);
|
|
this._removeAllSchemas(this.refs);
|
|
this._cache.clear();
|
|
return this;
|
|
case "string": {
|
|
const sch = getSchEnv.call(this, schemaKeyRef);
|
|
if (typeof sch == "object")
|
|
this._cache.delete(sch.schema);
|
|
delete this.schemas[schemaKeyRef];
|
|
delete this.refs[schemaKeyRef];
|
|
return this;
|
|
}
|
|
case "object": {
|
|
const cacheKey = schemaKeyRef;
|
|
this._cache.delete(cacheKey);
|
|
let id = schemaKeyRef[this.opts.schemaId];
|
|
if (id) {
|
|
id = (0, resolve_1.normalizeId)(id);
|
|
delete this.schemas[id];
|
|
delete this.refs[id];
|
|
}
|
|
return this;
|
|
}
|
|
default:
|
|
throw new Error("ajv.removeSchema: invalid parameter");
|
|
}
|
|
}
|
|
addVocabulary(definitions) {
|
|
for (const def of definitions)
|
|
this.addKeyword(def);
|
|
return this;
|
|
}
|
|
addKeyword(kwdOrDef, def) {
|
|
let keyword;
|
|
if (typeof kwdOrDef == "string") {
|
|
keyword = kwdOrDef;
|
|
if (typeof def == "object") {
|
|
this.logger.warn("these parameters are deprecated, see docs for addKeyword");
|
|
def.keyword = keyword;
|
|
}
|
|
} else if (typeof kwdOrDef == "object" && def === undefined) {
|
|
def = kwdOrDef;
|
|
keyword = def.keyword;
|
|
if (Array.isArray(keyword) && !keyword.length) {
|
|
throw new Error("addKeywords: keyword must be string or non-empty array");
|
|
}
|
|
} else {
|
|
throw new Error("invalid addKeywords parameters");
|
|
}
|
|
checkKeyword.call(this, keyword, def);
|
|
if (!def) {
|
|
(0, util_1.eachItem)(keyword, (kwd) => addRule.call(this, kwd));
|
|
return this;
|
|
}
|
|
keywordMetaschema.call(this, def);
|
|
const definition = {
|
|
...def,
|
|
type: (0, dataType_1.getJSONTypes)(def.type),
|
|
schemaType: (0, dataType_1.getJSONTypes)(def.schemaType)
|
|
};
|
|
(0, util_1.eachItem)(keyword, definition.type.length === 0 ? (k) => addRule.call(this, k, definition) : (k) => definition.type.forEach((t) => addRule.call(this, k, definition, t)));
|
|
return this;
|
|
}
|
|
getKeyword(keyword) {
|
|
const rule = this.RULES.all[keyword];
|
|
return typeof rule == "object" ? rule.definition : !!rule;
|
|
}
|
|
removeKeyword(keyword) {
|
|
const { RULES } = this;
|
|
delete RULES.keywords[keyword];
|
|
delete RULES.all[keyword];
|
|
for (const group of RULES.rules) {
|
|
const i = group.rules.findIndex((rule) => rule.keyword === keyword);
|
|
if (i >= 0)
|
|
group.rules.splice(i, 1);
|
|
}
|
|
return this;
|
|
}
|
|
addFormat(name, format) {
|
|
if (typeof format == "string")
|
|
format = new RegExp(format);
|
|
this.formats[name] = format;
|
|
return this;
|
|
}
|
|
errorsText(errors3 = this.errors, { separator = ", ", dataVar = "data" } = {}) {
|
|
if (!errors3 || errors3.length === 0)
|
|
return "No errors";
|
|
return errors3.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text, msg) => text + separator + msg);
|
|
}
|
|
$dataMetaSchema(metaSchema, keywordsJsonPointers) {
|
|
const rules = this.RULES.all;
|
|
metaSchema = JSON.parse(JSON.stringify(metaSchema));
|
|
for (const jsonPointer of keywordsJsonPointers) {
|
|
const segments = jsonPointer.split("/").slice(1);
|
|
let keywords = metaSchema;
|
|
for (const seg of segments)
|
|
keywords = keywords[seg];
|
|
for (const key in rules) {
|
|
const rule = rules[key];
|
|
if (typeof rule != "object")
|
|
continue;
|
|
const { $data } = rule.definition;
|
|
const schema = keywords[key];
|
|
if ($data && schema)
|
|
keywords[key] = schemaOrData(schema);
|
|
}
|
|
}
|
|
return metaSchema;
|
|
}
|
|
_removeAllSchemas(schemas4, regex) {
|
|
for (const keyRef in schemas4) {
|
|
const sch = schemas4[keyRef];
|
|
if (!regex || regex.test(keyRef)) {
|
|
if (typeof sch == "string") {
|
|
delete schemas4[keyRef];
|
|
} else if (sch && !sch.meta) {
|
|
this._cache.delete(sch.schema);
|
|
delete schemas4[keyRef];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_addSchema(schema, meta, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
|
|
let id;
|
|
const { schemaId } = this.opts;
|
|
if (typeof schema == "object") {
|
|
id = schema[schemaId];
|
|
} else {
|
|
if (this.opts.jtd)
|
|
throw new Error("schema must be object");
|
|
else if (typeof schema != "boolean")
|
|
throw new Error("schema must be object or boolean");
|
|
}
|
|
let sch = this._cache.get(schema);
|
|
if (sch !== undefined)
|
|
return sch;
|
|
baseId = (0, resolve_1.normalizeId)(id || baseId);
|
|
const localRefs = resolve_1.getSchemaRefs.call(this, schema, baseId);
|
|
sch = new compile_1.SchemaEnv({ schema, schemaId, meta, baseId, localRefs });
|
|
this._cache.set(sch.schema, sch);
|
|
if (addSchema && !baseId.startsWith("#")) {
|
|
if (baseId)
|
|
this._checkUnique(baseId);
|
|
this.refs[baseId] = sch;
|
|
}
|
|
if (validateSchema)
|
|
this.validateSchema(schema, true);
|
|
return sch;
|
|
}
|
|
_checkUnique(id) {
|
|
if (this.schemas[id] || this.refs[id]) {
|
|
throw new Error(`schema with key or id "${id}" already exists`);
|
|
}
|
|
}
|
|
_compileSchemaEnv(sch) {
|
|
if (sch.meta)
|
|
this._compileMetaSchema(sch);
|
|
else
|
|
compile_1.compileSchema.call(this, sch);
|
|
if (!sch.validate)
|
|
throw new Error("ajv implementation error");
|
|
return sch.validate;
|
|
}
|
|
_compileMetaSchema(sch) {
|
|
const currentOpts = this.opts;
|
|
this.opts = this._metaOpts;
|
|
try {
|
|
compile_1.compileSchema.call(this, sch);
|
|
} finally {
|
|
this.opts = currentOpts;
|
|
}
|
|
}
|
|
}
|
|
Ajv.ValidationError = validation_error_1.default;
|
|
Ajv.MissingRefError = ref_error_1.default;
|
|
exports.default = Ajv;
|
|
function checkOptions(checkOpts, options, msg, log = "error") {
|
|
for (const key in checkOpts) {
|
|
const opt = key;
|
|
if (opt in options)
|
|
this.logger[log](`${msg}: option ${key}. ${checkOpts[opt]}`);
|
|
}
|
|
}
|
|
function getSchEnv(keyRef) {
|
|
keyRef = (0, resolve_1.normalizeId)(keyRef);
|
|
return this.schemas[keyRef] || this.refs[keyRef];
|
|
}
|
|
function addInitialSchemas() {
|
|
const optsSchemas = this.opts.schemas;
|
|
if (!optsSchemas)
|
|
return;
|
|
if (Array.isArray(optsSchemas))
|
|
this.addSchema(optsSchemas);
|
|
else
|
|
for (const key in optsSchemas)
|
|
this.addSchema(optsSchemas[key], key);
|
|
}
|
|
function addInitialFormats() {
|
|
for (const name in this.opts.formats) {
|
|
const format = this.opts.formats[name];
|
|
if (format)
|
|
this.addFormat(name, format);
|
|
}
|
|
}
|
|
function addInitialKeywords(defs) {
|
|
if (Array.isArray(defs)) {
|
|
this.addVocabulary(defs);
|
|
return;
|
|
}
|
|
this.logger.warn("keywords option as map is deprecated, pass array");
|
|
for (const keyword in defs) {
|
|
const def = defs[keyword];
|
|
if (!def.keyword)
|
|
def.keyword = keyword;
|
|
this.addKeyword(def);
|
|
}
|
|
}
|
|
function getMetaSchemaOptions() {
|
|
const metaOpts = { ...this.opts };
|
|
for (const opt of META_IGNORE_OPTIONS)
|
|
delete metaOpts[opt];
|
|
return metaOpts;
|
|
}
|
|
var noLogs = { log() {}, warn() {}, error() {} };
|
|
function getLogger(logger) {
|
|
if (logger === false)
|
|
return noLogs;
|
|
if (logger === undefined)
|
|
return console;
|
|
if (logger.log && logger.warn && logger.error)
|
|
return logger;
|
|
throw new Error("logger must implement log, warn and error methods");
|
|
}
|
|
var KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
|
|
function checkKeyword(keyword, def) {
|
|
const { RULES } = this;
|
|
(0, util_1.eachItem)(keyword, (kwd) => {
|
|
if (RULES.keywords[kwd])
|
|
throw new Error(`Keyword ${kwd} is already defined`);
|
|
if (!KEYWORD_NAME.test(kwd))
|
|
throw new Error(`Keyword ${kwd} has invalid name`);
|
|
});
|
|
if (!def)
|
|
return;
|
|
if (def.$data && !(("code" in def) || ("validate" in def))) {
|
|
throw new Error('$data keyword must have "code" or "validate" function');
|
|
}
|
|
}
|
|
function addRule(keyword, definition, dataType) {
|
|
var _a;
|
|
const post = definition === null || definition === undefined ? undefined : definition.post;
|
|
if (dataType && post)
|
|
throw new Error('keyword with "post" flag cannot have "type"');
|
|
const { RULES } = this;
|
|
let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t }) => t === dataType);
|
|
if (!ruleGroup) {
|
|
ruleGroup = { type: dataType, rules: [] };
|
|
RULES.rules.push(ruleGroup);
|
|
}
|
|
RULES.keywords[keyword] = true;
|
|
if (!definition)
|
|
return;
|
|
const rule = {
|
|
keyword,
|
|
definition: {
|
|
...definition,
|
|
type: (0, dataType_1.getJSONTypes)(definition.type),
|
|
schemaType: (0, dataType_1.getJSONTypes)(definition.schemaType)
|
|
}
|
|
};
|
|
if (definition.before)
|
|
addBeforeRule.call(this, ruleGroup, rule, definition.before);
|
|
else
|
|
ruleGroup.rules.push(rule);
|
|
RULES.all[keyword] = rule;
|
|
(_a = definition.implements) === null || _a === undefined || _a.forEach((kwd) => this.addKeyword(kwd));
|
|
}
|
|
function addBeforeRule(ruleGroup, rule, before) {
|
|
const i = ruleGroup.rules.findIndex((_rule) => _rule.keyword === before);
|
|
if (i >= 0) {
|
|
ruleGroup.rules.splice(i, 0, rule);
|
|
} else {
|
|
ruleGroup.rules.push(rule);
|
|
this.logger.warn(`rule ${before} is not defined`);
|
|
}
|
|
}
|
|
function keywordMetaschema(def) {
|
|
let { metaSchema } = def;
|
|
if (metaSchema === undefined)
|
|
return;
|
|
if (def.$data && this.opts.$data)
|
|
metaSchema = schemaOrData(metaSchema);
|
|
def.validateSchema = this.compile(metaSchema, true);
|
|
}
|
|
var $dataRef = {
|
|
$ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#"
|
|
};
|
|
function schemaOrData(schema) {
|
|
return { anyOf: [schema, $dataRef] };
|
|
}
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/core/id.js
|
|
var require_id = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var def = {
|
|
keyword: "id",
|
|
code() {
|
|
throw new Error('NOT SUPPORTED: keyword "id", use "$id" for schema ID');
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/core/ref.js
|
|
var require_ref = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.callRef = exports.getValidate = undefined;
|
|
var ref_error_1 = require_ref_error();
|
|
var code_1 = require_code2();
|
|
var codegen_1 = require_codegen();
|
|
var names_1 = require_names();
|
|
var compile_1 = require_compile();
|
|
var util_1 = require_util();
|
|
var def = {
|
|
keyword: "$ref",
|
|
schemaType: "string",
|
|
code(cxt) {
|
|
const { gen, schema: $ref, it } = cxt;
|
|
const { baseId, schemaEnv: env, validateName, opts, self: self2 } = it;
|
|
const { root: root2 } = env;
|
|
if (($ref === "#" || $ref === "#/") && baseId === root2.baseId)
|
|
return callRootRef();
|
|
const schOrEnv = compile_1.resolveRef.call(self2, root2, baseId, $ref);
|
|
if (schOrEnv === undefined)
|
|
throw new ref_error_1.default(it.opts.uriResolver, baseId, $ref);
|
|
if (schOrEnv instanceof compile_1.SchemaEnv)
|
|
return callValidate(schOrEnv);
|
|
return inlineRefSchema(schOrEnv);
|
|
function callRootRef() {
|
|
if (env === root2)
|
|
return callRef(cxt, validateName, env, env.$async);
|
|
const rootName = gen.scopeValue("root", { ref: root2 });
|
|
return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root2, root2.$async);
|
|
}
|
|
function callValidate(sch) {
|
|
const v = getValidate(cxt, sch);
|
|
callRef(cxt, v, sch, sch.$async);
|
|
}
|
|
function inlineRefSchema(sch) {
|
|
const schName = gen.scopeValue("schema", opts.code.source === true ? { ref: sch, code: (0, codegen_1.stringify)(sch) } : { ref: sch });
|
|
const valid = gen.name("valid");
|
|
const schCxt = cxt.subschema({
|
|
schema: sch,
|
|
dataTypes: [],
|
|
schemaPath: codegen_1.nil,
|
|
topSchemaRef: schName,
|
|
errSchemaPath: $ref
|
|
}, valid);
|
|
cxt.mergeEvaluated(schCxt);
|
|
cxt.ok(valid);
|
|
}
|
|
}
|
|
};
|
|
function getValidate(cxt, sch) {
|
|
const { gen } = cxt;
|
|
return sch.validate ? gen.scopeValue("validate", { ref: sch.validate }) : (0, codegen_1._)`${gen.scopeValue("wrapper", { ref: sch })}.validate`;
|
|
}
|
|
exports.getValidate = getValidate;
|
|
function callRef(cxt, v, sch, $async) {
|
|
const { gen, it } = cxt;
|
|
const { allErrors, schemaEnv: env, opts } = it;
|
|
const passCxt = opts.passContext ? names_1.default.this : codegen_1.nil;
|
|
if ($async)
|
|
callAsyncRef();
|
|
else
|
|
callSyncRef();
|
|
function callAsyncRef() {
|
|
if (!env.$async)
|
|
throw new Error("async schema referenced by sync schema");
|
|
const valid = gen.let("valid");
|
|
gen.try(() => {
|
|
gen.code((0, codegen_1._)`await ${(0, code_1.callValidateCode)(cxt, v, passCxt)}`);
|
|
addEvaluatedFrom(v);
|
|
if (!allErrors)
|
|
gen.assign(valid, true);
|
|
}, (e) => {
|
|
gen.if((0, codegen_1._)`!(${e} instanceof ${it.ValidationError})`, () => gen.throw(e));
|
|
addErrorsFrom(e);
|
|
if (!allErrors)
|
|
gen.assign(valid, false);
|
|
});
|
|
cxt.ok(valid);
|
|
}
|
|
function callSyncRef() {
|
|
cxt.result((0, code_1.callValidateCode)(cxt, v, passCxt), () => addEvaluatedFrom(v), () => addErrorsFrom(v));
|
|
}
|
|
function addErrorsFrom(source) {
|
|
const errs = (0, codegen_1._)`${source}.errors`;
|
|
gen.assign(names_1.default.vErrors, (0, codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`);
|
|
gen.assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`);
|
|
}
|
|
function addEvaluatedFrom(source) {
|
|
var _a;
|
|
if (!it.opts.unevaluated)
|
|
return;
|
|
const schEvaluated = (_a = sch === null || sch === undefined ? undefined : sch.validate) === null || _a === undefined ? undefined : _a.evaluated;
|
|
if (it.props !== true) {
|
|
if (schEvaluated && !schEvaluated.dynamicProps) {
|
|
if (schEvaluated.props !== undefined) {
|
|
it.props = util_1.mergeEvaluated.props(gen, schEvaluated.props, it.props);
|
|
}
|
|
} else {
|
|
const props = gen.var("props", (0, codegen_1._)`${source}.evaluated.props`);
|
|
it.props = util_1.mergeEvaluated.props(gen, props, it.props, codegen_1.Name);
|
|
}
|
|
}
|
|
if (it.items !== true) {
|
|
if (schEvaluated && !schEvaluated.dynamicItems) {
|
|
if (schEvaluated.items !== undefined) {
|
|
it.items = util_1.mergeEvaluated.items(gen, schEvaluated.items, it.items);
|
|
}
|
|
} else {
|
|
const items = gen.var("items", (0, codegen_1._)`${source}.evaluated.items`);
|
|
it.items = util_1.mergeEvaluated.items(gen, items, it.items, codegen_1.Name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
exports.callRef = callRef;
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/core/index.js
|
|
var require_core2 = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var id_1 = require_id();
|
|
var ref_1 = require_ref();
|
|
var core2 = [
|
|
"$schema",
|
|
"$id",
|
|
"$defs",
|
|
"$vocabulary",
|
|
{ keyword: "$comment" },
|
|
"definitions",
|
|
id_1.default,
|
|
ref_1.default
|
|
];
|
|
exports.default = core2;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/validation/limitNumber.js
|
|
var require_limitNumber = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var codegen_1 = require_codegen();
|
|
var ops = codegen_1.operators;
|
|
var KWDs = {
|
|
maximum: { okStr: "<=", ok: ops.LTE, fail: ops.GT },
|
|
minimum: { okStr: ">=", ok: ops.GTE, fail: ops.LT },
|
|
exclusiveMaximum: { okStr: "<", ok: ops.LT, fail: ops.GTE },
|
|
exclusiveMinimum: { okStr: ">", ok: ops.GT, fail: ops.LTE }
|
|
};
|
|
var error2 = {
|
|
message: ({ keyword, schemaCode }) => (0, codegen_1.str)`must be ${KWDs[keyword].okStr} ${schemaCode}`,
|
|
params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`
|
|
};
|
|
var def = {
|
|
keyword: Object.keys(KWDs),
|
|
type: "number",
|
|
schemaType: "number",
|
|
$data: true,
|
|
error: error2,
|
|
code(cxt) {
|
|
const { keyword, data, schemaCode } = cxt;
|
|
cxt.fail$data((0, codegen_1._)`${data} ${KWDs[keyword].fail} ${schemaCode} || isNaN(${data})`);
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/validation/multipleOf.js
|
|
var require_multipleOf = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var codegen_1 = require_codegen();
|
|
var error2 = {
|
|
message: ({ schemaCode }) => (0, codegen_1.str)`must be multiple of ${schemaCode}`,
|
|
params: ({ schemaCode }) => (0, codegen_1._)`{multipleOf: ${schemaCode}}`
|
|
};
|
|
var def = {
|
|
keyword: "multipleOf",
|
|
type: "number",
|
|
schemaType: "number",
|
|
$data: true,
|
|
error: error2,
|
|
code(cxt) {
|
|
const { gen, data, schemaCode, it } = cxt;
|
|
const prec = it.opts.multipleOfPrecision;
|
|
const res = gen.let("res");
|
|
const invalid = prec ? (0, codegen_1._)`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}` : (0, codegen_1._)`${res} !== parseInt(${res})`;
|
|
cxt.fail$data((0, codegen_1._)`(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid}))`);
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/runtime/ucs2length.js
|
|
var require_ucs2length = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
function ucs2length(str) {
|
|
const len = str.length;
|
|
let length = 0;
|
|
let pos = 0;
|
|
let value;
|
|
while (pos < len) {
|
|
length++;
|
|
value = str.charCodeAt(pos++);
|
|
if (value >= 55296 && value <= 56319 && pos < len) {
|
|
value = str.charCodeAt(pos);
|
|
if ((value & 64512) === 56320)
|
|
pos++;
|
|
}
|
|
}
|
|
return length;
|
|
}
|
|
exports.default = ucs2length;
|
|
ucs2length.code = 'require("ajv/dist/runtime/ucs2length").default';
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/validation/limitLength.js
|
|
var require_limitLength = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var codegen_1 = require_codegen();
|
|
var util_1 = require_util();
|
|
var ucs2length_1 = require_ucs2length();
|
|
var error2 = {
|
|
message({ keyword, schemaCode }) {
|
|
const comp = keyword === "maxLength" ? "more" : "fewer";
|
|
return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} characters`;
|
|
},
|
|
params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
|
|
};
|
|
var def = {
|
|
keyword: ["maxLength", "minLength"],
|
|
type: "string",
|
|
schemaType: "number",
|
|
$data: true,
|
|
error: error2,
|
|
code(cxt) {
|
|
const { keyword, data, schemaCode, it } = cxt;
|
|
const op = keyword === "maxLength" ? codegen_1.operators.GT : codegen_1.operators.LT;
|
|
const len = it.opts.unicode === false ? (0, codegen_1._)`${data}.length` : (0, codegen_1._)`${(0, util_1.useFunc)(cxt.gen, ucs2length_1.default)}(${data})`;
|
|
cxt.fail$data((0, codegen_1._)`${len} ${op} ${schemaCode}`);
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/validation/pattern.js
|
|
var require_pattern = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var code_1 = require_code2();
|
|
var codegen_1 = require_codegen();
|
|
var error2 = {
|
|
message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`,
|
|
params: ({ schemaCode }) => (0, codegen_1._)`{pattern: ${schemaCode}}`
|
|
};
|
|
var def = {
|
|
keyword: "pattern",
|
|
type: "string",
|
|
schemaType: "string",
|
|
$data: true,
|
|
error: error2,
|
|
code(cxt) {
|
|
const { data, $data, schema, schemaCode, it } = cxt;
|
|
const u = it.opts.unicodeRegExp ? "u" : "";
|
|
const regExp = $data ? (0, codegen_1._)`(new RegExp(${schemaCode}, ${u}))` : (0, code_1.usePattern)(cxt, schema);
|
|
cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/validation/limitProperties.js
|
|
var require_limitProperties = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var codegen_1 = require_codegen();
|
|
var error2 = {
|
|
message({ keyword, schemaCode }) {
|
|
const comp = keyword === "maxProperties" ? "more" : "fewer";
|
|
return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} properties`;
|
|
},
|
|
params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
|
|
};
|
|
var def = {
|
|
keyword: ["maxProperties", "minProperties"],
|
|
type: "object",
|
|
schemaType: "number",
|
|
$data: true,
|
|
error: error2,
|
|
code(cxt) {
|
|
const { keyword, data, schemaCode } = cxt;
|
|
const op = keyword === "maxProperties" ? codegen_1.operators.GT : codegen_1.operators.LT;
|
|
cxt.fail$data((0, codegen_1._)`Object.keys(${data}).length ${op} ${schemaCode}`);
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/validation/required.js
|
|
var require_required = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var code_1 = require_code2();
|
|
var codegen_1 = require_codegen();
|
|
var util_1 = require_util();
|
|
var error2 = {
|
|
message: ({ params: { missingProperty } }) => (0, codegen_1.str)`must have required property '${missingProperty}'`,
|
|
params: ({ params: { missingProperty } }) => (0, codegen_1._)`{missingProperty: ${missingProperty}}`
|
|
};
|
|
var def = {
|
|
keyword: "required",
|
|
type: "object",
|
|
schemaType: "array",
|
|
$data: true,
|
|
error: error2,
|
|
code(cxt) {
|
|
const { gen, schema, schemaCode, data, $data, it } = cxt;
|
|
const { opts } = it;
|
|
if (!$data && schema.length === 0)
|
|
return;
|
|
const useLoop = schema.length >= opts.loopRequired;
|
|
if (it.allErrors)
|
|
allErrorsMode();
|
|
else
|
|
exitOnErrorMode();
|
|
if (opts.strictRequired) {
|
|
const props = cxt.parentSchema.properties;
|
|
const { definedProperties } = cxt.it;
|
|
for (const requiredKey of schema) {
|
|
if ((props === null || props === undefined ? undefined : props[requiredKey]) === undefined && !definedProperties.has(requiredKey)) {
|
|
const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
|
|
const msg = `required property "${requiredKey}" is not defined at "${schemaPath}" (strictRequired)`;
|
|
(0, util_1.checkStrictMode)(it, msg, it.opts.strictRequired);
|
|
}
|
|
}
|
|
}
|
|
function allErrorsMode() {
|
|
if (useLoop || $data) {
|
|
cxt.block$data(codegen_1.nil, loopAllRequired);
|
|
} else {
|
|
for (const prop of schema) {
|
|
(0, code_1.checkReportMissingProp)(cxt, prop);
|
|
}
|
|
}
|
|
}
|
|
function exitOnErrorMode() {
|
|
const missing = gen.let("missing");
|
|
if (useLoop || $data) {
|
|
const valid = gen.let("valid", true);
|
|
cxt.block$data(valid, () => loopUntilMissing(missing, valid));
|
|
cxt.ok(valid);
|
|
} else {
|
|
gen.if((0, code_1.checkMissingProp)(cxt, schema, missing));
|
|
(0, code_1.reportMissingProp)(cxt, missing);
|
|
gen.else();
|
|
}
|
|
}
|
|
function loopAllRequired() {
|
|
gen.forOf("prop", schemaCode, (prop) => {
|
|
cxt.setParams({ missingProperty: prop });
|
|
gen.if((0, code_1.noPropertyInData)(gen, data, prop, opts.ownProperties), () => cxt.error());
|
|
});
|
|
}
|
|
function loopUntilMissing(missing, valid) {
|
|
cxt.setParams({ missingProperty: missing });
|
|
gen.forOf(missing, schemaCode, () => {
|
|
gen.assign(valid, (0, code_1.propertyInData)(gen, data, missing, opts.ownProperties));
|
|
gen.if((0, codegen_1.not)(valid), () => {
|
|
cxt.error();
|
|
gen.break();
|
|
});
|
|
}, codegen_1.nil);
|
|
}
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/validation/limitItems.js
|
|
var require_limitItems = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var codegen_1 = require_codegen();
|
|
var error2 = {
|
|
message({ keyword, schemaCode }) {
|
|
const comp = keyword === "maxItems" ? "more" : "fewer";
|
|
return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} items`;
|
|
},
|
|
params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
|
|
};
|
|
var def = {
|
|
keyword: ["maxItems", "minItems"],
|
|
type: "array",
|
|
schemaType: "number",
|
|
$data: true,
|
|
error: error2,
|
|
code(cxt) {
|
|
const { keyword, data, schemaCode } = cxt;
|
|
const op = keyword === "maxItems" ? codegen_1.operators.GT : codegen_1.operators.LT;
|
|
cxt.fail$data((0, codegen_1._)`${data}.length ${op} ${schemaCode}`);
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/runtime/equal.js
|
|
var require_equal = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var equal = require_fast_deep_equal();
|
|
equal.code = 'require("ajv/dist/runtime/equal").default';
|
|
exports.default = equal;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/validation/uniqueItems.js
|
|
var require_uniqueItems = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var dataType_1 = require_dataType();
|
|
var codegen_1 = require_codegen();
|
|
var util_1 = require_util();
|
|
var equal_1 = require_equal();
|
|
var error2 = {
|
|
message: ({ params: { i, j } }) => (0, codegen_1.str)`must NOT have duplicate items (items ## ${j} and ${i} are identical)`,
|
|
params: ({ params: { i, j } }) => (0, codegen_1._)`{i: ${i}, j: ${j}}`
|
|
};
|
|
var def = {
|
|
keyword: "uniqueItems",
|
|
type: "array",
|
|
schemaType: "boolean",
|
|
$data: true,
|
|
error: error2,
|
|
code(cxt) {
|
|
const { gen, data, $data, schema, parentSchema, schemaCode, it } = cxt;
|
|
if (!$data && !schema)
|
|
return;
|
|
const valid = gen.let("valid");
|
|
const itemTypes = parentSchema.items ? (0, dataType_1.getSchemaTypes)(parentSchema.items) : [];
|
|
cxt.block$data(valid, validateUniqueItems, (0, codegen_1._)`${schemaCode} === false`);
|
|
cxt.ok(valid);
|
|
function validateUniqueItems() {
|
|
const i = gen.let("i", (0, codegen_1._)`${data}.length`);
|
|
const j = gen.let("j");
|
|
cxt.setParams({ i, j });
|
|
gen.assign(valid, true);
|
|
gen.if((0, codegen_1._)`${i} > 1`, () => (canOptimize() ? loopN : loopN2)(i, j));
|
|
}
|
|
function canOptimize() {
|
|
return itemTypes.length > 0 && !itemTypes.some((t) => t === "object" || t === "array");
|
|
}
|
|
function loopN(i, j) {
|
|
const item = gen.name("item");
|
|
const wrongType = (0, dataType_1.checkDataTypes)(itemTypes, item, it.opts.strictNumbers, dataType_1.DataType.Wrong);
|
|
const indices = gen.const("indices", (0, codegen_1._)`{}`);
|
|
gen.for((0, codegen_1._)`;${i}--;`, () => {
|
|
gen.let(item, (0, codegen_1._)`${data}[${i}]`);
|
|
gen.if(wrongType, (0, codegen_1._)`continue`);
|
|
if (itemTypes.length > 1)
|
|
gen.if((0, codegen_1._)`typeof ${item} == "string"`, (0, codegen_1._)`${item} += "_"`);
|
|
gen.if((0, codegen_1._)`typeof ${indices}[${item}] == "number"`, () => {
|
|
gen.assign(j, (0, codegen_1._)`${indices}[${item}]`);
|
|
cxt.error();
|
|
gen.assign(valid, false).break();
|
|
}).code((0, codegen_1._)`${indices}[${item}] = ${i}`);
|
|
});
|
|
}
|
|
function loopN2(i, j) {
|
|
const eql = (0, util_1.useFunc)(gen, equal_1.default);
|
|
const outer = gen.name("outer");
|
|
gen.label(outer).for((0, codegen_1._)`;${i}--;`, () => gen.for((0, codegen_1._)`${j} = ${i}; ${j}--;`, () => gen.if((0, codegen_1._)`${eql}(${data}[${i}], ${data}[${j}])`, () => {
|
|
cxt.error();
|
|
gen.assign(valid, false).break(outer);
|
|
})));
|
|
}
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/validation/const.js
|
|
var require_const = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var codegen_1 = require_codegen();
|
|
var util_1 = require_util();
|
|
var equal_1 = require_equal();
|
|
var error2 = {
|
|
message: "must be equal to constant",
|
|
params: ({ schemaCode }) => (0, codegen_1._)`{allowedValue: ${schemaCode}}`
|
|
};
|
|
var def = {
|
|
keyword: "const",
|
|
$data: true,
|
|
error: error2,
|
|
code(cxt) {
|
|
const { gen, data, $data, schemaCode, schema } = cxt;
|
|
if ($data || schema && typeof schema == "object") {
|
|
cxt.fail$data((0, codegen_1._)`!${(0, util_1.useFunc)(gen, equal_1.default)}(${data}, ${schemaCode})`);
|
|
} else {
|
|
cxt.fail((0, codegen_1._)`${schema} !== ${data}`);
|
|
}
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/validation/enum.js
|
|
var require_enum = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var codegen_1 = require_codegen();
|
|
var util_1 = require_util();
|
|
var equal_1 = require_equal();
|
|
var error2 = {
|
|
message: "must be equal to one of the allowed values",
|
|
params: ({ schemaCode }) => (0, codegen_1._)`{allowedValues: ${schemaCode}}`
|
|
};
|
|
var def = {
|
|
keyword: "enum",
|
|
schemaType: "array",
|
|
$data: true,
|
|
error: error2,
|
|
code(cxt) {
|
|
const { gen, data, $data, schema, schemaCode, it } = cxt;
|
|
if (!$data && schema.length === 0)
|
|
throw new Error("enum must have non-empty array");
|
|
const useLoop = schema.length >= it.opts.loopEnum;
|
|
let eql;
|
|
const getEql = () => eql !== null && eql !== undefined ? eql : eql = (0, util_1.useFunc)(gen, equal_1.default);
|
|
let valid;
|
|
if (useLoop || $data) {
|
|
valid = gen.let("valid");
|
|
cxt.block$data(valid, loopEnum);
|
|
} else {
|
|
if (!Array.isArray(schema))
|
|
throw new Error("ajv implementation error");
|
|
const vSchema = gen.const("vSchema", schemaCode);
|
|
valid = (0, codegen_1.or)(...schema.map((_x, i) => equalCode(vSchema, i)));
|
|
}
|
|
cxt.pass(valid);
|
|
function loopEnum() {
|
|
gen.assign(valid, false);
|
|
gen.forOf("v", schemaCode, (v) => gen.if((0, codegen_1._)`${getEql()}(${data}, ${v})`, () => gen.assign(valid, true).break()));
|
|
}
|
|
function equalCode(vSchema, i) {
|
|
const sch = schema[i];
|
|
return typeof sch === "object" && sch !== null ? (0, codegen_1._)`${getEql()}(${data}, ${vSchema}[${i}])` : (0, codegen_1._)`${data} === ${sch}`;
|
|
}
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/validation/index.js
|
|
var require_validation = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var limitNumber_1 = require_limitNumber();
|
|
var multipleOf_1 = require_multipleOf();
|
|
var limitLength_1 = require_limitLength();
|
|
var pattern_1 = require_pattern();
|
|
var limitProperties_1 = require_limitProperties();
|
|
var required_1 = require_required();
|
|
var limitItems_1 = require_limitItems();
|
|
var uniqueItems_1 = require_uniqueItems();
|
|
var const_1 = require_const();
|
|
var enum_1 = require_enum();
|
|
var validation = [
|
|
limitNumber_1.default,
|
|
multipleOf_1.default,
|
|
limitLength_1.default,
|
|
pattern_1.default,
|
|
limitProperties_1.default,
|
|
required_1.default,
|
|
limitItems_1.default,
|
|
uniqueItems_1.default,
|
|
{ keyword: "type", schemaType: ["string", "array"] },
|
|
{ keyword: "nullable", schemaType: "boolean" },
|
|
const_1.default,
|
|
enum_1.default
|
|
];
|
|
exports.default = validation;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/applicator/additionalItems.js
|
|
var require_additionalItems = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.validateAdditionalItems = undefined;
|
|
var codegen_1 = require_codegen();
|
|
var util_1 = require_util();
|
|
var error2 = {
|
|
message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
|
|
params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
|
|
};
|
|
var def = {
|
|
keyword: "additionalItems",
|
|
type: "array",
|
|
schemaType: ["boolean", "object"],
|
|
before: "uniqueItems",
|
|
error: error2,
|
|
code(cxt) {
|
|
const { parentSchema, it } = cxt;
|
|
const { items } = parentSchema;
|
|
if (!Array.isArray(items)) {
|
|
(0, util_1.checkStrictMode)(it, '"additionalItems" is ignored when "items" is not an array of schemas');
|
|
return;
|
|
}
|
|
validateAdditionalItems(cxt, items);
|
|
}
|
|
};
|
|
function validateAdditionalItems(cxt, items) {
|
|
const { gen, schema, data, keyword, it } = cxt;
|
|
it.items = true;
|
|
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
|
|
if (schema === false) {
|
|
cxt.setParams({ len: items.length });
|
|
cxt.pass((0, codegen_1._)`${len} <= ${items.length}`);
|
|
} else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
|
|
const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items.length}`);
|
|
gen.if((0, codegen_1.not)(valid), () => validateItems(valid));
|
|
cxt.ok(valid);
|
|
}
|
|
function validateItems(valid) {
|
|
gen.forRange("i", items.length, len, (i) => {
|
|
cxt.subschema({ keyword, dataProp: i, dataPropType: util_1.Type.Num }, valid);
|
|
if (!it.allErrors)
|
|
gen.if((0, codegen_1.not)(valid), () => gen.break());
|
|
});
|
|
}
|
|
}
|
|
exports.validateAdditionalItems = validateAdditionalItems;
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/applicator/items.js
|
|
var require_items = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.validateTuple = undefined;
|
|
var codegen_1 = require_codegen();
|
|
var util_1 = require_util();
|
|
var code_1 = require_code2();
|
|
var def = {
|
|
keyword: "items",
|
|
type: "array",
|
|
schemaType: ["object", "array", "boolean"],
|
|
before: "uniqueItems",
|
|
code(cxt) {
|
|
const { schema, it } = cxt;
|
|
if (Array.isArray(schema))
|
|
return validateTuple(cxt, "additionalItems", schema);
|
|
it.items = true;
|
|
if ((0, util_1.alwaysValidSchema)(it, schema))
|
|
return;
|
|
cxt.ok((0, code_1.validateArray)(cxt));
|
|
}
|
|
};
|
|
function validateTuple(cxt, extraItems, schArr = cxt.schema) {
|
|
const { gen, parentSchema, data, keyword, it } = cxt;
|
|
checkStrictTuple(parentSchema);
|
|
if (it.opts.unevaluated && schArr.length && it.items !== true) {
|
|
it.items = util_1.mergeEvaluated.items(gen, schArr.length, it.items);
|
|
}
|
|
const valid = gen.name("valid");
|
|
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
|
|
schArr.forEach((sch, i) => {
|
|
if ((0, util_1.alwaysValidSchema)(it, sch))
|
|
return;
|
|
gen.if((0, codegen_1._)`${len} > ${i}`, () => cxt.subschema({
|
|
keyword,
|
|
schemaProp: i,
|
|
dataProp: i
|
|
}, valid));
|
|
cxt.ok(valid);
|
|
});
|
|
function checkStrictTuple(sch) {
|
|
const { opts, errSchemaPath } = it;
|
|
const l = schArr.length;
|
|
const fullTuple = l === sch.minItems && (l === sch.maxItems || sch[extraItems] === false);
|
|
if (opts.strictTuples && !fullTuple) {
|
|
const msg = `"${keyword}" is ${l}-tuple, but minItems or maxItems/${extraItems} are not specified or different at path "${errSchemaPath}"`;
|
|
(0, util_1.checkStrictMode)(it, msg, opts.strictTuples);
|
|
}
|
|
}
|
|
}
|
|
exports.validateTuple = validateTuple;
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/applicator/prefixItems.js
|
|
var require_prefixItems = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var items_1 = require_items();
|
|
var def = {
|
|
keyword: "prefixItems",
|
|
type: "array",
|
|
schemaType: ["array"],
|
|
before: "uniqueItems",
|
|
code: (cxt) => (0, items_1.validateTuple)(cxt, "items")
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/applicator/items2020.js
|
|
var require_items2020 = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var codegen_1 = require_codegen();
|
|
var util_1 = require_util();
|
|
var code_1 = require_code2();
|
|
var additionalItems_1 = require_additionalItems();
|
|
var error2 = {
|
|
message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
|
|
params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
|
|
};
|
|
var def = {
|
|
keyword: "items",
|
|
type: "array",
|
|
schemaType: ["object", "boolean"],
|
|
before: "uniqueItems",
|
|
error: error2,
|
|
code(cxt) {
|
|
const { schema, parentSchema, it } = cxt;
|
|
const { prefixItems } = parentSchema;
|
|
it.items = true;
|
|
if ((0, util_1.alwaysValidSchema)(it, schema))
|
|
return;
|
|
if (prefixItems)
|
|
(0, additionalItems_1.validateAdditionalItems)(cxt, prefixItems);
|
|
else
|
|
cxt.ok((0, code_1.validateArray)(cxt));
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/applicator/contains.js
|
|
var require_contains = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var codegen_1 = require_codegen();
|
|
var util_1 = require_util();
|
|
var error2 = {
|
|
message: ({ params: { min, max } }) => max === undefined ? (0, codegen_1.str)`must contain at least ${min} valid item(s)` : (0, codegen_1.str)`must contain at least ${min} and no more than ${max} valid item(s)`,
|
|
params: ({ params: { min, max } }) => max === undefined ? (0, codegen_1._)`{minContains: ${min}}` : (0, codegen_1._)`{minContains: ${min}, maxContains: ${max}}`
|
|
};
|
|
var def = {
|
|
keyword: "contains",
|
|
type: "array",
|
|
schemaType: ["object", "boolean"],
|
|
before: "uniqueItems",
|
|
trackErrors: true,
|
|
error: error2,
|
|
code(cxt) {
|
|
const { gen, schema, parentSchema, data, it } = cxt;
|
|
let min;
|
|
let max;
|
|
const { minContains, maxContains } = parentSchema;
|
|
if (it.opts.next) {
|
|
min = minContains === undefined ? 1 : minContains;
|
|
max = maxContains;
|
|
} else {
|
|
min = 1;
|
|
}
|
|
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
|
|
cxt.setParams({ min, max });
|
|
if (max === undefined && min === 0) {
|
|
(0, util_1.checkStrictMode)(it, `"minContains" == 0 without "maxContains": "contains" keyword ignored`);
|
|
return;
|
|
}
|
|
if (max !== undefined && min > max) {
|
|
(0, util_1.checkStrictMode)(it, `"minContains" > "maxContains" is always invalid`);
|
|
cxt.fail();
|
|
return;
|
|
}
|
|
if ((0, util_1.alwaysValidSchema)(it, schema)) {
|
|
let cond = (0, codegen_1._)`${len} >= ${min}`;
|
|
if (max !== undefined)
|
|
cond = (0, codegen_1._)`${cond} && ${len} <= ${max}`;
|
|
cxt.pass(cond);
|
|
return;
|
|
}
|
|
it.items = true;
|
|
const valid = gen.name("valid");
|
|
if (max === undefined && min === 1) {
|
|
validateItems(valid, () => gen.if(valid, () => gen.break()));
|
|
} else if (min === 0) {
|
|
gen.let(valid, true);
|
|
if (max !== undefined)
|
|
gen.if((0, codegen_1._)`${data}.length > 0`, validateItemsWithCount);
|
|
} else {
|
|
gen.let(valid, false);
|
|
validateItemsWithCount();
|
|
}
|
|
cxt.result(valid, () => cxt.reset());
|
|
function validateItemsWithCount() {
|
|
const schValid = gen.name("_valid");
|
|
const count = gen.let("count", 0);
|
|
validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)));
|
|
}
|
|
function validateItems(_valid, block) {
|
|
gen.forRange("i", 0, len, (i) => {
|
|
cxt.subschema({
|
|
keyword: "contains",
|
|
dataProp: i,
|
|
dataPropType: util_1.Type.Num,
|
|
compositeRule: true
|
|
}, _valid);
|
|
block();
|
|
});
|
|
}
|
|
function checkLimits(count) {
|
|
gen.code((0, codegen_1._)`${count}++`);
|
|
if (max === undefined) {
|
|
gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true).break());
|
|
} else {
|
|
gen.if((0, codegen_1._)`${count} > ${max}`, () => gen.assign(valid, false).break());
|
|
if (min === 1)
|
|
gen.assign(valid, true);
|
|
else
|
|
gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true));
|
|
}
|
|
}
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/applicator/dependencies.js
|
|
var require_dependencies = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = undefined;
|
|
var codegen_1 = require_codegen();
|
|
var util_1 = require_util();
|
|
var code_1 = require_code2();
|
|
exports.error = {
|
|
message: ({ params: { property, depsCount, deps } }) => {
|
|
const property_ies = depsCount === 1 ? "property" : "properties";
|
|
return (0, codegen_1.str)`must have ${property_ies} ${deps} when property ${property} is present`;
|
|
},
|
|
params: ({ params: { property, depsCount, deps, missingProperty } }) => (0, codegen_1._)`{property: ${property},
|
|
missingProperty: ${missingProperty},
|
|
depsCount: ${depsCount},
|
|
deps: ${deps}}`
|
|
};
|
|
var def = {
|
|
keyword: "dependencies",
|
|
type: "object",
|
|
schemaType: "object",
|
|
error: exports.error,
|
|
code(cxt) {
|
|
const [propDeps, schDeps] = splitDependencies(cxt);
|
|
validatePropertyDeps(cxt, propDeps);
|
|
validateSchemaDeps(cxt, schDeps);
|
|
}
|
|
};
|
|
function splitDependencies({ schema }) {
|
|
const propertyDeps = {};
|
|
const schemaDeps = {};
|
|
for (const key in schema) {
|
|
if (key === "__proto__")
|
|
continue;
|
|
const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps;
|
|
deps[key] = schema[key];
|
|
}
|
|
return [propertyDeps, schemaDeps];
|
|
}
|
|
function validatePropertyDeps(cxt, propertyDeps = cxt.schema) {
|
|
const { gen, data, it } = cxt;
|
|
if (Object.keys(propertyDeps).length === 0)
|
|
return;
|
|
const missing = gen.let("missing");
|
|
for (const prop in propertyDeps) {
|
|
const deps = propertyDeps[prop];
|
|
if (deps.length === 0)
|
|
continue;
|
|
const hasProperty = (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties);
|
|
cxt.setParams({
|
|
property: prop,
|
|
depsCount: deps.length,
|
|
deps: deps.join(", ")
|
|
});
|
|
if (it.allErrors) {
|
|
gen.if(hasProperty, () => {
|
|
for (const depProp of deps) {
|
|
(0, code_1.checkReportMissingProp)(cxt, depProp);
|
|
}
|
|
});
|
|
} else {
|
|
gen.if((0, codegen_1._)`${hasProperty} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`);
|
|
(0, code_1.reportMissingProp)(cxt, missing);
|
|
gen.else();
|
|
}
|
|
}
|
|
}
|
|
exports.validatePropertyDeps = validatePropertyDeps;
|
|
function validateSchemaDeps(cxt, schemaDeps = cxt.schema) {
|
|
const { gen, data, keyword, it } = cxt;
|
|
const valid = gen.name("valid");
|
|
for (const prop in schemaDeps) {
|
|
if ((0, util_1.alwaysValidSchema)(it, schemaDeps[prop]))
|
|
continue;
|
|
gen.if((0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties), () => {
|
|
const schCxt = cxt.subschema({ keyword, schemaProp: prop }, valid);
|
|
cxt.mergeValidEvaluated(schCxt, valid);
|
|
}, () => gen.var(valid, true));
|
|
cxt.ok(valid);
|
|
}
|
|
}
|
|
exports.validateSchemaDeps = validateSchemaDeps;
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/applicator/propertyNames.js
|
|
var require_propertyNames = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var codegen_1 = require_codegen();
|
|
var util_1 = require_util();
|
|
var error2 = {
|
|
message: "property name must be valid",
|
|
params: ({ params }) => (0, codegen_1._)`{propertyName: ${params.propertyName}}`
|
|
};
|
|
var def = {
|
|
keyword: "propertyNames",
|
|
type: "object",
|
|
schemaType: ["object", "boolean"],
|
|
error: error2,
|
|
code(cxt) {
|
|
const { gen, schema, data, it } = cxt;
|
|
if ((0, util_1.alwaysValidSchema)(it, schema))
|
|
return;
|
|
const valid = gen.name("valid");
|
|
gen.forIn("key", data, (key) => {
|
|
cxt.setParams({ propertyName: key });
|
|
cxt.subschema({
|
|
keyword: "propertyNames",
|
|
data: key,
|
|
dataTypes: ["string"],
|
|
propertyName: key,
|
|
compositeRule: true
|
|
}, valid);
|
|
gen.if((0, codegen_1.not)(valid), () => {
|
|
cxt.error(true);
|
|
if (!it.allErrors)
|
|
gen.break();
|
|
});
|
|
});
|
|
cxt.ok(valid);
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js
|
|
var require_additionalProperties = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var code_1 = require_code2();
|
|
var codegen_1 = require_codegen();
|
|
var names_1 = require_names();
|
|
var util_1 = require_util();
|
|
var error2 = {
|
|
message: "must NOT have additional properties",
|
|
params: ({ params }) => (0, codegen_1._)`{additionalProperty: ${params.additionalProperty}}`
|
|
};
|
|
var def = {
|
|
keyword: "additionalProperties",
|
|
type: ["object"],
|
|
schemaType: ["boolean", "object"],
|
|
allowUndefined: true,
|
|
trackErrors: true,
|
|
error: error2,
|
|
code(cxt) {
|
|
const { gen, schema, parentSchema, data, errsCount, it } = cxt;
|
|
if (!errsCount)
|
|
throw new Error("ajv implementation error");
|
|
const { allErrors, opts } = it;
|
|
it.props = true;
|
|
if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema))
|
|
return;
|
|
const props = (0, code_1.allSchemaProperties)(parentSchema.properties);
|
|
const patProps = (0, code_1.allSchemaProperties)(parentSchema.patternProperties);
|
|
checkAdditionalProperties();
|
|
cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
|
|
function checkAdditionalProperties() {
|
|
gen.forIn("key", data, (key) => {
|
|
if (!props.length && !patProps.length)
|
|
additionalPropertyCode(key);
|
|
else
|
|
gen.if(isAdditional(key), () => additionalPropertyCode(key));
|
|
});
|
|
}
|
|
function isAdditional(key) {
|
|
let definedProp;
|
|
if (props.length > 8) {
|
|
const propsSchema = (0, util_1.schemaRefOrVal)(it, parentSchema.properties, "properties");
|
|
definedProp = (0, code_1.isOwnProperty)(gen, propsSchema, key);
|
|
} else if (props.length) {
|
|
definedProp = (0, codegen_1.or)(...props.map((p) => (0, codegen_1._)`${key} === ${p}`));
|
|
} else {
|
|
definedProp = codegen_1.nil;
|
|
}
|
|
if (patProps.length) {
|
|
definedProp = (0, codegen_1.or)(definedProp, ...patProps.map((p) => (0, codegen_1._)`${(0, code_1.usePattern)(cxt, p)}.test(${key})`));
|
|
}
|
|
return (0, codegen_1.not)(definedProp);
|
|
}
|
|
function deleteAdditional(key) {
|
|
gen.code((0, codegen_1._)`delete ${data}[${key}]`);
|
|
}
|
|
function additionalPropertyCode(key) {
|
|
if (opts.removeAdditional === "all" || opts.removeAdditional && schema === false) {
|
|
deleteAdditional(key);
|
|
return;
|
|
}
|
|
if (schema === false) {
|
|
cxt.setParams({ additionalProperty: key });
|
|
cxt.error();
|
|
if (!allErrors)
|
|
gen.break();
|
|
return;
|
|
}
|
|
if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
|
|
const valid = gen.name("valid");
|
|
if (opts.removeAdditional === "failing") {
|
|
applyAdditionalSchema(key, valid, false);
|
|
gen.if((0, codegen_1.not)(valid), () => {
|
|
cxt.reset();
|
|
deleteAdditional(key);
|
|
});
|
|
} else {
|
|
applyAdditionalSchema(key, valid);
|
|
if (!allErrors)
|
|
gen.if((0, codegen_1.not)(valid), () => gen.break());
|
|
}
|
|
}
|
|
}
|
|
function applyAdditionalSchema(key, valid, errors3) {
|
|
const subschema = {
|
|
keyword: "additionalProperties",
|
|
dataProp: key,
|
|
dataPropType: util_1.Type.Str
|
|
};
|
|
if (errors3 === false) {
|
|
Object.assign(subschema, {
|
|
compositeRule: true,
|
|
createErrors: false,
|
|
allErrors: false
|
|
});
|
|
}
|
|
cxt.subschema(subschema, valid);
|
|
}
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/applicator/properties.js
|
|
var require_properties = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var validate_1 = require_validate();
|
|
var code_1 = require_code2();
|
|
var util_1 = require_util();
|
|
var additionalProperties_1 = require_additionalProperties();
|
|
var def = {
|
|
keyword: "properties",
|
|
type: "object",
|
|
schemaType: "object",
|
|
code(cxt) {
|
|
const { gen, schema, parentSchema, data, it } = cxt;
|
|
if (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === undefined) {
|
|
additionalProperties_1.default.code(new validate_1.KeywordCxt(it, additionalProperties_1.default, "additionalProperties"));
|
|
}
|
|
const allProps = (0, code_1.allSchemaProperties)(schema);
|
|
for (const prop of allProps) {
|
|
it.definedProperties.add(prop);
|
|
}
|
|
if (it.opts.unevaluated && allProps.length && it.props !== true) {
|
|
it.props = util_1.mergeEvaluated.props(gen, (0, util_1.toHash)(allProps), it.props);
|
|
}
|
|
const properties = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema[p]));
|
|
if (properties.length === 0)
|
|
return;
|
|
const valid = gen.name("valid");
|
|
for (const prop of properties) {
|
|
if (hasDefault(prop)) {
|
|
applyPropertySchema(prop);
|
|
} else {
|
|
gen.if((0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties));
|
|
applyPropertySchema(prop);
|
|
if (!it.allErrors)
|
|
gen.else().var(valid, true);
|
|
gen.endIf();
|
|
}
|
|
cxt.it.definedProperties.add(prop);
|
|
cxt.ok(valid);
|
|
}
|
|
function hasDefault(prop) {
|
|
return it.opts.useDefaults && !it.compositeRule && schema[prop].default !== undefined;
|
|
}
|
|
function applyPropertySchema(prop) {
|
|
cxt.subschema({
|
|
keyword: "properties",
|
|
schemaProp: prop,
|
|
dataProp: prop
|
|
}, valid);
|
|
}
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/applicator/patternProperties.js
|
|
var require_patternProperties = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var code_1 = require_code2();
|
|
var codegen_1 = require_codegen();
|
|
var util_1 = require_util();
|
|
var util_2 = require_util();
|
|
var def = {
|
|
keyword: "patternProperties",
|
|
type: "object",
|
|
schemaType: "object",
|
|
code(cxt) {
|
|
const { gen, schema, data, parentSchema, it } = cxt;
|
|
const { opts } = it;
|
|
const patterns = (0, code_1.allSchemaProperties)(schema);
|
|
const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema[p]));
|
|
if (patterns.length === 0 || alwaysValidPatterns.length === patterns.length && (!it.opts.unevaluated || it.props === true)) {
|
|
return;
|
|
}
|
|
const checkProperties = opts.strictSchema && !opts.allowMatchingProperties && parentSchema.properties;
|
|
const valid = gen.name("valid");
|
|
if (it.props !== true && !(it.props instanceof codegen_1.Name)) {
|
|
it.props = (0, util_2.evaluatedPropsToName)(gen, it.props);
|
|
}
|
|
const { props } = it;
|
|
validatePatternProperties();
|
|
function validatePatternProperties() {
|
|
for (const pat of patterns) {
|
|
if (checkProperties)
|
|
checkMatchingProperties(pat);
|
|
if (it.allErrors) {
|
|
validateProperties(pat);
|
|
} else {
|
|
gen.var(valid, true);
|
|
validateProperties(pat);
|
|
gen.if(valid);
|
|
}
|
|
}
|
|
}
|
|
function checkMatchingProperties(pat) {
|
|
for (const prop in checkProperties) {
|
|
if (new RegExp(pat).test(prop)) {
|
|
(0, util_1.checkStrictMode)(it, `property ${prop} matches pattern ${pat} (use allowMatchingProperties)`);
|
|
}
|
|
}
|
|
}
|
|
function validateProperties(pat) {
|
|
gen.forIn("key", data, (key) => {
|
|
gen.if((0, codegen_1._)`${(0, code_1.usePattern)(cxt, pat)}.test(${key})`, () => {
|
|
const alwaysValid = alwaysValidPatterns.includes(pat);
|
|
if (!alwaysValid) {
|
|
cxt.subschema({
|
|
keyword: "patternProperties",
|
|
schemaProp: pat,
|
|
dataProp: key,
|
|
dataPropType: util_2.Type.Str
|
|
}, valid);
|
|
}
|
|
if (it.opts.unevaluated && props !== true) {
|
|
gen.assign((0, codegen_1._)`${props}[${key}]`, true);
|
|
} else if (!alwaysValid && !it.allErrors) {
|
|
gen.if((0, codegen_1.not)(valid), () => gen.break());
|
|
}
|
|
});
|
|
});
|
|
}
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/applicator/not.js
|
|
var require_not = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var util_1 = require_util();
|
|
var def = {
|
|
keyword: "not",
|
|
schemaType: ["object", "boolean"],
|
|
trackErrors: true,
|
|
code(cxt) {
|
|
const { gen, schema, it } = cxt;
|
|
if ((0, util_1.alwaysValidSchema)(it, schema)) {
|
|
cxt.fail();
|
|
return;
|
|
}
|
|
const valid = gen.name("valid");
|
|
cxt.subschema({
|
|
keyword: "not",
|
|
compositeRule: true,
|
|
createErrors: false,
|
|
allErrors: false
|
|
}, valid);
|
|
cxt.failResult(valid, () => cxt.reset(), () => cxt.error());
|
|
},
|
|
error: { message: "must NOT be valid" }
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/applicator/anyOf.js
|
|
var require_anyOf = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var code_1 = require_code2();
|
|
var def = {
|
|
keyword: "anyOf",
|
|
schemaType: "array",
|
|
trackErrors: true,
|
|
code: code_1.validateUnion,
|
|
error: { message: "must match a schema in anyOf" }
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/applicator/oneOf.js
|
|
var require_oneOf = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var codegen_1 = require_codegen();
|
|
var util_1 = require_util();
|
|
var error2 = {
|
|
message: "must match exactly one schema in oneOf",
|
|
params: ({ params }) => (0, codegen_1._)`{passingSchemas: ${params.passing}}`
|
|
};
|
|
var def = {
|
|
keyword: "oneOf",
|
|
schemaType: "array",
|
|
trackErrors: true,
|
|
error: error2,
|
|
code(cxt) {
|
|
const { gen, schema, parentSchema, it } = cxt;
|
|
if (!Array.isArray(schema))
|
|
throw new Error("ajv implementation error");
|
|
if (it.opts.discriminator && parentSchema.discriminator)
|
|
return;
|
|
const schArr = schema;
|
|
const valid = gen.let("valid", false);
|
|
const passing = gen.let("passing", null);
|
|
const schValid = gen.name("_valid");
|
|
cxt.setParams({ passing });
|
|
gen.block(validateOneOf);
|
|
cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
|
|
function validateOneOf() {
|
|
schArr.forEach((sch, i) => {
|
|
let schCxt;
|
|
if ((0, util_1.alwaysValidSchema)(it, sch)) {
|
|
gen.var(schValid, true);
|
|
} else {
|
|
schCxt = cxt.subschema({
|
|
keyword: "oneOf",
|
|
schemaProp: i,
|
|
compositeRule: true
|
|
}, schValid);
|
|
}
|
|
if (i > 0) {
|
|
gen.if((0, codegen_1._)`${schValid} && ${valid}`).assign(valid, false).assign(passing, (0, codegen_1._)`[${passing}, ${i}]`).else();
|
|
}
|
|
gen.if(schValid, () => {
|
|
gen.assign(valid, true);
|
|
gen.assign(passing, i);
|
|
if (schCxt)
|
|
cxt.mergeEvaluated(schCxt, codegen_1.Name);
|
|
});
|
|
});
|
|
}
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/applicator/allOf.js
|
|
var require_allOf = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var util_1 = require_util();
|
|
var def = {
|
|
keyword: "allOf",
|
|
schemaType: "array",
|
|
code(cxt) {
|
|
const { gen, schema, it } = cxt;
|
|
if (!Array.isArray(schema))
|
|
throw new Error("ajv implementation error");
|
|
const valid = gen.name("valid");
|
|
schema.forEach((sch, i) => {
|
|
if ((0, util_1.alwaysValidSchema)(it, sch))
|
|
return;
|
|
const schCxt = cxt.subschema({ keyword: "allOf", schemaProp: i }, valid);
|
|
cxt.ok(valid);
|
|
cxt.mergeEvaluated(schCxt);
|
|
});
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/applicator/if.js
|
|
var require_if = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var codegen_1 = require_codegen();
|
|
var util_1 = require_util();
|
|
var error2 = {
|
|
message: ({ params }) => (0, codegen_1.str)`must match "${params.ifClause}" schema`,
|
|
params: ({ params }) => (0, codegen_1._)`{failingKeyword: ${params.ifClause}}`
|
|
};
|
|
var def = {
|
|
keyword: "if",
|
|
schemaType: ["object", "boolean"],
|
|
trackErrors: true,
|
|
error: error2,
|
|
code(cxt) {
|
|
const { gen, parentSchema, it } = cxt;
|
|
if (parentSchema.then === undefined && parentSchema.else === undefined) {
|
|
(0, util_1.checkStrictMode)(it, '"if" without "then" and "else" is ignored');
|
|
}
|
|
const hasThen = hasSchema(it, "then");
|
|
const hasElse = hasSchema(it, "else");
|
|
if (!hasThen && !hasElse)
|
|
return;
|
|
const valid = gen.let("valid", true);
|
|
const schValid = gen.name("_valid");
|
|
validateIf();
|
|
cxt.reset();
|
|
if (hasThen && hasElse) {
|
|
const ifClause = gen.let("ifClause");
|
|
cxt.setParams({ ifClause });
|
|
gen.if(schValid, validateClause("then", ifClause), validateClause("else", ifClause));
|
|
} else if (hasThen) {
|
|
gen.if(schValid, validateClause("then"));
|
|
} else {
|
|
gen.if((0, codegen_1.not)(schValid), validateClause("else"));
|
|
}
|
|
cxt.pass(valid, () => cxt.error(true));
|
|
function validateIf() {
|
|
const schCxt = cxt.subschema({
|
|
keyword: "if",
|
|
compositeRule: true,
|
|
createErrors: false,
|
|
allErrors: false
|
|
}, schValid);
|
|
cxt.mergeEvaluated(schCxt);
|
|
}
|
|
function validateClause(keyword, ifClause) {
|
|
return () => {
|
|
const schCxt = cxt.subschema({ keyword }, schValid);
|
|
gen.assign(valid, schValid);
|
|
cxt.mergeValidEvaluated(schCxt, valid);
|
|
if (ifClause)
|
|
gen.assign(ifClause, (0, codegen_1._)`${keyword}`);
|
|
else
|
|
cxt.setParams({ ifClause: keyword });
|
|
};
|
|
}
|
|
}
|
|
};
|
|
function hasSchema(it, keyword) {
|
|
const schema = it.schema[keyword];
|
|
return schema !== undefined && !(0, util_1.alwaysValidSchema)(it, schema);
|
|
}
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/applicator/thenElse.js
|
|
var require_thenElse = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var util_1 = require_util();
|
|
var def = {
|
|
keyword: ["then", "else"],
|
|
schemaType: ["object", "boolean"],
|
|
code({ keyword, parentSchema, it }) {
|
|
if (parentSchema.if === undefined)
|
|
(0, util_1.checkStrictMode)(it, `"${keyword}" without "if" is ignored`);
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/applicator/index.js
|
|
var require_applicator = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var additionalItems_1 = require_additionalItems();
|
|
var prefixItems_1 = require_prefixItems();
|
|
var items_1 = require_items();
|
|
var items2020_1 = require_items2020();
|
|
var contains_1 = require_contains();
|
|
var dependencies_1 = require_dependencies();
|
|
var propertyNames_1 = require_propertyNames();
|
|
var additionalProperties_1 = require_additionalProperties();
|
|
var properties_1 = require_properties();
|
|
var patternProperties_1 = require_patternProperties();
|
|
var not_1 = require_not();
|
|
var anyOf_1 = require_anyOf();
|
|
var oneOf_1 = require_oneOf();
|
|
var allOf_1 = require_allOf();
|
|
var if_1 = require_if();
|
|
var thenElse_1 = require_thenElse();
|
|
function getApplicator(draft2020 = false) {
|
|
const applicator = [
|
|
not_1.default,
|
|
anyOf_1.default,
|
|
oneOf_1.default,
|
|
allOf_1.default,
|
|
if_1.default,
|
|
thenElse_1.default,
|
|
propertyNames_1.default,
|
|
additionalProperties_1.default,
|
|
dependencies_1.default,
|
|
properties_1.default,
|
|
patternProperties_1.default
|
|
];
|
|
if (draft2020)
|
|
applicator.push(prefixItems_1.default, items2020_1.default);
|
|
else
|
|
applicator.push(additionalItems_1.default, items_1.default);
|
|
applicator.push(contains_1.default);
|
|
return applicator;
|
|
}
|
|
exports.default = getApplicator;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/format/format.js
|
|
var require_format = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var codegen_1 = require_codegen();
|
|
var error2 = {
|
|
message: ({ schemaCode }) => (0, codegen_1.str)`must match format "${schemaCode}"`,
|
|
params: ({ schemaCode }) => (0, codegen_1._)`{format: ${schemaCode}}`
|
|
};
|
|
var def = {
|
|
keyword: "format",
|
|
type: ["number", "string"],
|
|
schemaType: "string",
|
|
$data: true,
|
|
error: error2,
|
|
code(cxt, ruleType) {
|
|
const { gen, data, $data, schema, schemaCode, it } = cxt;
|
|
const { opts, errSchemaPath, schemaEnv, self: self2 } = it;
|
|
if (!opts.validateFormats)
|
|
return;
|
|
if ($data)
|
|
validate$DataFormat();
|
|
else
|
|
validateFormat();
|
|
function validate$DataFormat() {
|
|
const fmts = gen.scopeValue("formats", {
|
|
ref: self2.formats,
|
|
code: opts.code.formats
|
|
});
|
|
const fDef = gen.const("fDef", (0, codegen_1._)`${fmts}[${schemaCode}]`);
|
|
const fType = gen.let("fType");
|
|
const format = gen.let("format");
|
|
gen.if((0, codegen_1._)`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`, () => gen.assign(fType, (0, codegen_1._)`${fDef}.type || "string"`).assign(format, (0, codegen_1._)`${fDef}.validate`), () => gen.assign(fType, (0, codegen_1._)`"string"`).assign(format, fDef));
|
|
cxt.fail$data((0, codegen_1.or)(unknownFmt(), invalidFmt()));
|
|
function unknownFmt() {
|
|
if (opts.strictSchema === false)
|
|
return codegen_1.nil;
|
|
return (0, codegen_1._)`${schemaCode} && !${format}`;
|
|
}
|
|
function invalidFmt() {
|
|
const callFormat = schemaEnv.$async ? (0, codegen_1._)`(${fDef}.async ? await ${format}(${data}) : ${format}(${data}))` : (0, codegen_1._)`${format}(${data})`;
|
|
const validData = (0, codegen_1._)`(typeof ${format} == "function" ? ${callFormat} : ${format}.test(${data}))`;
|
|
return (0, codegen_1._)`${format} && ${format} !== true && ${fType} === ${ruleType} && !${validData}`;
|
|
}
|
|
}
|
|
function validateFormat() {
|
|
const formatDef = self2.formats[schema];
|
|
if (!formatDef) {
|
|
unknownFormat();
|
|
return;
|
|
}
|
|
if (formatDef === true)
|
|
return;
|
|
const [fmtType, format, fmtRef] = getFormat(formatDef);
|
|
if (fmtType === ruleType)
|
|
cxt.pass(validCondition());
|
|
function unknownFormat() {
|
|
if (opts.strictSchema === false) {
|
|
self2.logger.warn(unknownMsg());
|
|
return;
|
|
}
|
|
throw new Error(unknownMsg());
|
|
function unknownMsg() {
|
|
return `unknown format "${schema}" ignored in schema at path "${errSchemaPath}"`;
|
|
}
|
|
}
|
|
function getFormat(fmtDef) {
|
|
const code = fmtDef instanceof RegExp ? (0, codegen_1.regexpCode)(fmtDef) : opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(schema)}` : undefined;
|
|
const fmt = gen.scopeValue("formats", { key: schema, ref: fmtDef, code });
|
|
if (typeof fmtDef == "object" && !(fmtDef instanceof RegExp)) {
|
|
return [fmtDef.type || "string", fmtDef.validate, (0, codegen_1._)`${fmt}.validate`];
|
|
}
|
|
return ["string", fmtDef, fmt];
|
|
}
|
|
function validCondition() {
|
|
if (typeof formatDef == "object" && !(formatDef instanceof RegExp) && formatDef.async) {
|
|
if (!schemaEnv.$async)
|
|
throw new Error("async format in sync schema");
|
|
return (0, codegen_1._)`await ${fmtRef}(${data})`;
|
|
}
|
|
return typeof format == "function" ? (0, codegen_1._)`${fmtRef}(${data})` : (0, codegen_1._)`${fmtRef}.test(${data})`;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/format/index.js
|
|
var require_format2 = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var format_1 = require_format();
|
|
var format = [format_1.default];
|
|
exports.default = format;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/metadata.js
|
|
var require_metadata = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.contentVocabulary = exports.metadataVocabulary = undefined;
|
|
exports.metadataVocabulary = [
|
|
"title",
|
|
"description",
|
|
"default",
|
|
"deprecated",
|
|
"readOnly",
|
|
"writeOnly",
|
|
"examples"
|
|
];
|
|
exports.contentVocabulary = [
|
|
"contentMediaType",
|
|
"contentEncoding",
|
|
"contentSchema"
|
|
];
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/draft7.js
|
|
var require_draft7 = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var core_1 = require_core2();
|
|
var validation_1 = require_validation();
|
|
var applicator_1 = require_applicator();
|
|
var format_1 = require_format2();
|
|
var metadata_1 = require_metadata();
|
|
var draft7Vocabularies = [
|
|
core_1.default,
|
|
validation_1.default,
|
|
(0, applicator_1.default)(),
|
|
format_1.default,
|
|
metadata_1.metadataVocabulary,
|
|
metadata_1.contentVocabulary
|
|
];
|
|
exports.default = draft7Vocabularies;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/discriminator/types.js
|
|
var require_types = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.DiscrError = undefined;
|
|
var DiscrError;
|
|
(function(DiscrError2) {
|
|
DiscrError2["Tag"] = "tag";
|
|
DiscrError2["Mapping"] = "mapping";
|
|
})(DiscrError || (exports.DiscrError = DiscrError = {}));
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/vocabularies/discriminator/index.js
|
|
var require_discriminator = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var codegen_1 = require_codegen();
|
|
var types_1 = require_types();
|
|
var compile_1 = require_compile();
|
|
var ref_error_1 = require_ref_error();
|
|
var util_1 = require_util();
|
|
var error2 = {
|
|
message: ({ params: { discrError, tagName } }) => discrError === types_1.DiscrError.Tag ? `tag "${tagName}" must be string` : `value of tag "${tagName}" must be in oneOf`,
|
|
params: ({ params: { discrError, tag, tagName } }) => (0, codegen_1._)`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}`
|
|
};
|
|
var def = {
|
|
keyword: "discriminator",
|
|
type: "object",
|
|
schemaType: "object",
|
|
error: error2,
|
|
code(cxt) {
|
|
const { gen, data, schema, parentSchema, it } = cxt;
|
|
const { oneOf } = parentSchema;
|
|
if (!it.opts.discriminator) {
|
|
throw new Error("discriminator: requires discriminator option");
|
|
}
|
|
const tagName = schema.propertyName;
|
|
if (typeof tagName != "string")
|
|
throw new Error("discriminator: requires propertyName");
|
|
if (schema.mapping)
|
|
throw new Error("discriminator: mapping is not supported");
|
|
if (!oneOf)
|
|
throw new Error("discriminator: requires oneOf keyword");
|
|
const valid = gen.let("valid", false);
|
|
const tag = gen.const("tag", (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(tagName)}`);
|
|
gen.if((0, codegen_1._)`typeof ${tag} == "string"`, () => validateMapping(), () => cxt.error(false, { discrError: types_1.DiscrError.Tag, tag, tagName }));
|
|
cxt.ok(valid);
|
|
function validateMapping() {
|
|
const mapping = getMapping();
|
|
gen.if(false);
|
|
for (const tagValue in mapping) {
|
|
gen.elseIf((0, codegen_1._)`${tag} === ${tagValue}`);
|
|
gen.assign(valid, applyTagSchema(mapping[tagValue]));
|
|
}
|
|
gen.else();
|
|
cxt.error(false, { discrError: types_1.DiscrError.Mapping, tag, tagName });
|
|
gen.endIf();
|
|
}
|
|
function applyTagSchema(schemaProp) {
|
|
const _valid = gen.name("valid");
|
|
const schCxt = cxt.subschema({ keyword: "oneOf", schemaProp }, _valid);
|
|
cxt.mergeEvaluated(schCxt, codegen_1.Name);
|
|
return _valid;
|
|
}
|
|
function getMapping() {
|
|
var _a;
|
|
const oneOfMapping = {};
|
|
const topRequired = hasRequired(parentSchema);
|
|
let tagRequired = true;
|
|
for (let i = 0;i < oneOf.length; i++) {
|
|
let sch = oneOf[i];
|
|
if ((sch === null || sch === undefined ? undefined : sch.$ref) && !(0, util_1.schemaHasRulesButRef)(sch, it.self.RULES)) {
|
|
const ref = sch.$ref;
|
|
sch = compile_1.resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref);
|
|
if (sch instanceof compile_1.SchemaEnv)
|
|
sch = sch.schema;
|
|
if (sch === undefined)
|
|
throw new ref_error_1.default(it.opts.uriResolver, it.baseId, ref);
|
|
}
|
|
const propSch = (_a = sch === null || sch === undefined ? undefined : sch.properties) === null || _a === undefined ? undefined : _a[tagName];
|
|
if (typeof propSch != "object") {
|
|
throw new Error(`discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`);
|
|
}
|
|
tagRequired = tagRequired && (topRequired || hasRequired(sch));
|
|
addMappings(propSch, i);
|
|
}
|
|
if (!tagRequired)
|
|
throw new Error(`discriminator: "${tagName}" must be required`);
|
|
return oneOfMapping;
|
|
function hasRequired({ required: required2 }) {
|
|
return Array.isArray(required2) && required2.includes(tagName);
|
|
}
|
|
function addMappings(sch, i) {
|
|
if (sch.const) {
|
|
addMapping(sch.const, i);
|
|
} else if (sch.enum) {
|
|
for (const tagValue of sch.enum) {
|
|
addMapping(tagValue, i);
|
|
}
|
|
} else {
|
|
throw new Error(`discriminator: "properties/${tagName}" must have "const" or "enum"`);
|
|
}
|
|
}
|
|
function addMapping(tagValue, i) {
|
|
if (typeof tagValue != "string" || tagValue in oneOfMapping) {
|
|
throw new Error(`discriminator: "${tagName}" values must be unique strings`);
|
|
}
|
|
oneOfMapping[tagValue] = i;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
exports.default = def;
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/refs/json-schema-draft-07.json
|
|
var require_json_schema_draft_07 = __commonJS((exports, module) => {
|
|
module.exports = {
|
|
$schema: "http://json-schema.org/draft-07/schema#",
|
|
$id: "http://json-schema.org/draft-07/schema#",
|
|
title: "Core schema meta-schema",
|
|
definitions: {
|
|
schemaArray: {
|
|
type: "array",
|
|
minItems: 1,
|
|
items: { $ref: "#" }
|
|
},
|
|
nonNegativeInteger: {
|
|
type: "integer",
|
|
minimum: 0
|
|
},
|
|
nonNegativeIntegerDefault0: {
|
|
allOf: [{ $ref: "#/definitions/nonNegativeInteger" }, { default: 0 }]
|
|
},
|
|
simpleTypes: {
|
|
enum: ["array", "boolean", "integer", "null", "number", "object", "string"]
|
|
},
|
|
stringArray: {
|
|
type: "array",
|
|
items: { type: "string" },
|
|
uniqueItems: true,
|
|
default: []
|
|
}
|
|
},
|
|
type: ["object", "boolean"],
|
|
properties: {
|
|
$id: {
|
|
type: "string",
|
|
format: "uri-reference"
|
|
},
|
|
$schema: {
|
|
type: "string",
|
|
format: "uri"
|
|
},
|
|
$ref: {
|
|
type: "string",
|
|
format: "uri-reference"
|
|
},
|
|
$comment: {
|
|
type: "string"
|
|
},
|
|
title: {
|
|
type: "string"
|
|
},
|
|
description: {
|
|
type: "string"
|
|
},
|
|
default: true,
|
|
readOnly: {
|
|
type: "boolean",
|
|
default: false
|
|
},
|
|
examples: {
|
|
type: "array",
|
|
items: true
|
|
},
|
|
multipleOf: {
|
|
type: "number",
|
|
exclusiveMinimum: 0
|
|
},
|
|
maximum: {
|
|
type: "number"
|
|
},
|
|
exclusiveMaximum: {
|
|
type: "number"
|
|
},
|
|
minimum: {
|
|
type: "number"
|
|
},
|
|
exclusiveMinimum: {
|
|
type: "number"
|
|
},
|
|
maxLength: { $ref: "#/definitions/nonNegativeInteger" },
|
|
minLength: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
|
|
pattern: {
|
|
type: "string",
|
|
format: "regex"
|
|
},
|
|
additionalItems: { $ref: "#" },
|
|
items: {
|
|
anyOf: [{ $ref: "#" }, { $ref: "#/definitions/schemaArray" }],
|
|
default: true
|
|
},
|
|
maxItems: { $ref: "#/definitions/nonNegativeInteger" },
|
|
minItems: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
|
|
uniqueItems: {
|
|
type: "boolean",
|
|
default: false
|
|
},
|
|
contains: { $ref: "#" },
|
|
maxProperties: { $ref: "#/definitions/nonNegativeInteger" },
|
|
minProperties: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
|
|
required: { $ref: "#/definitions/stringArray" },
|
|
additionalProperties: { $ref: "#" },
|
|
definitions: {
|
|
type: "object",
|
|
additionalProperties: { $ref: "#" },
|
|
default: {}
|
|
},
|
|
properties: {
|
|
type: "object",
|
|
additionalProperties: { $ref: "#" },
|
|
default: {}
|
|
},
|
|
patternProperties: {
|
|
type: "object",
|
|
additionalProperties: { $ref: "#" },
|
|
propertyNames: { format: "regex" },
|
|
default: {}
|
|
},
|
|
dependencies: {
|
|
type: "object",
|
|
additionalProperties: {
|
|
anyOf: [{ $ref: "#" }, { $ref: "#/definitions/stringArray" }]
|
|
}
|
|
},
|
|
propertyNames: { $ref: "#" },
|
|
const: true,
|
|
enum: {
|
|
type: "array",
|
|
items: true,
|
|
minItems: 1,
|
|
uniqueItems: true
|
|
},
|
|
type: {
|
|
anyOf: [
|
|
{ $ref: "#/definitions/simpleTypes" },
|
|
{
|
|
type: "array",
|
|
items: { $ref: "#/definitions/simpleTypes" },
|
|
minItems: 1,
|
|
uniqueItems: true
|
|
}
|
|
]
|
|
},
|
|
format: { type: "string" },
|
|
contentMediaType: { type: "string" },
|
|
contentEncoding: { type: "string" },
|
|
if: { $ref: "#" },
|
|
then: { $ref: "#" },
|
|
else: { $ref: "#" },
|
|
allOf: { $ref: "#/definitions/schemaArray" },
|
|
anyOf: { $ref: "#/definitions/schemaArray" },
|
|
oneOf: { $ref: "#/definitions/schemaArray" },
|
|
not: { $ref: "#" }
|
|
},
|
|
default: true
|
|
};
|
|
});
|
|
|
|
// ../node_modules/ajv/dist/ajv.js
|
|
var require_ajv = __commonJS((exports, module) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv = undefined;
|
|
var core_1 = require_core();
|
|
var draft7_1 = require_draft7();
|
|
var discriminator_1 = require_discriminator();
|
|
var draft7MetaSchema = require_json_schema_draft_07();
|
|
var META_SUPPORT_DATA = ["/properties"];
|
|
var META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
|
|
|
|
class Ajv extends core_1.default {
|
|
_addVocabularies() {
|
|
super._addVocabularies();
|
|
draft7_1.default.forEach((v) => this.addVocabulary(v));
|
|
if (this.opts.discriminator)
|
|
this.addKeyword(discriminator_1.default);
|
|
}
|
|
_addDefaultMetaSchema() {
|
|
super._addDefaultMetaSchema();
|
|
if (!this.opts.meta)
|
|
return;
|
|
const metaSchema = this.opts.$data ? this.$dataMetaSchema(draft7MetaSchema, META_SUPPORT_DATA) : draft7MetaSchema;
|
|
this.addMetaSchema(metaSchema, META_SCHEMA_ID, false);
|
|
this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
|
|
}
|
|
defaultMeta() {
|
|
return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : undefined);
|
|
}
|
|
}
|
|
exports.Ajv = Ajv;
|
|
module.exports = exports = Ajv;
|
|
module.exports.Ajv = Ajv;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.default = Ajv;
|
|
var validate_1 = require_validate();
|
|
Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
|
|
return validate_1.KeywordCxt;
|
|
} });
|
|
var codegen_1 = require_codegen();
|
|
Object.defineProperty(exports, "_", { enumerable: true, get: function() {
|
|
return codegen_1._;
|
|
} });
|
|
Object.defineProperty(exports, "str", { enumerable: true, get: function() {
|
|
return codegen_1.str;
|
|
} });
|
|
Object.defineProperty(exports, "stringify", { enumerable: true, get: function() {
|
|
return codegen_1.stringify;
|
|
} });
|
|
Object.defineProperty(exports, "nil", { enumerable: true, get: function() {
|
|
return codegen_1.nil;
|
|
} });
|
|
Object.defineProperty(exports, "Name", { enumerable: true, get: function() {
|
|
return codegen_1.Name;
|
|
} });
|
|
Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function() {
|
|
return codegen_1.CodeGen;
|
|
} });
|
|
var validation_error_1 = require_validation_error();
|
|
Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function() {
|
|
return validation_error_1.default;
|
|
} });
|
|
var ref_error_1 = require_ref_error();
|
|
Object.defineProperty(exports, "MissingRefError", { enumerable: true, get: function() {
|
|
return ref_error_1.default;
|
|
} });
|
|
});
|
|
|
|
// ../node_modules/ajv-formats/dist/formats.js
|
|
var require_formats = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.formatNames = exports.fastFormats = exports.fullFormats = undefined;
|
|
function fmtDef(validate, compare) {
|
|
return { validate, compare };
|
|
}
|
|
exports.fullFormats = {
|
|
date: fmtDef(date4, compareDate),
|
|
time: fmtDef(getTime(true), compareTime),
|
|
"date-time": fmtDef(getDateTime(true), compareDateTime),
|
|
"iso-time": fmtDef(getTime(), compareIsoTime),
|
|
"iso-date-time": fmtDef(getDateTime(), compareIsoDateTime),
|
|
duration: /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/,
|
|
uri,
|
|
"uri-reference": /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i,
|
|
"uri-template": /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i,
|
|
url: /^(?:https?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu,
|
|
email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,
|
|
hostname: /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i,
|
|
ipv4: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/,
|
|
ipv6: /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i,
|
|
regex,
|
|
uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,
|
|
"json-pointer": /^(?:\/(?:[^~/]|~0|~1)*)*$/,
|
|
"json-pointer-uri-fragment": /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i,
|
|
"relative-json-pointer": /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/,
|
|
byte,
|
|
int32: { type: "number", validate: validateInt32 },
|
|
int64: { type: "number", validate: validateInt64 },
|
|
float: { type: "number", validate: validateNumber },
|
|
double: { type: "number", validate: validateNumber },
|
|
password: true,
|
|
binary: true
|
|
};
|
|
exports.fastFormats = {
|
|
...exports.fullFormats,
|
|
date: fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d$/, compareDate),
|
|
time: fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareTime),
|
|
"date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareDateTime),
|
|
"iso-time": fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoTime),
|
|
"iso-date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoDateTime),
|
|
uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i,
|
|
"uri-reference": /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i,
|
|
email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i
|
|
};
|
|
exports.formatNames = Object.keys(exports.fullFormats);
|
|
function isLeapYear(year) {
|
|
return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
|
|
}
|
|
var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
|
|
var DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
|
|
function date4(str) {
|
|
const matches = DATE.exec(str);
|
|
if (!matches)
|
|
return false;
|
|
const year = +matches[1];
|
|
const month = +matches[2];
|
|
const day = +matches[3];
|
|
return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month]);
|
|
}
|
|
function compareDate(d1, d2) {
|
|
if (!(d1 && d2))
|
|
return;
|
|
if (d1 > d2)
|
|
return 1;
|
|
if (d1 < d2)
|
|
return -1;
|
|
return 0;
|
|
}
|
|
var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
|
|
function getTime(strictTimeZone) {
|
|
return function time(str) {
|
|
const matches = TIME.exec(str);
|
|
if (!matches)
|
|
return false;
|
|
const hr = +matches[1];
|
|
const min = +matches[2];
|
|
const sec = +matches[3];
|
|
const tz = matches[4];
|
|
const tzSign = matches[5] === "-" ? -1 : 1;
|
|
const tzH = +(matches[6] || 0);
|
|
const tzM = +(matches[7] || 0);
|
|
if (tzH > 23 || tzM > 59 || strictTimeZone && !tz)
|
|
return false;
|
|
if (hr <= 23 && min <= 59 && sec < 60)
|
|
return true;
|
|
const utcMin = min - tzM * tzSign;
|
|
const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0);
|
|
return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61;
|
|
};
|
|
}
|
|
function compareTime(s1, s2) {
|
|
if (!(s1 && s2))
|
|
return;
|
|
const t1 = new Date("2020-01-01T" + s1).valueOf();
|
|
const t2 = new Date("2020-01-01T" + s2).valueOf();
|
|
if (!(t1 && t2))
|
|
return;
|
|
return t1 - t2;
|
|
}
|
|
function compareIsoTime(t1, t2) {
|
|
if (!(t1 && t2))
|
|
return;
|
|
const a1 = TIME.exec(t1);
|
|
const a2 = TIME.exec(t2);
|
|
if (!(a1 && a2))
|
|
return;
|
|
t1 = a1[1] + a1[2] + a1[3];
|
|
t2 = a2[1] + a2[2] + a2[3];
|
|
if (t1 > t2)
|
|
return 1;
|
|
if (t1 < t2)
|
|
return -1;
|
|
return 0;
|
|
}
|
|
var DATE_TIME_SEPARATOR = /t|\s/i;
|
|
function getDateTime(strictTimeZone) {
|
|
const time3 = getTime(strictTimeZone);
|
|
return function date_time(str) {
|
|
const dateTime = str.split(DATE_TIME_SEPARATOR);
|
|
return dateTime.length === 2 && date4(dateTime[0]) && time3(dateTime[1]);
|
|
};
|
|
}
|
|
function compareDateTime(dt1, dt2) {
|
|
if (!(dt1 && dt2))
|
|
return;
|
|
const d1 = new Date(dt1).valueOf();
|
|
const d2 = new Date(dt2).valueOf();
|
|
if (!(d1 && d2))
|
|
return;
|
|
return d1 - d2;
|
|
}
|
|
function compareIsoDateTime(dt1, dt2) {
|
|
if (!(dt1 && dt2))
|
|
return;
|
|
const [d1, t1] = dt1.split(DATE_TIME_SEPARATOR);
|
|
const [d2, t2] = dt2.split(DATE_TIME_SEPARATOR);
|
|
const res = compareDate(d1, d2);
|
|
if (res === undefined)
|
|
return;
|
|
return res || compareTime(t1, t2);
|
|
}
|
|
var NOT_URI_FRAGMENT = /\/|:/;
|
|
var URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
|
|
function uri(str) {
|
|
return NOT_URI_FRAGMENT.test(str) && URI.test(str);
|
|
}
|
|
var BYTE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm;
|
|
function byte(str) {
|
|
BYTE.lastIndex = 0;
|
|
return BYTE.test(str);
|
|
}
|
|
var MIN_INT32 = -(2 ** 31);
|
|
var MAX_INT32 = 2 ** 31 - 1;
|
|
function validateInt32(value) {
|
|
return Number.isInteger(value) && value <= MAX_INT32 && value >= MIN_INT32;
|
|
}
|
|
function validateInt64(value) {
|
|
return Number.isInteger(value);
|
|
}
|
|
function validateNumber() {
|
|
return true;
|
|
}
|
|
var Z_ANCHOR = /[^\\]\\Z/;
|
|
function regex(str) {
|
|
if (Z_ANCHOR.test(str))
|
|
return false;
|
|
try {
|
|
new RegExp(str);
|
|
return true;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../node_modules/ajv-formats/dist/limit.js
|
|
var require_limit = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.formatLimitDefinition = undefined;
|
|
var ajv_1 = require_ajv();
|
|
var codegen_1 = require_codegen();
|
|
var ops = codegen_1.operators;
|
|
var KWDs = {
|
|
formatMaximum: { okStr: "<=", ok: ops.LTE, fail: ops.GT },
|
|
formatMinimum: { okStr: ">=", ok: ops.GTE, fail: ops.LT },
|
|
formatExclusiveMaximum: { okStr: "<", ok: ops.LT, fail: ops.GTE },
|
|
formatExclusiveMinimum: { okStr: ">", ok: ops.GT, fail: ops.LTE }
|
|
};
|
|
var error2 = {
|
|
message: ({ keyword, schemaCode }) => (0, codegen_1.str)`should be ${KWDs[keyword].okStr} ${schemaCode}`,
|
|
params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`
|
|
};
|
|
exports.formatLimitDefinition = {
|
|
keyword: Object.keys(KWDs),
|
|
type: "string",
|
|
schemaType: "string",
|
|
$data: true,
|
|
error: error2,
|
|
code(cxt) {
|
|
const { gen, data, schemaCode, keyword, it } = cxt;
|
|
const { opts, self: self2 } = it;
|
|
if (!opts.validateFormats)
|
|
return;
|
|
const fCxt = new ajv_1.KeywordCxt(it, self2.RULES.all.format.definition, "format");
|
|
if (fCxt.$data)
|
|
validate$DataFormat();
|
|
else
|
|
validateFormat();
|
|
function validate$DataFormat() {
|
|
const fmts = gen.scopeValue("formats", {
|
|
ref: self2.formats,
|
|
code: opts.code.formats
|
|
});
|
|
const fmt = gen.const("fmt", (0, codegen_1._)`${fmts}[${fCxt.schemaCode}]`);
|
|
cxt.fail$data((0, codegen_1.or)((0, codegen_1._)`typeof ${fmt} != "object"`, (0, codegen_1._)`${fmt} instanceof RegExp`, (0, codegen_1._)`typeof ${fmt}.compare != "function"`, compareCode(fmt)));
|
|
}
|
|
function validateFormat() {
|
|
const format = fCxt.schema;
|
|
const fmtDef = self2.formats[format];
|
|
if (!fmtDef || fmtDef === true)
|
|
return;
|
|
if (typeof fmtDef != "object" || fmtDef instanceof RegExp || typeof fmtDef.compare != "function") {
|
|
throw new Error(`"${keyword}": format "${format}" does not define "compare" function`);
|
|
}
|
|
const fmt = gen.scopeValue("formats", {
|
|
key: format,
|
|
ref: fmtDef,
|
|
code: opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format)}` : undefined
|
|
});
|
|
cxt.fail$data(compareCode(fmt));
|
|
}
|
|
function compareCode(fmt) {
|
|
return (0, codegen_1._)`${fmt}.compare(${data}, ${schemaCode}) ${KWDs[keyword].fail} 0`;
|
|
}
|
|
},
|
|
dependencies: ["format"]
|
|
};
|
|
var formatLimitPlugin = (ajv) => {
|
|
ajv.addKeyword(exports.formatLimitDefinition);
|
|
return ajv;
|
|
};
|
|
exports.default = formatLimitPlugin;
|
|
});
|
|
|
|
// ../node_modules/ajv-formats/dist/index.js
|
|
var require_dist = __commonJS((exports, module) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var formats_1 = require_formats();
|
|
var limit_1 = require_limit();
|
|
var codegen_1 = require_codegen();
|
|
var fullName = new codegen_1.Name("fullFormats");
|
|
var fastName = new codegen_1.Name("fastFormats");
|
|
var formatsPlugin = (ajv, opts = { keywords: true }) => {
|
|
if (Array.isArray(opts)) {
|
|
addFormats(ajv, opts, formats_1.fullFormats, fullName);
|
|
return ajv;
|
|
}
|
|
const [formats, exportName] = opts.mode === "fast" ? [formats_1.fastFormats, fastName] : [formats_1.fullFormats, fullName];
|
|
const list = opts.formats || formats_1.formatNames;
|
|
addFormats(ajv, list, formats, exportName);
|
|
if (opts.keywords)
|
|
(0, limit_1.default)(ajv);
|
|
return ajv;
|
|
};
|
|
formatsPlugin.get = (name, mode = "full") => {
|
|
const formats = mode === "fast" ? formats_1.fastFormats : formats_1.fullFormats;
|
|
const f = formats[name];
|
|
if (!f)
|
|
throw new Error(`Unknown format "${name}"`);
|
|
return f;
|
|
};
|
|
function addFormats(ajv, list, fs2, exportName) {
|
|
var _a;
|
|
var _b;
|
|
(_a = (_b = ajv.opts.code).formats) !== null && _a !== undefined || (_b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`);
|
|
for (const f of list)
|
|
ajv.addFormat(f, fs2[f]);
|
|
}
|
|
module.exports = exports = formatsPlugin;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.default = formatsPlugin;
|
|
});
|
|
|
|
// ../src/entrypoints/agentSdk.ts
|
|
import { join as join5 } from "path";
|
|
import { fileURLToPath as fileURLToPath2 } from "url";
|
|
|
|
// ../src/utils/abortController.ts
|
|
import { setMaxListeners } from "events";
|
|
var DEFAULT_MAX_LISTENERS = 50;
|
|
function createAbortController(maxListeners = DEFAULT_MAX_LISTENERS) {
|
|
const controller = new AbortController;
|
|
setMaxListeners(maxListeners, controller.signal);
|
|
return controller;
|
|
}
|
|
|
|
// ../src/transport/ProcessTransport.ts
|
|
import { spawn } from "child_process";
|
|
import { createInterface } from "readline";
|
|
|
|
// ../src/utils/fsOperations.ts
|
|
import * as fs from "fs";
|
|
import { stat as statPromise, open } from "fs/promises";
|
|
|
|
// ../node_modules/lodash-es/_freeGlobal.js
|
|
var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
|
|
var _freeGlobal_default = freeGlobal;
|
|
|
|
// ../node_modules/lodash-es/_root.js
|
|
var freeSelf = typeof self == "object" && self && self.Object === Object && self;
|
|
var root = _freeGlobal_default || freeSelf || Function("return this")();
|
|
var _root_default = root;
|
|
|
|
// ../node_modules/lodash-es/_Symbol.js
|
|
var Symbol2 = _root_default.Symbol;
|
|
var _Symbol_default = Symbol2;
|
|
|
|
// ../node_modules/lodash-es/_getRawTag.js
|
|
var objectProto = Object.prototype;
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
var nativeObjectToString = objectProto.toString;
|
|
var symToStringTag = _Symbol_default ? _Symbol_default.toStringTag : undefined;
|
|
function getRawTag(value) {
|
|
var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
|
|
try {
|
|
value[symToStringTag] = undefined;
|
|
var unmasked = true;
|
|
} catch (e) {}
|
|
var result = nativeObjectToString.call(value);
|
|
if (unmasked) {
|
|
if (isOwn) {
|
|
value[symToStringTag] = tag;
|
|
} else {
|
|
delete value[symToStringTag];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
var _getRawTag_default = getRawTag;
|
|
|
|
// ../node_modules/lodash-es/_objectToString.js
|
|
var objectProto2 = Object.prototype;
|
|
var nativeObjectToString2 = objectProto2.toString;
|
|
function objectToString(value) {
|
|
return nativeObjectToString2.call(value);
|
|
}
|
|
var _objectToString_default = objectToString;
|
|
|
|
// ../node_modules/lodash-es/_baseGetTag.js
|
|
var nullTag = "[object Null]";
|
|
var undefinedTag = "[object Undefined]";
|
|
var symToStringTag2 = _Symbol_default ? _Symbol_default.toStringTag : undefined;
|
|
function baseGetTag(value) {
|
|
if (value == null) {
|
|
return value === undefined ? undefinedTag : nullTag;
|
|
}
|
|
return symToStringTag2 && symToStringTag2 in Object(value) ? _getRawTag_default(value) : _objectToString_default(value);
|
|
}
|
|
var _baseGetTag_default = baseGetTag;
|
|
|
|
// ../node_modules/lodash-es/isObject.js
|
|
function isObject(value) {
|
|
var type = typeof value;
|
|
return value != null && (type == "object" || type == "function");
|
|
}
|
|
var isObject_default = isObject;
|
|
|
|
// ../node_modules/lodash-es/isFunction.js
|
|
var asyncTag = "[object AsyncFunction]";
|
|
var funcTag = "[object Function]";
|
|
var genTag = "[object GeneratorFunction]";
|
|
var proxyTag = "[object Proxy]";
|
|
function isFunction(value) {
|
|
if (!isObject_default(value)) {
|
|
return false;
|
|
}
|
|
var tag = _baseGetTag_default(value);
|
|
return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
|
|
}
|
|
var isFunction_default = isFunction;
|
|
|
|
// ../node_modules/lodash-es/_coreJsData.js
|
|
var coreJsData = _root_default["__core-js_shared__"];
|
|
var _coreJsData_default = coreJsData;
|
|
|
|
// ../node_modules/lodash-es/_isMasked.js
|
|
var maskSrcKey = function() {
|
|
var uid = /[^.]+$/.exec(_coreJsData_default && _coreJsData_default.keys && _coreJsData_default.keys.IE_PROTO || "");
|
|
return uid ? "Symbol(src)_1." + uid : "";
|
|
}();
|
|
function isMasked(func) {
|
|
return !!maskSrcKey && maskSrcKey in func;
|
|
}
|
|
var _isMasked_default = isMasked;
|
|
|
|
// ../node_modules/lodash-es/_toSource.js
|
|
var funcProto = Function.prototype;
|
|
var funcToString = funcProto.toString;
|
|
function toSource(func) {
|
|
if (func != null) {
|
|
try {
|
|
return funcToString.call(func);
|
|
} catch (e) {}
|
|
try {
|
|
return func + "";
|
|
} catch (e) {}
|
|
}
|
|
return "";
|
|
}
|
|
var _toSource_default = toSource;
|
|
|
|
// ../node_modules/lodash-es/_baseIsNative.js
|
|
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
|
|
var reIsHostCtor = /^\[object .+?Constructor\]$/;
|
|
var funcProto2 = Function.prototype;
|
|
var objectProto3 = Object.prototype;
|
|
var funcToString2 = funcProto2.toString;
|
|
var hasOwnProperty2 = objectProto3.hasOwnProperty;
|
|
var reIsNative = RegExp("^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
|
|
function baseIsNative(value) {
|
|
if (!isObject_default(value) || _isMasked_default(value)) {
|
|
return false;
|
|
}
|
|
var pattern = isFunction_default(value) ? reIsNative : reIsHostCtor;
|
|
return pattern.test(_toSource_default(value));
|
|
}
|
|
var _baseIsNative_default = baseIsNative;
|
|
|
|
// ../node_modules/lodash-es/_getValue.js
|
|
function getValue(object, key) {
|
|
return object == null ? undefined : object[key];
|
|
}
|
|
var _getValue_default = getValue;
|
|
|
|
// ../node_modules/lodash-es/_getNative.js
|
|
function getNative(object, key) {
|
|
var value = _getValue_default(object, key);
|
|
return _baseIsNative_default(value) ? value : undefined;
|
|
}
|
|
var _getNative_default = getNative;
|
|
|
|
// ../node_modules/lodash-es/_nativeCreate.js
|
|
var nativeCreate = _getNative_default(Object, "create");
|
|
var _nativeCreate_default = nativeCreate;
|
|
|
|
// ../node_modules/lodash-es/_hashClear.js
|
|
function hashClear() {
|
|
this.__data__ = _nativeCreate_default ? _nativeCreate_default(null) : {};
|
|
this.size = 0;
|
|
}
|
|
var _hashClear_default = hashClear;
|
|
|
|
// ../node_modules/lodash-es/_hashDelete.js
|
|
function hashDelete(key) {
|
|
var result = this.has(key) && delete this.__data__[key];
|
|
this.size -= result ? 1 : 0;
|
|
return result;
|
|
}
|
|
var _hashDelete_default = hashDelete;
|
|
|
|
// ../node_modules/lodash-es/_hashGet.js
|
|
var HASH_UNDEFINED = "__lodash_hash_undefined__";
|
|
var objectProto4 = Object.prototype;
|
|
var hasOwnProperty3 = objectProto4.hasOwnProperty;
|
|
function hashGet(key) {
|
|
var data = this.__data__;
|
|
if (_nativeCreate_default) {
|
|
var result = data[key];
|
|
return result === HASH_UNDEFINED ? undefined : result;
|
|
}
|
|
return hasOwnProperty3.call(data, key) ? data[key] : undefined;
|
|
}
|
|
var _hashGet_default = hashGet;
|
|
|
|
// ../node_modules/lodash-es/_hashHas.js
|
|
var objectProto5 = Object.prototype;
|
|
var hasOwnProperty4 = objectProto5.hasOwnProperty;
|
|
function hashHas(key) {
|
|
var data = this.__data__;
|
|
return _nativeCreate_default ? data[key] !== undefined : hasOwnProperty4.call(data, key);
|
|
}
|
|
var _hashHas_default = hashHas;
|
|
|
|
// ../node_modules/lodash-es/_hashSet.js
|
|
var HASH_UNDEFINED2 = "__lodash_hash_undefined__";
|
|
function hashSet(key, value) {
|
|
var data = this.__data__;
|
|
this.size += this.has(key) ? 0 : 1;
|
|
data[key] = _nativeCreate_default && value === undefined ? HASH_UNDEFINED2 : value;
|
|
return this;
|
|
}
|
|
var _hashSet_default = hashSet;
|
|
|
|
// ../node_modules/lodash-es/_Hash.js
|
|
function Hash(entries) {
|
|
var index = -1, length = entries == null ? 0 : entries.length;
|
|
this.clear();
|
|
while (++index < length) {
|
|
var entry = entries[index];
|
|
this.set(entry[0], entry[1]);
|
|
}
|
|
}
|
|
Hash.prototype.clear = _hashClear_default;
|
|
Hash.prototype["delete"] = _hashDelete_default;
|
|
Hash.prototype.get = _hashGet_default;
|
|
Hash.prototype.has = _hashHas_default;
|
|
Hash.prototype.set = _hashSet_default;
|
|
var _Hash_default = Hash;
|
|
|
|
// ../node_modules/lodash-es/_listCacheClear.js
|
|
function listCacheClear() {
|
|
this.__data__ = [];
|
|
this.size = 0;
|
|
}
|
|
var _listCacheClear_default = listCacheClear;
|
|
|
|
// ../node_modules/lodash-es/eq.js
|
|
function eq(value, other) {
|
|
return value === other || value !== value && other !== other;
|
|
}
|
|
var eq_default = eq;
|
|
|
|
// ../node_modules/lodash-es/_assocIndexOf.js
|
|
function assocIndexOf(array, key) {
|
|
var length = array.length;
|
|
while (length--) {
|
|
if (eq_default(array[length][0], key)) {
|
|
return length;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
var _assocIndexOf_default = assocIndexOf;
|
|
|
|
// ../node_modules/lodash-es/_listCacheDelete.js
|
|
var arrayProto = Array.prototype;
|
|
var splice = arrayProto.splice;
|
|
function listCacheDelete(key) {
|
|
var data = this.__data__, index = _assocIndexOf_default(data, key);
|
|
if (index < 0) {
|
|
return false;
|
|
}
|
|
var lastIndex = data.length - 1;
|
|
if (index == lastIndex) {
|
|
data.pop();
|
|
} else {
|
|
splice.call(data, index, 1);
|
|
}
|
|
--this.size;
|
|
return true;
|
|
}
|
|
var _listCacheDelete_default = listCacheDelete;
|
|
|
|
// ../node_modules/lodash-es/_listCacheGet.js
|
|
function listCacheGet(key) {
|
|
var data = this.__data__, index = _assocIndexOf_default(data, key);
|
|
return index < 0 ? undefined : data[index][1];
|
|
}
|
|
var _listCacheGet_default = listCacheGet;
|
|
|
|
// ../node_modules/lodash-es/_listCacheHas.js
|
|
function listCacheHas(key) {
|
|
return _assocIndexOf_default(this.__data__, key) > -1;
|
|
}
|
|
var _listCacheHas_default = listCacheHas;
|
|
|
|
// ../node_modules/lodash-es/_listCacheSet.js
|
|
function listCacheSet(key, value) {
|
|
var data = this.__data__, index = _assocIndexOf_default(data, key);
|
|
if (index < 0) {
|
|
++this.size;
|
|
data.push([key, value]);
|
|
} else {
|
|
data[index][1] = value;
|
|
}
|
|
return this;
|
|
}
|
|
var _listCacheSet_default = listCacheSet;
|
|
|
|
// ../node_modules/lodash-es/_ListCache.js
|
|
function ListCache(entries) {
|
|
var index = -1, length = entries == null ? 0 : entries.length;
|
|
this.clear();
|
|
while (++index < length) {
|
|
var entry = entries[index];
|
|
this.set(entry[0], entry[1]);
|
|
}
|
|
}
|
|
ListCache.prototype.clear = _listCacheClear_default;
|
|
ListCache.prototype["delete"] = _listCacheDelete_default;
|
|
ListCache.prototype.get = _listCacheGet_default;
|
|
ListCache.prototype.has = _listCacheHas_default;
|
|
ListCache.prototype.set = _listCacheSet_default;
|
|
var _ListCache_default = ListCache;
|
|
|
|
// ../node_modules/lodash-es/_Map.js
|
|
var Map2 = _getNative_default(_root_default, "Map");
|
|
var _Map_default = Map2;
|
|
|
|
// ../node_modules/lodash-es/_mapCacheClear.js
|
|
function mapCacheClear() {
|
|
this.size = 0;
|
|
this.__data__ = {
|
|
hash: new _Hash_default,
|
|
map: new (_Map_default || _ListCache_default),
|
|
string: new _Hash_default
|
|
};
|
|
}
|
|
var _mapCacheClear_default = mapCacheClear;
|
|
|
|
// ../node_modules/lodash-es/_isKeyable.js
|
|
function isKeyable(value) {
|
|
var type = typeof value;
|
|
return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
|
|
}
|
|
var _isKeyable_default = isKeyable;
|
|
|
|
// ../node_modules/lodash-es/_getMapData.js
|
|
function getMapData(map, key) {
|
|
var data = map.__data__;
|
|
return _isKeyable_default(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
|
|
}
|
|
var _getMapData_default = getMapData;
|
|
|
|
// ../node_modules/lodash-es/_mapCacheDelete.js
|
|
function mapCacheDelete(key) {
|
|
var result = _getMapData_default(this, key)["delete"](key);
|
|
this.size -= result ? 1 : 0;
|
|
return result;
|
|
}
|
|
var _mapCacheDelete_default = mapCacheDelete;
|
|
|
|
// ../node_modules/lodash-es/_mapCacheGet.js
|
|
function mapCacheGet(key) {
|
|
return _getMapData_default(this, key).get(key);
|
|
}
|
|
var _mapCacheGet_default = mapCacheGet;
|
|
|
|
// ../node_modules/lodash-es/_mapCacheHas.js
|
|
function mapCacheHas(key) {
|
|
return _getMapData_default(this, key).has(key);
|
|
}
|
|
var _mapCacheHas_default = mapCacheHas;
|
|
|
|
// ../node_modules/lodash-es/_mapCacheSet.js
|
|
function mapCacheSet(key, value) {
|
|
var data = _getMapData_default(this, key), size = data.size;
|
|
data.set(key, value);
|
|
this.size += data.size == size ? 0 : 1;
|
|
return this;
|
|
}
|
|
var _mapCacheSet_default = mapCacheSet;
|
|
|
|
// ../node_modules/lodash-es/_MapCache.js
|
|
function MapCache(entries) {
|
|
var index = -1, length = entries == null ? 0 : entries.length;
|
|
this.clear();
|
|
while (++index < length) {
|
|
var entry = entries[index];
|
|
this.set(entry[0], entry[1]);
|
|
}
|
|
}
|
|
MapCache.prototype.clear = _mapCacheClear_default;
|
|
MapCache.prototype["delete"] = _mapCacheDelete_default;
|
|
MapCache.prototype.get = _mapCacheGet_default;
|
|
MapCache.prototype.has = _mapCacheHas_default;
|
|
MapCache.prototype.set = _mapCacheSet_default;
|
|
var _MapCache_default = MapCache;
|
|
|
|
// ../node_modules/lodash-es/memoize.js
|
|
var FUNC_ERROR_TEXT = "Expected a function";
|
|
function memoize(func, resolver) {
|
|
if (typeof func != "function" || resolver != null && typeof resolver != "function") {
|
|
throw new TypeError(FUNC_ERROR_TEXT);
|
|
}
|
|
var memoized = function() {
|
|
var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
|
|
if (cache.has(key)) {
|
|
return cache.get(key);
|
|
}
|
|
var result = func.apply(this, args);
|
|
memoized.cache = cache.set(key, result) || cache;
|
|
return result;
|
|
};
|
|
memoized.cache = new (memoize.Cache || _MapCache_default);
|
|
return memoized;
|
|
}
|
|
memoize.Cache = _MapCache_default;
|
|
var memoize_default = memoize;
|
|
|
|
// ../src/utils/process.ts
|
|
var CHUNK_SIZE = 2000;
|
|
function writeToStderr(data) {
|
|
if (process.stderr.destroyed) {
|
|
return;
|
|
}
|
|
for (let i = 0;i < data.length; i += CHUNK_SIZE) {
|
|
process.stderr.write(data.substring(i, i + CHUNK_SIZE));
|
|
}
|
|
}
|
|
|
|
// ../src/utils/debugFilter.ts
|
|
var parseDebugFilter = memoize_default((filterString) => {
|
|
if (!filterString || filterString.trim() === "") {
|
|
return null;
|
|
}
|
|
const filters = filterString.split(",").map((f) => f.trim()).filter(Boolean);
|
|
if (filters.length === 0) {
|
|
return null;
|
|
}
|
|
const hasExclusive = filters.some((f) => f.startsWith("!"));
|
|
const hasInclusive = filters.some((f) => !f.startsWith("!"));
|
|
if (hasExclusive && hasInclusive) {
|
|
return null;
|
|
}
|
|
const cleanFilters = filters.map((f) => f.replace(/^!/, "").toLowerCase());
|
|
return {
|
|
include: hasExclusive ? [] : cleanFilters,
|
|
exclude: hasExclusive ? cleanFilters : [],
|
|
isExclusive: hasExclusive
|
|
};
|
|
});
|
|
function extractDebugCategories(message) {
|
|
const categories = [];
|
|
const mcpMatch = message.match(/^MCP server ["']([^"']+)["']/);
|
|
if (mcpMatch && mcpMatch[1]) {
|
|
categories.push("mcp");
|
|
categories.push(mcpMatch[1].toLowerCase());
|
|
} else {
|
|
const prefixMatch = message.match(/^([^:[]+):/);
|
|
if (prefixMatch && prefixMatch[1]) {
|
|
categories.push(prefixMatch[1].trim().toLowerCase());
|
|
}
|
|
}
|
|
const bracketMatch = message.match(/^\[([^\]]+)]/);
|
|
if (bracketMatch && bracketMatch[1]) {
|
|
categories.push(bracketMatch[1].trim().toLowerCase());
|
|
}
|
|
if (message.toLowerCase().includes("statsig event:")) {
|
|
categories.push("statsig");
|
|
}
|
|
const secondaryMatch = message.match(/:\s*([^:]+?)(?:\s+(?:type|mode|status|event))?:/);
|
|
if (secondaryMatch && secondaryMatch[1]) {
|
|
const secondary = secondaryMatch[1].trim().toLowerCase();
|
|
if (secondary.length < 30 && !secondary.includes(" ")) {
|
|
categories.push(secondary);
|
|
}
|
|
}
|
|
return Array.from(new Set(categories));
|
|
}
|
|
function shouldShowDebugCategories(categories, filter) {
|
|
if (!filter) {
|
|
return true;
|
|
}
|
|
if (categories.length === 0) {
|
|
return false;
|
|
}
|
|
if (filter.isExclusive) {
|
|
return !categories.some((cat) => filter.exclude.includes(cat));
|
|
} else {
|
|
return categories.some((cat) => filter.include.includes(cat));
|
|
}
|
|
}
|
|
function shouldShowDebugMessage(message, filter) {
|
|
if (!filter) {
|
|
return true;
|
|
}
|
|
const categories = extractDebugCategories(message);
|
|
return shouldShowDebugCategories(categories, filter);
|
|
}
|
|
|
|
// ../src/utils/envUtils.ts
|
|
import { join } from "path";
|
|
import { homedir } from "os";
|
|
function getClaudeConfigHomeDir() {
|
|
return process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
|
|
}
|
|
function isEnvTruthy(envVar) {
|
|
if (!envVar)
|
|
return false;
|
|
if (typeof envVar === "boolean")
|
|
return envVar;
|
|
const normalizedValue = envVar.toLowerCase().trim();
|
|
return ["1", "true", "yes", "on"].includes(normalizedValue);
|
|
}
|
|
|
|
// ../src/utils/debug.ts
|
|
import { dirname, join as join2 } from "path";
|
|
|
|
// ../src/bootstrap/state.ts
|
|
import { cwd } from "process";
|
|
import { realpathSync } from "fs";
|
|
import { randomUUID } from "crypto";
|
|
|
|
// ../src/bootstrap/envValidators.ts
|
|
var MAX_OUTPUT_LENGTH = 150000;
|
|
var DEFAULT_MAX_OUTPUT_LENGTH = 30000;
|
|
function createMaxOutputLengthValidator(name) {
|
|
return {
|
|
name,
|
|
default: DEFAULT_MAX_OUTPUT_LENGTH,
|
|
validate: (value) => {
|
|
if (!value) {
|
|
return {
|
|
effective: DEFAULT_MAX_OUTPUT_LENGTH,
|
|
status: "valid"
|
|
};
|
|
}
|
|
const parsed = parseInt(value, 10);
|
|
if (isNaN(parsed) || parsed <= 0) {
|
|
return {
|
|
effective: DEFAULT_MAX_OUTPUT_LENGTH,
|
|
status: "invalid",
|
|
message: `Invalid value "${value}" (using default: ${DEFAULT_MAX_OUTPUT_LENGTH})`
|
|
};
|
|
}
|
|
if (parsed > MAX_OUTPUT_LENGTH) {
|
|
return {
|
|
effective: MAX_OUTPUT_LENGTH,
|
|
status: "capped",
|
|
message: `Capped from ${parsed} to ${MAX_OUTPUT_LENGTH}`
|
|
};
|
|
}
|
|
return { effective: parsed, status: "valid" };
|
|
}
|
|
};
|
|
}
|
|
var bashMaxOutputLengthValidator = createMaxOutputLengthValidator("BASH_MAX_OUTPUT_LENGTH");
|
|
var taskMaxOutputLengthValidator = createMaxOutputLengthValidator("TASK_MAX_OUTPUT_LENGTH");
|
|
var maxOutputTokensValidator = {
|
|
name: "CLAUDE_CODE_MAX_OUTPUT_TOKENS",
|
|
default: 32000,
|
|
validate: (value) => {
|
|
const MAX_OUTPUT_TOKENS = 64000;
|
|
const DEFAULT_MAX_OUTPUT_TOKENS = 32000;
|
|
if (!value) {
|
|
return { effective: DEFAULT_MAX_OUTPUT_TOKENS, status: "valid" };
|
|
}
|
|
const parsed = parseInt(value, 10);
|
|
if (isNaN(parsed) || parsed <= 0) {
|
|
return {
|
|
effective: DEFAULT_MAX_OUTPUT_TOKENS,
|
|
status: "invalid",
|
|
message: `Invalid value "${value}" (using default: ${DEFAULT_MAX_OUTPUT_TOKENS})`
|
|
};
|
|
}
|
|
if (parsed > MAX_OUTPUT_TOKENS) {
|
|
return {
|
|
effective: MAX_OUTPUT_TOKENS,
|
|
status: "capped",
|
|
message: `Capped from ${parsed} to ${MAX_OUTPUT_TOKENS}`
|
|
};
|
|
}
|
|
return { effective: parsed, status: "valid" };
|
|
}
|
|
};
|
|
|
|
// ../src/constants/betas.ts
|
|
var CLAUDE_CODE_20250219_BETA_HEADER = "claude-code-20250219";
|
|
var INTERLEAVED_THINKING_BETA_HEADER = "interleaved-thinking-2025-05-14";
|
|
var FINE_GRAINED_TOOL_STREAMING_BETA_HEADER = "fine-grained-tool-streaming-2025-05-14";
|
|
var SONNET_1M_BETA_HEADER = "context-1m-2025-08-07";
|
|
var CONTEXT_MANAGEMENT_BETA_HEADER = "context-management-2025-06-27";
|
|
var TOOL_EXAMPLES_BETA_HEADER = "tool-examples-2025-10-29";
|
|
var TOOL_SEARCH_BETA_HEADER_3P = "tool-search-tool-2025-10-19";
|
|
var BEDROCK_EXTRA_PARAMS_HEADERS = new Set([
|
|
INTERLEAVED_THINKING_BETA_HEADER,
|
|
SONNET_1M_BETA_HEADER,
|
|
TOOL_SEARCH_BETA_HEADER_3P,
|
|
TOOL_EXAMPLES_BETA_HEADER
|
|
]);
|
|
var VERTEX_COUNT_TOKENS_ALLOWED_BETAS = new Set([
|
|
CLAUDE_CODE_20250219_BETA_HEADER,
|
|
INTERLEAVED_THINKING_BETA_HEADER,
|
|
FINE_GRAINED_TOOL_STREAMING_BETA_HEADER,
|
|
CONTEXT_MANAGEMENT_BETA_HEADER
|
|
]);
|
|
|
|
// ../src/bootstrap/state.ts
|
|
function getInitialState() {
|
|
let resolvedCwd = "";
|
|
if (typeof process !== "undefined" && typeof process.cwd === "function") {
|
|
resolvedCwd = realpathSync(cwd());
|
|
}
|
|
return {
|
|
originalCwd: resolvedCwd,
|
|
totalCostUSD: 0,
|
|
totalAPIDuration: 0,
|
|
totalAPIDurationWithoutRetries: 0,
|
|
totalToolDuration: 0,
|
|
startTime: Date.now(),
|
|
lastInteractionTime: Date.now(),
|
|
totalLinesAdded: 0,
|
|
totalLinesRemoved: 0,
|
|
hasUnknownModelCost: false,
|
|
cwd: resolvedCwd,
|
|
modelUsage: {},
|
|
mainLoopModelOverride: undefined,
|
|
initialMainLoopModel: null,
|
|
modelStrings: null,
|
|
isInteractive: false,
|
|
clientType: "cli",
|
|
sessionIngressToken: undefined,
|
|
oauthTokenFromFd: undefined,
|
|
apiKeyFromFd: undefined,
|
|
flagSettingsPath: undefined,
|
|
allowedSettingSources: [
|
|
"userSettings",
|
|
"projectSettings",
|
|
"localSettings",
|
|
"flagSettings",
|
|
"policySettings"
|
|
],
|
|
meter: null,
|
|
sessionCounter: null,
|
|
locCounter: null,
|
|
prCounter: null,
|
|
commitCounter: null,
|
|
costCounter: null,
|
|
tokenCounter: null,
|
|
codeEditToolDecisionCounter: null,
|
|
activeTimeCounter: null,
|
|
sessionId: randomUUID(),
|
|
loggerProvider: null,
|
|
eventLogger: null,
|
|
meterProvider: null,
|
|
tracerProvider: null,
|
|
agentColorMap: new Map,
|
|
agentColorIndex: 0,
|
|
envVarValidators: [bashMaxOutputLengthValidator, maxOutputTokensValidator],
|
|
lastAPIRequest: null,
|
|
inMemoryErrorLog: [],
|
|
inlinePlugins: [],
|
|
sessionBypassPermissionsMode: false,
|
|
sessionPersistenceDisabled: false,
|
|
hasExitedPlanMode: false,
|
|
needsPlanModeExitAttachment: false,
|
|
hasExitedDelegateMode: false,
|
|
needsDelegateModeExitAttachment: false,
|
|
lspRecommendationShownThisSession: false,
|
|
initJsonSchema: null,
|
|
registeredHooks: null,
|
|
planSlugCache: new Map,
|
|
teleportedSessionInfo: null,
|
|
invokedSkills: new Map,
|
|
slowOperations: [],
|
|
sdkBetas: undefined
|
|
};
|
|
}
|
|
var STATE = getInitialState();
|
|
function getSessionId() {
|
|
return STATE.sessionId;
|
|
}
|
|
var MAX_SLOW_OPERATIONS = 10;
|
|
var SLOW_OPERATION_TTL_MS = 1e4;
|
|
function addSlowOperation(operation, durationMs) {
|
|
if (true)
|
|
return;
|
|
const now = Date.now();
|
|
STATE.slowOperations = STATE.slowOperations.filter((op) => now - op.timestamp < SLOW_OPERATION_TTL_MS);
|
|
STATE.slowOperations.push({ operation, durationMs, timestamp: now });
|
|
if (STATE.slowOperations.length > MAX_SLOW_OPERATIONS) {
|
|
STATE.slowOperations = STATE.slowOperations.slice(-MAX_SLOW_OPERATIONS);
|
|
}
|
|
}
|
|
|
|
// ../src/utils/bufferedWriter.ts
|
|
function createBufferedWriter({
|
|
writeFn,
|
|
flushIntervalMs = 1000,
|
|
maxBufferSize = 100,
|
|
immediateMode = false
|
|
}) {
|
|
let buffer = [];
|
|
let flushTimer = null;
|
|
function clearTimer() {
|
|
if (flushTimer) {
|
|
clearTimeout(flushTimer);
|
|
flushTimer = null;
|
|
}
|
|
}
|
|
function flush() {
|
|
if (buffer.length === 0)
|
|
return;
|
|
writeFn(buffer.join(""));
|
|
buffer = [];
|
|
clearTimer();
|
|
}
|
|
function scheduleFlush() {
|
|
if (!flushTimer) {
|
|
flushTimer = setTimeout(flush, flushIntervalMs);
|
|
}
|
|
}
|
|
return {
|
|
write(content) {
|
|
if (immediateMode) {
|
|
writeFn(content);
|
|
return;
|
|
}
|
|
buffer.push(content);
|
|
scheduleFlush();
|
|
if (buffer.length >= maxBufferSize) {
|
|
flush();
|
|
}
|
|
},
|
|
flush,
|
|
dispose() {
|
|
flush();
|
|
}
|
|
};
|
|
}
|
|
|
|
// ../src/utils/cleanupRegistry.ts
|
|
var cleanupFunctions = new Set;
|
|
function registerCleanup(cleanupFn) {
|
|
cleanupFunctions.add(cleanupFn);
|
|
return () => cleanupFunctions.delete(cleanupFn);
|
|
}
|
|
|
|
// ../src/utils/slowOperations.ts
|
|
var SLOW_OPERATION_THRESHOLD_MS = Infinity;
|
|
function describeValue(value) {
|
|
if (value === null)
|
|
return "null";
|
|
if (value === undefined)
|
|
return "undefined";
|
|
if (Array.isArray(value))
|
|
return `Array[${value.length}]`;
|
|
if (typeof value === "object") {
|
|
const keys = Object.keys(value);
|
|
return `Object{${keys.length} keys}`;
|
|
}
|
|
if (typeof value === "string")
|
|
return `string(${value.length} chars)`;
|
|
return typeof value;
|
|
}
|
|
function withSlowLogging(operation, fn) {
|
|
const startTime = performance.now();
|
|
try {
|
|
return fn();
|
|
} finally {
|
|
const duration = performance.now() - startTime;
|
|
if (duration > SLOW_OPERATION_THRESHOLD_MS) {
|
|
logForDebugging(`[SLOW OPERATION DETECTED] ${operation} (${duration.toFixed(1)}ms)`);
|
|
addSlowOperation(operation, duration);
|
|
}
|
|
}
|
|
}
|
|
function jsonStringify(value, replacer, space) {
|
|
const description = describeValue(value);
|
|
return withSlowLogging(`JSON.stringify(${description})`, () => JSON.stringify(value, replacer, space));
|
|
}
|
|
var jsonParse = (text, reviver) => {
|
|
const length = typeof text === "string" ? text.length : 0;
|
|
return withSlowLogging(`JSON.parse(${length} chars)`, () => JSON.parse(text, reviver));
|
|
};
|
|
|
|
// ../src/utils/debug.ts
|
|
var isDebugMode = memoize_default(() => {
|
|
return isEnvTruthy(process.env.DEBUG) || isEnvTruthy(process.env.DEBUG_SDK) || process.argv.includes("--debug") || process.argv.includes("-d") || isDebugToStdErr() || process.argv.some((arg) => arg.startsWith("--debug="));
|
|
});
|
|
var getDebugFilter = memoize_default(() => {
|
|
const debugArg = process.argv.find((arg) => arg.startsWith("--debug="));
|
|
if (!debugArg) {
|
|
return null;
|
|
}
|
|
const filterPattern = debugArg.substring("--debug=".length);
|
|
return parseDebugFilter(filterPattern);
|
|
});
|
|
var isDebugToStdErr = memoize_default(() => {
|
|
return process.argv.includes("--debug-to-stderr") || process.argv.includes("-d2e");
|
|
});
|
|
function shouldLogDebugMessage(message) {
|
|
if (false) {}
|
|
if (typeof process === "undefined" || typeof process.versions === "undefined" || typeof process.versions.node === "undefined") {
|
|
return false;
|
|
}
|
|
const filter = getDebugFilter();
|
|
return shouldShowDebugMessage(message, filter);
|
|
}
|
|
var hasFormattedOutput = false;
|
|
var debugWriter = null;
|
|
function getDebugWriter() {
|
|
if (!debugWriter) {
|
|
debugWriter = createBufferedWriter({
|
|
writeFn: (content) => {
|
|
const path = getDebugLogPath();
|
|
if (!getFsImplementation().existsSync(dirname(path))) {
|
|
getFsImplementation().mkdirSync(dirname(path));
|
|
}
|
|
getFsImplementation().appendFileSync(path, content);
|
|
updateLatestDebugLogSymlink();
|
|
},
|
|
flushIntervalMs: 1000,
|
|
maxBufferSize: 100,
|
|
immediateMode: isDebugMode()
|
|
});
|
|
registerCleanup(async () => debugWriter?.dispose());
|
|
}
|
|
return debugWriter;
|
|
}
|
|
function logForDebugging(message, { level } = {
|
|
level: "debug"
|
|
}) {
|
|
if (!shouldLogDebugMessage(message)) {
|
|
return;
|
|
}
|
|
if (hasFormattedOutput && message.includes(`
|
|
`)) {
|
|
message = jsonStringify(message);
|
|
}
|
|
const timestamp = new Date().toISOString();
|
|
const output = `${timestamp} [${level.toUpperCase()}] ${message.trim()}
|
|
`;
|
|
if (isDebugToStdErr()) {
|
|
writeToStderr(output);
|
|
return;
|
|
}
|
|
getDebugWriter().write(output);
|
|
}
|
|
function getDebugLogPath() {
|
|
return process.env.CLAUDE_CODE_DEBUG_LOGS_DIR ?? join2(getClaudeConfigHomeDir(), "debug", `${getSessionId()}.txt`);
|
|
}
|
|
var updateLatestDebugLogSymlink = memoize_default(() => {
|
|
if (process.argv[2] === "--ripgrep") {
|
|
return;
|
|
}
|
|
try {
|
|
const debugLogPath = getDebugLogPath();
|
|
const debugLogsDir = dirname(debugLogPath);
|
|
const latestSymlinkPath = join2(debugLogsDir, "latest");
|
|
if (!getFsImplementation().existsSync(debugLogsDir)) {
|
|
getFsImplementation().mkdirSync(debugLogsDir);
|
|
}
|
|
if (getFsImplementation().existsSync(latestSymlinkPath)) {
|
|
try {
|
|
getFsImplementation().unlinkSync(latestSymlinkPath);
|
|
} catch {}
|
|
}
|
|
getFsImplementation().symlinkSync(debugLogPath, latestSymlinkPath);
|
|
} catch {}
|
|
});
|
|
|
|
// ../src/utils/fsOperations.ts
|
|
function withSlowLogging2(operation, fn) {
|
|
const startTime = performance.now();
|
|
try {
|
|
return fn();
|
|
} finally {
|
|
const duration = performance.now() - startTime;
|
|
if (duration > SLOW_OPERATION_THRESHOLD_MS) {
|
|
logForDebugging(`[SLOW OPERATION DETECTED] fs.${operation} (${duration.toFixed(1)}ms)`);
|
|
addSlowOperation(`fs.${operation}`, duration);
|
|
}
|
|
}
|
|
}
|
|
var NodeFsOperations = {
|
|
cwd() {
|
|
return process.cwd();
|
|
},
|
|
existsSync(fsPath) {
|
|
return withSlowLogging2(`existsSync(${fsPath})`, () => fs.existsSync(fsPath));
|
|
},
|
|
async stat(fsPath) {
|
|
return statPromise(fsPath);
|
|
},
|
|
statSync(fsPath) {
|
|
return withSlowLogging2(`statSync(${fsPath})`, () => fs.statSync(fsPath));
|
|
},
|
|
lstatSync(fsPath) {
|
|
return withSlowLogging2(`lstatSync(${fsPath})`, () => fs.lstatSync(fsPath));
|
|
},
|
|
readFileSync(fsPath, options) {
|
|
return withSlowLogging2(`readFileSync(${fsPath})`, () => fs.readFileSync(fsPath, { encoding: options.encoding }));
|
|
},
|
|
readFileBytesSync(fsPath) {
|
|
return withSlowLogging2(`readFileBytesSync(${fsPath})`, () => fs.readFileSync(fsPath));
|
|
},
|
|
readSync(fsPath, options) {
|
|
return withSlowLogging2(`readSync(${fsPath}, ${options.length} bytes)`, () => {
|
|
let fd = undefined;
|
|
try {
|
|
fd = fs.openSync(fsPath, "r");
|
|
const buffer = Buffer.alloc(options.length);
|
|
const bytesRead = fs.readSync(fd, buffer, 0, options.length, 0);
|
|
return { buffer, bytesRead };
|
|
} finally {
|
|
if (fd)
|
|
fs.closeSync(fd);
|
|
}
|
|
});
|
|
},
|
|
appendFileSync(path, data, options) {
|
|
return withSlowLogging2(`appendFileSync(${path}, ${data.length} chars)`, () => {
|
|
if (!fs.existsSync(path) && options?.mode !== undefined) {
|
|
const fd = fs.openSync(path, "a", options.mode);
|
|
try {
|
|
fs.appendFileSync(fd, data);
|
|
} finally {
|
|
fs.closeSync(fd);
|
|
}
|
|
} else {
|
|
fs.appendFileSync(path, data);
|
|
}
|
|
});
|
|
},
|
|
copyFileSync(src, dest) {
|
|
return withSlowLogging2(`copyFileSync(${src} → ${dest})`, () => fs.copyFileSync(src, dest));
|
|
},
|
|
unlinkSync(path) {
|
|
return withSlowLogging2(`unlinkSync(${path})`, () => fs.unlinkSync(path));
|
|
},
|
|
renameSync(oldPath, newPath) {
|
|
return withSlowLogging2(`renameSync(${oldPath} → ${newPath})`, () => fs.renameSync(oldPath, newPath));
|
|
},
|
|
linkSync(target, path) {
|
|
return withSlowLogging2(`linkSync(${target} → ${path})`, () => fs.linkSync(target, path));
|
|
},
|
|
symlinkSync(target, path) {
|
|
return withSlowLogging2(`symlinkSync(${target} → ${path})`, () => fs.symlinkSync(target, path));
|
|
},
|
|
readlinkSync(path) {
|
|
return withSlowLogging2(`readlinkSync(${path})`, () => fs.readlinkSync(path));
|
|
},
|
|
realpathSync(path) {
|
|
return withSlowLogging2(`realpathSync(${path})`, () => fs.realpathSync(path));
|
|
},
|
|
mkdirSync(dirPath, options) {
|
|
return withSlowLogging2(`mkdirSync(${dirPath})`, () => {
|
|
if (!fs.existsSync(dirPath)) {
|
|
const mkdirOptions = {
|
|
recursive: true
|
|
};
|
|
if (options?.mode !== undefined) {
|
|
mkdirOptions.mode = options.mode;
|
|
}
|
|
fs.mkdirSync(dirPath, mkdirOptions);
|
|
}
|
|
});
|
|
},
|
|
readdirSync(dirPath) {
|
|
return withSlowLogging2(`readdirSync(${dirPath})`, () => fs.readdirSync(dirPath, { withFileTypes: true }));
|
|
},
|
|
readdirStringSync(dirPath) {
|
|
return withSlowLogging2(`readdirStringSync(${dirPath})`, () => fs.readdirSync(dirPath));
|
|
},
|
|
isDirEmptySync(dirPath) {
|
|
return withSlowLogging2(`isDirEmptySync(${dirPath})`, () => {
|
|
const files = this.readdirSync(dirPath);
|
|
return files.length === 0;
|
|
});
|
|
},
|
|
rmdirSync(dirPath) {
|
|
return withSlowLogging2(`rmdirSync(${dirPath})`, () => fs.rmdirSync(dirPath));
|
|
},
|
|
rmSync(path, options) {
|
|
return withSlowLogging2(`rmSync(${path})`, () => fs.rmSync(path, options));
|
|
},
|
|
createWriteStream(path) {
|
|
return fs.createWriteStream(path);
|
|
}
|
|
};
|
|
var activeFs = NodeFsOperations;
|
|
function getFsImplementation() {
|
|
return activeFs;
|
|
}
|
|
|
|
// ../src/entrypoints/sdk/coreTypes.ts
|
|
var HOOK_EVENTS = [
|
|
"PreToolUse",
|
|
"PostToolUse",
|
|
"PostToolUseFailure",
|
|
"Notification",
|
|
"UserPromptSubmit",
|
|
"SessionStart",
|
|
"SessionEnd",
|
|
"Stop",
|
|
"SubagentStart",
|
|
"SubagentStop",
|
|
"PreCompact",
|
|
"PermissionRequest"
|
|
];
|
|
var EXIT_REASONS = [
|
|
"clear",
|
|
"logout",
|
|
"prompt_input_exit",
|
|
"other",
|
|
"bypass_permissions_disabled"
|
|
];
|
|
// ../src/entrypoints/agentSdkTypes.ts
|
|
class AbortError extends Error {
|
|
}
|
|
|
|
// ../src/utils/bundledMode.ts
|
|
function isRunningWithBun() {
|
|
return process.versions.bun !== undefined;
|
|
}
|
|
|
|
// ../src/utils/sdkDebug.ts
|
|
import { randomUUID as randomUUID2 } from "crypto";
|
|
import { appendFileSync as appendFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
|
|
import { join as join3 } from "path";
|
|
var debugFilePath = null;
|
|
var initialized = false;
|
|
function getOrCreateDebugFile() {
|
|
if (initialized) {
|
|
return debugFilePath;
|
|
}
|
|
initialized = true;
|
|
if (!process.env.DEBUG_CLAUDE_AGENT_SDK) {
|
|
return null;
|
|
}
|
|
const debugDir = join3(getClaudeConfigHomeDir(), "debug");
|
|
debugFilePath = join3(debugDir, `sdk-${randomUUID2()}.txt`);
|
|
if (!existsSync2(debugDir)) {
|
|
mkdirSync2(debugDir, { recursive: true });
|
|
}
|
|
process.stderr.write(`SDK debug logs: ${debugFilePath}
|
|
`);
|
|
return debugFilePath;
|
|
}
|
|
function logForSdkDebugging(message) {
|
|
const path = getOrCreateDebugFile();
|
|
if (!path) {
|
|
return;
|
|
}
|
|
const timestamp = new Date().toISOString();
|
|
const output = `${timestamp} ${message}
|
|
`;
|
|
appendFileSync2(path, output);
|
|
}
|
|
|
|
// ../src/transport/sandboxUtils.ts
|
|
function mergeSandboxIntoExtraArgs(extraArgs, sandbox) {
|
|
const effectiveExtraArgs = { ...extraArgs };
|
|
if (sandbox) {
|
|
let settingsObj = { sandbox };
|
|
if (effectiveExtraArgs.settings) {
|
|
try {
|
|
const existingSettings = jsonParse(effectiveExtraArgs.settings);
|
|
settingsObj = { ...existingSettings, sandbox };
|
|
} catch {}
|
|
}
|
|
effectiveExtraArgs.settings = jsonStringify(settingsObj);
|
|
}
|
|
return effectiveExtraArgs;
|
|
}
|
|
|
|
// ../src/transport/ProcessTransport.ts
|
|
class ProcessTransport {
|
|
options;
|
|
process;
|
|
processStdin;
|
|
processStdout;
|
|
ready = false;
|
|
abortController;
|
|
exitError;
|
|
exitListeners = [];
|
|
processExitHandler;
|
|
abortHandler;
|
|
constructor(options) {
|
|
this.options = options;
|
|
this.abortController = options.abortController || createAbortController();
|
|
this.initialize();
|
|
}
|
|
getDefaultExecutable() {
|
|
return isRunningWithBun() ? "bun" : "node";
|
|
}
|
|
spawnLocalProcess(spawnOptions) {
|
|
const { command, args, cwd: cwd2, env, signal } = spawnOptions;
|
|
const stderrMode = env.DEBUG_CLAUDE_AGENT_SDK || this.options.stderr ? "pipe" : "ignore";
|
|
const childProcess = spawn(command, args, {
|
|
cwd: cwd2,
|
|
stdio: ["pipe", "pipe", stderrMode],
|
|
signal,
|
|
env,
|
|
windowsHide: true
|
|
});
|
|
if (env.DEBUG_CLAUDE_AGENT_SDK || this.options.stderr) {
|
|
childProcess.stderr.on("data", (data) => {
|
|
const message = data.toString();
|
|
logForSdkDebugging(message);
|
|
if (this.options.stderr) {
|
|
this.options.stderr(message);
|
|
}
|
|
});
|
|
}
|
|
const mappedProcess = {
|
|
stdin: childProcess.stdin,
|
|
stdout: childProcess.stdout,
|
|
get killed() {
|
|
return childProcess.killed;
|
|
},
|
|
get exitCode() {
|
|
return childProcess.exitCode;
|
|
},
|
|
kill: childProcess.kill.bind(childProcess),
|
|
on: childProcess.on.bind(childProcess),
|
|
once: childProcess.once.bind(childProcess),
|
|
off: childProcess.off.bind(childProcess)
|
|
};
|
|
return mappedProcess;
|
|
}
|
|
initialize() {
|
|
try {
|
|
const {
|
|
additionalDirectories = [],
|
|
betas,
|
|
cwd: cwd2,
|
|
executable = this.getDefaultExecutable(),
|
|
executableArgs = [],
|
|
extraArgs = {},
|
|
pathToClaudeCodeExecutable,
|
|
env = { ...process.env },
|
|
maxThinkingTokens,
|
|
maxTurns,
|
|
maxBudgetUsd,
|
|
model,
|
|
fallbackModel,
|
|
jsonSchema,
|
|
permissionMode,
|
|
allowDangerouslySkipPermissions,
|
|
permissionPromptToolName,
|
|
continueConversation,
|
|
resume,
|
|
settingSources,
|
|
allowedTools = [],
|
|
disallowedTools = [],
|
|
tools,
|
|
mcpServers,
|
|
strictMcpConfig,
|
|
canUseTool,
|
|
includePartialMessages,
|
|
plugins,
|
|
sandbox
|
|
} = this.options;
|
|
const args = [
|
|
"--output-format",
|
|
"stream-json",
|
|
"--verbose",
|
|
"--input-format",
|
|
"stream-json"
|
|
];
|
|
if (maxThinkingTokens !== undefined) {
|
|
args.push("--max-thinking-tokens", maxThinkingTokens.toString());
|
|
}
|
|
if (maxTurns)
|
|
args.push("--max-turns", maxTurns.toString());
|
|
if (maxBudgetUsd !== undefined) {
|
|
args.push("--max-budget-usd", maxBudgetUsd.toString());
|
|
}
|
|
if (model)
|
|
args.push("--model", model);
|
|
if (betas && betas.length > 0) {
|
|
args.push("--betas", betas.join(","));
|
|
}
|
|
if (jsonSchema) {
|
|
args.push("--json-schema", jsonStringify(jsonSchema));
|
|
}
|
|
if (env.DEBUG_CLAUDE_AGENT_SDK) {
|
|
args.push("--debug-to-stderr");
|
|
}
|
|
if (canUseTool) {
|
|
if (permissionPromptToolName) {
|
|
throw new Error("canUseTool callback cannot be used with permissionPromptToolName. Please use one or the other.");
|
|
}
|
|
args.push("--permission-prompt-tool", "stdio");
|
|
} else if (permissionPromptToolName) {
|
|
args.push("--permission-prompt-tool", permissionPromptToolName);
|
|
}
|
|
if (continueConversation)
|
|
args.push("--continue");
|
|
if (resume)
|
|
args.push("--resume", resume);
|
|
if (allowedTools.length > 0) {
|
|
args.push("--allowedTools", allowedTools.join(","));
|
|
}
|
|
if (disallowedTools.length > 0) {
|
|
args.push("--disallowedTools", disallowedTools.join(","));
|
|
}
|
|
if (tools !== undefined) {
|
|
if (Array.isArray(tools)) {
|
|
if (tools.length === 0) {
|
|
args.push("--tools", "");
|
|
} else {
|
|
args.push("--tools", tools.join(","));
|
|
}
|
|
} else {
|
|
args.push("--tools", "default");
|
|
}
|
|
}
|
|
if (mcpServers && Object.keys(mcpServers).length > 0) {
|
|
args.push("--mcp-config", jsonStringify({ mcpServers }));
|
|
}
|
|
if (settingSources) {
|
|
args.push("--setting-sources", settingSources.join(","));
|
|
}
|
|
if (strictMcpConfig) {
|
|
args.push("--strict-mcp-config");
|
|
}
|
|
if (permissionMode) {
|
|
args.push("--permission-mode", permissionMode);
|
|
}
|
|
if (allowDangerouslySkipPermissions) {
|
|
args.push("--allow-dangerously-skip-permissions");
|
|
}
|
|
if (fallbackModel) {
|
|
if (model && fallbackModel === model) {
|
|
throw new Error("Fallback model cannot be the same as the main model. Please specify a different model for fallbackModel option.");
|
|
}
|
|
args.push("--fallback-model", fallbackModel);
|
|
}
|
|
if (includePartialMessages) {
|
|
args.push("--include-partial-messages");
|
|
}
|
|
for (const dir of additionalDirectories) {
|
|
args.push("--add-dir", dir);
|
|
}
|
|
if (plugins && plugins.length > 0) {
|
|
for (const plugin of plugins) {
|
|
if (plugin.type === "local") {
|
|
args.push("--plugin-dir", plugin.path);
|
|
} else {
|
|
throw new Error(`Unsupported plugin type: ${plugin.type}`);
|
|
}
|
|
}
|
|
}
|
|
if (this.options.forkSession) {
|
|
args.push("--fork-session");
|
|
}
|
|
if (this.options.resumeSessionAt) {
|
|
args.push("--resume-session-at", this.options.resumeSessionAt);
|
|
}
|
|
if (this.options.persistSession === false) {
|
|
args.push("--no-session-persistence");
|
|
}
|
|
const effectiveExtraArgs = mergeSandboxIntoExtraArgs(extraArgs ?? {}, sandbox);
|
|
for (const [flag, value] of Object.entries(effectiveExtraArgs)) {
|
|
if (value === null) {
|
|
args.push(`--${flag}`);
|
|
} else {
|
|
args.push(`--${flag}`, value);
|
|
}
|
|
}
|
|
if (!env.CLAUDE_CODE_ENTRYPOINT) {
|
|
env.CLAUDE_CODE_ENTRYPOINT = "sdk-ts";
|
|
}
|
|
delete env.NODE_OPTIONS;
|
|
if (env.DEBUG_CLAUDE_AGENT_SDK) {
|
|
env.DEBUG = "1";
|
|
} else {
|
|
delete env.DEBUG;
|
|
}
|
|
const isNative = isNativeBinary(pathToClaudeCodeExecutable);
|
|
const spawnCommand = isNative ? pathToClaudeCodeExecutable : executable;
|
|
const spawnArgs = isNative ? [...executableArgs, ...args] : [...executableArgs, pathToClaudeCodeExecutable, ...args];
|
|
const spawnOptions = {
|
|
command: spawnCommand,
|
|
args: spawnArgs,
|
|
cwd: cwd2,
|
|
env,
|
|
signal: this.abortController.signal
|
|
};
|
|
if (this.options.spawnClaudeCodeProcess) {
|
|
logForSdkDebugging(`Spawning Claude Code (custom): ${spawnCommand} ${spawnArgs.join(" ")}`);
|
|
this.process = this.options.spawnClaudeCodeProcess(spawnOptions);
|
|
} else {
|
|
const fs2 = getFsImplementation();
|
|
if (!fs2.existsSync(pathToClaudeCodeExecutable)) {
|
|
const errorMessage = isNative ? `Claude Code native binary not found at ${pathToClaudeCodeExecutable}. Please ensure Claude Code is installed via native installer or specify a valid path with options.pathToClaudeCodeExecutable.` : `Claude Code executable not found at ${pathToClaudeCodeExecutable}. Is options.pathToClaudeCodeExecutable set?`;
|
|
throw new ReferenceError(errorMessage);
|
|
}
|
|
logForSdkDebugging(`Spawning Claude Code: ${spawnCommand} ${spawnArgs.join(" ")}`);
|
|
this.process = this.spawnLocalProcess(spawnOptions);
|
|
}
|
|
this.processStdin = this.process.stdin;
|
|
this.processStdout = this.process.stdout;
|
|
const cleanup = () => {
|
|
if (this.process && !this.process.killed) {
|
|
this.process.kill("SIGTERM");
|
|
}
|
|
};
|
|
this.processExitHandler = cleanup;
|
|
this.abortHandler = cleanup;
|
|
process.on("exit", this.processExitHandler);
|
|
this.abortController.signal.addEventListener("abort", this.abortHandler);
|
|
this.process.on("error", (error) => {
|
|
this.ready = false;
|
|
if (this.abortController.signal.aborted) {
|
|
this.exitError = new AbortError("Claude Code process aborted by user");
|
|
} else {
|
|
this.exitError = new Error(`Failed to spawn Claude Code process: ${error.message}`);
|
|
logForSdkDebugging(this.exitError.message);
|
|
}
|
|
});
|
|
this.process.on("exit", (code, signal) => {
|
|
this.ready = false;
|
|
if (this.abortController.signal.aborted) {
|
|
this.exitError = new AbortError("Claude Code process aborted by user");
|
|
} else {
|
|
const error = this.getProcessExitError(code, signal);
|
|
if (error) {
|
|
this.exitError = error;
|
|
logForSdkDebugging(error.message);
|
|
}
|
|
}
|
|
});
|
|
this.ready = true;
|
|
} catch (error) {
|
|
this.ready = false;
|
|
throw error;
|
|
}
|
|
}
|
|
getProcessExitError(code, signal) {
|
|
if (code !== 0 && code !== null) {
|
|
return new Error(`Claude Code process exited with code ${code}`);
|
|
} else if (signal) {
|
|
return new Error(`Claude Code process terminated by signal ${signal}`);
|
|
}
|
|
return;
|
|
}
|
|
write(data) {
|
|
if (this.abortController.signal.aborted) {
|
|
throw new AbortError("Operation aborted");
|
|
}
|
|
if (!this.ready || !this.processStdin) {
|
|
throw new Error("ProcessTransport is not ready for writing");
|
|
}
|
|
if (this.process?.killed || this.process?.exitCode !== null) {
|
|
throw new Error("Cannot write to terminated process");
|
|
}
|
|
if (this.exitError) {
|
|
throw new Error(`Cannot write to process that exited with error: ${this.exitError.message}`);
|
|
}
|
|
logForSdkDebugging(`[ProcessTransport] Writing to stdin: ${data.substring(0, 100)}`);
|
|
try {
|
|
const written = this.processStdin.write(data);
|
|
if (!written) {
|
|
logForSdkDebugging("[ProcessTransport] Write buffer full, data queued");
|
|
}
|
|
} catch (error) {
|
|
this.ready = false;
|
|
throw new Error(`Failed to write to process stdin: ${error.message}`);
|
|
}
|
|
}
|
|
close() {
|
|
if (this.processStdin) {
|
|
this.processStdin.end();
|
|
this.processStdin = undefined;
|
|
}
|
|
if (this.abortHandler) {
|
|
this.abortController.signal.removeEventListener("abort", this.abortHandler);
|
|
this.abortHandler = undefined;
|
|
}
|
|
for (const { handler } of this.exitListeners) {
|
|
this.process?.off("exit", handler);
|
|
}
|
|
this.exitListeners = [];
|
|
if (this.process && !this.process.killed) {
|
|
this.process.kill("SIGTERM");
|
|
setTimeout(() => {
|
|
if (this.process && !this.process.killed) {
|
|
this.process.kill("SIGKILL");
|
|
}
|
|
}, 5000);
|
|
}
|
|
this.ready = false;
|
|
if (this.processExitHandler) {
|
|
process.off("exit", this.processExitHandler);
|
|
this.processExitHandler = undefined;
|
|
}
|
|
}
|
|
isReady() {
|
|
return this.ready;
|
|
}
|
|
async* readMessages() {
|
|
if (!this.processStdout) {
|
|
throw new Error("ProcessTransport output stream not available");
|
|
}
|
|
const rl = createInterface({ input: this.processStdout });
|
|
try {
|
|
for await (const line of rl) {
|
|
if (line.trim()) {
|
|
const message = jsonParse(line);
|
|
yield message;
|
|
}
|
|
}
|
|
await this.waitForExit();
|
|
} catch (error) {
|
|
throw error;
|
|
} finally {
|
|
rl.close();
|
|
}
|
|
}
|
|
endInput() {
|
|
if (this.processStdin) {
|
|
this.processStdin.end();
|
|
}
|
|
}
|
|
getInputStream() {
|
|
return this.processStdin;
|
|
}
|
|
onExit(callback) {
|
|
if (!this.process)
|
|
return () => {};
|
|
const handler = (code, signal) => {
|
|
const error = this.getProcessExitError(code, signal);
|
|
callback(error);
|
|
};
|
|
this.process.on("exit", handler);
|
|
this.exitListeners.push({ callback, handler });
|
|
return () => {
|
|
if (this.process) {
|
|
this.process.off("exit", handler);
|
|
}
|
|
const index = this.exitListeners.findIndex((l) => l.handler === handler);
|
|
if (index !== -1) {
|
|
this.exitListeners.splice(index, 1);
|
|
}
|
|
};
|
|
}
|
|
async waitForExit() {
|
|
if (!this.process) {
|
|
if (this.exitError) {
|
|
throw this.exitError;
|
|
}
|
|
return;
|
|
}
|
|
if (this.process.exitCode !== null || this.process.killed) {
|
|
if (this.exitError) {
|
|
throw this.exitError;
|
|
}
|
|
return;
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
const exitHandler = (code, signal) => {
|
|
if (this.abortController.signal.aborted) {
|
|
reject(new AbortError("Operation aborted"));
|
|
return;
|
|
}
|
|
const error = this.getProcessExitError(code, signal);
|
|
if (error) {
|
|
reject(error);
|
|
} else {
|
|
resolve();
|
|
}
|
|
};
|
|
this.process.once("exit", exitHandler);
|
|
const errorHandler = (error) => {
|
|
this.process.off("exit", exitHandler);
|
|
reject(error);
|
|
};
|
|
this.process.once("error", errorHandler);
|
|
this.process.once("exit", () => {
|
|
this.process.off("error", errorHandler);
|
|
});
|
|
});
|
|
}
|
|
}
|
|
function isNativeBinary(executablePath) {
|
|
const jsExtensions = [".js", ".mjs", ".tsx", ".ts", ".jsx"];
|
|
return !jsExtensions.some((ext) => executablePath.endsWith(ext));
|
|
}
|
|
|
|
// ../src/utils/stream.ts
|
|
class Stream {
|
|
returned;
|
|
queue = [];
|
|
readResolve;
|
|
readReject;
|
|
isDone = false;
|
|
hasError;
|
|
started = false;
|
|
constructor(returned) {
|
|
this.returned = returned;
|
|
}
|
|
[Symbol.asyncIterator]() {
|
|
if (this.started) {
|
|
throw new Error("Stream can only be iterated once");
|
|
}
|
|
this.started = true;
|
|
return this;
|
|
}
|
|
next() {
|
|
if (this.queue.length > 0) {
|
|
return Promise.resolve({
|
|
done: false,
|
|
value: this.queue.shift()
|
|
});
|
|
}
|
|
if (this.isDone) {
|
|
return Promise.resolve({ done: true, value: undefined });
|
|
}
|
|
if (this.hasError) {
|
|
return Promise.reject(this.hasError);
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
this.readResolve = resolve;
|
|
this.readReject = reject;
|
|
});
|
|
}
|
|
enqueue(value) {
|
|
if (this.readResolve) {
|
|
const resolve = this.readResolve;
|
|
this.readResolve = undefined;
|
|
this.readReject = undefined;
|
|
resolve({ done: false, value });
|
|
} else {
|
|
this.queue.push(value);
|
|
}
|
|
}
|
|
done() {
|
|
this.isDone = true;
|
|
if (this.readResolve) {
|
|
const resolve = this.readResolve;
|
|
this.readResolve = undefined;
|
|
this.readReject = undefined;
|
|
resolve({ done: true, value: undefined });
|
|
}
|
|
}
|
|
error(error) {
|
|
this.hasError = error;
|
|
if (this.readReject) {
|
|
const reject = this.readReject;
|
|
this.readResolve = undefined;
|
|
this.readReject = undefined;
|
|
reject(error);
|
|
}
|
|
}
|
|
return() {
|
|
this.isDone = true;
|
|
if (this.returned) {
|
|
this.returned();
|
|
}
|
|
return Promise.resolve({ done: true, value: undefined });
|
|
}
|
|
}
|
|
|
|
// ../src/services/mcp/SdkControlTransport.ts
|
|
class SdkControlServerTransport {
|
|
sendMcpMessage;
|
|
isClosed = false;
|
|
constructor(sendMcpMessage) {
|
|
this.sendMcpMessage = sendMcpMessage;
|
|
}
|
|
onclose;
|
|
onerror;
|
|
onmessage;
|
|
async start() {}
|
|
async send(message) {
|
|
if (this.isClosed) {
|
|
throw new Error("Transport is closed");
|
|
}
|
|
this.sendMcpMessage(message);
|
|
}
|
|
async close() {
|
|
if (this.isClosed) {
|
|
return;
|
|
}
|
|
this.isClosed = true;
|
|
this.onclose?.();
|
|
}
|
|
}
|
|
|
|
// ../src/core/Query.ts
|
|
import { randomUUID as randomUUID3 } from "crypto";
|
|
|
|
class Query {
|
|
transport;
|
|
isSingleUserTurn;
|
|
canUseTool;
|
|
hooks;
|
|
abortController;
|
|
jsonSchema;
|
|
initConfig;
|
|
pendingControlResponses = new Map;
|
|
cleanupPerformed = false;
|
|
sdkMessages;
|
|
inputStream = new Stream;
|
|
initialization;
|
|
cancelControllers = new Map;
|
|
hookCallbacks = new Map;
|
|
nextCallbackId = 0;
|
|
sdkMcpTransports = new Map;
|
|
sdkMcpServerInstances = new Map;
|
|
pendingMcpResponses = new Map;
|
|
firstResultReceivedResolve;
|
|
firstResultReceived = false;
|
|
hasBidirectionalNeeds() {
|
|
return this.sdkMcpTransports.size > 0 || this.hooks !== undefined && Object.keys(this.hooks).length > 0 || this.canUseTool !== undefined;
|
|
}
|
|
constructor(transport, isSingleUserTurn, canUseTool, hooks, abortController, sdkMcpServers = new Map, jsonSchema, initConfig) {
|
|
this.transport = transport;
|
|
this.isSingleUserTurn = isSingleUserTurn;
|
|
this.canUseTool = canUseTool;
|
|
this.hooks = hooks;
|
|
this.abortController = abortController;
|
|
this.jsonSchema = jsonSchema;
|
|
this.initConfig = initConfig;
|
|
for (const [name, server] of sdkMcpServers) {
|
|
this.connectSdkMcpServer(name, server);
|
|
}
|
|
this.sdkMessages = this.readSdkMessages();
|
|
this.readMessages();
|
|
this.initialization = this.initialize();
|
|
this.initialization.catch(() => {});
|
|
}
|
|
setError(error) {
|
|
this.inputStream.error(error);
|
|
}
|
|
cleanup(error) {
|
|
if (this.cleanupPerformed)
|
|
return;
|
|
this.cleanupPerformed = true;
|
|
try {
|
|
this.transport.close();
|
|
this.pendingControlResponses.clear();
|
|
this.pendingMcpResponses.clear();
|
|
this.cancelControllers.clear();
|
|
this.hookCallbacks.clear();
|
|
for (const transport of this.sdkMcpTransports.values()) {
|
|
try {
|
|
transport.close();
|
|
} catch {}
|
|
}
|
|
this.sdkMcpTransports.clear();
|
|
if (error) {
|
|
this.inputStream.error(error);
|
|
} else {
|
|
this.inputStream.done();
|
|
}
|
|
} catch (_error) {}
|
|
}
|
|
next(...[value]) {
|
|
return this.sdkMessages.next(...[value]);
|
|
}
|
|
return(value) {
|
|
return this.sdkMessages.return(value);
|
|
}
|
|
throw(e) {
|
|
return this.sdkMessages.throw(e);
|
|
}
|
|
[Symbol.asyncIterator]() {
|
|
return this.sdkMessages;
|
|
}
|
|
[Symbol.asyncDispose]() {
|
|
return this.sdkMessages[Symbol.asyncDispose]();
|
|
}
|
|
async readMessages() {
|
|
try {
|
|
for await (const message of this.transport.readMessages()) {
|
|
if (message.type === "control_response") {
|
|
const handler = this.pendingControlResponses.get(message.response.request_id);
|
|
if (handler) {
|
|
handler(message.response);
|
|
}
|
|
continue;
|
|
} else if (message.type === "control_request") {
|
|
this.handleControlRequest(message);
|
|
continue;
|
|
} else if (message.type === "control_cancel_request") {
|
|
this.handleControlCancelRequest(message);
|
|
continue;
|
|
} else if (message.type === "keep_alive") {
|
|
continue;
|
|
}
|
|
if (message.type === "result") {
|
|
this.firstResultReceived = true;
|
|
if (this.firstResultReceivedResolve) {
|
|
this.firstResultReceivedResolve();
|
|
}
|
|
if (this.isSingleUserTurn) {
|
|
logForDebugging(`[Query.readMessages] First result received for single-turn query, closing stdin`);
|
|
this.transport.endInput();
|
|
}
|
|
}
|
|
this.inputStream.enqueue(message);
|
|
}
|
|
if (this.firstResultReceivedResolve) {
|
|
this.firstResultReceivedResolve();
|
|
}
|
|
this.inputStream.done();
|
|
this.cleanup();
|
|
} catch (error) {
|
|
if (this.firstResultReceivedResolve) {
|
|
this.firstResultReceivedResolve();
|
|
}
|
|
this.inputStream.error(error);
|
|
this.cleanup(error);
|
|
}
|
|
}
|
|
async handleControlRequest(request) {
|
|
const controller = new AbortController;
|
|
this.cancelControllers.set(request.request_id, controller);
|
|
try {
|
|
const response = await this.processControlRequest(request, controller.signal);
|
|
const controlResponse = {
|
|
type: "control_response",
|
|
response: {
|
|
subtype: "success",
|
|
request_id: request.request_id,
|
|
response
|
|
}
|
|
};
|
|
await Promise.resolve(this.transport.write(jsonStringify(controlResponse) + `
|
|
`));
|
|
} catch (error) {
|
|
const controlErrorResponse = {
|
|
type: "control_response",
|
|
response: {
|
|
subtype: "error",
|
|
request_id: request.request_id,
|
|
error: error.message || String(error)
|
|
}
|
|
};
|
|
await Promise.resolve(this.transport.write(jsonStringify(controlErrorResponse) + `
|
|
`));
|
|
} finally {
|
|
this.cancelControllers.delete(request.request_id);
|
|
}
|
|
}
|
|
handleControlCancelRequest(request) {
|
|
const controller = this.cancelControllers.get(request.request_id);
|
|
if (controller) {
|
|
controller.abort();
|
|
this.cancelControllers.delete(request.request_id);
|
|
}
|
|
}
|
|
async processControlRequest(request, signal) {
|
|
if (request.request.subtype === "can_use_tool") {
|
|
if (!this.canUseTool) {
|
|
throw new Error("canUseTool callback is not provided.");
|
|
}
|
|
const result = await this.canUseTool(request.request.tool_name, request.request.input, {
|
|
signal,
|
|
suggestions: request.request.permission_suggestions,
|
|
blockedPath: request.request.blocked_path,
|
|
decisionReason: request.request.decision_reason,
|
|
toolUseID: request.request.tool_use_id,
|
|
agentID: request.request.agent_id
|
|
});
|
|
return {
|
|
...result,
|
|
toolUseID: request.request.tool_use_id
|
|
};
|
|
} else if (request.request.subtype === "hook_callback") {
|
|
const result = await this.handleHookCallbacks(request.request.callback_id, request.request.input, request.request.tool_use_id, signal);
|
|
return result;
|
|
} else if (request.request.subtype === "mcp_message") {
|
|
const mcpRequest = request.request;
|
|
const transport = this.sdkMcpTransports.get(mcpRequest.server_name);
|
|
if (!transport) {
|
|
throw new Error(`SDK MCP server not found: ${mcpRequest.server_name}`);
|
|
}
|
|
if ("method" in mcpRequest.message && "id" in mcpRequest.message && mcpRequest.message.id !== null) {
|
|
const response = await this.handleMcpControlRequest(mcpRequest.server_name, mcpRequest, transport);
|
|
return { mcp_response: response };
|
|
} else {
|
|
if (transport.onmessage) {
|
|
transport.onmessage(mcpRequest.message);
|
|
}
|
|
return { mcp_response: { jsonrpc: "2.0", result: {}, id: 0 } };
|
|
}
|
|
}
|
|
throw new Error("Unsupported control request subtype: " + request.request.subtype);
|
|
}
|
|
async* readSdkMessages() {
|
|
for await (const message of this.inputStream) {
|
|
yield message;
|
|
}
|
|
}
|
|
async initialize() {
|
|
let hooks;
|
|
if (this.hooks) {
|
|
hooks = {};
|
|
for (const [event, matchers] of Object.entries(this.hooks)) {
|
|
if (matchers.length > 0) {
|
|
hooks[event] = matchers.map((matcher) => {
|
|
const callbackIds = [];
|
|
for (const callback of matcher.hooks) {
|
|
const callbackId = `hook_${this.nextCallbackId++}`;
|
|
this.hookCallbacks.set(callbackId, callback);
|
|
callbackIds.push(callbackId);
|
|
}
|
|
return {
|
|
matcher: matcher.matcher,
|
|
hookCallbackIds: callbackIds,
|
|
timeout: matcher.timeout
|
|
};
|
|
});
|
|
}
|
|
}
|
|
}
|
|
const sdkMcpServers = this.sdkMcpTransports.size > 0 ? Array.from(this.sdkMcpTransports.keys()) : undefined;
|
|
const initRequest = {
|
|
subtype: "initialize",
|
|
hooks,
|
|
sdkMcpServers,
|
|
jsonSchema: this.jsonSchema,
|
|
systemPrompt: this.initConfig?.systemPrompt,
|
|
appendSystemPrompt: this.initConfig?.appendSystemPrompt,
|
|
agents: this.initConfig?.agents
|
|
};
|
|
const response = await this.request(initRequest);
|
|
return response.response;
|
|
}
|
|
async interrupt() {
|
|
await this.request({
|
|
subtype: "interrupt"
|
|
});
|
|
}
|
|
async setPermissionMode(mode) {
|
|
await this.request({
|
|
subtype: "set_permission_mode",
|
|
mode
|
|
});
|
|
}
|
|
async setModel(model) {
|
|
await this.request({
|
|
subtype: "set_model",
|
|
model
|
|
});
|
|
}
|
|
async setMaxThinkingTokens(maxThinkingTokens) {
|
|
await this.request({
|
|
subtype: "set_max_thinking_tokens",
|
|
max_thinking_tokens: maxThinkingTokens
|
|
});
|
|
}
|
|
async rewindFiles(userMessageId, options) {
|
|
const response = await this.request({
|
|
subtype: "rewind_files",
|
|
user_message_id: userMessageId,
|
|
dry_run: options?.dryRun
|
|
});
|
|
return response.response;
|
|
}
|
|
async processPendingPermissionRequests(pendingPermissionRequests) {
|
|
for (const request of pendingPermissionRequests) {
|
|
if (request.request.subtype === "can_use_tool") {
|
|
this.handleControlRequest(request).catch(() => {});
|
|
}
|
|
}
|
|
}
|
|
request(request) {
|
|
const requestId = Math.random().toString(36).substring(2, 15);
|
|
const sdkRequest = {
|
|
request_id: requestId,
|
|
type: "control_request",
|
|
request
|
|
};
|
|
return new Promise((resolve, reject) => {
|
|
this.pendingControlResponses.set(requestId, (response) => {
|
|
if (response.subtype === "success") {
|
|
resolve(response);
|
|
} else {
|
|
reject(new Error(response.error));
|
|
if (response.pending_permission_requests) {
|
|
this.processPendingPermissionRequests(response.pending_permission_requests);
|
|
}
|
|
}
|
|
});
|
|
Promise.resolve(this.transport.write(jsonStringify(sdkRequest) + `
|
|
`));
|
|
});
|
|
}
|
|
async supportedCommands() {
|
|
return (await this.initialization).commands;
|
|
}
|
|
async supportedModels() {
|
|
return (await this.initialization).models;
|
|
}
|
|
async mcpServerStatus() {
|
|
const response = await this.request({
|
|
subtype: "mcp_status"
|
|
});
|
|
const mcpStatusResponse = response.response;
|
|
return mcpStatusResponse.mcpServers;
|
|
}
|
|
async setMcpServers(servers) {
|
|
const sdkServers = {};
|
|
const processServers = {};
|
|
for (const [name, config] of Object.entries(servers)) {
|
|
if (config.type === "sdk" && "instance" in config) {
|
|
sdkServers[name] = config.instance;
|
|
} else {
|
|
processServers[name] = config;
|
|
}
|
|
}
|
|
const currentSdkNames = new Set(this.sdkMcpServerInstances.keys());
|
|
const newSdkNames = new Set(Object.keys(sdkServers));
|
|
for (const name of currentSdkNames) {
|
|
if (!newSdkNames.has(name)) {
|
|
await this.disconnectSdkMcpServer(name);
|
|
}
|
|
}
|
|
for (const [name, server] of Object.entries(sdkServers)) {
|
|
if (!currentSdkNames.has(name)) {
|
|
this.connectSdkMcpServer(name, server);
|
|
}
|
|
}
|
|
const sdkServerConfigs = {};
|
|
for (const name of Object.keys(sdkServers)) {
|
|
sdkServerConfigs[name] = { type: "sdk", name };
|
|
}
|
|
const response = await this.request({
|
|
subtype: "mcp_set_servers",
|
|
servers: { ...processServers, ...sdkServerConfigs }
|
|
});
|
|
return response.response;
|
|
}
|
|
async accountInfo() {
|
|
return (await this.initialization).account;
|
|
}
|
|
async streamInput(stream) {
|
|
logForDebugging(`[Query.streamInput] Starting to process input stream`);
|
|
try {
|
|
let messageCount = 0;
|
|
for await (const message of stream) {
|
|
messageCount++;
|
|
logForDebugging(`[Query.streamInput] Processing message ${messageCount}: ${message.type}`);
|
|
if (this.abortController?.signal.aborted)
|
|
break;
|
|
await Promise.resolve(this.transport.write(jsonStringify(message) + `
|
|
`));
|
|
}
|
|
logForDebugging(`[Query.streamInput] Finished processing ${messageCount} messages from input stream`);
|
|
if (messageCount > 0 && this.hasBidirectionalNeeds()) {
|
|
logForDebugging(`[Query.streamInput] Has bidirectional needs, waiting for first result`);
|
|
await this.waitForFirstResult();
|
|
}
|
|
logForDebugging(`[Query] Calling transport.endInput() to close stdin to CLI process`);
|
|
this.transport.endInput();
|
|
} catch (error) {
|
|
if (!(error instanceof AbortError)) {
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
waitForFirstResult() {
|
|
if (this.firstResultReceived) {
|
|
logForDebugging(`[Query.waitForFirstResult] Result already received, returning immediately`);
|
|
return Promise.resolve();
|
|
}
|
|
return new Promise((resolve) => {
|
|
if (this.abortController?.signal.aborted) {
|
|
resolve();
|
|
return;
|
|
}
|
|
this.abortController?.signal.addEventListener("abort", () => resolve(), {
|
|
once: true
|
|
});
|
|
this.firstResultReceivedResolve = resolve;
|
|
});
|
|
}
|
|
handleHookCallbacks(callbackId, input, toolUseID, abortSignal) {
|
|
const callback = this.hookCallbacks.get(callbackId);
|
|
if (!callback) {
|
|
throw new Error(`No hook callback found for ID: ${callbackId}`);
|
|
}
|
|
return callback(input, toolUseID, {
|
|
signal: abortSignal
|
|
});
|
|
}
|
|
connectSdkMcpServer(name, server) {
|
|
const sdkTransport = new SdkControlServerTransport((message) => this.sendMcpServerMessageToCli(name, message));
|
|
this.sdkMcpTransports.set(name, sdkTransport);
|
|
this.sdkMcpServerInstances.set(name, server);
|
|
server.connect(sdkTransport);
|
|
}
|
|
async disconnectSdkMcpServer(name) {
|
|
const transport = this.sdkMcpTransports.get(name);
|
|
if (transport) {
|
|
await transport.close();
|
|
this.sdkMcpTransports.delete(name);
|
|
}
|
|
this.sdkMcpServerInstances.delete(name);
|
|
}
|
|
sendMcpServerMessageToCli(serverName, message) {
|
|
if ("id" in message && message.id !== null && message.id !== undefined) {
|
|
const key = `${serverName}:${message.id}`;
|
|
const pending = this.pendingMcpResponses.get(key);
|
|
if (pending) {
|
|
pending.resolve(message);
|
|
this.pendingMcpResponses.delete(key);
|
|
return;
|
|
}
|
|
}
|
|
const controlRequest = {
|
|
type: "control_request",
|
|
request_id: randomUUID3(),
|
|
request: {
|
|
subtype: "mcp_message",
|
|
server_name: serverName,
|
|
message
|
|
}
|
|
};
|
|
this.transport.write(jsonStringify(controlRequest) + `
|
|
`);
|
|
}
|
|
handleMcpControlRequest(serverName, mcpRequest, transport) {
|
|
const messageId = "id" in mcpRequest.message ? mcpRequest.message.id : null;
|
|
const key = `${serverName}:${messageId}`;
|
|
return new Promise((resolve, reject) => {
|
|
const cleanup = () => {
|
|
this.pendingMcpResponses.delete(key);
|
|
};
|
|
const resolveAndCleanup = (response) => {
|
|
cleanup();
|
|
resolve(response);
|
|
};
|
|
const rejectAndCleanup = (error) => {
|
|
cleanup();
|
|
reject(error);
|
|
};
|
|
this.pendingMcpResponses.set(key, {
|
|
resolve: resolveAndCleanup,
|
|
reject: rejectAndCleanup
|
|
});
|
|
if (transport.onmessage) {
|
|
transport.onmessage(mcpRequest.message);
|
|
} else {
|
|
cleanup();
|
|
reject(new Error("No message handler registered"));
|
|
return;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
// ../src/core/Session.ts
|
|
import { join as join4 } from "path";
|
|
import { fileURLToPath } from "url";
|
|
class SessionImpl {
|
|
closed = false;
|
|
inputStream;
|
|
query;
|
|
queryIterator = null;
|
|
abortController;
|
|
_sessionId = null;
|
|
get sessionId() {
|
|
if (this._sessionId === null) {
|
|
throw new Error("Session ID not available until after receiving messages");
|
|
}
|
|
return this._sessionId;
|
|
}
|
|
constructor(options) {
|
|
if (options.resume) {
|
|
this._sessionId = options.resume;
|
|
}
|
|
this.inputStream = new Stream;
|
|
let pathToClaudeCodeExecutable = options.pathToClaudeCodeExecutable;
|
|
if (!pathToClaudeCodeExecutable) {
|
|
const filename = fileURLToPath(import.meta.url);
|
|
const dirname2 = join4(filename, "..");
|
|
pathToClaudeCodeExecutable = join4(dirname2, "cli.js");
|
|
}
|
|
const processEnv = { ...options.env ?? process.env };
|
|
if (!processEnv.CLAUDE_CODE_ENTRYPOINT) {
|
|
processEnv.CLAUDE_CODE_ENTRYPOINT = "sdk-ts";
|
|
}
|
|
this.abortController = createAbortController();
|
|
const transport = new ProcessTransport({
|
|
abortController: this.abortController,
|
|
pathToClaudeCodeExecutable,
|
|
env: processEnv,
|
|
executable: options.executable ?? (isRunningWithBun() ? "bun" : "node"),
|
|
executableArgs: options.executableArgs ?? [],
|
|
extraArgs: {},
|
|
maxThinkingTokens: undefined,
|
|
maxTurns: undefined,
|
|
maxBudgetUsd: undefined,
|
|
model: options.model,
|
|
fallbackModel: undefined,
|
|
permissionMode: "default",
|
|
allowDangerouslySkipPermissions: false,
|
|
continueConversation: false,
|
|
resume: options.resume,
|
|
settingSources: [],
|
|
allowedTools: [],
|
|
disallowedTools: [],
|
|
mcpServers: {},
|
|
strictMcpConfig: false,
|
|
canUseTool: false,
|
|
hooks: false,
|
|
includePartialMessages: false,
|
|
forkSession: false,
|
|
resumeSessionAt: undefined
|
|
});
|
|
this.query = new Query(transport, false, undefined, undefined, this.abortController, new Map);
|
|
this.query.streamInput(this.inputStream);
|
|
}
|
|
async send(message) {
|
|
if (this.closed) {
|
|
throw new Error("Cannot send to closed session");
|
|
}
|
|
const userMessage = typeof message === "string" ? {
|
|
type: "user",
|
|
session_id: "",
|
|
message: {
|
|
role: "user",
|
|
content: [{ type: "text", text: message }]
|
|
},
|
|
parent_tool_use_id: null
|
|
} : message;
|
|
this.inputStream.enqueue(userMessage);
|
|
}
|
|
async* stream() {
|
|
if (!this.queryIterator) {
|
|
this.queryIterator = this.query[Symbol.asyncIterator]();
|
|
}
|
|
while (true) {
|
|
const { value, done } = await this.queryIterator.next();
|
|
if (done) {
|
|
return;
|
|
}
|
|
if (value.type === "system" && value.subtype === "init") {
|
|
this._sessionId = value.session_id;
|
|
}
|
|
yield value;
|
|
if (value.type === "result") {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
close() {
|
|
if (this.closed) {
|
|
return;
|
|
}
|
|
this.closed = true;
|
|
this.inputStream.done();
|
|
this.abortController.abort();
|
|
}
|
|
async[Symbol.asyncDispose]() {
|
|
this.close();
|
|
}
|
|
}
|
|
function createSession(options) {
|
|
return new SessionImpl(options);
|
|
}
|
|
function resumeSession(sessionId, options) {
|
|
return new SessionImpl({ ...options, resume: sessionId });
|
|
}
|
|
|
|
// ../node_modules/zod/v3/helpers/util.js
|
|
var util;
|
|
(function(util2) {
|
|
util2.assertEqual = (_) => {};
|
|
function assertIs(_arg) {}
|
|
util2.assertIs = assertIs;
|
|
function assertNever(_x) {
|
|
throw new Error;
|
|
}
|
|
util2.assertNever = assertNever;
|
|
util2.arrayToEnum = (items) => {
|
|
const obj = {};
|
|
for (const item of items) {
|
|
obj[item] = item;
|
|
}
|
|
return obj;
|
|
};
|
|
util2.getValidEnumValues = (obj) => {
|
|
const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
|
|
const filtered = {};
|
|
for (const k of validKeys) {
|
|
filtered[k] = obj[k];
|
|
}
|
|
return util2.objectValues(filtered);
|
|
};
|
|
util2.objectValues = (obj) => {
|
|
return util2.objectKeys(obj).map(function(e) {
|
|
return obj[e];
|
|
});
|
|
};
|
|
util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
|
|
const keys = [];
|
|
for (const key in object) {
|
|
if (Object.prototype.hasOwnProperty.call(object, key)) {
|
|
keys.push(key);
|
|
}
|
|
}
|
|
return keys;
|
|
};
|
|
util2.find = (arr, checker) => {
|
|
for (const item of arr) {
|
|
if (checker(item))
|
|
return item;
|
|
}
|
|
return;
|
|
};
|
|
util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
|
|
function joinValues(array, separator = " | ") {
|
|
return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
|
|
}
|
|
util2.joinValues = joinValues;
|
|
util2.jsonStringifyReplacer = (_, value) => {
|
|
if (typeof value === "bigint") {
|
|
return value.toString();
|
|
}
|
|
return value;
|
|
};
|
|
})(util || (util = {}));
|
|
var objectUtil;
|
|
(function(objectUtil2) {
|
|
objectUtil2.mergeShapes = (first, second) => {
|
|
return {
|
|
...first,
|
|
...second
|
|
};
|
|
};
|
|
})(objectUtil || (objectUtil = {}));
|
|
var ZodParsedType = util.arrayToEnum([
|
|
"string",
|
|
"nan",
|
|
"number",
|
|
"integer",
|
|
"float",
|
|
"boolean",
|
|
"date",
|
|
"bigint",
|
|
"symbol",
|
|
"function",
|
|
"undefined",
|
|
"null",
|
|
"array",
|
|
"object",
|
|
"unknown",
|
|
"promise",
|
|
"void",
|
|
"never",
|
|
"map",
|
|
"set"
|
|
]);
|
|
var getParsedType = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "undefined":
|
|
return ZodParsedType.undefined;
|
|
case "string":
|
|
return ZodParsedType.string;
|
|
case "number":
|
|
return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
|
|
case "boolean":
|
|
return ZodParsedType.boolean;
|
|
case "function":
|
|
return ZodParsedType.function;
|
|
case "bigint":
|
|
return ZodParsedType.bigint;
|
|
case "symbol":
|
|
return ZodParsedType.symbol;
|
|
case "object":
|
|
if (Array.isArray(data)) {
|
|
return ZodParsedType.array;
|
|
}
|
|
if (data === null) {
|
|
return ZodParsedType.null;
|
|
}
|
|
if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
|
|
return ZodParsedType.promise;
|
|
}
|
|
if (typeof Map !== "undefined" && data instanceof Map) {
|
|
return ZodParsedType.map;
|
|
}
|
|
if (typeof Set !== "undefined" && data instanceof Set) {
|
|
return ZodParsedType.set;
|
|
}
|
|
if (typeof Date !== "undefined" && data instanceof Date) {
|
|
return ZodParsedType.date;
|
|
}
|
|
return ZodParsedType.object;
|
|
default:
|
|
return ZodParsedType.unknown;
|
|
}
|
|
};
|
|
|
|
// ../node_modules/zod/v3/ZodError.js
|
|
var ZodIssueCode = util.arrayToEnum([
|
|
"invalid_type",
|
|
"invalid_literal",
|
|
"custom",
|
|
"invalid_union",
|
|
"invalid_union_discriminator",
|
|
"invalid_enum_value",
|
|
"unrecognized_keys",
|
|
"invalid_arguments",
|
|
"invalid_return_type",
|
|
"invalid_date",
|
|
"invalid_string",
|
|
"too_small",
|
|
"too_big",
|
|
"invalid_intersection_types",
|
|
"not_multiple_of",
|
|
"not_finite"
|
|
]);
|
|
class ZodError extends Error {
|
|
get errors() {
|
|
return this.issues;
|
|
}
|
|
constructor(issues) {
|
|
super();
|
|
this.issues = [];
|
|
this.addIssue = (sub) => {
|
|
this.issues = [...this.issues, sub];
|
|
};
|
|
this.addIssues = (subs = []) => {
|
|
this.issues = [...this.issues, ...subs];
|
|
};
|
|
const actualProto = new.target.prototype;
|
|
if (Object.setPrototypeOf) {
|
|
Object.setPrototypeOf(this, actualProto);
|
|
} else {
|
|
this.__proto__ = actualProto;
|
|
}
|
|
this.name = "ZodError";
|
|
this.issues = issues;
|
|
}
|
|
format(_mapper) {
|
|
const mapper = _mapper || function(issue) {
|
|
return issue.message;
|
|
};
|
|
const fieldErrors = { _errors: [] };
|
|
const processError = (error) => {
|
|
for (const issue of error.issues) {
|
|
if (issue.code === "invalid_union") {
|
|
issue.unionErrors.map(processError);
|
|
} else if (issue.code === "invalid_return_type") {
|
|
processError(issue.returnTypeError);
|
|
} else if (issue.code === "invalid_arguments") {
|
|
processError(issue.argumentsError);
|
|
} else if (issue.path.length === 0) {
|
|
fieldErrors._errors.push(mapper(issue));
|
|
} else {
|
|
let curr = fieldErrors;
|
|
let i = 0;
|
|
while (i < issue.path.length) {
|
|
const el = issue.path[i];
|
|
const terminal = i === issue.path.length - 1;
|
|
if (!terminal) {
|
|
curr[el] = curr[el] || { _errors: [] };
|
|
} else {
|
|
curr[el] = curr[el] || { _errors: [] };
|
|
curr[el]._errors.push(mapper(issue));
|
|
}
|
|
curr = curr[el];
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
processError(this);
|
|
return fieldErrors;
|
|
}
|
|
static assert(value) {
|
|
if (!(value instanceof ZodError)) {
|
|
throw new Error(`Not a ZodError: ${value}`);
|
|
}
|
|
}
|
|
toString() {
|
|
return this.message;
|
|
}
|
|
get message() {
|
|
return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
|
|
}
|
|
get isEmpty() {
|
|
return this.issues.length === 0;
|
|
}
|
|
flatten(mapper = (issue) => issue.message) {
|
|
const fieldErrors = {};
|
|
const formErrors = [];
|
|
for (const sub of this.issues) {
|
|
if (sub.path.length > 0) {
|
|
const firstEl = sub.path[0];
|
|
fieldErrors[firstEl] = fieldErrors[firstEl] || [];
|
|
fieldErrors[firstEl].push(mapper(sub));
|
|
} else {
|
|
formErrors.push(mapper(sub));
|
|
}
|
|
}
|
|
return { formErrors, fieldErrors };
|
|
}
|
|
get formErrors() {
|
|
return this.flatten();
|
|
}
|
|
}
|
|
ZodError.create = (issues) => {
|
|
const error = new ZodError(issues);
|
|
return error;
|
|
};
|
|
|
|
// ../node_modules/zod/v3/locales/en.js
|
|
var errorMap = (issue, _ctx) => {
|
|
let message;
|
|
switch (issue.code) {
|
|
case ZodIssueCode.invalid_type:
|
|
if (issue.received === ZodParsedType.undefined) {
|
|
message = "Required";
|
|
} else {
|
|
message = `Expected ${issue.expected}, received ${issue.received}`;
|
|
}
|
|
break;
|
|
case ZodIssueCode.invalid_literal:
|
|
message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
|
|
break;
|
|
case ZodIssueCode.unrecognized_keys:
|
|
message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
|
|
break;
|
|
case ZodIssueCode.invalid_union:
|
|
message = `Invalid input`;
|
|
break;
|
|
case ZodIssueCode.invalid_union_discriminator:
|
|
message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
|
|
break;
|
|
case ZodIssueCode.invalid_enum_value:
|
|
message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
|
|
break;
|
|
case ZodIssueCode.invalid_arguments:
|
|
message = `Invalid function arguments`;
|
|
break;
|
|
case ZodIssueCode.invalid_return_type:
|
|
message = `Invalid function return type`;
|
|
break;
|
|
case ZodIssueCode.invalid_date:
|
|
message = `Invalid date`;
|
|
break;
|
|
case ZodIssueCode.invalid_string:
|
|
if (typeof issue.validation === "object") {
|
|
if ("includes" in issue.validation) {
|
|
message = `Invalid input: must include "${issue.validation.includes}"`;
|
|
if (typeof issue.validation.position === "number") {
|
|
message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
|
|
}
|
|
} else if ("startsWith" in issue.validation) {
|
|
message = `Invalid input: must start with "${issue.validation.startsWith}"`;
|
|
} else if ("endsWith" in issue.validation) {
|
|
message = `Invalid input: must end with "${issue.validation.endsWith}"`;
|
|
} else {
|
|
util.assertNever(issue.validation);
|
|
}
|
|
} else if (issue.validation !== "regex") {
|
|
message = `Invalid ${issue.validation}`;
|
|
} else {
|
|
message = "Invalid";
|
|
}
|
|
break;
|
|
case ZodIssueCode.too_small:
|
|
if (issue.type === "array")
|
|
message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
|
|
else if (issue.type === "string")
|
|
message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
|
|
else if (issue.type === "number")
|
|
message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
|
|
else if (issue.type === "bigint")
|
|
message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
|
|
else if (issue.type === "date")
|
|
message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;
|
|
else
|
|
message = "Invalid input";
|
|
break;
|
|
case ZodIssueCode.too_big:
|
|
if (issue.type === "array")
|
|
message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
|
|
else if (issue.type === "string")
|
|
message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
|
|
else if (issue.type === "number")
|
|
message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
|
|
else if (issue.type === "bigint")
|
|
message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
|
|
else if (issue.type === "date")
|
|
message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;
|
|
else
|
|
message = "Invalid input";
|
|
break;
|
|
case ZodIssueCode.custom:
|
|
message = `Invalid input`;
|
|
break;
|
|
case ZodIssueCode.invalid_intersection_types:
|
|
message = `Intersection results could not be merged`;
|
|
break;
|
|
case ZodIssueCode.not_multiple_of:
|
|
message = `Number must be a multiple of ${issue.multipleOf}`;
|
|
break;
|
|
case ZodIssueCode.not_finite:
|
|
message = "Number must be finite";
|
|
break;
|
|
default:
|
|
message = _ctx.defaultError;
|
|
util.assertNever(issue);
|
|
}
|
|
return { message };
|
|
};
|
|
var en_default = errorMap;
|
|
|
|
// ../node_modules/zod/v3/errors.js
|
|
var overrideErrorMap = en_default;
|
|
function getErrorMap() {
|
|
return overrideErrorMap;
|
|
}
|
|
|
|
// ../node_modules/zod/v3/helpers/parseUtil.js
|
|
var makeIssue = (params) => {
|
|
const { data, path, errorMaps, issueData } = params;
|
|
const fullPath = [...path, ...issueData.path || []];
|
|
const fullIssue = {
|
|
...issueData,
|
|
path: fullPath
|
|
};
|
|
if (issueData.message !== undefined) {
|
|
return {
|
|
...issueData,
|
|
path: fullPath,
|
|
message: issueData.message
|
|
};
|
|
}
|
|
let errorMessage = "";
|
|
const maps = errorMaps.filter((m) => !!m).slice().reverse();
|
|
for (const map of maps) {
|
|
errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
|
|
}
|
|
return {
|
|
...issueData,
|
|
path: fullPath,
|
|
message: errorMessage
|
|
};
|
|
};
|
|
function addIssueToContext(ctx, issueData) {
|
|
const overrideMap = getErrorMap();
|
|
const issue = makeIssue({
|
|
issueData,
|
|
data: ctx.data,
|
|
path: ctx.path,
|
|
errorMaps: [
|
|
ctx.common.contextualErrorMap,
|
|
ctx.schemaErrorMap,
|
|
overrideMap,
|
|
overrideMap === en_default ? undefined : en_default
|
|
].filter((x) => !!x)
|
|
});
|
|
ctx.common.issues.push(issue);
|
|
}
|
|
|
|
class ParseStatus {
|
|
constructor() {
|
|
this.value = "valid";
|
|
}
|
|
dirty() {
|
|
if (this.value === "valid")
|
|
this.value = "dirty";
|
|
}
|
|
abort() {
|
|
if (this.value !== "aborted")
|
|
this.value = "aborted";
|
|
}
|
|
static mergeArray(status, results) {
|
|
const arrayValue = [];
|
|
for (const s of results) {
|
|
if (s.status === "aborted")
|
|
return INVALID;
|
|
if (s.status === "dirty")
|
|
status.dirty();
|
|
arrayValue.push(s.value);
|
|
}
|
|
return { status: status.value, value: arrayValue };
|
|
}
|
|
static async mergeObjectAsync(status, pairs) {
|
|
const syncPairs = [];
|
|
for (const pair of pairs) {
|
|
const key = await pair.key;
|
|
const value = await pair.value;
|
|
syncPairs.push({
|
|
key,
|
|
value
|
|
});
|
|
}
|
|
return ParseStatus.mergeObjectSync(status, syncPairs);
|
|
}
|
|
static mergeObjectSync(status, pairs) {
|
|
const finalObject = {};
|
|
for (const pair of pairs) {
|
|
const { key, value } = pair;
|
|
if (key.status === "aborted")
|
|
return INVALID;
|
|
if (value.status === "aborted")
|
|
return INVALID;
|
|
if (key.status === "dirty")
|
|
status.dirty();
|
|
if (value.status === "dirty")
|
|
status.dirty();
|
|
if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
|
|
finalObject[key.value] = value.value;
|
|
}
|
|
}
|
|
return { status: status.value, value: finalObject };
|
|
}
|
|
}
|
|
var INVALID = Object.freeze({
|
|
status: "aborted"
|
|
});
|
|
var DIRTY = (value) => ({ status: "dirty", value });
|
|
var OK = (value) => ({ status: "valid", value });
|
|
var isAborted = (x) => x.status === "aborted";
|
|
var isDirty = (x) => x.status === "dirty";
|
|
var isValid = (x) => x.status === "valid";
|
|
var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
|
|
|
|
// ../node_modules/zod/v3/helpers/errorUtil.js
|
|
var errorUtil;
|
|
(function(errorUtil2) {
|
|
errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
|
|
errorUtil2.toString = (message) => typeof message === "string" ? message : message?.message;
|
|
})(errorUtil || (errorUtil = {}));
|
|
|
|
// ../node_modules/zod/v3/types.js
|
|
class ParseInputLazyPath {
|
|
constructor(parent, value, path, key) {
|
|
this._cachedPath = [];
|
|
this.parent = parent;
|
|
this.data = value;
|
|
this._path = path;
|
|
this._key = key;
|
|
}
|
|
get path() {
|
|
if (!this._cachedPath.length) {
|
|
if (Array.isArray(this._key)) {
|
|
this._cachedPath.push(...this._path, ...this._key);
|
|
} else {
|
|
this._cachedPath.push(...this._path, this._key);
|
|
}
|
|
}
|
|
return this._cachedPath;
|
|
}
|
|
}
|
|
var handleResult = (ctx, result) => {
|
|
if (isValid(result)) {
|
|
return { success: true, data: result.value };
|
|
} else {
|
|
if (!ctx.common.issues.length) {
|
|
throw new Error("Validation failed but no issues detected.");
|
|
}
|
|
return {
|
|
success: false,
|
|
get error() {
|
|
if (this._error)
|
|
return this._error;
|
|
const error = new ZodError(ctx.common.issues);
|
|
this._error = error;
|
|
return this._error;
|
|
}
|
|
};
|
|
}
|
|
};
|
|
function processCreateParams(params) {
|
|
if (!params)
|
|
return {};
|
|
const { errorMap: errorMap2, invalid_type_error, required_error, description } = params;
|
|
if (errorMap2 && (invalid_type_error || required_error)) {
|
|
throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
|
|
}
|
|
if (errorMap2)
|
|
return { errorMap: errorMap2, description };
|
|
const customMap = (iss, ctx) => {
|
|
const { message } = params;
|
|
if (iss.code === "invalid_enum_value") {
|
|
return { message: message ?? ctx.defaultError };
|
|
}
|
|
if (typeof ctx.data === "undefined") {
|
|
return { message: message ?? required_error ?? ctx.defaultError };
|
|
}
|
|
if (iss.code !== "invalid_type")
|
|
return { message: ctx.defaultError };
|
|
return { message: message ?? invalid_type_error ?? ctx.defaultError };
|
|
};
|
|
return { errorMap: customMap, description };
|
|
}
|
|
|
|
class ZodType {
|
|
get description() {
|
|
return this._def.description;
|
|
}
|
|
_getType(input) {
|
|
return getParsedType(input.data);
|
|
}
|
|
_getOrReturnCtx(input, ctx) {
|
|
return ctx || {
|
|
common: input.parent.common,
|
|
data: input.data,
|
|
parsedType: getParsedType(input.data),
|
|
schemaErrorMap: this._def.errorMap,
|
|
path: input.path,
|
|
parent: input.parent
|
|
};
|
|
}
|
|
_processInputParams(input) {
|
|
return {
|
|
status: new ParseStatus,
|
|
ctx: {
|
|
common: input.parent.common,
|
|
data: input.data,
|
|
parsedType: getParsedType(input.data),
|
|
schemaErrorMap: this._def.errorMap,
|
|
path: input.path,
|
|
parent: input.parent
|
|
}
|
|
};
|
|
}
|
|
_parseSync(input) {
|
|
const result = this._parse(input);
|
|
if (isAsync(result)) {
|
|
throw new Error("Synchronous parse encountered promise.");
|
|
}
|
|
return result;
|
|
}
|
|
_parseAsync(input) {
|
|
const result = this._parse(input);
|
|
return Promise.resolve(result);
|
|
}
|
|
parse(data, params) {
|
|
const result = this.safeParse(data, params);
|
|
if (result.success)
|
|
return result.data;
|
|
throw result.error;
|
|
}
|
|
safeParse(data, params) {
|
|
const ctx = {
|
|
common: {
|
|
issues: [],
|
|
async: params?.async ?? false,
|
|
contextualErrorMap: params?.errorMap
|
|
},
|
|
path: params?.path || [],
|
|
schemaErrorMap: this._def.errorMap,
|
|
parent: null,
|
|
data,
|
|
parsedType: getParsedType(data)
|
|
};
|
|
const result = this._parseSync({ data, path: ctx.path, parent: ctx });
|
|
return handleResult(ctx, result);
|
|
}
|
|
"~validate"(data) {
|
|
const ctx = {
|
|
common: {
|
|
issues: [],
|
|
async: !!this["~standard"].async
|
|
},
|
|
path: [],
|
|
schemaErrorMap: this._def.errorMap,
|
|
parent: null,
|
|
data,
|
|
parsedType: getParsedType(data)
|
|
};
|
|
if (!this["~standard"].async) {
|
|
try {
|
|
const result = this._parseSync({ data, path: [], parent: ctx });
|
|
return isValid(result) ? {
|
|
value: result.value
|
|
} : {
|
|
issues: ctx.common.issues
|
|
};
|
|
} catch (err) {
|
|
if (err?.message?.toLowerCase()?.includes("encountered")) {
|
|
this["~standard"].async = true;
|
|
}
|
|
ctx.common = {
|
|
issues: [],
|
|
async: true
|
|
};
|
|
}
|
|
}
|
|
return this._parseAsync({ data, path: [], parent: ctx }).then((result) => isValid(result) ? {
|
|
value: result.value
|
|
} : {
|
|
issues: ctx.common.issues
|
|
});
|
|
}
|
|
async parseAsync(data, params) {
|
|
const result = await this.safeParseAsync(data, params);
|
|
if (result.success)
|
|
return result.data;
|
|
throw result.error;
|
|
}
|
|
async safeParseAsync(data, params) {
|
|
const ctx = {
|
|
common: {
|
|
issues: [],
|
|
contextualErrorMap: params?.errorMap,
|
|
async: true
|
|
},
|
|
path: params?.path || [],
|
|
schemaErrorMap: this._def.errorMap,
|
|
parent: null,
|
|
data,
|
|
parsedType: getParsedType(data)
|
|
};
|
|
const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
|
|
const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
|
|
return handleResult(ctx, result);
|
|
}
|
|
refine(check, message) {
|
|
const getIssueProperties = (val) => {
|
|
if (typeof message === "string" || typeof message === "undefined") {
|
|
return { message };
|
|
} else if (typeof message === "function") {
|
|
return message(val);
|
|
} else {
|
|
return message;
|
|
}
|
|
};
|
|
return this._refinement((val, ctx) => {
|
|
const result = check(val);
|
|
const setError = () => ctx.addIssue({
|
|
code: ZodIssueCode.custom,
|
|
...getIssueProperties(val)
|
|
});
|
|
if (typeof Promise !== "undefined" && result instanceof Promise) {
|
|
return result.then((data) => {
|
|
if (!data) {
|
|
setError();
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
if (!result) {
|
|
setError();
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
refinement(check, refinementData) {
|
|
return this._refinement((val, ctx) => {
|
|
if (!check(val)) {
|
|
ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
_refinement(refinement) {
|
|
return new ZodEffects({
|
|
schema: this,
|
|
typeName: ZodFirstPartyTypeKind.ZodEffects,
|
|
effect: { type: "refinement", refinement }
|
|
});
|
|
}
|
|
superRefine(refinement) {
|
|
return this._refinement(refinement);
|
|
}
|
|
constructor(def) {
|
|
this.spa = this.safeParseAsync;
|
|
this._def = def;
|
|
this.parse = this.parse.bind(this);
|
|
this.safeParse = this.safeParse.bind(this);
|
|
this.parseAsync = this.parseAsync.bind(this);
|
|
this.safeParseAsync = this.safeParseAsync.bind(this);
|
|
this.spa = this.spa.bind(this);
|
|
this.refine = this.refine.bind(this);
|
|
this.refinement = this.refinement.bind(this);
|
|
this.superRefine = this.superRefine.bind(this);
|
|
this.optional = this.optional.bind(this);
|
|
this.nullable = this.nullable.bind(this);
|
|
this.nullish = this.nullish.bind(this);
|
|
this.array = this.array.bind(this);
|
|
this.promise = this.promise.bind(this);
|
|
this.or = this.or.bind(this);
|
|
this.and = this.and.bind(this);
|
|
this.transform = this.transform.bind(this);
|
|
this.brand = this.brand.bind(this);
|
|
this.default = this.default.bind(this);
|
|
this.catch = this.catch.bind(this);
|
|
this.describe = this.describe.bind(this);
|
|
this.pipe = this.pipe.bind(this);
|
|
this.readonly = this.readonly.bind(this);
|
|
this.isNullable = this.isNullable.bind(this);
|
|
this.isOptional = this.isOptional.bind(this);
|
|
this["~standard"] = {
|
|
version: 1,
|
|
vendor: "zod",
|
|
validate: (data) => this["~validate"](data)
|
|
};
|
|
}
|
|
optional() {
|
|
return ZodOptional.create(this, this._def);
|
|
}
|
|
nullable() {
|
|
return ZodNullable.create(this, this._def);
|
|
}
|
|
nullish() {
|
|
return this.nullable().optional();
|
|
}
|
|
array() {
|
|
return ZodArray.create(this);
|
|
}
|
|
promise() {
|
|
return ZodPromise.create(this, this._def);
|
|
}
|
|
or(option) {
|
|
return ZodUnion.create([this, option], this._def);
|
|
}
|
|
and(incoming) {
|
|
return ZodIntersection.create(this, incoming, this._def);
|
|
}
|
|
transform(transform) {
|
|
return new ZodEffects({
|
|
...processCreateParams(this._def),
|
|
schema: this,
|
|
typeName: ZodFirstPartyTypeKind.ZodEffects,
|
|
effect: { type: "transform", transform }
|
|
});
|
|
}
|
|
default(def) {
|
|
const defaultValueFunc = typeof def === "function" ? def : () => def;
|
|
return new ZodDefault({
|
|
...processCreateParams(this._def),
|
|
innerType: this,
|
|
defaultValue: defaultValueFunc,
|
|
typeName: ZodFirstPartyTypeKind.ZodDefault
|
|
});
|
|
}
|
|
brand() {
|
|
return new ZodBranded({
|
|
typeName: ZodFirstPartyTypeKind.ZodBranded,
|
|
type: this,
|
|
...processCreateParams(this._def)
|
|
});
|
|
}
|
|
catch(def) {
|
|
const catchValueFunc = typeof def === "function" ? def : () => def;
|
|
return new ZodCatch({
|
|
...processCreateParams(this._def),
|
|
innerType: this,
|
|
catchValue: catchValueFunc,
|
|
typeName: ZodFirstPartyTypeKind.ZodCatch
|
|
});
|
|
}
|
|
describe(description) {
|
|
const This = this.constructor;
|
|
return new This({
|
|
...this._def,
|
|
description
|
|
});
|
|
}
|
|
pipe(target) {
|
|
return ZodPipeline.create(this, target);
|
|
}
|
|
readonly() {
|
|
return ZodReadonly.create(this);
|
|
}
|
|
isOptional() {
|
|
return this.safeParse(undefined).success;
|
|
}
|
|
isNullable() {
|
|
return this.safeParse(null).success;
|
|
}
|
|
}
|
|
var cuidRegex = /^c[^\s-]{8,}$/i;
|
|
var cuid2Regex = /^[0-9a-z]+$/;
|
|
var ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
|
|
var uuidRegex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i;
|
|
var nanoidRegex = /^[a-z0-9_-]{21}$/i;
|
|
var jwtRegex = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/;
|
|
var durationRegex = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
|
|
var emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i;
|
|
var _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
|
|
var emojiRegex;
|
|
var ipv4Regex = /^(?:(?: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 ipv4CidrRegex = /^(?:(?: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])\/(3[0-2]|[12]?[0-9])$/;
|
|
var ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7,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}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;
|
|
var ipv6CidrRegex = /^(([0-9a-fA-F]{1,4}:){7,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}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
|
|
var base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
|
|
var base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/;
|
|
var dateRegexSource = `((\\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 dateRegex = new RegExp(`^${dateRegexSource}$`);
|
|
function timeRegexSource(args) {
|
|
let secondsRegexSource = `[0-5]\\d`;
|
|
if (args.precision) {
|
|
secondsRegexSource = `${secondsRegexSource}\\.\\d{${args.precision}}`;
|
|
} else if (args.precision == null) {
|
|
secondsRegexSource = `${secondsRegexSource}(\\.\\d+)?`;
|
|
}
|
|
const secondsQuantifier = args.precision ? "+" : "?";
|
|
return `([01]\\d|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`;
|
|
}
|
|
function timeRegex(args) {
|
|
return new RegExp(`^${timeRegexSource(args)}$`);
|
|
}
|
|
function datetimeRegex(args) {
|
|
let regex = `${dateRegexSource}T${timeRegexSource(args)}`;
|
|
const opts = [];
|
|
opts.push(args.local ? `Z?` : `Z`);
|
|
if (args.offset)
|
|
opts.push(`([+-]\\d{2}:?\\d{2})`);
|
|
regex = `${regex}(${opts.join("|")})`;
|
|
return new RegExp(`^${regex}$`);
|
|
}
|
|
function isValidIP(ip, version) {
|
|
if ((version === "v4" || !version) && ipv4Regex.test(ip)) {
|
|
return true;
|
|
}
|
|
if ((version === "v6" || !version) && ipv6Regex.test(ip)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isValidJWT(jwt, alg) {
|
|
if (!jwtRegex.test(jwt))
|
|
return false;
|
|
try {
|
|
const [header] = jwt.split(".");
|
|
if (!header)
|
|
return false;
|
|
const base64 = header.replace(/-/g, "+").replace(/_/g, "/").padEnd(header.length + (4 - header.length % 4) % 4, "=");
|
|
const decoded = JSON.parse(atob(base64));
|
|
if (typeof decoded !== "object" || decoded === null)
|
|
return false;
|
|
if ("typ" in decoded && decoded?.typ !== "JWT")
|
|
return false;
|
|
if (!decoded.alg)
|
|
return false;
|
|
if (alg && decoded.alg !== alg)
|
|
return false;
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
function isValidCidr(ip, version) {
|
|
if ((version === "v4" || !version) && ipv4CidrRegex.test(ip)) {
|
|
return true;
|
|
}
|
|
if ((version === "v6" || !version) && ipv6CidrRegex.test(ip)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
class ZodString extends ZodType {
|
|
_parse(input) {
|
|
if (this._def.coerce) {
|
|
input.data = String(input.data);
|
|
}
|
|
const parsedType = this._getType(input);
|
|
if (parsedType !== ZodParsedType.string) {
|
|
const ctx2 = this._getOrReturnCtx(input);
|
|
addIssueToContext(ctx2, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: ZodParsedType.string,
|
|
received: ctx2.parsedType
|
|
});
|
|
return INVALID;
|
|
}
|
|
const status = new ParseStatus;
|
|
let ctx = undefined;
|
|
for (const check of this._def.checks) {
|
|
if (check.kind === "min") {
|
|
if (input.data.length < check.value) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.too_small,
|
|
minimum: check.value,
|
|
type: "string",
|
|
inclusive: true,
|
|
exact: false,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "max") {
|
|
if (input.data.length > check.value) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.too_big,
|
|
maximum: check.value,
|
|
type: "string",
|
|
inclusive: true,
|
|
exact: false,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "length") {
|
|
const tooBig = input.data.length > check.value;
|
|
const tooSmall = input.data.length < check.value;
|
|
if (tooBig || tooSmall) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
if (tooBig) {
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.too_big,
|
|
maximum: check.value,
|
|
type: "string",
|
|
inclusive: true,
|
|
exact: true,
|
|
message: check.message
|
|
});
|
|
} else if (tooSmall) {
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.too_small,
|
|
minimum: check.value,
|
|
type: "string",
|
|
inclusive: true,
|
|
exact: true,
|
|
message: check.message
|
|
});
|
|
}
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "email") {
|
|
if (!emailRegex.test(input.data)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
validation: "email",
|
|
code: ZodIssueCode.invalid_string,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "emoji") {
|
|
if (!emojiRegex) {
|
|
emojiRegex = new RegExp(_emojiRegex, "u");
|
|
}
|
|
if (!emojiRegex.test(input.data)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
validation: "emoji",
|
|
code: ZodIssueCode.invalid_string,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "uuid") {
|
|
if (!uuidRegex.test(input.data)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
validation: "uuid",
|
|
code: ZodIssueCode.invalid_string,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "nanoid") {
|
|
if (!nanoidRegex.test(input.data)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
validation: "nanoid",
|
|
code: ZodIssueCode.invalid_string,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "cuid") {
|
|
if (!cuidRegex.test(input.data)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
validation: "cuid",
|
|
code: ZodIssueCode.invalid_string,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "cuid2") {
|
|
if (!cuid2Regex.test(input.data)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
validation: "cuid2",
|
|
code: ZodIssueCode.invalid_string,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "ulid") {
|
|
if (!ulidRegex.test(input.data)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
validation: "ulid",
|
|
code: ZodIssueCode.invalid_string,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "url") {
|
|
try {
|
|
new URL(input.data);
|
|
} catch {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
validation: "url",
|
|
code: ZodIssueCode.invalid_string,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "regex") {
|
|
check.regex.lastIndex = 0;
|
|
const testResult = check.regex.test(input.data);
|
|
if (!testResult) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
validation: "regex",
|
|
code: ZodIssueCode.invalid_string,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "trim") {
|
|
input.data = input.data.trim();
|
|
} else if (check.kind === "includes") {
|
|
if (!input.data.includes(check.value, check.position)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_string,
|
|
validation: { includes: check.value, position: check.position },
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "toLowerCase") {
|
|
input.data = input.data.toLowerCase();
|
|
} else if (check.kind === "toUpperCase") {
|
|
input.data = input.data.toUpperCase();
|
|
} else if (check.kind === "startsWith") {
|
|
if (!input.data.startsWith(check.value)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_string,
|
|
validation: { startsWith: check.value },
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "endsWith") {
|
|
if (!input.data.endsWith(check.value)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_string,
|
|
validation: { endsWith: check.value },
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "datetime") {
|
|
const regex = datetimeRegex(check);
|
|
if (!regex.test(input.data)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_string,
|
|
validation: "datetime",
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "date") {
|
|
const regex = dateRegex;
|
|
if (!regex.test(input.data)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_string,
|
|
validation: "date",
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "time") {
|
|
const regex = timeRegex(check);
|
|
if (!regex.test(input.data)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_string,
|
|
validation: "time",
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "duration") {
|
|
if (!durationRegex.test(input.data)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
validation: "duration",
|
|
code: ZodIssueCode.invalid_string,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "ip") {
|
|
if (!isValidIP(input.data, check.version)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
validation: "ip",
|
|
code: ZodIssueCode.invalid_string,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "jwt") {
|
|
if (!isValidJWT(input.data, check.alg)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
validation: "jwt",
|
|
code: ZodIssueCode.invalid_string,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "cidr") {
|
|
if (!isValidCidr(input.data, check.version)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
validation: "cidr",
|
|
code: ZodIssueCode.invalid_string,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "base64") {
|
|
if (!base64Regex.test(input.data)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
validation: "base64",
|
|
code: ZodIssueCode.invalid_string,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "base64url") {
|
|
if (!base64urlRegex.test(input.data)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
validation: "base64url",
|
|
code: ZodIssueCode.invalid_string,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else {
|
|
util.assertNever(check);
|
|
}
|
|
}
|
|
return { status: status.value, value: input.data };
|
|
}
|
|
_regex(regex, validation, message) {
|
|
return this.refinement((data) => regex.test(data), {
|
|
validation,
|
|
code: ZodIssueCode.invalid_string,
|
|
...errorUtil.errToObj(message)
|
|
});
|
|
}
|
|
_addCheck(check) {
|
|
return new ZodString({
|
|
...this._def,
|
|
checks: [...this._def.checks, check]
|
|
});
|
|
}
|
|
email(message) {
|
|
return this._addCheck({ kind: "email", ...errorUtil.errToObj(message) });
|
|
}
|
|
url(message) {
|
|
return this._addCheck({ kind: "url", ...errorUtil.errToObj(message) });
|
|
}
|
|
emoji(message) {
|
|
return this._addCheck({ kind: "emoji", ...errorUtil.errToObj(message) });
|
|
}
|
|
uuid(message) {
|
|
return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message) });
|
|
}
|
|
nanoid(message) {
|
|
return this._addCheck({ kind: "nanoid", ...errorUtil.errToObj(message) });
|
|
}
|
|
cuid(message) {
|
|
return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) });
|
|
}
|
|
cuid2(message) {
|
|
return this._addCheck({ kind: "cuid2", ...errorUtil.errToObj(message) });
|
|
}
|
|
ulid(message) {
|
|
return this._addCheck({ kind: "ulid", ...errorUtil.errToObj(message) });
|
|
}
|
|
base64(message) {
|
|
return this._addCheck({ kind: "base64", ...errorUtil.errToObj(message) });
|
|
}
|
|
base64url(message) {
|
|
return this._addCheck({
|
|
kind: "base64url",
|
|
...errorUtil.errToObj(message)
|
|
});
|
|
}
|
|
jwt(options) {
|
|
return this._addCheck({ kind: "jwt", ...errorUtil.errToObj(options) });
|
|
}
|
|
ip(options) {
|
|
return this._addCheck({ kind: "ip", ...errorUtil.errToObj(options) });
|
|
}
|
|
cidr(options) {
|
|
return this._addCheck({ kind: "cidr", ...errorUtil.errToObj(options) });
|
|
}
|
|
datetime(options) {
|
|
if (typeof options === "string") {
|
|
return this._addCheck({
|
|
kind: "datetime",
|
|
precision: null,
|
|
offset: false,
|
|
local: false,
|
|
message: options
|
|
});
|
|
}
|
|
return this._addCheck({
|
|
kind: "datetime",
|
|
precision: typeof options?.precision === "undefined" ? null : options?.precision,
|
|
offset: options?.offset ?? false,
|
|
local: options?.local ?? false,
|
|
...errorUtil.errToObj(options?.message)
|
|
});
|
|
}
|
|
date(message) {
|
|
return this._addCheck({ kind: "date", message });
|
|
}
|
|
time(options) {
|
|
if (typeof options === "string") {
|
|
return this._addCheck({
|
|
kind: "time",
|
|
precision: null,
|
|
message: options
|
|
});
|
|
}
|
|
return this._addCheck({
|
|
kind: "time",
|
|
precision: typeof options?.precision === "undefined" ? null : options?.precision,
|
|
...errorUtil.errToObj(options?.message)
|
|
});
|
|
}
|
|
duration(message) {
|
|
return this._addCheck({ kind: "duration", ...errorUtil.errToObj(message) });
|
|
}
|
|
regex(regex, message) {
|
|
return this._addCheck({
|
|
kind: "regex",
|
|
regex,
|
|
...errorUtil.errToObj(message)
|
|
});
|
|
}
|
|
includes(value, options) {
|
|
return this._addCheck({
|
|
kind: "includes",
|
|
value,
|
|
position: options?.position,
|
|
...errorUtil.errToObj(options?.message)
|
|
});
|
|
}
|
|
startsWith(value, message) {
|
|
return this._addCheck({
|
|
kind: "startsWith",
|
|
value,
|
|
...errorUtil.errToObj(message)
|
|
});
|
|
}
|
|
endsWith(value, message) {
|
|
return this._addCheck({
|
|
kind: "endsWith",
|
|
value,
|
|
...errorUtil.errToObj(message)
|
|
});
|
|
}
|
|
min(minLength, message) {
|
|
return this._addCheck({
|
|
kind: "min",
|
|
value: minLength,
|
|
...errorUtil.errToObj(message)
|
|
});
|
|
}
|
|
max(maxLength, message) {
|
|
return this._addCheck({
|
|
kind: "max",
|
|
value: maxLength,
|
|
...errorUtil.errToObj(message)
|
|
});
|
|
}
|
|
length(len, message) {
|
|
return this._addCheck({
|
|
kind: "length",
|
|
value: len,
|
|
...errorUtil.errToObj(message)
|
|
});
|
|
}
|
|
nonempty(message) {
|
|
return this.min(1, errorUtil.errToObj(message));
|
|
}
|
|
trim() {
|
|
return new ZodString({
|
|
...this._def,
|
|
checks: [...this._def.checks, { kind: "trim" }]
|
|
});
|
|
}
|
|
toLowerCase() {
|
|
return new ZodString({
|
|
...this._def,
|
|
checks: [...this._def.checks, { kind: "toLowerCase" }]
|
|
});
|
|
}
|
|
toUpperCase() {
|
|
return new ZodString({
|
|
...this._def,
|
|
checks: [...this._def.checks, { kind: "toUpperCase" }]
|
|
});
|
|
}
|
|
get isDatetime() {
|
|
return !!this._def.checks.find((ch) => ch.kind === "datetime");
|
|
}
|
|
get isDate() {
|
|
return !!this._def.checks.find((ch) => ch.kind === "date");
|
|
}
|
|
get isTime() {
|
|
return !!this._def.checks.find((ch) => ch.kind === "time");
|
|
}
|
|
get isDuration() {
|
|
return !!this._def.checks.find((ch) => ch.kind === "duration");
|
|
}
|
|
get isEmail() {
|
|
return !!this._def.checks.find((ch) => ch.kind === "email");
|
|
}
|
|
get isURL() {
|
|
return !!this._def.checks.find((ch) => ch.kind === "url");
|
|
}
|
|
get isEmoji() {
|
|
return !!this._def.checks.find((ch) => ch.kind === "emoji");
|
|
}
|
|
get isUUID() {
|
|
return !!this._def.checks.find((ch) => ch.kind === "uuid");
|
|
}
|
|
get isNANOID() {
|
|
return !!this._def.checks.find((ch) => ch.kind === "nanoid");
|
|
}
|
|
get isCUID() {
|
|
return !!this._def.checks.find((ch) => ch.kind === "cuid");
|
|
}
|
|
get isCUID2() {
|
|
return !!this._def.checks.find((ch) => ch.kind === "cuid2");
|
|
}
|
|
get isULID() {
|
|
return !!this._def.checks.find((ch) => ch.kind === "ulid");
|
|
}
|
|
get isIP() {
|
|
return !!this._def.checks.find((ch) => ch.kind === "ip");
|
|
}
|
|
get isCIDR() {
|
|
return !!this._def.checks.find((ch) => ch.kind === "cidr");
|
|
}
|
|
get isBase64() {
|
|
return !!this._def.checks.find((ch) => ch.kind === "base64");
|
|
}
|
|
get isBase64url() {
|
|
return !!this._def.checks.find((ch) => ch.kind === "base64url");
|
|
}
|
|
get minLength() {
|
|
let min = null;
|
|
for (const ch of this._def.checks) {
|
|
if (ch.kind === "min") {
|
|
if (min === null || ch.value > min)
|
|
min = ch.value;
|
|
}
|
|
}
|
|
return min;
|
|
}
|
|
get maxLength() {
|
|
let max = null;
|
|
for (const ch of this._def.checks) {
|
|
if (ch.kind === "max") {
|
|
if (max === null || ch.value < max)
|
|
max = ch.value;
|
|
}
|
|
}
|
|
return max;
|
|
}
|
|
}
|
|
ZodString.create = (params) => {
|
|
return new ZodString({
|
|
checks: [],
|
|
typeName: ZodFirstPartyTypeKind.ZodString,
|
|
coerce: params?.coerce ?? false,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
function floatSafeRemainder(val, step) {
|
|
const valDecCount = (val.toString().split(".")[1] || "").length;
|
|
const stepDecCount = (step.toString().split(".")[1] || "").length;
|
|
const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
|
|
const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
|
|
const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
|
|
return valInt % stepInt / 10 ** decCount;
|
|
}
|
|
|
|
class ZodNumber extends ZodType {
|
|
constructor() {
|
|
super(...arguments);
|
|
this.min = this.gte;
|
|
this.max = this.lte;
|
|
this.step = this.multipleOf;
|
|
}
|
|
_parse(input) {
|
|
if (this._def.coerce) {
|
|
input.data = Number(input.data);
|
|
}
|
|
const parsedType = this._getType(input);
|
|
if (parsedType !== ZodParsedType.number) {
|
|
const ctx2 = this._getOrReturnCtx(input);
|
|
addIssueToContext(ctx2, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: ZodParsedType.number,
|
|
received: ctx2.parsedType
|
|
});
|
|
return INVALID;
|
|
}
|
|
let ctx = undefined;
|
|
const status = new ParseStatus;
|
|
for (const check of this._def.checks) {
|
|
if (check.kind === "int") {
|
|
if (!util.isInteger(input.data)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: "integer",
|
|
received: "float",
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "min") {
|
|
const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
|
|
if (tooSmall) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.too_small,
|
|
minimum: check.value,
|
|
type: "number",
|
|
inclusive: check.inclusive,
|
|
exact: false,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "max") {
|
|
const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
|
|
if (tooBig) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.too_big,
|
|
maximum: check.value,
|
|
type: "number",
|
|
inclusive: check.inclusive,
|
|
exact: false,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "multipleOf") {
|
|
if (floatSafeRemainder(input.data, check.value) !== 0) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.not_multiple_of,
|
|
multipleOf: check.value,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "finite") {
|
|
if (!Number.isFinite(input.data)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.not_finite,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else {
|
|
util.assertNever(check);
|
|
}
|
|
}
|
|
return { status: status.value, value: input.data };
|
|
}
|
|
gte(value, message) {
|
|
return this.setLimit("min", value, true, errorUtil.toString(message));
|
|
}
|
|
gt(value, message) {
|
|
return this.setLimit("min", value, false, errorUtil.toString(message));
|
|
}
|
|
lte(value, message) {
|
|
return this.setLimit("max", value, true, errorUtil.toString(message));
|
|
}
|
|
lt(value, message) {
|
|
return this.setLimit("max", value, false, errorUtil.toString(message));
|
|
}
|
|
setLimit(kind, value, inclusive, message) {
|
|
return new ZodNumber({
|
|
...this._def,
|
|
checks: [
|
|
...this._def.checks,
|
|
{
|
|
kind,
|
|
value,
|
|
inclusive,
|
|
message: errorUtil.toString(message)
|
|
}
|
|
]
|
|
});
|
|
}
|
|
_addCheck(check) {
|
|
return new ZodNumber({
|
|
...this._def,
|
|
checks: [...this._def.checks, check]
|
|
});
|
|
}
|
|
int(message) {
|
|
return this._addCheck({
|
|
kind: "int",
|
|
message: errorUtil.toString(message)
|
|
});
|
|
}
|
|
positive(message) {
|
|
return this._addCheck({
|
|
kind: "min",
|
|
value: 0,
|
|
inclusive: false,
|
|
message: errorUtil.toString(message)
|
|
});
|
|
}
|
|
negative(message) {
|
|
return this._addCheck({
|
|
kind: "max",
|
|
value: 0,
|
|
inclusive: false,
|
|
message: errorUtil.toString(message)
|
|
});
|
|
}
|
|
nonpositive(message) {
|
|
return this._addCheck({
|
|
kind: "max",
|
|
value: 0,
|
|
inclusive: true,
|
|
message: errorUtil.toString(message)
|
|
});
|
|
}
|
|
nonnegative(message) {
|
|
return this._addCheck({
|
|
kind: "min",
|
|
value: 0,
|
|
inclusive: true,
|
|
message: errorUtil.toString(message)
|
|
});
|
|
}
|
|
multipleOf(value, message) {
|
|
return this._addCheck({
|
|
kind: "multipleOf",
|
|
value,
|
|
message: errorUtil.toString(message)
|
|
});
|
|
}
|
|
finite(message) {
|
|
return this._addCheck({
|
|
kind: "finite",
|
|
message: errorUtil.toString(message)
|
|
});
|
|
}
|
|
safe(message) {
|
|
return this._addCheck({
|
|
kind: "min",
|
|
inclusive: true,
|
|
value: Number.MIN_SAFE_INTEGER,
|
|
message: errorUtil.toString(message)
|
|
})._addCheck({
|
|
kind: "max",
|
|
inclusive: true,
|
|
value: Number.MAX_SAFE_INTEGER,
|
|
message: errorUtil.toString(message)
|
|
});
|
|
}
|
|
get minValue() {
|
|
let min = null;
|
|
for (const ch of this._def.checks) {
|
|
if (ch.kind === "min") {
|
|
if (min === null || ch.value > min)
|
|
min = ch.value;
|
|
}
|
|
}
|
|
return min;
|
|
}
|
|
get maxValue() {
|
|
let max = null;
|
|
for (const ch of this._def.checks) {
|
|
if (ch.kind === "max") {
|
|
if (max === null || ch.value < max)
|
|
max = ch.value;
|
|
}
|
|
}
|
|
return max;
|
|
}
|
|
get isInt() {
|
|
return !!this._def.checks.find((ch) => ch.kind === "int" || ch.kind === "multipleOf" && util.isInteger(ch.value));
|
|
}
|
|
get isFinite() {
|
|
let max = null;
|
|
let min = null;
|
|
for (const ch of this._def.checks) {
|
|
if (ch.kind === "finite" || ch.kind === "int" || ch.kind === "multipleOf") {
|
|
return true;
|
|
} else if (ch.kind === "min") {
|
|
if (min === null || ch.value > min)
|
|
min = ch.value;
|
|
} else if (ch.kind === "max") {
|
|
if (max === null || ch.value < max)
|
|
max = ch.value;
|
|
}
|
|
}
|
|
return Number.isFinite(min) && Number.isFinite(max);
|
|
}
|
|
}
|
|
ZodNumber.create = (params) => {
|
|
return new ZodNumber({
|
|
checks: [],
|
|
typeName: ZodFirstPartyTypeKind.ZodNumber,
|
|
coerce: params?.coerce || false,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodBigInt extends ZodType {
|
|
constructor() {
|
|
super(...arguments);
|
|
this.min = this.gte;
|
|
this.max = this.lte;
|
|
}
|
|
_parse(input) {
|
|
if (this._def.coerce) {
|
|
try {
|
|
input.data = BigInt(input.data);
|
|
} catch {
|
|
return this._getInvalidInput(input);
|
|
}
|
|
}
|
|
const parsedType = this._getType(input);
|
|
if (parsedType !== ZodParsedType.bigint) {
|
|
return this._getInvalidInput(input);
|
|
}
|
|
let ctx = undefined;
|
|
const status = new ParseStatus;
|
|
for (const check of this._def.checks) {
|
|
if (check.kind === "min") {
|
|
const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
|
|
if (tooSmall) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.too_small,
|
|
type: "bigint",
|
|
minimum: check.value,
|
|
inclusive: check.inclusive,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "max") {
|
|
const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
|
|
if (tooBig) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.too_big,
|
|
type: "bigint",
|
|
maximum: check.value,
|
|
inclusive: check.inclusive,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "multipleOf") {
|
|
if (input.data % check.value !== BigInt(0)) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.not_multiple_of,
|
|
multipleOf: check.value,
|
|
message: check.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else {
|
|
util.assertNever(check);
|
|
}
|
|
}
|
|
return { status: status.value, value: input.data };
|
|
}
|
|
_getInvalidInput(input) {
|
|
const ctx = this._getOrReturnCtx(input);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: ZodParsedType.bigint,
|
|
received: ctx.parsedType
|
|
});
|
|
return INVALID;
|
|
}
|
|
gte(value, message) {
|
|
return this.setLimit("min", value, true, errorUtil.toString(message));
|
|
}
|
|
gt(value, message) {
|
|
return this.setLimit("min", value, false, errorUtil.toString(message));
|
|
}
|
|
lte(value, message) {
|
|
return this.setLimit("max", value, true, errorUtil.toString(message));
|
|
}
|
|
lt(value, message) {
|
|
return this.setLimit("max", value, false, errorUtil.toString(message));
|
|
}
|
|
setLimit(kind, value, inclusive, message) {
|
|
return new ZodBigInt({
|
|
...this._def,
|
|
checks: [
|
|
...this._def.checks,
|
|
{
|
|
kind,
|
|
value,
|
|
inclusive,
|
|
message: errorUtil.toString(message)
|
|
}
|
|
]
|
|
});
|
|
}
|
|
_addCheck(check) {
|
|
return new ZodBigInt({
|
|
...this._def,
|
|
checks: [...this._def.checks, check]
|
|
});
|
|
}
|
|
positive(message) {
|
|
return this._addCheck({
|
|
kind: "min",
|
|
value: BigInt(0),
|
|
inclusive: false,
|
|
message: errorUtil.toString(message)
|
|
});
|
|
}
|
|
negative(message) {
|
|
return this._addCheck({
|
|
kind: "max",
|
|
value: BigInt(0),
|
|
inclusive: false,
|
|
message: errorUtil.toString(message)
|
|
});
|
|
}
|
|
nonpositive(message) {
|
|
return this._addCheck({
|
|
kind: "max",
|
|
value: BigInt(0),
|
|
inclusive: true,
|
|
message: errorUtil.toString(message)
|
|
});
|
|
}
|
|
nonnegative(message) {
|
|
return this._addCheck({
|
|
kind: "min",
|
|
value: BigInt(0),
|
|
inclusive: true,
|
|
message: errorUtil.toString(message)
|
|
});
|
|
}
|
|
multipleOf(value, message) {
|
|
return this._addCheck({
|
|
kind: "multipleOf",
|
|
value,
|
|
message: errorUtil.toString(message)
|
|
});
|
|
}
|
|
get minValue() {
|
|
let min = null;
|
|
for (const ch of this._def.checks) {
|
|
if (ch.kind === "min") {
|
|
if (min === null || ch.value > min)
|
|
min = ch.value;
|
|
}
|
|
}
|
|
return min;
|
|
}
|
|
get maxValue() {
|
|
let max = null;
|
|
for (const ch of this._def.checks) {
|
|
if (ch.kind === "max") {
|
|
if (max === null || ch.value < max)
|
|
max = ch.value;
|
|
}
|
|
}
|
|
return max;
|
|
}
|
|
}
|
|
ZodBigInt.create = (params) => {
|
|
return new ZodBigInt({
|
|
checks: [],
|
|
typeName: ZodFirstPartyTypeKind.ZodBigInt,
|
|
coerce: params?.coerce ?? false,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodBoolean extends ZodType {
|
|
_parse(input) {
|
|
if (this._def.coerce) {
|
|
input.data = Boolean(input.data);
|
|
}
|
|
const parsedType = this._getType(input);
|
|
if (parsedType !== ZodParsedType.boolean) {
|
|
const ctx = this._getOrReturnCtx(input);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: ZodParsedType.boolean,
|
|
received: ctx.parsedType
|
|
});
|
|
return INVALID;
|
|
}
|
|
return OK(input.data);
|
|
}
|
|
}
|
|
ZodBoolean.create = (params) => {
|
|
return new ZodBoolean({
|
|
typeName: ZodFirstPartyTypeKind.ZodBoolean,
|
|
coerce: params?.coerce || false,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodDate extends ZodType {
|
|
_parse(input) {
|
|
if (this._def.coerce) {
|
|
input.data = new Date(input.data);
|
|
}
|
|
const parsedType = this._getType(input);
|
|
if (parsedType !== ZodParsedType.date) {
|
|
const ctx2 = this._getOrReturnCtx(input);
|
|
addIssueToContext(ctx2, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: ZodParsedType.date,
|
|
received: ctx2.parsedType
|
|
});
|
|
return INVALID;
|
|
}
|
|
if (Number.isNaN(input.data.getTime())) {
|
|
const ctx2 = this._getOrReturnCtx(input);
|
|
addIssueToContext(ctx2, {
|
|
code: ZodIssueCode.invalid_date
|
|
});
|
|
return INVALID;
|
|
}
|
|
const status = new ParseStatus;
|
|
let ctx = undefined;
|
|
for (const check of this._def.checks) {
|
|
if (check.kind === "min") {
|
|
if (input.data.getTime() < check.value) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.too_small,
|
|
message: check.message,
|
|
inclusive: true,
|
|
exact: false,
|
|
minimum: check.value,
|
|
type: "date"
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (check.kind === "max") {
|
|
if (input.data.getTime() > check.value) {
|
|
ctx = this._getOrReturnCtx(input, ctx);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.too_big,
|
|
message: check.message,
|
|
inclusive: true,
|
|
exact: false,
|
|
maximum: check.value,
|
|
type: "date"
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else {
|
|
util.assertNever(check);
|
|
}
|
|
}
|
|
return {
|
|
status: status.value,
|
|
value: new Date(input.data.getTime())
|
|
};
|
|
}
|
|
_addCheck(check) {
|
|
return new ZodDate({
|
|
...this._def,
|
|
checks: [...this._def.checks, check]
|
|
});
|
|
}
|
|
min(minDate, message) {
|
|
return this._addCheck({
|
|
kind: "min",
|
|
value: minDate.getTime(),
|
|
message: errorUtil.toString(message)
|
|
});
|
|
}
|
|
max(maxDate, message) {
|
|
return this._addCheck({
|
|
kind: "max",
|
|
value: maxDate.getTime(),
|
|
message: errorUtil.toString(message)
|
|
});
|
|
}
|
|
get minDate() {
|
|
let min = null;
|
|
for (const ch of this._def.checks) {
|
|
if (ch.kind === "min") {
|
|
if (min === null || ch.value > min)
|
|
min = ch.value;
|
|
}
|
|
}
|
|
return min != null ? new Date(min) : null;
|
|
}
|
|
get maxDate() {
|
|
let max = null;
|
|
for (const ch of this._def.checks) {
|
|
if (ch.kind === "max") {
|
|
if (max === null || ch.value < max)
|
|
max = ch.value;
|
|
}
|
|
}
|
|
return max != null ? new Date(max) : null;
|
|
}
|
|
}
|
|
ZodDate.create = (params) => {
|
|
return new ZodDate({
|
|
checks: [],
|
|
coerce: params?.coerce || false,
|
|
typeName: ZodFirstPartyTypeKind.ZodDate,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodSymbol extends ZodType {
|
|
_parse(input) {
|
|
const parsedType = this._getType(input);
|
|
if (parsedType !== ZodParsedType.symbol) {
|
|
const ctx = this._getOrReturnCtx(input);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: ZodParsedType.symbol,
|
|
received: ctx.parsedType
|
|
});
|
|
return INVALID;
|
|
}
|
|
return OK(input.data);
|
|
}
|
|
}
|
|
ZodSymbol.create = (params) => {
|
|
return new ZodSymbol({
|
|
typeName: ZodFirstPartyTypeKind.ZodSymbol,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodUndefined extends ZodType {
|
|
_parse(input) {
|
|
const parsedType = this._getType(input);
|
|
if (parsedType !== ZodParsedType.undefined) {
|
|
const ctx = this._getOrReturnCtx(input);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: ZodParsedType.undefined,
|
|
received: ctx.parsedType
|
|
});
|
|
return INVALID;
|
|
}
|
|
return OK(input.data);
|
|
}
|
|
}
|
|
ZodUndefined.create = (params) => {
|
|
return new ZodUndefined({
|
|
typeName: ZodFirstPartyTypeKind.ZodUndefined,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodNull extends ZodType {
|
|
_parse(input) {
|
|
const parsedType = this._getType(input);
|
|
if (parsedType !== ZodParsedType.null) {
|
|
const ctx = this._getOrReturnCtx(input);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: ZodParsedType.null,
|
|
received: ctx.parsedType
|
|
});
|
|
return INVALID;
|
|
}
|
|
return OK(input.data);
|
|
}
|
|
}
|
|
ZodNull.create = (params) => {
|
|
return new ZodNull({
|
|
typeName: ZodFirstPartyTypeKind.ZodNull,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodAny extends ZodType {
|
|
constructor() {
|
|
super(...arguments);
|
|
this._any = true;
|
|
}
|
|
_parse(input) {
|
|
return OK(input.data);
|
|
}
|
|
}
|
|
ZodAny.create = (params) => {
|
|
return new ZodAny({
|
|
typeName: ZodFirstPartyTypeKind.ZodAny,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodUnknown extends ZodType {
|
|
constructor() {
|
|
super(...arguments);
|
|
this._unknown = true;
|
|
}
|
|
_parse(input) {
|
|
return OK(input.data);
|
|
}
|
|
}
|
|
ZodUnknown.create = (params) => {
|
|
return new ZodUnknown({
|
|
typeName: ZodFirstPartyTypeKind.ZodUnknown,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodNever extends ZodType {
|
|
_parse(input) {
|
|
const ctx = this._getOrReturnCtx(input);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: ZodParsedType.never,
|
|
received: ctx.parsedType
|
|
});
|
|
return INVALID;
|
|
}
|
|
}
|
|
ZodNever.create = (params) => {
|
|
return new ZodNever({
|
|
typeName: ZodFirstPartyTypeKind.ZodNever,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodVoid extends ZodType {
|
|
_parse(input) {
|
|
const parsedType = this._getType(input);
|
|
if (parsedType !== ZodParsedType.undefined) {
|
|
const ctx = this._getOrReturnCtx(input);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: ZodParsedType.void,
|
|
received: ctx.parsedType
|
|
});
|
|
return INVALID;
|
|
}
|
|
return OK(input.data);
|
|
}
|
|
}
|
|
ZodVoid.create = (params) => {
|
|
return new ZodVoid({
|
|
typeName: ZodFirstPartyTypeKind.ZodVoid,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodArray extends ZodType {
|
|
_parse(input) {
|
|
const { ctx, status } = this._processInputParams(input);
|
|
const def = this._def;
|
|
if (ctx.parsedType !== ZodParsedType.array) {
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: ZodParsedType.array,
|
|
received: ctx.parsedType
|
|
});
|
|
return INVALID;
|
|
}
|
|
if (def.exactLength !== null) {
|
|
const tooBig = ctx.data.length > def.exactLength.value;
|
|
const tooSmall = ctx.data.length < def.exactLength.value;
|
|
if (tooBig || tooSmall) {
|
|
addIssueToContext(ctx, {
|
|
code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small,
|
|
minimum: tooSmall ? def.exactLength.value : undefined,
|
|
maximum: tooBig ? def.exactLength.value : undefined,
|
|
type: "array",
|
|
inclusive: true,
|
|
exact: true,
|
|
message: def.exactLength.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
}
|
|
if (def.minLength !== null) {
|
|
if (ctx.data.length < def.minLength.value) {
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.too_small,
|
|
minimum: def.minLength.value,
|
|
type: "array",
|
|
inclusive: true,
|
|
exact: false,
|
|
message: def.minLength.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
}
|
|
if (def.maxLength !== null) {
|
|
if (ctx.data.length > def.maxLength.value) {
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.too_big,
|
|
maximum: def.maxLength.value,
|
|
type: "array",
|
|
inclusive: true,
|
|
exact: false,
|
|
message: def.maxLength.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
}
|
|
if (ctx.common.async) {
|
|
return Promise.all([...ctx.data].map((item, i) => {
|
|
return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
|
|
})).then((result2) => {
|
|
return ParseStatus.mergeArray(status, result2);
|
|
});
|
|
}
|
|
const result = [...ctx.data].map((item, i) => {
|
|
return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
|
|
});
|
|
return ParseStatus.mergeArray(status, result);
|
|
}
|
|
get element() {
|
|
return this._def.type;
|
|
}
|
|
min(minLength, message) {
|
|
return new ZodArray({
|
|
...this._def,
|
|
minLength: { value: minLength, message: errorUtil.toString(message) }
|
|
});
|
|
}
|
|
max(maxLength, message) {
|
|
return new ZodArray({
|
|
...this._def,
|
|
maxLength: { value: maxLength, message: errorUtil.toString(message) }
|
|
});
|
|
}
|
|
length(len, message) {
|
|
return new ZodArray({
|
|
...this._def,
|
|
exactLength: { value: len, message: errorUtil.toString(message) }
|
|
});
|
|
}
|
|
nonempty(message) {
|
|
return this.min(1, message);
|
|
}
|
|
}
|
|
ZodArray.create = (schema, params) => {
|
|
return new ZodArray({
|
|
type: schema,
|
|
minLength: null,
|
|
maxLength: null,
|
|
exactLength: null,
|
|
typeName: ZodFirstPartyTypeKind.ZodArray,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
function deepPartialify(schema) {
|
|
if (schema instanceof ZodObject) {
|
|
const newShape = {};
|
|
for (const key in schema.shape) {
|
|
const fieldSchema = schema.shape[key];
|
|
newShape[key] = ZodOptional.create(deepPartialify(fieldSchema));
|
|
}
|
|
return new ZodObject({
|
|
...schema._def,
|
|
shape: () => newShape
|
|
});
|
|
} else if (schema instanceof ZodArray) {
|
|
return new ZodArray({
|
|
...schema._def,
|
|
type: deepPartialify(schema.element)
|
|
});
|
|
} else if (schema instanceof ZodOptional) {
|
|
return ZodOptional.create(deepPartialify(schema.unwrap()));
|
|
} else if (schema instanceof ZodNullable) {
|
|
return ZodNullable.create(deepPartialify(schema.unwrap()));
|
|
} else if (schema instanceof ZodTuple) {
|
|
return ZodTuple.create(schema.items.map((item) => deepPartialify(item)));
|
|
} else {
|
|
return schema;
|
|
}
|
|
}
|
|
|
|
class ZodObject extends ZodType {
|
|
constructor() {
|
|
super(...arguments);
|
|
this._cached = null;
|
|
this.nonstrict = this.passthrough;
|
|
this.augment = this.extend;
|
|
}
|
|
_getCached() {
|
|
if (this._cached !== null)
|
|
return this._cached;
|
|
const shape = this._def.shape();
|
|
const keys = util.objectKeys(shape);
|
|
this._cached = { shape, keys };
|
|
return this._cached;
|
|
}
|
|
_parse(input) {
|
|
const parsedType = this._getType(input);
|
|
if (parsedType !== ZodParsedType.object) {
|
|
const ctx2 = this._getOrReturnCtx(input);
|
|
addIssueToContext(ctx2, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: ZodParsedType.object,
|
|
received: ctx2.parsedType
|
|
});
|
|
return INVALID;
|
|
}
|
|
const { status, ctx } = this._processInputParams(input);
|
|
const { shape, keys: shapeKeys } = this._getCached();
|
|
const extraKeys = [];
|
|
if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
|
|
for (const key in ctx.data) {
|
|
if (!shapeKeys.includes(key)) {
|
|
extraKeys.push(key);
|
|
}
|
|
}
|
|
}
|
|
const pairs = [];
|
|
for (const key of shapeKeys) {
|
|
const keyValidator = shape[key];
|
|
const value = ctx.data[key];
|
|
pairs.push({
|
|
key: { status: "valid", value: key },
|
|
value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
|
|
alwaysSet: key in ctx.data
|
|
});
|
|
}
|
|
if (this._def.catchall instanceof ZodNever) {
|
|
const unknownKeys = this._def.unknownKeys;
|
|
if (unknownKeys === "passthrough") {
|
|
for (const key of extraKeys) {
|
|
pairs.push({
|
|
key: { status: "valid", value: key },
|
|
value: { status: "valid", value: ctx.data[key] }
|
|
});
|
|
}
|
|
} else if (unknownKeys === "strict") {
|
|
if (extraKeys.length > 0) {
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.unrecognized_keys,
|
|
keys: extraKeys
|
|
});
|
|
status.dirty();
|
|
}
|
|
} else if (unknownKeys === "strip") {} else {
|
|
throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
|
|
}
|
|
} else {
|
|
const catchall = this._def.catchall;
|
|
for (const key of extraKeys) {
|
|
const value = ctx.data[key];
|
|
pairs.push({
|
|
key: { status: "valid", value: key },
|
|
value: catchall._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
|
|
alwaysSet: key in ctx.data
|
|
});
|
|
}
|
|
}
|
|
if (ctx.common.async) {
|
|
return Promise.resolve().then(async () => {
|
|
const syncPairs = [];
|
|
for (const pair of pairs) {
|
|
const key = await pair.key;
|
|
const value = await pair.value;
|
|
syncPairs.push({
|
|
key,
|
|
value,
|
|
alwaysSet: pair.alwaysSet
|
|
});
|
|
}
|
|
return syncPairs;
|
|
}).then((syncPairs) => {
|
|
return ParseStatus.mergeObjectSync(status, syncPairs);
|
|
});
|
|
} else {
|
|
return ParseStatus.mergeObjectSync(status, pairs);
|
|
}
|
|
}
|
|
get shape() {
|
|
return this._def.shape();
|
|
}
|
|
strict(message) {
|
|
errorUtil.errToObj;
|
|
return new ZodObject({
|
|
...this._def,
|
|
unknownKeys: "strict",
|
|
...message !== undefined ? {
|
|
errorMap: (issue, ctx) => {
|
|
const defaultError = this._def.errorMap?.(issue, ctx).message ?? ctx.defaultError;
|
|
if (issue.code === "unrecognized_keys")
|
|
return {
|
|
message: errorUtil.errToObj(message).message ?? defaultError
|
|
};
|
|
return {
|
|
message: defaultError
|
|
};
|
|
}
|
|
} : {}
|
|
});
|
|
}
|
|
strip() {
|
|
return new ZodObject({
|
|
...this._def,
|
|
unknownKeys: "strip"
|
|
});
|
|
}
|
|
passthrough() {
|
|
return new ZodObject({
|
|
...this._def,
|
|
unknownKeys: "passthrough"
|
|
});
|
|
}
|
|
extend(augmentation) {
|
|
return new ZodObject({
|
|
...this._def,
|
|
shape: () => ({
|
|
...this._def.shape(),
|
|
...augmentation
|
|
})
|
|
});
|
|
}
|
|
merge(merging) {
|
|
const merged = new ZodObject({
|
|
unknownKeys: merging._def.unknownKeys,
|
|
catchall: merging._def.catchall,
|
|
shape: () => ({
|
|
...this._def.shape(),
|
|
...merging._def.shape()
|
|
}),
|
|
typeName: ZodFirstPartyTypeKind.ZodObject
|
|
});
|
|
return merged;
|
|
}
|
|
setKey(key, schema) {
|
|
return this.augment({ [key]: schema });
|
|
}
|
|
catchall(index) {
|
|
return new ZodObject({
|
|
...this._def,
|
|
catchall: index
|
|
});
|
|
}
|
|
pick(mask) {
|
|
const shape = {};
|
|
for (const key of util.objectKeys(mask)) {
|
|
if (mask[key] && this.shape[key]) {
|
|
shape[key] = this.shape[key];
|
|
}
|
|
}
|
|
return new ZodObject({
|
|
...this._def,
|
|
shape: () => shape
|
|
});
|
|
}
|
|
omit(mask) {
|
|
const shape = {};
|
|
for (const key of util.objectKeys(this.shape)) {
|
|
if (!mask[key]) {
|
|
shape[key] = this.shape[key];
|
|
}
|
|
}
|
|
return new ZodObject({
|
|
...this._def,
|
|
shape: () => shape
|
|
});
|
|
}
|
|
deepPartial() {
|
|
return deepPartialify(this);
|
|
}
|
|
partial(mask) {
|
|
const newShape = {};
|
|
for (const key of util.objectKeys(this.shape)) {
|
|
const fieldSchema = this.shape[key];
|
|
if (mask && !mask[key]) {
|
|
newShape[key] = fieldSchema;
|
|
} else {
|
|
newShape[key] = fieldSchema.optional();
|
|
}
|
|
}
|
|
return new ZodObject({
|
|
...this._def,
|
|
shape: () => newShape
|
|
});
|
|
}
|
|
required(mask) {
|
|
const newShape = {};
|
|
for (const key of util.objectKeys(this.shape)) {
|
|
if (mask && !mask[key]) {
|
|
newShape[key] = this.shape[key];
|
|
} else {
|
|
const fieldSchema = this.shape[key];
|
|
let newField = fieldSchema;
|
|
while (newField instanceof ZodOptional) {
|
|
newField = newField._def.innerType;
|
|
}
|
|
newShape[key] = newField;
|
|
}
|
|
}
|
|
return new ZodObject({
|
|
...this._def,
|
|
shape: () => newShape
|
|
});
|
|
}
|
|
keyof() {
|
|
return createZodEnum(util.objectKeys(this.shape));
|
|
}
|
|
}
|
|
ZodObject.create = (shape, params) => {
|
|
return new ZodObject({
|
|
shape: () => shape,
|
|
unknownKeys: "strip",
|
|
catchall: ZodNever.create(),
|
|
typeName: ZodFirstPartyTypeKind.ZodObject,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
ZodObject.strictCreate = (shape, params) => {
|
|
return new ZodObject({
|
|
shape: () => shape,
|
|
unknownKeys: "strict",
|
|
catchall: ZodNever.create(),
|
|
typeName: ZodFirstPartyTypeKind.ZodObject,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
ZodObject.lazycreate = (shape, params) => {
|
|
return new ZodObject({
|
|
shape,
|
|
unknownKeys: "strip",
|
|
catchall: ZodNever.create(),
|
|
typeName: ZodFirstPartyTypeKind.ZodObject,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodUnion extends ZodType {
|
|
_parse(input) {
|
|
const { ctx } = this._processInputParams(input);
|
|
const options = this._def.options;
|
|
function handleResults(results) {
|
|
for (const result of results) {
|
|
if (result.result.status === "valid") {
|
|
return result.result;
|
|
}
|
|
}
|
|
for (const result of results) {
|
|
if (result.result.status === "dirty") {
|
|
ctx.common.issues.push(...result.ctx.common.issues);
|
|
return result.result;
|
|
}
|
|
}
|
|
const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues));
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_union,
|
|
unionErrors
|
|
});
|
|
return INVALID;
|
|
}
|
|
if (ctx.common.async) {
|
|
return Promise.all(options.map(async (option) => {
|
|
const childCtx = {
|
|
...ctx,
|
|
common: {
|
|
...ctx.common,
|
|
issues: []
|
|
},
|
|
parent: null
|
|
};
|
|
return {
|
|
result: await option._parseAsync({
|
|
data: ctx.data,
|
|
path: ctx.path,
|
|
parent: childCtx
|
|
}),
|
|
ctx: childCtx
|
|
};
|
|
})).then(handleResults);
|
|
} else {
|
|
let dirty = undefined;
|
|
const issues = [];
|
|
for (const option of options) {
|
|
const childCtx = {
|
|
...ctx,
|
|
common: {
|
|
...ctx.common,
|
|
issues: []
|
|
},
|
|
parent: null
|
|
};
|
|
const result = option._parseSync({
|
|
data: ctx.data,
|
|
path: ctx.path,
|
|
parent: childCtx
|
|
});
|
|
if (result.status === "valid") {
|
|
return result;
|
|
} else if (result.status === "dirty" && !dirty) {
|
|
dirty = { result, ctx: childCtx };
|
|
}
|
|
if (childCtx.common.issues.length) {
|
|
issues.push(childCtx.common.issues);
|
|
}
|
|
}
|
|
if (dirty) {
|
|
ctx.common.issues.push(...dirty.ctx.common.issues);
|
|
return dirty.result;
|
|
}
|
|
const unionErrors = issues.map((issues2) => new ZodError(issues2));
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_union,
|
|
unionErrors
|
|
});
|
|
return INVALID;
|
|
}
|
|
}
|
|
get options() {
|
|
return this._def.options;
|
|
}
|
|
}
|
|
ZodUnion.create = (types, params) => {
|
|
return new ZodUnion({
|
|
options: types,
|
|
typeName: ZodFirstPartyTypeKind.ZodUnion,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
var getDiscriminator = (type) => {
|
|
if (type instanceof ZodLazy) {
|
|
return getDiscriminator(type.schema);
|
|
} else if (type instanceof ZodEffects) {
|
|
return getDiscriminator(type.innerType());
|
|
} else if (type instanceof ZodLiteral) {
|
|
return [type.value];
|
|
} else if (type instanceof ZodEnum) {
|
|
return type.options;
|
|
} else if (type instanceof ZodNativeEnum) {
|
|
return util.objectValues(type.enum);
|
|
} else if (type instanceof ZodDefault) {
|
|
return getDiscriminator(type._def.innerType);
|
|
} else if (type instanceof ZodUndefined) {
|
|
return [undefined];
|
|
} else if (type instanceof ZodNull) {
|
|
return [null];
|
|
} else if (type instanceof ZodOptional) {
|
|
return [undefined, ...getDiscriminator(type.unwrap())];
|
|
} else if (type instanceof ZodNullable) {
|
|
return [null, ...getDiscriminator(type.unwrap())];
|
|
} else if (type instanceof ZodBranded) {
|
|
return getDiscriminator(type.unwrap());
|
|
} else if (type instanceof ZodReadonly) {
|
|
return getDiscriminator(type.unwrap());
|
|
} else if (type instanceof ZodCatch) {
|
|
return getDiscriminator(type._def.innerType);
|
|
} else {
|
|
return [];
|
|
}
|
|
};
|
|
|
|
class ZodDiscriminatedUnion extends ZodType {
|
|
_parse(input) {
|
|
const { ctx } = this._processInputParams(input);
|
|
if (ctx.parsedType !== ZodParsedType.object) {
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: ZodParsedType.object,
|
|
received: ctx.parsedType
|
|
});
|
|
return INVALID;
|
|
}
|
|
const discriminator = this.discriminator;
|
|
const discriminatorValue = ctx.data[discriminator];
|
|
const option = this.optionsMap.get(discriminatorValue);
|
|
if (!option) {
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_union_discriminator,
|
|
options: Array.from(this.optionsMap.keys()),
|
|
path: [discriminator]
|
|
});
|
|
return INVALID;
|
|
}
|
|
if (ctx.common.async) {
|
|
return option._parseAsync({
|
|
data: ctx.data,
|
|
path: ctx.path,
|
|
parent: ctx
|
|
});
|
|
} else {
|
|
return option._parseSync({
|
|
data: ctx.data,
|
|
path: ctx.path,
|
|
parent: ctx
|
|
});
|
|
}
|
|
}
|
|
get discriminator() {
|
|
return this._def.discriminator;
|
|
}
|
|
get options() {
|
|
return this._def.options;
|
|
}
|
|
get optionsMap() {
|
|
return this._def.optionsMap;
|
|
}
|
|
static create(discriminator, options, params) {
|
|
const optionsMap = new Map;
|
|
for (const type of options) {
|
|
const discriminatorValues = getDiscriminator(type.shape[discriminator]);
|
|
if (!discriminatorValues.length) {
|
|
throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
|
|
}
|
|
for (const value of discriminatorValues) {
|
|
if (optionsMap.has(value)) {
|
|
throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);
|
|
}
|
|
optionsMap.set(value, type);
|
|
}
|
|
}
|
|
return new ZodDiscriminatedUnion({
|
|
typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
|
|
discriminator,
|
|
options,
|
|
optionsMap,
|
|
...processCreateParams(params)
|
|
});
|
|
}
|
|
}
|
|
function mergeValues(a, b) {
|
|
const aType = getParsedType(a);
|
|
const bType = getParsedType(b);
|
|
if (a === b) {
|
|
return { valid: true, data: a };
|
|
} else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
|
|
const bKeys = util.objectKeys(b);
|
|
const sharedKeys = util.objectKeys(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 };
|
|
}
|
|
newObj[key] = sharedValue.data;
|
|
}
|
|
return { valid: true, data: newObj };
|
|
} else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
|
|
if (a.length !== b.length) {
|
|
return { valid: false };
|
|
}
|
|
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 };
|
|
}
|
|
newArray.push(sharedValue.data);
|
|
}
|
|
return { valid: true, data: newArray };
|
|
} else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) {
|
|
return { valid: true, data: a };
|
|
} else {
|
|
return { valid: false };
|
|
}
|
|
}
|
|
|
|
class ZodIntersection extends ZodType {
|
|
_parse(input) {
|
|
const { status, ctx } = this._processInputParams(input);
|
|
const handleParsed = (parsedLeft, parsedRight) => {
|
|
if (isAborted(parsedLeft) || isAborted(parsedRight)) {
|
|
return INVALID;
|
|
}
|
|
const merged = mergeValues(parsedLeft.value, parsedRight.value);
|
|
if (!merged.valid) {
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_intersection_types
|
|
});
|
|
return INVALID;
|
|
}
|
|
if (isDirty(parsedLeft) || isDirty(parsedRight)) {
|
|
status.dirty();
|
|
}
|
|
return { status: status.value, value: merged.data };
|
|
};
|
|
if (ctx.common.async) {
|
|
return Promise.all([
|
|
this._def.left._parseAsync({
|
|
data: ctx.data,
|
|
path: ctx.path,
|
|
parent: ctx
|
|
}),
|
|
this._def.right._parseAsync({
|
|
data: ctx.data,
|
|
path: ctx.path,
|
|
parent: ctx
|
|
})
|
|
]).then(([left, right]) => handleParsed(left, right));
|
|
} else {
|
|
return handleParsed(this._def.left._parseSync({
|
|
data: ctx.data,
|
|
path: ctx.path,
|
|
parent: ctx
|
|
}), this._def.right._parseSync({
|
|
data: ctx.data,
|
|
path: ctx.path,
|
|
parent: ctx
|
|
}));
|
|
}
|
|
}
|
|
}
|
|
ZodIntersection.create = (left, right, params) => {
|
|
return new ZodIntersection({
|
|
left,
|
|
right,
|
|
typeName: ZodFirstPartyTypeKind.ZodIntersection,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodTuple extends ZodType {
|
|
_parse(input) {
|
|
const { status, ctx } = this._processInputParams(input);
|
|
if (ctx.parsedType !== ZodParsedType.array) {
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: ZodParsedType.array,
|
|
received: ctx.parsedType
|
|
});
|
|
return INVALID;
|
|
}
|
|
if (ctx.data.length < this._def.items.length) {
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.too_small,
|
|
minimum: this._def.items.length,
|
|
inclusive: true,
|
|
exact: false,
|
|
type: "array"
|
|
});
|
|
return INVALID;
|
|
}
|
|
const rest = this._def.rest;
|
|
if (!rest && ctx.data.length > this._def.items.length) {
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.too_big,
|
|
maximum: this._def.items.length,
|
|
inclusive: true,
|
|
exact: false,
|
|
type: "array"
|
|
});
|
|
status.dirty();
|
|
}
|
|
const items = [...ctx.data].map((item, itemIndex) => {
|
|
const schema = this._def.items[itemIndex] || this._def.rest;
|
|
if (!schema)
|
|
return null;
|
|
return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
|
|
}).filter((x) => !!x);
|
|
if (ctx.common.async) {
|
|
return Promise.all(items).then((results) => {
|
|
return ParseStatus.mergeArray(status, results);
|
|
});
|
|
} else {
|
|
return ParseStatus.mergeArray(status, items);
|
|
}
|
|
}
|
|
get items() {
|
|
return this._def.items;
|
|
}
|
|
rest(rest) {
|
|
return new ZodTuple({
|
|
...this._def,
|
|
rest
|
|
});
|
|
}
|
|
}
|
|
ZodTuple.create = (schemas, params) => {
|
|
if (!Array.isArray(schemas)) {
|
|
throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
|
|
}
|
|
return new ZodTuple({
|
|
items: schemas,
|
|
typeName: ZodFirstPartyTypeKind.ZodTuple,
|
|
rest: null,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodRecord extends ZodType {
|
|
get keySchema() {
|
|
return this._def.keyType;
|
|
}
|
|
get valueSchema() {
|
|
return this._def.valueType;
|
|
}
|
|
_parse(input) {
|
|
const { status, ctx } = this._processInputParams(input);
|
|
if (ctx.parsedType !== ZodParsedType.object) {
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: ZodParsedType.object,
|
|
received: ctx.parsedType
|
|
});
|
|
return INVALID;
|
|
}
|
|
const pairs = [];
|
|
const keyType = this._def.keyType;
|
|
const valueType = this._def.valueType;
|
|
for (const key in ctx.data) {
|
|
pairs.push({
|
|
key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
|
|
value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
|
|
alwaysSet: key in ctx.data
|
|
});
|
|
}
|
|
if (ctx.common.async) {
|
|
return ParseStatus.mergeObjectAsync(status, pairs);
|
|
} else {
|
|
return ParseStatus.mergeObjectSync(status, pairs);
|
|
}
|
|
}
|
|
get element() {
|
|
return this._def.valueType;
|
|
}
|
|
static create(first, second, third) {
|
|
if (second instanceof ZodType) {
|
|
return new ZodRecord({
|
|
keyType: first,
|
|
valueType: second,
|
|
typeName: ZodFirstPartyTypeKind.ZodRecord,
|
|
...processCreateParams(third)
|
|
});
|
|
}
|
|
return new ZodRecord({
|
|
keyType: ZodString.create(),
|
|
valueType: first,
|
|
typeName: ZodFirstPartyTypeKind.ZodRecord,
|
|
...processCreateParams(second)
|
|
});
|
|
}
|
|
}
|
|
|
|
class ZodMap extends ZodType {
|
|
get keySchema() {
|
|
return this._def.keyType;
|
|
}
|
|
get valueSchema() {
|
|
return this._def.valueType;
|
|
}
|
|
_parse(input) {
|
|
const { status, ctx } = this._processInputParams(input);
|
|
if (ctx.parsedType !== ZodParsedType.map) {
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: ZodParsedType.map,
|
|
received: ctx.parsedType
|
|
});
|
|
return INVALID;
|
|
}
|
|
const keyType = this._def.keyType;
|
|
const valueType = this._def.valueType;
|
|
const pairs = [...ctx.data.entries()].map(([key, value], index) => {
|
|
return {
|
|
key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
|
|
value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"]))
|
|
};
|
|
});
|
|
if (ctx.common.async) {
|
|
const finalMap = new Map;
|
|
return Promise.resolve().then(async () => {
|
|
for (const pair of pairs) {
|
|
const key = await pair.key;
|
|
const value = await pair.value;
|
|
if (key.status === "aborted" || value.status === "aborted") {
|
|
return INVALID;
|
|
}
|
|
if (key.status === "dirty" || value.status === "dirty") {
|
|
status.dirty();
|
|
}
|
|
finalMap.set(key.value, value.value);
|
|
}
|
|
return { status: status.value, value: finalMap };
|
|
});
|
|
} else {
|
|
const finalMap = new Map;
|
|
for (const pair of pairs) {
|
|
const key = pair.key;
|
|
const value = pair.value;
|
|
if (key.status === "aborted" || value.status === "aborted") {
|
|
return INVALID;
|
|
}
|
|
if (key.status === "dirty" || value.status === "dirty") {
|
|
status.dirty();
|
|
}
|
|
finalMap.set(key.value, value.value);
|
|
}
|
|
return { status: status.value, value: finalMap };
|
|
}
|
|
}
|
|
}
|
|
ZodMap.create = (keyType, valueType, params) => {
|
|
return new ZodMap({
|
|
valueType,
|
|
keyType,
|
|
typeName: ZodFirstPartyTypeKind.ZodMap,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodSet extends ZodType {
|
|
_parse(input) {
|
|
const { status, ctx } = this._processInputParams(input);
|
|
if (ctx.parsedType !== ZodParsedType.set) {
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: ZodParsedType.set,
|
|
received: ctx.parsedType
|
|
});
|
|
return INVALID;
|
|
}
|
|
const def = this._def;
|
|
if (def.minSize !== null) {
|
|
if (ctx.data.size < def.minSize.value) {
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.too_small,
|
|
minimum: def.minSize.value,
|
|
type: "set",
|
|
inclusive: true,
|
|
exact: false,
|
|
message: def.minSize.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
}
|
|
if (def.maxSize !== null) {
|
|
if (ctx.data.size > def.maxSize.value) {
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.too_big,
|
|
maximum: def.maxSize.value,
|
|
type: "set",
|
|
inclusive: true,
|
|
exact: false,
|
|
message: def.maxSize.message
|
|
});
|
|
status.dirty();
|
|
}
|
|
}
|
|
const valueType = this._def.valueType;
|
|
function finalizeSet(elements2) {
|
|
const parsedSet = new Set;
|
|
for (const element of elements2) {
|
|
if (element.status === "aborted")
|
|
return INVALID;
|
|
if (element.status === "dirty")
|
|
status.dirty();
|
|
parsedSet.add(element.value);
|
|
}
|
|
return { status: status.value, value: parsedSet };
|
|
}
|
|
const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
|
|
if (ctx.common.async) {
|
|
return Promise.all(elements).then((elements2) => finalizeSet(elements2));
|
|
} else {
|
|
return finalizeSet(elements);
|
|
}
|
|
}
|
|
min(minSize, message) {
|
|
return new ZodSet({
|
|
...this._def,
|
|
minSize: { value: minSize, message: errorUtil.toString(message) }
|
|
});
|
|
}
|
|
max(maxSize, message) {
|
|
return new ZodSet({
|
|
...this._def,
|
|
maxSize: { value: maxSize, message: errorUtil.toString(message) }
|
|
});
|
|
}
|
|
size(size, message) {
|
|
return this.min(size, message).max(size, message);
|
|
}
|
|
nonempty(message) {
|
|
return this.min(1, message);
|
|
}
|
|
}
|
|
ZodSet.create = (valueType, params) => {
|
|
return new ZodSet({
|
|
valueType,
|
|
minSize: null,
|
|
maxSize: null,
|
|
typeName: ZodFirstPartyTypeKind.ZodSet,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodFunction extends ZodType {
|
|
constructor() {
|
|
super(...arguments);
|
|
this.validate = this.implement;
|
|
}
|
|
_parse(input) {
|
|
const { ctx } = this._processInputParams(input);
|
|
if (ctx.parsedType !== ZodParsedType.function) {
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: ZodParsedType.function,
|
|
received: ctx.parsedType
|
|
});
|
|
return INVALID;
|
|
}
|
|
function makeArgsIssue(args, error) {
|
|
return makeIssue({
|
|
data: args,
|
|
path: ctx.path,
|
|
errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x),
|
|
issueData: {
|
|
code: ZodIssueCode.invalid_arguments,
|
|
argumentsError: error
|
|
}
|
|
});
|
|
}
|
|
function makeReturnsIssue(returns, error) {
|
|
return makeIssue({
|
|
data: returns,
|
|
path: ctx.path,
|
|
errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x),
|
|
issueData: {
|
|
code: ZodIssueCode.invalid_return_type,
|
|
returnTypeError: error
|
|
}
|
|
});
|
|
}
|
|
const params = { errorMap: ctx.common.contextualErrorMap };
|
|
const fn = ctx.data;
|
|
if (this._def.returns instanceof ZodPromise) {
|
|
const me = this;
|
|
return OK(async function(...args) {
|
|
const error = new ZodError([]);
|
|
const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
|
|
error.addIssue(makeArgsIssue(args, e));
|
|
throw error;
|
|
});
|
|
const result = await Reflect.apply(fn, this, parsedArgs);
|
|
const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
|
|
error.addIssue(makeReturnsIssue(result, e));
|
|
throw error;
|
|
});
|
|
return parsedReturns;
|
|
});
|
|
} else {
|
|
const me = this;
|
|
return OK(function(...args) {
|
|
const parsedArgs = me._def.args.safeParse(args, params);
|
|
if (!parsedArgs.success) {
|
|
throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
|
|
}
|
|
const result = Reflect.apply(fn, this, parsedArgs.data);
|
|
const parsedReturns = me._def.returns.safeParse(result, params);
|
|
if (!parsedReturns.success) {
|
|
throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
|
|
}
|
|
return parsedReturns.data;
|
|
});
|
|
}
|
|
}
|
|
parameters() {
|
|
return this._def.args;
|
|
}
|
|
returnType() {
|
|
return this._def.returns;
|
|
}
|
|
args(...items) {
|
|
return new ZodFunction({
|
|
...this._def,
|
|
args: ZodTuple.create(items).rest(ZodUnknown.create())
|
|
});
|
|
}
|
|
returns(returnType) {
|
|
return new ZodFunction({
|
|
...this._def,
|
|
returns: returnType
|
|
});
|
|
}
|
|
implement(func) {
|
|
const validatedFunc = this.parse(func);
|
|
return validatedFunc;
|
|
}
|
|
strictImplement(func) {
|
|
const validatedFunc = this.parse(func);
|
|
return validatedFunc;
|
|
}
|
|
static create(args, returns, params) {
|
|
return new ZodFunction({
|
|
args: args ? args : ZodTuple.create([]).rest(ZodUnknown.create()),
|
|
returns: returns || ZodUnknown.create(),
|
|
typeName: ZodFirstPartyTypeKind.ZodFunction,
|
|
...processCreateParams(params)
|
|
});
|
|
}
|
|
}
|
|
|
|
class ZodLazy extends ZodType {
|
|
get schema() {
|
|
return this._def.getter();
|
|
}
|
|
_parse(input) {
|
|
const { ctx } = this._processInputParams(input);
|
|
const lazySchema = this._def.getter();
|
|
return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
|
|
}
|
|
}
|
|
ZodLazy.create = (getter, params) => {
|
|
return new ZodLazy({
|
|
getter,
|
|
typeName: ZodFirstPartyTypeKind.ZodLazy,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodLiteral extends ZodType {
|
|
_parse(input) {
|
|
if (input.data !== this._def.value) {
|
|
const ctx = this._getOrReturnCtx(input);
|
|
addIssueToContext(ctx, {
|
|
received: ctx.data,
|
|
code: ZodIssueCode.invalid_literal,
|
|
expected: this._def.value
|
|
});
|
|
return INVALID;
|
|
}
|
|
return { status: "valid", value: input.data };
|
|
}
|
|
get value() {
|
|
return this._def.value;
|
|
}
|
|
}
|
|
ZodLiteral.create = (value, params) => {
|
|
return new ZodLiteral({
|
|
value,
|
|
typeName: ZodFirstPartyTypeKind.ZodLiteral,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
function createZodEnum(values, params) {
|
|
return new ZodEnum({
|
|
values,
|
|
typeName: ZodFirstPartyTypeKind.ZodEnum,
|
|
...processCreateParams(params)
|
|
});
|
|
}
|
|
|
|
class ZodEnum extends ZodType {
|
|
_parse(input) {
|
|
if (typeof input.data !== "string") {
|
|
const ctx = this._getOrReturnCtx(input);
|
|
const expectedValues = this._def.values;
|
|
addIssueToContext(ctx, {
|
|
expected: util.joinValues(expectedValues),
|
|
received: ctx.parsedType,
|
|
code: ZodIssueCode.invalid_type
|
|
});
|
|
return INVALID;
|
|
}
|
|
if (!this._cache) {
|
|
this._cache = new Set(this._def.values);
|
|
}
|
|
if (!this._cache.has(input.data)) {
|
|
const ctx = this._getOrReturnCtx(input);
|
|
const expectedValues = this._def.values;
|
|
addIssueToContext(ctx, {
|
|
received: ctx.data,
|
|
code: ZodIssueCode.invalid_enum_value,
|
|
options: expectedValues
|
|
});
|
|
return INVALID;
|
|
}
|
|
return OK(input.data);
|
|
}
|
|
get options() {
|
|
return this._def.values;
|
|
}
|
|
get enum() {
|
|
const enumValues = {};
|
|
for (const val of this._def.values) {
|
|
enumValues[val] = val;
|
|
}
|
|
return enumValues;
|
|
}
|
|
get Values() {
|
|
const enumValues = {};
|
|
for (const val of this._def.values) {
|
|
enumValues[val] = val;
|
|
}
|
|
return enumValues;
|
|
}
|
|
get Enum() {
|
|
const enumValues = {};
|
|
for (const val of this._def.values) {
|
|
enumValues[val] = val;
|
|
}
|
|
return enumValues;
|
|
}
|
|
extract(values, newDef = this._def) {
|
|
return ZodEnum.create(values, {
|
|
...this._def,
|
|
...newDef
|
|
});
|
|
}
|
|
exclude(values, newDef = this._def) {
|
|
return ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {
|
|
...this._def,
|
|
...newDef
|
|
});
|
|
}
|
|
}
|
|
ZodEnum.create = createZodEnum;
|
|
|
|
class ZodNativeEnum extends ZodType {
|
|
_parse(input) {
|
|
const nativeEnumValues = util.getValidEnumValues(this._def.values);
|
|
const ctx = this._getOrReturnCtx(input);
|
|
if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
|
|
const expectedValues = util.objectValues(nativeEnumValues);
|
|
addIssueToContext(ctx, {
|
|
expected: util.joinValues(expectedValues),
|
|
received: ctx.parsedType,
|
|
code: ZodIssueCode.invalid_type
|
|
});
|
|
return INVALID;
|
|
}
|
|
if (!this._cache) {
|
|
this._cache = new Set(util.getValidEnumValues(this._def.values));
|
|
}
|
|
if (!this._cache.has(input.data)) {
|
|
const expectedValues = util.objectValues(nativeEnumValues);
|
|
addIssueToContext(ctx, {
|
|
received: ctx.data,
|
|
code: ZodIssueCode.invalid_enum_value,
|
|
options: expectedValues
|
|
});
|
|
return INVALID;
|
|
}
|
|
return OK(input.data);
|
|
}
|
|
get enum() {
|
|
return this._def.values;
|
|
}
|
|
}
|
|
ZodNativeEnum.create = (values, params) => {
|
|
return new ZodNativeEnum({
|
|
values,
|
|
typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodPromise extends ZodType {
|
|
unwrap() {
|
|
return this._def.type;
|
|
}
|
|
_parse(input) {
|
|
const { ctx } = this._processInputParams(input);
|
|
if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: ZodParsedType.promise,
|
|
received: ctx.parsedType
|
|
});
|
|
return INVALID;
|
|
}
|
|
const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
|
|
return OK(promisified.then((data) => {
|
|
return this._def.type.parseAsync(data, {
|
|
path: ctx.path,
|
|
errorMap: ctx.common.contextualErrorMap
|
|
});
|
|
}));
|
|
}
|
|
}
|
|
ZodPromise.create = (schema, params) => {
|
|
return new ZodPromise({
|
|
type: schema,
|
|
typeName: ZodFirstPartyTypeKind.ZodPromise,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodEffects extends ZodType {
|
|
innerType() {
|
|
return this._def.schema;
|
|
}
|
|
sourceType() {
|
|
return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
|
|
}
|
|
_parse(input) {
|
|
const { status, ctx } = this._processInputParams(input);
|
|
const effect = this._def.effect || null;
|
|
const checkCtx = {
|
|
addIssue: (arg) => {
|
|
addIssueToContext(ctx, arg);
|
|
if (arg.fatal) {
|
|
status.abort();
|
|
} else {
|
|
status.dirty();
|
|
}
|
|
},
|
|
get path() {
|
|
return ctx.path;
|
|
}
|
|
};
|
|
checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
|
|
if (effect.type === "preprocess") {
|
|
const processed = effect.transform(ctx.data, checkCtx);
|
|
if (ctx.common.async) {
|
|
return Promise.resolve(processed).then(async (processed2) => {
|
|
if (status.value === "aborted")
|
|
return INVALID;
|
|
const result = await this._def.schema._parseAsync({
|
|
data: processed2,
|
|
path: ctx.path,
|
|
parent: ctx
|
|
});
|
|
if (result.status === "aborted")
|
|
return INVALID;
|
|
if (result.status === "dirty")
|
|
return DIRTY(result.value);
|
|
if (status.value === "dirty")
|
|
return DIRTY(result.value);
|
|
return result;
|
|
});
|
|
} else {
|
|
if (status.value === "aborted")
|
|
return INVALID;
|
|
const result = this._def.schema._parseSync({
|
|
data: processed,
|
|
path: ctx.path,
|
|
parent: ctx
|
|
});
|
|
if (result.status === "aborted")
|
|
return INVALID;
|
|
if (result.status === "dirty")
|
|
return DIRTY(result.value);
|
|
if (status.value === "dirty")
|
|
return DIRTY(result.value);
|
|
return result;
|
|
}
|
|
}
|
|
if (effect.type === "refinement") {
|
|
const executeRefinement = (acc) => {
|
|
const result = effect.refinement(acc, checkCtx);
|
|
if (ctx.common.async) {
|
|
return Promise.resolve(result);
|
|
}
|
|
if (result instanceof Promise) {
|
|
throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
|
|
}
|
|
return acc;
|
|
};
|
|
if (ctx.common.async === false) {
|
|
const inner = this._def.schema._parseSync({
|
|
data: ctx.data,
|
|
path: ctx.path,
|
|
parent: ctx
|
|
});
|
|
if (inner.status === "aborted")
|
|
return INVALID;
|
|
if (inner.status === "dirty")
|
|
status.dirty();
|
|
executeRefinement(inner.value);
|
|
return { status: status.value, value: inner.value };
|
|
} else {
|
|
return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
|
|
if (inner.status === "aborted")
|
|
return INVALID;
|
|
if (inner.status === "dirty")
|
|
status.dirty();
|
|
return executeRefinement(inner.value).then(() => {
|
|
return { status: status.value, value: inner.value };
|
|
});
|
|
});
|
|
}
|
|
}
|
|
if (effect.type === "transform") {
|
|
if (ctx.common.async === false) {
|
|
const base = this._def.schema._parseSync({
|
|
data: ctx.data,
|
|
path: ctx.path,
|
|
parent: ctx
|
|
});
|
|
if (!isValid(base))
|
|
return INVALID;
|
|
const result = effect.transform(base.value, checkCtx);
|
|
if (result instanceof Promise) {
|
|
throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
|
|
}
|
|
return { status: status.value, value: result };
|
|
} else {
|
|
return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
|
|
if (!isValid(base))
|
|
return INVALID;
|
|
return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
|
|
status: status.value,
|
|
value: result
|
|
}));
|
|
});
|
|
}
|
|
}
|
|
util.assertNever(effect);
|
|
}
|
|
}
|
|
ZodEffects.create = (schema, effect, params) => {
|
|
return new ZodEffects({
|
|
schema,
|
|
typeName: ZodFirstPartyTypeKind.ZodEffects,
|
|
effect,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
|
|
return new ZodEffects({
|
|
schema,
|
|
effect: { type: "preprocess", transform: preprocess },
|
|
typeName: ZodFirstPartyTypeKind.ZodEffects,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
class ZodOptional extends ZodType {
|
|
_parse(input) {
|
|
const parsedType = this._getType(input);
|
|
if (parsedType === ZodParsedType.undefined) {
|
|
return OK(undefined);
|
|
}
|
|
return this._def.innerType._parse(input);
|
|
}
|
|
unwrap() {
|
|
return this._def.innerType;
|
|
}
|
|
}
|
|
ZodOptional.create = (type, params) => {
|
|
return new ZodOptional({
|
|
innerType: type,
|
|
typeName: ZodFirstPartyTypeKind.ZodOptional,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodNullable extends ZodType {
|
|
_parse(input) {
|
|
const parsedType = this._getType(input);
|
|
if (parsedType === ZodParsedType.null) {
|
|
return OK(null);
|
|
}
|
|
return this._def.innerType._parse(input);
|
|
}
|
|
unwrap() {
|
|
return this._def.innerType;
|
|
}
|
|
}
|
|
ZodNullable.create = (type, params) => {
|
|
return new ZodNullable({
|
|
innerType: type,
|
|
typeName: ZodFirstPartyTypeKind.ZodNullable,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodDefault extends ZodType {
|
|
_parse(input) {
|
|
const { ctx } = this._processInputParams(input);
|
|
let data = ctx.data;
|
|
if (ctx.parsedType === ZodParsedType.undefined) {
|
|
data = this._def.defaultValue();
|
|
}
|
|
return this._def.innerType._parse({
|
|
data,
|
|
path: ctx.path,
|
|
parent: ctx
|
|
});
|
|
}
|
|
removeDefault() {
|
|
return this._def.innerType;
|
|
}
|
|
}
|
|
ZodDefault.create = (type, params) => {
|
|
return new ZodDefault({
|
|
innerType: type,
|
|
typeName: ZodFirstPartyTypeKind.ZodDefault,
|
|
defaultValue: typeof params.default === "function" ? params.default : () => params.default,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodCatch extends ZodType {
|
|
_parse(input) {
|
|
const { ctx } = this._processInputParams(input);
|
|
const newCtx = {
|
|
...ctx,
|
|
common: {
|
|
...ctx.common,
|
|
issues: []
|
|
}
|
|
};
|
|
const result = this._def.innerType._parse({
|
|
data: newCtx.data,
|
|
path: newCtx.path,
|
|
parent: {
|
|
...newCtx
|
|
}
|
|
});
|
|
if (isAsync(result)) {
|
|
return result.then((result2) => {
|
|
return {
|
|
status: "valid",
|
|
value: result2.status === "valid" ? result2.value : this._def.catchValue({
|
|
get error() {
|
|
return new ZodError(newCtx.common.issues);
|
|
},
|
|
input: newCtx.data
|
|
})
|
|
};
|
|
});
|
|
} else {
|
|
return {
|
|
status: "valid",
|
|
value: result.status === "valid" ? result.value : this._def.catchValue({
|
|
get error() {
|
|
return new ZodError(newCtx.common.issues);
|
|
},
|
|
input: newCtx.data
|
|
})
|
|
};
|
|
}
|
|
}
|
|
removeCatch() {
|
|
return this._def.innerType;
|
|
}
|
|
}
|
|
ZodCatch.create = (type, params) => {
|
|
return new ZodCatch({
|
|
innerType: type,
|
|
typeName: ZodFirstPartyTypeKind.ZodCatch,
|
|
catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
|
|
class ZodNaN extends ZodType {
|
|
_parse(input) {
|
|
const parsedType = this._getType(input);
|
|
if (parsedType !== ZodParsedType.nan) {
|
|
const ctx = this._getOrReturnCtx(input);
|
|
addIssueToContext(ctx, {
|
|
code: ZodIssueCode.invalid_type,
|
|
expected: ZodParsedType.nan,
|
|
received: ctx.parsedType
|
|
});
|
|
return INVALID;
|
|
}
|
|
return { status: "valid", value: input.data };
|
|
}
|
|
}
|
|
ZodNaN.create = (params) => {
|
|
return new ZodNaN({
|
|
typeName: ZodFirstPartyTypeKind.ZodNaN,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
var BRAND = Symbol("zod_brand");
|
|
|
|
class ZodBranded extends ZodType {
|
|
_parse(input) {
|
|
const { ctx } = this._processInputParams(input);
|
|
const data = ctx.data;
|
|
return this._def.type._parse({
|
|
data,
|
|
path: ctx.path,
|
|
parent: ctx
|
|
});
|
|
}
|
|
unwrap() {
|
|
return this._def.type;
|
|
}
|
|
}
|
|
|
|
class ZodPipeline extends ZodType {
|
|
_parse(input) {
|
|
const { status, ctx } = this._processInputParams(input);
|
|
if (ctx.common.async) {
|
|
const handleAsync = async () => {
|
|
const inResult = await this._def.in._parseAsync({
|
|
data: ctx.data,
|
|
path: ctx.path,
|
|
parent: ctx
|
|
});
|
|
if (inResult.status === "aborted")
|
|
return INVALID;
|
|
if (inResult.status === "dirty") {
|
|
status.dirty();
|
|
return DIRTY(inResult.value);
|
|
} else {
|
|
return this._def.out._parseAsync({
|
|
data: inResult.value,
|
|
path: ctx.path,
|
|
parent: ctx
|
|
});
|
|
}
|
|
};
|
|
return handleAsync();
|
|
} else {
|
|
const inResult = this._def.in._parseSync({
|
|
data: ctx.data,
|
|
path: ctx.path,
|
|
parent: ctx
|
|
});
|
|
if (inResult.status === "aborted")
|
|
return INVALID;
|
|
if (inResult.status === "dirty") {
|
|
status.dirty();
|
|
return {
|
|
status: "dirty",
|
|
value: inResult.value
|
|
};
|
|
} else {
|
|
return this._def.out._parseSync({
|
|
data: inResult.value,
|
|
path: ctx.path,
|
|
parent: ctx
|
|
});
|
|
}
|
|
}
|
|
}
|
|
static create(a, b) {
|
|
return new ZodPipeline({
|
|
in: a,
|
|
out: b,
|
|
typeName: ZodFirstPartyTypeKind.ZodPipeline
|
|
});
|
|
}
|
|
}
|
|
|
|
class ZodReadonly extends ZodType {
|
|
_parse(input) {
|
|
const result = this._def.innerType._parse(input);
|
|
const freeze = (data) => {
|
|
if (isValid(data)) {
|
|
data.value = Object.freeze(data.value);
|
|
}
|
|
return data;
|
|
};
|
|
return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
|
|
}
|
|
unwrap() {
|
|
return this._def.innerType;
|
|
}
|
|
}
|
|
ZodReadonly.create = (type, params) => {
|
|
return new ZodReadonly({
|
|
innerType: type,
|
|
typeName: ZodFirstPartyTypeKind.ZodReadonly,
|
|
...processCreateParams(params)
|
|
});
|
|
};
|
|
var late = {
|
|
object: ZodObject.lazycreate
|
|
};
|
|
var ZodFirstPartyTypeKind;
|
|
(function(ZodFirstPartyTypeKind2) {
|
|
ZodFirstPartyTypeKind2["ZodString"] = "ZodString";
|
|
ZodFirstPartyTypeKind2["ZodNumber"] = "ZodNumber";
|
|
ZodFirstPartyTypeKind2["ZodNaN"] = "ZodNaN";
|
|
ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt";
|
|
ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean";
|
|
ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate";
|
|
ZodFirstPartyTypeKind2["ZodSymbol"] = "ZodSymbol";
|
|
ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined";
|
|
ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull";
|
|
ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny";
|
|
ZodFirstPartyTypeKind2["ZodUnknown"] = "ZodUnknown";
|
|
ZodFirstPartyTypeKind2["ZodNever"] = "ZodNever";
|
|
ZodFirstPartyTypeKind2["ZodVoid"] = "ZodVoid";
|
|
ZodFirstPartyTypeKind2["ZodArray"] = "ZodArray";
|
|
ZodFirstPartyTypeKind2["ZodObject"] = "ZodObject";
|
|
ZodFirstPartyTypeKind2["ZodUnion"] = "ZodUnion";
|
|
ZodFirstPartyTypeKind2["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
|
|
ZodFirstPartyTypeKind2["ZodIntersection"] = "ZodIntersection";
|
|
ZodFirstPartyTypeKind2["ZodTuple"] = "ZodTuple";
|
|
ZodFirstPartyTypeKind2["ZodRecord"] = "ZodRecord";
|
|
ZodFirstPartyTypeKind2["ZodMap"] = "ZodMap";
|
|
ZodFirstPartyTypeKind2["ZodSet"] = "ZodSet";
|
|
ZodFirstPartyTypeKind2["ZodFunction"] = "ZodFunction";
|
|
ZodFirstPartyTypeKind2["ZodLazy"] = "ZodLazy";
|
|
ZodFirstPartyTypeKind2["ZodLiteral"] = "ZodLiteral";
|
|
ZodFirstPartyTypeKind2["ZodEnum"] = "ZodEnum";
|
|
ZodFirstPartyTypeKind2["ZodEffects"] = "ZodEffects";
|
|
ZodFirstPartyTypeKind2["ZodNativeEnum"] = "ZodNativeEnum";
|
|
ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional";
|
|
ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable";
|
|
ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault";
|
|
ZodFirstPartyTypeKind2["ZodCatch"] = "ZodCatch";
|
|
ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
|
|
ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded";
|
|
ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
|
|
ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
|
|
})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
|
|
var stringType = ZodString.create;
|
|
var numberType = ZodNumber.create;
|
|
var nanType = ZodNaN.create;
|
|
var bigIntType = ZodBigInt.create;
|
|
var booleanType = ZodBoolean.create;
|
|
var dateType = ZodDate.create;
|
|
var symbolType = ZodSymbol.create;
|
|
var undefinedType = ZodUndefined.create;
|
|
var nullType = ZodNull.create;
|
|
var anyType = ZodAny.create;
|
|
var unknownType = ZodUnknown.create;
|
|
var neverType = ZodNever.create;
|
|
var voidType = ZodVoid.create;
|
|
var arrayType = ZodArray.create;
|
|
var objectType = ZodObject.create;
|
|
var strictObjectType = ZodObject.strictCreate;
|
|
var unionType = ZodUnion.create;
|
|
var discriminatedUnionType = ZodDiscriminatedUnion.create;
|
|
var intersectionType = ZodIntersection.create;
|
|
var tupleType = ZodTuple.create;
|
|
var recordType = ZodRecord.create;
|
|
var mapType = ZodMap.create;
|
|
var setType = ZodSet.create;
|
|
var functionType = ZodFunction.create;
|
|
var lazyType = ZodLazy.create;
|
|
var literalType = ZodLiteral.create;
|
|
var enumType = ZodEnum.create;
|
|
var nativeEnumType = ZodNativeEnum.create;
|
|
var promiseType = ZodPromise.create;
|
|
var effectsType = ZodEffects.create;
|
|
var optionalType = ZodOptional.create;
|
|
var nullableType = ZodNullable.create;
|
|
var preprocessType = ZodEffects.createWithPreprocess;
|
|
var pipelineType = ZodPipeline.create;
|
|
|
|
// ../node_modules/zod/v4/core/core.js
|
|
var NEVER = Object.freeze({
|
|
status: "aborted"
|
|
});
|
|
function $constructor(name, initializer, params) {
|
|
function init(inst, def) {
|
|
var _a;
|
|
Object.defineProperty(inst, "_zod", {
|
|
value: inst._zod ?? {},
|
|
enumerable: false
|
|
});
|
|
(_a = inst._zod).traits ?? (_a.traits = new Set);
|
|
inst._zod.traits.add(name);
|
|
initializer(inst, def);
|
|
for (const k in _.prototype) {
|
|
if (!(k in inst))
|
|
Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
|
|
}
|
|
inst._zod.constr = _;
|
|
inst._zod.def = def;
|
|
}
|
|
const Parent = params?.Parent ?? Object;
|
|
|
|
class Definition extends Parent {
|
|
}
|
|
Object.defineProperty(Definition, "name", { value: name });
|
|
function _(def) {
|
|
var _a;
|
|
const inst = params?.Parent ? new Definition : this;
|
|
init(inst, def);
|
|
(_a = inst._zod).deferred ?? (_a.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.`);
|
|
}
|
|
}
|
|
var globalConfig = {};
|
|
function config(newConfig) {
|
|
if (newConfig)
|
|
Object.assign(globalConfig, newConfig);
|
|
return globalConfig;
|
|
}
|
|
// ../node_modules/zod/v4/core/util.js
|
|
var exports_util = {};
|
|
__export(exports_util, {
|
|
unwrapMessage: () => unwrapMessage,
|
|
stringifyPrimitive: () => stringifyPrimitive,
|
|
required: () => required,
|
|
randomString: () => randomString,
|
|
propertyKeyTypes: () => propertyKeyTypes,
|
|
promiseAllObject: () => promiseAllObject,
|
|
primitiveTypes: () => primitiveTypes,
|
|
prefixIssues: () => prefixIssues,
|
|
pick: () => pick,
|
|
partial: () => partial,
|
|
optionalKeys: () => optionalKeys,
|
|
omit: () => omit,
|
|
numKeys: () => numKeys,
|
|
nullish: () => nullish,
|
|
normalizeParams: () => normalizeParams,
|
|
merge: () => merge,
|
|
jsonStringifyReplacer: () => jsonStringifyReplacer,
|
|
joinValues: () => joinValues,
|
|
issue: () => issue,
|
|
isPlainObject: () => isPlainObject,
|
|
isObject: () => isObject2,
|
|
getSizableOrigin: () => getSizableOrigin,
|
|
getParsedType: () => getParsedType2,
|
|
getLengthableOrigin: () => getLengthableOrigin,
|
|
getEnumValues: () => getEnumValues,
|
|
getElementAtPath: () => getElementAtPath,
|
|
floatSafeRemainder: () => floatSafeRemainder2,
|
|
finalizeIssue: () => finalizeIssue,
|
|
extend: () => extend,
|
|
escapeRegex: () => escapeRegex,
|
|
esc: () => esc,
|
|
defineLazy: () => defineLazy,
|
|
createTransparentProxy: () => createTransparentProxy,
|
|
clone: () => clone,
|
|
cleanRegex: () => cleanRegex,
|
|
cleanEnum: () => cleanEnum,
|
|
captureStackTrace: () => captureStackTrace,
|
|
cached: () => cached,
|
|
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;
|
|
}
|
|
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 floatSafeRemainder2(val, step) {
|
|
const valDecCount = (val.toString().split(".")[1] || "").length;
|
|
const stepDecCount = (step.toString().split(".")[1] || "").length;
|
|
const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
|
|
const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
|
|
const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
|
|
return valInt % stepInt / 10 ** decCount;
|
|
}
|
|
function defineLazy(object, key, getter) {
|
|
const set = false;
|
|
Object.defineProperty(object, key, {
|
|
get() {
|
|
if (!set) {
|
|
const value = getter();
|
|
object[key] = value;
|
|
return value;
|
|
}
|
|
throw new Error("cached value already set");
|
|
},
|
|
set(v) {
|
|
Object.defineProperty(object, key, {
|
|
value: v
|
|
});
|
|
},
|
|
configurable: true
|
|
});
|
|
}
|
|
function assignProp(target, prop, value) {
|
|
Object.defineProperty(target, prop, {
|
|
value,
|
|
writable: true,
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
}
|
|
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);
|
|
}
|
|
var captureStackTrace = Error.captureStackTrace ? Error.captureStackTrace : (..._args) => {};
|
|
function isObject2(data) {
|
|
return typeof data === "object" && data !== null && !Array.isArray(data);
|
|
}
|
|
var allowsEval = cached(() => {
|
|
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 (isObject2(o) === false)
|
|
return false;
|
|
const ctor = o.constructor;
|
|
if (ctor === undefined)
|
|
return true;
|
|
const prot = ctor.prototype;
|
|
if (isObject2(prot) === false)
|
|
return false;
|
|
if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function numKeys(data) {
|
|
let keyCount = 0;
|
|
for (const key in data) {
|
|
if (Object.prototype.hasOwnProperty.call(data, key)) {
|
|
keyCount++;
|
|
}
|
|
}
|
|
return keyCount;
|
|
}
|
|
var getParsedType2 = (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 = new Set(["string", "number", "symbol"]);
|
|
var primitiveTypes = 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 newShape = {};
|
|
const currDef = schema._zod.def;
|
|
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];
|
|
}
|
|
return clone(schema, {
|
|
...schema._zod.def,
|
|
shape: newShape,
|
|
checks: []
|
|
});
|
|
}
|
|
function omit(schema, mask) {
|
|
const newShape = { ...schema._zod.def.shape };
|
|
const currDef = schema._zod.def;
|
|
for (const key in mask) {
|
|
if (!(key in currDef.shape)) {
|
|
throw new Error(`Unrecognized key: "${key}"`);
|
|
}
|
|
if (!mask[key])
|
|
continue;
|
|
delete newShape[key];
|
|
}
|
|
return clone(schema, {
|
|
...schema._zod.def,
|
|
shape: newShape,
|
|
checks: []
|
|
});
|
|
}
|
|
function extend(schema, shape) {
|
|
if (!isPlainObject(shape)) {
|
|
throw new Error("Invalid input to extend: expected a plain object");
|
|
}
|
|
const def = {
|
|
...schema._zod.def,
|
|
get shape() {
|
|
const _shape = { ...schema._zod.def.shape, ...shape };
|
|
assignProp(this, "shape", _shape);
|
|
return _shape;
|
|
},
|
|
checks: []
|
|
};
|
|
return clone(schema, def);
|
|
}
|
|
function merge(a, b) {
|
|
return clone(a, {
|
|
...a._zod.def,
|
|
get shape() {
|
|
const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
|
|
assignProp(this, "shape", _shape);
|
|
return _shape;
|
|
},
|
|
catchall: b._zod.def.catchall,
|
|
checks: []
|
|
});
|
|
}
|
|
function partial(Class, schema, mask) {
|
|
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];
|
|
}
|
|
}
|
|
return clone(schema, {
|
|
...schema._zod.def,
|
|
shape,
|
|
checks: []
|
|
});
|
|
}
|
|
function required(Class, schema, mask) {
|
|
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]
|
|
});
|
|
}
|
|
}
|
|
return clone(schema, {
|
|
...schema._zod.def,
|
|
shape,
|
|
checks: []
|
|
});
|
|
}
|
|
function aborted(x, startIndex = 0) {
|
|
for (let i = startIndex;i < x.issues.length; i++) {
|
|
if (x.issues[i]?.continue !== true)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function prefixIssues(path, issues) {
|
|
return issues.map((iss) => {
|
|
var _a;
|
|
(_a = iss).path ?? (_a.path = []);
|
|
iss.path.unshift(path);
|
|
return iss;
|
|
});
|
|
}
|
|
function unwrapMessage(message) {
|
|
return typeof message === "string" ? message : message?.message;
|
|
}
|
|
function finalizeIssue(iss, ctx, config2) {
|
|
const full = { ...iss, path: iss.path ?? [] };
|
|
if (!iss.message) {
|
|
const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
|
|
full.message = message;
|
|
}
|
|
delete full.inst;
|
|
delete full.continue;
|
|
if (!ctx?.reportInput) {
|
|
delete full.input;
|
|
}
|
|
return full;
|
|
}
|
|
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 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]);
|
|
}
|
|
|
|
class Class {
|
|
constructor(..._args) {}
|
|
}
|
|
|
|
// ../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
|
|
});
|
|
Object.defineProperty(inst, "message", {
|
|
get() {
|
|
return JSON.stringify(def, jsonStringifyReplacer, 2);
|
|
},
|
|
enumerable: true
|
|
});
|
|
};
|
|
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) {
|
|
const mapper = _mapper || function(issue2) {
|
|
return issue2.message;
|
|
};
|
|
const fieldErrors = { _errors: [] };
|
|
const processError = (error2) => {
|
|
for (const issue2 of error2.issues) {
|
|
if (issue2.code === "invalid_union" && issue2.errors.length) {
|
|
issue2.errors.map((issues) => processError({ issues }));
|
|
} else if (issue2.code === "invalid_key") {
|
|
processError({ issues: issue2.issues });
|
|
} else if (issue2.code === "invalid_element") {
|
|
processError({ issues: issue2.issues });
|
|
} else if (issue2.path.length === 0) {
|
|
fieldErrors._errors.push(mapper(issue2));
|
|
} else {
|
|
let curr = fieldErrors;
|
|
let i = 0;
|
|
while (i < issue2.path.length) {
|
|
const el = issue2.path[i];
|
|
const terminal = i === issue2.path.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/zod/v4/core/parse.js
|
|
var _parse = (_Err) => (schema, value, _ctx, _params) => {
|
|
const ctx = _ctx ? Object.assign(_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 parse = /* @__PURE__ */ _parse($ZodRealError);
|
|
var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
|
|
const ctx = _ctx ? Object.assign(_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 parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
|
|
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 ? Object.assign(_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);
|
|
// ../node_modules/zod/v4/core/regexes.js
|
|
var cuid = /^[cC][^\s-]{8,}$/;
|
|
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)$/;
|
|
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})?::([0-9a-fA-F]{1,4}:?){0,6})$/;
|
|
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 hostname = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
|
|
var e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
|
|
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(`([+-]\\d{2}:\\d{2})`);
|
|
const timeRegex2 = `${time2}(?:${opts.join("|")})`;
|
|
return new RegExp(`^${dateSource}T(?:${timeRegex2})$`);
|
|
}
|
|
var string = (params) => {
|
|
const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
|
|
return new RegExp(`^${regex}$`);
|
|
};
|
|
var integer = /^\d+$/;
|
|
var number = /^-?\d+(?:\.\d+)?/i;
|
|
var boolean = /true|false/i;
|
|
var _null = /null/i;
|
|
var lowercase = /^[^A-Z]*$/;
|
|
var uppercase = /^[^a-z]*$/;
|
|
|
|
// ../node_modules/zod/v4/core/checks.js
|
|
var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
|
|
var _a;
|
|
inst._zod ?? (inst._zod = {});
|
|
inst._zod.def = def;
|
|
(_a = inst._zod).onattach ?? (_a.onattach = []);
|
|
});
|
|
var numericOriginMap = {
|
|
number: "number",
|
|
bigint: "bigint",
|
|
object: "date"
|
|
};
|
|
var $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
const origin = numericOriginMap[typeof def.value];
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
|
|
if (def.value < curr) {
|
|
if (def.inclusive)
|
|
bag.maximum = def.value;
|
|
else
|
|
bag.exclusiveMaximum = def.value;
|
|
}
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
|
|
return;
|
|
}
|
|
payload.issues.push({
|
|
origin,
|
|
code: "too_big",
|
|
maximum: def.value,
|
|
input: payload.value,
|
|
inclusive: def.inclusive,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
const origin = numericOriginMap[typeof def.value];
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
|
|
if (def.value > curr) {
|
|
if (def.inclusive)
|
|
bag.minimum = def.value;
|
|
else
|
|
bag.exclusiveMinimum = def.value;
|
|
}
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
|
|
return;
|
|
}
|
|
payload.issues.push({
|
|
origin,
|
|
code: "too_small",
|
|
minimum: def.value,
|
|
input: payload.value,
|
|
inclusive: def.inclusive,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
inst._zod.onattach.push((inst2) => {
|
|
var _a;
|
|
(_a = inst2._zod.bag).multipleOf ?? (_a.multipleOf = def.value);
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (typeof payload.value !== typeof def.value)
|
|
throw new Error("Cannot mix number and bigint in multiple_of check.");
|
|
const isMultiple = typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : floatSafeRemainder2(payload.value, def.value) === 0;
|
|
if (isMultiple)
|
|
return;
|
|
payload.issues.push({
|
|
origin: typeof payload.value,
|
|
code: "not_multiple_of",
|
|
divisor: def.value,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
def.format = def.format || "float64";
|
|
const isInt = def.format?.includes("int");
|
|
const origin = isInt ? "int" : "number";
|
|
const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.format = def.format;
|
|
bag.minimum = minimum;
|
|
bag.maximum = maximum;
|
|
if (isInt)
|
|
bag.pattern = integer;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
if (isInt) {
|
|
if (!Number.isInteger(input)) {
|
|
payload.issues.push({
|
|
expected: origin,
|
|
format: def.format,
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return;
|
|
}
|
|
if (!Number.isSafeInteger(input)) {
|
|
if (input > 0) {
|
|
payload.issues.push({
|
|
input,
|
|
code: "too_big",
|
|
maximum: Number.MAX_SAFE_INTEGER,
|
|
note: "Integers must be within the safe integer range.",
|
|
inst,
|
|
origin,
|
|
continue: !def.abort
|
|
});
|
|
} else {
|
|
payload.issues.push({
|
|
input,
|
|
code: "too_small",
|
|
minimum: Number.MIN_SAFE_INTEGER,
|
|
note: "Integers must be within the safe integer range.",
|
|
inst,
|
|
origin,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
if (input < minimum) {
|
|
payload.issues.push({
|
|
origin: "number",
|
|
input,
|
|
code: "too_small",
|
|
minimum,
|
|
inclusive: true,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
if (input > maximum) {
|
|
payload.issues.push({
|
|
origin: "number",
|
|
input,
|
|
code: "too_big",
|
|
maximum,
|
|
inst
|
|
});
|
|
}
|
|
};
|
|
});
|
|
var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
inst._zod.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) => {
|
|
$ZodCheck.init(inst, def);
|
|
inst._zod.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) => {
|
|
$ZodCheck.init(inst, def);
|
|
inst._zod.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 _a, _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)
|
|
(_a = inst._zod).check ?? (_a.check = (payload) => {
|
|
def.pattern.lastIndex = 0;
|
|
if (def.pattern.test(payload.value))
|
|
return;
|
|
payload.issues.push({
|
|
origin: "string",
|
|
code: "invalid_format",
|
|
format: def.format,
|
|
input: payload.value,
|
|
...def.pattern ? { pattern: def.pattern.toString() } : {},
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
});
|
|
else
|
|
(_b = inst._zod).check ?? (_b.check = () => {});
|
|
});
|
|
var $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/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/zod/v4/core/versions.js
|
|
var version = {
|
|
major: 4,
|
|
minor: 0,
|
|
patch: 0
|
|
};
|
|
|
|
// ../node_modules/zod/v4/core/schemas.js
|
|
var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
|
|
var _a;
|
|
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) {
|
|
(_a = inst._zod).deferred ?? (_a.deferred = []);
|
|
inst._zod.deferred?.push(() => {
|
|
inst._zod.run = inst._zod.parse;
|
|
});
|
|
} else {
|
|
const runChecks = (payload, checks2, ctx) => {
|
|
let isAborted2 = aborted(payload);
|
|
let asyncResult;
|
|
for (const ch of checks2) {
|
|
if (ch._zod.when) {
|
|
const shouldRun = ch._zod.when(payload);
|
|
if (!shouldRun)
|
|
continue;
|
|
} else if (isAborted2) {
|
|
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 (!isAborted2)
|
|
isAborted2 = aborted(payload, currLen);
|
|
});
|
|
} else {
|
|
const nextLen = payload.issues.length;
|
|
if (nextLen === currLen)
|
|
continue;
|
|
if (!isAborted2)
|
|
isAborted2 = aborted(payload, currLen);
|
|
}
|
|
}
|
|
if (asyncResult) {
|
|
return asyncResult.then(() => {
|
|
return payload;
|
|
});
|
|
}
|
|
return payload;
|
|
};
|
|
inst._zod.run = (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);
|
|
};
|
|
}
|
|
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 orig = payload.value;
|
|
const url = new URL(orig);
|
|
const href = url.href;
|
|
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: 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 (!orig.endsWith("/") && href.endsWith("/")) {
|
|
payload.value = href.slice(0, -1);
|
|
} else {
|
|
payload.value = href;
|
|
}
|
|
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.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.format = `ipv4`;
|
|
});
|
|
});
|
|
var $ZodIPv6 = /* @__PURE__ */ $constructor("$ZodIPv6", (inst, def) => {
|
|
def.pattern ?? (def.pattern = ipv6);
|
|
$ZodStringFormat.init(inst, def);
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
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 [address, prefix] = payload.value.split("/");
|
|
try {
|
|
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 (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.onattach.push((inst2) => {
|
|
inst2._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.onattach.push((inst2) => {
|
|
inst2._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 isValidJWT2(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 (isValidJWT2(payload.value, def.alg))
|
|
return;
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "jwt",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.pattern = inst._zod.bag.pattern ?? number;
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (def.coerce)
|
|
try {
|
|
payload.value = Number(payload.value);
|
|
} catch (_) {}
|
|
const input = payload.value;
|
|
if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
|
|
return payload;
|
|
}
|
|
const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : undefined : undefined;
|
|
payload.issues.push({
|
|
expected: "number",
|
|
code: "invalid_type",
|
|
input,
|
|
inst,
|
|
...received ? { received } : {}
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
|
|
$ZodCheckNumberFormat.init(inst, def);
|
|
$ZodNumber.init(inst, def);
|
|
});
|
|
var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.pattern = boolean;
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (def.coerce)
|
|
try {
|
|
payload.value = Boolean(payload.value);
|
|
} catch (_) {}
|
|
const input = payload.value;
|
|
if (typeof input === "boolean")
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "boolean",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
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 handleObjectResult(result, final, key) {
|
|
if (result.issues.length) {
|
|
final.issues.push(...prefixIssues(key, result.issues));
|
|
}
|
|
final.value[key] = result.value;
|
|
}
|
|
function handleOptionalObjectResult(result, final, key, input) {
|
|
if (result.issues.length) {
|
|
if (input[key] === undefined) {
|
|
if (key in input) {
|
|
final.value[key] = undefined;
|
|
} else {
|
|
final.value[key] = result.value;
|
|
}
|
|
} else {
|
|
final.issues.push(...prefixIssues(key, result.issues));
|
|
}
|
|
} else if (result.value === undefined) {
|
|
if (key in input)
|
|
final.value[key] = undefined;
|
|
} else {
|
|
final.value[key] = result.value;
|
|
}
|
|
}
|
|
var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
const _normalized = cached(() => {
|
|
const keys = Object.keys(def.shape);
|
|
for (const k of keys) {
|
|
if (!(def.shape[k] instanceof $ZodType)) {
|
|
throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
|
|
}
|
|
}
|
|
const okeys = optionalKeys(def.shape);
|
|
return {
|
|
shape: def.shape,
|
|
keys,
|
|
keySet: new Set(keys),
|
|
numKeys: keys.length,
|
|
optionalKeys: new Set(okeys)
|
|
};
|
|
});
|
|
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 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) {
|
|
if (normalized.optionalKeys.has(key)) {
|
|
const id = ids[key];
|
|
doc.write(`const ${id} = ${parseStr(key)};`);
|
|
const k = esc(key);
|
|
doc.write(`
|
|
if (${id}.issues.length) {
|
|
if (input[${k}] === undefined) {
|
|
if (${k} in input) {
|
|
newResult[${k}] = undefined;
|
|
}
|
|
} else {
|
|
payload.issues = payload.issues.concat(
|
|
${id}.issues.map((iss) => ({
|
|
...iss,
|
|
path: iss.path ? [${k}, ...iss.path] : [${k}],
|
|
}))
|
|
);
|
|
}
|
|
} else if (${id}.value === undefined) {
|
|
if (${k} in input) newResult[${k}] = undefined;
|
|
} else {
|
|
newResult[${k}] = ${id}.value;
|
|
}
|
|
`);
|
|
} else {
|
|
const id = ids[key];
|
|
doc.write(`const ${id} = ${parseStr(key)};`);
|
|
doc.write(`
|
|
if (${id}.issues.length) payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
|
|
...iss,
|
|
path: iss.path ? [${esc(key)}, ...iss.path] : [${esc(key)}]
|
|
})));`);
|
|
doc.write(`newResult[${esc(key)}] = ${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 isObject3 = isObject2;
|
|
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 (!isObject3(input)) {
|
|
payload.issues.push({
|
|
expected: "object",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
}
|
|
const proms = [];
|
|
if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
|
|
if (!fastpass)
|
|
fastpass = generateFastpass(def.shape);
|
|
payload = fastpass(payload, ctx);
|
|
} else {
|
|
payload.value = {};
|
|
const shape = value.shape;
|
|
for (const key of value.keys) {
|
|
const el = shape[key];
|
|
const r = el._zod.run({ value: input[key], issues: [] }, ctx);
|
|
const isOptional = el._zod.optin === "optional" && el._zod.optout === "optional";
|
|
if (r instanceof Promise) {
|
|
proms.push(r.then((r2) => isOptional ? handleOptionalObjectResult(r2, payload, key, input) : handleObjectResult(r2, payload, key)));
|
|
} else if (isOptional) {
|
|
handleOptionalObjectResult(r, payload, key, input);
|
|
} else {
|
|
handleObjectResult(r, payload, key);
|
|
}
|
|
}
|
|
}
|
|
if (!catchall) {
|
|
return proms.length ? Promise.all(proms).then(() => payload) : payload;
|
|
}
|
|
const unrecognized = [];
|
|
const keySet = value.keySet;
|
|
const _catchall = catchall._zod;
|
|
const t = _catchall.def.type;
|
|
for (const key of Object.keys(input)) {
|
|
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) => handleObjectResult(r2, payload, key)));
|
|
} else {
|
|
handleObjectResult(r, payload, key);
|
|
}
|
|
}
|
|
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;
|
|
});
|
|
};
|
|
});
|
|
function handleUnionResults(results, final, inst, ctx) {
|
|
for (const result of results) {
|
|
if (result.issues.length === 0) {
|
|
final.value = result.value;
|
|
return final;
|
|
}
|
|
}
|
|
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;
|
|
});
|
|
inst._zod.parse = (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) => {
|
|
$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 (!isObject2(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) {
|
|
return _super(payload, ctx);
|
|
}
|
|
payload.issues.push({
|
|
code: "invalid_union",
|
|
errors: [],
|
|
note: "No matching discriminator",
|
|
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 mergeValues2(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 = mergeValues2(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 = mergeValues2(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) {
|
|
if (left.issues.length) {
|
|
result.issues.push(...left.issues);
|
|
}
|
|
if (right.issues.length) {
|
|
result.issues.push(...right.issues);
|
|
}
|
|
if (aborted(result))
|
|
return result;
|
|
const merged = mergeValues2(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 $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
if (!isPlainObject(input)) {
|
|
payload.issues.push({
|
|
expected: "record",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
}
|
|
const proms = [];
|
|
if (def.keyType._zod.values) {
|
|
const values = def.keyType._zod.values;
|
|
payload.value = {};
|
|
for (const key of values) {
|
|
if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
|
|
const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
|
|
if (result instanceof Promise) {
|
|
proms.push(result.then((result2) => {
|
|
if (result2.issues.length) {
|
|
payload.issues.push(...prefixIssues(key, result2.issues));
|
|
}
|
|
payload.value[key] = result2.value;
|
|
}));
|
|
} else {
|
|
if (result.issues.length) {
|
|
payload.issues.push(...prefixIssues(key, result.issues));
|
|
}
|
|
payload.value[key] = result.value;
|
|
}
|
|
}
|
|
}
|
|
let unrecognized;
|
|
for (const key in input) {
|
|
if (!values.has(key)) {
|
|
unrecognized = unrecognized ?? [];
|
|
unrecognized.push(key);
|
|
}
|
|
}
|
|
if (unrecognized && unrecognized.length > 0) {
|
|
payload.issues.push({
|
|
code: "unrecognized_keys",
|
|
input,
|
|
inst,
|
|
keys: unrecognized
|
|
});
|
|
}
|
|
} else {
|
|
payload.value = {};
|
|
for (const key of Reflect.ownKeys(input)) {
|
|
if (key === "__proto__")
|
|
continue;
|
|
const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
|
|
if (keyResult instanceof Promise) {
|
|
throw new Error("Async schemas not supported in object keys currently");
|
|
}
|
|
if (keyResult.issues.length) {
|
|
payload.issues.push({
|
|
origin: "record",
|
|
code: "invalid_key",
|
|
issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
|
|
input: key,
|
|
path: [key],
|
|
inst
|
|
});
|
|
payload.value[keyResult.value] = keyResult.value;
|
|
continue;
|
|
}
|
|
const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
|
|
if (result instanceof Promise) {
|
|
proms.push(result.then((result2) => {
|
|
if (result2.issues.length) {
|
|
payload.issues.push(...prefixIssues(key, result2.issues));
|
|
}
|
|
payload.value[keyResult.value] = result2.value;
|
|
}));
|
|
} else {
|
|
if (result.issues.length) {
|
|
payload.issues.push(...prefixIssues(key, result.issues));
|
|
}
|
|
payload.value[keyResult.value] = result.value;
|
|
}
|
|
}
|
|
}
|
|
if (proms.length) {
|
|
return Promise.all(proms).then(() => payload);
|
|
}
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
const values = getEnumValues(def.entries);
|
|
inst._zod.values = new Set(values);
|
|
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 (inst._zod.values.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);
|
|
inst._zod.values = new Set(def.values);
|
|
inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? o.toString() : String(o)).join("|")})$`);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (inst._zod.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.parse = (payload, _ctx) => {
|
|
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;
|
|
return payload;
|
|
});
|
|
}
|
|
if (_out instanceof Promise) {
|
|
throw new $ZodAsyncError;
|
|
}
|
|
payload.value = _out;
|
|
return payload;
|
|
};
|
|
});
|
|
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") {
|
|
return def.innerType._zod.run(payload, ctx);
|
|
}
|
|
if (payload.value === undefined) {
|
|
return payload;
|
|
}
|
|
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 (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 (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) => {
|
|
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 = [];
|
|
}
|
|
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 = [];
|
|
}
|
|
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);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const left = def.in._zod.run(payload, ctx);
|
|
if (left instanceof Promise) {
|
|
return left.then((left2) => handlePipeResult(left2, def, ctx));
|
|
}
|
|
return handlePipeResult(left, def, ctx);
|
|
};
|
|
});
|
|
function handlePipeResult(left, def, ctx) {
|
|
if (aborted(left)) {
|
|
return left;
|
|
}
|
|
return def.out._zod.run({ value: left.value, issues: left.issues }, 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) => {
|
|
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/zod/v4/locales/en.js
|
|
var parsedType = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "number";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
var error = () => {
|
|
const Sizable = {
|
|
string: { unit: "characters", verb: "to have" },
|
|
file: { unit: "bytes", verb: "to have" },
|
|
array: { unit: "items", verb: "to have" },
|
|
set: { unit: "items", verb: "to have" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const Nouns = {
|
|
regex: "input",
|
|
email: "email address",
|
|
url: "URL",
|
|
emoji: "emoji",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "ISO datetime",
|
|
date: "ISO date",
|
|
time: "ISO time",
|
|
duration: "ISO duration",
|
|
ipv4: "IPv4 address",
|
|
ipv6: "IPv6 address",
|
|
cidrv4: "IPv4 range",
|
|
cidrv6: "IPv6 range",
|
|
base64: "base64-encoded string",
|
|
base64url: "base64url-encoded string",
|
|
json_string: "JSON string",
|
|
e164: "E.164 number",
|
|
jwt: "JWT",
|
|
template_literal: "input"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type":
|
|
return `Invalid input: expected ${issue2.expected}, received ${parsedType(issue2.input)}`;
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Invalid input: expected ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Invalid option: expected one of ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `Too big: expected ${issue2.origin ?? "value"} to have ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elements"}`;
|
|
return `Too big: expected ${issue2.origin ?? "value"} to be ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Too small: expected ${issue2.origin} to have ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Too small: expected ${issue2.origin} to be ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with") {
|
|
return `Invalid string: must start with "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `Invalid string: must end with "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Invalid string: must include "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Invalid string: must match pattern ${_issue.pattern}`;
|
|
return `Invalid ${Nouns[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Invalid number: must be a multiple of ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Unrecognized key${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Invalid key in ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "Invalid input";
|
|
case "invalid_element":
|
|
return `Invalid value in ${issue2.origin}`;
|
|
default:
|
|
return `Invalid input`;
|
|
}
|
|
};
|
|
};
|
|
function en_default2() {
|
|
return {
|
|
localeError: error()
|
|
};
|
|
}
|
|
// ../node_modules/zod/v4/core/registries.js
|
|
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) {
|
|
if (this._idmap.has(meta.id)) {
|
|
throw new Error(`ID ${meta.id} already exists in the registry`);
|
|
}
|
|
this._idmap.set(meta.id, schema);
|
|
}
|
|
return this;
|
|
}
|
|
remove(schema) {
|
|
this._map.delete(schema);
|
|
return this;
|
|
}
|
|
get(schema) {
|
|
const p = schema._zod.parent;
|
|
if (p) {
|
|
const pm = { ...this.get(p) ?? {} };
|
|
delete pm.id;
|
|
return { ...pm, ...this._map.get(schema) };
|
|
}
|
|
return this._map.get(schema);
|
|
}
|
|
has(schema) {
|
|
return this._map.has(schema);
|
|
}
|
|
}
|
|
function registry() {
|
|
return new $ZodRegistry;
|
|
}
|
|
var globalRegistry = /* @__PURE__ */ registry();
|
|
// ../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 _number(Class2, params) {
|
|
return new Class2({
|
|
type: "number",
|
|
checks: [],
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _int(Class2, params) {
|
|
return new Class2({
|
|
type: "number",
|
|
check: "number_format",
|
|
abort: false,
|
|
format: "safeint",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _boolean(Class2, params) {
|
|
return new Class2({
|
|
type: "boolean",
|
|
...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 _lt(value, params) {
|
|
return new $ZodCheckLessThan({
|
|
check: "less_than",
|
|
...normalizeParams(params),
|
|
value,
|
|
inclusive: false
|
|
});
|
|
}
|
|
function _lte(value, params) {
|
|
return new $ZodCheckLessThan({
|
|
check: "less_than",
|
|
...normalizeParams(params),
|
|
value,
|
|
inclusive: true
|
|
});
|
|
}
|
|
function _gt(value, params) {
|
|
return new $ZodCheckGreaterThan({
|
|
check: "greater_than",
|
|
...normalizeParams(params),
|
|
value,
|
|
inclusive: false
|
|
});
|
|
}
|
|
function _gte(value, params) {
|
|
return new $ZodCheckGreaterThan({
|
|
check: "greater_than",
|
|
...normalizeParams(params),
|
|
value,
|
|
inclusive: true
|
|
});
|
|
}
|
|
function _multipleOf(value, params) {
|
|
return new $ZodCheckMultipleOf({
|
|
check: "multiple_of",
|
|
...normalizeParams(params),
|
|
value
|
|
});
|
|
}
|
|
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 _array(Class2, element, params) {
|
|
return new Class2({
|
|
type: "array",
|
|
element,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _custom(Class2, fn, _params) {
|
|
const norm = normalizeParams(_params);
|
|
norm.abort ?? (norm.abort = true);
|
|
const schema = new Class2({
|
|
type: "custom",
|
|
check: "custom",
|
|
fn,
|
|
...norm
|
|
});
|
|
return schema;
|
|
}
|
|
function _refine(Class2, fn, _params) {
|
|
const schema = new Class2({
|
|
type: "custom",
|
|
check: "custom",
|
|
fn,
|
|
...normalizeParams(_params)
|
|
});
|
|
return schema;
|
|
}
|
|
// ../node_modules/zod/v4/core/to-json-schema.js
|
|
class JSONSchemaGenerator {
|
|
constructor(params) {
|
|
this.counter = 0;
|
|
this.metadataRegistry = params?.metadata ?? globalRegistry;
|
|
this.target = params?.target ?? "draft-2020-12";
|
|
this.unrepresentable = params?.unrepresentable ?? "throw";
|
|
this.override = params?.override ?? (() => {});
|
|
this.io = params?.io ?? "output";
|
|
this.seen = new Map;
|
|
}
|
|
process(schema, _params = { path: [], schemaPath: [] }) {
|
|
var _a;
|
|
const def = schema._zod.def;
|
|
const formatMap = {
|
|
guid: "uuid",
|
|
url: "uri",
|
|
datetime: "date-time",
|
|
json_string: "json-string",
|
|
regex: ""
|
|
};
|
|
const seen = this.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 };
|
|
this.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
|
|
};
|
|
const parent = schema._zod.parent;
|
|
if (parent) {
|
|
result.ref = parent;
|
|
this.process(parent, params);
|
|
this.seen.get(parent).isParent = true;
|
|
} else {
|
|
const _json = result.schema;
|
|
switch (def.type) {
|
|
case "string": {
|
|
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 (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) {
|
|
result.schema.allOf = [
|
|
...regexes.map((regex) => ({
|
|
...this.target === "draft-7" ? { type: "string" } : {},
|
|
pattern: regex.source
|
|
}))
|
|
];
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case "number": {
|
|
const json = _json;
|
|
const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
|
|
if (typeof format === "string" && format.includes("int"))
|
|
json.type = "integer";
|
|
else
|
|
json.type = "number";
|
|
if (typeof exclusiveMinimum === "number")
|
|
json.exclusiveMinimum = exclusiveMinimum;
|
|
if (typeof minimum === "number") {
|
|
json.minimum = minimum;
|
|
if (typeof exclusiveMinimum === "number") {
|
|
if (exclusiveMinimum >= minimum)
|
|
delete json.minimum;
|
|
else
|
|
delete json.exclusiveMinimum;
|
|
}
|
|
}
|
|
if (typeof exclusiveMaximum === "number")
|
|
json.exclusiveMaximum = exclusiveMaximum;
|
|
if (typeof maximum === "number") {
|
|
json.maximum = maximum;
|
|
if (typeof exclusiveMaximum === "number") {
|
|
if (exclusiveMaximum <= maximum)
|
|
delete json.maximum;
|
|
else
|
|
delete json.exclusiveMaximum;
|
|
}
|
|
}
|
|
if (typeof multipleOf === "number")
|
|
json.multipleOf = multipleOf;
|
|
break;
|
|
}
|
|
case "boolean": {
|
|
const json = _json;
|
|
json.type = "boolean";
|
|
break;
|
|
}
|
|
case "bigint": {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("BigInt cannot be represented in JSON Schema");
|
|
}
|
|
break;
|
|
}
|
|
case "symbol": {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("Symbols cannot be represented in JSON Schema");
|
|
}
|
|
break;
|
|
}
|
|
case "null": {
|
|
_json.type = "null";
|
|
break;
|
|
}
|
|
case "any": {
|
|
break;
|
|
}
|
|
case "unknown": {
|
|
break;
|
|
}
|
|
case "undefined":
|
|
case "never": {
|
|
_json.not = {};
|
|
break;
|
|
}
|
|
case "void": {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("Void cannot be represented in JSON Schema");
|
|
}
|
|
break;
|
|
}
|
|
case "date": {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("Date cannot be represented in JSON Schema");
|
|
}
|
|
break;
|
|
}
|
|
case "array": {
|
|
const json = _json;
|
|
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 = this.process(def.element, { ...params, path: [...params.path, "items"] });
|
|
break;
|
|
}
|
|
case "object": {
|
|
const json = _json;
|
|
json.type = "object";
|
|
json.properties = {};
|
|
const shape = def.shape;
|
|
for (const key in shape) {
|
|
json.properties[key] = this.process(shape[key], {
|
|
...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 (this.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 (this.io === "output")
|
|
json.additionalProperties = false;
|
|
} else if (def.catchall) {
|
|
json.additionalProperties = this.process(def.catchall, {
|
|
...params,
|
|
path: [...params.path, "additionalProperties"]
|
|
});
|
|
}
|
|
break;
|
|
}
|
|
case "union": {
|
|
const json = _json;
|
|
json.anyOf = def.options.map((x, i) => this.process(x, {
|
|
...params,
|
|
path: [...params.path, "anyOf", i]
|
|
}));
|
|
break;
|
|
}
|
|
case "intersection": {
|
|
const json = _json;
|
|
const a = this.process(def.left, {
|
|
...params,
|
|
path: [...params.path, "allOf", 0]
|
|
});
|
|
const b = this.process(def.right, {
|
|
...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;
|
|
break;
|
|
}
|
|
case "tuple": {
|
|
const json = _json;
|
|
json.type = "array";
|
|
const prefixItems = def.items.map((x, i) => this.process(x, { ...params, path: [...params.path, "prefixItems", i] }));
|
|
if (this.target === "draft-2020-12") {
|
|
json.prefixItems = prefixItems;
|
|
} else {
|
|
json.items = prefixItems;
|
|
}
|
|
if (def.rest) {
|
|
const rest = this.process(def.rest, {
|
|
...params,
|
|
path: [...params.path, "items"]
|
|
});
|
|
if (this.target === "draft-2020-12") {
|
|
json.items = rest;
|
|
} else {
|
|
json.additionalItems = rest;
|
|
}
|
|
}
|
|
if (def.rest) {
|
|
json.items = this.process(def.rest, {
|
|
...params,
|
|
path: [...params.path, "items"]
|
|
});
|
|
}
|
|
const { minimum, maximum } = schema._zod.bag;
|
|
if (typeof minimum === "number")
|
|
json.minItems = minimum;
|
|
if (typeof maximum === "number")
|
|
json.maxItems = maximum;
|
|
break;
|
|
}
|
|
case "record": {
|
|
const json = _json;
|
|
json.type = "object";
|
|
json.propertyNames = this.process(def.keyType, { ...params, path: [...params.path, "propertyNames"] });
|
|
json.additionalProperties = this.process(def.valueType, {
|
|
...params,
|
|
path: [...params.path, "additionalProperties"]
|
|
});
|
|
break;
|
|
}
|
|
case "map": {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("Map cannot be represented in JSON Schema");
|
|
}
|
|
break;
|
|
}
|
|
case "set": {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("Set cannot be represented in JSON Schema");
|
|
}
|
|
break;
|
|
}
|
|
case "enum": {
|
|
const json = _json;
|
|
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;
|
|
break;
|
|
}
|
|
case "literal": {
|
|
const json = _json;
|
|
const vals = [];
|
|
for (const val of def.values) {
|
|
if (val === undefined) {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("Literal `undefined` cannot be represented in JSON Schema");
|
|
} else {}
|
|
} else if (typeof val === "bigint") {
|
|
if (this.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;
|
|
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 = "string";
|
|
if (vals.every((v) => v === null))
|
|
json.type = "null";
|
|
json.enum = vals;
|
|
}
|
|
break;
|
|
}
|
|
case "file": {
|
|
const json = _json;
|
|
const file = {
|
|
type: "string",
|
|
format: "binary",
|
|
contentEncoding: "binary"
|
|
};
|
|
const { minimum, maximum, mime } = schema._zod.bag;
|
|
if (minimum !== undefined)
|
|
file.minLength = minimum;
|
|
if (maximum !== undefined)
|
|
file.maxLength = maximum;
|
|
if (mime) {
|
|
if (mime.length === 1) {
|
|
file.contentMediaType = mime[0];
|
|
Object.assign(json, file);
|
|
} else {
|
|
json.anyOf = mime.map((m) => {
|
|
const mFile = { ...file, contentMediaType: m };
|
|
return mFile;
|
|
});
|
|
}
|
|
} else {
|
|
Object.assign(json, file);
|
|
}
|
|
break;
|
|
}
|
|
case "transform": {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("Transforms cannot be represented in JSON Schema");
|
|
}
|
|
break;
|
|
}
|
|
case "nullable": {
|
|
const inner = this.process(def.innerType, params);
|
|
_json.anyOf = [inner, { type: "null" }];
|
|
break;
|
|
}
|
|
case "nonoptional": {
|
|
this.process(def.innerType, params);
|
|
result.ref = def.innerType;
|
|
break;
|
|
}
|
|
case "success": {
|
|
const json = _json;
|
|
json.type = "boolean";
|
|
break;
|
|
}
|
|
case "default": {
|
|
this.process(def.innerType, params);
|
|
result.ref = def.innerType;
|
|
_json.default = JSON.parse(JSON.stringify(def.defaultValue));
|
|
break;
|
|
}
|
|
case "prefault": {
|
|
this.process(def.innerType, params);
|
|
result.ref = def.innerType;
|
|
if (this.io === "input")
|
|
_json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
|
|
break;
|
|
}
|
|
case "catch": {
|
|
this.process(def.innerType, params);
|
|
result.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;
|
|
break;
|
|
}
|
|
case "nan": {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("NaN cannot be represented in JSON Schema");
|
|
}
|
|
break;
|
|
}
|
|
case "template_literal": {
|
|
const json = _json;
|
|
const pattern = schema._zod.pattern;
|
|
if (!pattern)
|
|
throw new Error("Pattern not found in template literal");
|
|
json.type = "string";
|
|
json.pattern = pattern.source;
|
|
break;
|
|
}
|
|
case "pipe": {
|
|
const innerType = this.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
|
|
this.process(innerType, params);
|
|
result.ref = innerType;
|
|
break;
|
|
}
|
|
case "readonly": {
|
|
this.process(def.innerType, params);
|
|
result.ref = def.innerType;
|
|
_json.readOnly = true;
|
|
break;
|
|
}
|
|
case "promise": {
|
|
this.process(def.innerType, params);
|
|
result.ref = def.innerType;
|
|
break;
|
|
}
|
|
case "optional": {
|
|
this.process(def.innerType, params);
|
|
result.ref = def.innerType;
|
|
break;
|
|
}
|
|
case "lazy": {
|
|
const innerType = schema._zod.innerType;
|
|
this.process(innerType, params);
|
|
result.ref = innerType;
|
|
break;
|
|
}
|
|
case "custom": {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("Custom types cannot be represented in JSON Schema");
|
|
}
|
|
break;
|
|
}
|
|
default: {}
|
|
}
|
|
}
|
|
}
|
|
const meta = this.metadataRegistry.get(schema);
|
|
if (meta)
|
|
Object.assign(result.schema, meta);
|
|
if (this.io === "input" && isTransforming(schema)) {
|
|
delete result.schema.examples;
|
|
delete result.schema.default;
|
|
}
|
|
if (this.io === "input" && result.schema._prefault)
|
|
(_a = result.schema).default ?? (_a.default = result.schema._prefault);
|
|
delete result.schema._prefault;
|
|
const _result = this.seen.get(schema);
|
|
return _result.schema;
|
|
}
|
|
emit(schema, _params) {
|
|
const params = {
|
|
cycles: _params?.cycles ?? "ref",
|
|
reused: _params?.reused ?? "inline",
|
|
external: _params?.external ?? undefined
|
|
};
|
|
const root2 = this.seen.get(schema);
|
|
if (!root2)
|
|
throw new Error("Unprocessed schema. This is a bug in Zod.");
|
|
const makeURI = (entry) => {
|
|
const defsSegment = this.target === "draft-2020-12" ? "$defs" : "definitions";
|
|
if (params.external) {
|
|
const externalId = params.external.registry.get(entry[0])?.id;
|
|
if (externalId)
|
|
return { ref: params.external.uri(externalId) };
|
|
const id = entry[1].defId ?? entry[1].schema.id ?? `schema${this.counter++}`;
|
|
entry[1].defId = id;
|
|
return { defId: id, ref: `${params.external.uri("__shared")}#/${defsSegment}/${id}` };
|
|
}
|
|
if (entry[1] === root2) {
|
|
return { ref: "#" };
|
|
}
|
|
const uriPrefix = `#`;
|
|
const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
|
|
const defId = entry[1].schema.id ?? `__schema${this.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;
|
|
};
|
|
for (const entry of this.seen.entries()) {
|
|
const seen = entry[1];
|
|
if (schema === entry[0]) {
|
|
extractToDef(entry);
|
|
continue;
|
|
}
|
|
if (params.external) {
|
|
const ext = params.external.registry.get(entry[0])?.id;
|
|
if (schema !== entry[0] && ext) {
|
|
extractToDef(entry);
|
|
continue;
|
|
}
|
|
}
|
|
const id = this.metadataRegistry.get(entry[0])?.id;
|
|
if (id) {
|
|
extractToDef(entry);
|
|
continue;
|
|
}
|
|
if (seen.cycle) {
|
|
if (params.cycles === "throw") {
|
|
throw new Error("Cycle detected: " + `#/${seen.cycle?.join("/")}/<root>` + '\n\nSet the `cycles` parameter to `"ref"` to resolve cyclical schemas with defs.');
|
|
} else if (params.cycles === "ref") {
|
|
extractToDef(entry);
|
|
}
|
|
continue;
|
|
}
|
|
if (seen.count > 1) {
|
|
if (params.reused === "ref") {
|
|
extractToDef(entry);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
const flattenRef = (zodSchema, params2) => {
|
|
const seen = this.seen.get(zodSchema);
|
|
const schema2 = seen.def ?? seen.schema;
|
|
const _cached = { ...schema2 };
|
|
if (seen.ref === null) {
|
|
return;
|
|
}
|
|
const ref = seen.ref;
|
|
seen.ref = null;
|
|
if (ref) {
|
|
flattenRef(ref, params2);
|
|
const refSchema = this.seen.get(ref).schema;
|
|
if (refSchema.$ref && params2.target === "draft-7") {
|
|
schema2.allOf = schema2.allOf ?? [];
|
|
schema2.allOf.push(refSchema);
|
|
} else {
|
|
Object.assign(schema2, refSchema);
|
|
Object.assign(schema2, _cached);
|
|
}
|
|
}
|
|
if (!seen.isParent)
|
|
this.override({
|
|
zodSchema,
|
|
jsonSchema: schema2,
|
|
path: seen.path ?? []
|
|
});
|
|
};
|
|
for (const entry of [...this.seen.entries()].reverse()) {
|
|
flattenRef(entry[0], { target: this.target });
|
|
}
|
|
const result = {};
|
|
if (this.target === "draft-2020-12") {
|
|
result.$schema = "https://json-schema.org/draft/2020-12/schema";
|
|
} else if (this.target === "draft-7") {
|
|
result.$schema = "http://json-schema.org/draft-07/schema#";
|
|
} else {
|
|
console.warn(`Invalid target: ${this.target}`);
|
|
}
|
|
Object.assign(result, root2.def);
|
|
const defs = params.external?.defs ?? {};
|
|
for (const entry of this.seen.entries()) {
|
|
const seen = entry[1];
|
|
if (seen.def && seen.defId) {
|
|
defs[seen.defId] = seen.def;
|
|
}
|
|
}
|
|
if (!params.external && Object.keys(defs).length > 0) {
|
|
if (this.target === "draft-2020-12") {
|
|
result.$defs = defs;
|
|
} else {
|
|
result.definitions = defs;
|
|
}
|
|
}
|
|
try {
|
|
return JSON.parse(JSON.stringify(result));
|
|
} catch (_err) {
|
|
throw new Error("Error converting schema to JSON.");
|
|
}
|
|
}
|
|
}
|
|
function toJSONSchema(input, _params) {
|
|
if (input instanceof $ZodRegistry) {
|
|
const gen2 = new JSONSchemaGenerator(_params);
|
|
const defs = {};
|
|
for (const entry of input._idmap.entries()) {
|
|
const [_, schema] = entry;
|
|
gen2.process(schema);
|
|
}
|
|
const schemas = {};
|
|
const external = {
|
|
registry: input,
|
|
uri: _params?.uri || ((id) => id),
|
|
defs
|
|
};
|
|
for (const entry of input._idmap.entries()) {
|
|
const [key, schema] = entry;
|
|
schemas[key] = gen2.emit(schema, {
|
|
..._params,
|
|
external
|
|
});
|
|
}
|
|
if (Object.keys(defs).length > 0) {
|
|
const defsSegment = gen2.target === "draft-2020-12" ? "$defs" : "definitions";
|
|
schemas.__shared = {
|
|
[defsSegment]: defs
|
|
};
|
|
}
|
|
return { schemas };
|
|
}
|
|
const gen = new JSONSchemaGenerator(_params);
|
|
gen.process(input);
|
|
return gen.emit(input, _params);
|
|
}
|
|
function isTransforming(_schema, _ctx) {
|
|
const ctx = _ctx ?? { seen: new Set };
|
|
if (ctx.seen.has(_schema))
|
|
return false;
|
|
ctx.seen.add(_schema);
|
|
const schema = _schema;
|
|
const def = schema._zod.def;
|
|
switch (def.type) {
|
|
case "string":
|
|
case "number":
|
|
case "bigint":
|
|
case "boolean":
|
|
case "date":
|
|
case "symbol":
|
|
case "undefined":
|
|
case "null":
|
|
case "any":
|
|
case "unknown":
|
|
case "never":
|
|
case "void":
|
|
case "literal":
|
|
case "enum":
|
|
case "nan":
|
|
case "file":
|
|
case "template_literal":
|
|
return false;
|
|
case "array": {
|
|
return isTransforming(def.element, ctx);
|
|
}
|
|
case "object": {
|
|
for (const key in def.shape) {
|
|
if (isTransforming(def.shape[key], ctx))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
case "union": {
|
|
for (const option of def.options) {
|
|
if (isTransforming(option, ctx))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
case "intersection": {
|
|
return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
|
|
}
|
|
case "tuple": {
|
|
for (const item of def.items) {
|
|
if (isTransforming(item, ctx))
|
|
return true;
|
|
}
|
|
if (def.rest && isTransforming(def.rest, ctx))
|
|
return true;
|
|
return false;
|
|
}
|
|
case "record": {
|
|
return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
|
|
}
|
|
case "map": {
|
|
return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
|
|
}
|
|
case "set": {
|
|
return isTransforming(def.valueType, ctx);
|
|
}
|
|
case "promise":
|
|
case "optional":
|
|
case "nonoptional":
|
|
case "nullable":
|
|
case "readonly":
|
|
return isTransforming(def.innerType, ctx);
|
|
case "lazy":
|
|
return isTransforming(def.getter(), ctx);
|
|
case "default": {
|
|
return isTransforming(def.innerType, ctx);
|
|
}
|
|
case "prefault": {
|
|
return isTransforming(def.innerType, ctx);
|
|
}
|
|
case "custom": {
|
|
return false;
|
|
}
|
|
case "transform": {
|
|
return true;
|
|
}
|
|
case "pipe": {
|
|
return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
|
|
}
|
|
case "success": {
|
|
return false;
|
|
}
|
|
case "catch": {
|
|
return false;
|
|
}
|
|
default:
|
|
}
|
|
throw new Error(`Unknown schema type: ${def.type}`);
|
|
}
|
|
// ../node_modules/zod/v4/mini/schemas.js
|
|
var ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
|
|
if (!inst._zod)
|
|
throw new Error("Uninitialized schema in ZodMiniType.");
|
|
$ZodType.init(inst, def);
|
|
inst.def = def;
|
|
inst.parse = (data, params) => parse(inst, data, params, { callee: inst.parse });
|
|
inst.safeParse = (data, params) => safeParse(inst, data, params);
|
|
inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
|
|
inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
|
|
inst.check = (...checks2) => {
|
|
return inst.clone({
|
|
...def,
|
|
checks: [
|
|
...def.checks ?? [],
|
|
...checks2.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
|
|
]
|
|
});
|
|
};
|
|
inst.clone = (_def, params) => clone(inst, _def, params);
|
|
inst.brand = () => inst;
|
|
inst.register = (reg, meta) => {
|
|
reg.add(inst, meta);
|
|
return inst;
|
|
};
|
|
});
|
|
var ZodMiniObject = /* @__PURE__ */ $constructor("ZodMiniObject", (inst, def) => {
|
|
$ZodObject.init(inst, def);
|
|
ZodMiniType.init(inst, def);
|
|
exports_util.defineLazy(inst, "shape", () => def.shape);
|
|
});
|
|
function object(shape, params) {
|
|
const def = {
|
|
type: "object",
|
|
get shape() {
|
|
exports_util.assignProp(this, "shape", { ...shape });
|
|
return this.shape;
|
|
},
|
|
...exports_util.normalizeParams(params)
|
|
};
|
|
return new ZodMiniObject(def);
|
|
}
|
|
// ../node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
|
|
function isZ4Schema(s) {
|
|
const schema = s;
|
|
return !!schema._zod;
|
|
}
|
|
function objectFromShape(shape) {
|
|
const values = Object.values(shape);
|
|
if (values.length === 0)
|
|
return object({});
|
|
const allV4 = values.every(isZ4Schema);
|
|
const allV3 = values.every((s) => !isZ4Schema(s));
|
|
if (allV4)
|
|
return object(shape);
|
|
if (allV3)
|
|
return objectType(shape);
|
|
throw new Error("Mixed Zod versions detected in object shape.");
|
|
}
|
|
function safeParse2(schema, data) {
|
|
if (isZ4Schema(schema)) {
|
|
const result2 = safeParse(schema, data);
|
|
return result2;
|
|
}
|
|
const v3Schema = schema;
|
|
const result = v3Schema.safeParse(data);
|
|
return result;
|
|
}
|
|
async function safeParseAsync2(schema, data) {
|
|
if (isZ4Schema(schema)) {
|
|
const result2 = await safeParseAsync(schema, data);
|
|
return result2;
|
|
}
|
|
const v3Schema = schema;
|
|
const result = await v3Schema.safeParseAsync(data);
|
|
return result;
|
|
}
|
|
function getObjectShape(schema) {
|
|
var _a, _b;
|
|
if (!schema)
|
|
return;
|
|
let rawShape;
|
|
if (isZ4Schema(schema)) {
|
|
const v4Schema = schema;
|
|
rawShape = (_b = (_a = v4Schema._zod) === null || _a === undefined ? undefined : _a.def) === null || _b === undefined ? undefined : _b.shape;
|
|
} else {
|
|
const v3Schema = schema;
|
|
rawShape = v3Schema.shape;
|
|
}
|
|
if (!rawShape)
|
|
return;
|
|
if (typeof rawShape === "function") {
|
|
try {
|
|
return rawShape();
|
|
} catch (_c) {
|
|
return;
|
|
}
|
|
}
|
|
return rawShape;
|
|
}
|
|
function normalizeObjectSchema(schema) {
|
|
var _a;
|
|
if (!schema)
|
|
return;
|
|
if (typeof schema === "object") {
|
|
const asV3 = schema;
|
|
const asV4 = schema;
|
|
if (!asV3._def && !asV4._zod) {
|
|
const values = Object.values(schema);
|
|
if (values.length > 0 && values.every((v) => typeof v === "object" && v !== null && (v._def !== undefined || v._zod !== undefined || typeof v.parse === "function"))) {
|
|
return objectFromShape(schema);
|
|
}
|
|
}
|
|
}
|
|
if (isZ4Schema(schema)) {
|
|
const v4Schema = schema;
|
|
const def = (_a = v4Schema._zod) === null || _a === undefined ? undefined : _a.def;
|
|
if (def && (def.type === "object" || def.shape !== undefined)) {
|
|
return schema;
|
|
}
|
|
} else {
|
|
const v3Schema = schema;
|
|
if (v3Schema.shape !== undefined) {
|
|
return schema;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
function getParseErrorMessage(error2) {
|
|
if (error2 && typeof error2 === "object") {
|
|
if ("message" in error2 && typeof error2.message === "string") {
|
|
return error2.message;
|
|
}
|
|
if ("issues" in error2 && Array.isArray(error2.issues) && error2.issues.length > 0) {
|
|
const firstIssue = error2.issues[0];
|
|
if (firstIssue && typeof firstIssue === "object" && "message" in firstIssue) {
|
|
return String(firstIssue.message);
|
|
}
|
|
}
|
|
try {
|
|
return JSON.stringify(error2);
|
|
} catch (_a) {
|
|
return String(error2);
|
|
}
|
|
}
|
|
return String(error2);
|
|
}
|
|
function getSchemaDescription(schema) {
|
|
var _a, _b, _c, _d;
|
|
if (isZ4Schema(schema)) {
|
|
const v4Schema = schema;
|
|
return (_b = (_a = v4Schema._zod) === null || _a === undefined ? undefined : _a.def) === null || _b === undefined ? undefined : _b.description;
|
|
}
|
|
const v3Schema = schema;
|
|
return (_c = schema.description) !== null && _c !== undefined ? _c : (_d = v3Schema._def) === null || _d === undefined ? undefined : _d.description;
|
|
}
|
|
function isSchemaOptional(schema) {
|
|
var _a, _b, _c;
|
|
if (isZ4Schema(schema)) {
|
|
const v4Schema = schema;
|
|
return ((_b = (_a = v4Schema._zod) === null || _a === undefined ? undefined : _a.def) === null || _b === undefined ? undefined : _b.type) === "optional";
|
|
}
|
|
const v3Schema = schema;
|
|
if (typeof schema.isOptional === "function") {
|
|
return schema.isOptional();
|
|
}
|
|
return ((_c = v3Schema._def) === null || _c === undefined ? undefined : _c.typeName) === "ZodOptional";
|
|
}
|
|
function getLiteralValue(schema) {
|
|
var _a;
|
|
if (isZ4Schema(schema)) {
|
|
const v4Schema = schema;
|
|
const def2 = (_a = v4Schema._zod) === null || _a === undefined ? undefined : _a.def;
|
|
if (def2) {
|
|
if (def2.value !== undefined)
|
|
return def2.value;
|
|
if (Array.isArray(def2.values) && def2.values.length > 0) {
|
|
return def2.values[0];
|
|
}
|
|
}
|
|
}
|
|
const v3Schema = schema;
|
|
const def = v3Schema._def;
|
|
if (def) {
|
|
if (def.value !== undefined)
|
|
return def.value;
|
|
if (Array.isArray(def.values) && def.values.length > 0) {
|
|
return def.values[0];
|
|
}
|
|
}
|
|
const directValue = schema.value;
|
|
if (directValue !== undefined)
|
|
return directValue;
|
|
return;
|
|
}
|
|
// ../node_modules/zod/v4/classic/iso.js
|
|
var exports_iso2 = {};
|
|
__export(exports_iso2, {
|
|
time: () => time2,
|
|
duration: () => duration2,
|
|
datetime: () => datetime2,
|
|
date: () => date2,
|
|
ZodISOTime: () => ZodISOTime,
|
|
ZodISODuration: () => ZodISODuration,
|
|
ZodISODateTime: () => ZodISODateTime,
|
|
ZodISODate: () => ZodISODate
|
|
});
|
|
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/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)
|
|
},
|
|
addIssues: {
|
|
value: (issues2) => inst.issues.push(...issues2)
|
|
},
|
|
isEmpty: {
|
|
get() {
|
|
return inst.issues.length === 0;
|
|
}
|
|
}
|
|
});
|
|
};
|
|
var ZodError2 = $constructor("ZodError", initializer2);
|
|
var ZodRealError = $constructor("ZodError", initializer2, {
|
|
Parent: Error
|
|
});
|
|
|
|
// ../node_modules/zod/v4/classic/parse.js
|
|
var parse4 = /* @__PURE__ */ _parse(ZodRealError);
|
|
var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
|
|
var safeParse3 = /* @__PURE__ */ _safeParse(ZodRealError);
|
|
var safeParseAsync3 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
|
|
|
|
// ../node_modules/zod/v4/classic/schemas.js
|
|
var ZodType2 = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst.def = def;
|
|
Object.defineProperty(inst, "_def", { value: def });
|
|
inst.check = (...checks3) => {
|
|
return inst.clone({
|
|
...def,
|
|
checks: [
|
|
...def.checks ?? [],
|
|
...checks3.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
|
|
]
|
|
});
|
|
};
|
|
inst.clone = (def2, params) => clone(inst, def2, params);
|
|
inst.brand = () => inst;
|
|
inst.register = (reg, meta) => {
|
|
reg.add(inst, meta);
|
|
return inst;
|
|
};
|
|
inst.parse = (data, params) => parse4(inst, data, params, { callee: inst.parse });
|
|
inst.safeParse = (data, params) => safeParse3(inst, data, params);
|
|
inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
|
|
inst.safeParseAsync = async (data, params) => safeParseAsync3(inst, data, params);
|
|
inst.spa = inst.safeParseAsync;
|
|
inst.refine = (check, params) => inst.check(refine(check, params));
|
|
inst.superRefine = (refinement) => inst.check(superRefine(refinement));
|
|
inst.overwrite = (fn) => inst.check(_overwrite(fn));
|
|
inst.optional = () => optional(inst);
|
|
inst.nullable = () => nullable(inst);
|
|
inst.nullish = () => optional(nullable(inst));
|
|
inst.nonoptional = (params) => nonoptional(inst, params);
|
|
inst.array = () => array(inst);
|
|
inst.or = (arg) => union([inst, arg]);
|
|
inst.and = (arg) => intersection(inst, arg);
|
|
inst.transform = (tx) => pipe(inst, transform(tx));
|
|
inst.default = (def2) => _default(inst, def2);
|
|
inst.prefault = (def2) => prefault(inst, def2);
|
|
inst.catch = (params) => _catch(inst, params);
|
|
inst.pipe = (target) => pipe(inst, target);
|
|
inst.readonly = () => readonly(inst);
|
|
inst.describe = (description) => {
|
|
const cl = inst.clone();
|
|
globalRegistry.add(cl, { description });
|
|
return cl;
|
|
};
|
|
Object.defineProperty(inst, "description", {
|
|
get() {
|
|
return globalRegistry.get(inst)?.description;
|
|
},
|
|
configurable: true
|
|
});
|
|
inst.meta = (...args) => {
|
|
if (args.length === 0) {
|
|
return globalRegistry.get(inst);
|
|
}
|
|
const cl = inst.clone();
|
|
globalRegistry.add(cl, args[0]);
|
|
return cl;
|
|
};
|
|
inst.isOptional = () => inst.safeParse(undefined).success;
|
|
inst.isNullable = () => inst.safeParse(null).success;
|
|
return inst;
|
|
});
|
|
var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
|
|
$ZodString.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
const bag = inst._zod.bag;
|
|
inst.format = bag.format ?? null;
|
|
inst.minLength = bag.minimum ?? null;
|
|
inst.maxLength = bag.maximum ?? null;
|
|
inst.regex = (...args) => inst.check(_regex(...args));
|
|
inst.includes = (...args) => inst.check(_includes(...args));
|
|
inst.startsWith = (...args) => inst.check(_startsWith(...args));
|
|
inst.endsWith = (...args) => inst.check(_endsWith(...args));
|
|
inst.min = (...args) => inst.check(_minLength(...args));
|
|
inst.max = (...args) => inst.check(_maxLength(...args));
|
|
inst.length = (...args) => inst.check(_length(...args));
|
|
inst.nonempty = (...args) => inst.check(_minLength(1, ...args));
|
|
inst.lowercase = (params) => inst.check(_lowercase(params));
|
|
inst.uppercase = (params) => inst.check(_uppercase(params));
|
|
inst.trim = () => inst.check(_trim());
|
|
inst.normalize = (...args) => inst.check(_normalize(...args));
|
|
inst.toLowerCase = () => inst.check(_toLowerCase());
|
|
inst.toUpperCase = () => inst.check(_toUpperCase());
|
|
});
|
|
var ZodString2 = /* @__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(ZodString2, 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 ZodNumber2 = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
|
|
$ZodNumber.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.gt = (value, params) => inst.check(_gt(value, params));
|
|
inst.gte = (value, params) => inst.check(_gte(value, params));
|
|
inst.min = (value, params) => inst.check(_gte(value, params));
|
|
inst.lt = (value, params) => inst.check(_lt(value, params));
|
|
inst.lte = (value, params) => inst.check(_lte(value, params));
|
|
inst.max = (value, params) => inst.check(_lte(value, params));
|
|
inst.int = (params) => inst.check(int(params));
|
|
inst.safe = (params) => inst.check(int(params));
|
|
inst.positive = (params) => inst.check(_gt(0, params));
|
|
inst.nonnegative = (params) => inst.check(_gte(0, params));
|
|
inst.negative = (params) => inst.check(_lt(0, params));
|
|
inst.nonpositive = (params) => inst.check(_lte(0, params));
|
|
inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
|
|
inst.step = (value, params) => inst.check(_multipleOf(value, params));
|
|
inst.finite = () => inst;
|
|
const bag = inst._zod.bag;
|
|
inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
|
|
inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
|
|
inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
|
|
inst.isFinite = true;
|
|
inst.format = bag.format ?? null;
|
|
});
|
|
function number2(params) {
|
|
return _number(ZodNumber2, params);
|
|
}
|
|
var ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => {
|
|
$ZodNumberFormat.init(inst, def);
|
|
ZodNumber2.init(inst, def);
|
|
});
|
|
function int(params) {
|
|
return _int(ZodNumberFormat, params);
|
|
}
|
|
var ZodBoolean2 = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
|
|
$ZodBoolean.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
});
|
|
function boolean2(params) {
|
|
return _boolean(ZodBoolean2, params);
|
|
}
|
|
var ZodNull2 = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
|
|
$ZodNull.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
});
|
|
function _null3(params) {
|
|
return _null2(ZodNull2, params);
|
|
}
|
|
var ZodUnknown2 = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
|
|
$ZodUnknown.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
});
|
|
function unknown() {
|
|
return _unknown(ZodUnknown2);
|
|
}
|
|
var ZodNever2 = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
|
|
$ZodNever.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
});
|
|
function never(params) {
|
|
return _never(ZodNever2, params);
|
|
}
|
|
var ZodArray2 = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
|
|
$ZodArray.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.element = def.element;
|
|
inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
|
|
inst.nonempty = (params) => inst.check(_minLength(1, params));
|
|
inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params));
|
|
inst.length = (len, params) => inst.check(_length(len, params));
|
|
inst.unwrap = () => inst.element;
|
|
});
|
|
function array(element, params) {
|
|
return _array(ZodArray2, element, params);
|
|
}
|
|
var ZodObject2 = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
|
|
$ZodObject.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
exports_util.defineLazy(inst, "shape", () => def.shape);
|
|
inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
|
|
inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
|
|
inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
|
|
inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
|
|
inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
|
|
inst.strip = () => inst.clone({ ...inst._zod.def, catchall: undefined });
|
|
inst.extend = (incoming) => {
|
|
return exports_util.extend(inst, incoming);
|
|
};
|
|
inst.merge = (other) => exports_util.merge(inst, other);
|
|
inst.pick = (mask) => exports_util.pick(inst, mask);
|
|
inst.omit = (mask) => exports_util.omit(inst, mask);
|
|
inst.partial = (...args) => exports_util.partial(ZodOptional2, inst, args[0]);
|
|
inst.required = (...args) => exports_util.required(ZodNonOptional, inst, args[0]);
|
|
});
|
|
function object2(shape, params) {
|
|
const def = {
|
|
type: "object",
|
|
get shape() {
|
|
exports_util.assignProp(this, "shape", { ...shape });
|
|
return this.shape;
|
|
},
|
|
...exports_util.normalizeParams(params)
|
|
};
|
|
return new ZodObject2(def);
|
|
}
|
|
function looseObject(shape, params) {
|
|
return new ZodObject2({
|
|
type: "object",
|
|
get shape() {
|
|
exports_util.assignProp(this, "shape", { ...shape });
|
|
return this.shape;
|
|
},
|
|
catchall: unknown(),
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodUnion2 = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
|
|
$ZodUnion.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.options = def.options;
|
|
});
|
|
function union(options, params) {
|
|
return new ZodUnion2({
|
|
type: "union",
|
|
options,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodDiscriminatedUnion2 = /* @__PURE__ */ $constructor("ZodDiscriminatedUnion", (inst, def) => {
|
|
ZodUnion2.init(inst, def);
|
|
$ZodDiscriminatedUnion.init(inst, def);
|
|
});
|
|
function discriminatedUnion(discriminator, options, params) {
|
|
return new ZodDiscriminatedUnion2({
|
|
type: "union",
|
|
options,
|
|
discriminator,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodIntersection2 = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
|
|
$ZodIntersection.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
});
|
|
function intersection(left, right) {
|
|
return new ZodIntersection2({
|
|
type: "intersection",
|
|
left,
|
|
right
|
|
});
|
|
}
|
|
var ZodRecord2 = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
|
|
$ZodRecord.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.keyType = def.keyType;
|
|
inst.valueType = def.valueType;
|
|
});
|
|
function record(keyType, valueType, params) {
|
|
return new ZodRecord2({
|
|
type: "record",
|
|
keyType,
|
|
valueType,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodEnum2 = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
|
|
$ZodEnum.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
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 ZodEnum2({
|
|
...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 ZodEnum2({
|
|
...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 ZodEnum2({
|
|
type: "enum",
|
|
entries,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodLiteral2 = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
|
|
$ZodLiteral.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
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 ZodLiteral2({
|
|
type: "literal",
|
|
values: Array.isArray(value) ? value : [value],
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
|
|
$ZodTransform.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
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);
|
|
_issue.continue ?? (_issue.continue = true);
|
|
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;
|
|
return payload;
|
|
});
|
|
}
|
|
payload.value = output;
|
|
return payload;
|
|
};
|
|
});
|
|
function transform(fn) {
|
|
return new ZodTransform({
|
|
type: "transform",
|
|
transform: fn
|
|
});
|
|
}
|
|
var ZodOptional2 = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
|
|
$ZodOptional.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function optional(innerType) {
|
|
return new ZodOptional2({
|
|
type: "optional",
|
|
innerType
|
|
});
|
|
}
|
|
var ZodNullable2 = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
|
|
$ZodNullable.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function nullable(innerType) {
|
|
return new ZodNullable2({
|
|
type: "nullable",
|
|
innerType
|
|
});
|
|
}
|
|
var ZodDefault2 = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
|
|
$ZodDefault.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
inst.removeDefault = inst.unwrap;
|
|
});
|
|
function _default(innerType, defaultValue) {
|
|
return new ZodDefault2({
|
|
type: "default",
|
|
innerType,
|
|
get defaultValue() {
|
|
return typeof defaultValue === "function" ? defaultValue() : defaultValue;
|
|
}
|
|
});
|
|
}
|
|
var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
|
|
$ZodPrefault.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function prefault(innerType, defaultValue) {
|
|
return new ZodPrefault({
|
|
type: "prefault",
|
|
innerType,
|
|
get defaultValue() {
|
|
return typeof defaultValue === "function" ? defaultValue() : defaultValue;
|
|
}
|
|
});
|
|
}
|
|
var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
|
|
$ZodNonOptional.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function nonoptional(innerType, params) {
|
|
return new ZodNonOptional({
|
|
type: "nonoptional",
|
|
innerType,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodCatch2 = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
|
|
$ZodCatch.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
inst.removeCatch = inst.unwrap;
|
|
});
|
|
function _catch(innerType, catchValue) {
|
|
return new ZodCatch2({
|
|
type: "catch",
|
|
innerType,
|
|
catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
|
|
});
|
|
}
|
|
var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
|
|
$ZodPipe.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.in = def.in;
|
|
inst.out = def.out;
|
|
});
|
|
function pipe(in_, out) {
|
|
return new ZodPipe({
|
|
type: "pipe",
|
|
in: in_,
|
|
out
|
|
});
|
|
}
|
|
var ZodReadonly2 = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
|
|
$ZodReadonly.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
});
|
|
function readonly(innerType) {
|
|
return new ZodReadonly2({
|
|
type: "readonly",
|
|
innerType
|
|
});
|
|
}
|
|
var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
|
|
$ZodCustom.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
});
|
|
function check(fn, params) {
|
|
const ch = new $ZodCheck({
|
|
check: "custom",
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
ch._zod.check = fn;
|
|
return ch;
|
|
}
|
|
function custom(fn, _params) {
|
|
return _custom(ZodCustom, fn ?? (() => true), _params);
|
|
}
|
|
function refine(fn, _params = {}) {
|
|
return _refine(ZodCustom, fn, _params);
|
|
}
|
|
function superRefine(fn, params) {
|
|
const ch = check((payload) => {
|
|
payload.addIssue = (issue2) => {
|
|
if (typeof issue2 === "string") {
|
|
payload.issues.push(exports_util.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(exports_util.issue(_issue));
|
|
}
|
|
};
|
|
return fn(payload.value, payload);
|
|
}, params);
|
|
return ch;
|
|
}
|
|
function preprocess(fn, schema) {
|
|
return pipe(transform(fn), schema);
|
|
}
|
|
// ../node_modules/zod/v4/classic/external.js
|
|
config(en_default2());
|
|
|
|
// ../node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
|
|
var LATEST_PROTOCOL_VERSION = "2025-11-25";
|
|
var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"];
|
|
var RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task";
|
|
var JSONRPC_VERSION = "2.0";
|
|
var AssertObjectSchema = custom((v) => v !== null && (typeof v === "object" || typeof v === "function"));
|
|
var ProgressTokenSchema = union([string2(), number2().int()]);
|
|
var CursorSchema = string2();
|
|
var TaskCreationParamsSchema = looseObject({
|
|
ttl: union([number2(), _null3()]).optional(),
|
|
pollInterval: number2().optional()
|
|
});
|
|
var RelatedTaskMetadataSchema = looseObject({
|
|
taskId: string2()
|
|
});
|
|
var RequestMetaSchema = looseObject({
|
|
progressToken: ProgressTokenSchema.optional(),
|
|
[RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional()
|
|
});
|
|
var BaseRequestParamsSchema = looseObject({
|
|
task: TaskCreationParamsSchema.optional(),
|
|
_meta: RequestMetaSchema.optional()
|
|
});
|
|
var RequestSchema = object2({
|
|
method: string2(),
|
|
params: BaseRequestParamsSchema.optional()
|
|
});
|
|
var NotificationsParamsSchema = looseObject({
|
|
_meta: object2({
|
|
[RELATED_TASK_META_KEY]: optional(RelatedTaskMetadataSchema)
|
|
}).passthrough().optional()
|
|
});
|
|
var NotificationSchema = object2({
|
|
method: string2(),
|
|
params: NotificationsParamsSchema.optional()
|
|
});
|
|
var ResultSchema = looseObject({
|
|
_meta: looseObject({
|
|
[RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional()
|
|
}).optional()
|
|
});
|
|
var RequestIdSchema = union([string2(), number2().int()]);
|
|
var JSONRPCRequestSchema = object2({
|
|
jsonrpc: literal(JSONRPC_VERSION),
|
|
id: RequestIdSchema,
|
|
...RequestSchema.shape
|
|
}).strict();
|
|
var isJSONRPCRequest = (value) => JSONRPCRequestSchema.safeParse(value).success;
|
|
var JSONRPCNotificationSchema = object2({
|
|
jsonrpc: literal(JSONRPC_VERSION),
|
|
...NotificationSchema.shape
|
|
}).strict();
|
|
var isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safeParse(value).success;
|
|
var JSONRPCResponseSchema = object2({
|
|
jsonrpc: literal(JSONRPC_VERSION),
|
|
id: RequestIdSchema,
|
|
result: ResultSchema
|
|
}).strict();
|
|
var isJSONRPCResponse = (value) => JSONRPCResponseSchema.safeParse(value).success;
|
|
var ErrorCode;
|
|
(function(ErrorCode2) {
|
|
ErrorCode2[ErrorCode2["ConnectionClosed"] = -32000] = "ConnectionClosed";
|
|
ErrorCode2[ErrorCode2["RequestTimeout"] = -32001] = "RequestTimeout";
|
|
ErrorCode2[ErrorCode2["ParseError"] = -32700] = "ParseError";
|
|
ErrorCode2[ErrorCode2["InvalidRequest"] = -32600] = "InvalidRequest";
|
|
ErrorCode2[ErrorCode2["MethodNotFound"] = -32601] = "MethodNotFound";
|
|
ErrorCode2[ErrorCode2["InvalidParams"] = -32602] = "InvalidParams";
|
|
ErrorCode2[ErrorCode2["InternalError"] = -32603] = "InternalError";
|
|
ErrorCode2[ErrorCode2["UrlElicitationRequired"] = -32042] = "UrlElicitationRequired";
|
|
})(ErrorCode || (ErrorCode = {}));
|
|
var JSONRPCErrorSchema = object2({
|
|
jsonrpc: literal(JSONRPC_VERSION),
|
|
id: RequestIdSchema,
|
|
error: object2({
|
|
code: number2().int(),
|
|
message: string2(),
|
|
data: optional(unknown())
|
|
})
|
|
}).strict();
|
|
var isJSONRPCError = (value) => JSONRPCErrorSchema.safeParse(value).success;
|
|
var JSONRPCMessageSchema = union([JSONRPCRequestSchema, JSONRPCNotificationSchema, JSONRPCResponseSchema, JSONRPCErrorSchema]);
|
|
var EmptyResultSchema = ResultSchema.strict();
|
|
var CancelledNotificationParamsSchema = NotificationsParamsSchema.extend({
|
|
requestId: RequestIdSchema,
|
|
reason: string2().optional()
|
|
});
|
|
var CancelledNotificationSchema = NotificationSchema.extend({
|
|
method: literal("notifications/cancelled"),
|
|
params: CancelledNotificationParamsSchema
|
|
});
|
|
var IconSchema = object2({
|
|
src: string2(),
|
|
mimeType: string2().optional(),
|
|
sizes: array(string2()).optional()
|
|
});
|
|
var IconsSchema = object2({
|
|
icons: array(IconSchema).optional()
|
|
});
|
|
var BaseMetadataSchema = object2({
|
|
name: string2(),
|
|
title: string2().optional()
|
|
});
|
|
var ImplementationSchema = BaseMetadataSchema.extend({
|
|
...BaseMetadataSchema.shape,
|
|
...IconsSchema.shape,
|
|
version: string2(),
|
|
websiteUrl: string2().optional()
|
|
});
|
|
var FormElicitationCapabilitySchema = intersection(object2({
|
|
applyDefaults: boolean2().optional()
|
|
}), record(string2(), unknown()));
|
|
var ElicitationCapabilitySchema = preprocess((value) => {
|
|
if (value && typeof value === "object" && !Array.isArray(value)) {
|
|
if (Object.keys(value).length === 0) {
|
|
return { form: {} };
|
|
}
|
|
}
|
|
return value;
|
|
}, intersection(object2({
|
|
form: FormElicitationCapabilitySchema.optional(),
|
|
url: AssertObjectSchema.optional()
|
|
}), record(string2(), unknown()).optional()));
|
|
var ClientTasksCapabilitySchema = object2({
|
|
list: optional(object2({}).passthrough()),
|
|
cancel: optional(object2({}).passthrough()),
|
|
requests: optional(object2({
|
|
sampling: optional(object2({
|
|
createMessage: optional(object2({}).passthrough())
|
|
}).passthrough()),
|
|
elicitation: optional(object2({
|
|
create: optional(object2({}).passthrough())
|
|
}).passthrough())
|
|
}).passthrough())
|
|
}).passthrough();
|
|
var ServerTasksCapabilitySchema = object2({
|
|
list: optional(object2({}).passthrough()),
|
|
cancel: optional(object2({}).passthrough()),
|
|
requests: optional(object2({
|
|
tools: optional(object2({
|
|
call: optional(object2({}).passthrough())
|
|
}).passthrough())
|
|
}).passthrough())
|
|
}).passthrough();
|
|
var ClientCapabilitiesSchema = object2({
|
|
experimental: record(string2(), AssertObjectSchema).optional(),
|
|
sampling: object2({
|
|
context: AssertObjectSchema.optional(),
|
|
tools: AssertObjectSchema.optional()
|
|
}).optional(),
|
|
elicitation: ElicitationCapabilitySchema.optional(),
|
|
roots: object2({
|
|
listChanged: boolean2().optional()
|
|
}).optional(),
|
|
tasks: optional(ClientTasksCapabilitySchema)
|
|
});
|
|
var InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
|
|
protocolVersion: string2(),
|
|
capabilities: ClientCapabilitiesSchema,
|
|
clientInfo: ImplementationSchema
|
|
});
|
|
var InitializeRequestSchema = RequestSchema.extend({
|
|
method: literal("initialize"),
|
|
params: InitializeRequestParamsSchema
|
|
});
|
|
var ServerCapabilitiesSchema = object2({
|
|
experimental: record(string2(), AssertObjectSchema).optional(),
|
|
logging: AssertObjectSchema.optional(),
|
|
completions: AssertObjectSchema.optional(),
|
|
prompts: optional(object2({
|
|
listChanged: optional(boolean2())
|
|
})),
|
|
resources: object2({
|
|
subscribe: boolean2().optional(),
|
|
listChanged: boolean2().optional()
|
|
}).optional(),
|
|
tools: object2({
|
|
listChanged: boolean2().optional()
|
|
}).optional(),
|
|
tasks: optional(ServerTasksCapabilitySchema)
|
|
}).passthrough();
|
|
var InitializeResultSchema = ResultSchema.extend({
|
|
protocolVersion: string2(),
|
|
capabilities: ServerCapabilitiesSchema,
|
|
serverInfo: ImplementationSchema,
|
|
instructions: string2().optional()
|
|
});
|
|
var InitializedNotificationSchema = NotificationSchema.extend({
|
|
method: literal("notifications/initialized")
|
|
});
|
|
var PingRequestSchema = RequestSchema.extend({
|
|
method: literal("ping")
|
|
});
|
|
var ProgressSchema = object2({
|
|
progress: number2(),
|
|
total: optional(number2()),
|
|
message: optional(string2())
|
|
});
|
|
var ProgressNotificationParamsSchema = object2({
|
|
...NotificationsParamsSchema.shape,
|
|
...ProgressSchema.shape,
|
|
progressToken: ProgressTokenSchema
|
|
});
|
|
var ProgressNotificationSchema = NotificationSchema.extend({
|
|
method: literal("notifications/progress"),
|
|
params: ProgressNotificationParamsSchema
|
|
});
|
|
var PaginatedRequestParamsSchema = BaseRequestParamsSchema.extend({
|
|
cursor: CursorSchema.optional()
|
|
});
|
|
var PaginatedRequestSchema = RequestSchema.extend({
|
|
params: PaginatedRequestParamsSchema.optional()
|
|
});
|
|
var PaginatedResultSchema = ResultSchema.extend({
|
|
nextCursor: optional(CursorSchema)
|
|
});
|
|
var TaskSchema = object2({
|
|
taskId: string2(),
|
|
status: _enum(["working", "input_required", "completed", "failed", "cancelled"]),
|
|
ttl: union([number2(), _null3()]),
|
|
createdAt: string2(),
|
|
lastUpdatedAt: string2(),
|
|
pollInterval: optional(number2()),
|
|
statusMessage: optional(string2())
|
|
});
|
|
var CreateTaskResultSchema = ResultSchema.extend({
|
|
task: TaskSchema
|
|
});
|
|
var TaskStatusNotificationParamsSchema = NotificationsParamsSchema.merge(TaskSchema);
|
|
var TaskStatusNotificationSchema = NotificationSchema.extend({
|
|
method: literal("notifications/tasks/status"),
|
|
params: TaskStatusNotificationParamsSchema
|
|
});
|
|
var GetTaskRequestSchema = RequestSchema.extend({
|
|
method: literal("tasks/get"),
|
|
params: BaseRequestParamsSchema.extend({
|
|
taskId: string2()
|
|
})
|
|
});
|
|
var GetTaskResultSchema = ResultSchema.merge(TaskSchema);
|
|
var GetTaskPayloadRequestSchema = RequestSchema.extend({
|
|
method: literal("tasks/result"),
|
|
params: BaseRequestParamsSchema.extend({
|
|
taskId: string2()
|
|
})
|
|
});
|
|
var ListTasksRequestSchema = PaginatedRequestSchema.extend({
|
|
method: literal("tasks/list")
|
|
});
|
|
var ListTasksResultSchema = PaginatedResultSchema.extend({
|
|
tasks: array(TaskSchema)
|
|
});
|
|
var CancelTaskRequestSchema = RequestSchema.extend({
|
|
method: literal("tasks/cancel"),
|
|
params: BaseRequestParamsSchema.extend({
|
|
taskId: string2()
|
|
})
|
|
});
|
|
var CancelTaskResultSchema = ResultSchema.merge(TaskSchema);
|
|
var ResourceContentsSchema = object2({
|
|
uri: string2(),
|
|
mimeType: optional(string2()),
|
|
_meta: record(string2(), unknown()).optional()
|
|
});
|
|
var TextResourceContentsSchema = ResourceContentsSchema.extend({
|
|
text: string2()
|
|
});
|
|
var Base64Schema = string2().refine((val) => {
|
|
try {
|
|
atob(val);
|
|
return true;
|
|
} catch (_a) {
|
|
return false;
|
|
}
|
|
}, { message: "Invalid Base64 string" });
|
|
var BlobResourceContentsSchema = ResourceContentsSchema.extend({
|
|
blob: Base64Schema
|
|
});
|
|
var AnnotationsSchema = object2({
|
|
audience: array(_enum(["user", "assistant"])).optional(),
|
|
priority: number2().min(0).max(1).optional(),
|
|
lastModified: exports_iso2.datetime({ offset: true }).optional()
|
|
});
|
|
var ResourceSchema = object2({
|
|
...BaseMetadataSchema.shape,
|
|
...IconsSchema.shape,
|
|
uri: string2(),
|
|
description: optional(string2()),
|
|
mimeType: optional(string2()),
|
|
annotations: AnnotationsSchema.optional(),
|
|
_meta: optional(looseObject({}))
|
|
});
|
|
var ResourceTemplateSchema = object2({
|
|
...BaseMetadataSchema.shape,
|
|
...IconsSchema.shape,
|
|
uriTemplate: string2(),
|
|
description: optional(string2()),
|
|
mimeType: optional(string2()),
|
|
annotations: AnnotationsSchema.optional(),
|
|
_meta: optional(looseObject({}))
|
|
});
|
|
var ListResourcesRequestSchema = PaginatedRequestSchema.extend({
|
|
method: literal("resources/list")
|
|
});
|
|
var ListResourcesResultSchema = PaginatedResultSchema.extend({
|
|
resources: array(ResourceSchema)
|
|
});
|
|
var ListResourceTemplatesRequestSchema = PaginatedRequestSchema.extend({
|
|
method: literal("resources/templates/list")
|
|
});
|
|
var ListResourceTemplatesResultSchema = PaginatedResultSchema.extend({
|
|
resourceTemplates: array(ResourceTemplateSchema)
|
|
});
|
|
var ResourceRequestParamsSchema = BaseRequestParamsSchema.extend({
|
|
uri: string2()
|
|
});
|
|
var ReadResourceRequestParamsSchema = ResourceRequestParamsSchema;
|
|
var ReadResourceRequestSchema = RequestSchema.extend({
|
|
method: literal("resources/read"),
|
|
params: ReadResourceRequestParamsSchema
|
|
});
|
|
var ReadResourceResultSchema = ResultSchema.extend({
|
|
contents: array(union([TextResourceContentsSchema, BlobResourceContentsSchema]))
|
|
});
|
|
var ResourceListChangedNotificationSchema = NotificationSchema.extend({
|
|
method: literal("notifications/resources/list_changed")
|
|
});
|
|
var SubscribeRequestParamsSchema = ResourceRequestParamsSchema;
|
|
var SubscribeRequestSchema = RequestSchema.extend({
|
|
method: literal("resources/subscribe"),
|
|
params: SubscribeRequestParamsSchema
|
|
});
|
|
var UnsubscribeRequestParamsSchema = ResourceRequestParamsSchema;
|
|
var UnsubscribeRequestSchema = RequestSchema.extend({
|
|
method: literal("resources/unsubscribe"),
|
|
params: UnsubscribeRequestParamsSchema
|
|
});
|
|
var ResourceUpdatedNotificationParamsSchema = NotificationsParamsSchema.extend({
|
|
uri: string2()
|
|
});
|
|
var ResourceUpdatedNotificationSchema = NotificationSchema.extend({
|
|
method: literal("notifications/resources/updated"),
|
|
params: ResourceUpdatedNotificationParamsSchema
|
|
});
|
|
var PromptArgumentSchema = object2({
|
|
name: string2(),
|
|
description: optional(string2()),
|
|
required: optional(boolean2())
|
|
});
|
|
var PromptSchema = object2({
|
|
...BaseMetadataSchema.shape,
|
|
...IconsSchema.shape,
|
|
description: optional(string2()),
|
|
arguments: optional(array(PromptArgumentSchema)),
|
|
_meta: optional(looseObject({}))
|
|
});
|
|
var ListPromptsRequestSchema = PaginatedRequestSchema.extend({
|
|
method: literal("prompts/list")
|
|
});
|
|
var ListPromptsResultSchema = PaginatedResultSchema.extend({
|
|
prompts: array(PromptSchema)
|
|
});
|
|
var GetPromptRequestParamsSchema = BaseRequestParamsSchema.extend({
|
|
name: string2(),
|
|
arguments: record(string2(), string2()).optional()
|
|
});
|
|
var GetPromptRequestSchema = RequestSchema.extend({
|
|
method: literal("prompts/get"),
|
|
params: GetPromptRequestParamsSchema
|
|
});
|
|
var TextContentSchema = object2({
|
|
type: literal("text"),
|
|
text: string2(),
|
|
annotations: AnnotationsSchema.optional(),
|
|
_meta: record(string2(), unknown()).optional()
|
|
});
|
|
var ImageContentSchema = object2({
|
|
type: literal("image"),
|
|
data: Base64Schema,
|
|
mimeType: string2(),
|
|
annotations: AnnotationsSchema.optional(),
|
|
_meta: record(string2(), unknown()).optional()
|
|
});
|
|
var AudioContentSchema = object2({
|
|
type: literal("audio"),
|
|
data: Base64Schema,
|
|
mimeType: string2(),
|
|
annotations: AnnotationsSchema.optional(),
|
|
_meta: record(string2(), unknown()).optional()
|
|
});
|
|
var ToolUseContentSchema = object2({
|
|
type: literal("tool_use"),
|
|
name: string2(),
|
|
id: string2(),
|
|
input: object2({}).passthrough(),
|
|
_meta: optional(object2({}).passthrough())
|
|
}).passthrough();
|
|
var EmbeddedResourceSchema = object2({
|
|
type: literal("resource"),
|
|
resource: union([TextResourceContentsSchema, BlobResourceContentsSchema]),
|
|
annotations: AnnotationsSchema.optional(),
|
|
_meta: record(string2(), unknown()).optional()
|
|
});
|
|
var ResourceLinkSchema = ResourceSchema.extend({
|
|
type: literal("resource_link")
|
|
});
|
|
var ContentBlockSchema = union([
|
|
TextContentSchema,
|
|
ImageContentSchema,
|
|
AudioContentSchema,
|
|
ResourceLinkSchema,
|
|
EmbeddedResourceSchema
|
|
]);
|
|
var PromptMessageSchema = object2({
|
|
role: _enum(["user", "assistant"]),
|
|
content: ContentBlockSchema
|
|
});
|
|
var GetPromptResultSchema = ResultSchema.extend({
|
|
description: optional(string2()),
|
|
messages: array(PromptMessageSchema)
|
|
});
|
|
var PromptListChangedNotificationSchema = NotificationSchema.extend({
|
|
method: literal("notifications/prompts/list_changed")
|
|
});
|
|
var ToolAnnotationsSchema = object2({
|
|
title: string2().optional(),
|
|
readOnlyHint: boolean2().optional(),
|
|
destructiveHint: boolean2().optional(),
|
|
idempotentHint: boolean2().optional(),
|
|
openWorldHint: boolean2().optional()
|
|
});
|
|
var ToolExecutionSchema = object2({
|
|
taskSupport: _enum(["required", "optional", "forbidden"]).optional()
|
|
});
|
|
var ToolSchema = object2({
|
|
...BaseMetadataSchema.shape,
|
|
...IconsSchema.shape,
|
|
description: string2().optional(),
|
|
inputSchema: object2({
|
|
type: literal("object"),
|
|
properties: record(string2(), AssertObjectSchema).optional(),
|
|
required: array(string2()).optional()
|
|
}).catchall(unknown()),
|
|
outputSchema: object2({
|
|
type: literal("object"),
|
|
properties: record(string2(), AssertObjectSchema).optional(),
|
|
required: array(string2()).optional()
|
|
}).catchall(unknown()).optional(),
|
|
annotations: optional(ToolAnnotationsSchema),
|
|
execution: optional(ToolExecutionSchema),
|
|
_meta: record(string2(), unknown()).optional()
|
|
});
|
|
var ListToolsRequestSchema = PaginatedRequestSchema.extend({
|
|
method: literal("tools/list")
|
|
});
|
|
var ListToolsResultSchema = PaginatedResultSchema.extend({
|
|
tools: array(ToolSchema)
|
|
});
|
|
var CallToolResultSchema = ResultSchema.extend({
|
|
content: array(ContentBlockSchema).default([]),
|
|
structuredContent: record(string2(), unknown()).optional(),
|
|
isError: optional(boolean2())
|
|
});
|
|
var CompatibilityCallToolResultSchema = CallToolResultSchema.or(ResultSchema.extend({
|
|
toolResult: unknown()
|
|
}));
|
|
var CallToolRequestParamsSchema = BaseRequestParamsSchema.extend({
|
|
name: string2(),
|
|
arguments: optional(record(string2(), unknown()))
|
|
});
|
|
var CallToolRequestSchema = RequestSchema.extend({
|
|
method: literal("tools/call"),
|
|
params: CallToolRequestParamsSchema
|
|
});
|
|
var ToolListChangedNotificationSchema = NotificationSchema.extend({
|
|
method: literal("notifications/tools/list_changed")
|
|
});
|
|
var LoggingLevelSchema = _enum(["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]);
|
|
var SetLevelRequestParamsSchema = BaseRequestParamsSchema.extend({
|
|
level: LoggingLevelSchema
|
|
});
|
|
var SetLevelRequestSchema = RequestSchema.extend({
|
|
method: literal("logging/setLevel"),
|
|
params: SetLevelRequestParamsSchema
|
|
});
|
|
var LoggingMessageNotificationParamsSchema = NotificationsParamsSchema.extend({
|
|
level: LoggingLevelSchema,
|
|
logger: string2().optional(),
|
|
data: unknown()
|
|
});
|
|
var LoggingMessageNotificationSchema = NotificationSchema.extend({
|
|
method: literal("notifications/message"),
|
|
params: LoggingMessageNotificationParamsSchema
|
|
});
|
|
var ModelHintSchema = object2({
|
|
name: string2().optional()
|
|
});
|
|
var ModelPreferencesSchema = object2({
|
|
hints: optional(array(ModelHintSchema)),
|
|
costPriority: optional(number2().min(0).max(1)),
|
|
speedPriority: optional(number2().min(0).max(1)),
|
|
intelligencePriority: optional(number2().min(0).max(1))
|
|
});
|
|
var ToolChoiceSchema = object2({
|
|
mode: optional(_enum(["auto", "required", "none"]))
|
|
});
|
|
var ToolResultContentSchema = object2({
|
|
type: literal("tool_result"),
|
|
toolUseId: string2().describe("The unique identifier for the corresponding tool call."),
|
|
content: array(ContentBlockSchema).default([]),
|
|
structuredContent: object2({}).passthrough().optional(),
|
|
isError: optional(boolean2()),
|
|
_meta: optional(object2({}).passthrough())
|
|
}).passthrough();
|
|
var SamplingContentSchema = discriminatedUnion("type", [TextContentSchema, ImageContentSchema, AudioContentSchema]);
|
|
var SamplingMessageContentBlockSchema = discriminatedUnion("type", [
|
|
TextContentSchema,
|
|
ImageContentSchema,
|
|
AudioContentSchema,
|
|
ToolUseContentSchema,
|
|
ToolResultContentSchema
|
|
]);
|
|
var SamplingMessageSchema = object2({
|
|
role: _enum(["user", "assistant"]),
|
|
content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)]),
|
|
_meta: optional(object2({}).passthrough())
|
|
}).passthrough();
|
|
var CreateMessageRequestParamsSchema = BaseRequestParamsSchema.extend({
|
|
messages: array(SamplingMessageSchema),
|
|
modelPreferences: ModelPreferencesSchema.optional(),
|
|
systemPrompt: string2().optional(),
|
|
includeContext: _enum(["none", "thisServer", "allServers"]).optional(),
|
|
temperature: number2().optional(),
|
|
maxTokens: number2().int(),
|
|
stopSequences: array(string2()).optional(),
|
|
metadata: AssertObjectSchema.optional(),
|
|
tools: optional(array(ToolSchema)),
|
|
toolChoice: optional(ToolChoiceSchema)
|
|
});
|
|
var CreateMessageRequestSchema = RequestSchema.extend({
|
|
method: literal("sampling/createMessage"),
|
|
params: CreateMessageRequestParamsSchema
|
|
});
|
|
var CreateMessageResultSchema = ResultSchema.extend({
|
|
model: string2(),
|
|
stopReason: optional(_enum(["endTurn", "stopSequence", "maxTokens"]).or(string2())),
|
|
role: _enum(["user", "assistant"]),
|
|
content: SamplingContentSchema
|
|
});
|
|
var CreateMessageResultWithToolsSchema = ResultSchema.extend({
|
|
model: string2(),
|
|
stopReason: optional(_enum(["endTurn", "stopSequence", "maxTokens", "toolUse"]).or(string2())),
|
|
role: _enum(["user", "assistant"]),
|
|
content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)])
|
|
});
|
|
var BooleanSchemaSchema = object2({
|
|
type: literal("boolean"),
|
|
title: string2().optional(),
|
|
description: string2().optional(),
|
|
default: boolean2().optional()
|
|
});
|
|
var StringSchemaSchema = object2({
|
|
type: literal("string"),
|
|
title: string2().optional(),
|
|
description: string2().optional(),
|
|
minLength: number2().optional(),
|
|
maxLength: number2().optional(),
|
|
format: _enum(["email", "uri", "date", "date-time"]).optional(),
|
|
default: string2().optional()
|
|
});
|
|
var NumberSchemaSchema = object2({
|
|
type: _enum(["number", "integer"]),
|
|
title: string2().optional(),
|
|
description: string2().optional(),
|
|
minimum: number2().optional(),
|
|
maximum: number2().optional(),
|
|
default: number2().optional()
|
|
});
|
|
var UntitledSingleSelectEnumSchemaSchema = object2({
|
|
type: literal("string"),
|
|
title: string2().optional(),
|
|
description: string2().optional(),
|
|
enum: array(string2()),
|
|
default: string2().optional()
|
|
});
|
|
var TitledSingleSelectEnumSchemaSchema = object2({
|
|
type: literal("string"),
|
|
title: string2().optional(),
|
|
description: string2().optional(),
|
|
oneOf: array(object2({
|
|
const: string2(),
|
|
title: string2()
|
|
})),
|
|
default: string2().optional()
|
|
});
|
|
var LegacyTitledEnumSchemaSchema = object2({
|
|
type: literal("string"),
|
|
title: string2().optional(),
|
|
description: string2().optional(),
|
|
enum: array(string2()),
|
|
enumNames: array(string2()).optional(),
|
|
default: string2().optional()
|
|
});
|
|
var SingleSelectEnumSchemaSchema = union([UntitledSingleSelectEnumSchemaSchema, TitledSingleSelectEnumSchemaSchema]);
|
|
var UntitledMultiSelectEnumSchemaSchema = object2({
|
|
type: literal("array"),
|
|
title: string2().optional(),
|
|
description: string2().optional(),
|
|
minItems: number2().optional(),
|
|
maxItems: number2().optional(),
|
|
items: object2({
|
|
type: literal("string"),
|
|
enum: array(string2())
|
|
}),
|
|
default: array(string2()).optional()
|
|
});
|
|
var TitledMultiSelectEnumSchemaSchema = object2({
|
|
type: literal("array"),
|
|
title: string2().optional(),
|
|
description: string2().optional(),
|
|
minItems: number2().optional(),
|
|
maxItems: number2().optional(),
|
|
items: object2({
|
|
anyOf: array(object2({
|
|
const: string2(),
|
|
title: string2()
|
|
}))
|
|
}),
|
|
default: array(string2()).optional()
|
|
});
|
|
var MultiSelectEnumSchemaSchema = union([UntitledMultiSelectEnumSchemaSchema, TitledMultiSelectEnumSchemaSchema]);
|
|
var EnumSchemaSchema = union([LegacyTitledEnumSchemaSchema, SingleSelectEnumSchemaSchema, MultiSelectEnumSchemaSchema]);
|
|
var PrimitiveSchemaDefinitionSchema = union([EnumSchemaSchema, BooleanSchemaSchema, StringSchemaSchema, NumberSchemaSchema]);
|
|
var ElicitRequestFormParamsSchema = BaseRequestParamsSchema.extend({
|
|
mode: literal("form").optional(),
|
|
message: string2(),
|
|
requestedSchema: object2({
|
|
type: literal("object"),
|
|
properties: record(string2(), PrimitiveSchemaDefinitionSchema),
|
|
required: array(string2()).optional()
|
|
})
|
|
});
|
|
var ElicitRequestURLParamsSchema = BaseRequestParamsSchema.extend({
|
|
mode: literal("url"),
|
|
message: string2(),
|
|
elicitationId: string2(),
|
|
url: string2().url()
|
|
});
|
|
var ElicitRequestParamsSchema = union([ElicitRequestFormParamsSchema, ElicitRequestURLParamsSchema]);
|
|
var ElicitRequestSchema = RequestSchema.extend({
|
|
method: literal("elicitation/create"),
|
|
params: ElicitRequestParamsSchema
|
|
});
|
|
var ElicitationCompleteNotificationParamsSchema = NotificationsParamsSchema.extend({
|
|
elicitationId: string2()
|
|
});
|
|
var ElicitationCompleteNotificationSchema = NotificationSchema.extend({
|
|
method: literal("notifications/elicitation/complete"),
|
|
params: ElicitationCompleteNotificationParamsSchema
|
|
});
|
|
var ElicitResultSchema = ResultSchema.extend({
|
|
action: _enum(["accept", "decline", "cancel"]),
|
|
content: preprocess((val) => val === null ? undefined : val, record(string2(), union([string2(), number2(), boolean2(), array(string2())])).optional())
|
|
});
|
|
var ResourceTemplateReferenceSchema = object2({
|
|
type: literal("ref/resource"),
|
|
uri: string2()
|
|
});
|
|
var PromptReferenceSchema = object2({
|
|
type: literal("ref/prompt"),
|
|
name: string2()
|
|
});
|
|
var CompleteRequestParamsSchema = BaseRequestParamsSchema.extend({
|
|
ref: union([PromptReferenceSchema, ResourceTemplateReferenceSchema]),
|
|
argument: object2({
|
|
name: string2(),
|
|
value: string2()
|
|
}),
|
|
context: object2({
|
|
arguments: record(string2(), string2()).optional()
|
|
}).optional()
|
|
});
|
|
var CompleteRequestSchema = RequestSchema.extend({
|
|
method: literal("completion/complete"),
|
|
params: CompleteRequestParamsSchema
|
|
});
|
|
function assertCompleteRequestPrompt(request) {
|
|
if (request.params.ref.type !== "ref/prompt") {
|
|
throw new TypeError(`Expected CompleteRequestPrompt, but got ${request.params.ref.type}`);
|
|
}
|
|
}
|
|
function assertCompleteRequestResourceTemplate(request) {
|
|
if (request.params.ref.type !== "ref/resource") {
|
|
throw new TypeError(`Expected CompleteRequestResourceTemplate, but got ${request.params.ref.type}`);
|
|
}
|
|
}
|
|
var CompleteResultSchema = ResultSchema.extend({
|
|
completion: looseObject({
|
|
values: array(string2()).max(100),
|
|
total: optional(number2().int()),
|
|
hasMore: optional(boolean2())
|
|
})
|
|
});
|
|
var RootSchema = object2({
|
|
uri: string2().startsWith("file://"),
|
|
name: string2().optional(),
|
|
_meta: record(string2(), unknown()).optional()
|
|
});
|
|
var ListRootsRequestSchema = RequestSchema.extend({
|
|
method: literal("roots/list")
|
|
});
|
|
var ListRootsResultSchema = ResultSchema.extend({
|
|
roots: array(RootSchema)
|
|
});
|
|
var RootsListChangedNotificationSchema = NotificationSchema.extend({
|
|
method: literal("notifications/roots/list_changed")
|
|
});
|
|
var ClientRequestSchema = union([
|
|
PingRequestSchema,
|
|
InitializeRequestSchema,
|
|
CompleteRequestSchema,
|
|
SetLevelRequestSchema,
|
|
GetPromptRequestSchema,
|
|
ListPromptsRequestSchema,
|
|
ListResourcesRequestSchema,
|
|
ListResourceTemplatesRequestSchema,
|
|
ReadResourceRequestSchema,
|
|
SubscribeRequestSchema,
|
|
UnsubscribeRequestSchema,
|
|
CallToolRequestSchema,
|
|
ListToolsRequestSchema,
|
|
GetTaskRequestSchema,
|
|
GetTaskPayloadRequestSchema,
|
|
ListTasksRequestSchema
|
|
]);
|
|
var ClientNotificationSchema = union([
|
|
CancelledNotificationSchema,
|
|
ProgressNotificationSchema,
|
|
InitializedNotificationSchema,
|
|
RootsListChangedNotificationSchema,
|
|
TaskStatusNotificationSchema
|
|
]);
|
|
var ClientResultSchema = union([
|
|
EmptyResultSchema,
|
|
CreateMessageResultSchema,
|
|
CreateMessageResultWithToolsSchema,
|
|
ElicitResultSchema,
|
|
ListRootsResultSchema,
|
|
GetTaskResultSchema,
|
|
ListTasksResultSchema,
|
|
CreateTaskResultSchema
|
|
]);
|
|
var ServerRequestSchema = union([
|
|
PingRequestSchema,
|
|
CreateMessageRequestSchema,
|
|
ElicitRequestSchema,
|
|
ListRootsRequestSchema,
|
|
GetTaskRequestSchema,
|
|
GetTaskPayloadRequestSchema,
|
|
ListTasksRequestSchema
|
|
]);
|
|
var ServerNotificationSchema = union([
|
|
CancelledNotificationSchema,
|
|
ProgressNotificationSchema,
|
|
LoggingMessageNotificationSchema,
|
|
ResourceUpdatedNotificationSchema,
|
|
ResourceListChangedNotificationSchema,
|
|
ToolListChangedNotificationSchema,
|
|
PromptListChangedNotificationSchema,
|
|
TaskStatusNotificationSchema,
|
|
ElicitationCompleteNotificationSchema
|
|
]);
|
|
var ServerResultSchema = union([
|
|
EmptyResultSchema,
|
|
InitializeResultSchema,
|
|
CompleteResultSchema,
|
|
GetPromptResultSchema,
|
|
ListPromptsResultSchema,
|
|
ListResourcesResultSchema,
|
|
ListResourceTemplatesResultSchema,
|
|
ReadResourceResultSchema,
|
|
CallToolResultSchema,
|
|
ListToolsResultSchema,
|
|
GetTaskResultSchema,
|
|
ListTasksResultSchema,
|
|
CreateTaskResultSchema
|
|
]);
|
|
|
|
class McpError extends Error {
|
|
constructor(code, message, data) {
|
|
super(`MCP error ${code}: ${message}`);
|
|
this.code = code;
|
|
this.data = data;
|
|
this.name = "McpError";
|
|
}
|
|
static fromError(code, message, data) {
|
|
if (code === ErrorCode.UrlElicitationRequired && data) {
|
|
const errorData = data;
|
|
if (errorData.elicitations) {
|
|
return new UrlElicitationRequiredError(errorData.elicitations, message);
|
|
}
|
|
}
|
|
return new McpError(code, message, data);
|
|
}
|
|
}
|
|
|
|
class UrlElicitationRequiredError extends McpError {
|
|
constructor(elicitations, message = `URL elicitation${elicitations.length > 1 ? "s" : ""} required`) {
|
|
super(ErrorCode.UrlElicitationRequired, message, {
|
|
elicitations
|
|
});
|
|
}
|
|
get elicitations() {
|
|
var _a, _b;
|
|
return (_b = (_a = this.data) === null || _a === undefined ? undefined : _a.elicitations) !== null && _b !== undefined ? _b : [];
|
|
}
|
|
}
|
|
|
|
// ../node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js
|
|
function isTerminal(status) {
|
|
return status === "completed" || status === "failed" || status === "cancelled";
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/Options.js
|
|
var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
|
|
var defaultOptions = {
|
|
name: undefined,
|
|
$refStrategy: "root",
|
|
basePath: ["#"],
|
|
effectStrategy: "input",
|
|
pipeStrategy: "all",
|
|
dateStrategy: "format:date-time",
|
|
mapStrategy: "entries",
|
|
removeAdditionalStrategy: "passthrough",
|
|
allowedAdditionalProperties: true,
|
|
rejectedAdditionalProperties: false,
|
|
definitionPath: "definitions",
|
|
target: "jsonSchema7",
|
|
strictUnions: false,
|
|
definitions: {},
|
|
errorMessages: false,
|
|
markdownDescription: false,
|
|
patternStrategy: "escape",
|
|
applyRegexFlags: false,
|
|
emailStrategy: "format:email",
|
|
base64Strategy: "contentEncoding:base64",
|
|
nameStrategy: "ref",
|
|
openAiAnyTypeName: "OpenAiAnyType"
|
|
};
|
|
var getDefaultOptions = (options) => typeof options === "string" ? {
|
|
...defaultOptions,
|
|
name: options
|
|
} : {
|
|
...defaultOptions,
|
|
...options
|
|
};
|
|
// ../node_modules/zod-to-json-schema/dist/esm/Refs.js
|
|
var getRefs = (options) => {
|
|
const _options = getDefaultOptions(options);
|
|
const currentPath = _options.name !== undefined ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
|
|
return {
|
|
..._options,
|
|
flags: { hasReferencedOpenAiAnyType: false },
|
|
currentPath,
|
|
propertyPath: undefined,
|
|
seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
|
|
def._def,
|
|
{
|
|
def: def._def,
|
|
path: [..._options.basePath, _options.definitionPath, name],
|
|
jsonSchema: undefined
|
|
}
|
|
]))
|
|
};
|
|
};
|
|
// ../node_modules/zod-to-json-schema/dist/esm/errorMessages.js
|
|
function addErrorMessage(res, key, errorMessage, refs) {
|
|
if (!refs?.errorMessages)
|
|
return;
|
|
if (errorMessage) {
|
|
res.errorMessage = {
|
|
...res.errorMessage,
|
|
[key]: errorMessage
|
|
};
|
|
}
|
|
}
|
|
function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
|
|
res[key] = value;
|
|
addErrorMessage(res, key, errorMessage, refs);
|
|
}
|
|
// ../node_modules/zod-to-json-schema/dist/esm/getRelativePath.js
|
|
var getRelativePath = (pathA, pathB) => {
|
|
let i = 0;
|
|
for (;i < pathA.length && i < pathB.length; i++) {
|
|
if (pathA[i] !== pathB[i])
|
|
break;
|
|
}
|
|
return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
|
|
};
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/any.js
|
|
function parseAnyDef(refs) {
|
|
if (refs.target !== "openAi") {
|
|
return {};
|
|
}
|
|
const anyDefinitionPath = [
|
|
...refs.basePath,
|
|
refs.definitionPath,
|
|
refs.openAiAnyTypeName
|
|
];
|
|
refs.flags.hasReferencedOpenAiAnyType = true;
|
|
return {
|
|
$ref: refs.$refStrategy === "relative" ? getRelativePath(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/")
|
|
};
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/array.js
|
|
function parseArrayDef(def, refs) {
|
|
const res = {
|
|
type: "array"
|
|
};
|
|
if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
|
|
res.items = parseDef(def.type._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "items"]
|
|
});
|
|
}
|
|
if (def.minLength) {
|
|
setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
|
|
}
|
|
if (def.maxLength) {
|
|
setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
|
|
}
|
|
if (def.exactLength) {
|
|
setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
|
|
setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
|
|
function parseBigintDef(def, refs) {
|
|
const res = {
|
|
type: "integer",
|
|
format: "int64"
|
|
};
|
|
if (!def.checks)
|
|
return res;
|
|
for (const check2 of def.checks) {
|
|
switch (check2.kind) {
|
|
case "min":
|
|
if (refs.target === "jsonSchema7") {
|
|
if (check2.inclusive) {
|
|
setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
|
|
} else {
|
|
setResponseValueAndErrors(res, "exclusiveMinimum", check2.value, check2.message, refs);
|
|
}
|
|
} else {
|
|
if (!check2.inclusive) {
|
|
res.exclusiveMinimum = true;
|
|
}
|
|
setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
|
|
}
|
|
break;
|
|
case "max":
|
|
if (refs.target === "jsonSchema7") {
|
|
if (check2.inclusive) {
|
|
setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
|
|
} else {
|
|
setResponseValueAndErrors(res, "exclusiveMaximum", check2.value, check2.message, refs);
|
|
}
|
|
} else {
|
|
if (!check2.inclusive) {
|
|
res.exclusiveMaximum = true;
|
|
}
|
|
setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
|
|
}
|
|
break;
|
|
case "multipleOf":
|
|
setResponseValueAndErrors(res, "multipleOf", check2.value, check2.message, refs);
|
|
break;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
|
|
function parseBooleanDef() {
|
|
return {
|
|
type: "boolean"
|
|
};
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
|
|
function parseBrandedDef(_def, refs) {
|
|
return parseDef(_def.type._def, refs);
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
|
|
var parseCatchDef = (def, refs) => {
|
|
return parseDef(def.innerType._def, refs);
|
|
};
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/date.js
|
|
function parseDateDef(def, refs, overrideDateStrategy) {
|
|
const strategy = overrideDateStrategy ?? refs.dateStrategy;
|
|
if (Array.isArray(strategy)) {
|
|
return {
|
|
anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))
|
|
};
|
|
}
|
|
switch (strategy) {
|
|
case "string":
|
|
case "format:date-time":
|
|
return {
|
|
type: "string",
|
|
format: "date-time"
|
|
};
|
|
case "format:date":
|
|
return {
|
|
type: "string",
|
|
format: "date"
|
|
};
|
|
case "integer":
|
|
return integerDateParser(def, refs);
|
|
}
|
|
}
|
|
var integerDateParser = (def, refs) => {
|
|
const res = {
|
|
type: "integer",
|
|
format: "unix-time"
|
|
};
|
|
if (refs.target === "openApi3") {
|
|
return res;
|
|
}
|
|
for (const check2 of def.checks) {
|
|
switch (check2.kind) {
|
|
case "min":
|
|
setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
|
|
break;
|
|
case "max":
|
|
setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
|
|
break;
|
|
}
|
|
}
|
|
return res;
|
|
};
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/default.js
|
|
function parseDefaultDef(_def, refs) {
|
|
return {
|
|
...parseDef(_def.innerType._def, refs),
|
|
default: _def.defaultValue()
|
|
};
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/effects.js
|
|
function parseEffectsDef(_def, refs) {
|
|
return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef(refs);
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/enum.js
|
|
function parseEnumDef(def) {
|
|
return {
|
|
type: "string",
|
|
enum: Array.from(def.values)
|
|
};
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js
|
|
var isJsonSchema7AllOfType = (type) => {
|
|
if ("type" in type && type.type === "string")
|
|
return false;
|
|
return "allOf" in type;
|
|
};
|
|
function parseIntersectionDef(def, refs) {
|
|
const allOf = [
|
|
parseDef(def.left._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "allOf", "0"]
|
|
}),
|
|
parseDef(def.right._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "allOf", "1"]
|
|
})
|
|
].filter((x) => !!x);
|
|
let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : undefined;
|
|
const mergedAllOf = [];
|
|
allOf.forEach((schema) => {
|
|
if (isJsonSchema7AllOfType(schema)) {
|
|
mergedAllOf.push(...schema.allOf);
|
|
if (schema.unevaluatedProperties === undefined) {
|
|
unevaluatedProperties = undefined;
|
|
}
|
|
} else {
|
|
let nestedSchema = schema;
|
|
if ("additionalProperties" in schema && schema.additionalProperties === false) {
|
|
const { additionalProperties, ...rest } = schema;
|
|
nestedSchema = rest;
|
|
} else {
|
|
unevaluatedProperties = undefined;
|
|
}
|
|
mergedAllOf.push(nestedSchema);
|
|
}
|
|
});
|
|
return mergedAllOf.length ? {
|
|
allOf: mergedAllOf,
|
|
...unevaluatedProperties
|
|
} : undefined;
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/literal.js
|
|
function parseLiteralDef(def, refs) {
|
|
const parsedType2 = typeof def.value;
|
|
if (parsedType2 !== "bigint" && parsedType2 !== "number" && parsedType2 !== "boolean" && parsedType2 !== "string") {
|
|
return {
|
|
type: Array.isArray(def.value) ? "array" : "object"
|
|
};
|
|
}
|
|
if (refs.target === "openApi3") {
|
|
return {
|
|
type: parsedType2 === "bigint" ? "integer" : parsedType2,
|
|
enum: [def.value]
|
|
};
|
|
}
|
|
return {
|
|
type: parsedType2 === "bigint" ? "integer" : parsedType2,
|
|
const: def.value
|
|
};
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/string.js
|
|
var emojiRegex2 = undefined;
|
|
var zodPatterns = {
|
|
cuid: /^[cC][^\s-]{8,}$/,
|
|
cuid2: /^[0-9a-z]+$/,
|
|
ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
|
|
email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
|
|
emoji: () => {
|
|
if (emojiRegex2 === undefined) {
|
|
emojiRegex2 = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
|
|
}
|
|
return emojiRegex2;
|
|
},
|
|
uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
|
|
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])$/,
|
|
ipv4Cidr: /^(?:(?: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])\/(3[0-2]|[12]?[0-9])$/,
|
|
ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
|
|
ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,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}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
|
|
base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
|
|
base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
|
|
nanoid: /^[a-zA-Z0-9_-]{21}$/,
|
|
jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
|
|
};
|
|
function parseStringDef(def, refs) {
|
|
const res = {
|
|
type: "string"
|
|
};
|
|
if (def.checks) {
|
|
for (const check2 of def.checks) {
|
|
switch (check2.kind) {
|
|
case "min":
|
|
setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check2.value) : check2.value, check2.message, refs);
|
|
break;
|
|
case "max":
|
|
setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check2.value) : check2.value, check2.message, refs);
|
|
break;
|
|
case "email":
|
|
switch (refs.emailStrategy) {
|
|
case "format:email":
|
|
addFormat(res, "email", check2.message, refs);
|
|
break;
|
|
case "format:idn-email":
|
|
addFormat(res, "idn-email", check2.message, refs);
|
|
break;
|
|
case "pattern:zod":
|
|
addPattern(res, zodPatterns.email, check2.message, refs);
|
|
break;
|
|
}
|
|
break;
|
|
case "url":
|
|
addFormat(res, "uri", check2.message, refs);
|
|
break;
|
|
case "uuid":
|
|
addFormat(res, "uuid", check2.message, refs);
|
|
break;
|
|
case "regex":
|
|
addPattern(res, check2.regex, check2.message, refs);
|
|
break;
|
|
case "cuid":
|
|
addPattern(res, zodPatterns.cuid, check2.message, refs);
|
|
break;
|
|
case "cuid2":
|
|
addPattern(res, zodPatterns.cuid2, check2.message, refs);
|
|
break;
|
|
case "startsWith":
|
|
addPattern(res, RegExp(`^${escapeLiteralCheckValue(check2.value, refs)}`), check2.message, refs);
|
|
break;
|
|
case "endsWith":
|
|
addPattern(res, RegExp(`${escapeLiteralCheckValue(check2.value, refs)}$`), check2.message, refs);
|
|
break;
|
|
case "datetime":
|
|
addFormat(res, "date-time", check2.message, refs);
|
|
break;
|
|
case "date":
|
|
addFormat(res, "date", check2.message, refs);
|
|
break;
|
|
case "time":
|
|
addFormat(res, "time", check2.message, refs);
|
|
break;
|
|
case "duration":
|
|
addFormat(res, "duration", check2.message, refs);
|
|
break;
|
|
case "length":
|
|
setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check2.value) : check2.value, check2.message, refs);
|
|
setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check2.value) : check2.value, check2.message, refs);
|
|
break;
|
|
case "includes": {
|
|
addPattern(res, RegExp(escapeLiteralCheckValue(check2.value, refs)), check2.message, refs);
|
|
break;
|
|
}
|
|
case "ip": {
|
|
if (check2.version !== "v6") {
|
|
addFormat(res, "ipv4", check2.message, refs);
|
|
}
|
|
if (check2.version !== "v4") {
|
|
addFormat(res, "ipv6", check2.message, refs);
|
|
}
|
|
break;
|
|
}
|
|
case "base64url":
|
|
addPattern(res, zodPatterns.base64url, check2.message, refs);
|
|
break;
|
|
case "jwt":
|
|
addPattern(res, zodPatterns.jwt, check2.message, refs);
|
|
break;
|
|
case "cidr": {
|
|
if (check2.version !== "v6") {
|
|
addPattern(res, zodPatterns.ipv4Cidr, check2.message, refs);
|
|
}
|
|
if (check2.version !== "v4") {
|
|
addPattern(res, zodPatterns.ipv6Cidr, check2.message, refs);
|
|
}
|
|
break;
|
|
}
|
|
case "emoji":
|
|
addPattern(res, zodPatterns.emoji(), check2.message, refs);
|
|
break;
|
|
case "ulid": {
|
|
addPattern(res, zodPatterns.ulid, check2.message, refs);
|
|
break;
|
|
}
|
|
case "base64": {
|
|
switch (refs.base64Strategy) {
|
|
case "format:binary": {
|
|
addFormat(res, "binary", check2.message, refs);
|
|
break;
|
|
}
|
|
case "contentEncoding:base64": {
|
|
setResponseValueAndErrors(res, "contentEncoding", "base64", check2.message, refs);
|
|
break;
|
|
}
|
|
case "pattern:zod": {
|
|
addPattern(res, zodPatterns.base64, check2.message, refs);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case "nanoid": {
|
|
addPattern(res, zodPatterns.nanoid, check2.message, refs);
|
|
}
|
|
case "toLowerCase":
|
|
case "toUpperCase":
|
|
case "trim":
|
|
break;
|
|
default:
|
|
((_) => {})(check2);
|
|
}
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
function escapeLiteralCheckValue(literal2, refs) {
|
|
return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal2) : literal2;
|
|
}
|
|
var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
|
|
function escapeNonAlphaNumeric(source) {
|
|
let result = "";
|
|
for (let i = 0;i < source.length; i++) {
|
|
if (!ALPHA_NUMERIC.has(source[i])) {
|
|
result += "\\";
|
|
}
|
|
result += source[i];
|
|
}
|
|
return result;
|
|
}
|
|
function addFormat(schema, value, message, refs) {
|
|
if (schema.format || schema.anyOf?.some((x) => x.format)) {
|
|
if (!schema.anyOf) {
|
|
schema.anyOf = [];
|
|
}
|
|
if (schema.format) {
|
|
schema.anyOf.push({
|
|
format: schema.format,
|
|
...schema.errorMessage && refs.errorMessages && {
|
|
errorMessage: { format: schema.errorMessage.format }
|
|
}
|
|
});
|
|
delete schema.format;
|
|
if (schema.errorMessage) {
|
|
delete schema.errorMessage.format;
|
|
if (Object.keys(schema.errorMessage).length === 0) {
|
|
delete schema.errorMessage;
|
|
}
|
|
}
|
|
}
|
|
schema.anyOf.push({
|
|
format: value,
|
|
...message && refs.errorMessages && { errorMessage: { format: message } }
|
|
});
|
|
} else {
|
|
setResponseValueAndErrors(schema, "format", value, message, refs);
|
|
}
|
|
}
|
|
function addPattern(schema, regex, message, refs) {
|
|
if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
|
|
if (!schema.allOf) {
|
|
schema.allOf = [];
|
|
}
|
|
if (schema.pattern) {
|
|
schema.allOf.push({
|
|
pattern: schema.pattern,
|
|
...schema.errorMessage && refs.errorMessages && {
|
|
errorMessage: { pattern: schema.errorMessage.pattern }
|
|
}
|
|
});
|
|
delete schema.pattern;
|
|
if (schema.errorMessage) {
|
|
delete schema.errorMessage.pattern;
|
|
if (Object.keys(schema.errorMessage).length === 0) {
|
|
delete schema.errorMessage;
|
|
}
|
|
}
|
|
}
|
|
schema.allOf.push({
|
|
pattern: stringifyRegExpWithFlags(regex, refs),
|
|
...message && refs.errorMessages && { errorMessage: { pattern: message } }
|
|
});
|
|
} else {
|
|
setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
|
|
}
|
|
}
|
|
function stringifyRegExpWithFlags(regex, refs) {
|
|
if (!refs.applyRegexFlags || !regex.flags) {
|
|
return regex.source;
|
|
}
|
|
const flags = {
|
|
i: regex.flags.includes("i"),
|
|
m: regex.flags.includes("m"),
|
|
s: regex.flags.includes("s")
|
|
};
|
|
const source = flags.i ? regex.source.toLowerCase() : regex.source;
|
|
let pattern = "";
|
|
let isEscaped = false;
|
|
let inCharGroup = false;
|
|
let inCharRange = false;
|
|
for (let i = 0;i < source.length; i++) {
|
|
if (isEscaped) {
|
|
pattern += source[i];
|
|
isEscaped = false;
|
|
continue;
|
|
}
|
|
if (flags.i) {
|
|
if (inCharGroup) {
|
|
if (source[i].match(/[a-z]/)) {
|
|
if (inCharRange) {
|
|
pattern += source[i];
|
|
pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
|
|
inCharRange = false;
|
|
} else if (source[i + 1] === "-" && source[i + 2]?.match(/[a-z]/)) {
|
|
pattern += source[i];
|
|
inCharRange = true;
|
|
} else {
|
|
pattern += `${source[i]}${source[i].toUpperCase()}`;
|
|
}
|
|
continue;
|
|
}
|
|
} else if (source[i].match(/[a-z]/)) {
|
|
pattern += `[${source[i]}${source[i].toUpperCase()}]`;
|
|
continue;
|
|
}
|
|
}
|
|
if (flags.m) {
|
|
if (source[i] === "^") {
|
|
pattern += `(^|(?<=[\r
|
|
]))`;
|
|
continue;
|
|
} else if (source[i] === "$") {
|
|
pattern += `($|(?=[\r
|
|
]))`;
|
|
continue;
|
|
}
|
|
}
|
|
if (flags.s && source[i] === ".") {
|
|
pattern += inCharGroup ? `${source[i]}\r
|
|
` : `[${source[i]}\r
|
|
]`;
|
|
continue;
|
|
}
|
|
pattern += source[i];
|
|
if (source[i] === "\\") {
|
|
isEscaped = true;
|
|
} else if (inCharGroup && source[i] === "]") {
|
|
inCharGroup = false;
|
|
} else if (!inCharGroup && source[i] === "[") {
|
|
inCharGroup = true;
|
|
}
|
|
}
|
|
try {
|
|
new RegExp(pattern);
|
|
} catch {
|
|
console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`);
|
|
return regex.source;
|
|
}
|
|
return pattern;
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/record.js
|
|
function parseRecordDef(def, refs) {
|
|
if (refs.target === "openAi") {
|
|
console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
|
|
}
|
|
if (refs.target === "openApi3" && def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
|
|
return {
|
|
type: "object",
|
|
required: def.keyType._def.values,
|
|
properties: def.keyType._def.values.reduce((acc, key) => ({
|
|
...acc,
|
|
[key]: parseDef(def.valueType._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "properties", key]
|
|
}) ?? parseAnyDef(refs)
|
|
}), {}),
|
|
additionalProperties: refs.rejectedAdditionalProperties
|
|
};
|
|
}
|
|
const schema = {
|
|
type: "object",
|
|
additionalProperties: parseDef(def.valueType._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "additionalProperties"]
|
|
}) ?? refs.allowedAdditionalProperties
|
|
};
|
|
if (refs.target === "openApi3") {
|
|
return schema;
|
|
}
|
|
if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
|
|
const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
|
|
return {
|
|
...schema,
|
|
propertyNames: keyType
|
|
};
|
|
} else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
|
|
return {
|
|
...schema,
|
|
propertyNames: {
|
|
enum: def.keyType._def.values
|
|
}
|
|
};
|
|
} else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
|
|
const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);
|
|
return {
|
|
...schema,
|
|
propertyNames: keyType
|
|
};
|
|
}
|
|
return schema;
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/map.js
|
|
function parseMapDef(def, refs) {
|
|
if (refs.mapStrategy === "record") {
|
|
return parseRecordDef(def, refs);
|
|
}
|
|
const keys = parseDef(def.keyType._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "items", "items", "0"]
|
|
}) || parseAnyDef(refs);
|
|
const values = parseDef(def.valueType._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "items", "items", "1"]
|
|
}) || parseAnyDef(refs);
|
|
return {
|
|
type: "array",
|
|
maxItems: 125,
|
|
items: {
|
|
type: "array",
|
|
items: [keys, values],
|
|
minItems: 2,
|
|
maxItems: 2
|
|
}
|
|
};
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
|
|
function parseNativeEnumDef(def) {
|
|
const object3 = def.values;
|
|
const actualKeys = Object.keys(def.values).filter((key) => {
|
|
return typeof object3[object3[key]] !== "number";
|
|
});
|
|
const actualValues = actualKeys.map((key) => object3[key]);
|
|
const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
|
|
return {
|
|
type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
|
|
enum: actualValues
|
|
};
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/never.js
|
|
function parseNeverDef(refs) {
|
|
return refs.target === "openAi" ? undefined : {
|
|
not: parseAnyDef({
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "not"]
|
|
})
|
|
};
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/null.js
|
|
function parseNullDef(refs) {
|
|
return refs.target === "openApi3" ? {
|
|
enum: ["null"],
|
|
nullable: true
|
|
} : {
|
|
type: "null"
|
|
};
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/union.js
|
|
var primitiveMappings = {
|
|
ZodString: "string",
|
|
ZodNumber: "number",
|
|
ZodBigInt: "integer",
|
|
ZodBoolean: "boolean",
|
|
ZodNull: "null"
|
|
};
|
|
function parseUnionDef(def, refs) {
|
|
if (refs.target === "openApi3")
|
|
return asAnyOf(def, refs);
|
|
const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
|
|
if (options.every((x) => (x._def.typeName in primitiveMappings) && (!x._def.checks || !x._def.checks.length))) {
|
|
const types = options.reduce((types2, x) => {
|
|
const type = primitiveMappings[x._def.typeName];
|
|
return type && !types2.includes(type) ? [...types2, type] : types2;
|
|
}, []);
|
|
return {
|
|
type: types.length > 1 ? types : types[0]
|
|
};
|
|
} else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
|
|
const types = options.reduce((acc, x) => {
|
|
const type = typeof x._def.value;
|
|
switch (type) {
|
|
case "string":
|
|
case "number":
|
|
case "boolean":
|
|
return [...acc, type];
|
|
case "bigint":
|
|
return [...acc, "integer"];
|
|
case "object":
|
|
if (x._def.value === null)
|
|
return [...acc, "null"];
|
|
case "symbol":
|
|
case "undefined":
|
|
case "function":
|
|
default:
|
|
return acc;
|
|
}
|
|
}, []);
|
|
if (types.length === options.length) {
|
|
const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
|
|
return {
|
|
type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
|
|
enum: options.reduce((acc, x) => {
|
|
return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
|
|
}, [])
|
|
};
|
|
}
|
|
} else if (options.every((x) => x._def.typeName === "ZodEnum")) {
|
|
return {
|
|
type: "string",
|
|
enum: options.reduce((acc, x) => [
|
|
...acc,
|
|
...x._def.values.filter((x2) => !acc.includes(x2))
|
|
], [])
|
|
};
|
|
}
|
|
return asAnyOf(def, refs);
|
|
}
|
|
var asAnyOf = (def, refs) => {
|
|
const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef(x._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "anyOf", `${i}`]
|
|
})).filter((x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0));
|
|
return anyOf.length ? { anyOf } : undefined;
|
|
};
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js
|
|
function parseNullableDef(def, refs) {
|
|
if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
|
|
if (refs.target === "openApi3") {
|
|
return {
|
|
type: primitiveMappings[def.innerType._def.typeName],
|
|
nullable: true
|
|
};
|
|
}
|
|
return {
|
|
type: [
|
|
primitiveMappings[def.innerType._def.typeName],
|
|
"null"
|
|
]
|
|
};
|
|
}
|
|
if (refs.target === "openApi3") {
|
|
const base2 = parseDef(def.innerType._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath]
|
|
});
|
|
if (base2 && "$ref" in base2)
|
|
return { allOf: [base2], nullable: true };
|
|
return base2 && { ...base2, nullable: true };
|
|
}
|
|
const base = parseDef(def.innerType._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "anyOf", "0"]
|
|
});
|
|
return base && { anyOf: [base, { type: "null" }] };
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/number.js
|
|
function parseNumberDef(def, refs) {
|
|
const res = {
|
|
type: "number"
|
|
};
|
|
if (!def.checks)
|
|
return res;
|
|
for (const check2 of def.checks) {
|
|
switch (check2.kind) {
|
|
case "int":
|
|
res.type = "integer";
|
|
addErrorMessage(res, "type", check2.message, refs);
|
|
break;
|
|
case "min":
|
|
if (refs.target === "jsonSchema7") {
|
|
if (check2.inclusive) {
|
|
setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
|
|
} else {
|
|
setResponseValueAndErrors(res, "exclusiveMinimum", check2.value, check2.message, refs);
|
|
}
|
|
} else {
|
|
if (!check2.inclusive) {
|
|
res.exclusiveMinimum = true;
|
|
}
|
|
setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
|
|
}
|
|
break;
|
|
case "max":
|
|
if (refs.target === "jsonSchema7") {
|
|
if (check2.inclusive) {
|
|
setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
|
|
} else {
|
|
setResponseValueAndErrors(res, "exclusiveMaximum", check2.value, check2.message, refs);
|
|
}
|
|
} else {
|
|
if (!check2.inclusive) {
|
|
res.exclusiveMaximum = true;
|
|
}
|
|
setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
|
|
}
|
|
break;
|
|
case "multipleOf":
|
|
setResponseValueAndErrors(res, "multipleOf", check2.value, check2.message, refs);
|
|
break;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/object.js
|
|
function parseObjectDef(def, refs) {
|
|
const forceOptionalIntoNullable = refs.target === "openAi";
|
|
const result = {
|
|
type: "object",
|
|
properties: {}
|
|
};
|
|
const required2 = [];
|
|
const shape = def.shape();
|
|
for (const propName in shape) {
|
|
let propDef = shape[propName];
|
|
if (propDef === undefined || propDef._def === undefined) {
|
|
continue;
|
|
}
|
|
let propOptional = safeIsOptional(propDef);
|
|
if (propOptional && forceOptionalIntoNullable) {
|
|
if (propDef._def.typeName === "ZodOptional") {
|
|
propDef = propDef._def.innerType;
|
|
}
|
|
if (!propDef.isNullable()) {
|
|
propDef = propDef.nullable();
|
|
}
|
|
propOptional = false;
|
|
}
|
|
const parsedDef = parseDef(propDef._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "properties", propName],
|
|
propertyPath: [...refs.currentPath, "properties", propName]
|
|
});
|
|
if (parsedDef === undefined) {
|
|
continue;
|
|
}
|
|
result.properties[propName] = parsedDef;
|
|
if (!propOptional) {
|
|
required2.push(propName);
|
|
}
|
|
}
|
|
if (required2.length) {
|
|
result.required = required2;
|
|
}
|
|
const additionalProperties = decideAdditionalProperties(def, refs);
|
|
if (additionalProperties !== undefined) {
|
|
result.additionalProperties = additionalProperties;
|
|
}
|
|
return result;
|
|
}
|
|
function decideAdditionalProperties(def, refs) {
|
|
if (def.catchall._def.typeName !== "ZodNever") {
|
|
return parseDef(def.catchall._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "additionalProperties"]
|
|
});
|
|
}
|
|
switch (def.unknownKeys) {
|
|
case "passthrough":
|
|
return refs.allowedAdditionalProperties;
|
|
case "strict":
|
|
return refs.rejectedAdditionalProperties;
|
|
case "strip":
|
|
return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
|
|
}
|
|
}
|
|
function safeIsOptional(schema) {
|
|
try {
|
|
return schema.isOptional();
|
|
} catch {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
|
|
var parseOptionalDef = (def, refs) => {
|
|
if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
|
|
return parseDef(def.innerType._def, refs);
|
|
}
|
|
const innerSchema = parseDef(def.innerType._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "anyOf", "1"]
|
|
});
|
|
return innerSchema ? {
|
|
anyOf: [
|
|
{
|
|
not: parseAnyDef(refs)
|
|
},
|
|
innerSchema
|
|
]
|
|
} : parseAnyDef(refs);
|
|
};
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js
|
|
var parsePipelineDef = (def, refs) => {
|
|
if (refs.pipeStrategy === "input") {
|
|
return parseDef(def.in._def, refs);
|
|
} else if (refs.pipeStrategy === "output") {
|
|
return parseDef(def.out._def, refs);
|
|
}
|
|
const a = parseDef(def.in._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "allOf", "0"]
|
|
});
|
|
const b = parseDef(def.out._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
|
|
});
|
|
return {
|
|
allOf: [a, b].filter((x) => x !== undefined)
|
|
};
|
|
};
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/promise.js
|
|
function parsePromiseDef(def, refs) {
|
|
return parseDef(def.type._def, refs);
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/set.js
|
|
function parseSetDef(def, refs) {
|
|
const items = parseDef(def.valueType._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "items"]
|
|
});
|
|
const schema = {
|
|
type: "array",
|
|
uniqueItems: true,
|
|
items
|
|
};
|
|
if (def.minSize) {
|
|
setResponseValueAndErrors(schema, "minItems", def.minSize.value, def.minSize.message, refs);
|
|
}
|
|
if (def.maxSize) {
|
|
setResponseValueAndErrors(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
|
|
}
|
|
return schema;
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js
|
|
function parseTupleDef(def, refs) {
|
|
if (def.rest) {
|
|
return {
|
|
type: "array",
|
|
minItems: def.items.length,
|
|
items: def.items.map((x, i) => parseDef(x._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "items", `${i}`]
|
|
})).reduce((acc, x) => x === undefined ? acc : [...acc, x], []),
|
|
additionalItems: parseDef(def.rest._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "additionalItems"]
|
|
})
|
|
};
|
|
} else {
|
|
return {
|
|
type: "array",
|
|
minItems: def.items.length,
|
|
maxItems: def.items.length,
|
|
items: def.items.map((x, i) => parseDef(x._def, {
|
|
...refs,
|
|
currentPath: [...refs.currentPath, "items", `${i}`]
|
|
})).reduce((acc, x) => x === undefined ? acc : [...acc, x], [])
|
|
};
|
|
}
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
|
|
function parseUndefinedDef(refs) {
|
|
return {
|
|
not: parseAnyDef(refs)
|
|
};
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
|
|
function parseUnknownDef(refs) {
|
|
return parseAnyDef(refs);
|
|
}
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js
|
|
var parseReadonlyDef = (def, refs) => {
|
|
return parseDef(def.innerType._def, refs);
|
|
};
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/selectParser.js
|
|
var selectParser = (def, typeName, refs) => {
|
|
switch (typeName) {
|
|
case ZodFirstPartyTypeKind.ZodString:
|
|
return parseStringDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodNumber:
|
|
return parseNumberDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodObject:
|
|
return parseObjectDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodBigInt:
|
|
return parseBigintDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodBoolean:
|
|
return parseBooleanDef();
|
|
case ZodFirstPartyTypeKind.ZodDate:
|
|
return parseDateDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodUndefined:
|
|
return parseUndefinedDef(refs);
|
|
case ZodFirstPartyTypeKind.ZodNull:
|
|
return parseNullDef(refs);
|
|
case ZodFirstPartyTypeKind.ZodArray:
|
|
return parseArrayDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodUnion:
|
|
case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
|
|
return parseUnionDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodIntersection:
|
|
return parseIntersectionDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodTuple:
|
|
return parseTupleDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodRecord:
|
|
return parseRecordDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodLiteral:
|
|
return parseLiteralDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodEnum:
|
|
return parseEnumDef(def);
|
|
case ZodFirstPartyTypeKind.ZodNativeEnum:
|
|
return parseNativeEnumDef(def);
|
|
case ZodFirstPartyTypeKind.ZodNullable:
|
|
return parseNullableDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodOptional:
|
|
return parseOptionalDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodMap:
|
|
return parseMapDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodSet:
|
|
return parseSetDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodLazy:
|
|
return () => def.getter()._def;
|
|
case ZodFirstPartyTypeKind.ZodPromise:
|
|
return parsePromiseDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodNaN:
|
|
case ZodFirstPartyTypeKind.ZodNever:
|
|
return parseNeverDef(refs);
|
|
case ZodFirstPartyTypeKind.ZodEffects:
|
|
return parseEffectsDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodAny:
|
|
return parseAnyDef(refs);
|
|
case ZodFirstPartyTypeKind.ZodUnknown:
|
|
return parseUnknownDef(refs);
|
|
case ZodFirstPartyTypeKind.ZodDefault:
|
|
return parseDefaultDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodBranded:
|
|
return parseBrandedDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodReadonly:
|
|
return parseReadonlyDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodCatch:
|
|
return parseCatchDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodPipeline:
|
|
return parsePipelineDef(def, refs);
|
|
case ZodFirstPartyTypeKind.ZodFunction:
|
|
case ZodFirstPartyTypeKind.ZodVoid:
|
|
case ZodFirstPartyTypeKind.ZodSymbol:
|
|
return;
|
|
default:
|
|
return ((_) => {
|
|
return;
|
|
})(typeName);
|
|
}
|
|
};
|
|
|
|
// ../node_modules/zod-to-json-schema/dist/esm/parseDef.js
|
|
function parseDef(def, refs, forceResolution = false) {
|
|
const seenItem = refs.seen.get(def);
|
|
if (refs.override) {
|
|
const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
|
|
if (overrideResult !== ignoreOverride) {
|
|
return overrideResult;
|
|
}
|
|
}
|
|
if (seenItem && !forceResolution) {
|
|
const seenSchema = get$ref(seenItem, refs);
|
|
if (seenSchema !== undefined) {
|
|
return seenSchema;
|
|
}
|
|
}
|
|
const newItem = { def, path: refs.currentPath, jsonSchema: undefined };
|
|
refs.seen.set(def, newItem);
|
|
const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
|
|
const jsonSchema = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
|
|
if (jsonSchema) {
|
|
addMeta(def, refs, jsonSchema);
|
|
}
|
|
if (refs.postProcess) {
|
|
const postProcessResult = refs.postProcess(jsonSchema, def, refs);
|
|
newItem.jsonSchema = jsonSchema;
|
|
return postProcessResult;
|
|
}
|
|
newItem.jsonSchema = jsonSchema;
|
|
return jsonSchema;
|
|
}
|
|
var get$ref = (item, refs) => {
|
|
switch (refs.$refStrategy) {
|
|
case "root":
|
|
return { $ref: item.path.join("/") };
|
|
case "relative":
|
|
return { $ref: getRelativePath(refs.currentPath, item.path) };
|
|
case "none":
|
|
case "seen": {
|
|
if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
|
|
console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
|
|
return parseAnyDef(refs);
|
|
}
|
|
return refs.$refStrategy === "seen" ? parseAnyDef(refs) : undefined;
|
|
}
|
|
}
|
|
};
|
|
var addMeta = (def, refs, jsonSchema) => {
|
|
if (def.description) {
|
|
jsonSchema.description = def.description;
|
|
if (refs.markdownDescription) {
|
|
jsonSchema.markdownDescription = def.description;
|
|
}
|
|
}
|
|
return jsonSchema;
|
|
};
|
|
// ../node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
|
|
var zodToJsonSchema = (schema, options) => {
|
|
const refs = getRefs(options);
|
|
let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name2, schema2]) => ({
|
|
...acc,
|
|
[name2]: parseDef(schema2._def, {
|
|
...refs,
|
|
currentPath: [...refs.basePath, refs.definitionPath, name2]
|
|
}, true) ?? parseAnyDef(refs)
|
|
}), {}) : undefined;
|
|
const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? undefined : options?.name;
|
|
const main = parseDef(schema._def, name === undefined ? refs : {
|
|
...refs,
|
|
currentPath: [...refs.basePath, refs.definitionPath, name]
|
|
}, false) ?? parseAnyDef(refs);
|
|
const title = typeof options === "object" && options.name !== undefined && options.nameStrategy === "title" ? options.name : undefined;
|
|
if (title !== undefined) {
|
|
main.title = title;
|
|
}
|
|
if (refs.flags.hasReferencedOpenAiAnyType) {
|
|
if (!definitions) {
|
|
definitions = {};
|
|
}
|
|
if (!definitions[refs.openAiAnyTypeName]) {
|
|
definitions[refs.openAiAnyTypeName] = {
|
|
type: ["string", "number", "integer", "boolean", "array", "null"],
|
|
items: {
|
|
$ref: refs.$refStrategy === "relative" ? "1" : [
|
|
...refs.basePath,
|
|
refs.definitionPath,
|
|
refs.openAiAnyTypeName
|
|
].join("/")
|
|
}
|
|
};
|
|
}
|
|
}
|
|
const combined = name === undefined ? definitions ? {
|
|
...main,
|
|
[refs.definitionPath]: definitions
|
|
} : main : {
|
|
$ref: [
|
|
...refs.$refStrategy === "relative" ? [] : refs.basePath,
|
|
refs.definitionPath,
|
|
name
|
|
].join("/"),
|
|
[refs.definitionPath]: {
|
|
...definitions,
|
|
[name]: main
|
|
}
|
|
};
|
|
if (refs.target === "jsonSchema7") {
|
|
combined.$schema = "http://json-schema.org/draft-07/schema#";
|
|
} else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
|
|
combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
|
|
}
|
|
if (refs.target === "openAi" && (("anyOf" in combined) || ("oneOf" in combined) || ("allOf" in combined) || ("type" in combined) && Array.isArray(combined.type))) {
|
|
console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
|
|
}
|
|
return combined;
|
|
};
|
|
// ../node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js
|
|
function mapMiniTarget(t) {
|
|
if (!t)
|
|
return "draft-7";
|
|
if (t === "jsonSchema7" || t === "draft-7")
|
|
return "draft-7";
|
|
if (t === "jsonSchema2019-09" || t === "draft-2020-12")
|
|
return "draft-2020-12";
|
|
return "draft-7";
|
|
}
|
|
function toJsonSchemaCompat(schema, opts) {
|
|
var _a, _b, _c;
|
|
if (isZ4Schema(schema)) {
|
|
return toJSONSchema(schema, {
|
|
target: mapMiniTarget(opts === null || opts === undefined ? undefined : opts.target),
|
|
io: (_a = opts === null || opts === undefined ? undefined : opts.pipeStrategy) !== null && _a !== undefined ? _a : "input"
|
|
});
|
|
}
|
|
return zodToJsonSchema(schema, {
|
|
strictUnions: (_b = opts === null || opts === undefined ? undefined : opts.strictUnions) !== null && _b !== undefined ? _b : true,
|
|
pipeStrategy: (_c = opts === null || opts === undefined ? undefined : opts.pipeStrategy) !== null && _c !== undefined ? _c : "input"
|
|
});
|
|
}
|
|
function getMethodLiteral(schema) {
|
|
const shape = getObjectShape(schema);
|
|
const methodSchema = shape === null || shape === undefined ? undefined : shape.method;
|
|
if (!methodSchema) {
|
|
throw new Error("Schema is missing a method literal");
|
|
}
|
|
const value = getLiteralValue(methodSchema);
|
|
if (typeof value !== "string") {
|
|
throw new Error("Schema method literal must be a string");
|
|
}
|
|
return value;
|
|
}
|
|
function parseWithCompat(schema, data) {
|
|
const result = safeParse2(schema, data);
|
|
if (!result.success) {
|
|
throw result.error;
|
|
}
|
|
return result.data;
|
|
}
|
|
|
|
// ../node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js
|
|
var DEFAULT_REQUEST_TIMEOUT_MSEC = 60000;
|
|
|
|
class Protocol {
|
|
constructor(_options) {
|
|
this._options = _options;
|
|
this._requestMessageId = 0;
|
|
this._requestHandlers = new Map;
|
|
this._requestHandlerAbortControllers = new Map;
|
|
this._notificationHandlers = new Map;
|
|
this._responseHandlers = new Map;
|
|
this._progressHandlers = new Map;
|
|
this._timeoutInfo = new Map;
|
|
this._pendingDebouncedNotifications = new Set;
|
|
this._taskProgressTokens = new Map;
|
|
this._requestResolvers = new Map;
|
|
this.setNotificationHandler(CancelledNotificationSchema, (notification) => {
|
|
this._oncancel(notification);
|
|
});
|
|
this.setNotificationHandler(ProgressNotificationSchema, (notification) => {
|
|
this._onprogress(notification);
|
|
});
|
|
this.setRequestHandler(PingRequestSchema, (_request) => ({}));
|
|
this._taskStore = _options === null || _options === undefined ? undefined : _options.taskStore;
|
|
this._taskMessageQueue = _options === null || _options === undefined ? undefined : _options.taskMessageQueue;
|
|
if (this._taskStore) {
|
|
this.setRequestHandler(GetTaskRequestSchema, async (request, extra) => {
|
|
const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
|
|
if (!task) {
|
|
throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
|
|
}
|
|
return {
|
|
...task
|
|
};
|
|
});
|
|
this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => {
|
|
const handleTaskResult = async () => {
|
|
var _a;
|
|
const taskId = request.params.taskId;
|
|
if (this._taskMessageQueue) {
|
|
let queuedMessage;
|
|
while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) {
|
|
if (queuedMessage.type === "response" || queuedMessage.type === "error") {
|
|
const message = queuedMessage.message;
|
|
const requestId = message.id;
|
|
const resolver = this._requestResolvers.get(requestId);
|
|
if (resolver) {
|
|
this._requestResolvers.delete(requestId);
|
|
if (queuedMessage.type === "response") {
|
|
resolver(message);
|
|
} else {
|
|
const errorMessage = message;
|
|
const error2 = new McpError(errorMessage.error.code, errorMessage.error.message, errorMessage.error.data);
|
|
resolver(error2);
|
|
}
|
|
} else {
|
|
const messageType = queuedMessage.type === "response" ? "Response" : "Error";
|
|
this._onerror(new Error(`${messageType} handler missing for request ${requestId}`));
|
|
}
|
|
continue;
|
|
}
|
|
await ((_a = this._transport) === null || _a === undefined ? undefined : _a.send(queuedMessage.message, { relatedRequestId: extra.requestId }));
|
|
}
|
|
}
|
|
const task = await this._taskStore.getTask(taskId, extra.sessionId);
|
|
if (!task) {
|
|
throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
|
|
}
|
|
if (!isTerminal(task.status)) {
|
|
await this._waitForTaskUpdate(taskId, extra.signal);
|
|
return await handleTaskResult();
|
|
}
|
|
if (isTerminal(task.status)) {
|
|
const result = await this._taskStore.getTaskResult(taskId, extra.sessionId);
|
|
this._clearTaskQueue(taskId);
|
|
return {
|
|
...result,
|
|
_meta: {
|
|
...result._meta,
|
|
[RELATED_TASK_META_KEY]: {
|
|
taskId
|
|
}
|
|
}
|
|
};
|
|
}
|
|
return await handleTaskResult();
|
|
};
|
|
return await handleTaskResult();
|
|
});
|
|
this.setRequestHandler(ListTasksRequestSchema, async (request, extra) => {
|
|
var _a;
|
|
try {
|
|
const { tasks, nextCursor } = await this._taskStore.listTasks((_a = request.params) === null || _a === undefined ? undefined : _a.cursor, extra.sessionId);
|
|
return {
|
|
tasks,
|
|
nextCursor,
|
|
_meta: {}
|
|
};
|
|
} catch (error2) {
|
|
throw new McpError(ErrorCode.InvalidParams, `Failed to list tasks: ${error2 instanceof Error ? error2.message : String(error2)}`);
|
|
}
|
|
});
|
|
this.setRequestHandler(CancelTaskRequestSchema, async (request, extra) => {
|
|
try {
|
|
const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
|
|
if (!task) {
|
|
throw new McpError(ErrorCode.InvalidParams, `Task not found: ${request.params.taskId}`);
|
|
}
|
|
if (isTerminal(task.status)) {
|
|
throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
|
|
}
|
|
await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
|
|
this._clearTaskQueue(request.params.taskId);
|
|
const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
|
|
if (!cancelledTask) {
|
|
throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
|
|
}
|
|
return {
|
|
_meta: {},
|
|
...cancelledTask
|
|
};
|
|
} catch (error2) {
|
|
if (error2 instanceof McpError) {
|
|
throw error2;
|
|
}
|
|
throw new McpError(ErrorCode.InvalidRequest, `Failed to cancel task: ${error2 instanceof Error ? error2.message : String(error2)}`);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
async _oncancel(notification) {
|
|
const controller = this._requestHandlerAbortControllers.get(notification.params.requestId);
|
|
controller === null || controller === undefined || controller.abort(notification.params.reason);
|
|
}
|
|
_setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) {
|
|
this._timeoutInfo.set(messageId, {
|
|
timeoutId: setTimeout(onTimeout, timeout),
|
|
startTime: Date.now(),
|
|
timeout,
|
|
maxTotalTimeout,
|
|
resetTimeoutOnProgress,
|
|
onTimeout
|
|
});
|
|
}
|
|
_resetTimeout(messageId) {
|
|
const info = this._timeoutInfo.get(messageId);
|
|
if (!info)
|
|
return false;
|
|
const totalElapsed = Date.now() - info.startTime;
|
|
if (info.maxTotalTimeout && totalElapsed >= info.maxTotalTimeout) {
|
|
this._timeoutInfo.delete(messageId);
|
|
throw McpError.fromError(ErrorCode.RequestTimeout, "Maximum total timeout exceeded", {
|
|
maxTotalTimeout: info.maxTotalTimeout,
|
|
totalElapsed
|
|
});
|
|
}
|
|
clearTimeout(info.timeoutId);
|
|
info.timeoutId = setTimeout(info.onTimeout, info.timeout);
|
|
return true;
|
|
}
|
|
_cleanupTimeout(messageId) {
|
|
const info = this._timeoutInfo.get(messageId);
|
|
if (info) {
|
|
clearTimeout(info.timeoutId);
|
|
this._timeoutInfo.delete(messageId);
|
|
}
|
|
}
|
|
async connect(transport) {
|
|
var _a, _b, _c;
|
|
this._transport = transport;
|
|
const _onclose = (_a = this.transport) === null || _a === undefined ? undefined : _a.onclose;
|
|
this._transport.onclose = () => {
|
|
_onclose === null || _onclose === undefined || _onclose();
|
|
this._onclose();
|
|
};
|
|
const _onerror = (_b = this.transport) === null || _b === undefined ? undefined : _b.onerror;
|
|
this._transport.onerror = (error2) => {
|
|
_onerror === null || _onerror === undefined || _onerror(error2);
|
|
this._onerror(error2);
|
|
};
|
|
const _onmessage = (_c = this._transport) === null || _c === undefined ? undefined : _c.onmessage;
|
|
this._transport.onmessage = (message, extra) => {
|
|
_onmessage === null || _onmessage === undefined || _onmessage(message, extra);
|
|
if (isJSONRPCResponse(message) || isJSONRPCError(message)) {
|
|
this._onresponse(message);
|
|
} else if (isJSONRPCRequest(message)) {
|
|
this._onrequest(message, extra);
|
|
} else if (isJSONRPCNotification(message)) {
|
|
this._onnotification(message);
|
|
} else {
|
|
this._onerror(new Error(`Unknown message type: ${JSON.stringify(message)}`));
|
|
}
|
|
};
|
|
await this._transport.start();
|
|
}
|
|
_onclose() {
|
|
var _a;
|
|
const responseHandlers = this._responseHandlers;
|
|
this._responseHandlers = new Map;
|
|
this._progressHandlers.clear();
|
|
this._taskProgressTokens.clear();
|
|
this._pendingDebouncedNotifications.clear();
|
|
const error2 = McpError.fromError(ErrorCode.ConnectionClosed, "Connection closed");
|
|
this._transport = undefined;
|
|
(_a = this.onclose) === null || _a === undefined || _a.call(this);
|
|
for (const handler of responseHandlers.values()) {
|
|
handler(error2);
|
|
}
|
|
}
|
|
_onerror(error2) {
|
|
var _a;
|
|
(_a = this.onerror) === null || _a === undefined || _a.call(this, error2);
|
|
}
|
|
_onnotification(notification) {
|
|
var _a;
|
|
const handler = (_a = this._notificationHandlers.get(notification.method)) !== null && _a !== undefined ? _a : this.fallbackNotificationHandler;
|
|
if (handler === undefined) {
|
|
return;
|
|
}
|
|
Promise.resolve().then(() => handler(notification)).catch((error2) => this._onerror(new Error(`Uncaught error in notification handler: ${error2}`)));
|
|
}
|
|
_onrequest(request, extra) {
|
|
var _a, _b, _c, _d, _e, _f;
|
|
const handler = (_a = this._requestHandlers.get(request.method)) !== null && _a !== undefined ? _a : this.fallbackRequestHandler;
|
|
const capturedTransport = this._transport;
|
|
const relatedTaskId = (_d = (_c = (_b = request.params) === null || _b === undefined ? undefined : _b._meta) === null || _c === undefined ? undefined : _c[RELATED_TASK_META_KEY]) === null || _d === undefined ? undefined : _d.taskId;
|
|
if (handler === undefined) {
|
|
const errorResponse = {
|
|
jsonrpc: "2.0",
|
|
id: request.id,
|
|
error: {
|
|
code: ErrorCode.MethodNotFound,
|
|
message: "Method not found"
|
|
}
|
|
};
|
|
if (relatedTaskId && this._taskMessageQueue) {
|
|
this._enqueueTaskMessage(relatedTaskId, {
|
|
type: "error",
|
|
message: errorResponse,
|
|
timestamp: Date.now()
|
|
}, capturedTransport === null || capturedTransport === undefined ? undefined : capturedTransport.sessionId).catch((error2) => this._onerror(new Error(`Failed to enqueue error response: ${error2}`)));
|
|
} else {
|
|
capturedTransport === null || capturedTransport === undefined || capturedTransport.send(errorResponse).catch((error2) => this._onerror(new Error(`Failed to send an error response: ${error2}`)));
|
|
}
|
|
return;
|
|
}
|
|
const abortController = new AbortController;
|
|
this._requestHandlerAbortControllers.set(request.id, abortController);
|
|
const taskCreationParams = (_e = request.params) === null || _e === undefined ? undefined : _e.task;
|
|
const taskStore = this._taskStore ? this.requestTaskStore(request, capturedTransport === null || capturedTransport === undefined ? undefined : capturedTransport.sessionId) : undefined;
|
|
const fullExtra = {
|
|
signal: abortController.signal,
|
|
sessionId: capturedTransport === null || capturedTransport === undefined ? undefined : capturedTransport.sessionId,
|
|
_meta: (_f = request.params) === null || _f === undefined ? undefined : _f._meta,
|
|
sendNotification: async (notification) => {
|
|
const notificationOptions = { relatedRequestId: request.id };
|
|
if (relatedTaskId) {
|
|
notificationOptions.relatedTask = { taskId: relatedTaskId };
|
|
}
|
|
await this.notification(notification, notificationOptions);
|
|
},
|
|
sendRequest: async (r, resultSchema, options) => {
|
|
var _a2, _b2;
|
|
const requestOptions = { ...options, relatedRequestId: request.id };
|
|
if (relatedTaskId && !requestOptions.relatedTask) {
|
|
requestOptions.relatedTask = { taskId: relatedTaskId };
|
|
}
|
|
const effectiveTaskId = (_b2 = (_a2 = requestOptions.relatedTask) === null || _a2 === undefined ? undefined : _a2.taskId) !== null && _b2 !== undefined ? _b2 : relatedTaskId;
|
|
if (effectiveTaskId && taskStore) {
|
|
await taskStore.updateTaskStatus(effectiveTaskId, "input_required");
|
|
}
|
|
return await this.request(r, resultSchema, requestOptions);
|
|
},
|
|
authInfo: extra === null || extra === undefined ? undefined : extra.authInfo,
|
|
requestId: request.id,
|
|
requestInfo: extra === null || extra === undefined ? undefined : extra.requestInfo,
|
|
taskId: relatedTaskId,
|
|
taskStore,
|
|
taskRequestedTtl: taskCreationParams === null || taskCreationParams === undefined ? undefined : taskCreationParams.ttl,
|
|
closeSSEStream: extra === null || extra === undefined ? undefined : extra.closeSSEStream,
|
|
closeStandaloneSSEStream: extra === null || extra === undefined ? undefined : extra.closeStandaloneSSEStream
|
|
};
|
|
Promise.resolve().then(() => {
|
|
if (taskCreationParams) {
|
|
this.assertTaskHandlerCapability(request.method);
|
|
}
|
|
}).then(() => handler(request, fullExtra)).then(async (result) => {
|
|
if (abortController.signal.aborted) {
|
|
return;
|
|
}
|
|
const response = {
|
|
result,
|
|
jsonrpc: "2.0",
|
|
id: request.id
|
|
};
|
|
if (relatedTaskId && this._taskMessageQueue) {
|
|
await this._enqueueTaskMessage(relatedTaskId, {
|
|
type: "response",
|
|
message: response,
|
|
timestamp: Date.now()
|
|
}, capturedTransport === null || capturedTransport === undefined ? undefined : capturedTransport.sessionId);
|
|
} else {
|
|
await (capturedTransport === null || capturedTransport === undefined ? undefined : capturedTransport.send(response));
|
|
}
|
|
}, async (error2) => {
|
|
var _a2;
|
|
if (abortController.signal.aborted) {
|
|
return;
|
|
}
|
|
const errorResponse = {
|
|
jsonrpc: "2.0",
|
|
id: request.id,
|
|
error: {
|
|
code: Number.isSafeInteger(error2["code"]) ? error2["code"] : ErrorCode.InternalError,
|
|
message: (_a2 = error2.message) !== null && _a2 !== undefined ? _a2 : "Internal error",
|
|
...error2["data"] !== undefined && { data: error2["data"] }
|
|
}
|
|
};
|
|
if (relatedTaskId && this._taskMessageQueue) {
|
|
await this._enqueueTaskMessage(relatedTaskId, {
|
|
type: "error",
|
|
message: errorResponse,
|
|
timestamp: Date.now()
|
|
}, capturedTransport === null || capturedTransport === undefined ? undefined : capturedTransport.sessionId);
|
|
} else {
|
|
await (capturedTransport === null || capturedTransport === undefined ? undefined : capturedTransport.send(errorResponse));
|
|
}
|
|
}).catch((error2) => this._onerror(new Error(`Failed to send response: ${error2}`))).finally(() => {
|
|
this._requestHandlerAbortControllers.delete(request.id);
|
|
});
|
|
}
|
|
_onprogress(notification) {
|
|
const { progressToken, ...params } = notification.params;
|
|
const messageId = Number(progressToken);
|
|
const handler = this._progressHandlers.get(messageId);
|
|
if (!handler) {
|
|
this._onerror(new Error(`Received a progress notification for an unknown token: ${JSON.stringify(notification)}`));
|
|
return;
|
|
}
|
|
const responseHandler = this._responseHandlers.get(messageId);
|
|
const timeoutInfo = this._timeoutInfo.get(messageId);
|
|
if (timeoutInfo && responseHandler && timeoutInfo.resetTimeoutOnProgress) {
|
|
try {
|
|
this._resetTimeout(messageId);
|
|
} catch (error2) {
|
|
this._responseHandlers.delete(messageId);
|
|
this._progressHandlers.delete(messageId);
|
|
this._cleanupTimeout(messageId);
|
|
responseHandler(error2);
|
|
return;
|
|
}
|
|
}
|
|
handler(params);
|
|
}
|
|
_onresponse(response) {
|
|
const messageId = Number(response.id);
|
|
const resolver = this._requestResolvers.get(messageId);
|
|
if (resolver) {
|
|
this._requestResolvers.delete(messageId);
|
|
if (isJSONRPCResponse(response)) {
|
|
resolver(response);
|
|
} else {
|
|
const error2 = new McpError(response.error.code, response.error.message, response.error.data);
|
|
resolver(error2);
|
|
}
|
|
return;
|
|
}
|
|
const handler = this._responseHandlers.get(messageId);
|
|
if (handler === undefined) {
|
|
this._onerror(new Error(`Received a response for an unknown message ID: ${JSON.stringify(response)}`));
|
|
return;
|
|
}
|
|
this._responseHandlers.delete(messageId);
|
|
this._cleanupTimeout(messageId);
|
|
let isTaskResponse = false;
|
|
if (isJSONRPCResponse(response) && response.result && typeof response.result === "object") {
|
|
const result = response.result;
|
|
if (result.task && typeof result.task === "object") {
|
|
const task = result.task;
|
|
if (typeof task.taskId === "string") {
|
|
isTaskResponse = true;
|
|
this._taskProgressTokens.set(task.taskId, messageId);
|
|
}
|
|
}
|
|
}
|
|
if (!isTaskResponse) {
|
|
this._progressHandlers.delete(messageId);
|
|
}
|
|
if (isJSONRPCResponse(response)) {
|
|
handler(response);
|
|
} else {
|
|
const error2 = McpError.fromError(response.error.code, response.error.message, response.error.data);
|
|
handler(error2);
|
|
}
|
|
}
|
|
get transport() {
|
|
return this._transport;
|
|
}
|
|
async close() {
|
|
var _a;
|
|
await ((_a = this._transport) === null || _a === undefined ? undefined : _a.close());
|
|
}
|
|
async* requestStream(request, resultSchema, options) {
|
|
var _a, _b, _c, _d;
|
|
const { task } = options !== null && options !== undefined ? options : {};
|
|
if (!task) {
|
|
try {
|
|
const result = await this.request(request, resultSchema, options);
|
|
yield { type: "result", result };
|
|
} catch (error2) {
|
|
yield {
|
|
type: "error",
|
|
error: error2 instanceof McpError ? error2 : new McpError(ErrorCode.InternalError, String(error2))
|
|
};
|
|
}
|
|
return;
|
|
}
|
|
let taskId;
|
|
try {
|
|
const createResult = await this.request(request, CreateTaskResultSchema, options);
|
|
if (createResult.task) {
|
|
taskId = createResult.task.taskId;
|
|
yield { type: "taskCreated", task: createResult.task };
|
|
} else {
|
|
throw new McpError(ErrorCode.InternalError, "Task creation did not return a task");
|
|
}
|
|
while (true) {
|
|
const task2 = await this.getTask({ taskId }, options);
|
|
yield { type: "taskStatus", task: task2 };
|
|
if (isTerminal(task2.status)) {
|
|
if (task2.status === "completed") {
|
|
const result = await this.getTaskResult({ taskId }, resultSchema, options);
|
|
yield { type: "result", result };
|
|
} else if (task2.status === "failed") {
|
|
yield {
|
|
type: "error",
|
|
error: new McpError(ErrorCode.InternalError, `Task ${taskId} failed`)
|
|
};
|
|
} else if (task2.status === "cancelled") {
|
|
yield {
|
|
type: "error",
|
|
error: new McpError(ErrorCode.InternalError, `Task ${taskId} was cancelled`)
|
|
};
|
|
}
|
|
return;
|
|
}
|
|
if (task2.status === "input_required") {
|
|
const result = await this.getTaskResult({ taskId }, resultSchema, options);
|
|
yield { type: "result", result };
|
|
return;
|
|
}
|
|
const pollInterval = (_c = (_a = task2.pollInterval) !== null && _a !== undefined ? _a : (_b = this._options) === null || _b === undefined ? undefined : _b.defaultTaskPollInterval) !== null && _c !== undefined ? _c : 1000;
|
|
await new Promise((resolve) => setTimeout(resolve, pollInterval));
|
|
(_d = options === null || options === undefined ? undefined : options.signal) === null || _d === undefined || _d.throwIfAborted();
|
|
}
|
|
} catch (error2) {
|
|
yield {
|
|
type: "error",
|
|
error: error2 instanceof McpError ? error2 : new McpError(ErrorCode.InternalError, String(error2))
|
|
};
|
|
}
|
|
}
|
|
request(request, resultSchema, options) {
|
|
const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options !== null && options !== undefined ? options : {};
|
|
return new Promise((resolve, reject) => {
|
|
var _a, _b, _c, _d, _e, _f, _g;
|
|
const earlyReject = (error2) => {
|
|
reject(error2);
|
|
};
|
|
if (!this._transport) {
|
|
earlyReject(new Error("Not connected"));
|
|
return;
|
|
}
|
|
if (((_a = this._options) === null || _a === undefined ? undefined : _a.enforceStrictCapabilities) === true) {
|
|
try {
|
|
this.assertCapabilityForMethod(request.method);
|
|
if (task) {
|
|
this.assertTaskCapability(request.method);
|
|
}
|
|
} catch (e) {
|
|
earlyReject(e);
|
|
return;
|
|
}
|
|
}
|
|
(_b = options === null || options === undefined ? undefined : options.signal) === null || _b === undefined || _b.throwIfAborted();
|
|
const messageId = this._requestMessageId++;
|
|
const jsonrpcRequest = {
|
|
...request,
|
|
jsonrpc: "2.0",
|
|
id: messageId
|
|
};
|
|
if (options === null || options === undefined ? undefined : options.onprogress) {
|
|
this._progressHandlers.set(messageId, options.onprogress);
|
|
jsonrpcRequest.params = {
|
|
...request.params,
|
|
_meta: {
|
|
...((_c = request.params) === null || _c === undefined ? undefined : _c._meta) || {},
|
|
progressToken: messageId
|
|
}
|
|
};
|
|
}
|
|
if (task) {
|
|
jsonrpcRequest.params = {
|
|
...jsonrpcRequest.params,
|
|
task
|
|
};
|
|
}
|
|
if (relatedTask) {
|
|
jsonrpcRequest.params = {
|
|
...jsonrpcRequest.params,
|
|
_meta: {
|
|
...((_d = jsonrpcRequest.params) === null || _d === undefined ? undefined : _d._meta) || {},
|
|
[RELATED_TASK_META_KEY]: relatedTask
|
|
}
|
|
};
|
|
}
|
|
const cancel = (reason) => {
|
|
var _a2;
|
|
this._responseHandlers.delete(messageId);
|
|
this._progressHandlers.delete(messageId);
|
|
this._cleanupTimeout(messageId);
|
|
(_a2 = this._transport) === null || _a2 === undefined || _a2.send({
|
|
jsonrpc: "2.0",
|
|
method: "notifications/cancelled",
|
|
params: {
|
|
requestId: messageId,
|
|
reason: String(reason)
|
|
}
|
|
}, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error3) => this._onerror(new Error(`Failed to send cancellation: ${error3}`)));
|
|
const error2 = reason instanceof McpError ? reason : new McpError(ErrorCode.RequestTimeout, String(reason));
|
|
reject(error2);
|
|
};
|
|
this._responseHandlers.set(messageId, (response) => {
|
|
var _a2;
|
|
if ((_a2 = options === null || options === undefined ? undefined : options.signal) === null || _a2 === undefined ? undefined : _a2.aborted) {
|
|
return;
|
|
}
|
|
if (response instanceof Error) {
|
|
return reject(response);
|
|
}
|
|
try {
|
|
const parseResult = safeParse2(resultSchema, response.result);
|
|
if (!parseResult.success) {
|
|
reject(parseResult.error);
|
|
} else {
|
|
resolve(parseResult.data);
|
|
}
|
|
} catch (error2) {
|
|
reject(error2);
|
|
}
|
|
});
|
|
(_e = options === null || options === undefined ? undefined : options.signal) === null || _e === undefined || _e.addEventListener("abort", () => {
|
|
var _a2;
|
|
cancel((_a2 = options === null || options === undefined ? undefined : options.signal) === null || _a2 === undefined ? undefined : _a2.reason);
|
|
});
|
|
const timeout = (_f = options === null || options === undefined ? undefined : options.timeout) !== null && _f !== undefined ? _f : DEFAULT_REQUEST_TIMEOUT_MSEC;
|
|
const timeoutHandler = () => cancel(McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout }));
|
|
this._setupTimeout(messageId, timeout, options === null || options === undefined ? undefined : options.maxTotalTimeout, timeoutHandler, (_g = options === null || options === undefined ? undefined : options.resetTimeoutOnProgress) !== null && _g !== undefined ? _g : false);
|
|
const relatedTaskId = relatedTask === null || relatedTask === undefined ? undefined : relatedTask.taskId;
|
|
if (relatedTaskId) {
|
|
const responseResolver = (response) => {
|
|
const handler = this._responseHandlers.get(messageId);
|
|
if (handler) {
|
|
handler(response);
|
|
} else {
|
|
this._onerror(new Error(`Response handler missing for side-channeled request ${messageId}`));
|
|
}
|
|
};
|
|
this._requestResolvers.set(messageId, responseResolver);
|
|
this._enqueueTaskMessage(relatedTaskId, {
|
|
type: "request",
|
|
message: jsonrpcRequest,
|
|
timestamp: Date.now()
|
|
}).catch((error2) => {
|
|
this._cleanupTimeout(messageId);
|
|
reject(error2);
|
|
});
|
|
} else {
|
|
this._transport.send(jsonrpcRequest, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error2) => {
|
|
this._cleanupTimeout(messageId);
|
|
reject(error2);
|
|
});
|
|
}
|
|
});
|
|
}
|
|
async getTask(params, options) {
|
|
return this.request({ method: "tasks/get", params }, GetTaskResultSchema, options);
|
|
}
|
|
async getTaskResult(params, resultSchema, options) {
|
|
return this.request({ method: "tasks/result", params }, resultSchema, options);
|
|
}
|
|
async listTasks(params, options) {
|
|
return this.request({ method: "tasks/list", params }, ListTasksResultSchema, options);
|
|
}
|
|
async cancelTask(params, options) {
|
|
return this.request({ method: "tasks/cancel", params }, CancelTaskResultSchema, options);
|
|
}
|
|
async notification(notification, options) {
|
|
var _a, _b, _c, _d, _e;
|
|
if (!this._transport) {
|
|
throw new Error("Not connected");
|
|
}
|
|
this.assertNotificationCapability(notification.method);
|
|
const relatedTaskId = (_a = options === null || options === undefined ? undefined : options.relatedTask) === null || _a === undefined ? undefined : _a.taskId;
|
|
if (relatedTaskId) {
|
|
const jsonrpcNotification2 = {
|
|
...notification,
|
|
jsonrpc: "2.0",
|
|
params: {
|
|
...notification.params,
|
|
_meta: {
|
|
...((_b = notification.params) === null || _b === undefined ? undefined : _b._meta) || {},
|
|
[RELATED_TASK_META_KEY]: options.relatedTask
|
|
}
|
|
}
|
|
};
|
|
await this._enqueueTaskMessage(relatedTaskId, {
|
|
type: "notification",
|
|
message: jsonrpcNotification2,
|
|
timestamp: Date.now()
|
|
});
|
|
return;
|
|
}
|
|
const debouncedMethods = (_d = (_c = this._options) === null || _c === undefined ? undefined : _c.debouncedNotificationMethods) !== null && _d !== undefined ? _d : [];
|
|
const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !(options === null || options === undefined ? undefined : options.relatedRequestId) && !(options === null || options === undefined ? undefined : options.relatedTask);
|
|
if (canDebounce) {
|
|
if (this._pendingDebouncedNotifications.has(notification.method)) {
|
|
return;
|
|
}
|
|
this._pendingDebouncedNotifications.add(notification.method);
|
|
Promise.resolve().then(() => {
|
|
var _a2, _b2;
|
|
this._pendingDebouncedNotifications.delete(notification.method);
|
|
if (!this._transport) {
|
|
return;
|
|
}
|
|
let jsonrpcNotification2 = {
|
|
...notification,
|
|
jsonrpc: "2.0"
|
|
};
|
|
if (options === null || options === undefined ? undefined : options.relatedTask) {
|
|
jsonrpcNotification2 = {
|
|
...jsonrpcNotification2,
|
|
params: {
|
|
...jsonrpcNotification2.params,
|
|
_meta: {
|
|
...((_a2 = jsonrpcNotification2.params) === null || _a2 === undefined ? undefined : _a2._meta) || {},
|
|
[RELATED_TASK_META_KEY]: options.relatedTask
|
|
}
|
|
}
|
|
};
|
|
}
|
|
(_b2 = this._transport) === null || _b2 === undefined || _b2.send(jsonrpcNotification2, options).catch((error2) => this._onerror(error2));
|
|
});
|
|
return;
|
|
}
|
|
let jsonrpcNotification = {
|
|
...notification,
|
|
jsonrpc: "2.0"
|
|
};
|
|
if (options === null || options === undefined ? undefined : options.relatedTask) {
|
|
jsonrpcNotification = {
|
|
...jsonrpcNotification,
|
|
params: {
|
|
...jsonrpcNotification.params,
|
|
_meta: {
|
|
...((_e = jsonrpcNotification.params) === null || _e === undefined ? undefined : _e._meta) || {},
|
|
[RELATED_TASK_META_KEY]: options.relatedTask
|
|
}
|
|
}
|
|
};
|
|
}
|
|
await this._transport.send(jsonrpcNotification, options);
|
|
}
|
|
setRequestHandler(requestSchema, handler) {
|
|
const method = getMethodLiteral(requestSchema);
|
|
this.assertRequestHandlerCapability(method);
|
|
this._requestHandlers.set(method, (request, extra) => {
|
|
const parsed = parseWithCompat(requestSchema, request);
|
|
return Promise.resolve(handler(parsed, extra));
|
|
});
|
|
}
|
|
removeRequestHandler(method) {
|
|
this._requestHandlers.delete(method);
|
|
}
|
|
assertCanSetRequestHandler(method) {
|
|
if (this._requestHandlers.has(method)) {
|
|
throw new Error(`A request handler for ${method} already exists, which would be overridden`);
|
|
}
|
|
}
|
|
setNotificationHandler(notificationSchema, handler) {
|
|
const method = getMethodLiteral(notificationSchema);
|
|
this._notificationHandlers.set(method, (notification) => {
|
|
const parsed = parseWithCompat(notificationSchema, notification);
|
|
return Promise.resolve(handler(parsed));
|
|
});
|
|
}
|
|
removeNotificationHandler(method) {
|
|
this._notificationHandlers.delete(method);
|
|
}
|
|
_cleanupTaskProgressHandler(taskId) {
|
|
const progressToken = this._taskProgressTokens.get(taskId);
|
|
if (progressToken !== undefined) {
|
|
this._progressHandlers.delete(progressToken);
|
|
this._taskProgressTokens.delete(taskId);
|
|
}
|
|
}
|
|
async _enqueueTaskMessage(taskId, message, sessionId) {
|
|
var _a;
|
|
if (!this._taskStore || !this._taskMessageQueue) {
|
|
throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
|
|
}
|
|
const maxQueueSize = (_a = this._options) === null || _a === undefined ? undefined : _a.maxTaskQueueSize;
|
|
await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
|
|
}
|
|
async _clearTaskQueue(taskId, sessionId) {
|
|
if (this._taskMessageQueue) {
|
|
const messages = await this._taskMessageQueue.dequeueAll(taskId, sessionId);
|
|
for (const message of messages) {
|
|
if (message.type === "request" && isJSONRPCRequest(message.message)) {
|
|
const requestId = message.message.id;
|
|
const resolver = this._requestResolvers.get(requestId);
|
|
if (resolver) {
|
|
resolver(new McpError(ErrorCode.InternalError, "Task cancelled or completed"));
|
|
this._requestResolvers.delete(requestId);
|
|
} else {
|
|
this._onerror(new Error(`Resolver missing for request ${requestId} during task ${taskId} cleanup`));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
async _waitForTaskUpdate(taskId, signal) {
|
|
var _a, _b, _c;
|
|
let interval = (_b = (_a = this._options) === null || _a === undefined ? undefined : _a.defaultTaskPollInterval) !== null && _b !== undefined ? _b : 1000;
|
|
try {
|
|
const task = await ((_c = this._taskStore) === null || _c === undefined ? undefined : _c.getTask(taskId));
|
|
if (task === null || task === undefined ? undefined : task.pollInterval) {
|
|
interval = task.pollInterval;
|
|
}
|
|
} catch (_d) {}
|
|
return new Promise((resolve, reject) => {
|
|
if (signal.aborted) {
|
|
reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
|
|
return;
|
|
}
|
|
const timeoutId = setTimeout(resolve, interval);
|
|
signal.addEventListener("abort", () => {
|
|
clearTimeout(timeoutId);
|
|
reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
|
|
}, { once: true });
|
|
});
|
|
}
|
|
requestTaskStore(request, sessionId) {
|
|
const taskStore = this._taskStore;
|
|
if (!taskStore) {
|
|
throw new Error("No task store configured");
|
|
}
|
|
return {
|
|
createTask: async (taskParams) => {
|
|
if (!request) {
|
|
throw new Error("No request provided");
|
|
}
|
|
return await taskStore.createTask(taskParams, request.id, {
|
|
method: request.method,
|
|
params: request.params
|
|
}, sessionId);
|
|
},
|
|
getTask: async (taskId) => {
|
|
const task = await taskStore.getTask(taskId, sessionId);
|
|
if (!task) {
|
|
throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
|
|
}
|
|
return task;
|
|
},
|
|
storeTaskResult: async (taskId, status, result) => {
|
|
await taskStore.storeTaskResult(taskId, status, result, sessionId);
|
|
const task = await taskStore.getTask(taskId, sessionId);
|
|
if (task) {
|
|
const notification = TaskStatusNotificationSchema.parse({
|
|
method: "notifications/tasks/status",
|
|
params: task
|
|
});
|
|
await this.notification(notification);
|
|
if (isTerminal(task.status)) {
|
|
this._cleanupTaskProgressHandler(taskId);
|
|
}
|
|
}
|
|
},
|
|
getTaskResult: (taskId) => {
|
|
return taskStore.getTaskResult(taskId, sessionId);
|
|
},
|
|
updateTaskStatus: async (taskId, status, statusMessage) => {
|
|
const task = await taskStore.getTask(taskId, sessionId);
|
|
if (!task) {
|
|
throw new McpError(ErrorCode.InvalidParams, `Task "${taskId}" not found - it may have been cleaned up`);
|
|
}
|
|
if (isTerminal(task.status)) {
|
|
throw new McpError(ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status}". Terminal states (completed, failed, cancelled) cannot transition to other states.`);
|
|
}
|
|
await taskStore.updateTaskStatus(taskId, status, statusMessage, sessionId);
|
|
const updatedTask = await taskStore.getTask(taskId, sessionId);
|
|
if (updatedTask) {
|
|
const notification = TaskStatusNotificationSchema.parse({
|
|
method: "notifications/tasks/status",
|
|
params: updatedTask
|
|
});
|
|
await this.notification(notification);
|
|
if (isTerminal(updatedTask.status)) {
|
|
this._cleanupTaskProgressHandler(taskId);
|
|
}
|
|
}
|
|
},
|
|
listTasks: (cursor) => {
|
|
return taskStore.listTasks(cursor, sessionId);
|
|
}
|
|
};
|
|
}
|
|
}
|
|
function isPlainObject2(value) {
|
|
return value !== null && typeof value === "object" && !Array.isArray(value);
|
|
}
|
|
function mergeCapabilities(base, additional) {
|
|
const result = { ...base };
|
|
for (const key in additional) {
|
|
const k = key;
|
|
const addValue = additional[k];
|
|
if (addValue === undefined)
|
|
continue;
|
|
const baseValue = result[k];
|
|
if (isPlainObject2(baseValue) && isPlainObject2(addValue)) {
|
|
result[k] = { ...baseValue, ...addValue };
|
|
} else {
|
|
result[k] = addValue;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// ../node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js
|
|
var import_ajv = __toESM(require_ajv(), 1);
|
|
var import_ajv_formats = __toESM(require_dist(), 1);
|
|
function createDefaultAjvInstance() {
|
|
const ajv = new import_ajv.Ajv({
|
|
strict: false,
|
|
validateFormats: true,
|
|
validateSchema: false,
|
|
allErrors: true
|
|
});
|
|
const addFormats = import_ajv_formats.default;
|
|
addFormats(ajv);
|
|
return ajv;
|
|
}
|
|
|
|
class AjvJsonSchemaValidator {
|
|
constructor(ajv) {
|
|
this._ajv = ajv !== null && ajv !== undefined ? ajv : createDefaultAjvInstance();
|
|
}
|
|
getValidator(schema) {
|
|
var _a;
|
|
const ajvValidator = "$id" in schema && typeof schema.$id === "string" ? (_a = this._ajv.getSchema(schema.$id)) !== null && _a !== undefined ? _a : this._ajv.compile(schema) : this._ajv.compile(schema);
|
|
return (input) => {
|
|
const valid = ajvValidator(input);
|
|
if (valid) {
|
|
return {
|
|
valid: true,
|
|
data: input,
|
|
errorMessage: undefined
|
|
};
|
|
} else {
|
|
return {
|
|
valid: false,
|
|
data: undefined,
|
|
errorMessage: this._ajv.errorsText(ajvValidator.errors)
|
|
};
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
// ../node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
|
|
class ExperimentalServerTasks {
|
|
constructor(_server) {
|
|
this._server = _server;
|
|
}
|
|
requestStream(request, resultSchema, options) {
|
|
return this._server.requestStream(request, resultSchema, options);
|
|
}
|
|
async getTask(taskId, options) {
|
|
return this._server.getTask({ taskId }, options);
|
|
}
|
|
async getTaskResult(taskId, resultSchema, options) {
|
|
return this._server.getTaskResult({ taskId }, resultSchema, options);
|
|
}
|
|
async listTasks(cursor, options) {
|
|
return this._server.listTasks(cursor ? { cursor } : undefined, options);
|
|
}
|
|
async cancelTask(taskId, options) {
|
|
return this._server.cancelTask({ taskId }, options);
|
|
}
|
|
}
|
|
|
|
// ../node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
|
|
function assertToolsCallTaskCapability(requests, method, entityName) {
|
|
var _a;
|
|
if (!requests) {
|
|
throw new Error(`${entityName} does not support task creation (required for ${method})`);
|
|
}
|
|
switch (method) {
|
|
case "tools/call":
|
|
if (!((_a = requests.tools) === null || _a === undefined ? undefined : _a.call)) {
|
|
throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
function assertClientRequestTaskCapability(requests, method, entityName) {
|
|
var _a, _b;
|
|
if (!requests) {
|
|
throw new Error(`${entityName} does not support task creation (required for ${method})`);
|
|
}
|
|
switch (method) {
|
|
case "sampling/createMessage":
|
|
if (!((_a = requests.sampling) === null || _a === undefined ? undefined : _a.createMessage)) {
|
|
throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
|
|
}
|
|
break;
|
|
case "elicitation/create":
|
|
if (!((_b = requests.elicitation) === null || _b === undefined ? undefined : _b.create)) {
|
|
throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// ../node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
|
|
class Server extends Protocol {
|
|
constructor(_serverInfo, options) {
|
|
var _a, _b;
|
|
super(options);
|
|
this._serverInfo = _serverInfo;
|
|
this._loggingLevels = new Map;
|
|
this.LOG_LEVEL_SEVERITY = new Map(LoggingLevelSchema.options.map((level, index) => [level, index]));
|
|
this.isMessageIgnored = (level, sessionId) => {
|
|
const currentLevel = this._loggingLevels.get(sessionId);
|
|
return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
|
|
};
|
|
this._capabilities = (_a = options === null || options === undefined ? undefined : options.capabilities) !== null && _a !== undefined ? _a : {};
|
|
this._instructions = options === null || options === undefined ? undefined : options.instructions;
|
|
this._jsonSchemaValidator = (_b = options === null || options === undefined ? undefined : options.jsonSchemaValidator) !== null && _b !== undefined ? _b : new AjvJsonSchemaValidator;
|
|
this.setRequestHandler(InitializeRequestSchema, (request) => this._oninitialize(request));
|
|
this.setNotificationHandler(InitializedNotificationSchema, () => {
|
|
var _a2;
|
|
return (_a2 = this.oninitialized) === null || _a2 === undefined ? undefined : _a2.call(this);
|
|
});
|
|
if (this._capabilities.logging) {
|
|
this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => {
|
|
var _a2;
|
|
const transportSessionId = extra.sessionId || ((_a2 = extra.requestInfo) === null || _a2 === undefined ? undefined : _a2.headers["mcp-session-id"]) || undefined;
|
|
const { level } = request.params;
|
|
const parseResult = LoggingLevelSchema.safeParse(level);
|
|
if (parseResult.success) {
|
|
this._loggingLevels.set(transportSessionId, parseResult.data);
|
|
}
|
|
return {};
|
|
});
|
|
}
|
|
}
|
|
get experimental() {
|
|
if (!this._experimental) {
|
|
this._experimental = {
|
|
tasks: new ExperimentalServerTasks(this)
|
|
};
|
|
}
|
|
return this._experimental;
|
|
}
|
|
registerCapabilities(capabilities) {
|
|
if (this.transport) {
|
|
throw new Error("Cannot register capabilities after connecting to transport");
|
|
}
|
|
this._capabilities = mergeCapabilities(this._capabilities, capabilities);
|
|
}
|
|
setRequestHandler(requestSchema, handler) {
|
|
var _a, _b, _c;
|
|
const shape = getObjectShape(requestSchema);
|
|
const methodSchema = shape === null || shape === undefined ? undefined : shape.method;
|
|
if (!methodSchema) {
|
|
throw new Error("Schema is missing a method literal");
|
|
}
|
|
let methodValue;
|
|
if (isZ4Schema(methodSchema)) {
|
|
const v4Schema = methodSchema;
|
|
const v4Def = (_a = v4Schema._zod) === null || _a === undefined ? undefined : _a.def;
|
|
methodValue = (_b = v4Def === null || v4Def === undefined ? undefined : v4Def.value) !== null && _b !== undefined ? _b : v4Schema.value;
|
|
} else {
|
|
const v3Schema = methodSchema;
|
|
const legacyDef = v3Schema._def;
|
|
methodValue = (_c = legacyDef === null || legacyDef === undefined ? undefined : legacyDef.value) !== null && _c !== undefined ? _c : v3Schema.value;
|
|
}
|
|
if (typeof methodValue !== "string") {
|
|
throw new Error("Schema method literal must be a string");
|
|
}
|
|
const method = methodValue;
|
|
if (method === "tools/call") {
|
|
const wrappedHandler = async (request, extra) => {
|
|
const validatedRequest = safeParse2(CallToolRequestSchema, request);
|
|
if (!validatedRequest.success) {
|
|
const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
|
|
throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
|
|
}
|
|
const { params } = validatedRequest.data;
|
|
const result = await Promise.resolve(handler(request, extra));
|
|
if (params.task) {
|
|
const taskValidationResult = safeParse2(CreateTaskResultSchema, result);
|
|
if (!taskValidationResult.success) {
|
|
const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
|
|
throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
|
|
}
|
|
return taskValidationResult.data;
|
|
}
|
|
const validationResult = safeParse2(CallToolResultSchema, result);
|
|
if (!validationResult.success) {
|
|
const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
|
|
throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
|
|
}
|
|
return validationResult.data;
|
|
};
|
|
return super.setRequestHandler(requestSchema, wrappedHandler);
|
|
}
|
|
return super.setRequestHandler(requestSchema, handler);
|
|
}
|
|
assertCapabilityForMethod(method) {
|
|
var _a, _b, _c;
|
|
switch (method) {
|
|
case "sampling/createMessage":
|
|
if (!((_a = this._clientCapabilities) === null || _a === undefined ? undefined : _a.sampling)) {
|
|
throw new Error(`Client does not support sampling (required for ${method})`);
|
|
}
|
|
break;
|
|
case "elicitation/create":
|
|
if (!((_b = this._clientCapabilities) === null || _b === undefined ? undefined : _b.elicitation)) {
|
|
throw new Error(`Client does not support elicitation (required for ${method})`);
|
|
}
|
|
break;
|
|
case "roots/list":
|
|
if (!((_c = this._clientCapabilities) === null || _c === undefined ? undefined : _c.roots)) {
|
|
throw new Error(`Client does not support listing roots (required for ${method})`);
|
|
}
|
|
break;
|
|
case "ping":
|
|
break;
|
|
}
|
|
}
|
|
assertNotificationCapability(method) {
|
|
var _a, _b;
|
|
switch (method) {
|
|
case "notifications/message":
|
|
if (!this._capabilities.logging) {
|
|
throw new Error(`Server does not support logging (required for ${method})`);
|
|
}
|
|
break;
|
|
case "notifications/resources/updated":
|
|
case "notifications/resources/list_changed":
|
|
if (!this._capabilities.resources) {
|
|
throw new Error(`Server does not support notifying about resources (required for ${method})`);
|
|
}
|
|
break;
|
|
case "notifications/tools/list_changed":
|
|
if (!this._capabilities.tools) {
|
|
throw new Error(`Server does not support notifying of tool list changes (required for ${method})`);
|
|
}
|
|
break;
|
|
case "notifications/prompts/list_changed":
|
|
if (!this._capabilities.prompts) {
|
|
throw new Error(`Server does not support notifying of prompt list changes (required for ${method})`);
|
|
}
|
|
break;
|
|
case "notifications/elicitation/complete":
|
|
if (!((_b = (_a = this._clientCapabilities) === null || _a === undefined ? undefined : _a.elicitation) === null || _b === undefined ? undefined : _b.url)) {
|
|
throw new Error(`Client does not support URL elicitation (required for ${method})`);
|
|
}
|
|
break;
|
|
case "notifications/cancelled":
|
|
break;
|
|
case "notifications/progress":
|
|
break;
|
|
}
|
|
}
|
|
assertRequestHandlerCapability(method) {
|
|
if (!this._capabilities) {
|
|
return;
|
|
}
|
|
switch (method) {
|
|
case "completion/complete":
|
|
if (!this._capabilities.completions) {
|
|
throw new Error(`Server does not support completions (required for ${method})`);
|
|
}
|
|
break;
|
|
case "logging/setLevel":
|
|
if (!this._capabilities.logging) {
|
|
throw new Error(`Server does not support logging (required for ${method})`);
|
|
}
|
|
break;
|
|
case "prompts/get":
|
|
case "prompts/list":
|
|
if (!this._capabilities.prompts) {
|
|
throw new Error(`Server does not support prompts (required for ${method})`);
|
|
}
|
|
break;
|
|
case "resources/list":
|
|
case "resources/templates/list":
|
|
case "resources/read":
|
|
if (!this._capabilities.resources) {
|
|
throw new Error(`Server does not support resources (required for ${method})`);
|
|
}
|
|
break;
|
|
case "tools/call":
|
|
case "tools/list":
|
|
if (!this._capabilities.tools) {
|
|
throw new Error(`Server does not support tools (required for ${method})`);
|
|
}
|
|
break;
|
|
case "tasks/get":
|
|
case "tasks/list":
|
|
case "tasks/result":
|
|
case "tasks/cancel":
|
|
if (!this._capabilities.tasks) {
|
|
throw new Error(`Server does not support tasks capability (required for ${method})`);
|
|
}
|
|
break;
|
|
case "ping":
|
|
case "initialize":
|
|
break;
|
|
}
|
|
}
|
|
assertTaskCapability(method) {
|
|
var _a, _b;
|
|
assertClientRequestTaskCapability((_b = (_a = this._clientCapabilities) === null || _a === undefined ? undefined : _a.tasks) === null || _b === undefined ? undefined : _b.requests, method, "Client");
|
|
}
|
|
assertTaskHandlerCapability(method) {
|
|
var _a;
|
|
if (!this._capabilities) {
|
|
return;
|
|
}
|
|
assertToolsCallTaskCapability((_a = this._capabilities.tasks) === null || _a === undefined ? undefined : _a.requests, method, "Server");
|
|
}
|
|
async _oninitialize(request) {
|
|
const requestedVersion = request.params.protocolVersion;
|
|
this._clientCapabilities = request.params.capabilities;
|
|
this._clientVersion = request.params.clientInfo;
|
|
const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION;
|
|
return {
|
|
protocolVersion,
|
|
capabilities: this.getCapabilities(),
|
|
serverInfo: this._serverInfo,
|
|
...this._instructions && { instructions: this._instructions }
|
|
};
|
|
}
|
|
getClientCapabilities() {
|
|
return this._clientCapabilities;
|
|
}
|
|
getClientVersion() {
|
|
return this._clientVersion;
|
|
}
|
|
getCapabilities() {
|
|
return this._capabilities;
|
|
}
|
|
async ping() {
|
|
return this.request({ method: "ping" }, EmptyResultSchema);
|
|
}
|
|
async createMessage(params, options) {
|
|
var _a, _b;
|
|
if (params.tools || params.toolChoice) {
|
|
if (!((_b = (_a = this._clientCapabilities) === null || _a === undefined ? undefined : _a.sampling) === null || _b === undefined ? undefined : _b.tools)) {
|
|
throw new Error("Client does not support sampling tools capability.");
|
|
}
|
|
}
|
|
if (params.messages.length > 0) {
|
|
const lastMessage = params.messages[params.messages.length - 1];
|
|
const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
|
|
const hasToolResults = lastContent.some((c) => c.type === "tool_result");
|
|
const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : undefined;
|
|
const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
|
|
const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
|
|
if (hasToolResults) {
|
|
if (lastContent.some((c) => c.type !== "tool_result")) {
|
|
throw new Error("The last message must contain only tool_result content if any is present");
|
|
}
|
|
if (!hasPreviousToolUse) {
|
|
throw new Error("tool_result blocks are not matching any tool_use from the previous message");
|
|
}
|
|
}
|
|
if (hasPreviousToolUse) {
|
|
const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
|
|
const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
|
|
if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) {
|
|
throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
|
|
}
|
|
}
|
|
}
|
|
if (params.tools) {
|
|
return this.request({ method: "sampling/createMessage", params }, CreateMessageResultWithToolsSchema, options);
|
|
}
|
|
return this.request({ method: "sampling/createMessage", params }, CreateMessageResultSchema, options);
|
|
}
|
|
async elicitInput(params, options) {
|
|
var _a, _b, _c, _d, _e;
|
|
const mode = (_a = params.mode) !== null && _a !== undefined ? _a : "form";
|
|
switch (mode) {
|
|
case "url": {
|
|
if (!((_c = (_b = this._clientCapabilities) === null || _b === undefined ? undefined : _b.elicitation) === null || _c === undefined ? undefined : _c.url)) {
|
|
throw new Error("Client does not support url elicitation.");
|
|
}
|
|
const urlParams = params;
|
|
return this.request({ method: "elicitation/create", params: urlParams }, ElicitResultSchema, options);
|
|
}
|
|
case "form": {
|
|
if (!((_e = (_d = this._clientCapabilities) === null || _d === undefined ? undefined : _d.elicitation) === null || _e === undefined ? undefined : _e.form)) {
|
|
throw new Error("Client does not support form elicitation.");
|
|
}
|
|
const formParams = params.mode === "form" ? params : { ...params, mode: "form" };
|
|
const result = await this.request({ method: "elicitation/create", params: formParams }, ElicitResultSchema, options);
|
|
if (result.action === "accept" && result.content && formParams.requestedSchema) {
|
|
try {
|
|
const validator = this._jsonSchemaValidator.getValidator(formParams.requestedSchema);
|
|
const validationResult = validator(result.content);
|
|
if (!validationResult.valid) {
|
|
throw new McpError(ErrorCode.InvalidParams, `Elicitation response content does not match requested schema: ${validationResult.errorMessage}`);
|
|
}
|
|
} catch (error2) {
|
|
if (error2 instanceof McpError) {
|
|
throw error2;
|
|
}
|
|
throw new McpError(ErrorCode.InternalError, `Error validating elicitation response: ${error2 instanceof Error ? error2.message : String(error2)}`);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
createElicitationCompletionNotifier(elicitationId, options) {
|
|
var _a, _b;
|
|
if (!((_b = (_a = this._clientCapabilities) === null || _a === undefined ? undefined : _a.elicitation) === null || _b === undefined ? undefined : _b.url)) {
|
|
throw new Error("Client does not support URL elicitation (required for notifications/elicitation/complete)");
|
|
}
|
|
return () => this.notification({
|
|
method: "notifications/elicitation/complete",
|
|
params: {
|
|
elicitationId
|
|
}
|
|
}, options);
|
|
}
|
|
async listRoots(params, options) {
|
|
return this.request({ method: "roots/list", params }, ListRootsResultSchema, options);
|
|
}
|
|
async sendLoggingMessage(params, sessionId) {
|
|
if (this._capabilities.logging) {
|
|
if (!this.isMessageIgnored(params.level, sessionId)) {
|
|
return this.notification({ method: "notifications/message", params });
|
|
}
|
|
}
|
|
}
|
|
async sendResourceUpdated(params) {
|
|
return this.notification({
|
|
method: "notifications/resources/updated",
|
|
params
|
|
});
|
|
}
|
|
async sendResourceListChanged() {
|
|
return this.notification({
|
|
method: "notifications/resources/list_changed"
|
|
});
|
|
}
|
|
async sendToolListChanged() {
|
|
return this.notification({ method: "notifications/tools/list_changed" });
|
|
}
|
|
async sendPromptListChanged() {
|
|
return this.notification({ method: "notifications/prompts/list_changed" });
|
|
}
|
|
}
|
|
|
|
// ../node_modules/@modelcontextprotocol/sdk/dist/esm/server/completable.js
|
|
var COMPLETABLE_SYMBOL = Symbol.for("mcp.completable");
|
|
function isCompletable(schema) {
|
|
return !!schema && typeof schema === "object" && COMPLETABLE_SYMBOL in schema;
|
|
}
|
|
function getCompleter(schema) {
|
|
const meta = schema[COMPLETABLE_SYMBOL];
|
|
return meta === null || meta === undefined ? undefined : meta.complete;
|
|
}
|
|
var McpZodTypeKind;
|
|
(function(McpZodTypeKind2) {
|
|
McpZodTypeKind2["Completable"] = "McpCompletable";
|
|
})(McpZodTypeKind || (McpZodTypeKind = {}));
|
|
|
|
// ../node_modules/@modelcontextprotocol/sdk/dist/esm/shared/toolNameValidation.js
|
|
var TOOL_NAME_REGEX = /^[A-Za-z0-9._-]{1,128}$/;
|
|
function validateToolName(name) {
|
|
const warnings = [];
|
|
if (name.length === 0) {
|
|
return {
|
|
isValid: false,
|
|
warnings: ["Tool name cannot be empty"]
|
|
};
|
|
}
|
|
if (name.length > 128) {
|
|
return {
|
|
isValid: false,
|
|
warnings: [`Tool name exceeds maximum length of 128 characters (current: ${name.length})`]
|
|
};
|
|
}
|
|
if (name.includes(" ")) {
|
|
warnings.push("Tool name contains spaces, which may cause parsing issues");
|
|
}
|
|
if (name.includes(",")) {
|
|
warnings.push("Tool name contains commas, which may cause parsing issues");
|
|
}
|
|
if (name.startsWith("-") || name.endsWith("-")) {
|
|
warnings.push("Tool name starts or ends with a dash, which may cause parsing issues in some contexts");
|
|
}
|
|
if (name.startsWith(".") || name.endsWith(".")) {
|
|
warnings.push("Tool name starts or ends with a dot, which may cause parsing issues in some contexts");
|
|
}
|
|
if (!TOOL_NAME_REGEX.test(name)) {
|
|
const invalidChars = name.split("").filter((char) => !/[A-Za-z0-9._-]/.test(char)).filter((char, index, arr) => arr.indexOf(char) === index);
|
|
warnings.push(`Tool name contains invalid characters: ${invalidChars.map((c) => `"${c}"`).join(", ")}`, "Allowed characters are: A-Z, a-z, 0-9, underscore (_), dash (-), and dot (.)");
|
|
return {
|
|
isValid: false,
|
|
warnings
|
|
};
|
|
}
|
|
return {
|
|
isValid: true,
|
|
warnings
|
|
};
|
|
}
|
|
function issueToolNameWarning(name, warnings) {
|
|
if (warnings.length > 0) {
|
|
console.warn(`Tool name validation warning for "${name}":`);
|
|
for (const warning of warnings) {
|
|
console.warn(` - ${warning}`);
|
|
}
|
|
console.warn("Tool registration will proceed, but this may cause compatibility issues.");
|
|
console.warn("Consider updating the tool name to conform to the MCP tool naming standard.");
|
|
console.warn("See SEP: Specify Format for Tool Names (https://github.com/modelcontextprotocol/modelcontextprotocol/issues/986) for more details.");
|
|
}
|
|
}
|
|
function validateAndWarnToolName(name) {
|
|
const result = validateToolName(name);
|
|
issueToolNameWarning(name, result.warnings);
|
|
return result.isValid;
|
|
}
|
|
|
|
// ../node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/mcp-server.js
|
|
class ExperimentalMcpServerTasks {
|
|
constructor(_mcpServer) {
|
|
this._mcpServer = _mcpServer;
|
|
}
|
|
registerToolTask(name, config2, handler) {
|
|
const execution = { taskSupport: "required", ...config2.execution };
|
|
if (execution.taskSupport === "forbidden") {
|
|
throw new Error(`Cannot register task-based tool '${name}' with taskSupport 'forbidden'. Use registerTool() instead.`);
|
|
}
|
|
const mcpServerInternal = this._mcpServer;
|
|
return mcpServerInternal._createRegisteredTool(name, config2.title, config2.description, config2.inputSchema, config2.outputSchema, config2.annotations, execution, config2._meta, handler);
|
|
}
|
|
}
|
|
|
|
// ../node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js
|
|
class McpServer {
|
|
constructor(serverInfo, options) {
|
|
this._registeredResources = {};
|
|
this._registeredResourceTemplates = {};
|
|
this._registeredTools = {};
|
|
this._registeredPrompts = {};
|
|
this._toolHandlersInitialized = false;
|
|
this._completionHandlerInitialized = false;
|
|
this._resourceHandlersInitialized = false;
|
|
this._promptHandlersInitialized = false;
|
|
this.server = new Server(serverInfo, options);
|
|
}
|
|
get experimental() {
|
|
if (!this._experimental) {
|
|
this._experimental = {
|
|
tasks: new ExperimentalMcpServerTasks(this)
|
|
};
|
|
}
|
|
return this._experimental;
|
|
}
|
|
async connect(transport) {
|
|
return await this.server.connect(transport);
|
|
}
|
|
async close() {
|
|
await this.server.close();
|
|
}
|
|
setToolRequestHandlers() {
|
|
if (this._toolHandlersInitialized) {
|
|
return;
|
|
}
|
|
this.server.assertCanSetRequestHandler(getMethodValue(ListToolsRequestSchema));
|
|
this.server.assertCanSetRequestHandler(getMethodValue(CallToolRequestSchema));
|
|
this.server.registerCapabilities({
|
|
tools: {
|
|
listChanged: true
|
|
}
|
|
});
|
|
this.server.setRequestHandler(ListToolsRequestSchema, () => ({
|
|
tools: Object.entries(this._registeredTools).filter(([, tool]) => tool.enabled).map(([name, tool]) => {
|
|
const toolDefinition = {
|
|
name,
|
|
title: tool.title,
|
|
description: tool.description,
|
|
inputSchema: (() => {
|
|
const obj = normalizeObjectSchema(tool.inputSchema);
|
|
return obj ? toJsonSchemaCompat(obj, {
|
|
strictUnions: true,
|
|
pipeStrategy: "input"
|
|
}) : EMPTY_OBJECT_JSON_SCHEMA;
|
|
})(),
|
|
annotations: tool.annotations,
|
|
execution: tool.execution,
|
|
_meta: tool._meta
|
|
};
|
|
if (tool.outputSchema) {
|
|
const obj = normalizeObjectSchema(tool.outputSchema);
|
|
if (obj) {
|
|
toolDefinition.outputSchema = toJsonSchemaCompat(obj, {
|
|
strictUnions: true,
|
|
pipeStrategy: "output"
|
|
});
|
|
}
|
|
}
|
|
return toolDefinition;
|
|
})
|
|
}));
|
|
this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
|
|
var _a;
|
|
try {
|
|
const tool = this._registeredTools[request.params.name];
|
|
if (!tool) {
|
|
throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} not found`);
|
|
}
|
|
if (!tool.enabled) {
|
|
throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} disabled`);
|
|
}
|
|
const isTaskRequest = !!request.params.task;
|
|
const taskSupport = (_a = tool.execution) === null || _a === undefined ? undefined : _a.taskSupport;
|
|
const isTaskHandler = "createTask" in tool.handler;
|
|
if ((taskSupport === "required" || taskSupport === "optional") && !isTaskHandler) {
|
|
throw new McpError(ErrorCode.InternalError, `Tool ${request.params.name} has taskSupport '${taskSupport}' but was not registered with registerToolTask`);
|
|
}
|
|
if (taskSupport === "required" && !isTaskRequest) {
|
|
throw new McpError(ErrorCode.MethodNotFound, `Tool ${request.params.name} requires task augmentation (taskSupport: 'required')`);
|
|
}
|
|
if (taskSupport === "optional" && !isTaskRequest && isTaskHandler) {
|
|
return await this.handleAutomaticTaskPolling(tool, request, extra);
|
|
}
|
|
const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
|
|
const result = await this.executeToolHandler(tool, args, extra);
|
|
if (isTaskRequest) {
|
|
return result;
|
|
}
|
|
await this.validateToolOutput(tool, result, request.params.name);
|
|
return result;
|
|
} catch (error2) {
|
|
if (error2 instanceof McpError) {
|
|
if (error2.code === ErrorCode.UrlElicitationRequired) {
|
|
throw error2;
|
|
}
|
|
}
|
|
return this.createToolError(error2 instanceof Error ? error2.message : String(error2));
|
|
}
|
|
});
|
|
this._toolHandlersInitialized = true;
|
|
}
|
|
createToolError(errorMessage) {
|
|
return {
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: errorMessage
|
|
}
|
|
],
|
|
isError: true
|
|
};
|
|
}
|
|
async validateToolInput(tool, args, toolName) {
|
|
if (!tool.inputSchema) {
|
|
return;
|
|
}
|
|
const inputObj = normalizeObjectSchema(tool.inputSchema);
|
|
const schemaToParse = inputObj !== null && inputObj !== undefined ? inputObj : tool.inputSchema;
|
|
const parseResult = await safeParseAsync2(schemaToParse, args);
|
|
if (!parseResult.success) {
|
|
const error2 = "error" in parseResult ? parseResult.error : "Unknown error";
|
|
const errorMessage = getParseErrorMessage(error2);
|
|
throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage}`);
|
|
}
|
|
return parseResult.data;
|
|
}
|
|
async validateToolOutput(tool, result, toolName) {
|
|
if (!tool.outputSchema) {
|
|
return;
|
|
}
|
|
if (!("content" in result)) {
|
|
return;
|
|
}
|
|
if (result.isError) {
|
|
return;
|
|
}
|
|
if (!result.structuredContent) {
|
|
throw new McpError(ErrorCode.InvalidParams, `Output validation error: Tool ${toolName} has an output schema but no structured content was provided`);
|
|
}
|
|
const outputObj = normalizeObjectSchema(tool.outputSchema);
|
|
const parseResult = await safeParseAsync2(outputObj, result.structuredContent);
|
|
if (!parseResult.success) {
|
|
const error2 = "error" in parseResult ? parseResult.error : "Unknown error";
|
|
const errorMessage = getParseErrorMessage(error2);
|
|
throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage}`);
|
|
}
|
|
}
|
|
async executeToolHandler(tool, args, extra) {
|
|
const handler = tool.handler;
|
|
const isTaskHandler = "createTask" in handler;
|
|
if (isTaskHandler) {
|
|
if (!extra.taskStore) {
|
|
throw new Error("No task store provided.");
|
|
}
|
|
const taskExtra = { ...extra, taskStore: extra.taskStore };
|
|
if (tool.inputSchema) {
|
|
const typedHandler = handler;
|
|
return await Promise.resolve(typedHandler.createTask(args, taskExtra));
|
|
} else {
|
|
const typedHandler = handler;
|
|
return await Promise.resolve(typedHandler.createTask(taskExtra));
|
|
}
|
|
}
|
|
if (tool.inputSchema) {
|
|
const typedHandler = handler;
|
|
return await Promise.resolve(typedHandler(args, extra));
|
|
} else {
|
|
const typedHandler = handler;
|
|
return await Promise.resolve(typedHandler(extra));
|
|
}
|
|
}
|
|
async handleAutomaticTaskPolling(tool, request, extra) {
|
|
var _a;
|
|
if (!extra.taskStore) {
|
|
throw new Error("No task store provided for task-capable tool.");
|
|
}
|
|
const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
|
|
const handler = tool.handler;
|
|
const taskExtra = { ...extra, taskStore: extra.taskStore };
|
|
const createTaskResult = args ? await Promise.resolve(handler.createTask(args, taskExtra)) : await Promise.resolve(handler.createTask(taskExtra));
|
|
const taskId = createTaskResult.task.taskId;
|
|
let task = createTaskResult.task;
|
|
const pollInterval = (_a = task.pollInterval) !== null && _a !== undefined ? _a : 5000;
|
|
while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
|
|
await new Promise((resolve) => setTimeout(resolve, pollInterval));
|
|
const updatedTask = await extra.taskStore.getTask(taskId);
|
|
if (!updatedTask) {
|
|
throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
|
|
}
|
|
task = updatedTask;
|
|
}
|
|
return await extra.taskStore.getTaskResult(taskId);
|
|
}
|
|
setCompletionRequestHandler() {
|
|
if (this._completionHandlerInitialized) {
|
|
return;
|
|
}
|
|
this.server.assertCanSetRequestHandler(getMethodValue(CompleteRequestSchema));
|
|
this.server.registerCapabilities({
|
|
completions: {}
|
|
});
|
|
this.server.setRequestHandler(CompleteRequestSchema, async (request) => {
|
|
switch (request.params.ref.type) {
|
|
case "ref/prompt":
|
|
assertCompleteRequestPrompt(request);
|
|
return this.handlePromptCompletion(request, request.params.ref);
|
|
case "ref/resource":
|
|
assertCompleteRequestResourceTemplate(request);
|
|
return this.handleResourceCompletion(request, request.params.ref);
|
|
default:
|
|
throw new McpError(ErrorCode.InvalidParams, `Invalid completion reference: ${request.params.ref}`);
|
|
}
|
|
});
|
|
this._completionHandlerInitialized = true;
|
|
}
|
|
async handlePromptCompletion(request, ref) {
|
|
const prompt = this._registeredPrompts[ref.name];
|
|
if (!prompt) {
|
|
throw new McpError(ErrorCode.InvalidParams, `Prompt ${ref.name} not found`);
|
|
}
|
|
if (!prompt.enabled) {
|
|
throw new McpError(ErrorCode.InvalidParams, `Prompt ${ref.name} disabled`);
|
|
}
|
|
if (!prompt.argsSchema) {
|
|
return EMPTY_COMPLETION_RESULT;
|
|
}
|
|
const promptShape = getObjectShape(prompt.argsSchema);
|
|
const field = promptShape === null || promptShape === undefined ? undefined : promptShape[request.params.argument.name];
|
|
if (!isCompletable(field)) {
|
|
return EMPTY_COMPLETION_RESULT;
|
|
}
|
|
const completer = getCompleter(field);
|
|
if (!completer) {
|
|
return EMPTY_COMPLETION_RESULT;
|
|
}
|
|
const suggestions = await completer(request.params.argument.value, request.params.context);
|
|
return createCompletionResult(suggestions);
|
|
}
|
|
async handleResourceCompletion(request, ref) {
|
|
const template = Object.values(this._registeredResourceTemplates).find((t) => t.resourceTemplate.uriTemplate.toString() === ref.uri);
|
|
if (!template) {
|
|
if (this._registeredResources[ref.uri]) {
|
|
return EMPTY_COMPLETION_RESULT;
|
|
}
|
|
throw new McpError(ErrorCode.InvalidParams, `Resource template ${request.params.ref.uri} not found`);
|
|
}
|
|
const completer = template.resourceTemplate.completeCallback(request.params.argument.name);
|
|
if (!completer) {
|
|
return EMPTY_COMPLETION_RESULT;
|
|
}
|
|
const suggestions = await completer(request.params.argument.value, request.params.context);
|
|
return createCompletionResult(suggestions);
|
|
}
|
|
setResourceRequestHandlers() {
|
|
if (this._resourceHandlersInitialized) {
|
|
return;
|
|
}
|
|
this.server.assertCanSetRequestHandler(getMethodValue(ListResourcesRequestSchema));
|
|
this.server.assertCanSetRequestHandler(getMethodValue(ListResourceTemplatesRequestSchema));
|
|
this.server.assertCanSetRequestHandler(getMethodValue(ReadResourceRequestSchema));
|
|
this.server.registerCapabilities({
|
|
resources: {
|
|
listChanged: true
|
|
}
|
|
});
|
|
this.server.setRequestHandler(ListResourcesRequestSchema, async (request, extra) => {
|
|
const resources = Object.entries(this._registeredResources).filter(([_, resource]) => resource.enabled).map(([uri, resource]) => ({
|
|
uri,
|
|
name: resource.name,
|
|
...resource.metadata
|
|
}));
|
|
const templateResources = [];
|
|
for (const template of Object.values(this._registeredResourceTemplates)) {
|
|
if (!template.resourceTemplate.listCallback) {
|
|
continue;
|
|
}
|
|
const result = await template.resourceTemplate.listCallback(extra);
|
|
for (const resource of result.resources) {
|
|
templateResources.push({
|
|
...template.metadata,
|
|
...resource
|
|
});
|
|
}
|
|
}
|
|
return { resources: [...resources, ...templateResources] };
|
|
});
|
|
this.server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
|
|
const resourceTemplates = Object.entries(this._registeredResourceTemplates).map(([name, template]) => ({
|
|
name,
|
|
uriTemplate: template.resourceTemplate.uriTemplate.toString(),
|
|
...template.metadata
|
|
}));
|
|
return { resourceTemplates };
|
|
});
|
|
this.server.setRequestHandler(ReadResourceRequestSchema, async (request, extra) => {
|
|
const uri = new URL(request.params.uri);
|
|
const resource = this._registeredResources[uri.toString()];
|
|
if (resource) {
|
|
if (!resource.enabled) {
|
|
throw new McpError(ErrorCode.InvalidParams, `Resource ${uri} disabled`);
|
|
}
|
|
return resource.readCallback(uri, extra);
|
|
}
|
|
for (const template of Object.values(this._registeredResourceTemplates)) {
|
|
const variables = template.resourceTemplate.uriTemplate.match(uri.toString());
|
|
if (variables) {
|
|
return template.readCallback(uri, variables, extra);
|
|
}
|
|
}
|
|
throw new McpError(ErrorCode.InvalidParams, `Resource ${uri} not found`);
|
|
});
|
|
this.setCompletionRequestHandler();
|
|
this._resourceHandlersInitialized = true;
|
|
}
|
|
setPromptRequestHandlers() {
|
|
if (this._promptHandlersInitialized) {
|
|
return;
|
|
}
|
|
this.server.assertCanSetRequestHandler(getMethodValue(ListPromptsRequestSchema));
|
|
this.server.assertCanSetRequestHandler(getMethodValue(GetPromptRequestSchema));
|
|
this.server.registerCapabilities({
|
|
prompts: {
|
|
listChanged: true
|
|
}
|
|
});
|
|
this.server.setRequestHandler(ListPromptsRequestSchema, () => ({
|
|
prompts: Object.entries(this._registeredPrompts).filter(([, prompt]) => prompt.enabled).map(([name, prompt]) => {
|
|
return {
|
|
name,
|
|
title: prompt.title,
|
|
description: prompt.description,
|
|
arguments: prompt.argsSchema ? promptArgumentsFromSchema(prompt.argsSchema) : undefined
|
|
};
|
|
})
|
|
}));
|
|
this.server.setRequestHandler(GetPromptRequestSchema, async (request, extra) => {
|
|
const prompt = this._registeredPrompts[request.params.name];
|
|
if (!prompt) {
|
|
throw new McpError(ErrorCode.InvalidParams, `Prompt ${request.params.name} not found`);
|
|
}
|
|
if (!prompt.enabled) {
|
|
throw new McpError(ErrorCode.InvalidParams, `Prompt ${request.params.name} disabled`);
|
|
}
|
|
if (prompt.argsSchema) {
|
|
const argsObj = normalizeObjectSchema(prompt.argsSchema);
|
|
const parseResult = await safeParseAsync2(argsObj, request.params.arguments);
|
|
if (!parseResult.success) {
|
|
const error2 = "error" in parseResult ? parseResult.error : "Unknown error";
|
|
const errorMessage = getParseErrorMessage(error2);
|
|
throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for prompt ${request.params.name}: ${errorMessage}`);
|
|
}
|
|
const args = parseResult.data;
|
|
const cb = prompt.callback;
|
|
return await Promise.resolve(cb(args, extra));
|
|
} else {
|
|
const cb = prompt.callback;
|
|
return await Promise.resolve(cb(extra));
|
|
}
|
|
});
|
|
this.setCompletionRequestHandler();
|
|
this._promptHandlersInitialized = true;
|
|
}
|
|
resource(name, uriOrTemplate, ...rest) {
|
|
let metadata;
|
|
if (typeof rest[0] === "object") {
|
|
metadata = rest.shift();
|
|
}
|
|
const readCallback = rest[0];
|
|
if (typeof uriOrTemplate === "string") {
|
|
if (this._registeredResources[uriOrTemplate]) {
|
|
throw new Error(`Resource ${uriOrTemplate} is already registered`);
|
|
}
|
|
const registeredResource = this._createRegisteredResource(name, undefined, uriOrTemplate, metadata, readCallback);
|
|
this.setResourceRequestHandlers();
|
|
this.sendResourceListChanged();
|
|
return registeredResource;
|
|
} else {
|
|
if (this._registeredResourceTemplates[name]) {
|
|
throw new Error(`Resource template ${name} is already registered`);
|
|
}
|
|
const registeredResourceTemplate = this._createRegisteredResourceTemplate(name, undefined, uriOrTemplate, metadata, readCallback);
|
|
this.setResourceRequestHandlers();
|
|
this.sendResourceListChanged();
|
|
return registeredResourceTemplate;
|
|
}
|
|
}
|
|
registerResource(name, uriOrTemplate, config2, readCallback) {
|
|
if (typeof uriOrTemplate === "string") {
|
|
if (this._registeredResources[uriOrTemplate]) {
|
|
throw new Error(`Resource ${uriOrTemplate} is already registered`);
|
|
}
|
|
const registeredResource = this._createRegisteredResource(name, config2.title, uriOrTemplate, config2, readCallback);
|
|
this.setResourceRequestHandlers();
|
|
this.sendResourceListChanged();
|
|
return registeredResource;
|
|
} else {
|
|
if (this._registeredResourceTemplates[name]) {
|
|
throw new Error(`Resource template ${name} is already registered`);
|
|
}
|
|
const registeredResourceTemplate = this._createRegisteredResourceTemplate(name, config2.title, uriOrTemplate, config2, readCallback);
|
|
this.setResourceRequestHandlers();
|
|
this.sendResourceListChanged();
|
|
return registeredResourceTemplate;
|
|
}
|
|
}
|
|
_createRegisteredResource(name, title, uri, metadata, readCallback) {
|
|
const registeredResource = {
|
|
name,
|
|
title,
|
|
metadata,
|
|
readCallback,
|
|
enabled: true,
|
|
disable: () => registeredResource.update({ enabled: false }),
|
|
enable: () => registeredResource.update({ enabled: true }),
|
|
remove: () => registeredResource.update({ uri: null }),
|
|
update: (updates) => {
|
|
if (typeof updates.uri !== "undefined" && updates.uri !== uri) {
|
|
delete this._registeredResources[uri];
|
|
if (updates.uri)
|
|
this._registeredResources[updates.uri] = registeredResource;
|
|
}
|
|
if (typeof updates.name !== "undefined")
|
|
registeredResource.name = updates.name;
|
|
if (typeof updates.title !== "undefined")
|
|
registeredResource.title = updates.title;
|
|
if (typeof updates.metadata !== "undefined")
|
|
registeredResource.metadata = updates.metadata;
|
|
if (typeof updates.callback !== "undefined")
|
|
registeredResource.readCallback = updates.callback;
|
|
if (typeof updates.enabled !== "undefined")
|
|
registeredResource.enabled = updates.enabled;
|
|
this.sendResourceListChanged();
|
|
}
|
|
};
|
|
this._registeredResources[uri] = registeredResource;
|
|
return registeredResource;
|
|
}
|
|
_createRegisteredResourceTemplate(name, title, template, metadata, readCallback) {
|
|
const registeredResourceTemplate = {
|
|
resourceTemplate: template,
|
|
title,
|
|
metadata,
|
|
readCallback,
|
|
enabled: true,
|
|
disable: () => registeredResourceTemplate.update({ enabled: false }),
|
|
enable: () => registeredResourceTemplate.update({ enabled: true }),
|
|
remove: () => registeredResourceTemplate.update({ name: null }),
|
|
update: (updates) => {
|
|
if (typeof updates.name !== "undefined" && updates.name !== name) {
|
|
delete this._registeredResourceTemplates[name];
|
|
if (updates.name)
|
|
this._registeredResourceTemplates[updates.name] = registeredResourceTemplate;
|
|
}
|
|
if (typeof updates.title !== "undefined")
|
|
registeredResourceTemplate.title = updates.title;
|
|
if (typeof updates.template !== "undefined")
|
|
registeredResourceTemplate.resourceTemplate = updates.template;
|
|
if (typeof updates.metadata !== "undefined")
|
|
registeredResourceTemplate.metadata = updates.metadata;
|
|
if (typeof updates.callback !== "undefined")
|
|
registeredResourceTemplate.readCallback = updates.callback;
|
|
if (typeof updates.enabled !== "undefined")
|
|
registeredResourceTemplate.enabled = updates.enabled;
|
|
this.sendResourceListChanged();
|
|
}
|
|
};
|
|
this._registeredResourceTemplates[name] = registeredResourceTemplate;
|
|
return registeredResourceTemplate;
|
|
}
|
|
_createRegisteredPrompt(name, title, description, argsSchema, callback) {
|
|
const registeredPrompt = {
|
|
title,
|
|
description,
|
|
argsSchema: argsSchema === undefined ? undefined : objectFromShape(argsSchema),
|
|
callback,
|
|
enabled: true,
|
|
disable: () => registeredPrompt.update({ enabled: false }),
|
|
enable: () => registeredPrompt.update({ enabled: true }),
|
|
remove: () => registeredPrompt.update({ name: null }),
|
|
update: (updates) => {
|
|
if (typeof updates.name !== "undefined" && updates.name !== name) {
|
|
delete this._registeredPrompts[name];
|
|
if (updates.name)
|
|
this._registeredPrompts[updates.name] = registeredPrompt;
|
|
}
|
|
if (typeof updates.title !== "undefined")
|
|
registeredPrompt.title = updates.title;
|
|
if (typeof updates.description !== "undefined")
|
|
registeredPrompt.description = updates.description;
|
|
if (typeof updates.argsSchema !== "undefined")
|
|
registeredPrompt.argsSchema = objectFromShape(updates.argsSchema);
|
|
if (typeof updates.callback !== "undefined")
|
|
registeredPrompt.callback = updates.callback;
|
|
if (typeof updates.enabled !== "undefined")
|
|
registeredPrompt.enabled = updates.enabled;
|
|
this.sendPromptListChanged();
|
|
}
|
|
};
|
|
this._registeredPrompts[name] = registeredPrompt;
|
|
return registeredPrompt;
|
|
}
|
|
_createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, execution, _meta, handler) {
|
|
validateAndWarnToolName(name);
|
|
const registeredTool = {
|
|
title,
|
|
description,
|
|
inputSchema: getZodSchemaObject(inputSchema),
|
|
outputSchema: getZodSchemaObject(outputSchema),
|
|
annotations,
|
|
execution,
|
|
_meta,
|
|
handler,
|
|
enabled: true,
|
|
disable: () => registeredTool.update({ enabled: false }),
|
|
enable: () => registeredTool.update({ enabled: true }),
|
|
remove: () => registeredTool.update({ name: null }),
|
|
update: (updates) => {
|
|
if (typeof updates.name !== "undefined" && updates.name !== name) {
|
|
if (typeof updates.name === "string") {
|
|
validateAndWarnToolName(updates.name);
|
|
}
|
|
delete this._registeredTools[name];
|
|
if (updates.name)
|
|
this._registeredTools[updates.name] = registeredTool;
|
|
}
|
|
if (typeof updates.title !== "undefined")
|
|
registeredTool.title = updates.title;
|
|
if (typeof updates.description !== "undefined")
|
|
registeredTool.description = updates.description;
|
|
if (typeof updates.paramsSchema !== "undefined")
|
|
registeredTool.inputSchema = objectFromShape(updates.paramsSchema);
|
|
if (typeof updates.callback !== "undefined")
|
|
registeredTool.handler = updates.callback;
|
|
if (typeof updates.annotations !== "undefined")
|
|
registeredTool.annotations = updates.annotations;
|
|
if (typeof updates._meta !== "undefined")
|
|
registeredTool._meta = updates._meta;
|
|
if (typeof updates.enabled !== "undefined")
|
|
registeredTool.enabled = updates.enabled;
|
|
this.sendToolListChanged();
|
|
}
|
|
};
|
|
this._registeredTools[name] = registeredTool;
|
|
this.setToolRequestHandlers();
|
|
this.sendToolListChanged();
|
|
return registeredTool;
|
|
}
|
|
tool(name, ...rest) {
|
|
if (this._registeredTools[name]) {
|
|
throw new Error(`Tool ${name} is already registered`);
|
|
}
|
|
let description;
|
|
let inputSchema;
|
|
let outputSchema;
|
|
let annotations;
|
|
if (typeof rest[0] === "string") {
|
|
description = rest.shift();
|
|
}
|
|
if (rest.length > 1) {
|
|
const firstArg = rest[0];
|
|
if (isZodRawShapeCompat(firstArg)) {
|
|
inputSchema = rest.shift();
|
|
if (rest.length > 1 && typeof rest[0] === "object" && rest[0] !== null && !isZodRawShapeCompat(rest[0])) {
|
|
annotations = rest.shift();
|
|
}
|
|
} else if (typeof firstArg === "object" && firstArg !== null) {
|
|
annotations = rest.shift();
|
|
}
|
|
}
|
|
const callback = rest[0];
|
|
return this._createRegisteredTool(name, undefined, description, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, undefined, callback);
|
|
}
|
|
registerTool(name, config2, cb) {
|
|
if (this._registeredTools[name]) {
|
|
throw new Error(`Tool ${name} is already registered`);
|
|
}
|
|
const { title, description, inputSchema, outputSchema, annotations, _meta } = config2;
|
|
return this._createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, _meta, cb);
|
|
}
|
|
prompt(name, ...rest) {
|
|
if (this._registeredPrompts[name]) {
|
|
throw new Error(`Prompt ${name} is already registered`);
|
|
}
|
|
let description;
|
|
if (typeof rest[0] === "string") {
|
|
description = rest.shift();
|
|
}
|
|
let argsSchema;
|
|
if (rest.length > 1) {
|
|
argsSchema = rest.shift();
|
|
}
|
|
const cb = rest[0];
|
|
const registeredPrompt = this._createRegisteredPrompt(name, undefined, description, argsSchema, cb);
|
|
this.setPromptRequestHandlers();
|
|
this.sendPromptListChanged();
|
|
return registeredPrompt;
|
|
}
|
|
registerPrompt(name, config2, cb) {
|
|
if (this._registeredPrompts[name]) {
|
|
throw new Error(`Prompt ${name} is already registered`);
|
|
}
|
|
const { title, description, argsSchema } = config2;
|
|
const registeredPrompt = this._createRegisteredPrompt(name, title, description, argsSchema, cb);
|
|
this.setPromptRequestHandlers();
|
|
this.sendPromptListChanged();
|
|
return registeredPrompt;
|
|
}
|
|
isConnected() {
|
|
return this.server.transport !== undefined;
|
|
}
|
|
async sendLoggingMessage(params, sessionId) {
|
|
return this.server.sendLoggingMessage(params, sessionId);
|
|
}
|
|
sendResourceListChanged() {
|
|
if (this.isConnected()) {
|
|
this.server.sendResourceListChanged();
|
|
}
|
|
}
|
|
sendToolListChanged() {
|
|
if (this.isConnected()) {
|
|
this.server.sendToolListChanged();
|
|
}
|
|
}
|
|
sendPromptListChanged() {
|
|
if (this.isConnected()) {
|
|
this.server.sendPromptListChanged();
|
|
}
|
|
}
|
|
}
|
|
var EMPTY_OBJECT_JSON_SCHEMA = {
|
|
type: "object",
|
|
properties: {}
|
|
};
|
|
function isZodTypeLike(value) {
|
|
return value !== null && typeof value === "object" && "parse" in value && typeof value.parse === "function" && "safeParse" in value && typeof value.safeParse === "function";
|
|
}
|
|
function isZodSchemaInstance(obj) {
|
|
return "_def" in obj || "_zod" in obj || isZodTypeLike(obj);
|
|
}
|
|
function isZodRawShapeCompat(obj) {
|
|
if (typeof obj !== "object" || obj === null) {
|
|
return false;
|
|
}
|
|
if (isZodSchemaInstance(obj)) {
|
|
return false;
|
|
}
|
|
if (Object.keys(obj).length === 0) {
|
|
return true;
|
|
}
|
|
return Object.values(obj).some(isZodTypeLike);
|
|
}
|
|
function getZodSchemaObject(schema) {
|
|
if (!schema) {
|
|
return;
|
|
}
|
|
if (isZodRawShapeCompat(schema)) {
|
|
return objectFromShape(schema);
|
|
}
|
|
return schema;
|
|
}
|
|
function promptArgumentsFromSchema(schema) {
|
|
const shape = getObjectShape(schema);
|
|
if (!shape)
|
|
return [];
|
|
return Object.entries(shape).map(([name, field]) => {
|
|
const description = getSchemaDescription(field);
|
|
const isOptional = isSchemaOptional(field);
|
|
return {
|
|
name,
|
|
description,
|
|
required: !isOptional
|
|
};
|
|
});
|
|
}
|
|
function getMethodValue(schema) {
|
|
const shape = getObjectShape(schema);
|
|
const methodSchema = shape === null || shape === undefined ? undefined : shape.method;
|
|
if (!methodSchema) {
|
|
throw new Error("Schema is missing a method literal");
|
|
}
|
|
const value = getLiteralValue(methodSchema);
|
|
if (typeof value === "string") {
|
|
return value;
|
|
}
|
|
throw new Error("Schema method literal must be a string");
|
|
}
|
|
function createCompletionResult(suggestions) {
|
|
return {
|
|
completion: {
|
|
values: suggestions.slice(0, 100),
|
|
total: suggestions.length,
|
|
hasMore: suggestions.length > 100
|
|
}
|
|
};
|
|
}
|
|
var EMPTY_COMPLETION_RESULT = {
|
|
completion: {
|
|
values: [],
|
|
hasMore: false
|
|
}
|
|
};
|
|
|
|
// ../src/services/mcp/createSdkMcpServer.ts
|
|
function tool(name, description, inputSchema, handler) {
|
|
return { name, description, inputSchema, handler };
|
|
}
|
|
function createSdkMcpServer(options) {
|
|
const server = new McpServer({
|
|
name: options.name,
|
|
version: options.version ?? "1.0.0"
|
|
}, {
|
|
capabilities: {
|
|
tools: options.tools ? {} : undefined
|
|
}
|
|
});
|
|
if (options.tools) {
|
|
options.tools.forEach((toolDef) => {
|
|
server.tool(toolDef.name, toolDef.description, toolDef.inputSchema, toolDef.handler);
|
|
});
|
|
}
|
|
return {
|
|
type: "sdk",
|
|
name: options.name,
|
|
instance: server
|
|
};
|
|
}
|
|
// ../src/entrypoints/agentSdk.ts
|
|
function query({
|
|
prompt,
|
|
options
|
|
}) {
|
|
const { systemPrompt, settingSources, sandbox, ...rest } = options ?? {};
|
|
let customSystemPrompt;
|
|
let appendSystemPrompt;
|
|
if (systemPrompt === undefined) {
|
|
customSystemPrompt = "";
|
|
} else if (typeof systemPrompt === "string") {
|
|
customSystemPrompt = systemPrompt;
|
|
} else if (systemPrompt.type === "preset") {
|
|
appendSystemPrompt = systemPrompt.append;
|
|
}
|
|
let pathToClaudeCodeExecutable = rest.pathToClaudeCodeExecutable;
|
|
if (!pathToClaudeCodeExecutable) {
|
|
const filename = fileURLToPath2(import.meta.url);
|
|
const dirname2 = join5(filename, "..");
|
|
pathToClaudeCodeExecutable = join5(dirname2, "cli.js");
|
|
}
|
|
process.env.CLAUDE_AGENT_SDK_VERSION = "0.1.77";
|
|
const {
|
|
abortController = createAbortController(),
|
|
additionalDirectories = [],
|
|
agents,
|
|
allowedTools = [],
|
|
betas,
|
|
canUseTool,
|
|
continue: continueConversation,
|
|
cwd: cwd2,
|
|
disallowedTools = [],
|
|
tools,
|
|
env,
|
|
executable = isRunningWithBun() ? "bun" : "node",
|
|
executableArgs = [],
|
|
extraArgs = {},
|
|
fallbackModel,
|
|
enableFileCheckpointing,
|
|
forkSession,
|
|
hooks,
|
|
includePartialMessages,
|
|
persistSession,
|
|
maxThinkingTokens,
|
|
maxTurns,
|
|
maxBudgetUsd,
|
|
mcpServers,
|
|
model,
|
|
outputFormat,
|
|
permissionMode = "default",
|
|
allowDangerouslySkipPermissions = false,
|
|
permissionPromptToolName,
|
|
plugins,
|
|
resume,
|
|
resumeSessionAt,
|
|
stderr,
|
|
strictMcpConfig
|
|
} = rest;
|
|
const jsonSchema = outputFormat?.type === "json_schema" ? outputFormat.schema : undefined;
|
|
let processEnv = env;
|
|
if (!processEnv) {
|
|
processEnv = { ...process.env };
|
|
}
|
|
if (!processEnv.CLAUDE_CODE_ENTRYPOINT) {
|
|
processEnv.CLAUDE_CODE_ENTRYPOINT = "sdk-ts";
|
|
}
|
|
if (enableFileCheckpointing) {
|
|
processEnv.CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING = "true";
|
|
}
|
|
if (!pathToClaudeCodeExecutable) {
|
|
throw new Error("pathToClaudeCodeExecutable is required");
|
|
}
|
|
const allMcpServers = {};
|
|
const sdkMcpServers = new Map;
|
|
if (mcpServers) {
|
|
for (const [name, config2] of Object.entries(mcpServers)) {
|
|
if (config2.type === "sdk" && "instance" in config2) {
|
|
sdkMcpServers.set(name, config2.instance);
|
|
allMcpServers[name] = {
|
|
type: "sdk",
|
|
name
|
|
};
|
|
} else {
|
|
allMcpServers[name] = config2;
|
|
}
|
|
}
|
|
}
|
|
const isSingleUserTurn = typeof prompt === "string";
|
|
const transport = new ProcessTransport({
|
|
abortController,
|
|
additionalDirectories,
|
|
betas,
|
|
cwd: cwd2,
|
|
executable,
|
|
executableArgs,
|
|
extraArgs,
|
|
pathToClaudeCodeExecutable,
|
|
env: processEnv,
|
|
forkSession,
|
|
stderr,
|
|
maxThinkingTokens,
|
|
maxTurns,
|
|
maxBudgetUsd,
|
|
model,
|
|
fallbackModel,
|
|
jsonSchema,
|
|
permissionMode,
|
|
allowDangerouslySkipPermissions,
|
|
permissionPromptToolName,
|
|
continueConversation,
|
|
resume,
|
|
resumeSessionAt,
|
|
settingSources: settingSources ?? [],
|
|
allowedTools,
|
|
disallowedTools,
|
|
tools,
|
|
mcpServers: allMcpServers,
|
|
strictMcpConfig,
|
|
canUseTool: !!canUseTool,
|
|
hooks: !!hooks,
|
|
includePartialMessages,
|
|
persistSession,
|
|
plugins,
|
|
sandbox,
|
|
spawnClaudeCodeProcess: rest.spawnClaudeCodeProcess
|
|
});
|
|
const initConfig = {
|
|
systemPrompt: customSystemPrompt,
|
|
appendSystemPrompt,
|
|
agents
|
|
};
|
|
const queryInstance = new Query(transport, isSingleUserTurn, canUseTool, hooks, abortController, sdkMcpServers, jsonSchema, initConfig);
|
|
if (typeof prompt === "string") {
|
|
transport.write(jsonStringify({
|
|
type: "user",
|
|
session_id: "",
|
|
message: {
|
|
role: "user",
|
|
content: [{ type: "text", text: prompt }]
|
|
},
|
|
parent_tool_use_id: null
|
|
}) + `
|
|
`);
|
|
} else {
|
|
queryInstance.streamInput(prompt);
|
|
}
|
|
return queryInstance;
|
|
}
|
|
function unstable_v2_createSession(options) {
|
|
return createSession(options);
|
|
}
|
|
function unstable_v2_resumeSession(sessionId, options) {
|
|
return resumeSession(sessionId, options);
|
|
}
|
|
async function unstable_v2_prompt(message, options) {
|
|
let __stack = [];
|
|
try {
|
|
const session = __using(__stack, createSession(options), 1);
|
|
await session.send(message);
|
|
for await (const msg of session.stream()) {
|
|
if (msg.type === "result") {
|
|
return msg;
|
|
}
|
|
}
|
|
throw new Error("Session ended without result message");
|
|
} catch (_catch2) {
|
|
var _err = _catch2, _hasErr = 1;
|
|
} finally {
|
|
var _promise = __callDispose(__stack, _err, _hasErr);
|
|
_promise && await _promise;
|
|
}
|
|
}
|
|
export {
|
|
unstable_v2_resumeSession,
|
|
unstable_v2_prompt,
|
|
unstable_v2_createSession,
|
|
tool,
|
|
query,
|
|
createSdkMcpServer,
|
|
HOOK_EVENTS,
|
|
EXIT_REASONS,
|
|
AbortError
|
|
};
|