← Files EvalDossierARCHIVED FILE
runtime/shared/evaldossier-local-core.mjs
460 KB · Oct 5, 2026 · 18:30 UTC
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
try {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
} catch (e) {
throw mod = 0, e;
}
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
// node_modules/ajv/dist/compile/codegen/code.js
var require_code = __commonJS({
"node_modules/ajv/dist/compile/codegen/code.js"(exports) {
"use strict";
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 = void 0;
var _CodeOrName = class {
};
exports._CodeOrName = _CodeOrName;
exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
var Name = class 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;
var _Code = class 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 !== void 0 ? _a : this._str = this._items.reduce((s, c) => `${s}${c}`, "");
}
get names() {
var _a;
return (_a = this._names) !== null && _a !== void 0 ? _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 !== void 0) {
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({
"node_modules/ajv/dist/compile/codegen/scope.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ValueScope = exports.ValueScopeName = exports.Scope = exports.varKinds = exports.UsedValueState = void 0;
var code_1 = require_code();
var ValueError = class 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")
};
var Scope = class {
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 === void 0 ? void 0 : _a._prefixes) === null || _b === void 0 ? void 0 : _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;
var ValueScopeName = class 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`;
var ValueScope = class 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 === void 0)
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 !== void 0 ? _a : value.ref;
let vs = this._values[prefix];
if (vs) {
const _name = vs.get(valueKey);
if (_name)
return _name;
} else {
vs = this._values[prefix] = /* @__PURE__ */ 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 === void 0)
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 === void 0)
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] || /* @__PURE__ */ 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 === void 0 ? void 0 : 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({
"node_modules/ajv/dist/compile/codegen/index.js"(exports) {
"use strict";
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._ = void 0;
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("+")
};
var Node = class {
optimizeNodes() {
return this;
}
optimizeNames(_names, _constants) {
return this;
}
};
var Def = class 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 === void 0 ? "" : ` = ${this.rhs}`;
return `${varKind} ${this.name}${rhs};` + _n;
}
optimizeNames(names, constants3) {
if (!names[this.name.str])
return;
if (this.rhs)
this.rhs = optimizeExpr(this.rhs, names, constants3);
return this;
}
get names() {
return this.rhs instanceof code_1._CodeOrName ? this.rhs.names : {};
}
};
var Assign = class 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, constants3) {
if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
return;
this.rhs = optimizeExpr(this.rhs, names, constants3);
return this;
}
get names() {
const names = this.lhs instanceof code_1.Name ? {} : { ...this.lhs.names };
return addExprNames(names, this.rhs);
}
};
var AssignOp = class extends Assign {
constructor(lhs, op, rhs, sideEffects) {
super(lhs, rhs, sideEffects);
this.op = op;
}
render({ _n }) {
return `${this.lhs} ${this.op}= ${this.rhs};` + _n;
}
};
var Label = class extends Node {
constructor(label) {
super();
this.label = label;
this.names = {};
}
render({ _n }) {
return `${this.label}:` + _n;
}
};
var Break = class extends Node {
constructor(label) {
super();
this.label = label;
this.names = {};
}
render({ _n }) {
const label = this.label ? ` ${this.label}` : "";
return `break${label};` + _n;
}
};
var Throw = class extends Node {
constructor(error) {
super();
this.error = error;
}
render({ _n }) {
return `throw ${this.error};` + _n;
}
get names() {
return this.error.names;
}
};
var AnyCode = class extends Node {
constructor(code) {
super();
this.code = code;
}
render({ _n }) {
return `${this.code};` + _n;
}
optimizeNodes() {
return `${this.code}` ? this : void 0;
}
optimizeNames(names, constants3) {
this.code = optimizeExpr(this.code, names, constants3);
return this;
}
get names() {
return this.code instanceof code_1._CodeOrName ? this.code.names : {};
}
};
var ParentNode = class 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 : void 0;
}
optimizeNames(names, constants3) {
const { nodes } = this;
let i = nodes.length;
while (i--) {
const n = nodes[i];
if (n.optimizeNames(names, constants3))
continue;
subtractNames(names, n.names);
nodes.splice(i, 1);
}
return nodes.length > 0 ? this : void 0;
}
get names() {
return this.nodes.reduce((names, n) => addNames(names, n.names), {});
}
};
var BlockNode = class extends ParentNode {
render(opts) {
return "{" + opts._n + super.render(opts) + "}" + opts._n;
}
};
var Root = class extends ParentNode {
};
var Else = class extends BlockNode {
};
Else.kind = "else";
var If = 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 void 0;
return this;
}
optimizeNames(names, constants3) {
var _a;
this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants3);
if (!(super.optimizeNames(names, constants3) || this.else))
return;
this.condition = optimizeExpr(this.condition, names, constants3);
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";
var For = class extends BlockNode {
};
For.kind = "for";
var ForLoop = class extends For {
constructor(iteration) {
super();
this.iteration = iteration;
}
render(opts) {
return `for(${this.iteration})` + super.render(opts);
}
optimizeNames(names, constants3) {
if (!super.optimizeNames(names, constants3))
return;
this.iteration = optimizeExpr(this.iteration, names, constants3);
return this;
}
get names() {
return addNames(super.names, this.iteration.names);
}
};
var ForRange = class 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);
}
};
var ForIter = class 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, constants3) {
if (!super.optimizeNames(names, constants3))
return;
this.iterable = optimizeExpr(this.iterable, names, constants3);
return this;
}
get names() {
return addNames(super.names, this.iterable.names);
}
};
var Func = class 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";
var Return = class extends ParentNode {
render(opts) {
return "return " + super.render(opts);
}
};
Return.kind = "return";
var Try = class 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 === void 0 ? void 0 : _a.optimizeNodes();
(_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes();
return this;
}
optimizeNames(names, constants3) {
var _a, _b;
super.optimizeNames(names, constants3);
(_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants3);
(_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants3);
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;
}
};
var Catch = class extends BlockNode {
constructor(error) {
super();
this.error = error;
}
render(opts) {
return `catch(${this.error})` + super.render(opts);
}
};
Catch.kind = "catch";
var Finally = class extends BlockNode {
render(opts) {
return "finally" + super.render(opts);
}
};
Finally.kind = "finally";
var CodeGen = class {
constructor(extScope, opts = {}) {
this._values = {};
this._blockStarts = [];
this._constants = {};
this.opts = { ...opts, _n: opts.lines ? "\n" : "" };
this._extScope = extScope;
this._scope = new scope_1.Scope({ parent: extScope });
this._nodes = [new Root()];
}
toString() {
return this._root.render(this.opts);
}
// returns unique name in the internal scope
name(prefix) {
return this._scope.name(prefix);
}
// reserves unique name in the external scope
scopeName(prefix) {
return this._extScope.name(prefix);
}
// reserves unique name in the external scope and assigns value to it
scopeValue(prefixOrName, value) {
const name = this._extScope.value(prefixOrName, value);
const vs = this._values[name.prefix] || (this._values[name.prefix] = /* @__PURE__ */ new Set());
vs.add(name);
return name;
}
getScopeValue(prefix, keyOrRef) {
return this._extScope.getValue(prefix, keyOrRef);
}
// return code that assigns values in the external scope to the names that are used internally
// (same names that were returned by gen.scopeName or gen.scopeValue)
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 !== void 0 && constant)
this._constants[name.str] = rhs;
this._leafNode(new Def(varKind, name, rhs));
return name;
}
// `const` declaration (`var` in es5 mode)
const(nameOrPrefix, rhs, _constant) {
return this._def(scope_1.varKinds.const, nameOrPrefix, rhs, _constant);
}
// `let` declaration with optional assignment (`var` in es5 mode)
let(nameOrPrefix, rhs, _constant) {
return this._def(scope_1.varKinds.let, nameOrPrefix, rhs, _constant);
}
// `var` declaration with optional assignment
var(nameOrPrefix, rhs, _constant) {
return this._def(scope_1.varKinds.var, nameOrPrefix, rhs, _constant);
}
// assignment code
assign(lhs, rhs, sideEffects) {
return this._leafNode(new Assign(lhs, rhs, sideEffects));
}
// `+=` code
add(lhs, rhs) {
return this._leafNode(new AssignOp(lhs, exports.operators.ADD, rhs));
}
// appends passed SafeExpr to code or executes Block
code(c) {
if (typeof c == "function")
c();
else if (c !== code_1.nil)
this._leafNode(new AnyCode(c));
return this;
}
// returns code for object literal for the passed argument list of key-value pairs
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` clause (or statement if `thenBody` and, optionally, `elseBody` are passed)
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;
}
// `else if` clause - invalid without `if` or after `else` clauses
elseIf(condition) {
return this._elseNode(new If(condition));
}
// `else` clause - only valid after `if` or `else if` clauses
else() {
return this._elseNode(new Else());
}
// end `if` statement (needed if gen.if was used only with condition)
endIf() {
return this._endBlockNode(If, Else);
}
_for(node, forBody) {
this._blockNode(node);
if (forBody)
this.code(forBody).endFor();
return this;
}
// a generic `for` clause (or statement if `forBody` is passed)
for(iteration, forBody) {
return this._for(new ForLoop(iteration), forBody);
}
// `for` statement for a range of values
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));
}
// `for-of` statement (in es5 mode replace with a normal for loop)
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));
}
// `for-in` statement.
// With option `ownProperties` replaced with a `for-of` loop for object keys
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));
}
// end `for` loop
endFor() {
return this._endBlockNode(For);
}
// `label` statement
label(label) {
return this._leafNode(new Label(label));
}
// `break` statement
break(label) {
return this._leafNode(new Break(label));
}
// `return` statement
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` statement
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 error = this.name("e");
this._currNode = node.catch = new Catch(error);
catchCode(error);
}
if (finallyCode) {
this._currNode = node.finally = new Finally();
this.code(finallyCode);
}
return this._endBlockNode(Catch, Finally);
}
// `throw` statement
throw(error) {
return this._leafNode(new Throw(error));
}
// start self-balancing block
block(body, nodeCount) {
this._blockStarts.push(this._nodes.length);
if (body)
this.code(body).endBlock(nodeCount);
return this;
}
// end the current self-balancing block
endBlock(nodeCount) {
const len = this._blockStarts.pop();
if (len === void 0)
throw new Error("CodeGen: not in self-balancing block");
const toClose = this._nodes.length - len;
if (toClose < 0 || nodeCount !== void 0 && toClose !== nodeCount) {
throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`);
}
this._nodes.length = len;
return this;
}
// `function` heading (or definition if funcBody is passed)
func(name, args = code_1.nil, async, funcBody) {
this._blockNode(new Func(name, args, async));
if (funcBody)
this.code(funcBody).endFunc();
return this;
}
// end function definition
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, constants3) {
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 = constants3[n.str];
if (c === void 0 || 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 && constants3[c.str] !== void 0);
}
}
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({
"node_modules/ajv/dist/compile/util.js"(exports) {
"use strict";
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 = void 0;
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 } = it;
if (!opts.strictSchema)
return;
if (typeof schema === "boolean")
return;
const rules = self.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, resultToName }) {
return (gen, from, to, toName) => {
const res = to === void 0 ? 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) : mergeValues(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 !== void 0)
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({
"node_modules/ajv/dist/compile/names.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var names = {
// validation function arguments
data: new codegen_1.Name("data"),
// data passed to validation function
// args passed from referencing schema
valCxt: new codegen_1.Name("valCxt"),
// validation/data context - should not be used directly, it is destructured to the names below
instancePath: new codegen_1.Name("instancePath"),
parentData: new codegen_1.Name("parentData"),
parentDataProperty: new codegen_1.Name("parentDataProperty"),
rootData: new codegen_1.Name("rootData"),
// root data - same as the data passed to the first/top validation function
dynamicAnchors: new codegen_1.Name("dynamicAnchors"),
// used to support recursiveRef and dynamicRef
// function scoped variables
vErrors: new codegen_1.Name("vErrors"),
// null or array of validation errors
errors: new codegen_1.Name("errors"),
// counter of validation errors
this: new codegen_1.Name("this"),
// "globals"
self: new codegen_1.Name("self"),
scope: new codegen_1.Name("scope"),
// JTD serialize/parse name for JSON string and position
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({
"node_modules/ajv/dist/compile/errors.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.extendErrors = exports.resetErrorsCount = exports.reportExtraError = exports.reportError = exports.keyword$DataError = exports.keywordError = void 0;
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, error = exports.keywordError, errorPaths, overrideAllErrors) {
const { it } = cxt;
const { gen, compositeRule, allErrors } = it;
const errObj = errorObjectCode(cxt, error, errorPaths);
if (overrideAllErrors !== null && overrideAllErrors !== void 0 ? overrideAllErrors : compositeRule || allErrors) {
addError(gen, errObj);
} else {
returnErrors(it, (0, codegen_1._)`[${errObj}]`);
}
}
exports.reportError = reportError;
function reportExtraError(cxt, error = exports.keywordError, errorPaths) {
const { it } = cxt;
const { gen, compositeRule, allErrors } = it;
const errObj = errorObjectCode(cxt, error, 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 === void 0)
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"),
// also used in JTD errors
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, error, errorPaths) {
const { createErrors } = cxt.it;
if (createErrors === false)
return (0, codegen_1._)`{}`;
return errorObject(cxt, error, errorPaths);
}
function errorObject(cxt, error, errorPaths = {}) {
const { gen, it } = cxt;
const keyValues = [
errorInstancePath(it, errorPaths),
errorSchemaPath(cxt, errorPaths)
];
extraErrorProps(cxt, error, 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({
"node_modules/ajv/dist/compile/validate/boolSchema.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.boolOrEmptySchema = exports.topBoolOrEmptySchema = void 0;
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, void 0, overrideAllErrors);
}
}
});
// node_modules/ajv/dist/compile/rules.js
var require_rules = __commonJS({
"node_modules/ajv/dist/compile/rules.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getRules = exports.isJSONType = void 0;
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({
"node_modules/ajv/dist/compile/validate/applicability.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.shouldUseRule = exports.shouldUseGroup = exports.schemaHasRulesForType = void 0;
function schemaHasRulesForType({ schema, self }, type) {
const group = self.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] !== void 0 || ((_a = rule.definition.implements) === null || _a === void 0 ? void 0 : _a.some((kwd) => schema[kwd] !== void 0));
}
exports.shouldUseRule = shouldUseRule;
}
});
// node_modules/ajv/dist/compile/validate/dataType.js
var require_dataType = __commonJS({
"node_modules/ajv/dist/compile/validate/dataType.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.reportTypeError = exports.checkDataTypes = exports.checkDataType = exports.coerceAndCheckDataType = exports.getJSONTypes = exports.getSchemaTypes = exports.DataType = void 0;
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 !== void 0) {
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 = /* @__PURE__ */ 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({
"node_modules/ajv/dist/compile/validate/defaults.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.assignDefaults = void 0;
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 === void 0)
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({
"node_modules/ajv/dist/vocabularies/code.js"(exports) {
"use strict";
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 = void 0;
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", {
// eslint-disable-next-line @typescript-eslint/unbound-method
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({
"node_modules/ajv/dist/compile/validate/keyword.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateKeywordUsage = exports.validSchemaType = exports.funcKeywordCode = exports.macroKeywordCode = void 0;
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 !== void 0 ? _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(errors) {
var _a2;
gen.if((0, codegen_1.not)((_a2 = def.valid) !== null && _a2 !== void 0 ? _a2 : valid), errors);
}
}
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 === void 0)
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, 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 === void 0 ? void 0 : 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}": ` + self.errorsText(def.validateSchema.errors);
if (opts.validateSchema === "log")
self.logger.error(msg);
else
throw new Error(msg);
}
}
}
exports.validateKeywordUsage = validateKeywordUsage;
}
});
// node_modules/ajv/dist/compile/validate/subschema.js
var require_subschema = __commonJS({
"node_modules/ajv/dist/compile/validate/subschema.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = void 0;
var codegen_1 = require_codegen();
var util_1 = require_util();
function getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {
if (keyword !== void 0 && schema !== void 0) {
throw new Error('both "keyword" and "schema" passed, only one allowed');
}
if (keyword !== void 0) {
const sch = it.schema[keyword];
return schemaProp === void 0 ? {
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 !== void 0) {
if (schemaPath === void 0 || errSchemaPath === void 0 || topSchemaRef === void 0) {
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 !== void 0 && dataProp !== void 0) {
throw new Error('both "data" and "dataProp" passed, only one allowed');
}
const { gen } = it;
if (dataProp !== void 0) {
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 !== void 0) {
const nextData = data instanceof codegen_1.Name ? data : gen.let("data", data, true);
dataContextProps(nextData);
if (propertyName !== void 0)
subschema.propertyName = propertyName;
}
if (dataTypes)
subschema.dataTypes = dataTypes;
function dataContextProps(_nextData) {
subschema.data = _nextData;
subschema.dataLevel = it.dataLevel + 1;
subschema.dataTypes = [];
it.definedProperties = /* @__PURE__ */ new Set();
subschema.parentData = it.data;
subschema.dataNames = [...it.dataNames, _nextData];
}
}
exports.extendSubschemaData = extendSubschemaData;
function extendSubschemaMode(subschema, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }) {
if (compositeRule !== void 0)
subschema.compositeRule = compositeRule;
if (createErrors !== void 0)
subschema.createErrors = createErrors;
if (allErrors !== void 0)
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({
"node_modules/fast-deep-equal/index.js"(exports, module) {
"use strict";
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({
"node_modules/json-schema-traverse/index.js"(exports, module) {
"use strict";
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({
"node_modules/ajv/dist/compile/resolve.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getSchemaRefs = exports.resolveUrl = exports.normalizeId = exports._getFullPath = exports.getFullPath = exports.inlineRef = void 0;
var util_1 = require_util();
var equal = require_fast_deep_equal();
var traverse = require_json_schema_traverse();
var SIMPLE_INLINED = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ new Set();
traverse(schema, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
if (parentJsonPtr === void 0)
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 !== void 0 && !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({
"node_modules/ajv/dist/compile/validate/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getData = exports.KeywordCxt = exports.validateFunctionCode = void 0;
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 }) {
if (typeof schema == "boolean")
return !schema;
for (const key in schema)
if (self.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 } = it;
if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema, self.RULES)) {
self.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
}
}
function checkNoDefault(it) {
const { schema, opts } = it;
if (schema.default !== void 0 && 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 } = it;
const { RULES } = self;
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);
}
var KeywordCxt = class {
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), void 0, failAction);
}
fail(condition) {
if (condition === void 0) {
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 === void 0)
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: void 0, props: void 0 };
subschemaCode(nextContext, valid);
return nextContext;
}
mergeEvaluated(schemaCxt, toName) {
const { it, gen } = this;
if (!it.opts.unevaluated)
return;
if (it.props !== true && schemaCxt.props !== void 0) {
it.props = util_1.mergeEvaluated.props(gen, schemaCxt.props, it.props, toName);
}
if (it.items !== true && schemaCxt.items !== void 0) {
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({
"node_modules/ajv/dist/runtime/validation_error.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ValidationError = class extends Error {
constructor(errors) {
super("validation failed");
this.errors = errors;
this.ajv = this.validation = true;
}
};
exports.default = ValidationError;
}
});
// node_modules/ajv/dist/compile/ref_error.js
var require_ref_error = __commonJS({
"node_modules/ajv/dist/compile/ref_error.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var resolve_1 = require_resolve();
var MissingRefError = class 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({
"node_modules/ajv/dist/compile/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.resolveSchema = exports.getCompilingSchema = exports.resolveRef = exports.compileSchema = exports.SchemaEnv = void 0;
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();
var SchemaEnv = class {
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 !== void 0 ? _a : (0, resolve_1.normalizeId)(schema === null || schema === void 0 ? void 0 : schema[env.schemaId || "$id"]);
this.schemaPath = env.schemaPath;
this.localRefs = env.localRefs;
this.meta = env.meta;
this.$async = schema === null || schema === void 0 ? void 0 : 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],
// TODO can its length be used as dataLevel if nil is removed?
dataLevel: 0,
dataTypes: [],
definedProperties: /* @__PURE__ */ 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 ? void 0 : props,
items: items instanceof codegen_1.Name ? void 0 : 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(root, baseId, ref) {
var _a;
ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
const schOrFunc = root.refs[ref];
if (schOrFunc)
return schOrFunc;
let _sch = resolve5.call(this, root, ref);
if (_sch === void 0) {
const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
const { schemaId } = this.opts;
if (schema)
_sch = new SchemaEnv({ schema, schemaId, root, baseId });
}
if (_sch === void 0)
return;
return root.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 resolve5(root, ref) {
let sch;
while (typeof (sch = this.refs[ref]) == "string")
ref = sch;
return sch || this.schemas[ref] || resolveSchema.call(this, root, ref);
}
function resolveSchema(root, 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, root.baseId, void 0);
if (Object.keys(root.schema).length > 0 && refPath === baseId) {
return getJsonPointer.call(this, p, root);
}
const id = (0, resolve_1.normalizeId)(refPath);
const schOrRef = this.refs[id] || this.schemas[id];
if (typeof schOrRef == "string") {
const sch = resolveSchema.call(this, root, schOrRef);
if (typeof (sch === null || sch === void 0 ? void 0 : sch.schema) !== "object")
return;
return getJsonPointer.call(this, p, sch);
}
if (typeof (schOrRef === null || schOrRef === void 0 ? void 0 : 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, baseId });
}
return getJsonPointer.call(this, p, schOrRef);
}
exports.resolveSchema = resolveSchema;
var PREVENT_SCOPE_CHANGE = /* @__PURE__ */ new Set([
"properties",
"patternProperties",
"enum",
"dependencies",
"definitions"
]);
function getJsonPointer(parsedRef, { baseId, schema, root }) {
var _a;
if (((_a = parsedRef.fragment) === null || _a === void 0 ? void 0 : _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 === void 0)
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, root, $ref);
}
const { schemaId } = this.opts;
env = env || new SchemaEnv({ schema, schemaId, root, baseId });
if (env.schema !== env.root.schema)
return env;
return void 0;
}
}
});
// node_modules/ajv/dist/refs/data.json
var require_data = __commonJS({
"node_modules/ajv/dist/refs/data.json"(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/utils.js
var require_utils = __commonJS({
"node_modules/fast-uri/lib/utils.js"(exports, module) {
"use strict";
var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
var isIPv4 = RegExp.prototype.test.bind(/^(?:(?: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);
var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
function stringArrayToHexStripped(input) {
let acc = "";
let code = 0;
let i = 0;
for (i = 0; i < input.length; i++) {
code = input[i].charCodeAt(0);
if (code === 48) {
continue;
}
if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) {
return "";
}
acc += input[i];
break;
}
for (i += 1; i < input.length; i++) {
code = input[i].charCodeAt(0);
if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) {
return "";
}
acc += input[i];
}
return acc;
}
var nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
function consumeIsZone(buffer) {
buffer.length = 0;
return true;
}
function consumeHextets(buffer, address, output) {
if (buffer.length) {
const hex = stringArrayToHexStripped(buffer);
if (hex !== "") {
address.push(hex);
} else {
output.error = true;
return false;
}
buffer.length = 0;
}
return true;
}
function getIPV6(input) {
let tokenCount = 0;
const output = { error: false, address: "", zone: "" };
const address = [];
const buffer = [];
let endipv6Encountered = false;
let endIpv6 = false;
let consume = consumeHextets;
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(buffer, address, output)) {
break;
}
if (++tokenCount > 7) {
output.error = true;
break;
}
if (i > 0 && input[i - 1] === ":") {
endipv6Encountered = true;
}
address.push(":");
continue;
} else if (cursor === "%") {
if (!consume(buffer, address, output)) {
break;
}
consume = consumeIsZone;
} else {
buffer.push(cursor);
continue;
}
}
if (buffer.length) {
if (consume === consumeIsZone) {
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 ipv6 = getIPV6(host);
if (!ipv6.error) {
let newHost = ipv6.address;
let escapedHost = ipv6.address;
if (ipv6.zone) {
newHost += "%" + ipv6.zone;
escapedHost += "%25" + ipv6.zone;
}
return { host: newHost, isIPV6: true, escapedHost };
} else {
return { host, isIPV6: false };
}
}
function findToken(str, token) {
let ind = 0;
for (let i = 0; i < str.length; i++) {
if (str[i] === token) ind++;
}
return ind;
}
function removeDotSegments(path) {
let input = path;
const output = [];
let nextSlash = -1;
let len = 0;
while (len = input.length) {
if (len === 1) {
if (input === ".") {
break;
} else if (input === "/") {
output.push("/");
break;
} else {
output.push(input);
break;
}
} else if (len === 2) {
if (input[0] === ".") {
if (input[1] === ".") {
break;
} else if (input[1] === "/") {
input = input.slice(2);
continue;
}
} else if (input[0] === "/") {
if (input[1] === "." || input[1] === "/") {
output.push("/");
break;
}
}
} else if (len === 3) {
if (input === "/..") {
if (output.length !== 0) {
output.pop();
}
output.push("/");
break;
}
}
if (input[0] === ".") {
if (input[1] === ".") {
if (input[2] === "/") {
input = input.slice(3);
continue;
}
} else if (input[1] === "/") {
input = input.slice(2);
continue;
}
} else if (input[0] === "/") {
if (input[1] === ".") {
if (input[2] === "/") {
input = input.slice(2);
continue;
} else if (input[2] === ".") {
if (input[3] === "/") {
input = input.slice(3);
if (output.length !== 0) {
output.pop();
}
continue;
}
}
}
}
if ((nextSlash = input.indexOf("/", 1)) === -1) {
output.push(input);
break;
} else {
output.push(input.slice(0, nextSlash));
input = input.slice(nextSlash);
}
}
return output.join("");
}
var HOST_DELIMS = { "@": "%40", "/": "%2F", "?": "%3F", "#": "%23", ":": "%3A" };
var HOST_DELIM_RE = /[@/?#:]/g;
var HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
function reescapeHostDelimiters(host, isIP) {
const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
re.lastIndex = 0;
return host.replace(re, (ch) => HOST_DELIMS[ch]);
}
function normalizePercentEncoding(input, decodeUnreserved = false) {
if (input.indexOf("%") === -1) {
return input;
}
let output = "";
for (let i = 0; i < input.length; i++) {
if (input[i] === "%" && i + 2 < input.length) {
const hex = input.slice(i + 1, i + 3);
if (isHexPair(hex)) {
const normalizedHex = hex.toUpperCase();
const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
if (decodeUnreserved && isUnreserved(decoded)) {
output += decoded;
} else {
output += "%" + normalizedHex;
}
i += 2;
continue;
}
}
output += input[i];
}
return output;
}
function normalizePathEncoding(input) {
let output = "";
for (let i = 0; i < input.length; i++) {
if (input[i] === "%" && i + 2 < input.length) {
const hex = input.slice(i + 1, i + 3);
if (isHexPair(hex)) {
const normalizedHex = hex.toUpperCase();
const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
if (decoded !== "." && isUnreserved(decoded)) {
output += decoded;
} else {
output += "%" + normalizedHex;
}
i += 2;
continue;
}
}
if (isPathCharacter(input[i])) {
output += input[i];
} else {
output += escape(input[i]);
}
}
return output;
}
function escapePreservingEscapes(input) {
let output = "";
for (let i = 0; i < input.length; i++) {
if (input[i] === "%" && i + 2 < input.length) {
const hex = input.slice(i + 1, i + 3);
if (isHexPair(hex)) {
output += "%" + hex.toUpperCase();
i += 2;
continue;
}
}
output += escape(input[i]);
}
return output;
}
function recomposeAuthority(component) {
const uriTokens = [];
if (component.userinfo !== void 0) {
uriTokens.push(component.userinfo);
uriTokens.push("@");
}
if (component.host !== void 0) {
let host = unescape(component.host);
if (!isIPv4(host)) {
const ipV6res = normalizeIPv6(host);
if (ipV6res.isIPV6 === true) {
host = `[${ipV6res.escapedHost}]`;
} else {
host = reescapeHostDelimiters(host, false);
}
}
uriTokens.push(host);
}
if (typeof component.port === "number" || typeof component.port === "string") {
uriTokens.push(":");
uriTokens.push(String(component.port));
}
return uriTokens.length ? uriTokens.join("") : void 0;
}
module.exports = {
nonSimpleDomain,
recomposeAuthority,
reescapeHostDelimiters,
normalizePercentEncoding,
normalizePathEncoding,
escapePreservingEscapes,
removeDotSegments,
isIPv4,
isUUID,
normalizeIPv6,
stringArrayToHexStripped
};
}
});
// node_modules/fast-uri/lib/schemes.js
var require_schemes = __commonJS({
"node_modules/fast-uri/lib/schemes.js"(exports, module) {
"use strict";
var { isUUID } = require_utils();
var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
var supportedSchemeNames = (
/** @type {const} */
[
"http",
"https",
"ws",
"wss",
"urn",
"urn:uuid"
]
);
function isValidSchemeName(name) {
return supportedSchemeNames.indexOf(
/** @type {*} */
name
) !== -1;
}
function wsIsSecure(wsComponent) {
if (wsComponent.secure === true) {
return true;
} else if (wsComponent.secure === false) {
return false;
} else if (wsComponent.scheme) {
return wsComponent.scheme.length === 3 && (wsComponent.scheme[0] === "w" || wsComponent.scheme[0] === "W") && (wsComponent.scheme[1] === "s" || wsComponent.scheme[1] === "S") && (wsComponent.scheme[2] === "s" || wsComponent.scheme[2] === "S");
} else {
return false;
}
}
function httpParse(component) {
if (!component.host) {
component.error = component.error || "HTTP URIs must have a host.";
}
return component;
}
function httpSerialize(component) {
const secure = String(component.scheme).toLowerCase() === "https";
if (component.port === (secure ? 443 : 80) || component.port === "") {
component.port = void 0;
}
if (!component.path) {
component.path = "/";
}
return component;
}
function wsParse(wsComponent) {
wsComponent.secure = wsIsSecure(wsComponent);
wsComponent.resourceName = (wsComponent.path || "/") + (wsComponent.query ? "?" + wsComponent.query : "");
wsComponent.path = void 0;
wsComponent.query = void 0;
return wsComponent;
}
function wsSerialize(wsComponent) {
if (wsComponent.port === (wsIsSecure(wsComponent) ? 443 : 80) || wsComponent.port === "") {
wsComponent.port = void 0;
}
if (typeof wsComponent.secure === "boolean") {
wsComponent.scheme = wsComponent.secure ? "wss" : "ws";
wsComponent.secure = void 0;
}
if (wsComponent.resourceName) {
const [path, query] = wsComponent.resourceName.split("?");
wsComponent.path = path && path !== "/" ? path : void 0;
wsComponent.query = query;
wsComponent.resourceName = void 0;
}
wsComponent.fragment = void 0;
return wsComponent;
}
function urnParse(urnComponent, options) {
if (!urnComponent.path) {
urnComponent.error = "URN can not be parsed";
return urnComponent;
}
const matches = urnComponent.path.match(URN_REG);
if (matches) {
const scheme = options.scheme || urnComponent.scheme || "urn";
urnComponent.nid = matches[1].toLowerCase();
urnComponent.nss = matches[2];
const urnScheme = `${scheme}:${options.nid || urnComponent.nid}`;
const schemeHandler = getSchemeHandler(urnScheme);
urnComponent.path = void 0;
if (schemeHandler) {
urnComponent = schemeHandler.parse(urnComponent, options);
}
} else {
urnComponent.error = urnComponent.error || "URN can not be parsed.";
}
return urnComponent;
}
function urnSerialize(urnComponent, options) {
if (urnComponent.nid === void 0) {
throw new Error("URN without nid cannot be serialized");
}
const scheme = options.scheme || urnComponent.scheme || "urn";
const nid = urnComponent.nid.toLowerCase();
const urnScheme = `${scheme}:${options.nid || nid}`;
const schemeHandler = getSchemeHandler(urnScheme);
if (schemeHandler) {
urnComponent = schemeHandler.serialize(urnComponent, options);
}
const uriComponent = urnComponent;
const nss = urnComponent.nss;
uriComponent.path = `${nid || options.nid}:${nss}`;
options.skipEscape = true;
return uriComponent;
}
function urnuuidParse(urnComponent, options) {
const uuidComponent = urnComponent;
uuidComponent.uuid = uuidComponent.nss;
uuidComponent.nss = void 0;
if (!options.tolerant && (!uuidComponent.uuid || !isUUID(uuidComponent.uuid))) {
uuidComponent.error = uuidComponent.error || "UUID is not valid.";
}
return uuidComponent;
}
function urnuuidSerialize(uuidComponent) {
const urnComponent = uuidComponent;
urnComponent.nss = (uuidComponent.uuid || "").toLowerCase();
return urnComponent;
}
var http = (
/** @type {SchemeHandler} */
{
scheme: "http",
domainHost: true,
parse: httpParse,
serialize: httpSerialize
}
);
var https = (
/** @type {SchemeHandler} */
{
scheme: "https",
domainHost: http.domainHost,
parse: httpParse,
serialize: httpSerialize
}
);
var ws = (
/** @type {SchemeHandler} */
{
scheme: "ws",
domainHost: true,
parse: wsParse,
serialize: wsSerialize
}
);
var wss = (
/** @type {SchemeHandler} */
{
scheme: "wss",
domainHost: ws.domainHost,
parse: ws.parse,
serialize: ws.serialize
}
);
var urn = (
/** @type {SchemeHandler} */
{
scheme: "urn",
parse: urnParse,
serialize: urnSerialize,
skipNormalize: true
}
);
var urnuuid = (
/** @type {SchemeHandler} */
{
scheme: "urn:uuid",
parse: urnuuidParse,
serialize: urnuuidSerialize,
skipNormalize: true
}
);
var SCHEMES = (
/** @type {Record<SchemeName, SchemeHandler>} */
{
http,
https,
ws,
wss,
urn,
"urn:uuid": urnuuid
}
);
Object.setPrototypeOf(SCHEMES, null);
function getSchemeHandler(scheme) {
return scheme && (SCHEMES[
/** @type {SchemeName} */
scheme
] || SCHEMES[
/** @type {SchemeName} */
scheme.toLowerCase()
]) || void 0;
}
module.exports = {
wsIsSecure,
SCHEMES,
isValidSchemeName,
getSchemeHandler
};
}
});
// node_modules/fast-uri/index.js
var require_fast_uri = __commonJS({
"node_modules/fast-uri/index.js"(exports, module) {
"use strict";
var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
var { SCHEMES, getSchemeHandler } = require_schemes();
function normalize(uri, options) {
if (typeof uri === "string") {
uri = /** @type {T} */
normalizeString(uri, options);
} else if (typeof uri === "object") {
uri = /** @type {T} */
parse2(serialize(uri, options), options);
}
return uri;
}
function resolve5(baseURI, relativeURI, options) {
const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
const resolved = resolveComponent(parse2(baseURI, schemelessOptions), parse2(relativeURI, schemelessOptions), schemelessOptions, true);
schemelessOptions.skipEscape = true;
return serialize(resolved, schemelessOptions);
}
function resolveComponent(base, relative3, options, skipNormalization) {
const target = {};
if (!skipNormalization) {
base = parse2(serialize(base, options), options);
relative3 = parse2(serialize(relative3, options), options);
}
options = options || {};
if (!options.tolerant && relative3.scheme) {
target.scheme = relative3.scheme;
target.userinfo = relative3.userinfo;
target.host = relative3.host;
target.port = relative3.port;
target.path = removeDotSegments(relative3.path || "");
target.query = relative3.query;
} else {
if (relative3.userinfo !== void 0 || relative3.host !== void 0 || relative3.port !== void 0) {
target.userinfo = relative3.userinfo;
target.host = relative3.host;
target.port = relative3.port;
target.path = removeDotSegments(relative3.path || "");
target.query = relative3.query;
} else {
if (!relative3.path) {
target.path = base.path;
if (relative3.query !== void 0) {
target.query = relative3.query;
} else {
target.query = base.query;
}
} else {
if (relative3.path[0] === "/") {
target.path = removeDotSegments(relative3.path);
} else {
if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
target.path = "/" + relative3.path;
} else if (!base.path) {
target.path = relative3.path;
} else {
target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative3.path;
}
target.path = removeDotSegments(target.path);
}
target.query = relative3.query;
}
target.userinfo = base.userinfo;
target.host = base.host;
target.port = base.port;
}
target.scheme = base.scheme;
}
target.fragment = relative3.fragment;
return target;
}
function equal(uriA, uriB, options) {
const normalizedA = normalizeComparableURI(uriA, options);
const normalizedB = normalizeComparableURI(uriB, options);
return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
}
function serialize(cmpts, opts) {
const component = {
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 = getSchemeHandler(options.scheme || component.scheme);
if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
if (component.path !== void 0) {
if (!options.skipEscape) {
component.path = escapePreservingEscapes(component.path);
if (component.scheme !== void 0) {
component.path = component.path.split("%3A").join(":");
}
} else {
component.path = normalizePercentEncoding(component.path);
}
}
if (options.reference !== "suffix" && component.scheme) {
uriTokens.push(component.scheme, ":");
}
const authority = recomposeAuthority(component);
if (authority !== void 0) {
if (options.reference !== "suffix") {
uriTokens.push("//");
}
uriTokens.push(authority);
if (component.path && component.path[0] !== "/") {
uriTokens.push("/");
}
}
if (component.path !== void 0) {
let s = component.path;
if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
s = removeDotSegments(s);
}
if (authority === void 0 && s[0] === "/" && s[1] === "/") {
s = "/%2F" + s.slice(2);
}
uriTokens.push(s);
}
if (component.query !== void 0) {
uriTokens.push("?", component.query);
}
if (component.fragment !== void 0) {
uriTokens.push("#", component.fragment);
}
return uriTokens.join("");
}
var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
var AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
function getParseError(parsed, matches) {
if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
return 'URI path must start with "/" when authority is present.';
}
if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) {
return "URI port is malformed.";
}
return void 0;
}
function parseWithStatus(uri, opts) {
const options = Object.assign({}, opts);
const parsed = {
scheme: void 0,
userinfo: void 0,
host: "",
port: void 0,
path: "",
query: void 0,
fragment: void 0
};
let malformedAuthorityOrPort = false;
let isIP = false;
if (options.reference === "suffix") {
if (options.scheme) {
uri = options.scheme + ":" + uri;
} else {
uri = "//" + uri;
}
}
const authorityMatch = uri.match(AUTHORITY_PREFIX);
if (authorityMatch !== null && authorityMatch[1].indexOf("\\") !== -1) {
parsed.error = "URI authority must not contain a literal backslash.";
malformedAuthorityOrPort = true;
}
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];
}
const parseError = getParseError(parsed, matches);
if (parseError !== void 0) {
parsed.error = parsed.error || parseError;
malformedAuthorityOrPort = true;
}
if (parsed.host) {
const ipv4result = isIPv4(parsed.host);
if (ipv4result === false) {
const ipv6result = normalizeIPv6(parsed.host);
parsed.host = ipv6result.host.toLowerCase();
isIP = ipv6result.isIPV6;
} else {
isIP = true;
}
}
if (parsed.scheme === void 0 && parsed.userinfo === void 0 && parsed.host === void 0 && parsed.port === void 0 && parsed.query === void 0 && !parsed.path) {
parsed.reference = "same-document";
} else if (parsed.scheme === void 0) {
parsed.reference = "relative";
} else if (parsed.fragment === void 0) {
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 = getSchemeHandler(options.scheme || parsed.scheme);
if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
try {
parsed.host = new URL("http://" + parsed.host).hostname;
} catch (e) {
parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
}
}
}
if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
if (uri.indexOf("%") !== -1) {
if (parsed.scheme !== void 0) {
parsed.scheme = unescape(parsed.scheme);
}
if (parsed.host !== void 0) {
parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
}
}
if (parsed.path) {
parsed.path = normalizePathEncoding(parsed.path);
}
if (parsed.fragment) {
try {
parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
} catch {
parsed.error = parsed.error || "URI malformed";
}
}
}
if (schemeHandler && schemeHandler.parse) {
schemeHandler.parse(parsed, options);
}
} else {
parsed.error = parsed.error || "URI can not be parsed.";
}
return { parsed, malformedAuthorityOrPort };
}
function parse2(uri, opts) {
return parseWithStatus(uri, opts).parsed;
}
function normalizeString(uri, opts) {
return normalizeStringWithStatus(uri, opts).normalized;
}
function normalizeStringWithStatus(uri, opts) {
const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
return {
normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
malformedAuthorityOrPort
};
}
function normalizeComparableURI(uri, opts) {
if (typeof uri === "string") {
const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
return malformedAuthorityOrPort ? void 0 : normalized;
}
if (typeof uri === "object") {
return serialize(uri, opts);
}
}
var fastUri = {
SCHEMES,
normalize,
resolve: resolve5,
resolveComponent,
equal,
serialize,
parse: parse2
};
module.exports = fastUri;
module.exports.default = fastUri;
module.exports.fastUri = fastUri;
}
});
// node_modules/ajv/dist/runtime/uri.js
var require_uri = __commonJS({
"node_modules/ajv/dist/runtime/uri.js"(exports) {
"use strict";
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({
"node_modules/ajv/dist/core.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = void 0;
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 = /* @__PURE__ */ 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 === void 0 ? void 0 : _a.optimize;
const optimize = _optz === true || _optz === void 0 ? 1 : _optz || 0;
const regExp = (_c = (_b = o.code) === null || _b === void 0 ? void 0 : _b.regExp) !== null && _c !== void 0 ? _c : defaultRegExp;
const uriResolver = (_d = o.uriResolver) !== null && _d !== void 0 ? _d : uri_1.default;
return {
strictSchema: (_f = (_e = o.strictSchema) !== null && _e !== void 0 ? _e : s) !== null && _f !== void 0 ? _f : true,
strictNumbers: (_h = (_g = o.strictNumbers) !== null && _g !== void 0 ? _g : s) !== null && _h !== void 0 ? _h : true,
strictTypes: (_k = (_j = o.strictTypes) !== null && _j !== void 0 ? _j : s) !== null && _k !== void 0 ? _k : "log",
strictTuples: (_m = (_l = o.strictTuples) !== null && _l !== void 0 ? _l : s) !== null && _m !== void 0 ? _m : "log",
strictRequired: (_p = (_o = o.strictRequired) !== null && _o !== void 0 ? _o : s) !== null && _p !== void 0 ? _p : false,
code: o.code ? { ...o.code, optimize, regExp } : { optimize, regExp },
loopRequired: (_q = o.loopRequired) !== null && _q !== void 0 ? _q : MAX_EXPRESSION,
loopEnum: (_r = o.loopEnum) !== null && _r !== void 0 ? _r : MAX_EXPRESSION,
meta: (_s = o.meta) !== null && _s !== void 0 ? _s : true,
messages: (_t = o.messages) !== null && _t !== void 0 ? _t : true,
inlineRefs: (_u = o.inlineRefs) !== null && _u !== void 0 ? _u : true,
schemaId: (_v = o.schemaId) !== null && _v !== void 0 ? _v : "$id",
addUsedSchema: (_w = o.addUsedSchema) !== null && _w !== void 0 ? _w : true,
validateSchema: (_x = o.validateSchema) !== null && _x !== void 0 ? _x : true,
validateFormats: (_y = o.validateFormats) !== null && _y !== void 0 ? _y : true,
unicodeRegExp: (_z = o.unicodeRegExp) !== null && _z !== void 0 ? _z : true,
int32range: (_0 = o.int32range) !== null && _0 !== void 0 ? _0 : true,
uriResolver
};
}
var Ajv = class {
constructor(opts = {}) {
this.schemas = {};
this.refs = {};
this.formats = /* @__PURE__ */ Object.create(null);
this._compilations = /* @__PURE__ */ new Set();
this._loading = {};
this._cache = /* @__PURE__ */ 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 : void 0;
}
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];
}
}
}
// Adds schema to the instance
addSchema(schema, key, _meta, _validateSchema = this.opts.validateSchema) {
if (Array.isArray(schema)) {
for (const sch of schema)
this.addSchema(sch, void 0, _meta, _validateSchema);
return this;
}
let id;
if (typeof schema === "object") {
const { schemaId } = this.opts;
id = schema[schemaId];
if (id !== void 0 && 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;
}
// Add schema that will be used to validate other schemas
// options in META_IGNORE_OPTIONS are alway set to false
addMetaSchema(schema, key, _validateSchema = this.opts.validateSchema) {
this.addSchema(schema, key, true, _validateSchema);
return this;
}
// Validate schema against its meta-schema
validateSchema(schema, throwOrLogError) {
if (typeof schema == "boolean")
return true;
let $schema;
$schema = schema.$schema;
if ($schema !== void 0 && 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;
}
// Get compiled schema by `key` or `ref`.
// (`key` that was passed to `addSchema` or full schema reference - `schema.$id` or resolved id)
getSchema(keyRef) {
let sch;
while (typeof (sch = getSchEnv.call(this, keyRef)) == "string")
keyRef = sch;
if (sch === void 0) {
const { schemaId } = this.opts;
const root = new compile_1.SchemaEnv({ schema: {}, schemaId });
sch = compile_1.resolveSchema.call(this, root, keyRef);
if (!sch)
return;
this.refs[keyRef] = sch;
}
return sch.validate || this._compileSchemaEnv(sch);
}
// Remove cached schema(s).
// If no parameter is passed all schemas but meta-schemas are removed.
// If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed.
// Even if schema is referenced by other schemas it still can be removed as other schemas have local references.
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");
}
}
// add "vocabulary" - a collection of keywords
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 === void 0) {
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;
}
// Remove keyword
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;
}
// Add format
addFormat(name, format2) {
if (typeof format2 == "string")
format2 = new RegExp(format2);
this.formats[name] = format2;
return this;
}
errorsText(errors = this.errors, { separator = ", ", dataVar = "data" } = {}) {
if (!errors || errors.length === 0)
return "No errors";
return errors.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(schemas, regex) {
for (const keyRef in schemas) {
const sch = schemas[keyRef];
if (!regex || regex.test(keyRef)) {
if (typeof sch == "string") {
delete schemas[keyRef];
} else if (sch && !sch.meta) {
this._cache.delete(sch.schema);
delete schemas[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 !== void 0)
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 format2 = this.opts.formats[name];
if (format2)
this.addFormat(name, format2);
}
}
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 === void 0)
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 === void 0 ? void 0 : 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 === void 0 ? void 0 : _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 === void 0)
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({
"node_modules/ajv/dist/vocabularies/core/id.js"(exports) {
"use strict";
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({
"node_modules/ajv/dist/vocabularies/core/ref.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.callRef = exports.getValidate = void 0;
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 } = it;
const { root } = env;
if (($ref === "#" || $ref === "#/") && baseId === root.baseId)
return callRootRef();
const schOrEnv = compile_1.resolveRef.call(self, root, baseId, $ref);
if (schOrEnv === void 0)
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 === root)
return callRef(cxt, validateName, env, env.$async);
const rootName = gen.scopeValue("root", { ref: root });
return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root, root.$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 === void 0 ? void 0 : sch.validate) === null || _a === void 0 ? void 0 : _a.evaluated;
if (it.props !== true) {
if (schEvaluated && !schEvaluated.dynamicProps) {
if (schEvaluated.props !== void 0) {
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 !== void 0) {
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({
"node_modules/ajv/dist/vocabularies/core/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var id_1 = require_id();
var ref_1 = require_ref();
var core = [
"$schema",
"$id",
"$defs",
"$vocabulary",
{ keyword: "$comment" },
"definitions",
id_1.default,
ref_1.default
];
exports.default = core;
}
});
// node_modules/ajv/dist/vocabularies/validation/limitNumber.js
var require_limitNumber = __commonJS({
"node_modules/ajv/dist/vocabularies/validation/limitNumber.js"(exports) {
"use strict";
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 error = {
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,
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({
"node_modules/ajv/dist/vocabularies/validation/multipleOf.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var error = {
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,
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({
"node_modules/ajv/dist/runtime/ucs2length.js"(exports) {
"use strict";
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({
"node_modules/ajv/dist/vocabularies/validation/limitLength.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var ucs2length_1 = require_ucs2length();
var error = {
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,
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({
"node_modules/ajv/dist/vocabularies/validation/pattern.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var code_1 = require_code2();
var util_1 = require_util();
var codegen_1 = require_codegen();
var error = {
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,
code(cxt) {
const { gen, data, $data, schema, schemaCode, it } = cxt;
const u = it.opts.unicodeRegExp ? "u" : "";
if ($data) {
const { regExp } = it.opts.code;
const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1._)`new RegExp` : (0, util_1.useFunc)(gen, regExp);
const valid = gen.let("valid");
gen.try(() => gen.assign(valid, (0, codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
cxt.fail$data((0, codegen_1._)`!${valid}`);
} else {
const regExp = (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({
"node_modules/ajv/dist/vocabularies/validation/limitProperties.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var error = {
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,
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({
"node_modules/ajv/dist/vocabularies/validation/required.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var code_1 = require_code2();
var codegen_1 = require_codegen();
var util_1 = require_util();
var error = {
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,
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 === void 0 ? void 0 : props[requiredKey]) === void 0 && !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({
"node_modules/ajv/dist/vocabularies/validation/limitItems.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var error = {
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,
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({
"node_modules/ajv/dist/runtime/equal.js"(exports) {
"use strict";
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({
"node_modules/ajv/dist/vocabularies/validation/uniqueItems.js"(exports) {
"use strict";
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 error = {
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,
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({
"node_modules/ajv/dist/vocabularies/validation/const.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var equal_1 = require_equal();
var error = {
message: "must be equal to constant",
params: ({ schemaCode }) => (0, codegen_1._)`{allowedValue: ${schemaCode}}`
};
var def = {
keyword: "const",
$data: true,
error,
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({
"node_modules/ajv/dist/vocabularies/validation/enum.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var equal_1 = require_equal();
var error = {
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,
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 !== void 0 ? 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({
"node_modules/ajv/dist/vocabularies/validation/index.js"(exports) {
"use strict";
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 = [
// number
limitNumber_1.default,
multipleOf_1.default,
// string
limitLength_1.default,
pattern_1.default,
// object
limitProperties_1.default,
required_1.default,
// array
limitItems_1.default,
uniqueItems_1.default,
// any
{ 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({
"node_modules/ajv/dist/vocabularies/applicator/additionalItems.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateAdditionalItems = void 0;
var codegen_1 = require_codegen();
var util_1 = require_util();
var error = {
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,
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({
"node_modules/ajv/dist/vocabularies/applicator/items.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateTuple = void 0;
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({
"node_modules/ajv/dist/vocabularies/applicator/prefixItems.js"(exports) {
"use strict";
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({
"node_modules/ajv/dist/vocabularies/applicator/items2020.js"(exports) {
"use strict";
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 error = {
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,
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({
"node_modules/ajv/dist/vocabularies/applicator/contains.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var error = {
message: ({ params: { min, max } }) => max === void 0 ? (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 === void 0 ? (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,
code(cxt) {
const { gen, schema, parentSchema, data, it } = cxt;
let min;
let max;
const { minContains, maxContains } = parentSchema;
if (it.opts.next) {
min = minContains === void 0 ? 1 : minContains;
max = maxContains;
} else {
min = 1;
}
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
cxt.setParams({ min, max });
if (max === void 0 && min === 0) {
(0, util_1.checkStrictMode)(it, `"minContains" == 0 without "maxContains": "contains" keyword ignored`);
return;
}
if (max !== void 0 && 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 !== void 0)
cond = (0, codegen_1._)`${cond} && ${len} <= ${max}`;
cxt.pass(cond);
return;
}
it.items = true;
const valid = gen.name("valid");
if (max === void 0 && min === 1) {
validateItems(valid, () => gen.if(valid, () => gen.break()));
} else if (min === 0) {
gen.let(valid, true);
if (max !== void 0)
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 === void 0) {
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({
"node_modules/ajv/dist/vocabularies/applicator/dependencies.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = void 0;
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}}`
// TODO change to reference
};
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)
// TODO var
);
cxt.ok(valid);
}
}
exports.validateSchemaDeps = validateSchemaDeps;
exports.default = def;
}
});
// node_modules/ajv/dist/vocabularies/applicator/propertyNames.js
var require_propertyNames = __commonJS({
"node_modules/ajv/dist/vocabularies/applicator/propertyNames.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var error = {
message: "property name must be valid",
params: ({ params }) => (0, codegen_1._)`{propertyName: ${params.propertyName}}`
};
var def = {
keyword: "propertyNames",
type: "object",
schemaType: ["object", "boolean"],
error,
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({
"node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js"(exports) {
"use strict";
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 error = {
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,
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, errors) {
const subschema = {
keyword: "additionalProperties",
dataProp: key,
dataPropType: util_1.Type.Str
};
if (errors === 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({
"node_modules/ajv/dist/vocabularies/applicator/properties.js"(exports) {
"use strict";
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 === void 0) {
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 !== void 0;
}
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({
"node_modules/ajv/dist/vocabularies/applicator/patternProperties.js"(exports) {
"use strict";
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({
"node_modules/ajv/dist/vocabularies/applicator/not.js"(exports) {
"use strict";
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({
"node_modules/ajv/dist/vocabularies/applicator/anyOf.js"(exports) {
"use strict";
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({
"node_modules/ajv/dist/vocabularies/applicator/oneOf.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var error = {
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,
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({
"node_modules/ajv/dist/vocabularies/applicator/allOf.js"(exports) {
"use strict";
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({
"node_modules/ajv/dist/vocabularies/applicator/if.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var error = {
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,
code(cxt) {
const { gen, parentSchema, it } = cxt;
if (parentSchema.then === void 0 && parentSchema.else === void 0) {
(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 !== void 0 && !(0, util_1.alwaysValidSchema)(it, schema);
}
exports.default = def;
}
});
// node_modules/ajv/dist/vocabularies/applicator/thenElse.js
var require_thenElse = __commonJS({
"node_modules/ajv/dist/vocabularies/applicator/thenElse.js"(exports) {
"use strict";
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 === void 0)
(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({
"node_modules/ajv/dist/vocabularies/applicator/index.js"(exports) {
"use strict";
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 = [
// any
not_1.default,
anyOf_1.default,
oneOf_1.default,
allOf_1.default,
if_1.default,
thenElse_1.default,
// object
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/dynamic/dynamicAnchor.js
var require_dynamicAnchor = __commonJS({
"node_modules/ajv/dist/vocabularies/dynamic/dynamicAnchor.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.dynamicAnchor = void 0;
var codegen_1 = require_codegen();
var names_1 = require_names();
var compile_1 = require_compile();
var ref_1 = require_ref();
var def = {
keyword: "$dynamicAnchor",
schemaType: "string",
code: (cxt) => dynamicAnchor(cxt, cxt.schema)
};
function dynamicAnchor(cxt, anchor) {
const { gen, it } = cxt;
it.schemaEnv.root.dynamicAnchors[anchor] = true;
const v = (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor)}`;
const validate = it.errSchemaPath === "#" ? it.validateName : _getValidate(cxt);
gen.if((0, codegen_1._)`!${v}`, () => gen.assign(v, validate));
}
exports.dynamicAnchor = dynamicAnchor;
function _getValidate(cxt) {
const { schemaEnv, schema, self } = cxt.it;
const { root, baseId, localRefs, meta } = schemaEnv.root;
const { schemaId } = self.opts;
const sch = new compile_1.SchemaEnv({ schema, schemaId, root, baseId, localRefs, meta });
compile_1.compileSchema.call(self, sch);
return (0, ref_1.getValidate)(cxt, sch);
}
exports.default = def;
}
});
// node_modules/ajv/dist/vocabularies/dynamic/dynamicRef.js
var require_dynamicRef = __commonJS({
"node_modules/ajv/dist/vocabularies/dynamic/dynamicRef.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.dynamicRef = void 0;
var codegen_1 = require_codegen();
var names_1 = require_names();
var ref_1 = require_ref();
var def = {
keyword: "$dynamicRef",
schemaType: "string",
code: (cxt) => dynamicRef(cxt, cxt.schema)
};
function dynamicRef(cxt, ref) {
const { gen, keyword, it } = cxt;
if (ref[0] !== "#")
throw new Error(`"${keyword}" only supports hash fragment reference`);
const anchor = ref.slice(1);
if (it.allErrors) {
_dynamicRef();
} else {
const valid = gen.let("valid", false);
_dynamicRef(valid);
cxt.ok(valid);
}
function _dynamicRef(valid) {
if (it.schemaEnv.root.dynamicAnchors[anchor]) {
const v = gen.let("_v", (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor)}`);
gen.if(v, _callRef(v, valid), _callRef(it.validateName, valid));
} else {
_callRef(it.validateName, valid)();
}
}
function _callRef(validate, valid) {
return valid ? () => gen.block(() => {
(0, ref_1.callRef)(cxt, validate);
gen.let(valid, true);
}) : () => (0, ref_1.callRef)(cxt, validate);
}
}
exports.dynamicRef = dynamicRef;
exports.default = def;
}
});
// node_modules/ajv/dist/vocabularies/dynamic/recursiveAnchor.js
var require_recursiveAnchor = __commonJS({
"node_modules/ajv/dist/vocabularies/dynamic/recursiveAnchor.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var dynamicAnchor_1 = require_dynamicAnchor();
var util_1 = require_util();
var def = {
keyword: "$recursiveAnchor",
schemaType: "boolean",
code(cxt) {
if (cxt.schema)
(0, dynamicAnchor_1.dynamicAnchor)(cxt, "");
else
(0, util_1.checkStrictMode)(cxt.it, "$recursiveAnchor: false is ignored");
}
};
exports.default = def;
}
});
// node_modules/ajv/dist/vocabularies/dynamic/recursiveRef.js
var require_recursiveRef = __commonJS({
"node_modules/ajv/dist/vocabularies/dynamic/recursiveRef.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var dynamicRef_1 = require_dynamicRef();
var def = {
keyword: "$recursiveRef",
schemaType: "string",
code: (cxt) => (0, dynamicRef_1.dynamicRef)(cxt, cxt.schema)
};
exports.default = def;
}
});
// node_modules/ajv/dist/vocabularies/dynamic/index.js
var require_dynamic = __commonJS({
"node_modules/ajv/dist/vocabularies/dynamic/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var dynamicAnchor_1 = require_dynamicAnchor();
var dynamicRef_1 = require_dynamicRef();
var recursiveAnchor_1 = require_recursiveAnchor();
var recursiveRef_1 = require_recursiveRef();
var dynamic = [dynamicAnchor_1.default, dynamicRef_1.default, recursiveAnchor_1.default, recursiveRef_1.default];
exports.default = dynamic;
}
});
// node_modules/ajv/dist/vocabularies/validation/dependentRequired.js
var require_dependentRequired = __commonJS({
"node_modules/ajv/dist/vocabularies/validation/dependentRequired.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var dependencies_1 = require_dependencies();
var def = {
keyword: "dependentRequired",
type: "object",
schemaType: "object",
error: dependencies_1.error,
code: (cxt) => (0, dependencies_1.validatePropertyDeps)(cxt)
};
exports.default = def;
}
});
// node_modules/ajv/dist/vocabularies/applicator/dependentSchemas.js
var require_dependentSchemas = __commonJS({
"node_modules/ajv/dist/vocabularies/applicator/dependentSchemas.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var dependencies_1 = require_dependencies();
var def = {
keyword: "dependentSchemas",
type: "object",
schemaType: "object",
code: (cxt) => (0, dependencies_1.validateSchemaDeps)(cxt)
};
exports.default = def;
}
});
// node_modules/ajv/dist/vocabularies/validation/limitContains.js
var require_limitContains = __commonJS({
"node_modules/ajv/dist/vocabularies/validation/limitContains.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var util_1 = require_util();
var def = {
keyword: ["maxContains", "minContains"],
type: "array",
schemaType: "number",
code({ keyword, parentSchema, it }) {
if (parentSchema.contains === void 0) {
(0, util_1.checkStrictMode)(it, `"${keyword}" without "contains" is ignored`);
}
}
};
exports.default = def;
}
});
// node_modules/ajv/dist/vocabularies/next.js
var require_next = __commonJS({
"node_modules/ajv/dist/vocabularies/next.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var dependentRequired_1 = require_dependentRequired();
var dependentSchemas_1 = require_dependentSchemas();
var limitContains_1 = require_limitContains();
var next = [dependentRequired_1.default, dependentSchemas_1.default, limitContains_1.default];
exports.default = next;
}
});
// node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.js
var require_unevaluatedProperties = __commonJS({
"node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var names_1 = require_names();
var error = {
message: "must NOT have unevaluated properties",
params: ({ params }) => (0, codegen_1._)`{unevaluatedProperty: ${params.unevaluatedProperty}}`
};
var def = {
keyword: "unevaluatedProperties",
type: "object",
schemaType: ["boolean", "object"],
trackErrors: true,
error,
code(cxt) {
const { gen, schema, data, errsCount, it } = cxt;
if (!errsCount)
throw new Error("ajv implementation error");
const { allErrors, props } = it;
if (props instanceof codegen_1.Name) {
gen.if((0, codegen_1._)`${props} !== true`, () => gen.forIn("key", data, (key) => gen.if(unevaluatedDynamic(props, key), () => unevaluatedPropCode(key))));
} else if (props !== true) {
gen.forIn("key", data, (key) => props === void 0 ? unevaluatedPropCode(key) : gen.if(unevaluatedStatic(props, key), () => unevaluatedPropCode(key)));
}
it.props = true;
cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
function unevaluatedPropCode(key) {
if (schema === false) {
cxt.setParams({ unevaluatedProperty: key });
cxt.error();
if (!allErrors)
gen.break();
return;
}
if (!(0, util_1.alwaysValidSchema)(it, schema)) {
const valid = gen.name("valid");
cxt.subschema({
keyword: "unevaluatedProperties",
dataProp: key,
dataPropType: util_1.Type.Str
}, valid);
if (!allErrors)
gen.if((0, codegen_1.not)(valid), () => gen.break());
}
}
function unevaluatedDynamic(evaluatedProps, key) {
return (0, codegen_1._)`!${evaluatedProps} || !${evaluatedProps}[${key}]`;
}
function unevaluatedStatic(evaluatedProps, key) {
const ps = [];
for (const p in evaluatedProps) {
if (evaluatedProps[p] === true)
ps.push((0, codegen_1._)`${key} !== ${p}`);
}
return (0, codegen_1.and)(...ps);
}
}
};
exports.default = def;
}
});
// node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedItems.js
var require_unevaluatedItems = __commonJS({
"node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedItems.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var util_1 = require_util();
var error = {
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: "unevaluatedItems",
type: "array",
schemaType: ["boolean", "object"],
error,
code(cxt) {
const { gen, schema, data, it } = cxt;
const items = it.items || 0;
if (items === true)
return;
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
if (schema === false) {
cxt.setParams({ len: items });
cxt.fail((0, codegen_1._)`${len} > ${items}`);
} else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items}`);
gen.if((0, codegen_1.not)(valid), () => validateItems(valid, items));
cxt.ok(valid);
}
it.items = true;
function validateItems(valid, from) {
gen.forRange("i", from, len, (i) => {
cxt.subschema({ keyword: "unevaluatedItems", dataProp: i, dataPropType: util_1.Type.Num }, valid);
if (!it.allErrors)
gen.if((0, codegen_1.not)(valid), () => gen.break());
});
}
}
};
exports.default = def;
}
});
// node_modules/ajv/dist/vocabularies/unevaluated/index.js
var require_unevaluated = __commonJS({
"node_modules/ajv/dist/vocabularies/unevaluated/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var unevaluatedProperties_1 = require_unevaluatedProperties();
var unevaluatedItems_1 = require_unevaluatedItems();
var unevaluated = [unevaluatedProperties_1.default, unevaluatedItems_1.default];
exports.default = unevaluated;
}
});
// node_modules/ajv/dist/vocabularies/format/format.js
var require_format = __commonJS({
"node_modules/ajv/dist/vocabularies/format/format.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var codegen_1 = require_codegen();
var error = {
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,
code(cxt, ruleType) {
const { gen, data, $data, schema, schemaCode, it } = cxt;
const { opts, errSchemaPath, schemaEnv, self } = it;
if (!opts.validateFormats)
return;
if ($data)
validate$DataFormat();
else
validateFormat();
function validate$DataFormat() {
const fmts = gen.scopeValue("formats", {
ref: self.formats,
code: opts.code.formats
});
const fDef = gen.const("fDef", (0, codegen_1._)`${fmts}[${schemaCode}]`);
const fType = gen.let("fType");
const format2 = gen.let("format");
gen.if((0, codegen_1._)`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`, () => gen.assign(fType, (0, codegen_1._)`${fDef}.type || "string"`).assign(format2, (0, codegen_1._)`${fDef}.validate`), () => gen.assign(fType, (0, codegen_1._)`"string"`).assign(format2, 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} && !${format2}`;
}
function invalidFmt() {
const callFormat = schemaEnv.$async ? (0, codegen_1._)`(${fDef}.async ? await ${format2}(${data}) : ${format2}(${data}))` : (0, codegen_1._)`${format2}(${data})`;
const validData = (0, codegen_1._)`(typeof ${format2} == "function" ? ${callFormat} : ${format2}.test(${data}))`;
return (0, codegen_1._)`${format2} && ${format2} !== true && ${fType} === ${ruleType} && !${validData}`;
}
}
function validateFormat() {
const formatDef = self.formats[schema];
if (!formatDef) {
unknownFormat();
return;
}
if (formatDef === true)
return;
const [fmtType, format2, fmtRef] = getFormat(formatDef);
if (fmtType === ruleType)
cxt.pass(validCondition());
function unknownFormat() {
if (opts.strictSchema === false) {
self.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)}` : void 0;
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 format2 == "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({
"node_modules/ajv/dist/vocabularies/format/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var format_1 = require_format();
var format2 = [format_1.default];
exports.default = format2;
}
});
// node_modules/ajv/dist/vocabularies/metadata.js
var require_metadata = __commonJS({
"node_modules/ajv/dist/vocabularies/metadata.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.contentVocabulary = exports.metadataVocabulary = void 0;
exports.metadataVocabulary = [
"title",
"description",
"default",
"deprecated",
"readOnly",
"writeOnly",
"examples"
];
exports.contentVocabulary = [
"contentMediaType",
"contentEncoding",
"contentSchema"
];
}
});
// node_modules/ajv/dist/vocabularies/draft2020.js
var require_draft2020 = __commonJS({
"node_modules/ajv/dist/vocabularies/draft2020.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var core_1 = require_core2();
var validation_1 = require_validation();
var applicator_1 = require_applicator();
var dynamic_1 = require_dynamic();
var next_1 = require_next();
var unevaluated_1 = require_unevaluated();
var format_1 = require_format2();
var metadata_1 = require_metadata();
var draft2020Vocabularies = [
dynamic_1.default,
core_1.default,
validation_1.default,
(0, applicator_1.default)(true),
format_1.default,
metadata_1.metadataVocabulary,
metadata_1.contentVocabulary,
next_1.default,
unevaluated_1.default
];
exports.default = draft2020Vocabularies;
}
});
// node_modules/ajv/dist/vocabularies/discriminator/types.js
var require_types = __commonJS({
"node_modules/ajv/dist/vocabularies/discriminator/types.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DiscrError = void 0;
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({
"node_modules/ajv/dist/vocabularies/discriminator/index.js"(exports) {
"use strict";
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 error = {
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,
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 === void 0 ? void 0 : 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 === void 0)
throw new ref_error_1.default(it.opts.uriResolver, it.baseId, ref);
}
const propSch = (_a = sch === null || sch === void 0 ? void 0 : sch.properties) === null || _a === void 0 ? void 0 : _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-2020-12/schema.json
var require_schema = __commonJS({
"node_modules/ajv/dist/refs/json-schema-2020-12/schema.json"(exports, module) {
module.exports = {
$schema: "https://json-schema.org/draft/2020-12/schema",
$id: "https://json-schema.org/draft/2020-12/schema",
$vocabulary: {
"https://json-schema.org/draft/2020-12/vocab/core": true,
"https://json-schema.org/draft/2020-12/vocab/applicator": true,
"https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
"https://json-schema.org/draft/2020-12/vocab/validation": true,
"https://json-schema.org/draft/2020-12/vocab/meta-data": true,
"https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
"https://json-schema.org/draft/2020-12/vocab/content": true
},
$dynamicAnchor: "meta",
title: "Core and Validation specifications meta-schema",
allOf: [
{ $ref: "meta/core" },
{ $ref: "meta/applicator" },
{ $ref: "meta/unevaluated" },
{ $ref: "meta/validation" },
{ $ref: "meta/meta-data" },
{ $ref: "meta/format-annotation" },
{ $ref: "meta/content" }
],
type: ["object", "boolean"],
$comment: "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.",
properties: {
definitions: {
$comment: '"definitions" has been replaced by "$defs".',
type: "object",
additionalProperties: { $dynamicRef: "#meta" },
deprecated: true,
default: {}
},
dependencies: {
$comment: '"dependencies" has been split and replaced by "dependentSchemas" and "dependentRequired" in order to serve their differing semantics.',
type: "object",
additionalProperties: {
anyOf: [{ $dynamicRef: "#meta" }, { $ref: "meta/validation#/$defs/stringArray" }]
},
deprecated: true,
default: {}
},
$recursiveAnchor: {
$comment: '"$recursiveAnchor" has been replaced by "$dynamicAnchor".',
$ref: "meta/core#/$defs/anchorString",
deprecated: true
},
$recursiveRef: {
$comment: '"$recursiveRef" has been replaced by "$dynamicRef".',
$ref: "meta/core#/$defs/uriReferenceString",
deprecated: true
}
}
};
}
});
// node_modules/ajv/dist/refs/json-schema-2020-12/meta/applicator.json
var require_applicator2 = __commonJS({
"node_modules/ajv/dist/refs/json-schema-2020-12/meta/applicator.json"(exports, module) {
module.exports = {
$schema: "https://json-schema.org/draft/2020-12/schema",
$id: "https://json-schema.org/draft/2020-12/meta/applicator",
$vocabulary: {
"https://json-schema.org/draft/2020-12/vocab/applicator": true
},
$dynamicAnchor: "meta",
title: "Applicator vocabulary meta-schema",
type: ["object", "boolean"],
properties: {
prefixItems: { $ref: "#/$defs/schemaArray" },
items: { $dynamicRef: "#meta" },
contains: { $dynamicRef: "#meta" },
additionalProperties: { $dynamicRef: "#meta" },
properties: {
type: "object",
additionalProperties: { $dynamicRef: "#meta" },
default: {}
},
patternProperties: {
type: "object",
additionalProperties: { $dynamicRef: "#meta" },
propertyNames: { format: "regex" },
default: {}
},
dependentSchemas: {
type: "object",
additionalProperties: { $dynamicRef: "#meta" },
default: {}
},
propertyNames: { $dynamicRef: "#meta" },
if: { $dynamicRef: "#meta" },
then: { $dynamicRef: "#meta" },
else: { $dynamicRef: "#meta" },
allOf: { $ref: "#/$defs/schemaArray" },
anyOf: { $ref: "#/$defs/schemaArray" },
oneOf: { $ref: "#/$defs/schemaArray" },
not: { $dynamicRef: "#meta" }
},
$defs: {
schemaArray: {
type: "array",
minItems: 1,
items: { $dynamicRef: "#meta" }
}
}
};
}
});
// node_modules/ajv/dist/refs/json-schema-2020-12/meta/unevaluated.json
var require_unevaluated2 = __commonJS({
"node_modules/ajv/dist/refs/json-schema-2020-12/meta/unevaluated.json"(exports, module) {
module.exports = {
$schema: "https://json-schema.org/draft/2020-12/schema",
$id: "https://json-schema.org/draft/2020-12/meta/unevaluated",
$vocabulary: {
"https://json-schema.org/draft/2020-12/vocab/unevaluated": true
},
$dynamicAnchor: "meta",
title: "Unevaluated applicator vocabulary meta-schema",
type: ["object", "boolean"],
properties: {
unevaluatedItems: { $dynamicRef: "#meta" },
unevaluatedProperties: { $dynamicRef: "#meta" }
}
};
}
});
// node_modules/ajv/dist/refs/json-schema-2020-12/meta/content.json
var require_content = __commonJS({
"node_modules/ajv/dist/refs/json-schema-2020-12/meta/content.json"(exports, module) {
module.exports = {
$schema: "https://json-schema.org/draft/2020-12/schema",
$id: "https://json-schema.org/draft/2020-12/meta/content",
$vocabulary: {
"https://json-schema.org/draft/2020-12/vocab/content": true
},
$dynamicAnchor: "meta",
title: "Content vocabulary meta-schema",
type: ["object", "boolean"],
properties: {
contentEncoding: { type: "string" },
contentMediaType: { type: "string" },
contentSchema: { $dynamicRef: "#meta" }
}
};
}
});
// node_modules/ajv/dist/refs/json-schema-2020-12/meta/core.json
var require_core3 = __commonJS({
"node_modules/ajv/dist/refs/json-schema-2020-12/meta/core.json"(exports, module) {
module.exports = {
$schema: "https://json-schema.org/draft/2020-12/schema",
$id: "https://json-schema.org/draft/2020-12/meta/core",
$vocabulary: {
"https://json-schema.org/draft/2020-12/vocab/core": true
},
$dynamicAnchor: "meta",
title: "Core vocabulary meta-schema",
type: ["object", "boolean"],
properties: {
$id: {
$ref: "#/$defs/uriReferenceString",
$comment: "Non-empty fragments not allowed.",
pattern: "^[^#]*#?$"
},
$schema: { $ref: "#/$defs/uriString" },
$ref: { $ref: "#/$defs/uriReferenceString" },
$anchor: { $ref: "#/$defs/anchorString" },
$dynamicRef: { $ref: "#/$defs/uriReferenceString" },
$dynamicAnchor: { $ref: "#/$defs/anchorString" },
$vocabulary: {
type: "object",
propertyNames: { $ref: "#/$defs/uriString" },
additionalProperties: {
type: "boolean"
}
},
$comment: {
type: "string"
},
$defs: {
type: "object",
additionalProperties: { $dynamicRef: "#meta" }
}
},
$defs: {
anchorString: {
type: "string",
pattern: "^[A-Za-z_][-A-Za-z0-9._]*$"
},
uriString: {
type: "string",
format: "uri"
},
uriReferenceString: {
type: "string",
format: "uri-reference"
}
}
};
}
});
// node_modules/ajv/dist/refs/json-schema-2020-12/meta/format-annotation.json
var require_format_annotation = __commonJS({
"node_modules/ajv/dist/refs/json-schema-2020-12/meta/format-annotation.json"(exports, module) {
module.exports = {
$schema: "https://json-schema.org/draft/2020-12/schema",
$id: "https://json-schema.org/draft/2020-12/meta/format-annotation",
$vocabulary: {
"https://json-schema.org/draft/2020-12/vocab/format-annotation": true
},
$dynamicAnchor: "meta",
title: "Format vocabulary meta-schema for annotation results",
type: ["object", "boolean"],
properties: {
format: { type: "string" }
}
};
}
});
// node_modules/ajv/dist/refs/json-schema-2020-12/meta/meta-data.json
var require_meta_data = __commonJS({
"node_modules/ajv/dist/refs/json-schema-2020-12/meta/meta-data.json"(exports, module) {
module.exports = {
$schema: "https://json-schema.org/draft/2020-12/schema",
$id: "https://json-schema.org/draft/2020-12/meta/meta-data",
$vocabulary: {
"https://json-schema.org/draft/2020-12/vocab/meta-data": true
},
$dynamicAnchor: "meta",
title: "Meta-data vocabulary meta-schema",
type: ["object", "boolean"],
properties: {
title: {
type: "string"
},
description: {
type: "string"
},
default: true,
deprecated: {
type: "boolean",
default: false
},
readOnly: {
type: "boolean",
default: false
},
writeOnly: {
type: "boolean",
default: false
},
examples: {
type: "array",
items: true
}
}
};
}
});
// node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json
var require_validation2 = __commonJS({
"node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json"(exports, module) {
module.exports = {
$schema: "https://json-schema.org/draft/2020-12/schema",
$id: "https://json-schema.org/draft/2020-12/meta/validation",
$vocabulary: {
"https://json-schema.org/draft/2020-12/vocab/validation": true
},
$dynamicAnchor: "meta",
title: "Validation vocabulary meta-schema",
type: ["object", "boolean"],
properties: {
type: {
anyOf: [
{ $ref: "#/$defs/simpleTypes" },
{
type: "array",
items: { $ref: "#/$defs/simpleTypes" },
minItems: 1,
uniqueItems: true
}
]
},
const: true,
enum: {
type: "array",
items: true
},
multipleOf: {
type: "number",
exclusiveMinimum: 0
},
maximum: {
type: "number"
},
exclusiveMaximum: {
type: "number"
},
minimum: {
type: "number"
},
exclusiveMinimum: {
type: "number"
},
maxLength: { $ref: "#/$defs/nonNegativeInteger" },
minLength: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
pattern: {
type: "string",
format: "regex"
},
maxItems: { $ref: "#/$defs/nonNegativeInteger" },
minItems: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
uniqueItems: {
type: "boolean",
default: false
},
maxContains: { $ref: "#/$defs/nonNegativeInteger" },
minContains: {
$ref: "#/$defs/nonNegativeInteger",
default: 1
},
maxProperties: { $ref: "#/$defs/nonNegativeInteger" },
minProperties: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
required: { $ref: "#/$defs/stringArray" },
dependentRequired: {
type: "object",
additionalProperties: {
$ref: "#/$defs/stringArray"
}
}
},
$defs: {
nonNegativeInteger: {
type: "integer",
minimum: 0
},
nonNegativeIntegerDefault0: {
$ref: "#/$defs/nonNegativeInteger",
default: 0
},
simpleTypes: {
enum: ["array", "boolean", "integer", "null", "number", "object", "string"]
},
stringArray: {
type: "array",
items: { type: "string" },
uniqueItems: true,
default: []
}
}
};
}
});
// node_modules/ajv/dist/refs/json-schema-2020-12/index.js
var require_json_schema_2020_12 = __commonJS({
"node_modules/ajv/dist/refs/json-schema-2020-12/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var metaSchema = require_schema();
var applicator = require_applicator2();
var unevaluated = require_unevaluated2();
var content = require_content();
var core = require_core3();
var format2 = require_format_annotation();
var metadata = require_meta_data();
var validation = require_validation2();
var META_SUPPORT_DATA = ["/properties"];
function addMetaSchema2020($data) {
;
[
metaSchema,
applicator,
unevaluated,
content,
core,
with$data(this, format2),
metadata,
with$data(this, validation)
].forEach((sch) => this.addMetaSchema(sch, void 0, false));
return this;
function with$data(ajv, sch) {
return $data ? ajv.$dataMetaSchema(sch, META_SUPPORT_DATA) : sch;
}
}
exports.default = addMetaSchema2020;
}
});
// node_modules/ajv/dist/2020.js
var require__ = __commonJS({
"node_modules/ajv/dist/2020.js"(exports, module) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv2020 = void 0;
var core_1 = require_core();
var draft2020_1 = require_draft2020();
var discriminator_1 = require_discriminator();
var json_schema_2020_12_1 = require_json_schema_2020_12();
var META_SCHEMA_ID = "https://json-schema.org/draft/2020-12/schema";
var Ajv20203 = class extends core_1.default {
constructor(opts = {}) {
super({
...opts,
dynamicRef: true,
next: true,
unevaluated: true
});
}
_addVocabularies() {
super._addVocabularies();
draft2020_1.default.forEach((v) => this.addVocabulary(v));
if (this.opts.discriminator)
this.addKeyword(discriminator_1.default);
}
_addDefaultMetaSchema() {
super._addDefaultMetaSchema();
const { $data, meta } = this.opts;
if (!meta)
return;
json_schema_2020_12_1.default.call(this, $data);
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 : void 0);
}
};
exports.Ajv2020 = Ajv20203;
module.exports = exports = Ajv20203;
module.exports.Ajv2020 = Ajv20203;
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = Ajv20203;
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({
"node_modules/ajv-formats/dist/formats.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.formatNames = exports.fastFormats = exports.fullFormats = void 0;
function fmtDef(validate, compare) {
return { validate, compare };
}
exports.fullFormats = {
// date: http://tools.ietf.org/html/rfc3339#section-5.6
date: fmtDef(date, compareDate),
// date-time: http://tools.ietf.org/html/rfc3339#section-5.6
time: fmtDef(getTime(true), compareTime),
"date-time": fmtDef(getDateTime(true), compareDateTime),
"iso-time": fmtDef(getTime(), compareIsoTime),
"iso-date-time": fmtDef(getDateTime(), compareIsoDateTime),
// duration: https://tools.ietf.org/html/rfc3339#appendix-A
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: https://tools.ietf.org/html/rfc6570
"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,
// For the source: https://gist.github.com/dperini/729294
// For test cases: https://mathiasbynens.be/demo/url-regex
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,
// optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html
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: http://tools.ietf.org/html/rfc4122
uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,
// JSON-pointer: https://tools.ietf.org/html/rfc6901
// uri fragment: https://tools.ietf.org/html/rfc3986#appendix-A
"json-pointer": /^(?:\/(?:[^~/]|~0|~1)*)*$/,
"json-pointer-uri-fragment": /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i,
// relative JSON-pointer: http://tools.ietf.org/html/draft-luff-relative-json-pointer-00
"relative-json-pointer": /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/,
// the following formats are used by the openapi specification: https://spec.openapis.org/oas/v3.0.0#data-types
// byte: https://github.com/miguelmota/is-base64
byte,
// signed 32 bit integer
int32: { type: "number", validate: validateInt32 },
// signed 64 bit integer
int64: { type: "number", validate: validateInt64 },
// C-type float
float: { type: "number", validate: validateNumber },
// C-type double
double: { type: "number", validate: validateNumber },
// hint to the UI to hide input strings
password: true,
// unchecked string payload
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: https://github.com/mafintosh/is-my-json-valid/blob/master/formats.js
uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i,
"uri-reference": /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i,
// email (sources from jsen validator):
// http://stackoverflow.com/questions/201323/using-a-regular-expression-to-validate-an-email-address#answer-8829363
// http://www.w3.org/TR/html5/forms.html#valid-e-mail-address (search for 'wilful violation')
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 date(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 void 0;
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 void 0;
const t1 = (/* @__PURE__ */ new Date("2020-01-01T" + s1)).valueOf();
const t2 = (/* @__PURE__ */ new Date("2020-01-01T" + s2)).valueOf();
if (!(t1 && t2))
return void 0;
return t1 - t2;
}
function compareIsoTime(t1, t2) {
if (!(t1 && t2))
return void 0;
const a1 = TIME.exec(t1);
const a2 = TIME.exec(t2);
if (!(a1 && a2))
return void 0;
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 time = getTime(strictTimeZone);
return function date_time(str) {
const dateTime = str.split(DATE_TIME_SEPARATOR);
return dateTime.length === 2 && date(dateTime[0]) && time(dateTime[1]);
};
}
function compareDateTime(dt1, dt2) {
if (!(dt1 && dt2))
return void 0;
const d1 = new Date(dt1).valueOf();
const d2 = new Date(dt2).valueOf();
if (!(d1 && d2))
return void 0;
return d1 - d2;
}
function compareIsoDateTime(dt1, dt2) {
if (!(dt1 && dt2))
return void 0;
const [d1, t1] = dt1.split(DATE_TIME_SEPARATOR);
const [d2, t2] = dt2.split(DATE_TIME_SEPARATOR);
const res = compareDate(d1, d2);
if (res === void 0)
return void 0;
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/dist/vocabularies/draft7.js
var require_draft7 = __commonJS({
"node_modules/ajv/dist/vocabularies/draft7.js"(exports) {
"use strict";
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/refs/json-schema-draft-07.json
var require_json_schema_draft_07 = __commonJS({
"node_modules/ajv/dist/refs/json-schema-draft-07.json"(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({
"node_modules/ajv/dist/ajv.js"(exports, module) {
"use strict";
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 = void 0;
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";
var Ajv = class 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 : void 0);
}
};
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/limit.js
var require_limit = __commonJS({
"node_modules/ajv-formats/dist/limit.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.formatLimitDefinition = void 0;
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 error = {
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,
code(cxt) {
const { gen, data, schemaCode, keyword, it } = cxt;
const { opts, self } = it;
if (!opts.validateFormats)
return;
const fCxt = new ajv_1.KeywordCxt(it, self.RULES.all.format.definition, "format");
if (fCxt.$data)
validate$DataFormat();
else
validateFormat();
function validate$DataFormat() {
const fmts = gen.scopeValue("formats", {
ref: self.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 format2 = fCxt.schema;
const fmtDef = self.formats[format2];
if (!fmtDef || fmtDef === true)
return;
if (typeof fmtDef != "object" || fmtDef instanceof RegExp || typeof fmtDef.compare != "function") {
throw new Error(`"${keyword}": format "${format2}" does not define "compare" function`);
}
const fmt = gen.scopeValue("formats", {
key: format2,
ref: fmtDef,
code: opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format2)}` : void 0
});
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({
"node_modules/ajv-formats/dist/index.js"(exports, module) {
"use strict";
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)) {
addFormats2(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;
addFormats2(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 addFormats2(ajv, list, fs, exportName) {
var _a;
var _b;
(_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
for (const f of list)
ajv.addFormat(f, fs[f]);
}
module.exports = exports = formatsPlugin;
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = formatsPlugin;
}
});
// integrations/shared/evaldossier-local-core.mjs
import { createHash as createHash5, generateKeyPairSync } from "node:crypto";
import { constants as fsConstants } from "node:fs";
import { lstat as lstat3, open as open3, readFile as readFile2 } from "node:fs/promises";
import { dirname as dirname2, resolve as resolve4 } from "node:path";
import { fileURLToPath as fileURLToPath2 } from "node:url";
// dist/src/dossier.js
import { constants as constants2 } from "node:fs";
import { lstat as lstat2, mkdir, open as open2, readdir, rm, writeFile } from "node:fs/promises";
import { dirname, isAbsolute as isAbsolute2, join, relative as relative2, resolve as resolve3, sep as sep2 } from "node:path";
// dist/src/canonical.js
import { createHash, timingSafeEqual } from "node:crypto";
// node_modules/json-canonicalize/esm5/serializer.js
var CircularRootPathName = "$";
function _serialize(obj, options) {
var buffer = "";
var vInclude = options && options.include;
var vExclude = options && options.exclude;
if (vExclude) {
if (typeof vExclude === "string")
vExclude = [vExclude];
}
if (vInclude)
vInclude.sort();
var visited = /* @__PURE__ */ new WeakMap();
var allowCircular = options && options.allowCircular;
var filterUndefined = options && options.filterUndefined;
var undefinedInArrayToNull = options && options.undefinedInArrayToNull;
serialize(obj, CircularRootPathName);
return buffer;
function serialize(object, path) {
if (object === null || typeof object !== "object" || object.toJSON != null) {
buffer += JSON.stringify(object);
} else if (Array.isArray(object)) {
var visitedPath = visited.get(object);
if (visitedPath !== void 0) {
if (path.startsWith(visitedPath)) {
if (!allowCircular) {
throw new Error("Circular reference detected");
}
buffer += '"[Circular:' + visitedPath + ']"';
return;
}
}
visited.set(object, path);
buffer += "[";
var next_1 = false;
object.forEach(function(element, index) {
if (next_1) {
buffer += ",";
}
next_1 = true;
if (undefinedInArrayToNull && element === void 0) {
element = null;
}
serialize(element, path + "[" + index + "]");
});
buffer += "]";
} else {
var visitedPath = visited.get(object);
if (visitedPath !== void 0) {
if (path.startsWith(visitedPath)) {
if (!allowCircular) {
throw new Error("Circular reference detected");
}
buffer += '"[Circular:' + visitedPath + ']"';
return;
}
}
visited.set(object, path);
buffer += "{";
var next_2 = false;
var addProp_1 = function(property) {
if (vExclude && vExclude.includes(property)) {
return;
}
if (next_2) {
buffer += ",";
}
next_2 = true;
buffer += JSON.stringify(property);
buffer += ":";
serialize(object[property], path + "." + property);
};
if (path === CircularRootPathName && vInclude) {
vInclude.forEach(function(property) {
if (object.hasOwnProperty(property)) {
addProp_1(property);
}
});
} else {
var vKeys = Object.keys(object);
if (filterUndefined) {
vKeys = vKeys.filter(function(k) {
return object[k] !== void 0;
});
}
vKeys.sort();
vKeys.forEach(function(property) {
addProp_1(property);
});
}
buffer += "}";
}
}
}
// node_modules/json-canonicalize/esm5/canonicalize.js
function canonicalize(obj, allowCircular) {
return _serialize(obj, {
allowCircular,
filterUndefined: true,
undefinedInArrayToNull: true
});
}
// dist/src/canonical.js
var DEFAULT_MAX_HASH_FILE_BYTES = 5 * 1024 * 1024;
var MAX_CANONICAL_DEPTH = 128;
var CanonicalizationError = class extends Error {
constructor(message) {
super(message);
this.name = "CanonicalizationError";
}
};
function assertUnicodeScalarString(value, path) {
for (let index = 0; index < value.length; index += 1) {
const codeUnit = value.charCodeAt(index);
if (codeUnit >= 55296 && codeUnit <= 56319) {
const next = value.charCodeAt(index + 1);
if (!(next >= 56320 && next <= 57343)) {
throw new CanonicalizationError(`unpaired high surrogate at ${path}`);
}
index += 1;
} else if (codeUnit >= 56320 && codeUnit <= 57343) {
throw new CanonicalizationError(`unpaired low surrogate at ${path}`);
}
}
}
function assertCanonicalizable(value, path, depth, ancestors) {
if (depth > MAX_CANONICAL_DEPTH) {
throw new CanonicalizationError(`nesting exceeds ${MAX_CANONICAL_DEPTH} levels at ${path}`);
}
if (value === null || typeof value === "boolean") {
return;
}
if (typeof value === "string") {
assertUnicodeScalarString(value, path);
return;
}
if (typeof value === "number") {
if (!Number.isFinite(value)) {
throw new CanonicalizationError(`non-finite number at ${path}`);
}
if (Object.is(value, -0)) {
throw new CanonicalizationError(`negative zero is not accepted at ${path}`);
}
if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
throw new CanonicalizationError(`unsafe integer at ${path}`);
}
return;
}
if (typeof value !== "object") {
throw new CanonicalizationError(`unsupported ${typeof value} value at ${path}`);
}
if (ancestors.has(value)) {
throw new CanonicalizationError(`cyclic reference at ${path}`);
}
ancestors.add(value);
try {
if (Array.isArray(value)) {
const ownNames = Object.getOwnPropertyNames(value);
for (let index = 0; index < value.length; index += 1) {
const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
if (descriptor === void 0) {
throw new CanonicalizationError(`sparse array entry at ${path}/${index}`);
}
if (!("value" in descriptor)) {
throw new CanonicalizationError(`accessor array entry at ${path}/${index}`);
}
assertCanonicalizable(descriptor.value, `${path}/${index}`, depth + 1, ancestors);
}
const unexpected = ownNames.filter((name) => name !== "length" && !/^(?:0|[1-9][0-9]*)$/.test(name));
if (unexpected.length > 0 || Object.getOwnPropertySymbols(value).length > 0) {
throw new CanonicalizationError(`array has non-JSON properties at ${path}`);
}
return;
}
const prototype = Object.getPrototypeOf(value);
if (prototype !== Object.prototype && prototype !== null) {
throw new CanonicalizationError(`non-plain object at ${path}`);
}
if (Object.getOwnPropertySymbols(value).length > 0) {
throw new CanonicalizationError(`symbol-keyed property at ${path}`);
}
for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
assertUnicodeScalarString(key, `${path}/<key>`);
if (!descriptor.enumerable) {
throw new CanonicalizationError(`non-enumerable property ${JSON.stringify(key)} at ${path}`);
}
if (!("value" in descriptor)) {
throw new CanonicalizationError(`accessor property ${JSON.stringify(key)} at ${path}`);
}
assertCanonicalizable(descriptor.value, `${path}/${key.replaceAll("~", "~0").replaceAll("/", "~1")}`, depth + 1, ancestors);
}
} finally {
ancestors.delete(value);
}
}
function canonicalString(value) {
assertCanonicalizable(value, "$", 0, /* @__PURE__ */ new Set());
const result = canonicalize(value);
if (typeof result !== "string") {
throw new CanonicalizationError("canonicalizer did not return a string");
}
return result;
}
function canonicalBytes(value) {
return Buffer.from(canonicalString(value), "utf8");
}
function sha256Bytes(input) {
const bytes = typeof input === "string" ? Buffer.from(input, "utf8") : input;
return {
algorithm: "sha-256",
value: createHash("sha256").update(bytes).digest("hex")
};
}
function digestOfObject(value) {
return sha256Bytes(canonicalBytes(value));
}
function withoutProof(value) {
const result = /* @__PURE__ */ Object.create(null);
for (const [key, member] of Object.entries(value)) {
if (key !== "proof") {
result[key] = member;
}
}
return result;
}
// dist/src/crypto.js
import { createHash as createHash3, createPrivateKey, createPublicKey, sign as ed25519Sign, timingSafeEqual as timingSafeEqual2, verify as ed25519Verify } from "node:crypto";
// dist/src/json.js
import { createHash as createHash2 } from "node:crypto";
import { readFile, stat } from "node:fs/promises";
// node_modules/jsonc-parser/lib/esm/impl/scanner.js
function createScanner(text, ignoreTrivia = false) {
const len = text.length;
let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
function scanHexDigits(count, exact) {
let digits = 0;
let value2 = 0;
while (digits < count || !exact) {
let ch = text.charCodeAt(pos);
if (ch >= 48 && ch <= 57) {
value2 = value2 * 16 + ch - 48;
} else if (ch >= 65 && ch <= 70) {
value2 = value2 * 16 + ch - 65 + 10;
} else if (ch >= 97 && ch <= 102) {
value2 = value2 * 16 + ch - 97 + 10;
} else {
break;
}
pos++;
digits++;
}
if (digits < count) {
value2 = -1;
}
return value2;
}
function setPosition(newPosition) {
pos = newPosition;
value = "";
tokenOffset = 0;
token = 16;
scanError = 0;
}
function scanNumber() {
let start = pos;
if (text.charCodeAt(pos) === 48) {
pos++;
} else {
pos++;
while (pos < text.length && isDigit(text.charCodeAt(pos))) {
pos++;
}
}
if (pos < text.length && text.charCodeAt(pos) === 46) {
pos++;
if (pos < text.length && isDigit(text.charCodeAt(pos))) {
pos++;
while (pos < text.length && isDigit(text.charCodeAt(pos))) {
pos++;
}
} else {
scanError = 3;
return text.substring(start, pos);
}
}
let end = pos;
if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
pos++;
if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
pos++;
}
if (pos < text.length && isDigit(text.charCodeAt(pos))) {
pos++;
while (pos < text.length && isDigit(text.charCodeAt(pos))) {
pos++;
}
end = pos;
} else {
scanError = 3;
}
}
return text.substring(start, end);
}
function scanString() {
let result = "", start = pos;
while (true) {
if (pos >= len) {
result += text.substring(start, pos);
scanError = 2;
break;
}
const ch = text.charCodeAt(pos);
if (ch === 34) {
result += text.substring(start, pos);
pos++;
break;
}
if (ch === 92) {
result += text.substring(start, pos);
pos++;
if (pos >= len) {
scanError = 2;
break;
}
const ch2 = text.charCodeAt(pos++);
switch (ch2) {
case 34:
result += '"';
break;
case 92:
result += "\\";
break;
case 47:
result += "/";
break;
case 98:
result += "\b";
break;
case 102:
result += "\f";
break;
case 110:
result += "\n";
break;
case 114:
result += "\r";
break;
case 116:
result += " ";
break;
case 117:
const ch3 = scanHexDigits(4, true);
if (ch3 >= 0) {
result += String.fromCharCode(ch3);
} else {
scanError = 4;
}
break;
default:
scanError = 5;
}
start = pos;
continue;
}
if (ch >= 0 && ch <= 31) {
if (isLineBreak(ch)) {
result += text.substring(start, pos);
scanError = 2;
break;
} else {
scanError = 6;
}
}
pos++;
}
return result;
}
function scanNext() {
value = "";
scanError = 0;
tokenOffset = pos;
lineStartOffset = lineNumber;
prevTokenLineStartOffset = tokenLineStartOffset;
if (pos >= len) {
tokenOffset = len;
return token = 17;
}
let code = text.charCodeAt(pos);
if (isWhiteSpace(code)) {
do {
pos++;
value += String.fromCharCode(code);
code = text.charCodeAt(pos);
} while (isWhiteSpace(code));
return token = 15;
}
if (isLineBreak(code)) {
pos++;
value += String.fromCharCode(code);
if (code === 13 && text.charCodeAt(pos) === 10) {
pos++;
value += "\n";
}
lineNumber++;
tokenLineStartOffset = pos;
return token = 14;
}
switch (code) {
// tokens: []{}:,
case 123:
pos++;
return token = 1;
case 125:
pos++;
return token = 2;
case 91:
pos++;
return token = 3;
case 93:
pos++;
return token = 4;
case 58:
pos++;
return token = 6;
case 44:
pos++;
return token = 5;
// strings
case 34:
pos++;
value = scanString();
return token = 10;
// comments
case 47:
const start = pos - 1;
if (text.charCodeAt(pos + 1) === 47) {
pos += 2;
while (pos < len) {
if (isLineBreak(text.charCodeAt(pos))) {
break;
}
pos++;
}
value = text.substring(start, pos);
return token = 12;
}
if (text.charCodeAt(pos + 1) === 42) {
pos += 2;
const safeLength = len - 1;
let commentClosed = false;
while (pos < safeLength) {
const ch = text.charCodeAt(pos);
if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
pos += 2;
commentClosed = true;
break;
}
pos++;
if (isLineBreak(ch)) {
if (ch === 13 && text.charCodeAt(pos) === 10) {
pos++;
}
lineNumber++;
tokenLineStartOffset = pos;
}
}
if (!commentClosed) {
pos++;
scanError = 1;
}
value = text.substring(start, pos);
return token = 13;
}
value += String.fromCharCode(code);
pos++;
return token = 16;
// numbers
case 45:
value += String.fromCharCode(code);
pos++;
if (pos === len || !isDigit(text.charCodeAt(pos))) {
return token = 16;
}
// found a minus, followed by a number so
// we fall through to proceed with scanning
// numbers
case 48:
case 49:
case 50:
case 51:
case 52:
case 53:
case 54:
case 55:
case 56:
case 57:
value += scanNumber();
return token = 11;
// literals and unknown symbols
default:
while (pos < len && isUnknownContentCharacter(code)) {
pos++;
code = text.charCodeAt(pos);
}
if (tokenOffset !== pos) {
value = text.substring(tokenOffset, pos);
switch (value) {
case "true":
return token = 8;
case "false":
return token = 9;
case "null":
return token = 7;
}
return token = 16;
}
value += String.fromCharCode(code);
pos++;
return token = 16;
}
}
function isUnknownContentCharacter(code) {
if (isWhiteSpace(code) || isLineBreak(code)) {
return false;
}
switch (code) {
case 125:
case 93:
case 123:
case 91:
case 34:
case 58:
case 44:
case 47:
return false;
}
return true;
}
function scanNextNonTrivia() {
let result;
do {
result = scanNext();
} while (result >= 12 && result <= 15);
return result;
}
return {
setPosition,
getPosition: () => pos,
scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
getToken: () => token,
getTokenValue: () => value,
getTokenOffset: () => tokenOffset,
getTokenLength: () => pos - tokenOffset,
getTokenStartLine: () => lineStartOffset,
getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
getTokenError: () => scanError
};
}
function isWhiteSpace(ch) {
return ch === 32 || ch === 9;
}
function isLineBreak(ch) {
return ch === 10 || ch === 13;
}
function isDigit(ch) {
return ch >= 48 && ch <= 57;
}
var CharacterCodes;
(function(CharacterCodes2) {
CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
})(CharacterCodes || (CharacterCodes = {}));
// node_modules/jsonc-parser/lib/esm/impl/string-intern.js
var cachedSpaces = new Array(20).fill(0).map((_, index) => {
return " ".repeat(index);
});
var maxCachedValues = 200;
var cachedBreakLinesWithSpaces = {
" ": {
"\n": new Array(maxCachedValues).fill(0).map((_, index) => {
return "\n" + " ".repeat(index);
}),
"\r": new Array(maxCachedValues).fill(0).map((_, index) => {
return "\r" + " ".repeat(index);
}),
"\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
return "\r\n" + " ".repeat(index);
})
},
" ": {
"\n": new Array(maxCachedValues).fill(0).map((_, index) => {
return "\n" + " ".repeat(index);
}),
"\r": new Array(maxCachedValues).fill(0).map((_, index) => {
return "\r" + " ".repeat(index);
}),
"\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
return "\r\n" + " ".repeat(index);
})
}
};
// node_modules/jsonc-parser/lib/esm/impl/parser.js
var ParseOptions;
(function(ParseOptions2) {
ParseOptions2.DEFAULT = {
allowTrailingComma: false
};
})(ParseOptions || (ParseOptions = {}));
function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
let currentParent = { type: "array", offset: -1, length: -1, children: [], parent: void 0 };
function ensurePropertyComplete(endOffset) {
if (currentParent.type === "property") {
currentParent.length = endOffset - currentParent.offset;
currentParent = currentParent.parent;
}
}
function onValue(valueNode) {
currentParent.children.push(valueNode);
return valueNode;
}
const visitor = {
onObjectBegin: (offset) => {
currentParent = onValue({ type: "object", offset, length: -1, parent: currentParent, children: [] });
},
onObjectProperty: (name, offset, length) => {
currentParent = onValue({ type: "property", offset, length: -1, parent: currentParent, children: [] });
currentParent.children.push({ type: "string", value: name, offset, length, parent: currentParent });
},
onObjectEnd: (offset, length) => {
ensurePropertyComplete(offset + length);
currentParent.length = offset + length - currentParent.offset;
currentParent = currentParent.parent;
ensurePropertyComplete(offset + length);
},
onArrayBegin: (offset, length) => {
currentParent = onValue({ type: "array", offset, length: -1, parent: currentParent, children: [] });
},
onArrayEnd: (offset, length) => {
currentParent.length = offset + length - currentParent.offset;
currentParent = currentParent.parent;
ensurePropertyComplete(offset + length);
},
onLiteralValue: (value, offset, length) => {
onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
ensurePropertyComplete(offset + length);
},
onSeparator: (sep3, offset, length) => {
if (currentParent.type === "property") {
if (sep3 === ":") {
currentParent.colonOffset = offset;
} else if (sep3 === ",") {
ensurePropertyComplete(offset);
}
}
},
onError: (error, offset, length) => {
errors.push({ error, offset, length });
}
};
visit(text, visitor, options);
const result = currentParent.children[0];
if (result) {
delete result.parent;
}
return result;
}
function visit(text, visitor, options = ParseOptions.DEFAULT) {
const _scanner = createScanner(text, false);
const _jsonPath = [];
let suppressedCallbacks = 0;
function toNoArgVisit(visitFunction) {
return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
}
function toOneArgVisit(visitFunction) {
return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
}
function toOneArgVisitWithPath(visitFunction) {
return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
}
function toBeginVisit(visitFunction) {
return visitFunction ? () => {
if (suppressedCallbacks > 0) {
suppressedCallbacks++;
} else {
let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
if (cbReturn === false) {
suppressedCallbacks = 1;
}
}
} : () => true;
}
function toEndVisit(visitFunction) {
return visitFunction ? () => {
if (suppressedCallbacks > 0) {
suppressedCallbacks--;
}
if (suppressedCallbacks === 0) {
visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
}
} : () => true;
}
const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
const disallowComments = options && options.disallowComments;
const allowTrailingComma = options && options.allowTrailingComma;
function scanNext() {
while (true) {
const token = _scanner.scan();
switch (_scanner.getTokenError()) {
case 4:
handleError(
14
/* ParseErrorCode.InvalidUnicode */
);
break;
case 5:
handleError(
15
/* ParseErrorCode.InvalidEscapeCharacter */
);
break;
case 3:
handleError(
13
/* ParseErrorCode.UnexpectedEndOfNumber */
);
break;
case 1:
if (!disallowComments) {
handleError(
11
/* ParseErrorCode.UnexpectedEndOfComment */
);
}
break;
case 2:
handleError(
12
/* ParseErrorCode.UnexpectedEndOfString */
);
break;
case 6:
handleError(
16
/* ParseErrorCode.InvalidCharacter */
);
break;
}
switch (token) {
case 12:
case 13:
if (disallowComments) {
handleError(
10
/* ParseErrorCode.InvalidCommentToken */
);
} else {
onComment();
}
break;
case 16:
handleError(
1
/* ParseErrorCode.InvalidSymbol */
);
break;
case 15:
case 14:
break;
default:
return token;
}
}
}
function handleError(error, skipUntilAfter = [], skipUntil = []) {
onError(error);
if (skipUntilAfter.length + skipUntil.length > 0) {
let token = _scanner.getToken();
while (token !== 17) {
if (skipUntilAfter.indexOf(token) !== -1) {
scanNext();
break;
} else if (skipUntil.indexOf(token) !== -1) {
break;
}
token = scanNext();
}
}
}
function parseString(isValue) {
const value = _scanner.getTokenValue();
if (isValue) {
onLiteralValue(value);
} else {
onObjectProperty(value);
_jsonPath.push(value);
}
scanNext();
return true;
}
function parseLiteral() {
switch (_scanner.getToken()) {
case 11:
const tokenValue = _scanner.getTokenValue();
let value = Number(tokenValue);
if (isNaN(value)) {
handleError(
2
/* ParseErrorCode.InvalidNumberFormat */
);
value = 0;
}
onLiteralValue(value);
break;
case 7:
onLiteralValue(null);
break;
case 8:
onLiteralValue(true);
break;
case 9:
onLiteralValue(false);
break;
default:
return false;
}
scanNext();
return true;
}
function parseProperty() {
if (_scanner.getToken() !== 10) {
handleError(3, [], [
2,
5
/* SyntaxKind.CommaToken */
]);
return false;
}
parseString(false);
if (_scanner.getToken() === 6) {
onSeparator(":");
scanNext();
if (!parseValue()) {
handleError(4, [], [
2,
5
/* SyntaxKind.CommaToken */
]);
}
} else {
handleError(5, [], [
2,
5
/* SyntaxKind.CommaToken */
]);
}
_jsonPath.pop();
return true;
}
function parseObject() {
onObjectBegin();
scanNext();
let needsComma = false;
while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
if (_scanner.getToken() === 5) {
if (!needsComma) {
handleError(4, [], []);
}
onSeparator(",");
scanNext();
if (_scanner.getToken() === 2 && allowTrailingComma) {
break;
}
} else if (needsComma) {
handleError(6, [], []);
}
if (!parseProperty()) {
handleError(4, [], [
2,
5
/* SyntaxKind.CommaToken */
]);
}
needsComma = true;
}
onObjectEnd();
if (_scanner.getToken() !== 2) {
handleError(7, [
2
/* SyntaxKind.CloseBraceToken */
], []);
} else {
scanNext();
}
return true;
}
function parseArray() {
onArrayBegin();
scanNext();
let isFirstElement = true;
let needsComma = false;
while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
if (_scanner.getToken() === 5) {
if (!needsComma) {
handleError(4, [], []);
}
onSeparator(",");
scanNext();
if (_scanner.getToken() === 4 && allowTrailingComma) {
break;
}
} else if (needsComma) {
handleError(6, [], []);
}
if (isFirstElement) {
_jsonPath.push(0);
isFirstElement = false;
} else {
_jsonPath[_jsonPath.length - 1]++;
}
if (!parseValue()) {
handleError(4, [], [
4,
5
/* SyntaxKind.CommaToken */
]);
}
needsComma = true;
}
onArrayEnd();
if (!isFirstElement) {
_jsonPath.pop();
}
if (_scanner.getToken() !== 4) {
handleError(8, [
4
/* SyntaxKind.CloseBracketToken */
], []);
} else {
scanNext();
}
return true;
}
function parseValue() {
switch (_scanner.getToken()) {
case 3:
return parseArray();
case 1:
return parseObject();
case 10:
return parseString(true);
default:
return parseLiteral();
}
}
scanNext();
if (_scanner.getToken() === 17) {
if (options.allowEmptyContent) {
return true;
}
handleError(4, [], []);
return false;
}
if (!parseValue()) {
handleError(4, [], []);
return false;
}
if (_scanner.getToken() !== 17) {
handleError(9, [], []);
}
return true;
}
function getNodeType(value) {
switch (typeof value) {
case "boolean":
return "boolean";
case "number":
return "number";
case "string":
return "string";
case "object": {
if (!value) {
return "null";
} else if (Array.isArray(value)) {
return "array";
}
return "object";
}
default:
return "null";
}
}
// node_modules/jsonc-parser/lib/esm/main.js
var ScanError;
(function(ScanError2) {
ScanError2[ScanError2["None"] = 0] = "None";
ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
})(ScanError || (ScanError = {}));
var SyntaxKind;
(function(SyntaxKind2) {
SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
})(SyntaxKind || (SyntaxKind = {}));
var parseTree2 = parseTree;
var ParseErrorCode;
(function(ParseErrorCode2) {
ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
})(ParseErrorCode || (ParseErrorCode = {}));
// dist/src/json.js
var DEFAULT_MAX_JSON_BYTES = 5 * 1024 * 1024;
var DEFAULT_MAX_JSON_DEPTH = 128;
var MAX_DIAGNOSTIC_LABEL_CHARS = 160;
var MAX_DIAGNOSTIC_BODY_CHARS = 768;
var MAX_DIAGNOSTIC_PATH_CHARS = 512;
var MAX_DIAGNOSTIC_KEY_CHARS = 96;
function diagnosticDigest(value) {
return createHash2("sha256").update(value, "utf8").digest("hex").slice(0, 16);
}
function boundDiagnosticText(value, maxChars) {
if (value.length <= maxChars) {
return value;
}
const suffix = `...[sha256:${diagnosticDigest(value)};chars:${value.length}]`;
return `${value.slice(0, Math.max(0, maxChars - suffix.length))}${suffix}`;
}
function diagnosticObjectSegment(key) {
if (key.length <= MAX_DIAGNOSTIC_KEY_CHARS) {
return `[${JSON.stringify(key)}]`;
}
return `[key-sha256:${diagnosticDigest(key)};chars:${key.length}]`;
}
function appendDiagnosticPath(path, segment) {
return boundDiagnosticText(`${path}${segment}`, MAX_DIAGNOSTIC_PATH_CHARS);
}
function diagnosticKey(key) {
return key.length <= MAX_DIAGNOSTIC_KEY_CHARS ? JSON.stringify(key) : `<sha256:${diagnosticDigest(key)};chars:${key.length}>`;
}
var StrictJsonError = class extends Error {
code;
sourceLabel;
offset;
constructor(code, message, sourceLabel = "JSON input", offset) {
super(`${boundDiagnosticText(sourceLabel, MAX_DIAGNOSTIC_LABEL_CHARS)}: ${boundDiagnosticText(message, MAX_DIAGNOSTIC_BODY_CHARS)}`);
this.name = "StrictJsonError";
this.code = code;
this.sourceLabel = boundDiagnosticText(sourceLabel, MAX_DIAGNOSTIC_LABEL_CHARS);
this.offset = offset;
}
};
function decodeUtf8Strict(input, sourceLabel) {
if (input.byteLength >= 3 && input[0] === 239 && input[1] === 187 && input[2] === 191) {
throw new StrictJsonError("UNEXPECTED_BOM", "a UTF-8 BOM is not accepted", sourceLabel, 0);
}
try {
return new TextDecoder("utf-8", { fatal: true, ignoreBOM: false }).decode(input);
} catch (error) {
throw new StrictJsonError("INVALID_UTF8", `input is not valid UTF-8 (${error instanceof Error ? error.message : "decode failed"})`, sourceLabel);
}
}
function locationSuffix(text, offset) {
const boundedOffset = Math.min(text.length, Math.max(0, offset));
let line = 1;
let lastLineBreak = -1;
for (let index = 0; index < boundedOffset; index += 1) {
if (text.charCodeAt(index) === 10) {
line += 1;
lastLineBreak = index;
}
}
return ` at line ${line}, column ${boundedOffset - lastLineBreak}`;
}
function assertNoDuplicateKeys(node, text, sourceLabel, path, depth) {
if (depth > DEFAULT_MAX_JSON_DEPTH) {
throw new StrictJsonError("MAX_DEPTH_EXCEEDED", `nesting exceeds ${DEFAULT_MAX_JSON_DEPTH} levels at ${path}`, sourceLabel, node.offset);
}
if (node.type === "object") {
const seen = /* @__PURE__ */ new Map();
for (const property of node.children ?? []) {
const keyNode = property.children?.[0];
const valueNode = property.children?.[1];
if (keyNode === void 0 || typeof keyNode.value !== "string" || valueNode === void 0) {
throw new StrictJsonError("MALFORMED_OBJECT", `malformed object member at ${path}`, sourceLabel, property.offset);
}
const key = keyNode.value;
const firstOffset = seen.get(key);
if (firstOffset !== void 0) {
throw new StrictJsonError("DUPLICATE_KEY", `duplicate key ${diagnosticKey(key)} at ${path}${locationSuffix(text, keyNode.offset)}; first occurrence at offset ${firstOffset}`, sourceLabel, keyNode.offset);
}
seen.set(key, keyNode.offset);
assertNoDuplicateKeys(valueNode, text, sourceLabel, appendDiagnosticPath(path, diagnosticObjectSegment(key)), depth + 1);
}
return;
}
if (node.type === "array") {
for (const [index, child] of (node.children ?? []).entries()) {
assertNoDuplicateKeys(child, text, sourceLabel, appendDiagnosticPath(path, `[${index}]`), depth + 1);
}
}
}
function assertUnicodeScalarString2(value, sourceLabel, path) {
for (let index = 0; index < value.length; index += 1) {
const codeUnit = value.charCodeAt(index);
if (codeUnit >= 55296 && codeUnit <= 56319) {
const next = value.charCodeAt(index + 1);
if (!(next >= 56320 && next <= 57343)) {
throw new StrictJsonError("INVALID_UNICODE_SCALAR", `unpaired high surrogate at ${path}`, sourceLabel);
}
index += 1;
} else if (codeUnit >= 56320 && codeUnit <= 57343) {
throw new StrictJsonError("INVALID_UNICODE_SCALAR", `unpaired low surrogate at ${path}`, sourceLabel);
}
}
}
function assertUnicodeScalars(value, sourceLabel, path = "$") {
if (typeof value === "number") {
if (!Number.isFinite(value)) {
throw new StrictJsonError("NON_FINITE_NUMBER", `non-finite number is not accepted at ${path}`, sourceLabel);
}
if (Object.is(value, -0)) {
throw new StrictJsonError("NEGATIVE_ZERO", `negative zero is not accepted at ${path}`, sourceLabel);
}
if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
throw new StrictJsonError("UNSAFE_INTEGER", `integer is outside the interoperable safe range at ${path}`, sourceLabel);
}
return;
}
if (typeof value === "string") {
assertUnicodeScalarString2(value, sourceLabel, path);
return;
}
if (Array.isArray(value)) {
for (const [index, item] of value.entries()) {
assertUnicodeScalars(item, sourceLabel, appendDiagnosticPath(path, `[${index}]`));
}
return;
}
if (value !== null && typeof value === "object") {
for (const [key, item] of Object.entries(value)) {
assertUnicodeScalarString2(key, sourceLabel, `${path}/<key>`);
assertUnicodeScalars(item, sourceLabel, appendDiagnosticPath(path, diagnosticObjectSegment(key)));
}
}
}
function parseJsonStrict(input, sourceLabel = "JSON input") {
const text = typeof input === "string" ? input : decodeUtf8Strict(input, sourceLabel);
if (text.startsWith("\uFEFF")) {
throw new StrictJsonError("UNEXPECTED_BOM", "a UTF-8 BOM is not accepted", sourceLabel, 0);
}
let value;
try {
value = JSON.parse(text);
} catch {
throw new StrictJsonError("INVALID_JSON", "invalid JSON document", sourceLabel);
}
const root = parseTree2(text, void 0, {
allowEmptyContent: false,
allowTrailingComma: false,
disallowComments: true
});
if (root === void 0) {
throw new StrictJsonError("INVALID_JSON", "invalid JSON document", sourceLabel);
}
assertNoDuplicateKeys(root, text, sourceLabel, "$", 0);
assertUnicodeScalars(value, sourceLabel);
return value;
}
async function parseJsonFileStrict(filePath, options = {}) {
const maxBytes = options.maxBytes ?? DEFAULT_MAX_JSON_BYTES;
if (!Number.isSafeInteger(maxBytes) || maxBytes < 1) {
throw new RangeError("maxBytes must be a positive safe integer");
}
const metadata = await stat(filePath);
if (!metadata.isFile()) {
throw new StrictJsonError("NOT_A_FILE", "path is not a regular file", options.label ?? filePath);
}
if (metadata.size > maxBytes) {
throw new StrictJsonError("FILE_TOO_LARGE", `file is ${metadata.size} bytes; limit is ${maxBytes}`, options.label ?? filePath);
}
const bytes = await readFile(filePath);
if (bytes.byteLength > maxBytes) {
throw new StrictJsonError("FILE_TOO_LARGE", `file grew beyond the ${maxBytes}-byte limit while being read`, options.label ?? filePath);
}
return parseJsonStrict(bytes, options.label ?? filePath);
}
// dist/src/crypto.js
var PROOF_TYPE = "evaldossier.detached-jws/0.1";
var BASE64URL_32_BYTES = /^[A-Za-z0-9_-]{43}$/;
var BASE64URL_SIGNATURE = /^[A-Za-z0-9_-]{86}$/;
var SignatureError = class extends Error {
code;
constructor(code, message) {
super(message);
this.name = "SignatureError";
this.code = code;
}
};
function isRecord(value) {
return value !== null && typeof value === "object" && !Array.isArray(value);
}
function assertExactKeys(value, expected, label) {
const actual = Object.keys(value).sort();
const wanted = [...expected].sort();
if (actual.length !== wanted.length || actual.some((key, index) => key !== wanted[index])) {
throw new SignatureError("UNEXPECTED_MEMBERS", `${label} must contain exactly ${wanted.join(", ")}`);
}
}
function decodeBase64urlStrict(value, label) {
if (!/^[A-Za-z0-9_-]+$/.test(value) || value.length % 4 === 1) {
throw new SignatureError("INVALID_BASE64URL", `${label} is not unpadded base64url`);
}
const decoded = Buffer.from(value, "base64url");
if (decoded.toString("base64url") !== value) {
throw new SignatureError("NON_CANONICAL_BASE64URL", `${label} is not canonically encoded`);
}
return decoded;
}
function minimalPublicJwk(key) {
return { kty: key.kty, crv: key.crv, x: key.x };
}
function minimalPrivateJwk(key) {
return { kty: key.kty, crv: key.crv, x: key.x, d: key.d };
}
function assertPublicJwk(value) {
if (!isRecord(value)) {
throw new SignatureError("INVALID_KEY", "public key must be a JSON object");
}
assertExactKeys(value, ["alg", "crv", "kid", "kty", "use", "x"], "public JWK");
if (value.kty !== "OKP" || value.crv !== "Ed25519" || value.alg !== "EdDSA" || value.use !== "sig" || typeof value.x !== "string" || typeof value.kid !== "string" || !BASE64URL_32_BYTES.test(value.x) || !BASE64URL_32_BYTES.test(value.kid)) {
throw new SignatureError("INVALID_KEY", "JWK must be an Ed25519 signing key with canonical x and kid");
}
if (decodeBase64urlStrict(value.x, "JWK x").byteLength !== 32) {
throw new SignatureError("INVALID_KEY", "Ed25519 JWK x must encode 32 bytes");
}
const thumbprint = jwkThumbprintUnchecked(value);
if (value.kid !== thumbprint) {
throw new SignatureError("KID_THUMBPRINT_MISMATCH", "JWK kid is not its RFC 7638 thumbprint");
}
}
function assertPrivateJwk(value) {
if (!isRecord(value)) {
throw new SignatureError("INVALID_KEY", "private key must be a JSON object");
}
assertExactKeys(value, ["alg", "crv", "d", "kid", "kty", "use", "x"], "private JWK");
if (typeof value.d !== "string" || !BASE64URL_32_BYTES.test(value.d)) {
throw new SignatureError("INVALID_KEY", "Ed25519 JWK d must be canonical unpadded base64url");
}
if (decodeBase64urlStrict(value.d, "JWK d").byteLength !== 32) {
throw new SignatureError("INVALID_KEY", "Ed25519 JWK d must encode 32 bytes");
}
const publicPart = {
kty: value.kty,
crv: value.crv,
x: value.x,
kid: value.kid,
alg: value.alg,
use: value.use
};
assertPublicJwk(publicPart);
let derivedX;
try {
const privateKey = createPrivateKey({
key: minimalPrivateJwk(value),
format: "jwk"
});
const exported = createPublicKey(privateKey).export({ format: "jwk" });
derivedX = exported.x;
} catch (error) {
throw new SignatureError("INVALID_KEY", `private JWK cannot be imported (${error instanceof Error ? error.message : "unknown error"})`);
}
if (derivedX !== value.x) {
throw new SignatureError("PRIVATE_PUBLIC_MISMATCH", "private JWK d does not correspond to x");
}
}
function jwkThumbprintUnchecked(jwk) {
const members = { crv: jwk.crv, kty: jwk.kty, x: jwk.x };
return createHash3("sha256").update(canonicalBytes(members)).digest("base64url");
}
function jwkThumbprint(jwk) {
if (jwk.kty !== "OKP" || jwk.crv !== "Ed25519" || typeof jwk.x !== "string" || !BASE64URL_32_BYTES.test(jwk.x) || decodeBase64urlStrict(jwk.x, "JWK x").byteLength !== 32) {
throw new SignatureError("INVALID_KEY", "thumbprint input must be an Ed25519 public JWK");
}
return jwkThumbprintUnchecked(jwk);
}
function publicJwkFromPrivate(privateJwk) {
assertPrivateJwk(privateJwk);
return {
kty: "OKP",
crv: "Ed25519",
x: privateJwk.x,
kid: privateJwk.kid,
alg: "EdDSA",
use: "sig"
};
}
function payloadKeyIds(payload) {
const ids = [];
if (typeof payload.signingKeyId === "string") {
ids.push(payload.signingKeyId);
}
const evaluator = payload.evaluator;
if (isRecord(evaluator) && typeof evaluator.keyId === "string") {
ids.push(evaluator.keyId);
}
for (const memberName of ["requester", "collector", "publisher", "exporter"]) {
const signer = payload[memberName];
if (isRecord(signer) && isRecord(signer.key) && typeof signer.key.kid === "string") {
ids.push(signer.key.kid);
}
}
return [...new Set(ids)];
}
function assertPayloadBinding(payload, kid) {
if (payload.protocolVersion !== "evaldossier/0.1") {
throw new SignatureError("INVALID_PROTOCOL_VERSION", "signed payload has an unsupported protocolVersion");
}
if (typeof payload.schemaVersion !== "string" || payload.schemaVersion.length === 0) {
throw new SignatureError("MISSING_SCHEMA_VERSION", "signed payload must declare schemaVersion");
}
const keyIds = payloadKeyIds(payload);
if (keyIds.length === 0) {
throw new SignatureError("MISSING_KEY_BINDING", "signed payload does not bind a signing key ID");
}
if (keyIds.some((payloadKid) => payloadKid !== kid)) {
throw new SignatureError("KEY_BINDING_MISMATCH", `payload key binding does not match JWK thumbprint ${kid}`);
}
return payload.schemaVersion;
}
function protectedHeader(schemaVersion, kid) {
return { alg: "EdDSA", kid, typ: schemaVersion };
}
function attachProof(payload, proof) {
return { ...payload, proof };
}
function signObject(payload, privateJwk) {
if (Object.hasOwn(payload, "proof")) {
throw new SignatureError("PROOF_ALREADY_PRESENT", "refusing to replace an existing proof");
}
assertPrivateJwk(privateJwk);
const schemaVersion = assertPayloadBinding(payload, privateJwk.kid);
const header = protectedHeader(schemaVersion, privateJwk.kid);
const encodedHeader = canonicalBytes(header).toString("base64url");
const encodedPayload = canonicalBytes(payload).toString("base64url");
const signingInput = Buffer.from(`${encodedHeader}.${encodedPayload}`, "ascii");
let signature;
try {
const key = createPrivateKey({ key: minimalPrivateJwk(privateJwk), format: "jwk" });
signature = ed25519Sign(null, signingInput, key);
} catch (error) {
throw new SignatureError("SIGNING_FAILED", error instanceof Error ? error.message : "Ed25519 signing failed");
}
if (signature.byteLength !== 64) {
throw new SignatureError("SIGNING_FAILED", "Ed25519 signature was not 64 bytes");
}
return attachProof(payload, {
type: PROOF_TYPE,
jws: `${encodedHeader}..${signature.toString("base64url")}`
});
}
function signedPayload(value) {
if (!isRecord(value) || Array.isArray(value)) {
throw new SignatureError("INVALID_PAYLOAD", "signed protocol object must be a JSON object");
}
const proof = value.proof;
if (!isRecord(proof)) {
throw new SignatureError("MISSING_PROOF", "signed protocol object has no proof object");
}
assertExactKeys(proof, ["jws", "type"], "proof");
if (proof.type !== PROOF_TYPE || typeof proof.jws !== "string") {
throw new SignatureError("INVALID_PROOF", `proof must use ${PROOF_TYPE}`);
}
if (proof.jws.length > 1024) {
throw new SignatureError("INVALID_PROOF", "proof JWS exceeds the 1024-character protocol limit");
}
return {
payload: withoutProof(value),
proof
};
}
function verifyObjectSignature(value, publicJwk) {
assertPublicJwk(publicJwk);
const { payload, proof } = signedPayload(value);
const schemaVersion = assertPayloadBinding(payload, publicJwk.kid);
const parts = proof.jws.split(".");
if (parts.length !== 3 || parts[1] !== "" || parts[0] === void 0 || parts[2] === void 0) {
throw new SignatureError("INVALID_COMPACT_JWS", "proof JWS must use detached compact serialization");
}
const headerBytes = decodeBase64urlStrict(parts[0], "JWS protected header");
const parsedHeader = parseJsonStrict(headerBytes, "JWS protected header");
if (!isRecord(parsedHeader)) {
throw new SignatureError("INVALID_PROTECTED_HEADER", "protected header must be a JSON object");
}
assertExactKeys(parsedHeader, ["alg", "kid", "typ"], "JWS protected header");
if (parsedHeader.alg !== "EdDSA" || parsedHeader.kid !== publicJwk.kid || parsedHeader.typ !== schemaVersion) {
throw new SignatureError("PROTECTED_HEADER_MISMATCH", "protected header must bind EdDSA, the JWK thumbprint and payload schemaVersion");
}
const expectedHeader = protectedHeader(schemaVersion, publicJwk.kid);
const canonicalHeaderBytes = canonicalBytes(expectedHeader);
if (headerBytes.byteLength !== canonicalHeaderBytes.byteLength || !timingSafeEqual2(headerBytes, canonicalHeaderBytes)) {
throw new SignatureError("NON_CANONICAL_HEADER", "protected header JSON is not canonical JCS");
}
if (!BASE64URL_SIGNATURE.test(parts[2])) {
throw new SignatureError("INVALID_SIGNATURE_ENCODING", "Ed25519 signature must be canonical base64url");
}
const signature = decodeBase64urlStrict(parts[2], "JWS signature");
if (signature.byteLength !== 64) {
throw new SignatureError("INVALID_SIGNATURE_ENCODING", "Ed25519 signature must encode 64 bytes");
}
const encodedPayload = canonicalBytes(payload).toString("base64url");
const signingInput = Buffer.from(`${parts[0]}.${encodedPayload}`, "ascii");
let valid;
try {
const key = createPublicKey({ key: minimalPublicJwk(publicJwk), format: "jwk" });
valid = ed25519Verify(null, signingInput, key, signature);
} catch (error) {
throw new SignatureError("VERIFICATION_FAILED", error instanceof Error ? error.message : "Ed25519 verification failed");
}
return {
valid,
keyId: publicJwk.kid,
schemaVersion,
protectedHeader: expectedHeader
};
}
// dist/src/fs-safe.js
import { constants } from "node:fs";
import { lstat, open, realpath } from "node:fs/promises";
import { isAbsolute, relative, resolve, sep, win32 } from "node:path";
var DEFAULT_MAX_DOSSIER_FILE_BYTES = 5 * 1024 * 1024;
var DEFAULT_MAX_DOSSIER_PATH_BYTES = 200;
var UnsafeDossierPathError = class extends Error {
code;
constructor(code, message) {
super(message);
this.name = "UnsafeDossierPathError";
this.code = code;
}
};
function assertPositiveLimit(value, name) {
if (!Number.isSafeInteger(value) || value < 1) {
throw new RangeError(`${name} must be a positive safe integer`);
}
}
function pathIsWithin(root, candidate) {
const fromRoot = relative(root, candidate);
return fromRoot !== "" && fromRoot !== ".." && !fromRoot.startsWith(`..${sep}`) && !isAbsolute(fromRoot);
}
function isReservedWindowsDeviceSegment(segment) {
const [withoutStream = ""] = segment.split(":", 1);
const [withoutExtension = ""] = withoutStream.split(".", 1);
const baseName = withoutExtension.replace(/[ .]+$/u, "");
return /^(?:CON|PRN|AUX|NUL|CONIN\$|CONOUT\$|COM[0-9¹²³]|LPT[0-9¹²³])$/iu.test(baseName);
}
function validateDossierRelativePath(relativePath, maxPathBytes = DEFAULT_MAX_DOSSIER_PATH_BYTES) {
assertPositiveLimit(maxPathBytes, "maxPathBytes");
if (typeof relativePath !== "string" || relativePath.length === 0) {
throw new UnsafeDossierPathError("EMPTY_PATH", "dossier path must be a non-empty string");
}
if (Buffer.byteLength(relativePath, "utf8") > maxPathBytes) {
throw new UnsafeDossierPathError("PATH_TOO_LONG", `dossier path exceeds the ${maxPathBytes}-byte limit`);
}
if (relativePath.includes("\0")) {
throw new UnsafeDossierPathError("NUL_BYTE", "dossier path contains a NUL byte");
}
if (relativePath.includes("\\")) {
throw new UnsafeDossierPathError("BACKSLASH", "dossier paths must use forward slashes");
}
if (isAbsolute(relativePath) || win32.isAbsolute(relativePath)) {
throw new UnsafeDossierPathError("ABSOLUTE_PATH", "absolute dossier paths are forbidden");
}
const segments = relativePath.split("/");
if (segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
throw new UnsafeDossierPathError("UNSAFE_SEGMENT", "empty, current-directory and parent-directory path segments are forbidden");
}
if (segments.some(isReservedWindowsDeviceSegment)) {
throw new UnsafeDossierPathError("RESERVED_WINDOWS_DEVICE", "dossier path contains a reserved Windows device name");
}
if (segments.some((segment) => /[ .]$/u.test(segment))) {
throw new UnsafeDossierPathError("WINDOWS_NORMALIZED_SEGMENT", "dossier path segments must not end with a dot or space");
}
if (!/^[A-Za-z0-9._/-]+$/.test(relativePath)) {
throw new UnsafeDossierPathError("UNSAFE_CHARACTER", "dossier path contains a character outside [A-Za-z0-9._/-]");
}
return segments;
}
async function resolveSafeDossierPath(dossierRoot, relativePath, options = {}) {
const maxBytes = options.maxBytes ?? DEFAULT_MAX_DOSSIER_FILE_BYTES;
const maxPathBytes = options.maxPathBytes ?? DEFAULT_MAX_DOSSIER_PATH_BYTES;
const requireRegularFile = options.requireRegularFile ?? true;
assertPositiveLimit(maxBytes, "maxBytes");
assertPositiveLimit(maxPathBytes, "maxPathBytes");
const segments = validateDossierRelativePath(relativePath, maxPathBytes);
const lexicalRoot = resolve(dossierRoot);
const rootMetadata = await lstat(lexicalRoot);
if (rootMetadata.isSymbolicLink()) {
throw new UnsafeDossierPathError("SYMLINK_ROOT", "dossier root must not be a symbolic link");
}
if (!rootMetadata.isDirectory()) {
throw new UnsafeDossierPathError("INVALID_ROOT", "dossier root is not a directory");
}
const canonicalRoot = await realpath(lexicalRoot);
const candidate = resolve(canonicalRoot, ...segments);
if (!pathIsWithin(canonicalRoot, candidate)) {
throw new UnsafeDossierPathError("PATH_ESCAPE", "dossier path escapes its root");
}
let cursor = canonicalRoot;
for (const [index, segment] of segments.entries()) {
cursor = resolve(cursor, segment);
const metadata = await lstat(cursor);
if (metadata.isSymbolicLink()) {
throw new UnsafeDossierPathError("SYMLINK_COMPONENT", `symbolic link is forbidden at path segment ${index + 1}`);
}
const final = index === segments.length - 1;
if (!final && !metadata.isDirectory()) {
throw new UnsafeDossierPathError("NON_DIRECTORY_COMPONENT", `path segment ${index + 1} is not a directory`);
}
if (final && requireRegularFile && !metadata.isFile()) {
throw new UnsafeDossierPathError("NOT_REGULAR_FILE", "dossier artifact is not a regular file");
}
if (final && metadata.isFile() && metadata.nlink !== 1) {
throw new UnsafeDossierPathError("HARDLINK", "hard-linked dossier artifacts are forbidden");
}
if (final && metadata.size > maxBytes) {
throw new UnsafeDossierPathError("FILE_TOO_LARGE", `dossier artifact is ${metadata.size} bytes; limit is ${maxBytes}`);
}
}
const canonicalCandidate = await realpath(candidate);
if (!pathIsWithin(canonicalRoot, canonicalCandidate)) {
throw new UnsafeDossierPathError("PATH_ESCAPE", "resolved dossier path escapes its root");
}
if (canonicalCandidate !== candidate) {
throw new UnsafeDossierPathError("NON_CANONICAL_PATH", "dossier path does not resolve to the exact confined path");
}
return canonicalCandidate;
}
async function readSafeDossierFile(dossierRoot, relativePath, options = {}) {
const maxBytes = options.maxBytes ?? DEFAULT_MAX_DOSSIER_FILE_BYTES;
const safePath = await resolveSafeDossierPath(dossierRoot, relativePath, {
...options,
maxBytes,
requireRegularFile: true
});
let handle;
try {
handle = await open(safePath, constants.O_RDONLY | constants.O_NOFOLLOW);
const before = await handle.stat();
if (!before.isFile()) {
throw new UnsafeDossierPathError("NOT_REGULAR_FILE", "opened artifact is not a regular file");
}
if (before.nlink !== 1) {
throw new UnsafeDossierPathError("HARDLINK", "hard-linked dossier artifacts are forbidden");
}
if (before.size > maxBytes) {
throw new UnsafeDossierPathError("FILE_TOO_LARGE", `opened artifact is ${before.size} bytes; limit is ${maxBytes}`);
}
const bytes = await handle.readFile();
if (bytes.byteLength > maxBytes) {
throw new UnsafeDossierPathError("FILE_TOO_LARGE", `artifact grew beyond the ${maxBytes}-byte limit while being read`);
}
return bytes;
} finally {
await handle?.close();
}
}
// dist/src/report.js
function asObject(value, field) {
if (value === null || typeof value !== "object" || Array.isArray(value)) {
throw new Error(`Expected ${field} to be an object`);
}
return value;
}
function asArray(value, field) {
if (!Array.isArray(value)) {
throw new Error(`Expected ${field} to be an array`);
}
return value;
}
function asString(value, field) {
if (typeof value !== "string") {
throw new Error(`Expected ${field} to be a string`);
}
return value;
}
function escapeMarkdown(value) {
return value.replaceAll("\\", "\\\\").replaceAll("|", "\\|").replaceAll("`", "\\`").replace(/[\r\n]+/g, " ");
}
function unique(values) {
return [...new Set(values)].sort();
}
function summarizeAttestation(attestation) {
const assessments = asArray(attestation.assessments, "attestation.assessments");
const objects = assessments.map((assessment, index) => asObject(assessment, `attestation.assessments[${index}]`));
const overall = asObject(attestation.overallAssessment, "attestation.overallAssessment");
const economicAction = asString(attestation.economicAction, "attestation.economicAction");
if (economicAction !== "OUT_OF_SCOPE") {
throw new Error("EvalDossier v0.1 forbids economic actions");
}
return {
bases: unique(objects.map((assessment) => asString(assessment.basis, "assessment.basis"))),
overallBasis: asString(overall.basis, "overallAssessment.basis"),
predicateStatuses: unique(objects.map((assessment) => asString(assessment.predicateStatus, "assessment.predicateStatus"))),
obligationVerdict: asString(attestation.obligationVerdict, "attestation.obligationVerdict"),
economicAction
};
}
function renderAttestationReport(attestation) {
const overall = asObject(attestation.overallAssessment, "attestation.overallAssessment");
const coverage = asObject(attestation.coverage, "attestation.coverage");
const assessments = asArray(attestation.assessments, "attestation.assessments").map((assessment, index) => asObject(assessment, `attestation.assessments[${index}]`));
const summary = summarizeAttestation(attestation);
const rows = assessments.map((assessment) => {
const confidence = assessment.confidence;
const confidenceValue = confidence === void 0 ? "—" : asString(asObject(confidence, "assessment.confidence").value, "assessment.confidence.value");
return `| ${escapeMarkdown(asString(assessment.assessmentId, "assessment.assessmentId"))} | ${escapeMarkdown(asString(assessment.basis, "assessment.basis"))} | ${escapeMarkdown(asString(assessment.assessment, "assessment.assessment"))} | ${escapeMarkdown(asString(assessment.predicateStatus, "assessment.predicateStatus"))} | ${escapeMarkdown(confidenceValue)} | ${escapeMarkdown(asString(assessment.statement, "assessment.statement"))} |`;
});
return [
"# EvalDossier human-readable report",
"",
"> This rendering is committed by the dossier but is not authoritative. Verify the signed JSON objects.",
"",
`- Attestation: \`${escapeMarkdown(asString(attestation.attestationId, "attestation.attestationId"))}\``,
`- Mode: \`${escapeMarkdown(asString(attestation.mode, "attestation.mode"))}\``,
`- Coverage: \`${escapeMarkdown(asString(coverage.status, "coverage.status"))}\``,
`- Overall assessment: \`${escapeMarkdown(asString(overall.assessment, "overallAssessment.assessment"))}\``,
`- Overall basis: \`${escapeMarkdown(summary.overallBasis)}\``,
`- Obligation verdict: \`${escapeMarkdown(summary.obligationVerdict)}\``,
`- Economic action: \`${summary.economicAction}\``,
"",
"| Result | Basis | Assessment | Predicate status | Upstream confidence | Statement |",
"|---|---|---|---|---:|---|",
...rows,
"",
"## Interpretation boundary",
"",
"A valid signature proves integrity and control of a demo signing key. It does not establish institutional identity, independence, factual truth, contractual authority, or a payment instruction.",
""
].join("\n");
}
// dist/src/schema-validator.js
var import__ = __toESM(require__(), 1);
var import_ajv_formats = __toESM(require_dist(), 1);
import { createHash as createHash4 } from "node:crypto";
import { existsSync } from "node:fs";
import { fileURLToPath } from "node:url";
import { resolve as resolve2 } from "node:path";
// dist/src/types.js
var PROTOCOL_SCHEMA_VERSIONS = [
"evaldossier.evaluator-manifest/0.1",
"evaldossier.profile-definition/0.1",
"evaldossier.evaluation-request/0.1",
"evaldossier.evidence-bundle/0.1",
"evaldossier.evaluation-attestation/0.1",
"evaldossier.dossier/0.1"
];
// dist/src/schema-validator.js
var COMMON_SCHEMA_FILE = "common.schema.json";
var addFormats = import_ajv_formats.default;
var PROTOCOL_SCHEMA_FILES = [
"evaluator-manifest.schema.json",
"profile-definition.schema.json",
"evaluation-request.schema.json",
"evidence-bundle.schema.json",
"evaluation-attestation.schema.json",
"dossier.schema.json"
];
var SCHEMA_ID_BY_VERSION = {
"evaldossier.evaluator-manifest/0.1": "https://raw.githubusercontent.com/miguel-herrero-systems/evaldossier/v0.1.0/schemas/evaluator-manifest.schema.json",
"evaldossier.profile-definition/0.1": "https://raw.githubusercontent.com/miguel-herrero-systems/evaldossier/v0.1.0/schemas/profile-definition.schema.json",
"evaldossier.evaluation-request/0.1": "https://raw.githubusercontent.com/miguel-herrero-systems/evaldossier/v0.1.0/schemas/evaluation-request.schema.json",
"evaldossier.evidence-bundle/0.1": "https://raw.githubusercontent.com/miguel-herrero-systems/evaldossier/v0.1.0/schemas/evidence-bundle.schema.json",
"evaldossier.evaluation-attestation/0.1": "https://raw.githubusercontent.com/miguel-herrero-systems/evaldossier/v0.1.0/schemas/evaluation-attestation.schema.json",
"evaldossier.dossier/0.1": "https://raw.githubusercontent.com/miguel-herrero-systems/evaldossier/v0.1.0/schemas/dossier.schema.json"
};
var RESOURCE_LIMITS = {
dossierArtifacts: 64,
assessedCriterionIds: 128,
unassessedCriterionIds: 128,
assessments: 128,
evidenceArtifactIds: 32,
acceptedClassifications: 2,
allowedBases: 6,
obligationEligibleBases: 6
};
var MAX_SCHEMA_DIAGNOSTIC_CHARS = 256;
var MAX_SCHEMA_PARAM_ENTRIES = 16;
var MAX_SCHEMA_PARAM_DEPTH = 4;
var ProtocolSchemaError = class extends Error {
issues;
constructor(message, issues = []) {
super(message);
this.name = "ProtocolSchemaError";
this.issues = issues;
}
};
function diagnosticDigest2(value) {
return createHash4("sha256").update(value, "utf8").digest("hex").slice(0, 16);
}
function boundDiagnosticString(value) {
if (value.length <= MAX_SCHEMA_DIAGNOSTIC_CHARS) {
return value;
}
const suffix = `...[sha256:${diagnosticDigest2(value)};chars:${value.length}]`;
return `${value.slice(0, MAX_SCHEMA_DIAGNOSTIC_CHARS - suffix.length)}${suffix}`;
}
function sanitizeDiagnosticValue(value, depth = 0) {
if (typeof value === "string") {
return boundDiagnosticString(value);
}
if (value === null || typeof value === "boolean") {
return value;
}
if (typeof value === "number") {
return Number.isFinite(value) ? value : String(value);
}
if (depth >= MAX_SCHEMA_PARAM_DEPTH) {
return "[diagnostic value depth omitted]";
}
if (Array.isArray(value)) {
const bounded = value.slice(0, MAX_SCHEMA_PARAM_ENTRIES).map((entry) => sanitizeDiagnosticValue(entry, depth + 1));
if (value.length > MAX_SCHEMA_PARAM_ENTRIES) {
bounded.push(`[${value.length - MAX_SCHEMA_PARAM_ENTRIES} entries omitted]`);
}
return bounded;
}
if (typeof value === "object") {
const entries = Object.entries(value);
const bounded = {};
for (const [key, entry] of entries.slice(0, MAX_SCHEMA_PARAM_ENTRIES)) {
bounded[boundDiagnosticString(key)] = sanitizeDiagnosticValue(entry, depth + 1);
}
if (entries.length > MAX_SCHEMA_PARAM_ENTRIES) {
bounded.__omittedEntries = entries.length - MAX_SCHEMA_PARAM_ENTRIES;
}
return bounded;
}
return `[${typeof value} omitted]`;
}
function sanitizeDiagnosticParams(params) {
return sanitizeDiagnosticValue(params);
}
function issue(error) {
return {
instancePath: boundDiagnosticString(error.instancePath),
schemaPath: boundDiagnosticString(error.schemaPath),
keyword: boundDiagnosticString(error.keyword),
message: boundDiagnosticString(error.message ?? "schema validation failed"),
params: sanitizeDiagnosticParams(error.params)
};
}
function objectValue(value) {
return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
}
function arrayValue(value) {
return Array.isArray(value) ? value : void 0;
}
function maxItemsIssue(instancePath, schemaPath, limit) {
return {
instancePath,
schemaPath,
keyword: "maxItems",
message: `must NOT have more than ${limit} items`,
params: { limit }
};
}
function pushMaxItemsIssue(issues, value, instancePath, schemaPath, limit) {
const entries = arrayValue(value);
if (entries !== void 0 && entries.length > limit) {
issues.push(maxItemsIssue(instancePath, schemaPath, limit));
}
}
function resourceAdmissionIssues(value, schemaVersion) {
const root = objectValue(value);
if (root === void 0) {
return [];
}
const issues = [];
switch (schemaVersion) {
case "evaldossier.dossier/0.1":
pushMaxItemsIssue(issues, root.artifacts, "/artifacts", "#/properties/artifacts/maxItems", RESOURCE_LIMITS.dossierArtifacts);
break;
case "evaldossier.evaluation-attestation/0.1": {
const coverage = objectValue(root.coverage);
if (coverage !== void 0) {
pushMaxItemsIssue(issues, coverage.assessedCriterionIds, "/coverage/assessedCriterionIds", "#/properties/coverage/properties/assessedCriterionIds/maxItems", RESOURCE_LIMITS.assessedCriterionIds);
pushMaxItemsIssue(issues, coverage.unassessedCriterionIds, "/coverage/unassessedCriterionIds", "#/properties/coverage/properties/unassessedCriterionIds/maxItems", RESOURCE_LIMITS.unassessedCriterionIds);
}
const assessments = arrayValue(root.assessments);
pushMaxItemsIssue(issues, assessments, "/assessments", "#/properties/assessments/maxItems", RESOURCE_LIMITS.assessments);
if (assessments !== void 0 && assessments.length <= RESOURCE_LIMITS.assessments) {
for (let index = 0; index < assessments.length; index += 1) {
const assessment = objectValue(assessments[index]);
if (assessment !== void 0) {
pushMaxItemsIssue(issues, assessment.evidenceArtifactIds, `/assessments/${index}/evidenceArtifactIds`, "#/x-evaldossier-operational-limits/evidenceArtifactIds/maxItems", RESOURCE_LIMITS.evidenceArtifactIds);
}
}
}
break;
}
case "evaldossier.evaluator-manifest/0.1": {
const dataPractices = objectValue(root.dataPractices);
if (dataPractices !== void 0) {
pushMaxItemsIssue(issues, dataPractices.acceptedClassifications, "/dataPractices/acceptedClassifications", "#/x-evaldossier-operational-limits/acceptedClassifications/maxItems", RESOURCE_LIMITS.acceptedClassifications);
}
break;
}
case "evaldossier.profile-definition/0.1": {
pushMaxItemsIssue(issues, root.allowedBases, "/allowedBases", "#/x-evaldossier-operational-limits/allowedBases/maxItems", RESOURCE_LIMITS.allowedBases);
const aggregationPolicy = objectValue(root.aggregationPolicy);
if (aggregationPolicy !== void 0) {
pushMaxItemsIssue(issues, aggregationPolicy.obligationEligibleBases, "/aggregationPolicy/obligationEligibleBases", "#/properties/aggregationPolicy/properties/obligationEligibleBases/maxItems", RESOURCE_LIMITS.obligationEligibleBases);
}
break;
}
default:
break;
}
return issues;
}
function protocolSchemaVersion(value) {
if (value === null || typeof value !== "object" || Array.isArray(value)) {
return void 0;
}
const candidate = value.schemaVersion;
return typeof candidate === "string" ? candidate : void 0;
}
function isProtocolSchemaVersion(value) {
return PROTOCOL_SCHEMA_VERSIONS.includes(value);
}
function defaultSchemaDirectory() {
const sourceCandidate = fileURLToPath(new URL("../schemas/", import.meta.url));
if (existsSync(resolve2(sourceCandidate, COMMON_SCHEMA_FILE))) {
return sourceCandidate;
}
const compiledCandidate = fileURLToPath(new URL("../../schemas/", import.meta.url));
if (existsSync(resolve2(compiledCandidate, COMMON_SCHEMA_FILE))) {
return compiledCandidate;
}
throw new ProtocolSchemaError(`cannot locate bundled schemas (checked ${sourceCandidate} and ${compiledCandidate})`);
}
var ProtocolSchemaValidator = class {
schemaDirectory;
#validators = /* @__PURE__ */ new Map();
constructor(schemaDirectory, validators) {
this.schemaDirectory = schemaDirectory;
this.#validators = validators;
}
validateProtocolObject(value, expectedSchemaVersion) {
const declaredVersion = protocolSchemaVersion(value);
if (declaredVersion === void 0) {
return {
valid: false,
errors: [
{
instancePath: "",
schemaPath: "",
keyword: "schemaVersion",
message: "protocol object must declare a string schemaVersion",
params: {}
}
]
};
}
if (expectedSchemaVersion !== void 0 && declaredVersion !== expectedSchemaVersion) {
const diagnosticVersion = boundDiagnosticString(declaredVersion);
return {
valid: false,
schemaVersion: diagnosticVersion,
errors: [
{
instancePath: "/schemaVersion",
schemaPath: "",
keyword: "const",
message: `expected ${expectedSchemaVersion}, received ${diagnosticVersion}`,
params: { allowedValue: expectedSchemaVersion }
}
]
};
}
if (!isProtocolSchemaVersion(declaredVersion)) {
const diagnosticVersion = boundDiagnosticString(declaredVersion);
return {
valid: false,
schemaVersion: diagnosticVersion,
errors: [
{
instancePath: "/schemaVersion",
schemaPath: "",
keyword: "enum",
message: `unsupported protocol schema version ${diagnosticVersion}`,
params: { allowedValues: [...PROTOCOL_SCHEMA_VERSIONS] }
}
]
};
}
const validator = this.#validators.get(declaredVersion);
if (validator === void 0) {
throw new ProtocolSchemaError(`schema validator was not compiled for ${declaredVersion}`);
}
const admissionIssues = resourceAdmissionIssues(value, declaredVersion);
if (admissionIssues.length > 0) {
return {
valid: false,
schemaVersion: declaredVersion,
errors: admissionIssues
};
}
const valid = validator(value);
return {
valid,
schemaVersion: declaredVersion,
errors: valid ? [] : (validator.errors ?? []).map(issue)
};
}
assertProtocolObject(value, expectedSchemaVersion) {
const result = this.validateProtocolObject(value, expectedSchemaVersion);
if (!result.valid) {
const detail = result.errors.map((entry) => `${entry.instancePath || "/"}: ${entry.message}`).join("; ");
throw new ProtocolSchemaError(`protocol schema validation failed: ${detail}`, result.errors);
}
}
};
async function createSchemaValidator(schemaDirectory = defaultSchemaDirectory()) {
const directory = resolve2(schemaDirectory);
const ajv = new import__.Ajv2020({
allErrors: false,
allowUnionTypes: true,
coerceTypes: false,
removeAdditional: false,
useDefaults: false,
strict: true,
// JSON Schema permits conditional `properties` without a repeated local
// `type`; the enclosing object schemas already constrain those locations.
strictTypes: false,
// Likewise, a conditional `required` may name a property declared by its
// enclosing schema rather than redeclaring it inside the `then` branch.
strictRequired: false,
validateFormats: true
});
addFormats(ajv);
const common = await parseJsonFileStrict(resolve2(directory, COMMON_SCHEMA_FILE), {
label: COMMON_SCHEMA_FILE
});
ajv.addSchema(common);
for (const fileName of PROTOCOL_SCHEMA_FILES) {
const schema = await parseJsonFileStrict(resolve2(directory, fileName), {
label: fileName
});
ajv.addSchema(schema);
}
const validators = /* @__PURE__ */ new Map();
for (const schemaVersion of PROTOCOL_SCHEMA_VERSIONS) {
const validator = ajv.getSchema(SCHEMA_ID_BY_VERSION[schemaVersion]);
if (validator === void 0) {
throw new ProtocolSchemaError(`unable to compile schema for ${schemaVersion}`);
}
validators.set(schemaVersion, validator);
}
return new ProtocolSchemaValidator(directory, validators);
}
var defaultValidatorPromise;
async function validateProtocolObject(value, expectedSchemaVersion) {
defaultValidatorPromise ??= createSchemaValidator();
const validator = await defaultValidatorPromise;
return validator.validateProtocolObject(value, expectedSchemaVersion);
}
// dist/src/dossier.js
var OBJECT_FILES = {
EVALUATOR_MANIFEST: "objects/evaluator-manifest.json",
PROFILE_DEFINITION: "objects/profile-definition.json",
EVALUATION_REQUEST: "objects/evaluation-request.json",
EVIDENCE_BUNDLE: "objects/evidence-bundle.json",
EVALUATION_ATTESTATION: "objects/evaluation-attestation.json"
};
var PROTOCOL_ROLES = Object.keys(OBJECT_FILES);
var MAX_DOSSIER_ENTRIES = 64;
var MAX_DOSSIER_FILESYSTEM_NODES = 128;
var MAX_DOSSIER_DIRECTORY_DEPTH = 8;
function isObject(value) {
return value !== null && typeof value === "object" && !Array.isArray(value);
}
function objectAt(value, field) {
if (!isObject(value)) {
throw new Error(`Expected ${field} to be an object`);
}
return value;
}
function arrayAt(value, field) {
if (!Array.isArray(value)) {
throw new Error(`Expected ${field} to be an array`);
}
return value;
}
function stringAt(value, field) {
if (typeof value !== "string") {
throw new Error(`Expected ${field} to be a string`);
}
return value;
}
function booleanAt(value, field) {
if (typeof value !== "boolean") {
throw new Error(`Expected ${field} to be a boolean`);
}
return value;
}
function integerAt(value, field) {
if (typeof value !== "number" || !Number.isSafeInteger(value)) {
throw new Error(`Expected ${field} to be a safe integer`);
}
return value;
}
function timestampAt(value, field) {
const text = stringAt(value, field);
const milliseconds = Date.parse(text);
if (!Number.isFinite(milliseconds)) {
throw new Error(`Invalid timestamp at ${field}`);
}
return milliseconds;
}
function digestAt(value, field) {
const object = objectAt(value, field);
const algorithm = stringAt(object.algorithm, `${field}.algorithm`);
const digest = stringAt(object.value, `${field}.value`);
if (algorithm !== "sha-256" || !/^[a-f0-9]{64}$/.test(digest)) {
throw new Error(`Invalid ${field}`);
}
return { algorithm: "sha-256", value: digest };
}
function sameDigest(left, right) {
return left.algorithm === right.algorithm && left.value === right.value;
}
function sameJsonValue(left, right) {
return canonicalBytes(left).equals(canonicalBytes(right));
}
function setEquals(left, right) {
return left.size === right.size && [...left].every((value) => right.has(value));
}
function decodeJsonPointerSegment(segment, pointer) {
if (/(?:~[^01]|~$)/.test(segment)) {
throw new Error(`Invalid JSON Pointer escape in ${pointer}`);
}
return segment.replaceAll("~1", "/").replaceAll("~0", "~");
}
function resolveJsonPointer(document, pointer) {
if (pointer === "") {
return document;
}
if (!pointer.startsWith("/")) {
throw new Error(`JSON Pointer must start with '/': ${pointer}`);
}
let current = document;
for (const encodedSegment of pointer.slice(1).split("/")) {
const segment = decodeJsonPointerSegment(encodedSegment, pointer);
if (Array.isArray(current)) {
if (!/^(?:0|[1-9][0-9]*)$/.test(segment)) {
throw new Error(`Invalid array index ${JSON.stringify(segment)} in ${pointer}`);
}
const index = Number(segment);
if (!Number.isSafeInteger(index) || index >= current.length) {
throw new Error(`Array index out of range in ${pointer}`);
}
current = current[index];
continue;
}
if (isObject(current) && Object.hasOwn(current, segment)) {
current = current[segment];
continue;
}
throw new Error(`JSON Pointer does not resolve: ${pointer}`);
}
return current;
}
function schemaErrorText(errors) {
return errors.map((error) => `${error.instancePath || "/"}: ${error.message}`).join("; ");
}
function expectDigest(actual, expectedValue, field) {
const expected = digestAt(expectedValue, field);
if (!sameDigest(actual, expected)) {
throw new Error(`${field} does not match the committed object`);
}
}
function publicKeyFrom(value, field) {
return objectAt(value, field);
}
function entryFromObject(value, index) {
const entry = objectAt(value, `dossier.artifacts[${index}]`);
return {
role: stringAt(entry.role, `dossier.artifacts[${index}].role`),
path: stringAt(entry.path, `dossier.artifacts[${index}].path`),
mediaType: stringAt(entry.mediaType, `dossier.artifacts[${index}].mediaType`),
digest: digestAt(entry.digest, `dossier.artifacts[${index}].digest`),
sizeBytes: integerAt(entry.sizeBytes, `dossier.artifacts[${index}].sizeBytes`),
requiredForVerification: booleanAt(entry.requiredForVerification, `dossier.artifacts[${index}].requiredForVerification`)
};
}
function entryJson(entry) {
return {
role: entry.role,
path: entry.path,
mediaType: entry.mediaType,
digest: entry.digest,
sizeBytes: entry.sizeBytes,
requiredForVerification: entry.requiredForVerification
};
}
async function writeCommittedFile(root, relativePath, bytes, role, mediaType, requiredForVerification) {
const destination = safeOutputPath(root, relativePath);
await mkdir(dirname(destination), { recursive: true });
await writeFile(destination, bytes, { flag: "wx" });
return {
role,
path: relativePath,
mediaType,
digest: sha256Bytes(bytes),
sizeBytes: bytes.byteLength,
requiredForVerification
};
}
function safeOutputPath(root, relativePath) {
const segments = validateDossierRelativePath(relativePath, 200);
if (!/^(?:objects|evidence|reports)\/[A-Za-z0-9._/-]+$/.test(relativePath)) {
throw new Error(`Unsafe dossier output path: ${relativePath}`);
}
const absoluteRoot = resolve3(root);
const destination = resolve3(absoluteRoot, ...segments);
const fromRoot = relative2(absoluteRoot, destination);
if (fromRoot === "" || fromRoot === ".." || fromRoot.startsWith(`..${sep2}`) || isAbsolute2(fromRoot)) {
throw new Error(`Dossier output path escapes its root: ${relativePath}`);
}
return destination;
}
function prevalidateOutputPlan(root, relativePaths) {
if (relativePaths.length > MAX_DOSSIER_ENTRIES) {
throw new Error(`Dossier contains too many entries: ${relativePaths.length}`);
}
const portablePaths = /* @__PURE__ */ new Set();
for (const relativePath of relativePaths) {
safeOutputPath(root, relativePath);
const portablePath = relativePath.toLowerCase();
if (portablePaths.has(portablePath)) {
throw new Error(`Duplicate or case-colliding dossier path: ${relativePath}`);
}
portablePaths.add(portablePath);
}
}
async function readSourceArtifact(path) {
const metadata = await lstat2(path);
if (metadata.isSymbolicLink() || !metadata.isFile()) {
throw new Error(`Source artifact must be a regular non-symlink file: ${path}`);
}
if (metadata.nlink !== 1) {
throw new Error(`Hard-linked source artifacts are forbidden: ${path}`);
}
if (metadata.size < 1 || metadata.size > 5 * 1024 * 1024) {
throw new Error(`Source artifact is empty or exceeds 5 MiB: ${path}`);
}
const handle = await open2(path, constants2.O_RDONLY | constants2.O_NOFOLLOW);
try {
const opened = await handle.stat();
if (!opened.isFile() || opened.nlink !== 1 || opened.size < 1 || opened.size > 5 * 1024 * 1024) {
throw new Error(`Source artifact changed or is unsafe: ${path}`);
}
const bytes = await handle.readFile();
if (bytes.byteLength !== opened.size) {
throw new Error(`Source artifact changed while being read: ${path}`);
}
return bytes;
} finally {
await handle.close();
}
}
async function writeProtocolObject(root, relativePath, value, role) {
const validation = await validateProtocolObject(value);
if (!validation.valid) {
throw new Error(`Invalid ${role}: ${schemaErrorText(validation.errors)}`);
}
return writeCommittedFile(root, relativePath, canonicalBytes(value), role, "application/json", true);
}
async function assembleDossier(run, outputDirectory, exporterKey, options) {
const objectValues = [
["EVALUATOR_MANIFEST", run.manifest],
["PROFILE_DEFINITION", run.profile],
["EVALUATION_REQUEST", run.request],
["EVIDENCE_BUNDLE", run.evidenceBundle],
["EVALUATION_ATTESTATION", run.attestation]
];
const sourceArtifacts = run.sourceArtifacts.map((source) => ({ ...source }));
prevalidateOutputPlan(outputDirectory, [
...objectValues.map(([role]) => OBJECT_FILES[role]),
...sourceArtifacts.map(({ dossierPath }) => dossierPath),
"reports/summary.md"
]);
const outputRoot = resolve3(outputDirectory);
await mkdir(outputRoot, { recursive: false });
const createdRoot = await lstat2(outputRoot);
let complete = false;
try {
const entries = [];
for (const [role, value] of objectValues) {
entries.push(await writeProtocolObject(outputRoot, OBJECT_FILES[role], value, role));
}
for (const source of sourceArtifacts) {
const bytes = await readSourceArtifact(source.sourcePath);
entries.push(await writeCommittedFile(outputRoot, source.dossierPath, bytes, "SOURCE_ARTIFACT", source.mediaType, true));
}
const humanReport = Buffer.from(renderAttestationReport(run.attestation), "utf8");
entries.push(await writeCommittedFile(outputRoot, "reports/summary.md", humanReport, "HUMAN_REPORT", "text/markdown", false));
requireUniqueEntries(entries);
const exporterPublicKey = publicJwkFromPrivate(exporterKey);
const unsigned = {
protocolVersion: "evaldossier/0.1",
schemaVersion: "evaldossier.dossier/0.1",
dossierId: options.dossierId,
generatedAt: options.generatedAt,
classification: options.classification,
exporter: {
id: options.exporterId,
key: exporterPublicKey
},
signingKeyId: exporterPublicKey.kid,
artifacts: entries.map(entryJson),
bindings: {
manifestDigest: digestOfObject(run.manifest),
profileDigest: digestOfObject(run.profile),
requestDigest: digestOfObject(run.request),
evidenceBundleDigest: digestOfObject(run.evidenceBundle),
attestationDigest: digestOfObject(run.attestation)
},
warnings: options.warnings ?? [],
economicAction: "OUT_OF_SCOPE",
signatureContext: {
audience: options.audience,
nonce: options.nonce
}
};
const dossier = signObject(unsigned, exporterKey);
const dossierValidation = await validateProtocolObject(dossier);
if (!dossierValidation.valid) {
throw new Error(`Invalid dossier: ${schemaErrorText(dossierValidation.errors)}`);
}
await writeFile(join(outputRoot, "dossier.json"), canonicalBytes(dossier), { flag: "wx" });
complete = true;
return dossier;
} finally {
if (!complete) {
try {
const currentRoot = await lstat2(outputRoot);
if (!currentRoot.isSymbolicLink() && currentRoot.isDirectory() && currentRoot.dev === createdRoot.dev && currentRoot.ino === createdRoot.ino) {
await rm(outputRoot, { recursive: true, force: true });
}
} catch (error) {
if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
throw error;
}
}
}
}
}
function requireUniqueEntries(entries) {
const paths = /* @__PURE__ */ new Set();
for (const entry of entries) {
const portablePath = entry.path.toLowerCase();
if (paths.has(portablePath)) {
throw new Error(`Duplicate or case-colliding dossier path: ${entry.path}`);
}
paths.add(portablePath);
}
for (const role of PROTOCOL_ROLES) {
const count = entries.filter((entry) => entry.role === role).length;
if (count !== 1) {
throw new Error(`Dossier must contain exactly one ${role}; found ${count}`);
}
}
}
async function rejectUnexpectedFiles(root, expectedPaths, directory = root, prefix = "", state = { nodes: 0 }, depth = 0) {
if (depth > MAX_DOSSIER_DIRECTORY_DEPTH) {
throw new Error(`Dossier directory nesting exceeds ${MAX_DOSSIER_DIRECTORY_DEPTH}`);
}
const children = await readdir(directory, { withFileTypes: true });
for (const child of children) {
state.nodes += 1;
if (state.nodes > MAX_DOSSIER_FILESYSTEM_NODES) {
throw new Error(`Dossier tree exceeds ${MAX_DOSSIER_FILESYSTEM_NODES} filesystem entries`);
}
const relativePath = prefix === "" ? child.name : `${prefix}/${child.name}`;
if (child.isSymbolicLink()) {
throw new Error(`Unlisted symbolic link in dossier: ${relativePath}`);
}
if (child.isDirectory()) {
if (![...expectedPaths].some((expected) => expected.startsWith(`${relativePath}/`))) {
throw new Error(`Uncommitted directory in dossier: ${relativePath}`);
}
await rejectUnexpectedFiles(root, expectedPaths, join(directory, child.name), relativePath, state, depth + 1);
continue;
}
if (!child.isFile()) {
throw new Error(`Unsupported filesystem entry in dossier: ${relativePath}`);
}
if (!expectedPaths.has(relativePath)) {
throw new Error(`Uncommitted file in dossier: ${relativePath}`);
}
}
}
function findRole(entries, role) {
const entry = entries.find((candidate) => candidate.role === role);
if (entry === void 0) {
throw new Error(`Missing dossier role ${role}`);
}
return entry;
}
async function verifyEntryBytes(root, entry) {
const bytes = await readSafeDossierFile(root, entry.path);
if (bytes.byteLength !== entry.sizeBytes) {
throw new Error(`Size mismatch for ${entry.path}`);
}
if (!sameDigest(sha256Bytes(bytes), entry.digest)) {
throw new Error(`Digest mismatch for ${entry.path}`);
}
return bytes;
}
async function readProtocolEntry(root, entry) {
const bytes = await verifyEntryBytes(root, entry);
const parsed = parseJsonStrict(bytes, entry.path);
if (!isObject(parsed)) {
throw new Error(`${entry.path} must contain a JSON object`);
}
const validation = await validateProtocolObject(parsed);
if (!validation.valid) {
throw new Error(`Invalid protocol object ${entry.path}: ${schemaErrorText(validation.errors)}`);
}
return parsed;
}
function requireValidSignature(value, key, field) {
const verification = verifyObjectSignature(value, key);
if (!verification.valid) {
throw new Error(`Invalid signature for ${field}`);
}
}
function findManifestKey(manifest, keyId) {
const keys = arrayAt(manifest.keys, "manifest.keys").map((key2, index) => publicKeyFrom(key2, `manifest.keys[${index}]`));
const key = keys.find((candidate) => candidate.kid === keyId);
if (key === void 0) {
throw new Error(`Manifest does not contain signing key ${keyId}`);
}
return key;
}
function verifyCrossBindings(dossier, manifest, profile, request, evidenceBundle, attestation) {
const bindings = objectAt(dossier.bindings, "dossier.bindings");
const actual = {
manifestDigest: digestOfObject(manifest),
profileDigest: digestOfObject(profile),
requestDigest: digestOfObject(request),
evidenceBundleDigest: digestOfObject(evidenceBundle),
attestationDigest: digestOfObject(attestation)
};
expectDigest(actual.manifestDigest, bindings.manifestDigest, "dossier.bindings.manifestDigest");
expectDigest(actual.profileDigest, bindings.profileDigest, "dossier.bindings.profileDigest");
expectDigest(actual.requestDigest, bindings.requestDigest, "dossier.bindings.requestDigest");
expectDigest(actual.evidenceBundleDigest, bindings.evidenceBundleDigest, "dossier.bindings.evidenceBundleDigest");
expectDigest(actual.attestationDigest, bindings.attestationDigest, "dossier.bindings.attestationDigest");
const manifestProfiles = arrayAt(manifest.profiles, "manifest.profiles");
const manifestProfile = manifestProfiles.map((value, index) => objectAt(value, `manifest.profiles[${index}]`)).find((value) => stringAt(value.id, "manifest profile id") === stringAt(profile.profileId, "profile.profileId") && stringAt(value.version, "manifest profile version") === stringAt(profile.version, "profile.version"));
if (manifestProfile === void 0) {
throw new Error("Manifest does not authorize the enclosed profile");
}
expectDigest(actual.profileDigest, manifestProfile.digest, "manifest profile digest");
const requestProfile = objectAt(request.profile, "request.profile");
if (stringAt(requestProfile.id, "request.profile.id") !== stringAt(profile.profileId, "profile.profileId") || stringAt(requestProfile.version, "request.profile.version") !== stringAt(profile.version, "profile.version")) {
throw new Error("Request profile identity does not match the enclosed profile");
}
expectDigest(actual.profileDigest, requestProfile.digest, "request.profile.digest");
if (stringAt(request.targetEvaluatorId, "request.targetEvaluatorId") !== stringAt(manifest.evaluatorId, "manifest.evaluatorId")) {
throw new Error("Request target evaluator does not match the manifest");
}
if (stringAt(request.operation, "request.operation") !== stringAt(profile.operation, "profile.operation")) {
throw new Error("Request operation does not match profile operation");
}
if (stringAt(evidenceBundle.requestId, "evidenceBundle.requestId") !== stringAt(request.requestId, "request.requestId")) {
throw new Error("Evidence bundle is bound to another request");
}
const attestationEvaluator = objectAt(attestation.evaluator, "attestation.evaluator");
if (stringAt(attestationEvaluator.evaluatorId, "attestation.evaluator.evaluatorId") !== stringAt(manifest.evaluatorId, "manifest.evaluatorId")) {
throw new Error("Attestation evaluator does not match the manifest");
}
const manifestSoftware = objectAt(manifest.software, "manifest.software");
if (stringAt(attestationEvaluator.softwareVersion, "attestation.evaluator.softwareVersion") !== stringAt(manifestSoftware.version, "manifest.software.version")) {
throw new Error("Attestation software version does not match the manifest");
}
const operation = stringAt(profile.operation, "profile.operation");
const bindingMode = stringAt(profile.resultBindingMode, "profile.resultBindingMode");
const attestationMode = stringAt(attestation.mode, "attestation.mode");
const evaluatorType = stringAt(manifest.evaluatorType, "manifest.evaluatorType");
const expectedMode = operation === "EVALUATE" ? "NATIVE_EVALUATION" : "UPSTREAM_NORMALIZATION";
if (attestationMode !== expectedMode) {
throw new Error(`Attestation mode ${attestationMode} is incompatible with ${operation}`);
}
if (operation === "EVALUATE" && bindingMode !== "DIRECT_PREDICATE_RESULT" || operation === "NORMALIZE" && bindingMode !== "PRESERVE_UPSTREAM_ASSESSMENT") {
throw new Error("Profile operation and result-binding mode are incompatible");
}
if (attestationMode === "NATIVE_EVALUATION" && !["NATIVE", "HYBRID"].includes(evaluatorType) || attestationMode === "UPSTREAM_NORMALIZATION" && !["ADAPTER", "HYBRID"].includes(evaluatorType)) {
throw new Error(`Evaluator type ${evaluatorType} cannot issue ${attestationMode}`);
}
const attestationBindings = objectAt(attestation.bindings, "attestation.bindings");
expectDigest(actual.manifestDigest, attestationBindings.manifestDigest, "attestation manifest binding");
expectDigest(actual.profileDigest, attestationBindings.profileDigest, "attestation profile binding");
expectDigest(actual.requestDigest, attestationBindings.requestDigest, "attestation request binding");
expectDigest(actual.evidenceBundleDigest, attestationBindings.evidenceBundleDigest, "attestation evidence binding");
const requestContext = objectAt(request.signatureContext, "request.signatureContext");
const attestationContext = objectAt(attestation.signatureContext, "attestation.signatureContext");
if (stringAt(requestContext.audience, "request audience") !== stringAt(attestationContext.audience, "attestation audience")) {
throw new Error("Attestation audience does not match the request");
}
}
function expectedObligationVerdict(profile, request, attestation) {
const aggregation = objectAt(profile.aggregationPolicy, "profile.aggregationPolicy");
const aggregationRule = stringAt(aggregation.rule, "aggregationPolicy.rule");
const eligibleBases = new Set(arrayAt(aggregation.obligationEligibleBases, "aggregationPolicy.obligationEligibleBases").map((basis, index) => stringAt(basis, `obligationEligibleBases[${index}]`)));
const allowedBases = new Set(arrayAt(profile.allowedBases, "profile.allowedBases").map((basis, index) => stringAt(basis, `allowedBases[${index}]`)));
for (const basis of eligibleBases) {
if (!allowedBases.has(basis)) {
throw new Error(`Obligation-eligible basis ${basis} is not allowed by the profile`);
}
}
if (aggregationRule === "PRESERVE_UPSTREAM_OVERALL") {
if (eligibleBases.size !== 0) {
throw new Error("PRESERVE_UPSTREAM_OVERALL cannot establish an obligation in v0.1");
}
return "INCONCLUSIVE";
}
if (aggregationRule !== "ALL_REQUIRED_TRUE") {
throw new Error(`Unsupported aggregation rule: ${aggregationRule}`);
}
const criteria = arrayAt(request.criteria, "request.criteria").map((value, index) => objectAt(value, `request.criteria[${index}]`));
const assessments = arrayAt(attestation.assessments, "attestation.assessments").map((value, index) => objectAt(value, `attestation.assessments[${index}]`));
const criterionIds = /* @__PURE__ */ new Set();
for (const criterion of criteria) {
const id = stringAt(criterion.criterionId, "criterion.criterionId");
if (criterionIds.has(id)) {
throw new Error(`Duplicate criterionId: ${id}`);
}
criterionIds.add(id);
}
const assessmentIds = /* @__PURE__ */ new Set();
const byCriterion = /* @__PURE__ */ new Map();
for (const assessment of assessments) {
const assessmentId = stringAt(assessment.assessmentId, "assessment.assessmentId");
const criterionId = stringAt(assessment.criterionId, "assessment.criterionId");
if (assessmentIds.has(assessmentId) || byCriterion.has(criterionId)) {
throw new Error(`Duplicate assessment or criterion result: ${assessmentId}/${criterionId}`);
}
assessmentIds.add(assessmentId);
byCriterion.set(criterionId, assessment);
const basis = stringAt(assessment.basis, "assessment.basis");
if (!allowedBases.has(basis)) {
throw new Error(`Assessment uses basis not allowed by profile: ${basis}`);
}
if (!eligibleBases.has(basis) && stringAt(assessment.predicateStatus, "assessment.predicateStatus") !== "UNDETERMINED") {
throw new Error(`Ineligible basis ${basis} cannot establish a predicate`);
}
}
let hasFalse = false;
let hasUndetermined = false;
for (const criterion of criteria) {
if (!booleanAt(criterion.required, "criterion.required")) {
continue;
}
const criterionId = stringAt(criterion.criterionId, "criterion.criterionId");
const assessment = byCriterion.get(criterionId);
if (assessment === void 0) {
hasUndetermined = true;
continue;
}
const basis = stringAt(assessment.basis, "assessment.basis");
const status = stringAt(assessment.predicateStatus, "assessment.predicateStatus");
if (!eligibleBases.has(basis) || status === "UNDETERMINED") {
hasUndetermined = true;
} else if (status === "ESTABLISHED_FALSE") {
hasFalse = true;
} else if (status !== "ESTABLISHED_TRUE") {
throw new Error(`Unknown predicate status: ${status}`);
}
}
if (hasFalse) {
return "NOT_SATISFIED";
}
if (hasUndetermined || eligibleBases.size === 0) {
return "INCONCLUSIVE";
}
return "SATISFIED";
}
function verifySemanticBoundary(profile, request, attestation, dossier) {
for (const [object, field] of [
[request, "request.economicBoundary"],
[attestation, "attestation"],
[dossier, "dossier"]
]) {
if (field === "request.economicBoundary") {
const boundary = objectAt(object.economicBoundary, field);
if (stringAt(boundary.paymentExecution, `${field}.paymentExecution`) !== "OUT_OF_SCOPE" || stringAt(boundary.paymentRecommendation, `${field}.paymentRecommendation`) !== "OUT_OF_SCOPE") {
throw new Error("Evaluation request crosses the v0.1 economic boundary");
}
} else if (stringAt(object.economicAction, `${field}.economicAction`) !== "OUT_OF_SCOPE") {
throw new Error(`${field} crosses the v0.1 economic boundary`);
}
}
const expected = expectedObligationVerdict(profile, request, attestation);
const actual = stringAt(attestation.obligationVerdict, "attestation.obligationVerdict");
if (actual !== expected) {
throw new Error(`Invalid obligation verdict: expected ${expected}, got ${actual}`);
}
}
function verifyTemporalBindings(dossier, manifest, profile, request, evidenceBundle, attestation) {
const manifestIssued = timestampAt(manifest.issuedAt, "manifest.issuedAt");
const manifestExpires = timestampAt(manifest.expiresAt, "manifest.expiresAt");
const profilePublished = timestampAt(profile.publishedAt, "profile.publishedAt");
const requestCreated = timestampAt(request.createdAt, "request.createdAt");
const requestExpires = timestampAt(request.expiresAt, "request.expiresAt");
const evidenceCaptured = timestampAt(evidenceBundle.capturedAt, "evidenceBundle.capturedAt");
const attestationIssued = timestampAt(attestation.issuedAt, "attestation.issuedAt");
const dossierGenerated = timestampAt(dossier.generatedAt, "dossier.generatedAt");
if (manifestIssued > manifestExpires) {
throw new Error("Manifest validity interval is reversed");
}
if (requestCreated > requestExpires) {
throw new Error("Request validity interval is reversed");
}
if (profilePublished > requestCreated) {
throw new Error("Request predates the enclosed profile");
}
if (attestationIssued < manifestIssued || attestationIssued > manifestExpires) {
throw new Error("Attestation was issued outside the manifest validity interval");
}
if (attestationIssued < requestCreated || attestationIssued > requestExpires) {
throw new Error("Attestation was issued outside the request validity interval");
}
if (attestationIssued < evidenceCaptured) {
throw new Error("Attestation predates its evidence capture");
}
if (request.operation === "EVALUATE" && evidenceCaptured < requestCreated) {
throw new Error("Native evaluation evidence predates its request");
}
if (dossierGenerated < attestationIssued) {
throw new Error("Dossier predates its attestation");
}
}
function verifyEvidenceEntries(entries, evidenceBundle) {
const sourceEntries = new Map(entries.filter((entry) => entry.role === "SOURCE_ARTIFACT").map((entry) => [entry.path, entry]));
const provenance = [];
const artifactIds = /* @__PURE__ */ new Set();
const usedPaths = /* @__PURE__ */ new Set();
const artifacts = arrayAt(evidenceBundle.artifacts, "evidenceBundle.artifacts");
for (let index = 0; index < artifacts.length; index += 1) {
const artifact = objectAt(artifacts[index], `evidenceBundle.artifacts[${index}]`);
const artifactId = stringAt(artifact.artifactId, `evidenceBundle.artifacts[${index}].artifactId`);
if (artifactIds.has(artifactId)) {
throw new Error(`Duplicate evidence artifactId: ${artifactId}`);
}
artifactIds.add(artifactId);
const path = stringAt(artifact.path, `evidenceBundle.artifacts[${index}].path`);
if (usedPaths.has(path)) {
throw new Error(`Multiple evidence artifacts reference the same dossier path: ${path}`);
}
usedPaths.add(path);
const entry = sourceEntries.get(path);
if (entry === void 0) {
throw new Error(`Evidence bundle references uncommitted source artifact ${path}`);
}
expectDigest(entry.digest, artifact.digest, `evidence artifact ${artifactId} digest`);
if (entry.sizeBytes !== integerAt(artifact.sizeBytes, `evidence artifact ${artifactId} sizeBytes`)) {
throw new Error(`Evidence artifact size mismatch: ${artifactId}`);
}
const source = objectAt(artifact.source, `evidence artifact ${artifactId}.source`);
const originAuthentication = stringAt(source.originAuthentication, `evidence artifact ${artifactId}.originAuthentication`);
if (originAuthentication === "SOURCE_SIGNED") {
throw new Error(`SOURCE_SIGNED provenance is unsupported until a portable origin proof is committed and verified: ${artifactId}`);
}
provenance.push(originAuthentication);
}
if (!setEquals(new Set(sourceEntries.keys()), usedPaths)) {
throw new Error("Dossier contains source artifacts not referenced by the evidence bundle");
}
return [...new Set(provenance)].sort();
}
function verifyDeclaredGraph(entries, profile, request, evidenceBundle, attestation) {
const allowedBases = new Set(arrayAt(profile.allowedBases, "profile.allowedBases").map((value, index) => stringAt(value, `profile.allowedBases[${index}]`)));
const predicates = /* @__PURE__ */ new Map();
for (const [index, value] of arrayAt(profile.predicates, "profile.predicates").entries()) {
const predicate = objectAt(value, `profile.predicates[${index}]`);
const id = stringAt(predicate.predicateId, `profile.predicates[${index}].predicateId`);
if (predicates.has(id)) {
throw new Error(`Duplicate profile predicateId: ${id}`);
}
const predicateBasis = stringAt(predicate.basis, `profile.predicates[${index}].basis`);
if (!allowedBases.has(predicateBasis)) {
throw new Error(`Profile predicate ${id} uses undeclared basis ${predicateBasis}`);
}
predicates.set(id, predicate);
}
const criteria = /* @__PURE__ */ new Map();
for (const [index, value] of arrayAt(request.criteria, "request.criteria").entries()) {
const criterion = objectAt(value, `request.criteria[${index}]`);
const id = stringAt(criterion.criterionId, `request.criteria[${index}].criterionId`);
const predicateId = stringAt(criterion.predicateId, `request.criteria[${index}].predicateId`);
if (criteria.has(id)) {
throw new Error(`Duplicate request criterionId: ${id}`);
}
if (!predicates.has(predicateId)) {
throw new Error(`Criterion ${id} references unknown profile predicate ${predicateId}`);
}
criteria.set(id, criterion);
}
const requestArtifacts = /* @__PURE__ */ new Map();
for (const [index, value] of arrayAt(request.artifacts, "request.artifacts").entries()) {
const artifact = objectAt(value, `request.artifacts[${index}]`);
const id = stringAt(artifact.artifactId, `request.artifacts[${index}].artifactId`);
if (requestArtifacts.has(id)) {
throw new Error(`Duplicate request artifactId: ${id}`);
}
requestArtifacts.set(id, artifact);
}
const evidenceArtifacts = /* @__PURE__ */ new Map();
for (const [index, value] of arrayAt(evidenceBundle.artifacts, "evidenceBundle.artifacts").entries()) {
const artifact = objectAt(value, `evidenceBundle.artifacts[${index}]`);
const id = stringAt(artifact.artifactId, `evidenceBundle.artifacts[${index}].artifactId`);
if (evidenceArtifacts.has(id)) {
throw new Error(`Duplicate evidence artifactId: ${id}`);
}
const requested = requestArtifacts.get(id);
if (requested === void 0) {
throw new Error(`Evidence artifact ${id} was not committed by the request`);
}
if (stringAt(artifact.role, `evidence artifact ${id}.role`) !== stringAt(requested.role, `request artifact ${id}.role`) || stringAt(artifact.mediaType, `evidence artifact ${id}.mediaType`) !== stringAt(requested.mediaType, `request artifact ${id}.mediaType`)) {
throw new Error(`Evidence artifact ${id} changes the requested role or media type`);
}
if (stringAt(requested.commitmentMode, `request artifact ${id}.commitmentMode`) !== "EXACT_INPUT") {
throw new Error(`Unsupported request artifact commitment mode for ${id}`);
}
const requestedDigest = digestAt(requested.digest, `request artifact ${id}.digest`);
const observedDigest = digestAt(artifact.digest, `evidence artifact ${id}.digest`);
if (!sameDigest(requestedDigest, observedDigest)) {
throw new Error(`Evidence artifact ${id} does not match its exact request digest commitment`);
}
if (integerAt(requested.sizeBytes, `request artifact ${id}.sizeBytes`) !== integerAt(artifact.sizeBytes, `evidence artifact ${id}.sizeBytes`)) {
throw new Error(`Evidence artifact ${id} does not match its exact request size commitment`);
}
const entry = entries.find((candidate) => candidate.role === "SOURCE_ARTIFACT" && candidate.path === stringAt(artifact.path, `evidence artifact ${id}.path`));
if (entry === void 0 || entry.mediaType !== stringAt(artifact.mediaType, `evidence artifact ${id}.mediaType`)) {
throw new Error(`Dossier entry for evidence artifact ${id} has the wrong media type`);
}
evidenceArtifacts.set(id, artifact);
}
if (requestArtifacts.size !== evidenceArtifacts.size) {
throw new Error("Not every requested artifact is present in the evidence bundle");
}
const resultCriteria = /* @__PURE__ */ new Set();
for (const [index, value] of arrayAt(attestation.assessments, "attestation.assessments").entries()) {
const assessment = objectAt(value, `attestation.assessments[${index}]`);
const criterionId = stringAt(assessment.criterionId, `attestation.assessments[${index}].criterionId`);
const criterion = criteria.get(criterionId);
if (criterion === void 0) {
throw new Error(`Assessment references unknown criterion ${criterionId}`);
}
if (resultCriteria.has(criterionId)) {
throw new Error(`Multiple assessments target criterion ${criterionId}`);
}
resultCriteria.add(criterionId);
const predicateId = stringAt(criterion.predicateId, `criterion ${criterionId}.predicateId`);
const predicate = predicates.get(predicateId);
if (predicate === void 0) {
throw new Error(`Criterion ${criterionId} references unknown predicate ${predicateId}`);
}
const expectedBasis = stringAt(predicate.basis, `predicate ${predicateId}.basis`);
const actualBasis = stringAt(assessment.basis, `assessment ${criterionId}.basis`);
if (actualBasis !== expectedBasis) {
throw new Error(`Assessment basis ${actualBasis} does not match predicate ${predicateId} basis ${expectedBasis}`);
}
for (const [referenceIndex, reference] of arrayAt(assessment.evidenceArtifactIds, `attestation.assessments[${index}].evidenceArtifactIds`).entries()) {
const artifactId = stringAt(reference, `attestation.assessments[${index}].evidenceArtifactIds[${referenceIndex}]`);
if (!evidenceArtifacts.has(artifactId)) {
throw new Error(`Assessment references unknown evidence artifact ${artifactId}`);
}
}
}
const coverage = objectAt(attestation.coverage, "attestation.coverage");
const assessedCoverage = new Set(arrayAt(coverage.assessedCriterionIds, "coverage.assessedCriterionIds").map((value, index) => stringAt(value, `coverage.assessedCriterionIds[${index}]`)));
const unassessedCoverage = new Set(arrayAt(coverage.unassessedCriterionIds, "coverage.unassessedCriterionIds").map((value, index) => stringAt(value, `coverage.unassessedCriterionIds[${index}]`)));
if (!setEquals(assessedCoverage, resultCriteria)) {
throw new Error("Coverage assessedCriterionIds do not match the actual assessments");
}
for (const id of unassessedCoverage) {
if (!criteria.has(id) || assessedCoverage.has(id)) {
throw new Error(`Invalid or overlapping unassessed criterion ${id}`);
}
}
const expectedUnassessed = new Set([...criteria.keys()].filter((id) => !resultCriteria.has(id)));
if (!setEquals(unassessedCoverage, expectedUnassessed)) {
throw new Error("Coverage does not partition every requested criterion");
}
const expectedCoverageStatus = assessedCoverage.size === criteria.size ? "COMPLETE" : assessedCoverage.size === 0 ? "UNKNOWN" : "PARTIAL";
if (stringAt(coverage.status, "coverage.status") !== expectedCoverageStatus) {
throw new Error(`Coverage status must be ${expectedCoverageStatus}`);
}
const aggregation = objectAt(profile.aggregationPolicy, "profile.aggregationPolicy");
const aggregationRule = stringAt(aggregation.rule, "aggregationPolicy.rule");
const overall = objectAt(attestation.overallAssessment, "attestation.overallAssessment");
const overallBasis = stringAt(overall.basis, "attestation.overallAssessment.basis");
if (overallBasis !== "MIXED" && !allowedBases.has(overallBasis)) {
throw new Error(`Overall assessment uses basis not allowed by profile: ${overallBasis}`);
}
const requestedPredicateBases = new Set([...criteria.values()].map((criterion) => {
const predicateId = stringAt(criterion.predicateId, "criterion.predicateId");
const predicate = predicates.get(predicateId);
if (predicate === void 0) {
throw new Error(`Criterion references unknown predicate ${predicateId}`);
}
return stringAt(predicate.basis, `predicate ${predicateId}.basis`);
}));
const expectedOverallBasis = requestedPredicateBases.size === 1 ? [...requestedPredicateBases][0] : "MIXED";
if (overallBasis !== expectedOverallBasis) {
throw new Error(`Overall basis must be ${expectedOverallBasis} for the requested criteria`);
}
if (aggregationRule === "ALL_REQUIRED_TRUE") {
const expectedVerdict = expectedObligationVerdict(profile, request, attestation);
const expectedAssessment = expectedVerdict === "SATISFIED" ? "AFFIRMED" : expectedVerdict === "NOT_SATISFIED" ? "REJECTED" : "INCONCLUSIVE";
if (stringAt(overall.assessment, "overallAssessment.assessment") !== expectedAssessment) {
throw new Error(`Overall assessment must be ${expectedAssessment} for ${expectedVerdict}`);
}
} else if (aggregationRule === "PRESERVE_UPSTREAM_OVERALL") {
if (stringAt(profile.operation, "profile.operation") !== "NORMALIZE") {
throw new Error("PRESERVE_UPSTREAM_OVERALL requires a normalization profile");
}
} else {
throw new Error(`Unsupported aggregation rule: ${aggregationRule}`);
}
}
async function verifyUpstreamMappings(root, profile, evidenceBundle, attestation) {
const operation = stringAt(profile.operation, "profile.operation");
const policy = objectAt(profile.mappingPolicy, "profile.mappingPolicy");
const policyId = stringAt(policy.policyId, "profile.mappingPolicy.policyId");
const artifacts = /* @__PURE__ */ new Map();
for (const [index, value] of arrayAt(evidenceBundle.artifacts, "evidenceBundle.artifacts").entries()) {
const artifact = objectAt(value, `evidenceBundle.artifacts[${index}]`);
artifacts.set(stringAt(artifact.artifactId, `evidence artifact ${index}.artifactId`), artifact);
}
const mappings = [];
const overall = objectAt(attestation.overallAssessment, "attestation.overallAssessment");
if (overall.upstreamMapping !== void 0) {
mappings.push({
mapping: objectAt(overall.upstreamMapping, "overallAssessment.upstreamMapping"),
label: "overallAssessment.upstreamMapping"
});
} else if (operation === "NORMALIZE") {
throw new Error("Normalization overall assessment must declare upstreamMapping");
}
for (const [index, value] of arrayAt(attestation.assessments, "attestation.assessments").entries()) {
const assessment = objectAt(value, `attestation.assessments[${index}]`);
const evidenceIds = new Set(arrayAt(assessment.evidenceArtifactIds, `assessment ${index}.evidenceArtifactIds`).map((id, idIndex) => stringAt(id, `assessment ${index}.evidenceArtifactIds[${idIndex}]`)));
if (assessment.upstreamMapping !== void 0) {
mappings.push({
mapping: objectAt(assessment.upstreamMapping, `assessment ${index}.upstreamMapping`),
evidenceIds,
label: `assessment ${index}.upstreamMapping`
});
} else if (operation === "NORMALIZE") {
throw new Error(`Normalization assessment ${index} must declare upstreamMapping`);
}
}
if (operation !== "NORMALIZE") {
if (mappings.length !== 0) {
throw new Error("Native evaluations must not declare upstream mappings");
}
return;
}
const parsedSources = /* @__PURE__ */ new Map();
for (const { mapping, evidenceIds, label } of mappings) {
const sourceArtifactId = stringAt(mapping.sourceArtifactId, `${label}.sourceArtifactId`);
const artifact = artifacts.get(sourceArtifactId);
if (artifact === void 0) {
throw new Error(`${label} references unknown source artifact ${sourceArtifactId}`);
}
if (evidenceIds !== void 0 && !evidenceIds.has(sourceArtifactId)) {
throw new Error(`${label} source artifact is not cited by its assessment`);
}
if (stringAt(mapping.mappingPolicyId, `${label}.mappingPolicyId`) !== policyId) {
throw new Error(`${label} does not use the signed profile mapping policy`);
}
const mediaType = stringAt(artifact.mediaType, `evidence artifact ${sourceArtifactId}.mediaType`);
if (mediaType !== "application/json" && !mediaType.endsWith("+json")) {
throw new Error(`${label} source artifact is not JSON`);
}
let source = parsedSources.get(sourceArtifactId);
if (source === void 0) {
const path = stringAt(artifact.path, `evidence artifact ${sourceArtifactId}.path`);
source = parseJsonStrict(await readSafeDossierFile(root, path), path);
parsedSources.set(sourceArtifactId, source);
}
const pointer = stringAt(mapping.nativePointer, `${label}.nativePointer`);
const observed = resolveJsonPointer(source, pointer);
const declared = mapping.nativeValue;
if (declared === void 0 || !sameJsonValue(observed, declared)) {
throw new Error(`${label}.nativeValue does not match the committed source at ${pointer}`);
}
}
}
function verifyAudienceBindings(dossier, options) {
const dossierContext = objectAt(dossier.signatureContext, "dossier.signatureContext");
const audience = stringAt(dossierContext.audience, "dossier.signatureContext.audience");
const dossierNonce = stringAt(dossierContext.nonce, "dossier.signatureContext.nonce");
if (options.expectedAudience !== void 0 && options.expectedAudience !== audience) {
throw new Error(`Dossier audience mismatch: expected ${options.expectedAudience}, got ${audience}`);
}
if (options.expectedDossierNonce !== void 0 && options.expectedDossierNonce !== dossierNonce) {
throw new Error("Dossier nonce does not match the caller's expected nonce");
}
return {
audience,
audienceBinding: options.expectedAudience === void 0 ? "UNPINNED" : "PINNED",
dossierNonceBinding: options.expectedDossierNonce === void 0 ? "UNPINNED" : "PINNED"
};
}
async function verifyDossier(root, options = {}) {
const dossierBytes = await readSafeDossierFile(root, "dossier.json");
const parsed = parseJsonStrict(dossierBytes, "dossier.json");
if (!isObject(parsed)) {
throw new Error("dossier.json must contain an object");
}
const dossier = parsed;
const validation = await validateProtocolObject(dossier);
if (!validation.valid) {
throw new Error(`Invalid dossier schema: ${schemaErrorText(validation.errors)}`);
}
const exporter = objectAt(dossier.exporter, "dossier.exporter");
requireValidSignature(dossier, publicKeyFrom(exporter.key, "dossier.exporter.key"), "dossier");
const entries = arrayAt(dossier.artifacts, "dossier.artifacts").map(entryFromObject);
requireUniqueEntries(entries);
await rejectUnexpectedFiles(root, /* @__PURE__ */ new Set(["dossier.json", ...entries.map((entry) => entry.path)]));
for (const entry of entries) {
await verifyEntryBytes(root, entry);
}
const manifest = await readProtocolEntry(root, findRole(entries, "EVALUATOR_MANIFEST"));
const profile = await readProtocolEntry(root, findRole(entries, "PROFILE_DEFINITION"));
const request = await readProtocolEntry(root, findRole(entries, "EVALUATION_REQUEST"));
const evidenceBundle = await readProtocolEntry(root, findRole(entries, "EVIDENCE_BUNDLE"));
const attestation = await readProtocolEntry(root, findRole(entries, "EVALUATION_ATTESTATION"));
const manifestKeyId = stringAt(manifest.signingKeyId, "manifest.signingKeyId");
const manifestKey = findManifestKey(manifest, manifestKeyId);
requireValidSignature(manifest, manifestKey, "manifest");
const publisher = objectAt(profile.publisher, "profile.publisher");
requireValidSignature(profile, publicKeyFrom(publisher.key, "profile.publisher.key"), "profile");
const requester = objectAt(request.requester, "request.requester");
requireValidSignature(request, publicKeyFrom(requester.key, "request.requester.key"), "request");
const collector = objectAt(evidenceBundle.collector, "evidenceBundle.collector");
requireValidSignature(evidenceBundle, publicKeyFrom(collector.key, "evidenceBundle.collector.key"), "evidence bundle");
const evaluator = objectAt(attestation.evaluator, "attestation.evaluator");
const attestationKeyId = stringAt(evaluator.keyId, "attestation.evaluator.keyId");
requireValidSignature(attestation, findManifestKey(manifest, attestationKeyId), "attestation");
verifyCrossBindings(dossier, manifest, profile, request, evidenceBundle, attestation);
verifyDeclaredGraph(entries, profile, request, evidenceBundle, attestation);
await verifyUpstreamMappings(root, profile, evidenceBundle, attestation);
verifySemanticBoundary(profile, request, attestation, dossier);
verifyTemporalBindings(dossier, manifest, profile, request, evidenceBundle, attestation);
const provenance = verifyEvidenceEntries(entries, evidenceBundle);
const audience = verifyAudienceBindings(dossier, options);
const attestationSummary = summarizeAttestation(attestation);
const warnings = arrayAt(dossier.warnings, "dossier.warnings").map((warning, index) => stringAt(warning, `dossier.warnings[${index}]`));
return {
dossier,
objects: { manifest, profile, request, evidenceBundle, attestation },
summary: {
dossierId: stringAt(dossier.dossierId, "dossier.dossierId"),
schema: "VALID",
integrity: "VALID",
signatures: "VALID",
keyControl: "ESTABLISHED",
signerTrust: "UNPINNED",
identity: "NOT_ESTABLISHED",
audience: audience.audience,
audienceBinding: audience.audienceBinding,
dossierNonceBinding: audience.dossierNonceBinding,
provenance,
bases: attestationSummary.bases,
overallBasis: attestationSummary.overallBasis,
predicateStatuses: attestationSummary.predicateStatuses,
obligationVerdict: attestationSummary.obligationVerdict,
economicAction: "OUT_OF_SCOPE",
warnings
}
};
}
// dist/src/reference-evaluator.js
var import__2 = __toESM(require__(), 1);
import { readFileSync } from "node:fs";
import { join as join2 } from "node:path";
var REFERENCE_EVALUATOR_ID = "evaldossier-reference-evaluator";
var REFERENCE_PROFILE_ID = "json-artifact-conformance-v0";
var REFERENCE_PROFILE_VERSION = "0.1.0";
var REFERENCE_MAPPING_POLICY_ID = "direct-formal-predicate-v0";
var DEFAULT_AUDIENCE = "evaldossier-offline-demo";
function assertNonEmpty(bytes, label) {
if (bytes.byteLength === 0) {
throw new Error(`${label} must not be empty`);
}
if (bytes.byteLength > 5242880) {
throw new Error(`${label} exceeds the v0.1 artifact size limit`);
}
}
function assertLocalReferencesOnly(value, pointer = "") {
if (Array.isArray(value)) {
value.forEach((item, index) => assertLocalReferencesOnly(item, `${pointer}/${index}`));
return;
}
if (value === null || typeof value !== "object") {
return;
}
for (const [key, child] of Object.entries(value)) {
const childPointer = `${pointer}/${key.replaceAll("~", "~0").replaceAll("/", "~1")}`;
if ((key === "$ref" || key === "$dynamicRef") && typeof child === "string" && !child.startsWith("#")) {
throw new Error(`Remote schema reference is forbidden at ${childPointer}`);
}
assertLocalReferencesOnly(child, childPointer);
}
}
function evaluateAgainstLocalSchema(deliverableBytes, schemaBytes) {
let schema;
try {
schema = parseJsonStrict(schemaBytes, "reference JSON Schema");
if (schema === null || typeof schema !== "object" || Array.isArray(schema)) {
throw new Error("The committed JSON Schema must be an object");
}
assertLocalReferencesOnly(schema);
} catch (error) {
const message = error instanceof Error ? error.message : "Unknown JSON Schema error";
return {
assessment: "INCONCLUSIVE",
predicateStatus: "UNDETERMINED",
reasonCode: "LOCAL_SCHEMA_INVALID",
limitations: ["The committed schema could not be safely compiled as a local-only JSON Schema."],
error: {
code: "LOCAL_SCHEMA_INVALID",
message: message.slice(0, 500),
retryable: false
}
};
}
let deliverable;
try {
deliverable = parseJsonStrict(deliverableBytes, "reference deliverable");
} catch {
return {
assessment: "REJECTED",
predicateStatus: "ESTABLISHED_FALSE",
reasonCode: "DELIVERABLE_NOT_STRICT_JSON",
limitations: ["This result establishes only that the committed bytes are not a strict JSON instance of the committed schema."]
};
}
try {
const ajv = new import__2.Ajv2020({
allErrors: true,
strict: true,
validateFormats: false
});
const validate = ajv.compile(schema);
const valid = validate(deliverable);
if (valid) {
return {
assessment: "AFFIRMED",
predicateStatus: "ESTABLISHED_TRUE",
reasonCode: "LOCAL_JSON_SCHEMA_VALID",
limitations: ["JSON Schema conformance does not establish the deliverable's broader factual accuracy, quality, or commercial fitness."]
};
}
return {
assessment: "REJECTED",
predicateStatus: "ESTABLISHED_FALSE",
reasonCode: "LOCAL_JSON_SCHEMA_MISMATCH",
limitations: ["This result is limited to the committed local schema and committed JSON bytes."]
};
} catch (error) {
const message = error instanceof Error ? error.message : "Unknown JSON Schema compilation error";
return {
assessment: "INCONCLUSIVE",
predicateStatus: "UNDETERMINED",
reasonCode: "LOCAL_SCHEMA_INVALID",
limitations: ["The committed schema could not be safely compiled as a local-only JSON Schema."],
error: {
code: "LOCAL_SCHEMA_INVALID",
message: message.slice(0, 500),
retryable: false
}
};
}
}
function aggregate(results) {
if (results.some((result) => result.predicateStatus === "ESTABLISHED_FALSE")) {
return {
assessment: "REJECTED",
obligationVerdict: "NOT_SATISFIED",
reasonCode: "REQUIRED_FORMAL_PREDICATE_FALSE"
};
}
if (results.some((result) => result.predicateStatus === "UNDETERMINED")) {
return {
assessment: "INCONCLUSIVE",
obligationVerdict: "INCONCLUSIVE",
reasonCode: "REQUIRED_FORMAL_PREDICATE_UNDETERMINED"
};
}
return {
assessment: "AFFIRMED",
obligationVerdict: "SATISFIED",
reasonCode: "ALL_REQUIRED_FORMAL_PREDICATES_TRUE"
};
}
function signed(payload, key) {
return signObject(payload, key);
}
function buildReferenceEvaluationFromFiles(options) {
const audience = options.audience ?? DEFAULT_AUDIENCE;
const publishedAt = options.publishedAt ?? "2026-07-21T12:00:00Z";
const expiresAt = options.expiresAt ?? "2027-07-21T12:00:00Z";
const requestCreatedAt = options.requestCreatedAt ?? "2026-07-21T12:00:01Z";
const requestExpiresAt = options.requestExpiresAt ?? "2026-07-22T12:00:01Z";
const capturedAt = options.capturedAt ?? "2026-07-21T12:00:01Z";
const issuedAt = options.issuedAt ?? "2026-07-21T12:00:02Z";
const deliverableBytes = readFileSync(options.deliverablePath);
const schemaBytes = readFileSync(options.schemaPath);
assertNonEmpty(deliverableBytes, "deliverable");
assertNonEmpty(schemaBytes, "schema");
const actualDeliverableDigest = sha256Bytes(deliverableBytes);
const schemaDigest = sha256Bytes(schemaBytes);
const committedDeliverableDigest = actualDeliverableDigest;
const committedDeliverableSizeBytes = deliverableBytes.byteLength;
const evaluatorPublicKey = publicJwkFromPrivate(options.evaluatorKey);
const requesterPublicKey = publicJwkFromPrivate(options.requesterKey);
const profile = signed({
protocolVersion: "evaldossier/0.1",
schemaVersion: "evaldossier.profile-definition/0.1",
profileId: REFERENCE_PROFILE_ID,
version: REFERENCE_PROFILE_VERSION,
title: "Local JSON artifact conformance",
description: "Establishes presence, raw-byte SHA-256 equality, and conformance of committed JSON bytes to a committed local-only JSON Schema. It does not establish broader commercial intent.",
publishedAt,
publisher: {
id: REFERENCE_EVALUATOR_ID,
key: evaluatorPublicKey
},
signingKeyId: evaluatorPublicKey.kid,
operation: "EVALUATE",
resultBindingMode: "DIRECT_PREDICATE_RESULT",
evaluationClass: "DETERMINISTIC",
allowedBases: ["FORMAL_PREDICATE"],
predicates: [
{
predicateId: "artifact-present",
description: "The committed deliverable artifact is present and non-empty.",
basis: "FORMAL_PREDICATE"
},
{
predicateId: "artifact-digest-matches",
description: "The deliverable's raw-byte SHA-256 digest and size match the request commitment.",
basis: "FORMAL_PREDICATE"
},
{
predicateId: "local-json-schema-valid",
description: "The committed deliverable is strict JSON valid against the committed local-only JSON Schema.",
basis: "FORMAL_PREDICATE"
}
],
aggregationPolicy: {
rule: "ALL_REQUIRED_TRUE",
unknownHandling: "INCONCLUSIVE_WHEN_REQUIRED_PREDICATE_UNDETERMINED",
obligationEligibleBases: ["FORMAL_PREDICATE"]
},
mappingPolicy: {
policyId: REFERENCE_MAPPING_POLICY_ID,
description: "Direct deterministic evaluation; no upstream result is normalized or strengthened."
},
signatureContext: {
audience,
nonce: "reference-profile-nonce-0001"
}
}, options.evaluatorKey);
const profileDigest = digestOfObject(profile);
const manifest = signed({
protocolVersion: "evaldossier/0.1",
schemaVersion: "evaldossier.evaluator-manifest/0.1",
manifestId: "reference-evaluator-manifest-v0",
evaluatorId: REFERENCE_EVALUATOR_ID,
evaluatorType: "NATIVE",
issuedAt: publishedAt,
expiresAt,
operator: {
id: "evaldossier-reference-operator",
displayName: "EvalDossier reference evaluator",
relationship: "INTERNAL_REFERENCE_OPERATOR"
},
signingKeyId: evaluatorPublicKey.kid,
keys: [evaluatorPublicKey],
profiles: [
{
id: REFERENCE_PROFILE_ID,
version: REFERENCE_PROFILE_VERSION,
digest: profileDigest
}
],
software: {
name: "evaldossier-reference-evaluator",
version: "0.1.0",
sourceVisibility: "OPEN_SOURCE"
},
dataPractices: {
acceptedClassifications: ["PUBLIC_SYNTHETIC"],
trainingUse: false,
networkUse: false
},
signatureContext: {
audience,
nonce: "reference-manifest-nonce-0001"
}
}, options.evaluatorKey);
const request = signed({
protocolVersion: "evaldossier/0.1",
schemaVersion: "evaldossier.evaluation-request/0.1",
requestId: "reference-evaluation-request-v0",
operation: "EVALUATE",
createdAt: requestCreatedAt,
expiresAt: requestExpiresAt,
requester: {
id: "evaldossier-demo-requester",
key: requesterPublicKey
},
signingKeyId: requesterPublicKey.kid,
targetEvaluatorId: REFERENCE_EVALUATOR_ID,
profile: {
id: REFERENCE_PROFILE_ID,
version: REFERENCE_PROFILE_VERSION,
digest: profileDigest
},
statement: "Evaluate the committed JSON deliverable against the three required formal predicates.",
criteria: [
{
criterionId: "criterion-artifact-present",
predicateId: "artifact-present",
required: true,
statement: "The deliverable artifact is present and non-empty.",
parameters: [{ name: "artifact-id", value: "reference-deliverable" }]
},
{
criterionId: "criterion-artifact-digest",
predicateId: "artifact-digest-matches",
required: true,
statement: "The deliverable digest and size match their precommitted values.",
parameters: [{ name: "artifact-id", value: "reference-deliverable" }]
},
{
criterionId: "criterion-json-schema",
predicateId: "local-json-schema-valid",
required: true,
statement: "The deliverable is valid against the committed local-only JSON Schema.",
parameters: [
{ name: "artifact-id", value: "reference-deliverable" },
{ name: "schema-artifact-id", value: "reference-deliverable-schema" }
]
}
],
artifacts: [
{
artifactId: "reference-deliverable",
role: "DELIVERABLE",
mediaType: "application/json",
commitmentMode: "EXACT_INPUT",
digest: committedDeliverableDigest,
sizeBytes: committedDeliverableSizeBytes
},
{
artifactId: "reference-deliverable-schema",
role: "SCHEMA",
mediaType: "application/schema+json",
commitmentMode: "EXACT_INPUT",
digest: schemaDigest,
sizeBytes: schemaBytes.byteLength
}
],
privacy: {
classification: "PUBLIC_SYNTHETIC",
trainingUse: false
},
economicBoundary: {
paymentExecution: "OUT_OF_SCOPE",
paymentRecommendation: "OUT_OF_SCOPE"
},
signatureContext: {
audience,
nonce: "reference-request-nonce-0001"
}
}, options.requesterKey);
const sourceArtifacts = [
{
artifactId: "reference-deliverable",
role: "DELIVERABLE",
sourcePath: options.deliverablePath,
dossierPath: "evidence/deliverable.json",
mediaType: "application/json"
},
{
artifactId: "reference-deliverable-schema",
role: "SCHEMA",
sourcePath: options.schemaPath,
dossierPath: "evidence/deliverable.schema.json",
mediaType: "application/schema+json"
}
];
const evidenceBundle = signed({
protocolVersion: "evaldossier/0.1",
schemaVersion: "evaldossier.evidence-bundle/0.1",
bundleId: "reference-evidence-bundle-v0",
requestId: "reference-evaluation-request-v0",
capturedAt,
collector: {
id: "evaldossier-demo-requester",
key: requesterPublicKey
},
signingKeyId: requesterPublicKey.kid,
captureMode: "GENERATED_SYNTHETIC",
artifacts: [
{
artifactId: "reference-deliverable",
role: "DELIVERABLE",
mediaType: "application/json",
digest: actualDeliverableDigest,
sizeBytes: deliverableBytes.byteLength,
path: "evidence/deliverable.json",
source: {
systemId: "evaldossier-reference-fixture",
role: "REFERENCE_FIXTURE",
controllerRelationship: "INTERNAL_FIXTURE",
observationMode: "SYNTHETIC",
originAuthentication: "SYNTHETIC",
derivation: "GENERATED",
authorityStatus: "FORMALLY_DEFINED"
}
},
{
artifactId: "reference-deliverable-schema",
role: "SCHEMA",
mediaType: "application/schema+json",
digest: schemaDigest,
sizeBytes: schemaBytes.byteLength,
path: "evidence/deliverable.schema.json",
source: {
systemId: "evaldossier-reference-fixture",
role: "REFERENCE_FIXTURE",
controllerRelationship: "INTERNAL_FIXTURE",
observationMode: "SYNTHETIC",
originAuthentication: "SYNTHETIC",
derivation: "GENERATED",
authorityStatus: "FORMALLY_DEFINED"
}
}
],
limitations: [
"Both artifacts are public synthetic fixtures generated for the local demo.",
"Fixture provenance does not establish external adoption, neutrality, or commercial authority."
],
signatureContext: {
audience,
nonce: "reference-evidence-nonce-0001"
}
}, options.requesterKey);
const present = {
assessment: "AFFIRMED",
predicateStatus: "ESTABLISHED_TRUE",
reasonCode: "ARTIFACT_PRESENT",
limitations: ["Presence establishes neither authorship nor semantic quality."]
};
const digestMatches = actualDeliverableDigest.value === committedDeliverableDigest.value && deliverableBytes.byteLength === committedDeliverableSizeBytes;
const digestResult = digestMatches ? {
assessment: "AFFIRMED",
predicateStatus: "ESTABLISHED_TRUE",
reasonCode: "ARTIFACT_DIGEST_MATCHES",
limitations: ["Digest equality establishes byte identity only."]
} : {
assessment: "REJECTED",
predicateStatus: "ESTABLISHED_FALSE",
reasonCode: "ARTIFACT_DIGEST_MISMATCH",
limitations: ["The observed artifact differs from the request commitment in digest or byte length."]
};
const schemaResult = evaluateAgainstLocalSchema(deliverableBytes, schemaBytes);
const aggregateResult = aggregate([present, digestResult, schemaResult]);
const attestation = signed({
protocolVersion: "evaldossier/0.1",
schemaVersion: "evaldossier.evaluation-attestation/0.1",
attestationId: "reference-evaluation-attestation-v0",
issuedAt,
evaluator: {
evaluatorId: REFERENCE_EVALUATOR_ID,
keyId: evaluatorPublicKey.kid,
softwareVersion: "0.1.0"
},
bindings: {
manifestDigest: digestOfObject(manifest),
profileDigest,
requestDigest: digestOfObject(request),
evidenceBundleDigest: digestOfObject(evidenceBundle)
},
mode: "NATIVE_EVALUATION",
coverage: {
status: "COMPLETE",
assessedCriterionIds: [
"criterion-artifact-present",
"criterion-artifact-digest",
"criterion-json-schema"
],
unassessedCriterionIds: []
},
overallAssessment: {
assessment: aggregateResult.assessment,
basis: "FORMAL_PREDICATE",
reasonCode: aggregateResult.reasonCode
},
obligationVerdict: aggregateResult.obligationVerdict,
assessments: [
{
assessmentId: "assessment-artifact-present",
criterionId: "criterion-artifact-present",
statement: "The deliverable artifact is present and non-empty.",
basis: "FORMAL_PREDICATE",
assessment: present.assessment,
predicateStatus: present.predicateStatus,
reasonCode: present.reasonCode,
evidenceArtifactIds: ["reference-deliverable"],
limitations: present.limitations
},
{
assessmentId: "assessment-artifact-digest",
criterionId: "criterion-artifact-digest",
statement: "The observed deliverable digest and size match their signed request commitment.",
basis: "FORMAL_PREDICATE",
assessment: digestResult.assessment,
predicateStatus: digestResult.predicateStatus,
reasonCode: digestResult.reasonCode,
evidenceArtifactIds: ["reference-deliverable"],
limitations: digestResult.limitations
},
{
assessmentId: "assessment-json-schema",
criterionId: "criterion-json-schema",
statement: "The committed deliverable is strict JSON valid against the committed local-only JSON Schema.",
basis: "FORMAL_PREDICATE",
assessment: schemaResult.assessment,
predicateStatus: schemaResult.predicateStatus,
reasonCode: schemaResult.reasonCode,
evidenceArtifactIds: ["reference-deliverable", "reference-deliverable-schema"],
limitations: schemaResult.limitations
}
],
ignoredInputs: [],
errors: schemaResult.error === void 0 ? [] : [schemaResult.error],
limitations: [
"The evaluator proves only the predicates named in the signed profile over the committed bytes.",
"A SATISFIED obligation verdict here is protocol-local and is not an instruction to move funds."
],
economicAction: "OUT_OF_SCOPE",
signatureContext: {
audience,
nonce: "reference-attestation-nonce-0001"
}
}, options.evaluatorKey);
return {
manifest,
profile,
request,
evidenceBundle,
attestation,
sourceArtifacts
};
}
async function buildReferenceEvaluation(projectRoot2, evaluatorKey, requesterKey) {
return buildReferenceEvaluationFromFiles({
evaluatorKey,
requesterKey,
deliverablePath: join2(projectRoot2, "fixtures", "reference", "deliverable.json"),
schemaPath: join2(projectRoot2, "fixtures", "reference", "deliverable.schema.json")
});
}
// dist/src/sdk.js
var EVALUATOR_ID_PATTERN = /^[A-Za-z][A-Za-z0-9._:-]{2,127}$/;
var SDK_PROTOCOL_SCHEMA_VERSIONS = Object.freeze({
"evaluator-manifest": "evaldossier.evaluator-manifest/0.1",
"profile-definition": "evaldossier.profile-definition/0.1",
"evaluation-request": "evaldossier.evaluation-request/0.1",
"evidence-bundle": "evaldossier.evidence-bundle/0.1",
"evaluation-attestation": "evaldossier.evaluation-attestation/0.1"
});
var EvaluatorSdkError = class extends Error {
code;
constructor(code, message) {
super(message);
this.name = "EvaluatorSdkError";
this.code = code;
}
};
function isObject2(value) {
return value !== null && typeof value === "object" && !Array.isArray(value);
}
function stringMember(value, member, label) {
const candidate = value[member];
if (typeof candidate !== "string") {
throw new EvaluatorSdkError("INVALID_EVALUATION_RUN", `${label}.${member} must be a string`);
}
return candidate;
}
function objectMember(value, member, label) {
const candidate = value[member];
if (!isObject2(candidate)) {
throw new EvaluatorSdkError("INVALID_EVALUATION_RUN", `${label}.${member} must be an object`);
}
return candidate;
}
function assertEvaluatorId(evaluatorId) {
if (typeof evaluatorId !== "string" || !EVALUATOR_ID_PATTERN.test(evaluatorId)) {
throw new EvaluatorSdkError("INVALID_EVALUATOR_ID", "evaluatorId must satisfy the EvalDossier identifier grammar");
}
}
function snapshot(value, code, label) {
try {
return structuredClone(value);
} catch {
throw new EvaluatorSdkError(code, `${label} must be structured-cloneable data`);
}
}
function schemaErrorText2(errors) {
return errors.map((error) => `${error.instancePath || "/"}: ${error.message}`).join("; ");
}
function defineEvaluator(definition) {
if (definition === null || typeof definition !== "object") {
throw new EvaluatorSdkError("INVALID_EVALUATION_RUN", "evaluator definition must be an object");
}
const evaluatorId = definition.evaluatorId;
const evaluate = definition.evaluate;
assertEvaluatorId(evaluatorId);
if (typeof evaluate !== "function") {
throw new EvaluatorSdkError("INVALID_EVALUATION_RUN", "evaluator definition must provide an evaluate function");
}
return Object.freeze({
evaluatorId,
evaluate
});
}
var RUN_OBJECTS = [
["manifest", "evaldossier.evaluator-manifest/0.1"],
["profile", "evaldossier.profile-definition/0.1"],
["request", "evaldossier.evaluation-request/0.1"],
["evidenceBundle", "evaldossier.evidence-bundle/0.1"],
["attestation", "evaldossier.evaluation-attestation/0.1"]
];
async function assertEvaluationRun(run, expectedEvaluatorId) {
if (!isObject2(run) || !Array.isArray(run.sourceArtifacts)) {
throw new EvaluatorSdkError("INVALID_EVALUATION_RUN", "evaluator must return a complete EvaluationRun");
}
for (const [member, schemaVersion] of RUN_OBJECTS) {
const value = run[member];
if (!isObject2(value)) {
throw new EvaluatorSdkError("INVALID_EVALUATION_RUN", `evaluation run member ${member} must be a JSON object`);
}
const validation = await validateProtocolObject(value, schemaVersion);
if (!validation.valid) {
throw new EvaluatorSdkError("INVALID_PROTOCOL_OBJECT", `${member} failed protocol validation: ${schemaErrorText2(validation.errors)}`);
}
}
const manifestEvaluatorId = stringMember(run.manifest, "evaluatorId", "manifest");
const requestEvaluatorId = stringMember(run.request, "targetEvaluatorId", "request");
const attestationEvaluator = objectMember(run.attestation, "evaluator", "attestation");
const attestationEvaluatorId = stringMember(attestationEvaluator, "evaluatorId", "attestation.evaluator");
const observedIds = [manifestEvaluatorId, requestEvaluatorId, attestationEvaluatorId];
if (observedIds.some((value) => value !== expectedEvaluatorId)) {
throw new EvaluatorSdkError("EVALUATOR_ID_MISMATCH", `evaluator definition ${expectedEvaluatorId} does not match the signed run identities`);
}
}
function captureEvaluator(evaluator) {
if (evaluator === null || typeof evaluator !== "object") {
throw new EvaluatorSdkError("INVALID_EVALUATION_RUN", "evaluator definition must be an object");
}
const evaluatorId = evaluator.evaluatorId;
const evaluate = evaluator.evaluate;
assertEvaluatorId(evaluatorId);
if (typeof evaluate !== "function") {
throw new EvaluatorSdkError("INVALID_EVALUATION_RUN", "evaluator definition must provide an evaluate function");
}
return {
evaluatorId,
evaluate: (input) => Reflect.apply(evaluate, evaluator, [input])
};
}
function snapshotOptions(options) {
const captured = snapshot(options, "INVALID_EVALUATOR_OPTIONS", "evaluator options");
if (!isObject2(captured) || typeof captured.outputDirectory !== "string" || captured.outputDirectory.length === 0 || !isObject2(captured.exporterKey) || !isObject2(captured.dossier)) {
throw new EvaluatorSdkError("INVALID_EVALUATOR_OPTIONS", "evaluator options must include an output directory, exporter key and dossier metadata");
}
return captured;
}
function snapshotEvaluationRun(value) {
return snapshot(value, "INVALID_EVALUATION_RUN", "evaluation run");
}
function capturePromiseLike(value) {
if (value === null || typeof value !== "object" && typeof value !== "function") {
return void 0;
}
const then = value.then;
if (typeof then !== "function") {
return void 0;
}
return new Promise((resolve5, reject) => {
try {
Reflect.apply(then, value, [resolve5, reject]);
} catch (error) {
reject(error);
}
});
}
async function prepareEvaluation(evaluator, input, options) {
const capturedEvaluator = captureEvaluator(evaluator);
const capturedOptions = snapshotOptions(options);
const returned = capturedEvaluator.evaluate(input);
const pending = capturePromiseLike(returned);
const run = snapshotEvaluationRun(pending === void 0 ? returned : await pending);
await assertEvaluationRun(run, capturedEvaluator.evaluatorId);
return {
evaluatorId: capturedEvaluator.evaluatorId,
run,
options: capturedOptions
};
}
async function materializeEvaluation(prepared) {
const { evaluatorId, run, options } = prepared;
const dossier = await assembleDossier(run, options.outputDirectory, options.exporterKey, options.dossier);
const verified = await verifyDossier(options.outputDirectory, {
expectedAudience: options.dossier.audience,
expectedDossierNonce: options.dossier.nonce
});
return {
evaluatorId,
outputDirectory: options.outputDirectory,
run,
dossier,
verified
};
}
function sorted(values) {
return [...values].sort();
}
function assertEqualString(label, actual, expected) {
if (actual !== expected) {
throw new EvaluatorSdkError("CONFORMANCE_EXPECTATION_FAILED", `${label}: expected ${expected}, received ${actual}`);
}
}
function assertEqualStrings(label, actual, expected) {
const actualSorted = sorted(actual);
const expectedSorted = sorted(expected);
if (actualSorted.length !== expectedSorted.length || actualSorted.some((value, index) => value !== expectedSorted[index])) {
throw new EvaluatorSdkError("CONFORMANCE_EXPECTATION_FAILED", `${label}: expected ${expectedSorted.join(", ")}, received ${actualSorted.join(", ")}`);
}
}
function snapshotExpectations(expectations) {
const captured = snapshot(expectations, "CONFORMANCE_EXPECTATION_FAILED", "conformance expectations");
if (!isObject2(captured)) {
throw new EvaluatorSdkError("CONFORMANCE_EXPECTATION_FAILED", "conformance expectations must be an object");
}
const allowedMembers = /* @__PURE__ */ new Set([
"bases",
"overallBasis",
"predicateStatuses",
"obligationVerdict"
]);
for (const member of Object.keys(captured)) {
if (!allowedMembers.has(member)) {
throw new EvaluatorSdkError("CONFORMANCE_EXPECTATION_FAILED", `unknown conformance expectation: ${member}`);
}
}
for (const member of ["overallBasis", "obligationVerdict"]) {
if (captured[member] !== void 0 && typeof captured[member] !== "string") {
throw new EvaluatorSdkError("CONFORMANCE_EXPECTATION_FAILED", `${member} expectation must be a string`);
}
}
for (const member of ["bases", "predicateStatuses"]) {
const value = captured[member];
if (value !== void 0 && (!Array.isArray(value) || value.some((entry) => typeof entry !== "string"))) {
throw new EvaluatorSdkError("CONFORMANCE_EXPECTATION_FAILED", `${member} expectation must be an array of strings`);
}
}
return captured;
}
function assertSemanticExpectations(summary, expectations) {
const checks = [];
if (expectations.bases !== void 0) {
assertEqualStrings("bases", summary.bases, expectations.bases);
checks.push({ id: "EXPECTED_BASES", status: "PASS" });
}
if (expectations.overallBasis !== void 0) {
assertEqualString("overallBasis", summary.overallBasis, expectations.overallBasis);
checks.push({ id: "EXPECTED_OVERALL_BASIS", status: "PASS" });
}
if (expectations.predicateStatuses !== void 0) {
assertEqualStrings("predicateStatuses", summary.predicateStatuses, expectations.predicateStatuses);
checks.push({ id: "EXPECTED_PREDICATE_STATUSES", status: "PASS" });
}
if (expectations.obligationVerdict !== void 0) {
assertEqualString("obligationVerdict", summary.obligationVerdict, expectations.obligationVerdict);
checks.push({ id: "EXPECTED_OBLIGATION_VERDICT", status: "PASS" });
}
return checks;
}
async function assertEvaluatorConformance(evaluator, input, options, expectations = {}) {
const capturedExpectations = snapshotExpectations(expectations);
const prepared = await prepareEvaluation(evaluator, input, options);
assertSemanticExpectations(summarizeAttestation(prepared.run.attestation), capturedExpectations);
const execution = await materializeEvaluation(prepared);
const summary = execution.verified.summary;
assertEqualString("schema", summary.schema, "VALID");
assertEqualString("integrity", summary.integrity, "VALID");
assertEqualString("signatures", summary.signatures, "VALID");
assertEqualString("audienceBinding", summary.audienceBinding, "PINNED");
assertEqualString("dossierNonceBinding", summary.dossierNonceBinding, "PINNED");
assertEqualString("economicAction", summary.economicAction, "OUT_OF_SCOPE");
const checks = [
{ id: "EVALUATOR_ID_BOUND", status: "PASS" },
{ id: "SCHEMAS_VALID", status: "PASS" },
{ id: "INTEGRITY_VALID", status: "PASS" },
{ id: "SIGNATURES_VALID", status: "PASS" },
{ id: "AUDIENCE_PINNED", status: "PASS" },
{ id: "DOSSIER_NONCE_PINNED", status: "PASS" },
{ id: "ECONOMIC_ACTION_OUT_OF_SCOPE", status: "PASS" }
];
checks.push(...assertSemanticExpectations(summary, capturedExpectations));
return {
...execution,
status: "PASS",
checks
};
}
// integrations/shared/evaldossier-local-core.mjs
var PIN_SOURCES = Object.freeze({
"user-request": "USER_REQUEST",
"upstream-context": "UPSTREAM_CONTEXT"
});
var VERIFY_NON_CLAIMS = Object.freeze([
"PINNED establishes equality with a supplied expected value; it does not establish how that value was obtained.",
"Pin provenance is caller-declared and is not independently verified by this integration.",
"The legacy status field reports operation success; verificationStatus reports dossier verification separately from the signed protocol outcome.",
"criterionResults preserve verified signed mappings through SHA-256 commitments; raw identifiers and reason codes are not emitted and external truth is not established.",
"No truth, neutrality, legal identity, authority, or payment entitlement is established by this result alone."
]);
var CONFORMANCE_NON_CLAIMS = Object.freeze([
"Conformance establishes compatibility with declared protocol semantics, not evaluator certification.",
"The ephemeral keys and bundled evidence are synthetic test material and establish no institutional identity or external adoption.",
"The legacy status field reports operation success; verificationStatus reports dossier verification separately from the signed protocol outcome.",
"criterionResults preserve verified signed mappings through SHA-256 commitments; raw identifiers and reason codes are not emitted and external truth is not established.",
"No truth, neutrality, legal authority, or payment entitlement is established by this result alone."
]);
var CONFIG_KEYS = Object.freeze(["hostName", "hostSlug", "integrationId"]);
var REQUEST_KEYS = Object.freeze([
"audience",
"audienceSource",
"dossier",
"nonce",
"nonceSource",
"schemaVersion"
]);
var REQUEST_SCHEMA_VERSION = "evaldossier.local-verification-request/0.1";
var CONFORMANCE_REQUEST_KEYS = Object.freeze(["output", "schemaVersion"]);
var CONFORMANCE_REQUEST_SCHEMA_VERSION = "evaldossier.local-conformance-request/0.1";
var PROJECTION_VERSION = "evaldossier.model-safe-projection/0.2";
var MAX_REQUEST_BYTES = 16 * 1024;
var scriptDirectory = dirname2(fileURLToPath2(import.meta.url));
var projectRoot = resolve4(scriptDirectory, "../..");
var IntegrationError = class extends Error {
constructor(code, message, diagnostic = void 0) {
super(message);
this.name = "IntegrationError";
this.code = code;
this.diagnostic = diagnostic;
}
};
function fail(code, message, diagnostic = void 0) {
throw new IntegrationError(code, message, diagnostic);
}
function assertExactKeys2(value, expectedKeys, label, errorCode = "INVALID_INTEGRATION_CONFIG") {
if (value === null || typeof value !== "object" || Array.isArray(value)) {
fail(errorCode, `${label} must be an object`);
}
const actualKeys = Object.keys(value).sort();
const sortedExpected = [...expectedKeys].sort();
if (actualKeys.length !== sortedExpected.length || actualKeys.some((key, index) => key !== sortedExpected[index])) {
fail(errorCode, `${label} has unsupported or missing fields`);
}
}
function requestString(value, field, maxLength) {
if (typeof value !== "string" || value.length === 0 || value.length > maxLength) {
fail(
"INVALID_VERIFICATION_REQUEST",
`${field} must be a non-empty string no longer than ${maxLength} characters`
);
}
return value;
}
function normalizeVerificationRequest(value) {
assertExactKeys2(
value,
REQUEST_KEYS,
"verification request",
"INVALID_VERIFICATION_REQUEST"
);
if (value.schemaVersion !== REQUEST_SCHEMA_VERSION) {
fail("INVALID_VERIFICATION_REQUEST", "verification request schemaVersion is unsupported");
}
return Object.freeze({
dossier: requestString(value.dossier, "dossier", 4096),
audience: requestString(value.audience, "audience", 2048),
nonce: requestString(value.nonce, "nonce", 4096),
audienceSource: requestString(value.audienceSource, "audienceSource", 32),
nonceSource: requestString(value.nonceSource, "nonceSource", 32)
});
}
function normalizeConformanceRequest(value) {
assertExactKeys2(
value,
CONFORMANCE_REQUEST_KEYS,
"conformance request",
"INVALID_CONFORMANCE_REQUEST"
);
if (value.schemaVersion !== CONFORMANCE_REQUEST_SCHEMA_VERSION) {
fail("INVALID_CONFORMANCE_REQUEST", "conformance request schemaVersion is unsupported");
}
return Object.freeze({
output: requestString(value.output, "output", 4096)
});
}
function normalizeIntegrationConfig(value) {
assertExactKeys2(value, CONFIG_KEYS, "integration config");
const { hostName, hostSlug, integrationId } = value;
if (typeof hostName !== "string" || !/^[A-Za-z][A-Za-z0-9 .-]{0,63}$/u.test(hostName)) {
fail("INVALID_INTEGRATION_CONFIG", "hostName is invalid");
}
if (typeof hostSlug !== "string" || !/^[a-z][a-z0-9-]{0,31}$/u.test(hostSlug)) {
fail("INVALID_INTEGRATION_CONFIG", "hostSlug is invalid");
}
if (typeof integrationId !== "string" || !/^evaldossier-[a-z][a-z0-9-]*-(?:local|plugin)\/0\.1$/u.test(integrationId)) {
fail("INVALID_INTEGRATION_CONFIG", "integrationId is invalid");
}
return Object.freeze({ hostName, hostSlug, integrationId });
}
function sha256Text(value) {
return createHash5("sha256").update(value, "utf8").digest("hex");
}
function failureDiagnostic(error) {
const detail = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
return {
detailSha256: sha256Text(detail),
rawDetailEmitted: false
};
}
function localPathReference(value) {
return {
kind: "LOCAL_PATH",
pathSha256: sha256Text(value),
rawPathEmitted: false
};
}
function modelSafeCriterionResults(verified) {
const criterionById = new Map(
verified.objects.request.criteria.map((criterion, criterionIndex) => [
criterion.criterionId,
{
criterionIndex,
predicateId: criterion.predicateId,
required: criterion.required
}
])
);
return verified.objects.attestation.assessments.map((assessment) => {
const criterion = criterionById.get(assessment.criterionId);
if (criterion === void 0) {
fail("PROJECTION_INVARIANT_FAILED", "Verified assessment has no request criterion");
}
return {
criterionIndex: criterion.criterionIndex,
criterionIdSha256: sha256Text(assessment.criterionId),
predicateIdSha256: sha256Text(criterion.predicateId),
rawIdentifiersEmitted: false,
required: criterion.required === true,
basis: assessment.basis,
assessment: assessment.assessment,
predicateStatus: assessment.predicateStatus,
reasonCodeSha256: sha256Text(assessment.reasonCode),
rawReasonCodeEmitted: false,
evidenceArtifactCount: assessment.evidenceArtifactIds.length
};
}).sort((left, right) => left.criterionIndex - right.criterionIndex);
}
function modelSafeSummary(verified) {
const { summary } = verified;
const overallAssessment = verified.objects.attestation.overallAssessment;
return {
schema: summary.schema,
integrity: summary.integrity,
signatures: summary.signatures,
keyControl: summary.keyControl,
signerTrust: summary.signerTrust,
identity: summary.identity,
audienceBinding: summary.audienceBinding,
dossierNonceBinding: summary.dossierNonceBinding,
provenance: [...summary.provenance],
bases: [...summary.bases],
overallBasis: summary.overallBasis,
predicateStatuses: [...summary.predicateStatuses],
obligationVerdict: summary.obligationVerdict,
protocolOutcome: {
overallAssessment: overallAssessment.assessment,
reasonCodeSha256: sha256Text(overallAssessment.reasonCode),
rawReasonCodeEmitted: false,
obligationVerdict: summary.obligationVerdict
},
criterionResults: modelSafeCriterionResults(verified),
economicAction: summary.economicAction,
untrustedText: {
dossierIdSha256: sha256Text(summary.dossierId),
audienceSha256: sha256Text(summary.audience),
warningCount: summary.warnings.length,
warningSha256: summary.warnings.map(sha256Text),
rawTextEmitted: false
}
};
}
function containsWindowsDeviceAlias(value) {
return value.split(/[\\/]+/u).some((segment) => {
const normalized = segment.replace(/[ .]+$/u, "");
const [baseName] = normalized.split(/[.:]/u, 1);
return /^(?:CON|PRN|AUX|NUL|CONIN\$|CONOUT\$|COM[0-9¹²³]|LPT[0-9¹²³])$/iu.test(
baseName
);
});
}
function assertLocalPath(value, label) {
if (value.includes("\0")) {
fail("INVALID_LOCAL_PATH", `${label} contains a NUL byte`);
}
if (/^[\\/]{2}/.test(value)) {
fail(
"NETWORK_REFERENCE_FORBIDDEN",
`${label} must not use a network or device-namespace filesystem path`
);
}
if (containsWindowsDeviceAlias(value)) {
fail(
"DEVICE_REFERENCE_FORBIDDEN",
`${label} must not contain a reserved Windows device alias`
);
}
const looksLikeScheme = /^[A-Za-z][A-Za-z0-9+.-]*:/.test(value);
const windowsDrivePath = /^[A-Za-z]:[\\/]/.test(value);
if (looksLikeScheme && !(process.platform === "win32" && windowsDrivePath)) {
fail("NETWORK_REFERENCE_FORBIDDEN", `${label} must be a local filesystem path, not a URL`);
}
}
function parseOptions(args, valueOptions, hostName) {
const values = /* @__PURE__ */ new Map();
let json = false;
for (let index = 0; index < args.length; index += 1) {
const argument = args[index];
if (argument === "--json") {
if (json) {
fail("DUPLICATE_OPTION", "--json may be supplied only once");
}
json = true;
continue;
}
if (!valueOptions.has(argument)) {
fail("UNKNOWN_OPTION", "An unsupported option was supplied");
}
if (values.has(argument)) {
fail("DUPLICATE_OPTION", `${argument} may be supplied only once`);
}
const value = args[index + 1];
if (value === void 0 || value.startsWith("--") || value.length === 0) {
fail("MISSING_OPTION_VALUE", `${argument} requires a non-empty value`);
}
values.set(argument, value);
index += 1;
}
if (!json) {
fail("JSON_OUTPUT_REQUIRED", `--json is required for the ${hostName} integration`);
}
return values;
}
function required(values, option) {
const value = values.get(option);
if (value === void 0) {
fail("INPUT_REQUIRED", `${option} is required and must not be inferred from a dossier`);
}
return value;
}
function pinSource(value, option) {
if (!Object.hasOwn(PIN_SOURCES, value)) {
fail(
"INVALID_PIN_SOURCE",
`${option} must be user-request or upstream-context; dossier-derived sources are forbidden`
);
}
return PIN_SOURCES[value];
}
async function verifyCommand(config, args) {
const values = parseOptions(
args,
/* @__PURE__ */ new Set([
"--dossier",
"--audience",
"--nonce",
"--audience-source",
"--nonce-source"
]),
config.hostName
);
return verifyInputs(config, {
expectedAudience: required(values, "--audience"),
expectedDossierNonce: required(values, "--nonce"),
audienceSource: required(values, "--audience-source"),
nonceSource: required(values, "--nonce-source"),
dossierInput: required(values, "--dossier")
});
}
async function readStrictRequestFile(requestInput, label) {
assertLocalPath(requestInput, "--request");
const requestPath = resolve4(requestInput);
let handle;
try {
const beforeOpen = await lstat3(requestPath);
if (!beforeOpen.isFile() || beforeOpen.isSymbolicLink() || beforeOpen.nlink !== 1) {
fail(
label.code,
`${label.name} must be one regular, non-linked local file`
);
}
const noFollow = fsConstants.O_NOFOLLOW ?? 0;
handle = await open3(requestPath, fsConstants.O_RDONLY | noFollow);
const opened = await handle.stat();
if (!opened.isFile() || opened.nlink !== 1 || opened.dev !== beforeOpen.dev || opened.ino !== beforeOpen.ino) {
fail(label.code, `${label.name} changed while it was being opened`);
}
if (opened.size > MAX_REQUEST_BYTES) {
fail(label.code, `${label.name} exceeds the byte limit`);
}
const bytes = await handle.readFile();
if (bytes.byteLength > MAX_REQUEST_BYTES) {
fail(label.code, `${label.name} grew beyond the byte limit while being read`);
}
return parseJsonStrict(bytes, `structured ${label.name}`);
} catch (error) {
if (error instanceof IntegrationError) {
throw error;
}
fail(
label.code,
`structured ${label.name} is invalid`,
failureDiagnostic(error)
);
} finally {
await handle?.close();
}
}
async function readVerificationRequest(requestInput) {
const parsed = await readStrictRequestFile(requestInput, {
code: "INVALID_VERIFICATION_REQUEST",
name: "verification request"
});
return normalizeVerificationRequest(parsed);
}
async function readConformanceRequest(requestInput) {
const parsed = await readStrictRequestFile(requestInput, {
code: "INVALID_CONFORMANCE_REQUEST",
name: "conformance request"
});
return normalizeConformanceRequest(parsed);
}
async function readOneJsonLineFromStdin(errorCode, label) {
if (process.stdin.isTTY) {
fail(errorCode, `${label} requires structured non-interactive stdin`);
}
const bytes = await new Promise((resolveInput, rejectInput) => {
const chunks = [];
let totalBytes = 0;
let settled = false;
const cleanup = () => {
process.stdin.off("data", onData);
process.stdin.off("end", onEnd);
process.stdin.off("error", onError);
process.stdin.pause();
};
const settle = (callback, value) => {
if (settled) {
return;
}
settled = true;
cleanup();
callback(value);
};
const onError = (error) => settle(rejectInput, error);
const onEnd = () => settle(rejectInput, new Error(`${label} ended before newline`));
const onData = (chunk) => {
const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
totalBytes += buffer.byteLength;
if (totalBytes > MAX_REQUEST_BYTES + 1) {
settle(rejectInput, new Error(`${label} exceeds the byte limit`));
return;
}
const newlineIndex = buffer.indexOf(10);
if (newlineIndex === -1) {
chunks.push(buffer);
return;
}
if (newlineIndex !== buffer.byteLength - 1) {
settle(rejectInput, new Error(`${label} must contain exactly one JSON line`));
return;
}
chunks.push(buffer.subarray(0, newlineIndex));
const combined = Buffer.concat(chunks);
if (combined.byteLength === 0 || combined.byteLength > MAX_REQUEST_BYTES) {
settle(rejectInput, new Error(`${label} has an invalid byte length`));
return;
}
settle(resolveInput, combined);
};
process.stdin.on("data", onData);
process.stdin.on("end", onEnd);
process.stdin.on("error", onError);
process.stdin.resume();
}).catch((error) => {
fail(errorCode, `${label} is invalid`, failureDiagnostic(error));
});
try {
return parseJsonStrict(bytes, label);
} catch (error) {
fail(errorCode, `${label} is invalid`, failureDiagnostic(error));
}
}
async function verifyRequestCommand(config, args) {
const values = parseOptions(args, /* @__PURE__ */ new Set(["--request"]), config.hostName);
const request = await readVerificationRequest(required(values, "--request"));
return verifyInputs(config, {
expectedAudience: request.audience,
expectedDossierNonce: request.nonce,
audienceSource: request.audienceSource,
nonceSource: request.nonceSource,
dossierInput: request.dossier
});
}
async function verifyStdinCommand(config, args) {
const values = parseOptions(args, /* @__PURE__ */ new Set(), config.hostName);
if (values.size !== 0) {
fail("UNKNOWN_OPTION", "An unsupported option was supplied");
}
const parsed = await readOneJsonLineFromStdin(
"INVALID_VERIFICATION_REQUEST",
"structured verification request"
);
const request = normalizeVerificationRequest(parsed);
return verifyInputs(config, {
expectedAudience: request.audience,
expectedDossierNonce: request.nonce,
audienceSource: request.audienceSource,
nonceSource: request.nonceSource,
dossierInput: request.dossier
});
}
async function verifyInputs(config, { expectedAudience, expectedDossierNonce, audienceSource, nonceSource, dossierInput }) {
const normalizedAudienceSource = pinSource(audienceSource, "audience source");
const normalizedNonceSource = pinSource(nonceSource, "nonce source");
assertLocalPath(dossierInput, "--dossier");
const dossierPath = resolve4(dossierInput);
let verified;
try {
verified = await verifyDossier(dossierPath, {
expectedAudience,
expectedDossierNonce
});
} catch (error) {
fail("VERIFICATION_FAILED", "Dossier verification failed", failureDiagnostic(error));
}
if (verified.summary.audienceBinding !== "PINNED" || verified.summary.dossierNonceBinding !== "PINNED") {
fail("PINNING_INVARIANT_FAILED", "The verifier did not report both context bindings as PINNED");
}
if (verified.summary.economicAction !== "OUT_OF_SCOPE") {
fail("ECONOMIC_BOUNDARY_FAILED", "EvalDossier protocol 0.1 forbids economic action");
}
return {
integration: config.integrationId,
operation: "verify",
status: "PASS",
verificationStatus: "VERIFIED",
projectionVersion: PROJECTION_VERSION,
dossierLocation: localPathReference(dossierPath),
pinProvenance: {
audience: normalizedAudienceSource,
nonce: normalizedNonceSource,
assurance: "CALLER_DECLARED_NOT_VERIFIED"
},
summary: modelSafeSummary(verified),
nonClaims: [...VERIFY_NON_CLAIMS]
};
}
function generateEphemeralFixtureKey() {
const { privateKey } = generateKeyPairSync("ed25519");
const exported = privateKey.export({ format: "jwk" });
if (exported.kty !== "OKP" || exported.crv !== "Ed25519" || typeof exported.x !== "string" || typeof exported.d !== "string") {
throw new Error("Node.js did not export an Ed25519 private JWK");
}
return Object.freeze({
alg: "EdDSA",
crv: "Ed25519",
d: exported.d,
kid: jwkThumbprint({ kty: "OKP", crv: "Ed25519", x: exported.x }),
kty: "OKP",
use: "sig",
x: exported.x
});
}
function conformanceDossier(config) {
return {
dossierId: `${config.hostSlug}.skill.reference.conformance.001`,
generatedAt: "2026-07-21T12:00:10Z",
classification: "INTERNAL_REFERENCE",
exporterId: "evaldossier.fixture.exporter",
audience: `evaldossier.${config.hostSlug}.skill.example`,
nonce: Buffer.from(`${config.hostSlug}-skill-reference-nonce-001`, "utf8").toString(
"base64url"
),
warnings: [
`This dossier was generated by the local ${config.hostName} Skill conformance path with ephemeral synthetic keys.`,
"Ephemeral test-key control establishes no institutional identity, trust, authority, or production readiness."
]
};
}
async function runConformance(config, outputInput) {
assertLocalPath(outputInput, "--output");
const outputDirectory = resolve4(outputInput);
let result;
try {
const evaluatorKey = generateEphemeralFixtureKey();
const requesterKey = generateEphemeralFixtureKey();
const exporterKey = generateEphemeralFixtureKey();
const evaluator = defineEvaluator({
evaluatorId: "evaldossier-reference-evaluator",
async evaluate(input) {
return buildReferenceEvaluation(input.projectRoot, input.evaluatorKey, input.requesterKey);
}
});
result = await assertEvaluatorConformance(
evaluator,
{ projectRoot, evaluatorKey, requesterKey },
{
outputDirectory,
exporterKey,
dossier: conformanceDossier(config)
},
{
bases: ["FORMAL_PREDICATE"],
overallBasis: "FORMAL_PREDICATE",
predicateStatuses: ["ESTABLISHED_TRUE"],
obligationVerdict: "SATISFIED"
}
);
} catch (error) {
fail("CONFORMANCE_FAILED", "Evaluator conformance failed", failureDiagnostic(error));
}
return {
integration: config.integrationId,
operation: "conformance",
status: "PASS",
verificationStatus: "VERIFIED",
projectionVersion: PROJECTION_VERSION,
dossierLocation: localPathReference(outputDirectory),
pinProvenance: {
audience: "PUBLIC_TEST_FIXTURE",
nonce: "PUBLIC_TEST_FIXTURE",
assurance: "SYNTHETIC_CONFORMANCE_ONLY"
},
checks: result.checks,
summary: modelSafeSummary(result.verified),
nonClaims: [...CONFORMANCE_NON_CLAIMS]
};
}
async function conformanceCommand(config, args) {
const values = parseOptions(args, /* @__PURE__ */ new Set(["--output"]), config.hostName);
return runConformance(config, required(values, "--output"));
}
async function conformanceRequestCommand(config, args) {
const values = parseOptions(args, /* @__PURE__ */ new Set(["--request"]), config.hostName);
const request = await readConformanceRequest(required(values, "--request"));
return runConformance(config, request.output);
}
async function conformanceStdinCommand(config, args) {
const values = parseOptions(args, /* @__PURE__ */ new Set(), config.hostName);
if (values.size !== 0) {
fail("UNKNOWN_OPTION", "An unsupported option was supplied");
}
const parsed = await readOneJsonLineFromStdin(
"INVALID_CONFORMANCE_REQUEST",
"structured conformance request"
);
const request = normalizeConformanceRequest(parsed);
return runConformance(config, request.output);
}
async function main(config, args) {
const [operation, ...rest] = args;
if (operation === "verify") {
return verifyCommand(config, rest);
}
if (operation === "verify-request") {
return verifyRequestCommand(config, rest);
}
if (operation === "verify-stdin") {
return verifyStdinCommand(config, rest);
}
if (operation === "conformance") {
return conformanceCommand(config, rest);
}
if (operation === "conformance-request") {
return conformanceRequestCommand(config, rest);
}
if (operation === "conformance-stdin") {
return conformanceStdinCommand(config, rest);
}
fail(
"UNKNOWN_OPERATION",
"Operation must be verify, verify-request, verify-stdin, conformance, conformance-request or conformance-stdin"
);
}
async function runLocalIntegrationCli(configInput, args = process.argv.slice(2)) {
let config;
try {
config = normalizeIntegrationConfig(configInput);
const result = await main(config, args);
process.stdout.write(`${JSON.stringify(result, null, 2)}
`);
} catch (error) {
const integrationError = error instanceof IntegrationError ? error : new IntegrationError("INTEGRATION_FAILED", "Unexpected integration failure");
const operation = args[0] === "verify" || args[0] === "verify-request" || args[0] === "verify-stdin" ? "verify" : args[0] === "conformance" || args[0] === "conformance-request" || args[0] === "conformance-stdin" ? "conformance" : "unknown";
process.stdout.write(
`${JSON.stringify(
{
integration: config?.integrationId ?? "evaldossier-local/invalid-config",
operation,
status: "FAIL",
verificationStatus: "NOT_VERIFIED",
projectionVersion: PROJECTION_VERSION,
error: {
code: integrationError.code,
message: integrationError.message,
...integrationError.diagnostic === void 0 ? {} : { diagnostic: integrationError.diagnostic }
}
},
null,
2
)}
`
);
process.stderr.write(
`EvalDossier ${config?.hostName ?? "local"} integration: ${integrationError.message}
`
);
process.exitCode = 1;
}
}
export {
runLocalIntegrationCli
};
SHA-256: f61e96e4ef696fa5af6dc044afbe37cb31a281a3188e005afe9f6900713c2706