diff --git a/README.md b/README.md
index 5c691ff..e896efe 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,5 @@
-
-
+
+
@@ -24,27 +24,26 @@ Pullfrog is a GitHub bot that brings the full power of your favorite coding agen
- **Tag `@pullfrog`** — Tag `@pullfrog` in a comment anywhere in your repo. It will pull in any relevant context using the action's internal MCP server and perform the appropriate task.
- **Prompt from the web** — Trigger arbitrary tasks from the Pullfrog dashboard
-- **Automated triggers** — Configure Pullfrog to trigger agent runs in response to specific events. Each of these triggers can be associated with custom prompt instructions.
+- **Automated triggers** — Configure Pullfrog to trigger agent runs in response to specific events. Each of these triggers can be associated with custom prompt instructions.
- issue created
- issue labeled
- PR created
- - PR review created
+ - PR review created
- PR review requested
- and more...
Pullfrog is the bridge between your preferred coding agents and GitHub. Use it for:
-
+
- **🤖 Coding tasks** — Tell `@pullfrog` to implement something and it'll spin up a PR. If CI fails, it'll read the logs and attempt a fix automatically. It'll automatically address any PR reviews too.
- **🔍 PR review** — Coding agents are great at reviewing PRs. Using the "PR created" trigger, you can configure Pullfrog to auto-review new PRs.
- **🤙 Issue management** — Via the "issue created" trigger, Pullfrog can automatically respond to common questions, create implementation plans, and link to related issues/PRs. Or (if you're feeling lucky) you can prompt it to immediately attempt a PR addressing new issues.
- **Literally whatever** — Want to have the agent automatically add docs to all new PRs? Cut a new release with agent-written notes on every commit to `main`? Pullfrog lets you do it.
-
-
+
+## Standalone Usage
+
+You can also use `pullfrog/pullfrog` as a step in your own workflows. The action exposes a `result` output that can be consumed by subsequent steps.
+
+### Example: Auto-generate release notes on new tags
+
+```yaml
+name: Release
+on:
+ push:
+ tags: ['v*']
+
+permissions:
+ contents: write
+
+jobs:
+ release:
+ runs-on: ubuntu-latest
+ steps:
+ - name: Checkout
+ uses: actions/checkout@v4
+ with:
+ fetch-depth: 0
+
+ - name: Generate release notes
+ id: notes
+ uses: pullfrog/pullfrog@v0
+ with:
+ prompt: |
+ Generate release notes for ${{ github.ref_name }}.
+ Compare commits between this tag and the previous tag.
+ Format as markdown: summary paragraph, then ### Features, ### Fixes, ### Breaking Changes sections.
+ Omit empty sections. Be concise.
+ env:
+ ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+
+ # write to file to avoid shell escaping issues with special characters
+ - name: Create GitHub release
+ run: |
+ notesfile="$RUNNER_TEMP/release-notes-$GITHUB_RUN_ID.md"
+ printf '%s' "$NOTES" > "$notesfile"
+ gh release create ${{ github.ref_name }} --title "${{ github.ref_name }}" --notes-file "$notesfile"
+ env:
+ GH_TOKEN: ${{ github.token }}
+ NOTES: ${{ steps.notes.outputs.result }}
+```
+
+### Example: Structured Output with Zod Schema
+
+You can force the agent to return structured JSON output by providing a JSON schema. This allows you to reliably parse and use the agent's response in subsequent workflow steps.
+
+You can define your JSON schema directly or uou can use any validation library that converts to JSON Schema. Here's an example using [Zod](https://zod.dev):
+
+```yaml
+name: Release Check
+on:
+ pull_request:
+ types: [closed]
+
+jobs:
+ check-release:
+ if: github.event.pull_request.merged == true
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+
+ - name: Install dependencies
+ run: npm install --no-save --no-package-lock zod @actions/core
+
+ - name: Generate Schema
+ id: schema
+ run: |
+ node -e '
+ import { z } from "zod";
+ import { setOutput } from "@actions/core";
+ const schema = z.object({
+ version: z.string().describe("Semantic version number (e.g. 1.0.0)"),
+ isBreaking: z.boolean().describe("Whether this release contains breaking changes"),
+ changelog: z.array(z.string()).describe("List of changes in this release"),
+ });
+ setOutput("schema", JSON.stringify(z.toJSONSchema(schema)));
+ '
+
+ - name: Analyze PR
+ id: analysis
+ uses: pullfrog/pullfrog@v0
+ with:
+ prompt: |
+ Analyze this PR and determine semantic versioning impact.
+ Return a JSON object matching the provided schema.
+ output_schema: ${{ steps.schema.outputs.schema }}
+ env:
+ ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+
+ - name: Process Result
+ run: |
+ # Parse the JSON result using fromJSON()
+ echo "Version: ${{ fromJSON(steps.analysis.outputs.result).version }}"
+ echo "Breaking: ${{ fromJSON(steps.analysis.outputs.result).isBreaking }}"
+```
diff --git a/action.yml b/action.yml
index 7905029..00873ae 100644
--- a/action.yml
+++ b/action.yml
@@ -30,6 +30,9 @@ inputs:
shell:
description: "Shell permission: disabled, restricted (filters secrets from env vars), or enabled. Public repos default to restricted for security; private repos default to enabled."
required: false
+ output_schema:
+ description: "JSON Schema (draft-07) for structured output validation. When provided, the action output becomes required and must conform to this schema."
+ required: false
token:
description: "GitHub-provided token with job-scoped permissions. Do not set this unless you know what you are doing."
required: false
@@ -37,7 +40,7 @@ inputs:
outputs:
result:
- description: "It's set when the prompt explicitly requests it. It can be used to capture an actionable output for the next step in the workflow."
+ description: "It's set when the prompt explicitly requests it and is required when output_schema is provided; use it to capture actionable output for the next workflow step."
runs:
using: "node24"
diff --git a/entry b/entry
index cdeee5f..6164ce0 100755
--- a/entry
+++ b/entry
@@ -19732,7 +19732,7 @@ var require_core = __commonJS({
process.env["PATH"] = `${inputPath}${path3.delimiter}${process.env["PATH"]}`;
}
exports.addPath = addPath;
- function getInput3(name, options) {
+ function getInput4(name, options) {
const val = process.env[`INPUT_${name.replace(/ /g, "_").toUpperCase()}`] || "";
if (options && options.required && !val) {
throw new Error(`Input required and not supplied: ${name}`);
@@ -19742,9 +19742,9 @@ var require_core = __commonJS({
}
return val.trim();
}
- exports.getInput = getInput3;
+ exports.getInput = getInput4;
function getMultilineInput(name, options) {
- const inputs = getInput3(name, options).split("\n").filter((x) => x !== "");
+ const inputs = getInput4(name, options).split("\n").filter((x) => x !== "");
if (options && options.trimWhitespace === false) {
return inputs;
}
@@ -19754,7 +19754,7 @@ var require_core = __commonJS({
function getBooleanInput(name, options) {
const trueValue = ["true", "True", "TRUE"];
const falseValue = ["false", "False", "FALSE"];
- const val = getInput3(name, options);
+ const val = getInput4(name, options);
if (trueValue.includes(val))
return true;
if (falseValue.includes(val))
@@ -41441,7 +41441,7 @@ var require_core2 = __commonJS({
uriResolver
};
}
- var Ajv2 = class {
+ var Ajv3 = class {
constructor(opts = {}) {
this.schemas = {};
this.refs = {};
@@ -41811,9 +41811,9 @@ var require_core2 = __commonJS({
}
}
};
- Ajv2.ValidationError = validation_error_1.default;
- Ajv2.MissingRefError = ref_error_1.default;
- exports.default = Ajv2;
+ Ajv3.ValidationError = validation_error_1.default;
+ Ajv3.MissingRefError = ref_error_1.default;
+ exports.default = Ajv3;
function checkOptions(checkOpts, options, msg, log2 = "error") {
for (const key in checkOpts) {
const opt = key;
@@ -42088,7 +42088,7 @@ var require_core3 = __commonJS({
Object.defineProperty(exports, "__esModule", { value: true });
var id_1 = require_id();
var ref_1 = require_ref();
- var core6 = [
+ var core7 = [
"$schema",
"$id",
"$defs",
@@ -42098,7 +42098,7 @@ var require_core3 = __commonJS({
id_1.default,
ref_1.default
];
- exports.default = core6;
+ exports.default = core7;
}
});
@@ -43915,7 +43915,7 @@ var require_ajv = __commonJS({
var draft7MetaSchema = require_json_schema_draft_07();
var META_SUPPORT_DATA = ["/properties"];
var META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
- var Ajv2 = class extends core_1.default {
+ var Ajv3 = class extends core_1.default {
_addVocabularies() {
super._addVocabularies();
draft7_1.default.forEach((v) => this.addVocabulary(v));
@@ -43934,11 +43934,11 @@ var require_ajv = __commonJS({
return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
}
};
- exports.Ajv = Ajv2;
- module.exports = exports = Ajv2;
- module.exports.Ajv = Ajv2;
+ exports.Ajv = Ajv3;
+ module.exports = exports = Ajv3;
+ module.exports.Ajv = Ajv3;
Object.defineProperty(exports, "__esModule", { value: true });
- exports.default = Ajv2;
+ exports.default = Ajv3;
var validate_1 = require_validate();
Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
return validate_1.KeywordCxt;
@@ -74358,6 +74358,5613 @@ var require_fast_content_type_parse = __commonJS({
}
});
+// node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/codegen/code.js
+var require_code4 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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 _a2;
+ return (_a2 = this._str) !== null && _a2 !== void 0 ? _a2 : this._str = this._items.reduce((s, c) => `${s}${c}`, "");
+ }
+ get names() {
+ var _a2;
+ return (_a2 = this._names) !== null && _a2 !== void 0 ? _a2 : 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, ...args2) {
+ const code = [strs[0]];
+ let i = 0;
+ while (i < args2.length) {
+ addCodeArg(code, args2[i]);
+ code.push(strs[++i]);
+ }
+ return new _Code(code);
+ }
+ exports._ = _;
+ var plus = new _Code("+");
+ function str(strs, ...args2) {
+ const expr = [safeStringify(strs[0])];
+ let i = 0;
+ while (i < args2.length) {
+ expr.push(plus);
+ addCodeArg(expr, args2[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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/codegen/scope.js
+var require_scope3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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_code4();
+ 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 Scope2 = 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 _a2, _b;
+ if (((_b = (_a2 = this._parent) === null || _a2 === void 0 ? void 0 : _a2._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 = Scope2;
+ var ValueScopeName = class extends code_1.Name {
+ constructor(prefix, nameStr) {
+ super(nameStr);
+ this.prefix = prefix;
+ }
+ setValue(value2, { property, itemIndex }) {
+ this.value = value2;
+ this.scopePath = (0, code_1._)`.${new code_1.Name(property)}[${itemIndex}]`;
+ }
+ };
+ exports.ValueScopeName = ValueScopeName;
+ var line = (0, code_1._)`\n`;
+ var ValueScope = class extends Scope2 {
+ 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, value2) {
+ var _a2;
+ if (value2.ref === void 0)
+ throw new Error("CodeGen: ref must be passed in value");
+ const name = this.toName(nameOrPrefix);
+ const { prefix } = name;
+ const valueKey = (_a2 = value2.key) !== null && _a2 !== void 0 ? _a2 : value2.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] = value2.ref;
+ name.setValue(value2, { 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/codegen/index.js
+var require_codegen3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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_code4();
+ var scope_1 = require_scope3();
+ var code_2 = require_code4();
+ 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_scope3();
+ 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, constants) {
+ if (!names[this.name.str])
+ return;
+ if (this.rhs)
+ this.rhs = optimizeExpr(this.rhs, names, constants);
+ return this;
+ }
+ get names() {
+ return this.rhs instanceof code_1._CodeOrName ? this.rhs.names : {};
+ }
+ };
+ 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, constants) {
+ if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
+ return;
+ this.rhs = optimizeExpr(this.rhs, names, constants);
+ return this;
+ }
+ get names() {
+ const names = this.lhs instanceof code_1.Name ? {} : { ...this.lhs.names };
+ return addExprNames(names, this.rhs);
+ }
+ };
+ 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(error49) {
+ super();
+ this.error = error49;
+ }
+ 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, constants) {
+ this.code = optimizeExpr(this.code, names, constants);
+ 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, constants) {
+ const { nodes } = this;
+ let i = nodes.length;
+ while (i--) {
+ const n = nodes[i];
+ if (n.optimizeNames(names, constants))
+ continue;
+ subtractNames(names, n.names);
+ nodes.splice(i, 1);
+ }
+ return nodes.length > 0 ? this : 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, constants) {
+ var _a2;
+ this.else = (_a2 = this.else) === null || _a2 === void 0 ? void 0 : _a2.optimizeNames(names, constants);
+ if (!(super.optimizeNames(names, constants) || this.else))
+ return;
+ this.condition = optimizeExpr(this.condition, names, constants);
+ return this;
+ }
+ get names() {
+ const names = super.names;
+ addExprNames(names, this.condition);
+ if (this.else)
+ addNames(names, this.else.names);
+ return names;
+ }
+ };
+ If.kind = "if";
+ 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, constants) {
+ if (!super.optimizeNames(names, constants))
+ return;
+ this.iteration = optimizeExpr(this.iteration, names, constants);
+ return this;
+ }
+ get names() {
+ return addNames(super.names, this.iteration.names);
+ }
+ };
+ 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, constants) {
+ if (!super.optimizeNames(names, constants))
+ return;
+ this.iterable = optimizeExpr(this.iterable, names, constants);
+ return this;
+ }
+ get names() {
+ return addNames(super.names, this.iterable.names);
+ }
+ };
+ var Func = class extends BlockNode {
+ constructor(name, args2, async) {
+ super();
+ this.name = name;
+ this.args = args2;
+ 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 _a2, _b;
+ super.optimizeNodes();
+ (_a2 = this.catch) === null || _a2 === void 0 ? void 0 : _a2.optimizeNodes();
+ (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes();
+ return this;
+ }
+ optimizeNames(names, constants) {
+ var _a2, _b;
+ super.optimizeNames(names, constants);
+ (_a2 = this.catch) === null || _a2 === void 0 ? void 0 : _a2.optimizeNames(names, constants);
+ (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants);
+ return this;
+ }
+ get names() {
+ const names = super.names;
+ if (this.catch)
+ addNames(names, this.catch.names);
+ if (this.finally)
+ addNames(names, this.finally.names);
+ return names;
+ }
+ };
+ var Catch = class extends BlockNode {
+ constructor(error49) {
+ super();
+ this.error = error49;
+ }
+ 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, value2) {
+ const name = this._extScope.value(prefixOrName, value2);
+ 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, value2] of keyValues) {
+ if (code.length > 1)
+ code.push(",");
+ code.push(key);
+ if (key !== value2 || this.opts.es5) {
+ code.push(":");
+ (0, code_1.addCodeArg)(code, value2);
+ }
+ }
+ 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(node2, forBody) {
+ this._blockNode(node2);
+ 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(value2) {
+ const node2 = new Return();
+ this._blockNode(node2);
+ this.code(value2);
+ if (node2.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 node2 = new Try();
+ this._blockNode(node2);
+ this.code(tryBody);
+ if (catchCode) {
+ const error49 = this.name("e");
+ this._currNode = node2.catch = new Catch(error49);
+ catchCode(error49);
+ }
+ if (finallyCode) {
+ this._currNode = node2.finally = new Finally();
+ this.code(finallyCode);
+ }
+ return this._endBlockNode(Catch, Finally);
+ }
+ // `throw` statement
+ throw(error49) {
+ return this._leafNode(new Throw(error49));
+ }
+ // 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, args2 = code_1.nil, async, funcBody) {
+ this._blockNode(new Func(name, args2, 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(node2) {
+ this._currNode.nodes.push(node2);
+ return this;
+ }
+ _blockNode(node2) {
+ this._currNode.nodes.push(node2);
+ this._nodes.push(node2);
+ }
+ _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(node2) {
+ const n = this._currNode;
+ if (!(n instanceof If)) {
+ throw new Error('CodeGen: "else" without "if"');
+ }
+ this._currNode = n.else = node2;
+ return this;
+ }
+ get _root() {
+ return this._nodes[0];
+ }
+ get _currNode() {
+ const ns = this._nodes;
+ return ns[ns.length - 1];
+ }
+ set _currNode(node2) {
+ const ns = this._nodes;
+ ns[ns.length - 1] = node2;
+ }
+ };
+ exports.CodeGen = CodeGen;
+ function addNames(names, from) {
+ for (const n in from)
+ names[n] = (names[n] || 0) + (from[n] || 0);
+ return names;
+ }
+ function addExprNames(names, from) {
+ return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
+ }
+ function optimizeExpr(expr, names, constants) {
+ if (expr instanceof code_1.Name)
+ return replaceName(expr);
+ if (!canOptimize(expr))
+ return expr;
+ return new code_1._Code(expr._items.reduce((items, c) => {
+ if (c instanceof code_1.Name)
+ c = replaceName(c);
+ if (c instanceof code_1._Code)
+ items.push(...c._items);
+ else
+ items.push(c);
+ return items;
+ }, []));
+ function replaceName(n) {
+ const c = constants[n.str];
+ if (c === 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 && constants[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(...args2) {
+ return args2.reduce(andCode);
+ }
+ exports.and = and;
+ var orCode = mappend(exports.operators.OR);
+ function or(...args2) {
+ return args2.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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/util.js
+var require_util16 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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_codegen3();
+ var code_1 = require_code4();
+ function toHash(arr) {
+ const hash2 = {};
+ for (const item of arr)
+ hash2[item] = true;
+ return hash2;
+ }
+ exports.toHash = toHash;
+ function alwaysValidSchema(it, schema2) {
+ if (typeof schema2 == "boolean")
+ return schema2;
+ if (Object.keys(schema2).length === 0)
+ return true;
+ checkUnknownRules(it, schema2);
+ return !schemaHasRules(schema2, it.self.RULES.all);
+ }
+ exports.alwaysValidSchema = alwaysValidSchema;
+ function checkUnknownRules(it, schema2 = it.schema) {
+ const { opts, self: self2 } = it;
+ if (!opts.strictSchema)
+ return;
+ if (typeof schema2 === "boolean")
+ return;
+ const rules = self2.RULES.keywords;
+ for (const key in schema2) {
+ if (!rules[key])
+ checkStrictMode(it, `unknown keyword: "${key}"`);
+ }
+ }
+ exports.checkUnknownRules = checkUnknownRules;
+ function schemaHasRules(schema2, rules) {
+ if (typeof schema2 == "boolean")
+ return !schema2;
+ for (const key in schema2)
+ if (rules[key])
+ return true;
+ return false;
+ }
+ exports.schemaHasRules = schemaHasRules;
+ function schemaHasRulesButRef(schema2, RULES) {
+ if (typeof schema2 == "boolean")
+ return !schema2;
+ for (const key in schema2)
+ if (key !== "$ref" && RULES.all[key])
+ return true;
+ return false;
+ }
+ exports.schemaHasRulesButRef = schemaHasRulesButRef;
+ function schemaRefOrVal({ topSchemaRef, schemaPath }, schema2, keyword, $data) {
+ if (!$data) {
+ if (typeof schema2 == "number" || typeof schema2 == "boolean")
+ return schema2;
+ if (typeof schema2 == "string")
+ return (0, codegen_1._)`${schema2}`;
+ }
+ 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: mergeValues4, 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) : mergeValues4(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 Type2;
+ (function(Type3) {
+ Type3[Type3["Num"] = 0] = "Num";
+ Type3[Type3["Str"] = 1] = "Str";
+ })(Type2 || (exports.Type = Type2 = {}));
+ function getErrorPath(dataProp, dataPropType, jsPropertySyntax) {
+ if (dataProp instanceof codegen_1.Name) {
+ const isNumber2 = dataPropType === Type2.Num;
+ return jsPropertySyntax ? isNumber2 ? (0, codegen_1._)`"[" + ${dataProp} + "]"` : (0, codegen_1._)`"['" + ${dataProp} + "']"` : isNumber2 ? (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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/names.js
+var require_names3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/names.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var codegen_1 = require_codegen3();
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/errors.js
+var require_errors5 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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_codegen3();
+ var util_1 = require_util16();
+ var names_1 = require_names3();
+ 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, error49 = exports.keywordError, errorPaths, overrideAllErrors) {
+ const { it } = cxt;
+ const { gen, compositeRule, allErrors } = it;
+ const errObj = errorObjectCode(cxt, error49, 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, error49 = exports.keywordError, errorPaths) {
+ const { it } = cxt;
+ const { gen, compositeRule, allErrors } = it;
+ const errObj = errorObjectCode(cxt, error49, 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, error49, errorPaths) {
+ const { createErrors } = cxt.it;
+ if (createErrors === false)
+ return (0, codegen_1._)`{}`;
+ return errorObject(cxt, error49, errorPaths);
+ }
+ function errorObject(cxt, error49, errorPaths = {}) {
+ const { gen, it } = cxt;
+ const keyValues = [
+ errorInstancePath(it, errorPaths),
+ errorSchemaPath(cxt, errorPaths)
+ ];
+ extraErrorProps(cxt, error49, 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/validate/boolSchema.js
+var require_boolSchema3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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_errors5();
+ var codegen_1 = require_codegen3();
+ var names_1 = require_names3();
+ var boolError = {
+ message: "boolean schema is false"
+ };
+ function topBoolOrEmptySchema(it) {
+ const { gen, schema: schema2, validateName } = it;
+ if (schema2 === false) {
+ falseSchemaError(it, false);
+ } else if (typeof schema2 == "object" && schema2.$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: schema2 } = it;
+ if (schema2 === 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/rules.js
+var require_rules3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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 groups2 = {
+ number: { type: "number", rules: [] },
+ string: { type: "string", rules: [] },
+ array: { type: "array", rules: [] },
+ object: { type: "object", rules: [] }
+ };
+ return {
+ types: { ...groups2, integer: true, boolean: true, null: true },
+ rules: [{ rules: [] }, groups2.number, groups2.string, groups2.array, groups2.object],
+ post: { rules: [] },
+ all: {},
+ keywords: {}
+ };
+ }
+ exports.getRules = getRules;
+ }
+});
+
+// node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/validate/applicability.js
+var require_applicability3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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: schema2, self: self2 }, type2) {
+ const group2 = self2.RULES.types[type2];
+ return group2 && group2 !== true && shouldUseGroup(schema2, group2);
+ }
+ exports.schemaHasRulesForType = schemaHasRulesForType;
+ function shouldUseGroup(schema2, group2) {
+ return group2.rules.some((rule) => shouldUseRule(schema2, rule));
+ }
+ exports.shouldUseGroup = shouldUseGroup;
+ function shouldUseRule(schema2, rule) {
+ var _a2;
+ return schema2[rule.keyword] !== void 0 || ((_a2 = rule.definition.implements) === null || _a2 === void 0 ? void 0 : _a2.some((kwd) => schema2[kwd] !== void 0));
+ }
+ exports.shouldUseRule = shouldUseRule;
+ }
+});
+
+// node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/validate/dataType.js
+var require_dataType3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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_rules3();
+ var applicability_1 = require_applicability3();
+ var errors_1 = require_errors5();
+ var codegen_1 = require_codegen3();
+ var util_1 = require_util16();
+ var DataType;
+ (function(DataType2) {
+ DataType2[DataType2["Correct"] = 0] = "Correct";
+ DataType2[DataType2["Wrong"] = 1] = "Wrong";
+ })(DataType || (exports.DataType = DataType = {}));
+ function getSchemaTypes(schema2) {
+ const types = getJSONTypes(schema2.type);
+ const hasNull = types.includes("null");
+ if (hasNull) {
+ if (schema2.nullable === false)
+ throw new Error("type: null contradicts nullable: false");
+ } else {
+ if (!types.length && schema2.nullable !== void 0) {
+ throw new Error('"nullable" cannot be used without "type"');
+ }
+ if (schema2.nullable === true)
+ types.push("null");
+ }
+ return types;
+ }
+ exports.getSchemaTypes = getSchemaTypes;
+ function getJSONTypes(ts2) {
+ const types = Array.isArray(ts2) ? ts2 : ts2 ? [ts2] : [];
+ 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: schema2 }) => `must be ${schema2}`,
+ params: ({ schema: schema2, schemaValue }) => typeof schema2 == "string" ? (0, codegen_1._)`{type: ${schema2}}` : (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: schema2 } = it;
+ const schemaCode = (0, util_1.schemaRefOrVal)(it, schema2, "type");
+ return {
+ gen,
+ keyword: "type",
+ data,
+ schema: schema2.type,
+ schemaCode,
+ schemaValue: schemaCode,
+ parentSchema: schema2,
+ params: {},
+ it
+ };
+ }
+ }
+});
+
+// node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/validate/defaults.js
+var require_defaults3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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_codegen3();
+ var util_1 = require_util16();
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/code.js
+var require_code5 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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_codegen3();
+ var util_1 = require_util16();
+ var names_1 = require_names3();
+ var util_2 = require_util16();
+ 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 args2 = (0, codegen_1._)`${dataAndSchema}, ${gen.object(...valCxt)}`;
+ return context !== codegen_1.nil ? (0, codegen_1._)`${func}.call(${context}, ${args2})` : (0, codegen_1._)`${func}(${args2})`;
+ }
+ 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: schema2, keyword, it } = cxt;
+ if (!Array.isArray(schema2))
+ throw new Error("ajv implementation error");
+ const alwaysValid = schema2.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(() => schema2.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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/validate/keyword.js
+var require_keyword3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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_codegen3();
+ var names_1 = require_names3();
+ var code_1 = require_code5();
+ var errors_1 = require_errors5();
+ function macroKeywordCode(cxt, def) {
+ const { gen, keyword, schema: schema2, parentSchema, it } = cxt;
+ const macroSchema = def.macro.call(it.self, schema2, 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 _a2;
+ const { gen, keyword, schema: schema2, parentSchema, $data, it } = cxt;
+ checkAsyncKeyword(it, def);
+ const validate2 = !$data && def.compile ? def.compile.call(it.self, schema2, parentSchema, it) : def.validate;
+ const validateRef = useKeyword(gen, keyword, validate2);
+ const valid = gen.let("valid");
+ cxt.block$data(valid, validateKeyword);
+ cxt.ok((_a2 = def.valid) !== null && _a2 !== void 0 ? _a2 : 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 _a3;
+ gen.if((0, codegen_1.not)((_a3 = def.valid) !== null && _a3 !== void 0 ? _a3 : 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(schema2, schemaType, allowUndefined = false) {
+ return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema2) : st === "object" ? schema2 && typeof schema2 == "object" && !Array.isArray(schema2) : typeof schema2 == st || allowUndefined && typeof schema2 == "undefined");
+ }
+ exports.validSchemaType = validSchemaType;
+ function validateKeywordUsage({ schema: schema2, opts, self: self2, errSchemaPath }, def, keyword) {
+ if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword) {
+ throw new Error("ajv implementation error");
+ }
+ const deps = def.dependencies;
+ if (deps === null || deps === void 0 ? void 0 : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema2, kwd))) {
+ throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(",")}`);
+ }
+ if (def.validateSchema) {
+ const valid = def.validateSchema(schema2[keyword]);
+ if (!valid) {
+ const msg = `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` + self2.errorsText(def.validateSchema.errors);
+ if (opts.validateSchema === "log")
+ self2.logger.error(msg);
+ else
+ throw new Error(msg);
+ }
+ }
+ }
+ exports.validateKeywordUsage = validateKeywordUsage;
+ }
+});
+
+// node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/validate/subschema.js
+var require_subschema3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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_codegen3();
+ var util_1 = require_util16();
+ function getSubschema(it, { keyword, schemaProp, schema: schema2, schemaPath, errSchemaPath, topSchemaRef }) {
+ if (keyword !== void 0 && schema2 !== 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 (schema2 !== 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: schema2,
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/resolve.js
+var require_resolve3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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_util16();
+ 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(schema2, limit = true) {
+ if (typeof schema2 == "boolean")
+ return true;
+ if (limit === true)
+ return !hasRef(schema2);
+ if (!limit)
+ return false;
+ return countKeys(schema2) <= limit;
+ }
+ exports.inlineRef = inlineRef;
+ var REF_KEYWORDS = /* @__PURE__ */ new Set([
+ "$ref",
+ "$recursiveRef",
+ "$recursiveAnchor",
+ "$dynamicRef",
+ "$dynamicAnchor"
+ ]);
+ function hasRef(schema2) {
+ for (const key in schema2) {
+ if (REF_KEYWORDS.has(key))
+ return true;
+ const sch = schema2[key];
+ if (Array.isArray(sch) && sch.some(hasRef))
+ return true;
+ if (typeof sch == "object" && hasRef(sch))
+ return true;
+ }
+ return false;
+ }
+ function countKeys(schema2) {
+ let count = 0;
+ for (const key in schema2) {
+ if (key === "$ref")
+ return Infinity;
+ count++;
+ if (SIMPLE_INLINED.has(key))
+ continue;
+ if (typeof schema2[key] == "object") {
+ (0, util_1.eachItem)(schema2[key], (sch) => count += countKeys(sch));
+ }
+ if (count === Infinity)
+ return Infinity;
+ }
+ return count;
+ }
+ function getFullPath(resolver, id = "", normalize2) {
+ if (normalize2 !== 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(schema2, baseId) {
+ if (typeof schema2 == "boolean")
+ return {};
+ const { schemaId, uriResolver } = this.opts;
+ const schId = normalizeId(schema2[schemaId] || baseId);
+ const baseIds = { "": schId };
+ const pathPrefix = getFullPath(uriResolver, schId, false);
+ const localRefs = {};
+ const schemaRefs = /* @__PURE__ */ new Set();
+ traverse(schema2, { 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/validate/index.js
+var require_validate3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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_boolSchema3();
+ var dataType_1 = require_dataType3();
+ var applicability_1 = require_applicability3();
+ var dataType_2 = require_dataType3();
+ var defaults_1 = require_defaults3();
+ var keyword_1 = require_keyword3();
+ var subschema_1 = require_subschema3();
+ var codegen_1 = require_codegen3();
+ var names_1 = require_names3();
+ var resolve_1 = require_resolve3();
+ var util_1 = require_util16();
+ var errors_1 = require_errors5();
+ 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: schema2, 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(schema2, 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(schema2, 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: schema2, opts, gen } = it;
+ validateFunction(it, () => {
+ if (opts.$comment && schema2.$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(schema2, opts) {
+ const schId = typeof schema2 == "object" && schema2[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: schema2, self: self2 }) {
+ if (typeof schema2 == "boolean")
+ return !schema2;
+ for (const key in schema2)
+ if (self2.RULES.all[key])
+ return true;
+ return false;
+ }
+ function isSchemaObj(it) {
+ return typeof it.schema != "boolean";
+ }
+ function subSchemaObjCode(it, valid) {
+ const { schema: schema2, gen, opts } = it;
+ if (opts.$comment && schema2.$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: schema2, errSchemaPath, opts, self: self2 } = it;
+ if (schema2.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema2, self2.RULES)) {
+ self2.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
+ }
+ }
+ function checkNoDefault(it) {
+ const { schema: schema2, opts } = it;
+ if (schema2.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: schema2, errSchemaPath, opts }) {
+ const msg = schema2.$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: schema2, data, allErrors, opts, self: self2 } = it;
+ const { RULES } = self2;
+ if (schema2.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema2, RULES))) {
+ gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
+ return;
+ }
+ if (!opts.jtd)
+ checkStrictTypes(it, types);
+ gen.block(() => {
+ for (const group2 of RULES.rules)
+ groupKeywords(group2);
+ groupKeywords(RULES.post);
+ });
+ function groupKeywords(group2) {
+ if (!(0, applicability_1.shouldUseGroup)(schema2, group2))
+ return;
+ if (group2.type) {
+ gen.if((0, dataType_2.checkDataType)(group2.type, data, opts.strictNumbers));
+ iterateKeywords(it, group2);
+ if (types.length === 1 && types[0] === group2.type && typeErrors) {
+ gen.else();
+ (0, dataType_2.reportTypeError)(it);
+ }
+ gen.endIf();
+ } else {
+ iterateKeywords(it, group2);
+ }
+ if (!allErrors)
+ gen.if((0, codegen_1._)`${names_1.default.errors} === ${errsCount || 0}`);
+ }
+ }
+ function iterateKeywords(it, group2) {
+ const { gen, schema: schema2, opts: { useDefaults } } = it;
+ if (useDefaults)
+ (0, defaults_1.assignDefaults)(it, group2.type);
+ gen.block(() => {
+ for (const rule of group2.rules) {
+ if ((0, applicability_1.shouldUseRule)(schema2, rule)) {
+ keywordCode(it, rule.keyword, rule.definition, group2.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, ts2) {
+ if (ts2.length > 1 && !(ts2.length === 2 && ts2.includes("null"))) {
+ strictTypesError(it, "use allowUnionTypes to allow union type keyword");
+ }
+ }
+ function checkKeywordTypes(it, ts2) {
+ 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: type2 } = rule.definition;
+ if (type2.length && !type2.some((t) => hasApplicableType(ts2, t))) {
+ strictTypesError(it, `missing type "${type2.join(",")}" for keyword "${keyword}"`);
+ }
+ }
+ }
+ }
+ function hasApplicableType(schTs, kwdT) {
+ return schTs.includes(kwdT) || kwdT === "number" && schTs.includes("integer");
+ }
+ function includesType(ts2, t) {
+ return ts2.includes(t) || t === "integer" && ts2.includes("number");
+ }
+ function narrowSchemaTypes(it, withTypes) {
+ const ts2 = [];
+ for (const t of it.dataTypes) {
+ if (includesType(withTypes, t))
+ ts2.push(t);
+ else if (withTypes.includes("integer") && t === "number")
+ ts2.push("integer");
+ }
+ it.dataTypes = ts2;
+ }
+ 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(append2, errorParams, errorPaths) {
+ if (errorParams) {
+ this.setParams(errorParams);
+ this._error(append2, errorPaths);
+ this.setParams({});
+ return;
+ }
+ this._error(append2, errorPaths);
+ }
+ _error(append2, errorPaths) {
+ ;
+ (append2 ? 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/runtime/validation_error.js
+var require_validation_error3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/ref_error.js
+var require_ref_error3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/ref_error.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var resolve_1 = require_resolve3();
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/index.js
+var require_compile3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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_codegen3();
+ var validation_error_1 = require_validation_error3();
+ var names_1 = require_names3();
+ var resolve_1 = require_resolve3();
+ var util_1 = require_util16();
+ var validate_1 = require_validate3();
+ var SchemaEnv = class {
+ constructor(env2) {
+ var _a2;
+ this.refs = {};
+ this.dynamicAnchors = {};
+ let schema2;
+ if (typeof env2.schema == "object")
+ schema2 = env2.schema;
+ this.schema = env2.schema;
+ this.schemaId = env2.schemaId;
+ this.root = env2.root || this;
+ this.baseId = (_a2 = env2.baseId) !== null && _a2 !== void 0 ? _a2 : (0, resolve_1.normalizeId)(schema2 === null || schema2 === void 0 ? void 0 : schema2[env2.schemaId || "$id"]);
+ this.schemaPath = env2.schemaPath;
+ this.localRefs = env2.localRefs;
+ this.meta = env2.meta;
+ this.$async = schema2 === null || schema2 === void 0 ? void 0 : schema2.$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 validate2 = makeValidate(this, this.scope.get());
+ this.scope.value(validateName, { ref: validate2 });
+ validate2.errors = null;
+ validate2.schema = sch.schema;
+ validate2.schemaEnv = sch;
+ if (sch.$async)
+ validate2.$async = true;
+ if (this.opts.code.source === true) {
+ validate2.source = { validateName, validateCode, scopeValues: gen._values };
+ }
+ if (this.opts.unevaluated) {
+ const { props, items } = schemaCxt;
+ validate2.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 (validate2.source)
+ validate2.source.evaluated = (0, codegen_1.stringify)(validate2.evaluated);
+ }
+ sch.validate = validate2;
+ 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 resolveRef2(root, baseId, ref) {
+ var _a2;
+ ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
+ const schOrFunc = root.refs[ref];
+ if (schOrFunc)
+ return schOrFunc;
+ let _sch = resolve3.call(this, root, ref);
+ if (_sch === void 0) {
+ const schema2 = (_a2 = root.localRefs) === null || _a2 === void 0 ? void 0 : _a2[ref];
+ const { schemaId } = this.opts;
+ if (schema2)
+ _sch = new SchemaEnv({ schema: schema2, schemaId, root, baseId });
+ }
+ if (_sch === void 0)
+ return;
+ return root.refs[ref] = inlineOrCompile.call(this, _sch);
+ }
+ exports.resolveRef = resolveRef2;
+ 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 resolve3(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: schema2 } = schOrRef;
+ const { schemaId } = this.opts;
+ const schId = schema2[schemaId];
+ if (schId)
+ baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
+ return new SchemaEnv({ schema: schema2, 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: schema2, root }) {
+ var _a2;
+ if (((_a2 = parsedRef.fragment) === null || _a2 === void 0 ? void 0 : _a2[0]) !== "/")
+ return;
+ for (const part of parsedRef.fragment.slice(1).split("/")) {
+ if (typeof schema2 === "boolean")
+ return;
+ const partSchema = schema2[(0, util_1.unescapeFragment)(part)];
+ if (partSchema === void 0)
+ return;
+ schema2 = partSchema;
+ const schId = typeof schema2 === "object" && schema2[this.opts.schemaId];
+ if (!PREVENT_SCOPE_CHANGE.has(part) && schId) {
+ baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
+ }
+ }
+ let env2;
+ if (typeof schema2 != "boolean" && schema2.$ref && !(0, util_1.schemaHasRulesButRef)(schema2, this.RULES)) {
+ const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema2.$ref);
+ env2 = resolveSchema.call(this, root, $ref);
+ }
+ const { schemaId } = this.opts;
+ env2 = env2 || new SchemaEnv({ schema: schema2, schemaId, root, baseId });
+ if (env2.schema !== env2.root.schema)
+ return env2;
+ return void 0;
+ }
+ }
+});
+
+// node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/refs/data.json
+var require_data3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/runtime/uri.js
+var require_uri3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/core.js
+var require_core5 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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_validate3();
+ Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
+ return validate_1.KeywordCxt;
+ } });
+ var codegen_1 = require_codegen3();
+ 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_error3();
+ var ref_error_1 = require_ref_error3();
+ var rules_1 = require_rules3();
+ var compile_1 = require_compile3();
+ var codegen_2 = require_codegen3();
+ var resolve_1 = require_resolve3();
+ var dataType_1 = require_dataType3();
+ var util_1 = require_util16();
+ var $dataRefSchema = require_data3();
+ var uri_1 = require_uri3();
+ 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 _a2, _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 = (_a2 = o.code) === null || _a2 === void 0 ? void 0 : _a2.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 Ajv3 = class {
+ constructor(opts = {}) {
+ this.schemas = {};
+ this.refs = {};
+ this.formats = {};
+ 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: meta3, schemaId } = this.opts;
+ let _dataRefSchema = $dataRefSchema;
+ if (schemaId === "id") {
+ _dataRefSchema = { ...$dataRefSchema };
+ _dataRefSchema.id = _dataRefSchema.$id;
+ delete _dataRefSchema.$id;
+ }
+ if (meta3 && $data)
+ this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false);
+ }
+ defaultMeta() {
+ const { meta: meta3, schemaId } = this.opts;
+ return this.opts.defaultMeta = typeof meta3 == "object" ? meta3[schemaId] || meta3 : 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(schema2, _meta) {
+ const sch = this._addSchema(schema2, _meta);
+ return sch.validate || this._compileSchemaEnv(sch);
+ }
+ compileAsync(schema2, meta3) {
+ if (typeof this.opts.loadSchema != "function") {
+ throw new Error("options.loadSchema should be a function");
+ }
+ const { loadSchema } = this.opts;
+ return runCompileAsync.call(this, schema2, meta3);
+ 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, meta3);
+ }
+ 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(schema2, key, _meta, _validateSchema = this.opts.validateSchema) {
+ if (Array.isArray(schema2)) {
+ for (const sch of schema2)
+ this.addSchema(sch, void 0, _meta, _validateSchema);
+ return this;
+ }
+ let id;
+ if (typeof schema2 === "object") {
+ const { schemaId } = this.opts;
+ id = schema2[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(schema2, _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(schema2, key, _validateSchema = this.opts.validateSchema) {
+ this.addSchema(schema2, key, true, _validateSchema);
+ return this;
+ }
+ // Validate schema against its meta-schema
+ validateSchema(schema2, throwOrLogError) {
+ if (typeof schema2 == "boolean")
+ return true;
+ let $schema;
+ $schema = schema2.$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, schema2);
+ 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 group2 of RULES.rules) {
+ const i = group2.rules.findIndex((rule) => rule.keyword === keyword);
+ if (i >= 0)
+ group2.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: separator2 = ", ", dataVar = "data" } = {}) {
+ if (!errors || errors.length === 0)
+ return "No errors";
+ return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text, msg) => text + separator2 + 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 keywords2 = metaSchema;
+ for (const seg of segments)
+ keywords2 = keywords2[seg];
+ for (const key in rules) {
+ const rule = rules[key];
+ if (typeof rule != "object")
+ continue;
+ const { $data } = rule.definition;
+ const schema2 = keywords2[key];
+ if ($data && schema2)
+ keywords2[key] = schemaOrData(schema2);
+ }
+ }
+ return metaSchema;
+ }
+ _removeAllSchemas(schemas, regex4) {
+ for (const keyRef in schemas) {
+ const sch = schemas[keyRef];
+ if (!regex4 || regex4.test(keyRef)) {
+ if (typeof sch == "string") {
+ delete schemas[keyRef];
+ } else if (sch && !sch.meta) {
+ this._cache.delete(sch.schema);
+ delete schemas[keyRef];
+ }
+ }
+ }
+ }
+ _addSchema(schema2, meta3, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
+ let id;
+ const { schemaId } = this.opts;
+ if (typeof schema2 == "object") {
+ id = schema2[schemaId];
+ } else {
+ if (this.opts.jtd)
+ throw new Error("schema must be object");
+ else if (typeof schema2 != "boolean")
+ throw new Error("schema must be object or boolean");
+ }
+ let sch = this._cache.get(schema2);
+ if (sch !== void 0)
+ return sch;
+ baseId = (0, resolve_1.normalizeId)(id || baseId);
+ const localRefs = resolve_1.getSchemaRefs.call(this, schema2, baseId);
+ sch = new compile_1.SchemaEnv({ schema: schema2, schemaId, meta: meta3, 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(schema2, 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;
+ }
+ }
+ };
+ Ajv3.ValidationError = validation_error_1.default;
+ Ajv3.MissingRefError = ref_error_1.default;
+ exports.default = Ajv3;
+ function checkOptions(checkOpts, options, msg, log2 = "error") {
+ for (const key in checkOpts) {
+ const opt = key;
+ if (opt in options)
+ this.logger[log2](`${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 _a2;
+ 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;
+ (_a2 = definition.implements) === null || _a2 === void 0 ? void 0 : _a2.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(schema2) {
+ return { anyOf: [schema2, $dataRef] };
+ }
+ }
+});
+
+// node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/core/id.js
+var require_id3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/core/ref.js
+var require_ref3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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_error3();
+ var code_1 = require_code5();
+ var codegen_1 = require_codegen3();
+ var names_1 = require_names3();
+ var compile_1 = require_compile3();
+ var util_1 = require_util16();
+ var def = {
+ keyword: "$ref",
+ schemaType: "string",
+ code(cxt) {
+ const { gen, schema: $ref, it } = cxt;
+ const { baseId, schemaEnv: env2, validateName, opts, self: self2 } = it;
+ const { root } = env2;
+ if (($ref === "#" || $ref === "#/") && baseId === root.baseId)
+ return callRootRef();
+ const schOrEnv = compile_1.resolveRef.call(self2, 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 (env2 === root)
+ return callRef(cxt, validateName, env2, env2.$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: env2, opts } = it;
+ const passCxt = opts.passContext ? names_1.default.this : codegen_1.nil;
+ if ($async)
+ callAsyncRef();
+ else
+ callSyncRef();
+ function callAsyncRef() {
+ if (!env2.$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 _a2;
+ if (!it.opts.unevaluated)
+ return;
+ const schEvaluated = (_a2 = sch === null || sch === void 0 ? void 0 : sch.validate) === null || _a2 === void 0 ? void 0 : _a2.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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/core/index.js
+var require_core6 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/core/index.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var id_1 = require_id3();
+ var ref_1 = require_ref3();
+ var core7 = [
+ "$schema",
+ "$id",
+ "$defs",
+ "$vocabulary",
+ { keyword: "$comment" },
+ "definitions",
+ id_1.default,
+ ref_1.default
+ ];
+ exports.default = core7;
+ }
+});
+
+// node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/limitNumber.js
+var require_limitNumber3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/limitNumber.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var codegen_1 = require_codegen3();
+ 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 error49 = {
+ 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: error49,
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/multipleOf.js
+var require_multipleOf3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/multipleOf.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var codegen_1 = require_codegen3();
+ var error49 = {
+ 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: error49,
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/runtime/ucs2length.js
+var require_ucs2length3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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 value2;
+ while (pos < len) {
+ length++;
+ value2 = str.charCodeAt(pos++);
+ if (value2 >= 55296 && value2 <= 56319 && pos < len) {
+ value2 = str.charCodeAt(pos);
+ if ((value2 & 64512) === 56320)
+ pos++;
+ }
+ }
+ return length;
+ }
+ exports.default = ucs2length;
+ ucs2length.code = 'require("ajv/dist/runtime/ucs2length").default';
+ }
+});
+
+// node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/limitLength.js
+var require_limitLength3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/limitLength.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var codegen_1 = require_codegen3();
+ var util_1 = require_util16();
+ var ucs2length_1 = require_ucs2length3();
+ var error49 = {
+ 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: error49,
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/pattern.js
+var require_pattern3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/pattern.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var code_1 = require_code5();
+ var util_1 = require_util16();
+ var codegen_1 = require_codegen3();
+ var error49 = {
+ 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: error49,
+ code(cxt) {
+ const { gen, data, $data, schema: schema2, 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, schema2);
+ cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
+ }
+ }
+ };
+ exports.default = def;
+ }
+});
+
+// node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/limitProperties.js
+var require_limitProperties3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/limitProperties.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var codegen_1 = require_codegen3();
+ var error49 = {
+ 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: error49,
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/required.js
+var require_required3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/required.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var code_1 = require_code5();
+ var codegen_1 = require_codegen3();
+ var util_1 = require_util16();
+ var error49 = {
+ 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: error49,
+ code(cxt) {
+ const { gen, schema: schema2, schemaCode, data, $data, it } = cxt;
+ const { opts } = it;
+ if (!$data && schema2.length === 0)
+ return;
+ const useLoop = schema2.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 schema2) {
+ 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 schema2) {
+ (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, schema2, 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/limitItems.js
+var require_limitItems3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/limitItems.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var codegen_1 = require_codegen3();
+ var error49 = {
+ 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: error49,
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/runtime/equal.js
+var require_equal3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/uniqueItems.js
+var require_uniqueItems3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/uniqueItems.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var dataType_1 = require_dataType3();
+ var codegen_1 = require_codegen3();
+ var util_1 = require_util16();
+ var equal_1 = require_equal3();
+ var error49 = {
+ 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: error49,
+ code(cxt) {
+ const { gen, data, $data, schema: schema2, parentSchema, schemaCode, it } = cxt;
+ if (!$data && !schema2)
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/const.js
+var require_const3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/const.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var codegen_1 = require_codegen3();
+ var util_1 = require_util16();
+ var equal_1 = require_equal3();
+ var error49 = {
+ message: "must be equal to constant",
+ params: ({ schemaCode }) => (0, codegen_1._)`{allowedValue: ${schemaCode}}`
+ };
+ var def = {
+ keyword: "const",
+ $data: true,
+ error: error49,
+ code(cxt) {
+ const { gen, data, $data, schemaCode, schema: schema2 } = cxt;
+ if ($data || schema2 && typeof schema2 == "object") {
+ cxt.fail$data((0, codegen_1._)`!${(0, util_1.useFunc)(gen, equal_1.default)}(${data}, ${schemaCode})`);
+ } else {
+ cxt.fail((0, codegen_1._)`${schema2} !== ${data}`);
+ }
+ }
+ };
+ exports.default = def;
+ }
+});
+
+// node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/enum.js
+var require_enum3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/enum.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var codegen_1 = require_codegen3();
+ var util_1 = require_util16();
+ var equal_1 = require_equal3();
+ var error49 = {
+ 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: error49,
+ code(cxt) {
+ const { gen, data, $data, schema: schema2, schemaCode, it } = cxt;
+ if (!$data && schema2.length === 0)
+ throw new Error("enum must have non-empty array");
+ const useLoop = schema2.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(schema2))
+ throw new Error("ajv implementation error");
+ const vSchema = gen.const("vSchema", schemaCode);
+ valid = (0, codegen_1.or)(...schema2.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 = schema2[i];
+ return typeof sch === "object" && sch !== null ? (0, codegen_1._)`${getEql()}(${data}, ${vSchema}[${i}])` : (0, codegen_1._)`${data} === ${sch}`;
+ }
+ }
+ };
+ exports.default = def;
+ }
+});
+
+// node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/index.js
+var require_validation3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/validation/index.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var limitNumber_1 = require_limitNumber3();
+ var multipleOf_1 = require_multipleOf3();
+ var limitLength_1 = require_limitLength3();
+ var pattern_1 = require_pattern3();
+ var limitProperties_1 = require_limitProperties3();
+ var required_1 = require_required3();
+ var limitItems_1 = require_limitItems3();
+ var uniqueItems_1 = require_uniqueItems3();
+ var const_1 = require_const3();
+ var enum_1 = require_enum3();
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/additionalItems.js
+var require_additionalItems3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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_codegen3();
+ var util_1 = require_util16();
+ var error49 = {
+ 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: error49,
+ 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: schema2, data, keyword, it } = cxt;
+ it.items = true;
+ const len = gen.const("len", (0, codegen_1._)`${data}.length`);
+ if (schema2 === false) {
+ cxt.setParams({ len: items.length });
+ cxt.pass((0, codegen_1._)`${len} <= ${items.length}`);
+ } else if (typeof schema2 == "object" && !(0, util_1.alwaysValidSchema)(it, schema2)) {
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/items.js
+var require_items3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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_codegen3();
+ var util_1 = require_util16();
+ var code_1 = require_code5();
+ var def = {
+ keyword: "items",
+ type: "array",
+ schemaType: ["object", "array", "boolean"],
+ before: "uniqueItems",
+ code(cxt) {
+ const { schema: schema2, it } = cxt;
+ if (Array.isArray(schema2))
+ return validateTuple(cxt, "additionalItems", schema2);
+ it.items = true;
+ if ((0, util_1.alwaysValidSchema)(it, schema2))
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/prefixItems.js
+var require_prefixItems3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/prefixItems.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var items_1 = require_items3();
+ var def = {
+ keyword: "prefixItems",
+ type: "array",
+ schemaType: ["array"],
+ before: "uniqueItems",
+ code: (cxt) => (0, items_1.validateTuple)(cxt, "items")
+ };
+ exports.default = def;
+ }
+});
+
+// node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/items2020.js
+var require_items20203 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/items2020.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var codegen_1 = require_codegen3();
+ var util_1 = require_util16();
+ var code_1 = require_code5();
+ var additionalItems_1 = require_additionalItems3();
+ var error49 = {
+ 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: error49,
+ code(cxt) {
+ const { schema: schema2, parentSchema, it } = cxt;
+ const { prefixItems } = parentSchema;
+ it.items = true;
+ if ((0, util_1.alwaysValidSchema)(it, schema2))
+ return;
+ if (prefixItems)
+ (0, additionalItems_1.validateAdditionalItems)(cxt, prefixItems);
+ else
+ cxt.ok((0, code_1.validateArray)(cxt));
+ }
+ };
+ exports.default = def;
+ }
+});
+
+// node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/contains.js
+var require_contains3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/contains.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var codegen_1 = require_codegen3();
+ var util_1 = require_util16();
+ var error49 = {
+ 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: error49,
+ code(cxt) {
+ const { gen, schema: schema2, 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, schema2)) {
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/dependencies.js
+var require_dependencies3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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_codegen3();
+ var util_1 = require_util16();
+ var code_1 = require_code5();
+ 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: schema2 }) {
+ const propertyDeps = {};
+ const schemaDeps = {};
+ for (const key in schema2) {
+ if (key === "__proto__")
+ continue;
+ const deps = Array.isArray(schema2[key]) ? propertyDeps : schemaDeps;
+ deps[key] = schema2[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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/propertyNames.js
+var require_propertyNames3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/propertyNames.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var codegen_1 = require_codegen3();
+ var util_1 = require_util16();
+ var error49 = {
+ message: "property name must be valid",
+ params: ({ params }) => (0, codegen_1._)`{propertyName: ${params.propertyName}}`
+ };
+ var def = {
+ keyword: "propertyNames",
+ type: "object",
+ schemaType: ["object", "boolean"],
+ error: error49,
+ code(cxt) {
+ const { gen, schema: schema2, data, it } = cxt;
+ if ((0, util_1.alwaysValidSchema)(it, schema2))
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js
+var require_additionalProperties3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var code_1 = require_code5();
+ var codegen_1 = require_codegen3();
+ var names_1 = require_names3();
+ var util_1 = require_util16();
+ var error49 = {
+ 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: error49,
+ code(cxt) {
+ const { gen, schema: schema2, 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, schema2))
+ 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 && schema2 === false) {
+ deleteAdditional(key);
+ return;
+ }
+ if (schema2 === false) {
+ cxt.setParams({ additionalProperty: key });
+ cxt.error();
+ if (!allErrors)
+ gen.break();
+ return;
+ }
+ if (typeof schema2 == "object" && !(0, util_1.alwaysValidSchema)(it, schema2)) {
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/properties.js
+var require_properties3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/properties.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var validate_1 = require_validate3();
+ var code_1 = require_code5();
+ var util_1 = require_util16();
+ var additionalProperties_1 = require_additionalProperties3();
+ var def = {
+ keyword: "properties",
+ type: "object",
+ schemaType: "object",
+ code(cxt) {
+ const { gen, schema: schema2, 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)(schema2);
+ 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, schema2[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 && schema2[prop].default !== void 0;
+ }
+ function applyPropertySchema(prop) {
+ cxt.subschema({
+ keyword: "properties",
+ schemaProp: prop,
+ dataProp: prop
+ }, valid);
+ }
+ }
+ };
+ exports.default = def;
+ }
+});
+
+// node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/patternProperties.js
+var require_patternProperties3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/patternProperties.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var code_1 = require_code5();
+ var codegen_1 = require_codegen3();
+ var util_1 = require_util16();
+ var util_2 = require_util16();
+ var def = {
+ keyword: "patternProperties",
+ type: "object",
+ schemaType: "object",
+ code(cxt) {
+ const { gen, schema: schema2, data, parentSchema, it } = cxt;
+ const { opts } = it;
+ const patterns = (0, code_1.allSchemaProperties)(schema2);
+ const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema2[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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/not.js
+var require_not3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/not.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var util_1 = require_util16();
+ var def = {
+ keyword: "not",
+ schemaType: ["object", "boolean"],
+ trackErrors: true,
+ code(cxt) {
+ const { gen, schema: schema2, it } = cxt;
+ if ((0, util_1.alwaysValidSchema)(it, schema2)) {
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/anyOf.js
+var require_anyOf3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/anyOf.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var code_1 = require_code5();
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/oneOf.js
+var require_oneOf3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/oneOf.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var codegen_1 = require_codegen3();
+ var util_1 = require_util16();
+ var error49 = {
+ 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: error49,
+ code(cxt) {
+ const { gen, schema: schema2, parentSchema, it } = cxt;
+ if (!Array.isArray(schema2))
+ throw new Error("ajv implementation error");
+ if (it.opts.discriminator && parentSchema.discriminator)
+ return;
+ const schArr = schema2;
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/allOf.js
+var require_allOf3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/allOf.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var util_1 = require_util16();
+ var def = {
+ keyword: "allOf",
+ schemaType: "array",
+ code(cxt) {
+ const { gen, schema: schema2, it } = cxt;
+ if (!Array.isArray(schema2))
+ throw new Error("ajv implementation error");
+ const valid = gen.name("valid");
+ schema2.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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/if.js
+var require_if3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/if.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var codegen_1 = require_codegen3();
+ var util_1 = require_util16();
+ var error49 = {
+ 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: error49,
+ 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 schema2 = it.schema[keyword];
+ return schema2 !== void 0 && !(0, util_1.alwaysValidSchema)(it, schema2);
+ }
+ exports.default = def;
+ }
+});
+
+// node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/thenElse.js
+var require_thenElse3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/thenElse.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var util_1 = require_util16();
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/index.js
+var require_applicator3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/applicator/index.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var additionalItems_1 = require_additionalItems3();
+ var prefixItems_1 = require_prefixItems3();
+ var items_1 = require_items3();
+ var items2020_1 = require_items20203();
+ var contains_1 = require_contains3();
+ var dependencies_1 = require_dependencies3();
+ var propertyNames_1 = require_propertyNames3();
+ var additionalProperties_1 = require_additionalProperties3();
+ var properties_1 = require_properties3();
+ var patternProperties_1 = require_patternProperties3();
+ var not_1 = require_not3();
+ var anyOf_1 = require_anyOf3();
+ var oneOf_1 = require_oneOf3();
+ var allOf_1 = require_allOf3();
+ var if_1 = require_if3();
+ var thenElse_1 = require_thenElse3();
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/format/format.js
+var require_format4 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/format/format.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var codegen_1 = require_codegen3();
+ var error49 = {
+ 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: error49,
+ code(cxt, ruleType) {
+ const { gen, data, $data, schema: schema2, schemaCode, it } = cxt;
+ const { opts, errSchemaPath, schemaEnv, self: self2 } = it;
+ if (!opts.validateFormats)
+ return;
+ if ($data)
+ validate$DataFormat();
+ else
+ validateFormat();
+ function validate$DataFormat() {
+ const fmts = gen.scopeValue("formats", {
+ ref: self2.formats,
+ code: opts.code.formats
+ });
+ const fDef = gen.const("fDef", (0, codegen_1._)`${fmts}[${schemaCode}]`);
+ const fType = gen.let("fType");
+ const 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 = self2.formats[schema2];
+ 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) {
+ self2.logger.warn(unknownMsg());
+ return;
+ }
+ throw new Error(unknownMsg());
+ function unknownMsg() {
+ return `unknown format "${schema2}" 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)(schema2)}` : void 0;
+ const fmt = gen.scopeValue("formats", { key: schema2, 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/format/index.js
+var require_format5 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/format/index.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var format_1 = require_format4();
+ var format2 = [format_1.default];
+ exports.default = format2;
+ }
+});
+
+// node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/metadata.js
+var require_metadata3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/draft7.js
+var require_draft73 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/draft7.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var core_1 = require_core6();
+ var validation_1 = require_validation3();
+ var applicator_1 = require_applicator3();
+ var format_1 = require_format5();
+ var metadata_1 = require_metadata3();
+ 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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/discriminator/types.js
+var require_types3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/discriminator/index.js
+var require_discriminator3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/vocabularies/discriminator/index.js"(exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var codegen_1 = require_codegen3();
+ var types_1 = require_types3();
+ var compile_1 = require_compile3();
+ var ref_error_1 = require_ref_error3();
+ var util_1 = require_util16();
+ var error49 = {
+ 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: error49,
+ code(cxt) {
+ const { gen, data, schema: schema2, parentSchema, it } = cxt;
+ const { oneOf } = parentSchema;
+ if (!it.opts.discriminator) {
+ throw new Error("discriminator: requires discriminator option");
+ }
+ const tagName = schema2.propertyName;
+ if (typeof tagName != "string")
+ throw new Error("discriminator: requires propertyName");
+ if (schema2.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 _a2;
+ 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 = (_a2 = sch === null || sch === void 0 ? void 0 : sch.properties) === null || _a2 === void 0 ? void 0 : _a2[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: required3 }) {
+ return Array.isArray(required3) && required3.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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/refs/json-schema-draft-07.json
+var require_json_schema_draft_073 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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/.pnpm/ajv@8.18.0/node_modules/ajv/dist/ajv.js
+var require_ajv3 = __commonJS({
+ "node_modules/.pnpm/ajv@8.18.0/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_core5();
+ var draft7_1 = require_draft73();
+ var discriminator_1 = require_discriminator3();
+ var draft7MetaSchema = require_json_schema_draft_073();
+ var META_SUPPORT_DATA = ["/properties"];
+ var META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
+ var Ajv3 = 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 = Ajv3;
+ module.exports = exports = Ajv3;
+ module.exports.Ajv = Ajv3;
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.default = Ajv3;
+ var validate_1 = require_validate3();
+ Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
+ return validate_1.KeywordCxt;
+ } });
+ var codegen_1 = require_codegen3();
+ 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_error3();
+ Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function() {
+ return validation_error_1.default;
+ } });
+ var ref_error_1 = require_ref_error3();
+ Object.defineProperty(exports, "MissingRefError", { enumerable: true, get: function() {
+ return ref_error_1.default;
+ } });
+ }
+});
+
// node_modules/.pnpm/strtok3@10.3.4/node_modules/strtok3/lib/stream/Errors.js
var defaultMessages, EndOfStreamError, AbortError;
var init_Errors = __esm({
@@ -97611,9 +103218,12 @@ var require_semver2 = __commonJS({
});
// entry.ts
-var core5 = __toESM(require_core(), 1);
+var core6 = __toESM(require_core(), 1);
import { dirname as dirname3 } from "node:path";
+// main.ts
+var core5 = __toESM(require_core(), 1);
+
// node_modules/.pnpm/@ark+util@0.56.0/node_modules/@ark/util/out/arrays.js
var liftArray = (data) => Array.isArray(data) ? data : [data];
var spliterate = (arr, predicate) => {
@@ -123969,7 +129579,7 @@ var require_core4 = /* @__PURE__ */ __commonJSMin(((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const id_1 = require_id2();
const ref_1 = require_ref2();
- const core6 = [
+ const core7 = [
"$schema",
"$id",
"$defs",
@@ -123979,7 +129589,7 @@ var require_core4 = /* @__PURE__ */ __commonJSMin(((exports) => {
id_1.default,
ref_1.default
];
- exports.default = core6;
+ exports.default = core7;
}));
var require_limitNumber2 = /* @__PURE__ */ __commonJSMin(((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
@@ -143143,31 +148753,72 @@ function AddLabelsTool(ctx) {
}
// mcp/output.ts
+var import_ajv3 = __toESM(require_ajv3(), 1);
var SetOutputParams = type({
value: type.string.describe("the output value to expose as a GitHub Action output")
});
-function SetOutputTool(ctx) {
+function jsonSchemaToStandardSchema({
+ $schema: _,
+ ...jsonSchema2
+}) {
+ const ajv = new import_ajv3.Ajv();
+ const validate2 = ajv.compile(jsonSchema2);
+ return {
+ "~standard": {
+ version: 1,
+ // xsschema (used by fastmcp) hardcodes supported vendors instead of duck-typing toJsonSchema().
+ // "arktype" works because its converter is just `(schema) => schema.toJsonSchema()`.
+ vendor: "arktype",
+ validate(input) {
+ if (validate2(input)) {
+ return { value: input };
+ }
+ return {
+ issues: (validate2.errors ?? []).map((err) => ({
+ message: `${err.instancePath || "/"}: ${err.message ?? "validation error"}`,
+ path: err.instancePath ? err.instancePath.split("/").filter(Boolean) : []
+ }))
+ };
+ }
+ },
+ toJsonSchema() {
+ return jsonSchema2;
+ }
+ };
+}
+function storeOutput(ctx, value2) {
+ const selfId = ctx.toolState.selfSubagentId;
+ if (selfId) {
+ const subagent = ctx.toolState.subagents.get(selfId);
+ if (subagent) {
+ subagent.output = value2;
+ log.debug(`set_output: routed to subagent ${selfId} (value=${value2.slice(0, 80)})`);
+ return { success: true, routed: "subagent" };
+ }
+ log.warning(
+ `set_output: selfSubagentId=${selfId} but subagent not found in map \u2014 routing to action output`
+ );
+ }
+ ctx.toolState.output = value2;
+ return { success: true, routed: "action_output" };
+}
+function SetOutputTool(ctx, outputSchema) {
+ if (outputSchema) {
+ return tool({
+ name: "set_output",
+ description: "Set the structured action output. You MUST call this tool before finishing \u2014 the output is required. Pass the output object directly as the tool arguments (no wrapping needed).",
+ parameters: jsonSchemaToStandardSchema(outputSchema),
+ execute: execute(async (params) => {
+ return storeOutput(ctx, JSON.stringify(params));
+ })
+ });
+ }
return tool({
name: "set_output",
description: "Set the action output. When called by a subagent, returns a summary result to the orchestrator \u2014 this is the ONLY way to pass results back. When called by the orchestrator in standalone mode (trigger: unknown), exposes the value as the 'result' GitHub Action output for downstream workflow steps. Do NOT use this for progress reporting \u2014 use report_progress instead.",
parameters: SetOutputParams,
execute: execute(async (params) => {
- const selfId = ctx.toolState.selfSubagentId;
- if (selfId) {
- const subagent = ctx.toolState.subagents.get(selfId);
- if (subagent) {
- subagent.output = params.value;
- log.debug(
- `set_output: routed to subagent ${selfId} (value=${params.value.slice(0, 80)})`
- );
- return { success: true, routed: "subagent" };
- }
- log.warning(
- `set_output: selfSubagentId=${selfId} but subagent not found in map \u2014 routing to action output`
- );
- }
- ctx.toolState.output = params.value;
- return { success: true, routed: "action_output" };
+ return storeOutput(ctx, params.value);
})
});
}
@@ -144487,7 +150138,7 @@ function isAddressInUse(error49) {
const message = getErrorMessage(error49).toLowerCase();
return message.includes("eaddrinuse") || message.includes("address already in use");
}
-function buildCommonTools(ctx) {
+function buildCommonTools(ctx, outputSchema) {
const tools = [
StartDependencyInstallationTool(ctx),
AwaitDependencyInstallationTool(ctx),
@@ -144510,7 +150161,7 @@ function buildCommonTools(ctx) {
GitTool(ctx),
GitFetchTool(ctx),
UploadFileTool(ctx),
- SetOutputTool(ctx),
+ SetOutputTool(ctx, outputSchema),
FileReadTool(ctx),
FileWriteTool(ctx),
FileEditTool(ctx),
@@ -144523,9 +150174,9 @@ function buildCommonTools(ctx) {
}
return tools;
}
-function buildOrchestratorTools(ctx) {
+function buildOrchestratorTools(ctx, outputSchema) {
return [
- ...buildCommonTools(ctx),
+ ...buildCommonTools(ctx, outputSchema),
ReportProgressTool(ctx),
SelectModeTool(ctx),
DelegateTool(ctx),
@@ -144617,8 +150268,8 @@ async function killBackgroundProcesses(toolState) {
}
backgroundProcesses.clear();
}
-async function startMcpHttpServer(ctx) {
- const tools = buildOrchestratorTools(ctx);
+async function startMcpHttpServer(ctx, options) {
+ const tools = buildOrchestratorTools(ctx, options?.outputSchema);
const startResult = await selectMcpPort(ctx, tools);
return {
url: startResult.url,
@@ -144946,6 +150597,7 @@ var package_default = {
"@opencode-ai/sdk": "^1.0.143",
"@standard-schema/spec": "1.0.0",
"@toon-format/toon": "^1.0.0",
+ ajv: "^8.18.0",
arkregex: "0.0.5",
arktype: "2.1.29",
dotenv: "^17.2.3",
@@ -147168,13 +152820,14 @@ Use the \`${ghPullfrogMcpName}\` MCP file tools for all file operations. Do NOT
All file tools enforce repository-scoped access and prevent modifications to .git/.`;
}
-function getStandaloneModeInstructions(trigger) {
+function getStandaloneModeInstructions(trigger, outputSchema) {
if (trigger !== "unknown") {
return "";
}
+ const outputRequirement = outputSchema ? `**REQUIRED structured output:** You MUST call \`${ghPullfrogMcpName}/set_output\` before finishing. The tool expects a structured object matching a JSON Schema \u2014 inspect its parameter schema to see the exact shape. Omitting this call or providing non-conforming output will fail the action.` : `When you complete your task, call \`${ghPullfrogMcpName}/set_output\` with the main result of your work (generated content, summary of changes, analysis results, etc.). This makes it available as a GitHub Action output named \`result\` for subsequent workflow steps to consume. When in doubt, prefer calling \`set_output\`\u2014unused outputs are harmless, but missing outputs may break downstream steps.`;
return `### Standalone mode
-You are running as a step in a user-defined CI workflow. When you complete your task, call \`${ghPullfrogMcpName}/set_output\` with the main result of your work (generated content, summary of changes, analysis results, etc.). This makes it available as a GitHub Action output named \`result\` for subsequent workflow steps to consume.`;
+You are running as a step in a user-defined CI workflow. ${outputRequirement}`;
}
function buildSystemPrompt(ctx) {
return `***********************************************
@@ -147232,7 +152885,7 @@ ${getShellInstructions(ctx.shell)}
${getFileInstructions()}
-${getStandaloneModeInstructions(ctx.trigger)}
+${getStandaloneModeInstructions(ctx.trigger, ctx.outputSchema)}
## Workflow
@@ -147388,7 +153041,8 @@ If the task clearly requires no work, skip delegation. Call \`${ghPullfrogMcpNam
shell: ctx.payload.shell,
trigger: ctx.payload.event.trigger,
priorityOrder: orchestratorPriorityOrder,
- taskSection: orchestratorTaskSection
+ taskSection: orchestratorTaskSection,
+ outputSchema: ctx.outputSchema
});
const contextSections = buildContextSections({
payload: ctx.payload,
@@ -147512,7 +153166,8 @@ var Inputs = type({
"search?": ToolPermissionInput.or("undefined"),
"push?": PushPermissionInput.or("undefined"),
"shell?": ShellPermissionInput.or("undefined"),
- "cwd?": type.string.or("undefined")
+ "cwd?": type.string.or("undefined"),
+ "output_schema?": type.string.or("undefined")
});
function isAgentName(value2) {
return typeof value2 === "string" && AgentName(value2) instanceof type.errors === false;
@@ -147826,6 +153481,21 @@ async function resolveRun(params) {
}
// main.ts
+function resolveOutputSchema() {
+ const raw = core5.getInput("output_schema");
+ if (!raw) return void 0;
+ let parsed2;
+ try {
+ parsed2 = JSON.parse(raw);
+ } catch {
+ throw new Error(`invalid output_schema: not valid JSON`);
+ }
+ if (!parsed2 || typeof parsed2 !== "object" || Array.isArray(parsed2)) {
+ throw new Error(`invalid output_schema: must be a JSON object`);
+ }
+ log.info("\xBB structured output schema provided \u2014 output will be required");
+ return parsed2;
+}
async function writeJobSummary(toolState) {
const usageSummary = formatUsageSummary(toolState.usageEntries);
const summaryParts = [toolState.lastProgressBody, usageSummary].filter(Boolean);
@@ -147905,6 +153575,7 @@ async function main() {
});
timer.checkpoint("lifecycleHooks::setup");
const modes2 = [...computeModes(), ...runContext.repoSettings.modes];
+ const outputSchema = resolveOutputSchema();
const toolContext = {
repo: runContext.repo,
payload,
@@ -147922,14 +153593,15 @@ async function main() {
mcpServerUrl: "",
tmpdir: tmpdir3
};
- const mcpHttpServer = __using(_stack, await startMcpHttpServer(toolContext), true);
+ const mcpHttpServer = __using(_stack, await startMcpHttpServer(toolContext, { outputSchema }), true);
toolContext.mcpServerUrl = mcpHttpServer.url;
log.info(`\xBB MCP server started at ${mcpHttpServer.url}`);
timer.checkpoint("mcpServer");
const instructions = resolveInstructions({
payload,
repo: runContext.repo,
- modes: modes2
+ modes: modes2,
+ outputSchema
});
const logParts = [
instructions.eventInstructions ? `EVENT-LEVEL INSTRUCTIONS:
@@ -147980,6 +153652,11 @@ ${instructions.user}` : null,
if (result.usage) {
toolState.usageEntries.push(result.usage);
}
+ if (outputSchema && !toolState.output) {
+ throw new Error(
+ "output_schema was provided but agent did not call set_output \u2014 structured output is required"
+ );
+ }
await writeJobSummary(toolState);
if (toolState.output) {
log.info(`::pullfrog-output::${Buffer.from(toolState.output).toString("base64")}`);
@@ -148038,11 +153715,11 @@ async function run() {
throw new Error(result.error || "Agent execution failed");
}
if (result.result) {
- core5.setOutput("result", result.result);
+ core6.setOutput("result", result.result);
}
} catch (error49) {
const errorMessage = error49 instanceof Error ? error49.message : "Unknown error occurred";
- core5.setFailed(`Action failed: ${errorMessage}`);
+ core6.setFailed(`Action failed: ${errorMessage}`);
}
}
await run();
diff --git a/main.ts b/main.ts
index 1d45a0e..d19144b 100644
--- a/main.ts
+++ b/main.ts
@@ -1,4 +1,5 @@
// changes to tool permissions should be reflected in wiki/granular-tools.md
+import * as core from "@actions/core";
import { initToolState, startMcpHttpServer, type ToolState } from "./mcp/server.ts";
import { computeModes } from "./modes.ts";
import {
@@ -37,6 +38,23 @@ export interface MainResult {
result?: string | undefined;
}
+function resolveOutputSchema(): Record | undefined {
+ const raw = core.getInput("output_schema");
+ if (!raw) return undefined;
+
+ let parsed: unknown;
+ try {
+ parsed = JSON.parse(raw);
+ } catch {
+ throw new Error(`invalid output_schema: not valid JSON`);
+ }
+ if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+ throw new Error(`invalid output_schema: must be a JSON object`);
+ }
+ log.info("» structured output schema provided — output will be required");
+ return parsed as Record;
+}
+
async function writeJobSummary(toolState: ToolState): Promise {
const usageSummary = formatUsageSummary(toolState.usageEntries);
const summaryParts = [toolState.lastProgressBody, usageSummary].filter(Boolean);
@@ -151,6 +169,8 @@ export async function main(): Promise {
const modes = [...computeModes(), ...runContext.repoSettings.modes];
+ const outputSchema = resolveOutputSchema();
+
// mcpServerUrl and tmpdir are set after server starts — delegate tool reads them at call time
const toolContext = {
repo: runContext.repo,
@@ -169,7 +189,7 @@ export async function main(): Promise {
mcpServerUrl: "",
tmpdir,
};
- await using mcpHttpServer = await startMcpHttpServer(toolContext);
+ await using mcpHttpServer = await startMcpHttpServer(toolContext, { outputSchema });
toolContext.mcpServerUrl = mcpHttpServer.url;
log.info(`» MCP server started at ${mcpHttpServer.url}`);
timer.checkpoint("mcpServer");
@@ -178,6 +198,7 @@ export async function main(): Promise {
payload,
repo: runContext.repo,
modes,
+ outputSchema,
});
// log instructions as soon as they are fully resolved
const logParts = [
@@ -236,6 +257,13 @@ export async function main(): Promise {
toolState.usageEntries.push(result.usage);
}
+ // validate this before writing job summary to avoid masking the error
+ if (outputSchema && !toolState.output) {
+ throw new Error(
+ "output_schema was provided but agent did not call set_output — structured output is required"
+ );
+ }
+
await writeJobSummary(toolState);
// emit structured output marker for test validation
diff --git a/mcp/output.ts b/mcp/output.ts
index 8a3704a..5629538 100644
--- a/mcp/output.ts
+++ b/mcp/output.ts
@@ -1,3 +1,5 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import { Ajv } from "ajv";
import { type } from "arktype";
import { log } from "../utils/cli.ts";
import type { ToolContext } from "./server.ts";
@@ -7,29 +9,76 @@ export const SetOutputParams = type({
value: type.string.describe("the output value to expose as a GitHub Action output"),
});
-export function SetOutputTool(ctx: ToolContext) {
+type JsonSchema = Record;
+
+function jsonSchemaToStandardSchema({
+ $schema: _,
+ ...jsonSchema
+}: JsonSchema): StandardSchemaV1 & { toJsonSchema(): JsonSchema } {
+ const ajv = new Ajv();
+ const validate = ajv.compile(jsonSchema);
+
+ return {
+ "~standard": {
+ version: 1,
+ // xsschema (used by fastmcp) hardcodes supported vendors instead of duck-typing toJsonSchema().
+ // "arktype" works because its converter is just `(schema) => schema.toJsonSchema()`.
+ vendor: "arktype",
+ validate(input: unknown) {
+ if (validate(input)) {
+ return { value: input };
+ }
+ return {
+ issues: (validate.errors ?? []).map((err) => ({
+ message: `${err.instancePath || "/"}: ${err.message ?? "validation error"}`,
+ path: err.instancePath ? err.instancePath.split("/").filter(Boolean) : [],
+ })),
+ };
+ },
+ },
+ toJsonSchema() {
+ return jsonSchema;
+ },
+ };
+}
+
+function storeOutput(ctx: ToolContext, value: string) {
+ const selfId = ctx.toolState.selfSubagentId;
+ if (selfId) {
+ const subagent = ctx.toolState.subagents.get(selfId);
+ if (subagent) {
+ subagent.output = value;
+ log.debug(`set_output: routed to subagent ${selfId} (value=${value.slice(0, 80)})`);
+ return { success: true, routed: "subagent" as const };
+ }
+ log.warning(
+ `set_output: selfSubagentId=${selfId} but subagent not found in map — routing to action output`
+ );
+ }
+ ctx.toolState.output = value;
+ return { success: true, routed: "action_output" as const };
+}
+
+export function SetOutputTool(ctx: ToolContext, outputSchema?: JsonSchema) {
+ if (outputSchema) {
+ return tool({
+ name: "set_output",
+ description:
+ "Set the structured action output. You MUST call this tool before finishing — the output is required. Pass the output object directly as the tool arguments (no wrapping needed).",
+ parameters: jsonSchemaToStandardSchema(outputSchema),
+ execute: execute(async (params) => {
+ return storeOutput(ctx, JSON.stringify(params));
+ }),
+ });
+ }
+
return tool({
name: "set_output",
description:
"Set the action output. When called by a subagent, returns a summary result to the orchestrator — this is the ONLY way to pass results back. When called by the orchestrator in standalone mode (trigger: unknown), exposes the value as the 'result' GitHub Action output for downstream workflow steps. Do NOT use this for progress reporting — use report_progress instead.",
parameters: SetOutputParams,
execute: execute(async (params) => {
- const selfId = ctx.toolState.selfSubagentId;
- if (selfId) {
- const subagent = ctx.toolState.subagents.get(selfId);
- if (subagent) {
- subagent.output = params.value;
- log.debug(
- `set_output: routed to subagent ${selfId} (value=${params.value.slice(0, 80)})`
- );
- return { success: true, routed: "subagent" };
- }
- log.warning(
- `set_output: selfSubagentId=${selfId} but subagent not found in map — routing to action output`
- );
- }
- ctx.toolState.output = params.value;
- return { success: true, routed: "action_output" };
+ return storeOutput(ctx, params.value);
}),
});
}
diff --git a/mcp/server.ts b/mcp/server.ts
index f5cda13..cf66ad9 100644
--- a/mcp/server.ts
+++ b/mcp/server.ts
@@ -189,8 +189,10 @@ function isAddressInUse(error: unknown): boolean {
return message.includes("eaddrinuse") || message.includes("address already in use");
}
+type JsonSchema = Record;
+
// tools shared by both orchestrator and subagent servers
-function buildCommonTools(ctx: ToolContext): Tool[] {
+function buildCommonTools(ctx: ToolContext, outputSchema?: JsonSchema): Tool[] {
const tools: Tool[] = [
StartDependencyInstallationTool(ctx),
AwaitDependencyInstallationTool(ctx),
@@ -213,7 +215,7 @@ function buildCommonTools(ctx: ToolContext): Tool[] {
GitTool(ctx),
GitFetchTool(ctx),
UploadFileTool(ctx),
- SetOutputTool(ctx),
+ SetOutputTool(ctx, outputSchema),
FileReadTool(ctx),
FileWriteTool(ctx),
FileEditTool(ctx),
@@ -234,9 +236,9 @@ function buildCommonTools(ctx: ToolContext): Tool[] {
}
// orchestrator gets common tools + delegation + remote-mutating tools
-function buildOrchestratorTools(ctx: ToolContext): Tool[] {
+function buildOrchestratorTools(ctx: ToolContext, outputSchema?: JsonSchema): Tool[] {
return [
- ...buildCommonTools(ctx),
+ ...buildCommonTools(ctx, outputSchema),
ReportProgressTool(ctx),
SelectModeTool(ctx),
DelegateTool(ctx),
@@ -353,13 +355,18 @@ async function killBackgroundProcesses(toolState: ToolState): Promise {
backgroundProcesses.clear();
}
+type McpHttpServerOptions = {
+ outputSchema?: JsonSchema | undefined;
+};
+
/**
* Start the orchestrator MCP HTTP server (has all tools including push/PR/delegation).
*/
export async function startMcpHttpServer(
- ctx: ToolContext
+ ctx: ToolContext,
+ options?: McpHttpServerOptions
): Promise<{ url: string; [Symbol.asyncDispose]: () => Promise }> {
- const tools = buildOrchestratorTools(ctx);
+ const tools = buildOrchestratorTools(ctx, options?.outputSchema);
const startResult = await selectMcpPort(ctx, tools);
return {
diff --git a/package.json b/package.json
index b0b788b..6cdc27c 100644
--- a/package.json
+++ b/package.json
@@ -36,6 +36,7 @@
"@opencode-ai/sdk": "^1.0.143",
"@standard-schema/spec": "1.0.0",
"@toon-format/toon": "^1.0.0",
+ "ajv": "^8.18.0",
"arkregex": "0.0.5",
"arktype": "2.1.29",
"dotenv": "^17.2.3",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b4ac9fe..f27c9ef 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -43,6 +43,9 @@ importers:
'@toon-format/toon':
specifier: ^1.0.0
version: 1.4.0
+ ajv:
+ specifier: ^8.18.0
+ version: 8.18.0
arkregex:
specifier: 0.0.5
version: 0.0.5
@@ -868,6 +871,9 @@ packages:
ajv@8.17.1:
resolution: {integrity: sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==}
+ ajv@8.18.0:
+ resolution: {integrity: sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==}
+
ansi-regex@5.0.1:
resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
engines: {node: '>=8'}
@@ -2280,6 +2286,13 @@ snapshots:
json-schema-traverse: 1.0.0
require-from-string: 2.0.2
+ ajv@8.18.0:
+ dependencies:
+ fast-deep-equal: 3.1.3
+ fast-uri: 3.1.0
+ json-schema-traverse: 1.0.0
+ require-from-string: 2.0.2
+
ansi-regex@5.0.1: {}
ansi-regex@6.2.2: {}
diff --git a/post b/post
index 9949bcf..b211796 100755
--- a/post
+++ b/post
@@ -41348,6 +41348,7 @@ var package_default = {
"@opencode-ai/sdk": "^1.0.143",
"@standard-schema/spec": "1.0.0",
"@toon-format/toon": "^1.0.0",
+ ajv: "^8.18.0",
arkregex: "0.0.5",
arktype: "2.1.29",
dotenv: "^17.2.3",
@@ -41445,7 +41446,8 @@ var Inputs = type({
"search?": ToolPermissionInput.or("undefined"),
"push?": PushPermissionInput.or("undefined"),
"shell?": ShellPermissionInput.or("undefined"),
- "cwd?": type.string.or("undefined")
+ "cwd?": type.string.or("undefined"),
+ "output_schema?": type.string.or("undefined")
});
function resolvePromptInput() {
const prompt = core3.getInput("prompt", { required: true });
diff --git a/utils/instructions.ts b/utils/instructions.ts
index f7bc99c..dfeaa16 100644
--- a/utils/instructions.ts
+++ b/utils/instructions.ts
@@ -10,6 +10,7 @@ interface InstructionsContext {
payload: ResolvedPayload;
repo: RunContextData["repo"];
modes: Mode[];
+ outputSchema?: Record | undefined;
}
function buildRuntimeContext(ctx: InstructionsContext): string {
@@ -118,13 +119,21 @@ Use the \`${ghPullfrogMcpName}\` MCP file tools for all file operations. Do NOT
All file tools enforce repository-scoped access and prevent modifications to .git/.`;
}
-function getStandaloneModeInstructions(trigger: string): string {
+function getStandaloneModeInstructions(
+ trigger: string,
+ outputSchema?: Record | undefined
+): string {
if (trigger !== "unknown") {
return "";
}
+
+ const outputRequirement = outputSchema
+ ? `**REQUIRED structured output:** You MUST call \`${ghPullfrogMcpName}/set_output\` before finishing. The tool expects a structured object matching a JSON Schema — inspect its parameter schema to see the exact shape. Omitting this call or providing non-conforming output will fail the action.`
+ : `When you complete your task, call \`${ghPullfrogMcpName}/set_output\` with the main result of your work (generated content, summary of changes, analysis results, etc.). This makes it available as a GitHub Action output named \`result\` for subsequent workflow steps to consume. When in doubt, prefer calling \`set_output\`—unused outputs are harmless, but missing outputs may break downstream steps.`;
+
return `### Standalone mode
-You are running as a step in a user-defined CI workflow. When you complete your task, call \`${ghPullfrogMcpName}/set_output\` with the main result of your work (generated content, summary of changes, analysis results, etc.). This makes it available as a GitHub Action output named \`result\` for subsequent workflow steps to consume.`;
+You are running as a step in a user-defined CI workflow. ${outputRequirement}`;
}
// shared system prompt body used by both orchestrator and subagent instructions.
@@ -134,6 +143,7 @@ interface SystemPromptContext {
trigger: string;
priorityOrder: string;
taskSection: string;
+ outputSchema?: Record | undefined;
}
function buildSystemPrompt(ctx: SystemPromptContext): string {
@@ -192,7 +202,7 @@ ${getShellInstructions(ctx.shell)}
${getFileInstructions()}
-${getStandaloneModeInstructions(ctx.trigger)}
+${getStandaloneModeInstructions(ctx.trigger, ctx.outputSchema)}
## Workflow
@@ -406,6 +416,7 @@ If the task clearly requires no work, skip delegation. Call \`${ghPullfrogMcpNam
trigger: ctx.payload.event.trigger,
priorityOrder: orchestratorPriorityOrder,
taskSection: orchestratorTaskSection,
+ outputSchema: ctx.outputSchema,
});
const contextSections = buildContextSections({
diff --git a/utils/payload.ts b/utils/payload.ts
index e9a6511..9a548d9 100644
--- a/utils/payload.ts
+++ b/utils/payload.ts
@@ -54,6 +54,7 @@ export const Inputs = type({
"push?": PushPermissionInput.or("undefined"),
"shell?": ShellPermissionInput.or("undefined"),
"cwd?": type.string.or("undefined"),
+ "output_schema?": type.string.or("undefined"),
});
export type Inputs = typeof Inputs.infer;