Compiled (unminified) | ajv | Schema Benchmarks

schemas/libraries/ajv/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/ajv/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/ajv/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/ajv/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/ajv/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/ajv/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/ajv/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/ajv/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/ajv/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/ajv/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/ajv/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/ajv/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

//#region \0rolldown/runtime.js
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc =
  Object.getOwnPropertyDescriptor;
var __getOwnPropNames =
  Object.getOwnPropertyNames;
var __getProtoOf =
  Object.getPrototypeOf;
var __hasOwnProp =
  Object.prototype.hasOwnProperty;
var __commonJSMin = (cb, mod) => () => (
  mod ||
    (cb(
      (mod = { exports: {} }).exports,
      mod,
      mod.exports,
    ),
    (cb = null)),
  mod.exports
);
var __copyProps = (
  to,
  from,
  except,
  desc,
) => {
  if (
    (from &&
      typeof from === "object") ||
    typeof from === "function"
  )
    for (
      var keys =
          __getOwnPropNames(from),
        i = 0,
        n = keys.length,
        key;
      i < n;
      i++
    ) {
      key = keys[i];
      if (
        !__hasOwnProp.call(to, key) &&
        key !== except
      )
        __defProp(to, key, {
          get: ((k) => from[k]).bind(
            null,
            key,
          ),
          enumerable:
            !(desc = __getOwnPropDesc(
              from,
              key,
            )) || desc.enumerable,
        });
    }
  return to;
};
var __toESM = (
  mod,
  isNodeMode,
  target,
) => (
  (target =
    mod != null
      ? __create(__getProtoOf(mod))
      : {}),
  __copyProps(
    isNodeMode ||
      !mod ||
      !mod.__esModule ||
      !__hasOwnProp.call(mod, "default")
      ? __defProp(target, "default", {
          value: mod,
          enumerable: true,
        })
      : target,
    mod,
  )
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/code.js
var require_code$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.regexpCode =
        exports.getEsmExportName =
        exports.getProperty =
        exports.safeStringify =
        exports.stringify =
        exports.strConcat =
        exports.addCodeArg =
        exports.str =
        exports._ =
        exports.nil =
        exports._Code =
        exports.Name =
        exports.IDENTIFIER =
        exports._CodeOrName =
          void 0;
      var _CodeOrName = class {};
      exports._CodeOrName = _CodeOrName;
      exports.IDENTIFIER =
        /^[a-z$_][a-z$_0-9]*$/i;
      var Name = class extends _CodeOrName {
        constructor(s) {
          super();
          if (
            !exports.IDENTIFIER.test(s)
          )
            throw new Error(
              "CodeGen: name must be a valid identifier",
            );
          this.str = s;
        }
        toString() {
          return this.str;
        }
        emptyStr() {
          return false;
        }
        get names() {
          return { [this.str]: 1 };
        }
      };
      exports.Name = Name;
      var _Code = class extends _CodeOrName {
        constructor(code) {
          super();
          this._items =
            typeof code === "string"
              ? [code]
              : code;
        }
        toString() {
          return this.str;
        }
        emptyStr() {
          if (this._items.length > 1)
            return false;
          const item = this._items[0];
          return (
            item === "" || item === '""'
          );
        }
        get str() {
          var _a;
          return (_a = this._str) !==
            null && _a !== void 0
            ? _a
            : (this._str =
                this._items.reduce(
                  (s, c) => `${s}${c}`,
                  "",
                ));
        }
        get names() {
          var _a;
          return (_a = this._names) !==
            null && _a !== void 0
            ? _a
            : (this._names =
                this._items.reduce(
                  (names, c) => {
                    if (
                      c instanceof Name
                    )
                      names[c.str] =
                        (names[c.str] ||
                          0) + 1;
                    return names;
                  },
                  {},
                ));
        }
      };
      exports._Code = _Code;
      exports.nil = new _Code("");
      function _(strs, ...args) {
        const code = [strs[0]];
        let i = 0;
        while (i < args.length) {
          addCodeArg(code, args[i]);
          code.push(strs[++i]);
        }
        return new _Code(code);
      }
      exports._ = _;
      const plus = new _Code("+");
      function str(strs, ...args) {
        const expr = [
          safeStringify(strs[0]),
        ];
        let i = 0;
        while (i < args.length) {
          expr.push(plus);
          addCodeArg(expr, args[i]);
          expr.push(
            plus,
            safeStringify(strs[++i]),
          );
        }
        optimize(expr);
        return new _Code(expr);
      }
      exports.str = str;
      function addCodeArg(code, arg) {
        if (arg instanceof _Code)
          code.push(...arg._items);
        else if (arg instanceof Name)
          code.push(arg);
        else
          code.push(interpolate(arg));
      }
      exports.addCodeArg = addCodeArg;
      function optimize(expr) {
        let i = 1;
        while (i < expr.length - 1) {
          if (expr[i] === plus) {
            const res = mergeExprItems(
              expr[i - 1],
              expr[i + 1],
            );
            if (res !== void 0) {
              expr.splice(
                i - 1,
                3,
                res,
              );
              continue;
            }
            expr[i++] = "+";
          }
          i++;
        }
      }
      function mergeExprItems(a, b) {
        if (b === '""') return a;
        if (a === '""') return b;
        if (typeof a == "string") {
          if (
            b instanceof Name ||
            a[a.length - 1] !== '"'
          )
            return;
          if (typeof b != "string")
            return `${a.slice(0, -1)}${b}"`;
          if (b[0] === '"')
            return (
              a.slice(0, -1) +
              b.slice(1)
            );
          return;
        }
        if (
          typeof b == "string" &&
          b[0] === '"' &&
          !(a instanceof Name)
        )
          return `"${a}${b.slice(1)}`;
      }
      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;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/scope.js
var require_scope =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.ValueScope =
        exports.ValueScopeName =
        exports.Scope =
        exports.varKinds =
        exports.UsedValueState =
          void 0;
      const code_1 = require_code$1();
      var ValueError = class extends Error {
        constructor(name) {
          super(
            `CodeGen: "code" for ${name} not defined`,
          );
          this.value = name.value;
        }
      };
      var UsedValueState;
      (function (UsedValueState) {
        UsedValueState[
          (UsedValueState["Started"] =
            0)
        ] = "Started";
        UsedValueState[
          (UsedValueState["Completed"] =
            1)
        ] = "Completed";
      })(
        UsedValueState ||
          (exports.UsedValueState =
            UsedValueState =
              {}),
      );
      exports.varKinds = {
        const: new code_1.Name("const"),
        let: new code_1.Name("let"),
        var: new code_1.Name("var"),
      };
      var Scope = class {
        constructor({
          prefixes,
          parent,
        } = {}) {
          this._names = {};
          this._prefixes = prefixes;
          this._parent = parent;
        }
        toName(nameOrPrefix) {
          return nameOrPrefix instanceof
            code_1.Name
            ? nameOrPrefix
            : this.name(nameOrPrefix);
        }
        name(prefix) {
          return new code_1.Name(
            this._newName(prefix),
          );
        }
        _newName(prefix) {
          const ng =
            this._names[prefix] ||
            this._nameGroup(prefix);
          return `${prefix}${ng.index++}`;
        }
        _nameGroup(prefix) {
          var _a, _b;
          if (
            ((_b =
              (_a = this._parent) ===
                null || _a === void 0
                ? void 0
                : _a._prefixes) ===
              null || _b === void 0
              ? void 0
              : _b.has(prefix)) ||
            (this._prefixes &&
              !this._prefixes.has(
                prefix,
              ))
          )
            throw new Error(
              `CodeGen: prefix "${prefix}" is not allowed in this scope`,
            );
          return (this._names[prefix] =
            {
              prefix,
              index: 0,
            });
        }
      };
      exports.Scope = Scope;
      var ValueScopeName = class
        extends code_1.Name
      {
        constructor(prefix, nameStr) {
          super(nameStr);
          this.prefix = prefix;
        }
        setValue(
          value,
          { property, itemIndex },
        ) {
          this.value = value;
          this.scopePath = (0,
          code_1._)`.${new code_1.Name(property)}[${itemIndex}]`;
        }
      };
      exports.ValueScopeName =
        ValueScopeName;
      const line = (0, code_1._)`\n`;
      var ValueScope = class extends Scope {
        constructor(opts) {
          super(opts);
          this._values = {};
          this._scope = opts.scope;
          this.opts = {
            ...opts,
            _n: opts.lines
              ? line
              : code_1.nil,
          };
        }
        get() {
          return this._scope;
        }
        name(prefix) {
          return new ValueScopeName(
            prefix,
            this._newName(prefix),
          );
        }
        value(nameOrPrefix, value) {
          var _a;
          if (value.ref === void 0)
            throw new Error(
              "CodeGen: ref must be passed in value",
            );
          const name = this.toName(
            nameOrPrefix,
          );
          const { prefix } = name;
          const valueKey =
            (_a = value.key) !== null &&
            _a !== void 0
              ? _a
              : value.ref;
          let vs = this._values[prefix];
          if (vs) {
            const _name =
              vs.get(valueKey);
            if (_name) return _name;
          } else
            vs = this._values[prefix] =
              /* @__PURE__ */ new Map();
          vs.set(valueKey, name);
          const s =
            this._scope[prefix] ||
            (this._scope[prefix] = []);
          const itemIndex = s.length;
          s[itemIndex] = value.ref;
          name.setValue(value, {
            property: prefix,
            itemIndex,
          });
          return name;
        }
        getValue(prefix, keyOrRef) {
          const vs =
            this._values[prefix];
          if (!vs) return;
          return vs.get(keyOrRef);
        }
        scopeRefs(
          scopeName,
          values = this._values,
        ) {
          return this._reduceValues(
            values,
            (name) => {
              if (
                name.scopePath ===
                void 0
              )
                throw new Error(
                  `CodeGen: name "${name}" has no value`,
                );
              return (0,
              code_1._)`${scopeName}${name.scopePath}`;
            },
          );
        }
        scopeCode(
          values = this._values,
          usedValues,
          getCode,
        ) {
          return this._reduceValues(
            values,
            (name) => {
              if (name.value === void 0)
                throw new Error(
                  `CodeGen: name "${name}" has no value`,
                );
              return name.value.code;
            },
            usedValues,
            getCode,
          );
        }
        _reduceValues(
          values,
          valueCode,
          usedValues = {},
          getCode,
        ) {
          let code = code_1.nil;
          for (const prefix in values) {
            const vs = values[prefix];
            if (!vs) continue;
            const nameSet = (usedValues[
              prefix
            ] =
              usedValues[prefix] ||
              /* @__PURE__ */ new Map());
            vs.forEach((name) => {
              if (nameSet.has(name))
                return;
              nameSet.set(
                name,
                UsedValueState.Started,
              );
              let c = valueCode(name);
              if (c) {
                const def = this.opts
                  .es5
                  ? exports.varKinds.var
                  : exports.varKinds
                      .const;
                code = (0,
                code_1._)`${code}${def} ${name} = ${c};${this.opts._n}`;
              } else if (
                (c =
                  getCode === null ||
                  getCode === void 0
                    ? void 0
                    : getCode(name))
              )
                code = (0,
                code_1._)`${code}${c}${this.opts._n}`;
              else
                throw new ValueError(
                  name,
                );
              nameSet.set(
                name,
                UsedValueState.Completed,
              );
            });
          }
          return code;
        }
      };
      exports.ValueScope = ValueScope;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/index.js
var require_codegen =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.or =
        exports.and =
        exports.not =
        exports.CodeGen =
        exports.operators =
        exports.varKinds =
        exports.ValueScopeName =
        exports.ValueScope =
        exports.Scope =
        exports.Name =
        exports.regexpCode =
        exports.stringify =
        exports.getProperty =
        exports.nil =
        exports.strConcat =
        exports.str =
        exports._ =
          void 0;
      const code_1 = require_code$1();
      const scope_1 = require_scope();
      var code_2 = require_code$1();
      Object.defineProperty(
        exports,
        "_",
        {
          enumerable: true,
          get: function () {
            return code_2._;
          },
        },
      );
      Object.defineProperty(
        exports,
        "str",
        {
          enumerable: true,
          get: function () {
            return code_2.str;
          },
        },
      );
      Object.defineProperty(
        exports,
        "strConcat",
        {
          enumerable: true,
          get: function () {
            return code_2.strConcat;
          },
        },
      );
      Object.defineProperty(
        exports,
        "nil",
        {
          enumerable: true,
          get: function () {
            return code_2.nil;
          },
        },
      );
      Object.defineProperty(
        exports,
        "getProperty",
        {
          enumerable: true,
          get: function () {
            return code_2.getProperty;
          },
        },
      );
      Object.defineProperty(
        exports,
        "stringify",
        {
          enumerable: true,
          get: function () {
            return code_2.stringify;
          },
        },
      );
      Object.defineProperty(
        exports,
        "regexpCode",
        {
          enumerable: true,
          get: function () {
            return code_2.regexpCode;
          },
        },
      );
      Object.defineProperty(
        exports,
        "Name",
        {
          enumerable: true,
          get: function () {
            return code_2.Name;
          },
        },
      );
      var scope_2 = require_scope();
      Object.defineProperty(
        exports,
        "Scope",
        {
          enumerable: true,
          get: function () {
            return scope_2.Scope;
          },
        },
      );
      Object.defineProperty(
        exports,
        "ValueScope",
        {
          enumerable: true,
          get: function () {
            return scope_2.ValueScope;
          },
        },
      );
      Object.defineProperty(
        exports,
        "ValueScopeName",
        {
          enumerable: true,
          get: function () {
            return scope_2.ValueScopeName;
          },
        },
      );
      Object.defineProperty(
        exports,
        "varKinds",
        {
          enumerable: true,
          get: function () {
            return scope_2.varKinds;
          },
        },
      );
      exports.operators = {
        GT: new code_1._Code(">"),
        GTE: new code_1._Code(">="),
        LT: new code_1._Code("<"),
        LTE: new code_1._Code("<="),
        EQ: new code_1._Code("==="),
        NEQ: new code_1._Code("!=="),
        NOT: new code_1._Code("!"),
        OR: new code_1._Code("||"),
        AND: new code_1._Code("&&"),
        ADD: new code_1._Code("+"),
      };
      var Node = class {
        optimizeNodes() {
          return this;
        }
        optimizeNames(
          _names,
          _constants,
        ) {
          return this;
        }
      };
      var Def = class extends Node {
        constructor(
          varKind,
          name,
          rhs,
        ) {
          super();
          this.varKind = varKind;
          this.name = name;
          this.rhs = rhs;
        }
        render({ es5, _n }) {
          const varKind = es5
            ? scope_1.varKinds.var
            : this.varKind;
          const rhs =
            this.rhs === void 0
              ? ""
              : ` = ${this.rhs}`;
          return (
            `${varKind} ${this.name}${rhs};` +
            _n
          );
        }
        optimizeNames(
          names,
          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() {
          return addExprNames(
            this.lhs instanceof
              code_1.Name
              ? {}
              : { ...this.lhs.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 }) {
          return (
            `break${this.label ? ` ${this.label}` : ""};` +
            _n
          );
        }
      };
      var Throw = class extends Node {
        constructor(error) {
          super();
          this.error = error;
        }
        render({ _n }) {
          return (
            `throw ${this.error};` + _n
          );
        }
        get names() {
          return this.error.names;
        }
      };
      var AnyCode = class extends Node {
        constructor(code) {
          super();
          this.code = code;
        }
        render({ _n }) {
          return `${this.code};` + _n;
        }
        optimizeNodes() {
          return `${this.code}`
            ? this
            : void 0;
        }
        optimizeNames(
          names,
          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 _a;
          this.else =
            (_a = this.else) === null ||
            _a === void 0
              ? void 0
              : _a.optimizeNames(
                  names,
                  constants,
                );
          if (
            !(
              super.optimizeNames(
                names,
                constants,
              ) || this.else
            )
          )
            return;
          this.condition = optimizeExpr(
            this.condition,
            names,
            constants,
          );
          return this;
        }
        get names() {
          const names = super.names;
          addExprNames(
            names,
            this.condition,
          );
          if (this.else)
            addNames(
              names,
              this.else.names,
            );
          return names;
        }
      };
      If.kind = "if";
      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() {
          return addExprNames(
            addExprNames(
              super.names,
              this.from,
            ),
            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, args, async) {
          super();
          this.name = name;
          this.args = args;
          this.async = async;
        }
        render(opts) {
          return (
            `${this.async ? "async " : ""}function ${this.name}(${this.args})` +
            super.render(opts)
          );
        }
      };
      Func.kind = "func";
      var Return = class extends ParentNode {
        render(opts) {
          return (
            "return " +
            super.render(opts)
          );
        }
      };
      Return.kind = "return";
      var Try = class extends BlockNode {
        render(opts) {
          let code =
            "try" + super.render(opts);
          if (this.catch)
            code +=
              this.catch.render(opts);
          if (this.finally)
            code +=
              this.finally.render(opts);
          return code;
        }
        optimizeNodes() {
          var _a, _b;
          super.optimizeNodes();
          (_a = this.catch) === null ||
            _a === void 0 ||
            _a.optimizeNodes();
          (_b = this.finally) ===
            null ||
            _b === void 0 ||
            _b.optimizeNodes();
          return this;
        }
        optimizeNames(
          names,
          constants,
        ) {
          var _a, _b;
          super.optimizeNames(
            names,
            constants,
          );
          (_a = this.catch) === null ||
            _a === void 0 ||
            _a.optimizeNames(
              names,
              constants,
            );
          (_b = this.finally) ===
            null ||
            _b === 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(error) {
          super();
          this.error = error;
        }
        render(opts) {
          return (
            `catch(${this.error})` +
            super.render(opts)
          );
        }
      };
      Catch.kind = "catch";
      var Finally = class extends BlockNode {
        render(opts) {
          return (
            "finally" +
            super.render(opts)
          );
        }
      };
      Finally.kind = "finally";
      var CodeGen = class {
        constructor(
          extScope,
          opts = {},
        ) {
          this._values = {};
          this._blockStarts = [];
          this._constants = {};
          this.opts = {
            ...opts,
            _n: opts.lines ? "\n" : "",
          };
          this._extScope = extScope;
          this._scope =
            new scope_1.Scope({
              parent: extScope,
            });
          this._nodes = [new Root()];
        }
        toString() {
          return this._root.render(
            this.opts,
          );
        }
        name(prefix) {
          return this._scope.name(
            prefix,
          );
        }
        scopeName(prefix) {
          return this._extScope.name(
            prefix,
          );
        }
        scopeValue(
          prefixOrName,
          value,
        ) {
          const name =
            this._extScope.value(
              prefixOrName,
              value,
            );
          (
            this._values[name.prefix] ||
            (this._values[name.prefix] =
              /* @__PURE__ */ new Set())
          ).add(name);
          return name;
        }
        getScopeValue(
          prefix,
          keyOrRef,
        ) {
          return this._extScope.getValue(
            prefix,
            keyOrRef,
          );
        }
        scopeRefs(scopeName) {
          return this._extScope.scopeRefs(
            scopeName,
            this._values,
          );
        }
        scopeCode() {
          return this._extScope.scopeCode(
            this._values,
          );
        }
        _def(
          varKind,
          nameOrPrefix,
          rhs,
          constant,
        ) {
          const name =
            this._scope.toName(
              nameOrPrefix,
            );
          if (
            rhs !== void 0 &&
            constant
          )
            this._constants[name.str] =
              rhs;
          this._leafNode(
            new Def(varKind, name, rhs),
          );
          return name;
        }
        const(
          nameOrPrefix,
          rhs,
          _constant,
        ) {
          return this._def(
            scope_1.varKinds.const,
            nameOrPrefix,
            rhs,
            _constant,
          );
        }
        let(
          nameOrPrefix,
          rhs,
          _constant,
        ) {
          return this._def(
            scope_1.varKinds.let,
            nameOrPrefix,
            rhs,
            _constant,
          );
        }
        var(
          nameOrPrefix,
          rhs,
          _constant,
        ) {
          return this._def(
            scope_1.varKinds.var,
            nameOrPrefix,
            rhs,
            _constant,
          );
        }
        assign(lhs, rhs, sideEffects) {
          return this._leafNode(
            new Assign(
              lhs,
              rhs,
              sideEffects,
            ),
          );
        }
        add(lhs, rhs) {
          return this._leafNode(
            new AssignOp(
              lhs,
              exports.operators.ADD,
              rhs,
            ),
          );
        }
        code(c) {
          if (typeof c == "function")
            c();
          else if (c !== code_1.nil)
            this._leafNode(
              new AnyCode(c),
            );
          return this;
        }
        object(...keyValues) {
          const code = ["{"];
          for (const [
            key,
            value,
          ] of keyValues) {
            if (code.length > 1)
              code.push(",");
            code.push(key);
            if (
              key !== value ||
              this.opts.es5
            ) {
              code.push(":");
              (0, code_1.addCodeArg)(
                code,
                value,
              );
            }
          }
          code.push("}");
          return new code_1._Code(code);
        }
        if(
          condition,
          thenBody,
          elseBody,
        ) {
          this._blockNode(
            new If(condition),
          );
          if (thenBody && elseBody)
            this.code(thenBody)
              .else()
              .code(elseBody)
              .endIf();
          else if (thenBody)
            this.code(thenBody).endIf();
          else if (elseBody)
            throw new Error(
              'CodeGen: "else" body without "then" body',
            );
          return this;
        }
        elseIf(condition) {
          return this._elseNode(
            new If(condition),
          );
        }
        else() {
          return this._elseNode(
            new Else(),
          );
        }
        endIf() {
          return this._endBlockNode(
            If,
            Else,
          );
        }
        _for(node, forBody) {
          this._blockNode(node);
          if (forBody)
            this.code(forBody).endFor();
          return this;
        }
        for(iteration, forBody) {
          return this._for(
            new ForLoop(iteration),
            forBody,
          );
        }
        forRange(
          nameOrPrefix,
          from,
          to,
          forBody,
          varKind = this.opts.es5
            ? scope_1.varKinds.var
            : scope_1.varKinds.let,
        ) {
          const name =
            this._scope.toName(
              nameOrPrefix,
            );
          return this._for(
            new ForRange(
              varKind,
              name,
              from,
              to,
            ),
            () => forBody(name),
          );
        }
        forOf(
          nameOrPrefix,
          iterable,
          forBody,
          varKind = scope_1.varKinds
            .const,
        ) {
          const name =
            this._scope.toName(
              nameOrPrefix,
            );
          if (this.opts.es5) {
            const arr =
              iterable instanceof
              code_1.Name
                ? iterable
                : this.var(
                    "_arr",
                    iterable,
                  );
            return this.forRange(
              "_i",
              0,
              (0,
              code_1._)`${arr}.length`,
              (i) => {
                this.var(
                  name,
                  (0,
                  code_1._)`${arr}[${i}]`,
                );
                forBody(name);
              },
            );
          }
          return this._for(
            new ForIter(
              "of",
              varKind,
              name,
              iterable,
            ),
            () => forBody(name),
          );
        }
        forIn(
          nameOrPrefix,
          obj,
          forBody,
          varKind = this.opts.es5
            ? scope_1.varKinds.var
            : scope_1.varKinds.const,
        ) {
          if (this.opts.ownProperties)
            return this.forOf(
              nameOrPrefix,
              (0,
              code_1._)`Object.keys(${obj})`,
              forBody,
            );
          const name =
            this._scope.toName(
              nameOrPrefix,
            );
          return this._for(
            new ForIter(
              "in",
              varKind,
              name,
              obj,
            ),
            () => forBody(name),
          );
        }
        endFor() {
          return this._endBlockNode(
            For,
          );
        }
        label(label) {
          return this._leafNode(
            new Label(label),
          );
        }
        break(label) {
          return this._leafNode(
            new Break(label),
          );
        }
        return(value) {
          const node = new Return();
          this._blockNode(node);
          this.code(value);
          if (node.nodes.length !== 1)
            throw new Error(
              'CodeGen: "return" should have one node',
            );
          return this._endBlockNode(
            Return,
          );
        }
        try(
          tryBody,
          catchCode,
          finallyCode,
        ) {
          if (
            !catchCode &&
            !finallyCode
          )
            throw new Error(
              'CodeGen: "try" without "catch" and "finally"',
            );
          const node = new Try();
          this._blockNode(node);
          this.code(tryBody);
          if (catchCode) {
            const error =
              this.name("e");
            this._currNode =
              node.catch = new Catch(
                error,
              );
            catchCode(error);
          }
          if (finallyCode) {
            this._currNode =
              node.finally =
                new Finally();
            this.code(finallyCode);
          }
          return this._endBlockNode(
            Catch,
            Finally,
          );
        }
        throw(error) {
          return this._leafNode(
            new Throw(error),
          );
        }
        block(body, nodeCount) {
          this._blockStarts.push(
            this._nodes.length,
          );
          if (body)
            this.code(body).endBlock(
              nodeCount,
            );
          return this;
        }
        endBlock(nodeCount) {
          const len =
            this._blockStarts.pop();
          if (len === 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;
        }
        func(
          name,
          args = code_1.nil,
          async,
          funcBody,
        ) {
          this._blockNode(
            new Func(name, args, async),
          );
          if (funcBody)
            this.code(
              funcBody,
            ).endFunc();
          return this;
        }
        endFunc() {
          return this._endBlockNode(
            Func,
          );
        }
        optimize(n = 1) {
          while (n-- > 0) {
            this._root.optimizeNodes();
            this._root.optimizeNames(
              this._root.names,
              this._constants,
            );
          }
        }
        _leafNode(node) {
          this._currNode.nodes.push(
            node,
          );
          return this;
        }
        _blockNode(node) {
          this._currNode.nodes.push(
            node,
          );
          this._nodes.push(node);
        }
        _endBlockNode(N1, N2) {
          const n = this._currNode;
          if (
            n instanceof N1 ||
            (N2 && n instanceof N2)
          ) {
            this._nodes.pop();
            return this;
          }
          throw new Error(
            `CodeGen: not in block "${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}"`,
          );
        }
        _elseNode(node) {
          const n = this._currNode;
          if (!(n instanceof If))
            throw new Error(
              'CodeGen: "else" without "if"',
            );
          this._currNode = n.else =
            node;
          return this;
        }
        get _root() {
          return this._nodes[0];
        }
        get _currNode() {
          const ns = this._nodes;
          return ns[ns.length - 1];
        }
        set _currNode(node) {
          const ns = this._nodes;
          ns[ns.length - 1] = node;
        }
      };
      exports.CodeGen = CodeGen;
      function addNames(names, from) {
        for (const n in from)
          names[n] =
            (names[n] || 0) +
            (from[n] || 0);
        return names;
      }
      function addExprNames(
        names,
        from,
      ) {
        return from instanceof
          code_1._CodeOrName
          ? addNames(names, from.names)
          : names;
      }
      function optimizeExpr(
        expr,
        names,
        constants,
      ) {
        if (expr instanceof code_1.Name)
          return replaceName(expr);
        if (!canOptimize(expr))
          return expr;
        return new code_1._Code(
          expr._items.reduce(
            (items, c) => {
              if (
                c instanceof code_1.Name
              )
                c = replaceName(c);
              if (
                c instanceof
                code_1._Code
              )
                items.push(...c._items);
              else items.push(c);
              return items;
            },
            [],
          ),
        );
        function replaceName(n) {
          const c = constants[n.str];
          if (
            c === 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;
      const andCode = mappend(
        exports.operators.AND,
      );
      function and(...args) {
        return args.reduce(andCode);
      }
      exports.and = and;
      const orCode = mappend(
        exports.operators.OR,
      );
      function or(...args) {
        return args.reduce(orCode);
      }
      exports.or = or;
      function mappend(op) {
        return (x, y) =>
          x === code_1.nil
            ? y
            : y === code_1.nil
              ? x
              : (0,
                code_1._)`${par(x)} ${op} ${par(y)}`;
      }
      function par(x) {
        return x instanceof code_1.Name
          ? x
          : (0, code_1._)`(${x})`;
      }
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/util.js
var require_util =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.checkStrictMode =
        exports.getErrorPath =
        exports.Type =
        exports.useFunc =
        exports.setEvaluated =
        exports.evaluatedPropsToName =
        exports.mergeEvaluated =
        exports.eachItem =
        exports.unescapeJsonPointer =
        exports.escapeJsonPointer =
        exports.escapeFragment =
        exports.unescapeFragment =
        exports.schemaRefOrVal =
        exports.schemaHasRulesButRef =
        exports.schemaHasRules =
        exports.checkUnknownRules =
        exports.alwaysValidSchema =
        exports.toHash =
          void 0;
      const codegen_1 =
        require_codegen();
      const code_1 = require_code$1();
      function toHash(arr) {
        const hash = {};
        for (const item of arr)
          hash[item] = true;
        return hash;
      }
      exports.toHash = toHash;
      function alwaysValidSchema(
        it,
        schema,
      ) {
        if (typeof schema == "boolean")
          return schema;
        if (
          Object.keys(schema).length ===
          0
        )
          return true;
        checkUnknownRules(it, schema);
        return !schemaHasRules(
          schema,
          it.self.RULES.all,
        );
      }
      exports.alwaysValidSchema =
        alwaysValidSchema;
      function checkUnknownRules(
        it,
        schema = it.schema,
      ) {
        const { opts, self } = it;
        if (!opts.strictSchema) return;
        if (typeof schema === "boolean")
          return;
        const rules =
          self.RULES.keywords;
        for (const key in schema)
          if (!rules[key])
            checkStrictMode(
              it,
              `unknown keyword: "${key}"`,
            );
      }
      exports.checkUnknownRules =
        checkUnknownRules;
      function schemaHasRules(
        schema,
        rules,
      ) {
        if (typeof schema == "boolean")
          return !schema;
        for (const key in schema)
          if (rules[key]) return true;
        return false;
      }
      exports.schemaHasRules =
        schemaHasRules;
      function schemaHasRulesButRef(
        schema,
        RULES,
      ) {
        if (typeof schema == "boolean")
          return !schema;
        for (const key in schema)
          if (
            key !== "$ref" &&
            RULES.all[key]
          )
            return true;
        return false;
      }
      exports.schemaHasRulesButRef =
        schemaHasRulesButRef;
      function schemaRefOrVal(
        { topSchemaRef, schemaPath },
        schema,
        keyword,
        $data,
      ) {
        if (!$data) {
          if (
            typeof schema == "number" ||
            typeof schema == "boolean"
          )
            return schema;
          if (typeof schema == "string")
            return (0,
            codegen_1._)`${schema}`;
        }
        return (0,
        codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
      }
      exports.schemaRefOrVal =
        schemaRefOrVal;
      function unescapeFragment(str) {
        return unescapeJsonPointer(
          decodeURIComponent(str),
        );
      }
      exports.unescapeFragment =
        unescapeFragment;
      function escapeFragment(str) {
        return encodeURIComponent(
          escapeJsonPointer(str),
        );
      }
      exports.escapeFragment =
        escapeFragment;
      function escapeJsonPointer(str) {
        if (typeof str == "number")
          return `${str}`;
        return str
          .replace(/~/g, "~0")
          .replace(/\//g, "~1");
      }
      exports.escapeJsonPointer =
        escapeJsonPointer;
      function unescapeJsonPointer(
        str,
      ) {
        return str
          .replace(/~1/g, "/")
          .replace(/~0/g, "~");
      }
      exports.unescapeJsonPointer =
        unescapeJsonPointer;
      function eachItem(xs, f) {
        if (Array.isArray(xs))
          for (const x of xs) f(x);
        else f(xs);
      }
      exports.eachItem = eachItem;
      function makeMergeEvaluated({
        mergeNames,
        mergeToName,
        mergeValues,
        resultToName,
      }) {
        return (
          gen,
          from,
          to,
          toName,
        ) => {
          const res =
            to === void 0
              ? from
              : to instanceof
                  codegen_1.Name
                ? (from instanceof
                  codegen_1.Name
                    ? mergeNames(
                        gen,
                        from,
                        to,
                      )
                    : mergeToName(
                        gen,
                        from,
                        to,
                      ),
                  to)
                : from instanceof
                    codegen_1.Name
                  ? (mergeToName(
                      gen,
                      to,
                      from,
                    ),
                    from)
                  : mergeValues(
                      from,
                      to,
                    );
          return toName ===
            codegen_1.Name &&
            !(
              res instanceof
              codegen_1.Name
            )
            ? resultToName(gen, res)
            : res;
        };
      }
      exports.mergeEvaluated = {
        props: makeMergeEvaluated({
          mergeNames: (gen, from, to) =>
            gen.if(
              (0,
              codegen_1._)`${to} !== true && ${from} !== undefined`,
              () => {
                gen.if(
                  (0,
                  codegen_1._)`${from} === true`,
                  () =>
                    gen.assign(
                      to,
                      true,
                    ),
                  () =>
                    gen
                      .assign(
                        to,
                        (0,
                        codegen_1._)`${to} || {}`,
                      )
                      .code(
                        (0,
                        codegen_1._)`Object.assign(${to}, ${from})`,
                      ),
                );
              },
            ),
          mergeToName: (
            gen,
            from,
            to,
          ) =>
            gen.if(
              (0,
              codegen_1._)`${to} !== true`,
              () => {
                if (from === true)
                  gen.assign(to, true);
                else {
                  gen.assign(
                    to,
                    (0,
                    codegen_1._)`${to} || {}`,
                  );
                  setEvaluated(
                    gen,
                    to,
                    from,
                  );
                }
              },
            ),
          mergeValues: (from, to) =>
            from === true
              ? true
              : {
                  ...from,
                  ...to,
                },
          resultToName:
            evaluatedPropsToName,
        }),
        items: makeMergeEvaluated({
          mergeNames: (gen, from, to) =>
            gen.if(
              (0,
              codegen_1._)`${to} !== true && ${from} !== undefined`,
              () =>
                gen.assign(
                  to,
                  (0,
                  codegen_1._)`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`,
                ),
            ),
          mergeToName: (
            gen,
            from,
            to,
          ) =>
            gen.if(
              (0,
              codegen_1._)`${to} !== true`,
              () =>
                gen.assign(
                  to,
                  from === true
                    ? true
                    : (0,
                      codegen_1._)`${to} > ${from} ? ${to} : ${from}`,
                ),
            ),
          mergeValues: (from, to) =>
            from === true
              ? true
              : Math.max(from, to),
          resultToName: (gen, items) =>
            gen.var("items", items),
        }),
      };
      function evaluatedPropsToName(
        gen,
        ps,
      ) {
        if (ps === true)
          return gen.var("props", true);
        const props = gen.var(
          "props",
          (0, codegen_1._)`{}`,
        );
        if (ps !== void 0)
          setEvaluated(gen, props, ps);
        return props;
      }
      exports.evaluatedPropsToName =
        evaluatedPropsToName;
      function setEvaluated(
        gen,
        props,
        ps,
      ) {
        Object.keys(ps).forEach((p) =>
          gen.assign(
            (0,
            codegen_1._)`${props}${(0, codegen_1.getProperty)(p)}`,
            true,
          ),
        );
      }
      exports.setEvaluated =
        setEvaluated;
      const snippets = {};
      function useFunc(gen, f) {
        return gen.scopeValue("func", {
          ref: f,
          code:
            snippets[f.code] ||
            (snippets[f.code] =
              new code_1._Code(f.code)),
        });
      }
      exports.useFunc = useFunc;
      var Type;
      (function (Type) {
        Type[(Type["Num"] = 0)] = "Num";
        Type[(Type["Str"] = 1)] = "Str";
      })(
        Type ||
          (exports.Type = Type = {}),
      );
      function getErrorPath(
        dataProp,
        dataPropType,
        jsPropertySyntax,
      ) {
        if (
          dataProp instanceof
          codegen_1.Name
        ) {
          const isNumber =
            dataPropType === Type.Num;
          return jsPropertySyntax
            ? isNumber
              ? (0,
                codegen_1._)`"[" + ${dataProp} + "]"`
              : (0,
                codegen_1._)`"['" + ${dataProp} + "']"`
            : isNumber
              ? (0,
                codegen_1._)`"/" + ${dataProp}`
              : (0,
                codegen_1._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
        }
        return jsPropertySyntax
          ? (0, codegen_1.getProperty)(
              dataProp,
            ).toString()
          : "/" +
              escapeJsonPointer(
                dataProp,
              );
      }
      exports.getErrorPath =
        getErrorPath;
      function checkStrictMode(
        it,
        msg,
        mode = it.opts.strictSchema,
      ) {
        if (!mode) return;
        msg = `strict mode: ${msg}`;
        if (mode === true)
          throw new Error(msg);
        it.self.logger.warn(msg);
      }
      exports.checkStrictMode =
        checkStrictMode;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/names.js
var require_names =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      exports.default = {
        data: new codegen_1.Name(
          "data",
        ),
        valCxt: new codegen_1.Name(
          "valCxt",
        ),
        instancePath:
          new codegen_1.Name(
            "instancePath",
          ),
        parentData: new codegen_1.Name(
          "parentData",
        ),
        parentDataProperty:
          new codegen_1.Name(
            "parentDataProperty",
          ),
        rootData: new codegen_1.Name(
          "rootData",
        ),
        dynamicAnchors:
          new codegen_1.Name(
            "dynamicAnchors",
          ),
        vErrors: new codegen_1.Name(
          "vErrors",
        ),
        errors: new codegen_1.Name(
          "errors",
        ),
        this: new codegen_1.Name(
          "this",
        ),
        self: new codegen_1.Name(
          "self",
        ),
        scope: new codegen_1.Name(
          "scope",
        ),
        json: new codegen_1.Name(
          "json",
        ),
        jsonPos: new codegen_1.Name(
          "jsonPos",
        ),
        jsonLen: new codegen_1.Name(
          "jsonLen",
        ),
        jsonPart: new codegen_1.Name(
          "jsonPart",
        ),
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/errors.js
var require_errors =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.extendErrors =
        exports.resetErrorsCount =
        exports.reportExtraError =
        exports.reportError =
        exports.keyword$DataError =
        exports.keywordError =
          void 0;
      const codegen_1 =
        require_codegen();
      const util_1 = require_util();
      const names_1 = require_names();
      exports.keywordError = {
        message: ({ keyword }) =>
          (0,
          codegen_1.str)`must pass "${keyword}" keyword validation`,
      };
      exports.keyword$DataError = {
        message: ({
          keyword,
          schemaType,
        }) =>
          schemaType
            ? (0,
              codegen_1.str)`"${keyword}" keyword must be ${schemaType} ($data)`
            : (0,
              codegen_1.str)`"${keyword}" keyword is invalid ($data)`,
      };
      function reportError(
        cxt,
        error = exports.keywordError,
        errorPaths,
        overrideAllErrors,
      ) {
        const { it } = cxt;
        const {
          gen,
          compositeRule,
          allErrors,
        } = it;
        const errObj = errorObjectCode(
          cxt,
          error,
          errorPaths,
        );
        if (
          overrideAllErrors !== null &&
          overrideAllErrors !== void 0
            ? overrideAllErrors
            : compositeRule || allErrors
        )
          addError(gen, errObj);
        else
          returnErrors(
            it,
            (0,
            codegen_1._)`[${errObj}]`,
          );
      }
      exports.reportError = reportError;
      function reportExtraError(
        cxt,
        error = exports.keywordError,
        errorPaths,
      ) {
        const { it } = cxt;
        const {
          gen,
          compositeRule,
          allErrors,
        } = it;
        addError(
          gen,
          errorObjectCode(
            cxt,
            error,
            errorPaths,
          ),
        );
        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,
      }) {
        /* istanbul ignore if */
        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);
        }
      }
      const E = {
        keyword: new codegen_1.Name(
          "keyword",
        ),
        schemaPath: new codegen_1.Name(
          "schemaPath",
        ),
        params: new codegen_1.Name(
          "params",
        ),
        propertyName:
          new codegen_1.Name(
            "propertyName",
          ),
        message: new codegen_1.Name(
          "message",
        ),
        schema: new codegen_1.Name(
          "schema",
        ),
        parentSchema:
          new codegen_1.Name(
            "parentSchema",
          ),
      };
      function errorObjectCode(
        cxt,
        error,
        errorPaths,
      ) {
        const { createErrors } = cxt.it;
        if (createErrors === false)
          return (0, codegen_1._)`{}`;
        return errorObject(
          cxt,
          error,
          errorPaths,
        );
      }
      function errorObject(
        cxt,
        error,
        errorPaths = {},
      ) {
        const { gen, it } = cxt;
        const keyValues = [
          errorInstancePath(
            it,
            errorPaths,
          ),
          errorSchemaPath(
            cxt,
            errorPaths,
          ),
        ];
        extraErrorProps(
          cxt,
          error,
          keyValues,
        );
        return gen.object(...keyValues);
      }
      function errorInstancePath(
        { errorPath },
        { instancePath },
      ) {
        const instPath = instancePath
          ? (0,
            codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(instancePath, util_1.Type.Str)}`
          : errorPath;
        return [
          names_1.default.instancePath,
          (0, codegen_1.strConcat)(
            names_1.default
              .instancePath,
            instPath,
          ),
        ];
      }
      function errorSchemaPath(
        {
          keyword,
          it: { errSchemaPath },
        },
        { schemaPath, parentSchema },
      ) {
        let schPath = parentSchema
          ? errSchemaPath
          : (0,
            codegen_1.str)`${errSchemaPath}/${keyword}`;
        if (schemaPath)
          schPath = (0,
          codegen_1.str)`${schPath}${(0, util_1.getErrorPath)(schemaPath, util_1.Type.Str)}`;
        return [E.schemaPath, schPath];
      }
      function extraErrorProps(
        cxt,
        { params, message },
        keyValues,
      ) {
        const {
          keyword,
          data,
          schemaValue,
          it,
        } = cxt;
        const {
          opts,
          propertyName,
          topSchemaRef,
          schemaPath,
        } = it;
        keyValues.push(
          [E.keyword, keyword],
          [
            E.params,
            typeof params == "function"
              ? params(cxt)
              : params ||
                (0, codegen_1._)`{}`,
          ],
        );
        if (opts.messages)
          keyValues.push([
            E.message,
            typeof message == "function"
              ? message(cxt)
              : message,
          ]);
        if (opts.verbose)
          keyValues.push(
            [E.schema, schemaValue],
            [
              E.parentSchema,
              (0,
              codegen_1._)`${topSchemaRef}${schemaPath}`,
            ],
            [
              names_1.default.data,
              data,
            ],
          );
        if (propertyName)
          keyValues.push([
            E.propertyName,
            propertyName,
          ]);
      }
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/boolSchema.js
var require_boolSchema =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.boolOrEmptySchema =
        exports.topBoolOrEmptySchema =
          void 0;
      const errors_1 = require_errors();
      const codegen_1 =
        require_codegen();
      const names_1 = require_names();
      const boolError = {
        message:
          "boolean schema is false",
      };
      function topBoolOrEmptySchema(
        it,
      ) {
        const {
          gen,
          schema,
          validateName,
        } = it;
        if (schema === false)
          falseSchemaError(it, false);
        else if (
          typeof schema == "object" &&
          schema.$async === true
        )
          gen.return(
            names_1.default.data,
          );
        else {
          gen.assign(
            (0,
            codegen_1._)`${validateName}.errors`,
            null,
          );
          gen.return(true);
        }
      }
      exports.topBoolOrEmptySchema =
        topBoolOrEmptySchema;
      function boolOrEmptySchema(
        it,
        valid,
      ) {
        const { gen, schema } = it;
        if (schema === false) {
          gen.var(valid, false);
          falseSchemaError(it);
        } else gen.var(valid, true);
      }
      exports.boolOrEmptySchema =
        boolOrEmptySchema;
      function falseSchemaError(
        it,
        overrideAllErrors,
      ) {
        const { gen, data } = it;
        const cxt = {
          gen,
          keyword: "false schema",
          data,
          schema: false,
          schemaCode: false,
          schemaValue: false,
          params: {},
          it,
        };
        (0, errors_1.reportError)(
          cxt,
          boolError,
          void 0,
          overrideAllErrors,
        );
      }
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/rules.js
var require_rules =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.getRules =
        exports.isJSONType = void 0;
      const jsonTypes =
        /* @__PURE__ */ new Set([
          "string",
          "number",
          "integer",
          "boolean",
          "null",
          "object",
          "array",
        ]);
      function isJSONType(x) {
        return (
          typeof x == "string" &&
          jsonTypes.has(x)
        );
      }
      exports.isJSONType = isJSONType;
      function getRules() {
        const groups = {
          number: {
            type: "number",
            rules: [],
          },
          string: {
            type: "string",
            rules: [],
          },
          array: {
            type: "array",
            rules: [],
          },
          object: {
            type: "object",
            rules: [],
          },
        };
        return {
          types: {
            ...groups,
            integer: true,
            boolean: true,
            null: true,
          },
          rules: [
            { rules: [] },
            groups.number,
            groups.string,
            groups.array,
            groups.object,
          ],
          post: { rules: [] },
          all: {},
          keywords: {},
        };
      }
      exports.getRules = getRules;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/applicability.js
var require_applicability =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.shouldUseRule =
        exports.shouldUseGroup =
        exports.schemaHasRulesForType =
          void 0;
      function schemaHasRulesForType(
        { schema, self },
        type,
      ) {
        const group =
          self.RULES.types[type];
        return (
          group &&
          group !== true &&
          shouldUseGroup(schema, group)
        );
      }
      exports.schemaHasRulesForType =
        schemaHasRulesForType;
      function shouldUseGroup(
        schema,
        group,
      ) {
        return group.rules.some(
          (rule) =>
            shouldUseRule(schema, rule),
        );
      }
      exports.shouldUseGroup =
        shouldUseGroup;
      function shouldUseRule(
        schema,
        rule,
      ) {
        var _a;
        return (
          schema[rule.keyword] !==
            void 0 ||
          ((_a =
            rule.definition
              .implements) === null ||
          _a === void 0
            ? void 0
            : _a.some(
                (kwd) =>
                  schema[kwd] !==
                  void 0,
              ))
        );
      }
      exports.shouldUseRule =
        shouldUseRule;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/dataType.js
var require_dataType =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.reportTypeError =
        exports.checkDataTypes =
        exports.checkDataType =
        exports.coerceAndCheckDataType =
        exports.getJSONTypes =
        exports.getSchemaTypes =
        exports.DataType =
          void 0;
      const rules_1 = require_rules();
      const applicability_1 =
        require_applicability();
      const errors_1 = require_errors();
      const codegen_1 =
        require_codegen();
      const util_1 = require_util();
      var DataType;
      (function (DataType) {
        DataType[
          (DataType["Correct"] = 0)
        ] = "Correct";
        DataType[
          (DataType["Wrong"] = 1)
        ] = "Wrong";
      })(
        DataType ||
          (exports.DataType = DataType =
            {}),
      );
      function getSchemaTypes(schema) {
        const types = getJSONTypes(
          schema.type,
        );
        if (types.includes("null")) {
          if (schema.nullable === false)
            throw new Error(
              "type: null contradicts nullable: false",
            );
        } else {
          if (
            !types.length &&
            schema.nullable !== void 0
          )
            throw new Error(
              '"nullable" cannot be used without "type"',
            );
          if (schema.nullable === true)
            types.push("null");
        }
        return types;
      }
      exports.getSchemaTypes =
        getSchemaTypes;
      function getJSONTypes(ts) {
        const types = Array.isArray(ts)
          ? ts
          : ts
            ? [ts]
            : [];
        if (
          types.every(
            rules_1.isJSONType,
          )
        )
          return types;
        throw new Error(
          "type must be JSONType or JSONType[]: " +
            types.join(","),
        );
      }
      exports.getJSONTypes =
        getJSONTypes;
      function coerceAndCheckDataType(
        it,
        types,
      ) {
        const { gen, data, opts } = it;
        const coerceTo = coerceToTypes(
          types,
          opts.coerceTypes,
        );
        const checkTypes =
          types.length > 0 &&
          !(
            coerceTo.length === 0 &&
            types.length === 1 &&
            (0,
            applicability_1.schemaHasRulesForType)(
              it,
              types[0],
            )
          );
        if (checkTypes) {
          const wrongType =
            checkDataTypes(
              types,
              data,
              opts.strictNumbers,
              DataType.Wrong,
            );
          gen.if(wrongType, () => {
            if (coerceTo.length)
              coerceData(
                it,
                types,
                coerceTo,
              );
            else reportTypeError(it);
          });
        }
        return checkTypes;
      }
      exports.coerceAndCheckDataType =
        coerceAndCheckDataType;
      const 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;
      const typeError = {
        message: ({ schema }) =>
          `must be ${schema}`,
        params: ({
          schema,
          schemaValue,
        }) =>
          typeof schema == "string"
            ? (0,
              codegen_1._)`{type: ${schema}}`
            : (0,
              codegen_1._)`{type: ${schemaValue}}`,
      };
      function reportTypeError(it) {
        const cxt =
          getTypeErrorContext(it);
        (0, errors_1.reportError)(
          cxt,
          typeError,
        );
      }
      exports.reportTypeError =
        reportTypeError;
      function getTypeErrorContext(it) {
        const { gen, data, schema } =
          it;
        const schemaCode = (0,
        util_1.schemaRefOrVal)(
          it,
          schema,
          "type",
        );
        return {
          gen,
          keyword: "type",
          data,
          schema: schema.type,
          schemaCode,
          schemaValue: schemaCode,
          parentSchema: schema,
          params: {},
          it,
        };
      }
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/defaults.js
var require_defaults =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.assignDefaults = void 0;
      const codegen_1 =
        require_codegen();
      const util_1 = require_util();
      function assignDefaults(it, ty) {
        const { properties, items } =
          it.schema;
        if (
          ty === "object" &&
          properties
        )
          for (const key in properties)
            assignDefault(
              it,
              key,
              properties[key].default,
            );
        else if (
          ty === "array" &&
          Array.isArray(items)
        )
          items.forEach((sch, i) =>
            assignDefault(
              it,
              i,
              sch.default,
            ),
          );
      }
      exports.assignDefaults =
        assignDefaults;
      function assignDefault(
        it,
        prop,
        defaultValue,
      ) {
        const {
          gen,
          compositeRule,
          data,
          opts,
        } = it;
        if (defaultValue === void 0)
          return;
        const childData = (0,
        codegen_1._)`${data}${(0, codegen_1.getProperty)(prop)}`;
        if (compositeRule) {
          (0, util_1.checkStrictMode)(
            it,
            `default is ignored for: ${childData}`,
          );
          return;
        }
        let condition = (0,
        codegen_1._)`${childData} === undefined`;
        if (
          opts.useDefaults === "empty"
        )
          condition = (0,
          codegen_1._)`${condition} || ${childData} === null || ${childData} === ""`;
        gen.if(
          condition,
          (0,
          codegen_1._)`${childData} = ${(0, codegen_1.stringify)(defaultValue)}`,
        );
      }
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/code.js
var require_code =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.validateUnion =
        exports.validateArray =
        exports.usePattern =
        exports.callValidateCode =
        exports.schemaProperties =
        exports.allSchemaProperties =
        exports.noPropertyInData =
        exports.propertyInData =
        exports.isOwnProperty =
        exports.hasPropFunc =
        exports.reportMissingProp =
        exports.checkMissingProp =
        exports.checkReportMissingProp =
          void 0;
      const codegen_1 =
        require_codegen();
      const util_1 = require_util();
      const names_1 = require_names();
      const util_2 = require_util();
      function checkReportMissingProp(
        cxt,
        prop,
      ) {
        const { gen, data, it } = cxt;
        gen.if(
          noPropertyInData(
            gen,
            data,
            prop,
            it.opts.ownProperties,
          ),
          () => {
            cxt.setParams(
              {
                missingProperty: (0,
                codegen_1._)`${prop}`,
              },
              true,
            );
            cxt.error();
          },
        );
      }
      exports.checkReportMissingProp =
        checkReportMissingProp;
      function checkMissingProp(
        { gen, data, it: { opts } },
        properties,
        missing,
      ) {
        return (0, codegen_1.or)(
          ...properties.map((prop) =>
            (0, codegen_1.and)(
              noPropertyInData(
                gen,
                data,
                prop,
                opts.ownProperties,
              ),
              (0,
              codegen_1._)`${missing} = ${prop}`,
            ),
          ),
        );
      }
      exports.checkMissingProp =
        checkMissingProp;
      function reportMissingProp(
        cxt,
        missing,
      ) {
        cxt.setParams(
          { missingProperty: missing },
          true,
        );
        cxt.error();
      }
      exports.reportMissingProp =
        reportMissingProp;
      function hasPropFunc(gen) {
        return gen.scopeValue("func", {
          ref: Object.prototype
            .hasOwnProperty,
          code: (0,
          codegen_1._)`Object.prototype.hasOwnProperty`,
        });
      }
      exports.hasPropFunc = hasPropFunc;
      function isOwnProperty(
        gen,
        data,
        property,
      ) {
        return (0,
        codegen_1._)`${hasPropFunc(gen)}.call(${data}, ${property})`;
      }
      exports.isOwnProperty =
        isOwnProperty;
      function propertyInData(
        gen,
        data,
        property,
        ownProperties,
      ) {
        const cond = (0,
        codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} !== undefined`;
        return ownProperties
          ? (0,
            codegen_1._)`${cond} && ${isOwnProperty(gen, data, property)}`
          : cond;
      }
      exports.propertyInData =
        propertyInData;
      function noPropertyInData(
        gen,
        data,
        property,
        ownProperties,
      ) {
        const cond = (0,
        codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} === undefined`;
        return ownProperties
          ? (0, codegen_1.or)(
              cond,
              (0, codegen_1.not)(
                isOwnProperty(
                  gen,
                  data,
                  property,
                ),
              ),
            )
          : cond;
      }
      exports.noPropertyInData =
        noPropertyInData;
      function allSchemaProperties(
        schemaMap,
      ) {
        return schemaMap
          ? Object.keys(
              schemaMap,
            ).filter(
              (p) => p !== "__proto__",
            )
          : [];
      }
      exports.allSchemaProperties =
        allSchemaProperties;
      function schemaProperties(
        it,
        schemaMap,
      ) {
        return allSchemaProperties(
          schemaMap,
        ).filter(
          (p) =>
            !(0,
            util_1.alwaysValidSchema)(
              it,
              schemaMap[p],
            ),
        );
      }
      exports.schemaProperties =
        schemaProperties;
      function callValidateCode(
        {
          schemaCode,
          data,
          it: {
            gen,
            topSchemaRef,
            schemaPath,
            errorPath,
          },
          it,
        },
        func,
        context,
        passSchema,
      ) {
        const dataAndSchema = passSchema
          ? (0,
            codegen_1._)`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}`
          : data;
        const valCxt = [
          [
            names_1.default
              .instancePath,
            (0, codegen_1.strConcat)(
              names_1.default
                .instancePath,
              errorPath,
            ),
          ],
          [
            names_1.default.parentData,
            it.parentData,
          ],
          [
            names_1.default
              .parentDataProperty,
            it.parentDataProperty,
          ],
          [
            names_1.default.rootData,
            names_1.default.rootData,
          ],
        ];
        if (it.opts.dynamicRef)
          valCxt.push([
            names_1.default
              .dynamicAnchors,
            names_1.default
              .dynamicAnchors,
          ]);
        const args = (0,
        codegen_1._)`${dataAndSchema}, ${gen.object(...valCxt)}`;
        return context !== codegen_1.nil
          ? (0,
            codegen_1._)`${func}.call(${context}, ${args})`
          : (0,
            codegen_1._)`${func}(${args})`;
      }
      exports.callValidateCode =
        callValidateCode;
      const newRegExp = (0,
      codegen_1._)`new RegExp`;
      function usePattern(
        { gen, it: { opts } },
        pattern,
      ) {
        const u = opts.unicodeRegExp
          ? "u"
          : "";
        const { regExp } = opts.code;
        const rx = regExp(pattern, u);
        return gen.scopeValue(
          "pattern",
          {
            key: rx.toString(),
            ref: rx,
            code: (0,
            codegen_1._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern}, ${u})`,
          },
        );
      }
      exports.usePattern = usePattern;
      function validateArray(cxt) {
        const {
          gen,
          data,
          keyword,
          it,
        } = cxt;
        const valid = gen.name("valid");
        if (it.allErrors) {
          const validArr = gen.let(
            "valid",
            true,
          );
          validateItems(() =>
            gen.assign(validArr, false),
          );
          return validArr;
        }
        gen.var(valid, true);
        validateItems(() =>
          gen.break(),
        );
        return valid;
        function validateItems(
          notValid,
        ) {
          const len = gen.const(
            "len",
            (0,
            codegen_1._)`${data}.length`,
          );
          gen.forRange(
            "i",
            0,
            len,
            (i) => {
              cxt.subschema(
                {
                  keyword,
                  dataProp: i,
                  dataPropType:
                    util_1.Type.Num,
                },
                valid,
              );
              gen.if(
                (0, codegen_1.not)(
                  valid,
                ),
                notValid,
              );
            },
          );
        }
      }
      exports.validateArray =
        validateArray;
      function validateUnion(cxt) {
        const {
          gen,
          schema,
          keyword,
          it,
        } = cxt;
        /* istanbul ignore if */
        if (!Array.isArray(schema))
          throw new Error(
            "ajv implementation error",
          );
        if (
          schema.some((sch) =>
            (0,
            util_1.alwaysValidSchema)(
              it,
              sch,
            ),
          ) &&
          !it.opts.unevaluated
        )
          return;
        const valid = gen.let(
          "valid",
          false,
        );
        const schValid =
          gen.name("_valid");
        gen.block(() =>
          schema.forEach((_sch, i) => {
            const schCxt =
              cxt.subschema(
                {
                  keyword,
                  schemaProp: i,
                  compositeRule: true,
                },
                schValid,
              );
            gen.assign(
              valid,
              (0,
              codegen_1._)`${valid} || ${schValid}`,
            );
            if (
              !cxt.mergeValidEvaluated(
                schCxt,
                schValid,
              )
            )
              gen.if(
                (0, codegen_1.not)(
                  valid,
                ),
              );
          }),
        );
        cxt.result(
          valid,
          () => cxt.reset(),
          () => cxt.error(true),
        );
      }
      exports.validateUnion =
        validateUnion;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/keyword.js
var require_keyword =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.validateKeywordUsage =
        exports.validSchemaType =
        exports.funcKeywordCode =
        exports.macroKeywordCode =
          void 0;
      const codegen_1 =
        require_codegen();
      const names_1 = require_names();
      const code_1 = require_code();
      const errors_1 = require_errors();
      function macroKeywordCode(
        cxt,
        def,
      ) {
        const {
          gen,
          keyword,
          schema,
          parentSchema,
          it,
        } = cxt;
        const macroSchema =
          def.macro.call(
            it.self,
            schema,
            parentSchema,
            it,
          );
        const schemaRef = useKeyword(
          gen,
          keyword,
          macroSchema,
        );
        if (
          it.opts.validateSchema !==
          false
        )
          it.self.validateSchema(
            macroSchema,
            true,
          );
        const valid = gen.name("valid");
        cxt.subschema(
          {
            schema: macroSchema,
            schemaPath: codegen_1.nil,
            errSchemaPath: `${it.errSchemaPath}/${keyword}`,
            topSchemaRef: schemaRef,
            compositeRule: true,
          },
          valid,
        );
        cxt.pass(valid, () =>
          cxt.error(true),
        );
      }
      exports.macroKeywordCode =
        macroKeywordCode;
      function funcKeywordCode(
        cxt,
        def,
      ) {
        var _a;
        const {
          gen,
          keyword,
          schema,
          parentSchema,
          $data,
          it,
        } = cxt;
        checkAsyncKeyword(it, def);
        const validateRef = useKeyword(
          gen,
          keyword,
          !$data && def.compile
            ? def.compile.call(
                it.self,
                schema,
                parentSchema,
                it,
              )
            : def.validate,
        );
        const valid = gen.let("valid");
        cxt.block$data(
          valid,
          validateKeyword,
        );
        cxt.ok(
          (_a = def.valid) !== null &&
            _a !== void 0
            ? _a
            : valid,
        );
        function validateKeyword() {
          if (def.errors === false) {
            assignValid();
            if (def.modifying)
              modifyData(cxt);
            reportErrs(() =>
              cxt.error(),
            );
          } else {
            const ruleErrs = def.async
              ? validateAsync()
              : validateSync();
            if (def.modifying)
              modifyData(cxt);
            reportErrs(() =>
              addErrs(cxt, ruleErrs),
            );
          }
        }
        function validateAsync() {
          const ruleErrs = gen.let(
            "ruleErrs",
            null,
          );
          gen.try(
            () =>
              assignValid(
                (0,
                codegen_1._)`await `,
              ),
            (e) =>
              gen
                .assign(valid, false)
                .if(
                  (0,
                  codegen_1._)`${e} instanceof ${it.ValidationError}`,
                  () =>
                    gen.assign(
                      ruleErrs,
                      (0,
                      codegen_1._)`${e}.errors`,
                    ),
                  () => gen.throw(e),
                ),
          );
          return ruleErrs;
        }
        function validateSync() {
          const validateErrs = (0,
          codegen_1._)`${validateRef}.errors`;
          gen.assign(
            validateErrs,
            null,
          );
          assignValid(codegen_1.nil);
          return validateErrs;
        }
        function assignValid(
          _await = def.async
            ? (0, codegen_1._)`await `
            : codegen_1.nil,
        ) {
          const passCxt = it.opts
            .passContext
            ? names_1.default.this
            : names_1.default.self;
          const passSchema = !(
            ("compile" in def &&
              !$data) ||
            def.schema === false
          );
          gen.assign(
            valid,
            (0,
            codegen_1._)`${_await}${(0, code_1.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`,
            def.modifying,
          );
        }
        function reportErrs(errors) {
          var _a;
          gen.if(
            (0, codegen_1.not)(
              (_a = def.valid) !==
                null && _a !== void 0
                ? _a
                : valid,
            ),
            errors,
          );
        }
      }
      exports.funcKeywordCode =
        funcKeywordCode;
      function modifyData(cxt) {
        const { gen, data, it } = cxt;
        gen.if(it.parentData, () =>
          gen.assign(
            data,
            (0,
            codegen_1._)`${it.parentData}[${it.parentDataProperty}]`,
          ),
        );
      }
      function addErrs(cxt, errs) {
        const { gen } = cxt;
        gen.if(
          (0,
          codegen_1._)`Array.isArray(${errs})`,
          () => {
            gen
              .assign(
                names_1.default.vErrors,
                (0,
                codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`,
              )
              .assign(
                names_1.default.errors,
                (0,
                codegen_1._)`${names_1.default.vErrors}.length`,
              );
            (0, errors_1.extendErrors)(
              cxt,
            );
          },
          () => cxt.error(),
        );
      }
      function checkAsyncKeyword(
        { schemaEnv },
        def,
      ) {
        if (
          def.async &&
          !schemaEnv.$async
        )
          throw new Error(
            "async keyword in sync schema",
          );
      }
      function useKeyword(
        gen,
        keyword,
        result,
      ) {
        if (result === void 0)
          throw new Error(
            `keyword "${keyword}" failed to compile`,
          );
        return gen.scopeValue(
          "keyword",
          typeof result == "function"
            ? { ref: result }
            : {
                ref: result,
                code: (0,
                codegen_1.stringify)(
                  result,
                ),
              },
        );
      }
      function validSchemaType(
        schema,
        schemaType,
        allowUndefined = false,
      ) {
        return (
          !schemaType.length ||
          schemaType.some((st) =>
            st === "array"
              ? Array.isArray(schema)
              : st === "object"
                ? schema &&
                  typeof schema ==
                    "object" &&
                  !Array.isArray(schema)
                : typeof schema == st ||
                  (allowUndefined &&
                    typeof schema ==
                      "undefined"),
          )
        );
      }
      exports.validSchemaType =
        validSchemaType;
      function validateKeywordUsage(
        {
          schema,
          opts,
          self,
          errSchemaPath,
        },
        def,
        keyword,
      ) {
        /* istanbul ignore if */
        if (
          Array.isArray(def.keyword)
            ? !def.keyword.includes(
                keyword,
              )
            : def.keyword !== keyword
        )
          throw new Error(
            "ajv implementation error",
          );
        const deps = def.dependencies;
        if (
          deps === null ||
          deps === void 0
            ? void 0
            : deps.some(
                (kwd) =>
                  !Object.prototype.hasOwnProperty.call(
                    schema,
                    kwd,
                  ),
              )
        )
          throw new Error(
            `parent schema must have dependencies of ${keyword}: ${deps.join(",")}`,
          );
        if (def.validateSchema) {
          if (
            !def.validateSchema(
              schema[keyword],
            )
          ) {
            const msg =
              `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` +
              self.errorsText(
                def.validateSchema
                  .errors,
              );
            if (
              opts.validateSchema ===
              "log"
            )
              self.logger.error(msg);
            else throw new Error(msg);
          }
        }
      }
      exports.validateKeywordUsage =
        validateKeywordUsage;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/subschema.js
var require_subschema =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.extendSubschemaMode =
        exports.extendSubschemaData =
        exports.getSubschema =
          void 0;
      const codegen_1 =
        require_codegen();
      const util_1 = require_util();
      function getSubschema(
        it,
        {
          keyword,
          schemaProp,
          schema,
          schemaPath,
          errSchemaPath,
          topSchemaRef,
        },
      ) {
        if (
          keyword !== void 0 &&
          schema !== void 0
        )
          throw new Error(
            'both "keyword" and "schema" passed, only one allowed',
          );
        if (keyword !== void 0) {
          const sch =
            it.schema[keyword];
          return schemaProp === void 0
            ? {
                schema: sch,
                schemaPath: (0,
                codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}`,
                errSchemaPath: `${it.errSchemaPath}/${keyword}`,
              }
            : {
                schema: sch[schemaProp],
                schemaPath: (0,
                codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}${(0, codegen_1.getProperty)(schemaProp)}`,
                errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}`,
              };
        }
        if (schema !== void 0) {
          if (
            schemaPath === void 0 ||
            errSchemaPath === void 0 ||
            topSchemaRef === void 0
          )
            throw new Error(
              '"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"',
            );
          return {
            schema,
            schemaPath,
            topSchemaRef,
            errSchemaPath,
          };
        }
        throw new Error(
          'either "keyword" or "schema" must be passed',
        );
      }
      exports.getSubschema =
        getSubschema;
      function extendSubschemaData(
        subschema,
        it,
        {
          dataProp,
          dataPropType: dpType,
          data,
          dataTypes,
          propertyName,
        },
      ) {
        if (
          data !== void 0 &&
          dataProp !== void 0
        )
          throw new Error(
            'both "data" and "dataProp" passed, only one allowed',
          );
        const { gen } = it;
        if (dataProp !== void 0) {
          const {
            errorPath,
            dataPathArr,
            opts,
          } = it;
          dataContextProps(
            gen.let(
              "data",
              (0,
              codegen_1._)`${it.data}${(0, codegen_1.getProperty)(dataProp)}`,
              true,
            ),
          );
          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) {
          dataContextProps(
            data instanceof
              codegen_1.Name
              ? data
              : gen.let(
                  "data",
                  data,
                  true,
                ),
          );
          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;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js
var require_fast_deep_equal =
  /* @__PURE__ */ __commonJSMin(
    (exports, module) => {
      module.exports = function equal(
        a,
        b,
      ) {
        if (a === b) return true;
        if (
          a &&
          b &&
          typeof a == "object" &&
          typeof b == "object"
        ) {
          if (
            a.constructor !==
            b.constructor
          )
            return false;
          var length, i, keys;
          if (Array.isArray(a)) {
            length = a.length;
            if (length != b.length)
              return false;
            for (i = length; i-- !== 0;)
              if (!equal(a[i], b[i]))
                return false;
            return true;
          }
          if (a.constructor === RegExp)
            return (
              a.source === b.source &&
              a.flags === b.flags
            );
          if (
            a.valueOf !==
            Object.prototype.valueOf
          )
            return (
              a.valueOf() ===
              b.valueOf()
            );
          if (
            a.toString !==
            Object.prototype.toString
          )
            return (
              a.toString() ===
              b.toString()
            );
          keys = Object.keys(a);
          length = keys.length;
          if (
            length !==
            Object.keys(b).length
          )
            return false;
          for (i = length; i-- !== 0;)
            if (
              !Object.prototype.hasOwnProperty.call(
                b,
                keys[i],
              )
            )
              return false;
          for (i = length; i-- !== 0;) {
            var key = keys[i];
            if (!equal(a[key], b[key]))
              return false;
          }
          return true;
        }
        return a !== a && b !== b;
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/json-schema-traverse@1.0.0/node_modules/json-schema-traverse/index.js
var require_json_schema_traverse =
  /* @__PURE__ */ __commonJSMin(
    (exports, module) => {
      var traverse = (module.exports =
        function (schema, opts, cb) {
          if (
            typeof opts == "function"
          ) {
            cb = opts;
            opts = {};
          }
          cb = opts.cb || cb;
          var pre =
            typeof cb == "function"
              ? cb
              : cb.pre ||
                function () {};
          var post =
            cb.post || function () {};
          _traverse(
            opts,
            pre,
            post,
            schema,
            "",
            schema,
          );
        });
      traverse.keywords = {
        additionalItems: true,
        items: true,
        contains: true,
        additionalProperties: true,
        propertyNames: true,
        not: true,
        if: true,
        then: true,
        else: true,
      };
      traverse.arrayKeywords = {
        items: true,
        allOf: true,
        anyOf: true,
        oneOf: true,
      };
      traverse.propsKeywords = {
        $defs: true,
        definitions: true,
        properties: true,
        patternProperties: true,
        dependencies: true,
      };
      traverse.skipKeywords = {
        default: true,
        enum: true,
        const: true,
        required: true,
        maximum: true,
        minimum: true,
        exclusiveMaximum: true,
        exclusiveMinimum: true,
        multipleOf: true,
        maxLength: true,
        minLength: true,
        pattern: true,
        format: true,
        maxItems: true,
        minItems: true,
        uniqueItems: true,
        maxProperties: true,
        minProperties: true,
      };
      function _traverse(
        opts,
        pre,
        post,
        schema,
        jsonPtr,
        rootSchema,
        parentJsonPtr,
        parentKeyword,
        parentSchema,
        keyIndex,
      ) {
        if (
          schema &&
          typeof schema == "object" &&
          !Array.isArray(schema)
        ) {
          pre(
            schema,
            jsonPtr,
            rootSchema,
            parentJsonPtr,
            parentKeyword,
            parentSchema,
            keyIndex,
          );
          for (var key in schema) {
            var sch = schema[key];
            if (Array.isArray(sch)) {
              if (
                key in
                traverse.arrayKeywords
              )
                for (
                  var i = 0;
                  i < sch.length;
                  i++
                )
                  _traverse(
                    opts,
                    pre,
                    post,
                    sch[i],
                    jsonPtr +
                      "/" +
                      key +
                      "/" +
                      i,
                    rootSchema,
                    jsonPtr,
                    key,
                    schema,
                    i,
                  );
            } else if (
              key in
              traverse.propsKeywords
            ) {
              if (
                sch &&
                typeof sch == "object"
              )
                for (var prop in sch)
                  _traverse(
                    opts,
                    pre,
                    post,
                    sch[prop],
                    jsonPtr +
                      "/" +
                      key +
                      "/" +
                      escapeJsonPtr(
                        prop,
                      ),
                    rootSchema,
                    jsonPtr,
                    key,
                    schema,
                    prop,
                  );
            } else if (
              key in
                traverse.keywords ||
              (opts.allKeys &&
                !(
                  key in
                  traverse.skipKeywords
                ))
            )
              _traverse(
                opts,
                pre,
                post,
                sch,
                jsonPtr + "/" + key,
                rootSchema,
                jsonPtr,
                key,
                schema,
              );
          }
          post(
            schema,
            jsonPtr,
            rootSchema,
            parentJsonPtr,
            parentKeyword,
            parentSchema,
            keyIndex,
          );
        }
      }
      function escapeJsonPtr(str) {
        return str
          .replace(/~/g, "~0")
          .replace(/\//g, "~1");
      }
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/resolve.js
var require_resolve =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.getSchemaRefs =
        exports.resolveUrl =
        exports.normalizeId =
        exports._getFullPath =
        exports.getFullPath =
        exports.inlineRef =
          void 0;
      const util_1 = require_util();
      const equal =
        require_fast_deep_equal();
      const traverse =
        require_json_schema_traverse();
      const SIMPLE_INLINED =
        /* @__PURE__ */ new Set([
          "type",
          "format",
          "pattern",
          "maxLength",
          "minLength",
          "maxProperties",
          "minProperties",
          "maxItems",
          "minItems",
          "maximum",
          "minimum",
          "uniqueItems",
          "multipleOf",
          "required",
          "enum",
          "const",
        ]);
      function inlineRef(
        schema,
        limit = true,
      ) {
        if (typeof schema == "boolean")
          return true;
        if (limit === true)
          return !hasRef(schema);
        if (!limit) return false;
        return (
          countKeys(schema) <= limit
        );
      }
      exports.inlineRef = inlineRef;
      const REF_KEYWORDS =
        /* @__PURE__ */ new Set([
          "$ref",
          "$recursiveRef",
          "$recursiveAnchor",
          "$dynamicRef",
          "$dynamicAnchor",
        ]);
      function hasRef(schema) {
        for (const key in schema) {
          if (REF_KEYWORDS.has(key))
            return true;
          const sch = schema[key];
          if (
            Array.isArray(sch) &&
            sch.some(hasRef)
          )
            return true;
          if (
            typeof sch == "object" &&
            hasRef(sch)
          )
            return true;
        }
        return false;
      }
      function countKeys(schema) {
        let count = 0;
        for (const key in schema) {
          if (key === "$ref")
            return Infinity;
          count++;
          if (SIMPLE_INLINED.has(key))
            continue;
          if (
            typeof schema[key] ==
            "object"
          )
            (0, util_1.eachItem)(
              schema[key],
              (sch) =>
                (count +=
                  countKeys(sch)),
            );
          if (count === Infinity)
            return Infinity;
        }
        return count;
      }
      function getFullPath(
        resolver,
        id = "",
        normalize,
      ) {
        if (normalize !== false)
          id = normalizeId(id);
        return _getFullPath(
          resolver,
          resolver.parse(id),
        );
      }
      exports.getFullPath = getFullPath;
      function _getFullPath(
        resolver,
        p,
      ) {
        return (
          resolver
            .serialize(p)
            .split("#")[0] + "#"
        );
      }
      exports._getFullPath =
        _getFullPath;
      const 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;
      const ANCHOR =
        /^[a-z_][-a-z0-9._]*$/i;
      function getSchemaRefs(
        schema,
        baseId,
      ) {
        if (typeof schema == "boolean")
          return {};
        const {
          schemaId,
          uriResolver,
        } = this.opts;
        const schId = normalizeId(
          schema[schemaId] || baseId,
        );
        const baseIds = { "": schId };
        const pathPrefix = getFullPath(
          uriResolver,
          schId,
          false,
        );
        const localRefs = {};
        const schemaRefs =
          /* @__PURE__ */ new Set();
        traverse(
          schema,
          { allKeys: true },
          (
            sch,
            jsonPtr,
            _,
            parentJsonPtr,
          ) => {
            if (
              parentJsonPtr === void 0
            )
              return;
            const fullPath =
              pathPrefix + jsonPtr;
            let innerBaseId =
              baseIds[parentJsonPtr];
            if (
              typeof sch[schemaId] ==
              "string"
            )
              innerBaseId = addRef.call(
                this,
                sch[schemaId],
              );
            addAnchor.call(
              this,
              sch.$anchor,
            );
            addAnchor.call(
              this,
              sch.$dynamicAnchor,
            );
            baseIds[jsonPtr] =
              innerBaseId;
            function addRef(ref) {
              const _resolve =
                this.opts.uriResolver
                  .resolve;
              ref = normalizeId(
                innerBaseId
                  ? _resolve(
                      innerBaseId,
                      ref,
                    )
                  : ref,
              );
              if (schemaRefs.has(ref))
                throw ambiguos(ref);
              schemaRefs.add(ref);
              let schOrRef =
                this.refs[ref];
              if (
                typeof schOrRef ==
                "string"
              )
                schOrRef =
                  this.refs[schOrRef];
              if (
                typeof schOrRef ==
                "object"
              )
                checkAmbiguosRef(
                  sch,
                  schOrRef.schema,
                  ref,
                );
              else if (
                ref !==
                normalizeId(fullPath)
              ) {
                if (ref[0] === "#") {
                  checkAmbiguosRef(
                    sch,
                    localRefs[ref],
                    ref,
                  );
                  localRefs[ref] = sch;
                } else
                  this.refs[ref] =
                    fullPath;
              }
              return ref;
            }
            function addAnchor(anchor) {
              if (
                typeof anchor ==
                "string"
              ) {
                if (
                  !ANCHOR.test(anchor)
                )
                  throw new Error(
                    `invalid anchor "${anchor}"`,
                  );
                addRef.call(
                  this,
                  `#${anchor}`,
                );
              }
            }
          },
        );
        return localRefs;
        function checkAmbiguosRef(
          sch1,
          sch2,
          ref,
        ) {
          if (
            sch2 !== void 0 &&
            !equal(sch1, sch2)
          )
            throw ambiguos(ref);
        }
        function ambiguos(ref) {
          return /* @__PURE__ */ new Error(
            `reference "${ref}" resolves to more than one schema`,
          );
        }
      }
      exports.getSchemaRefs =
        getSchemaRefs;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/index.js
var require_validate =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.getData =
        exports.KeywordCxt =
        exports.validateFunctionCode =
          void 0;
      const boolSchema_1 =
        require_boolSchema();
      const dataType_1 =
        require_dataType();
      const applicability_1 =
        require_applicability();
      const dataType_2 =
        require_dataType();
      const defaults_1 =
        require_defaults();
      const keyword_1 =
        require_keyword();
      const subschema_1 =
        require_subschema();
      const codegen_1 =
        require_codegen();
      const names_1 = require_names();
      const resolve_1 =
        require_resolve();
      const util_1 = require_util();
      const errors_1 = require_errors();
      function validateFunctionCode(
        it,
      ) {
        if (isSchemaObj(it)) {
          checkKeywords(it);
          if (schemaCxtHasRules(it)) {
            topSchemaObjCode(it);
            return;
          }
        }
        validateFunction(it, () =>
          (0,
          boolSchema_1.topBoolOrEmptySchema)(
            it,
          ),
        );
      }
      exports.validateFunctionCode =
        validateFunctionCode;
      function validateFunction(
        {
          gen,
          validateName,
          schema,
          schemaEnv,
          opts,
        },
        body,
      ) {
        if (opts.code.es5)
          gen.func(
            validateName,
            (0,
            codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`,
            schemaEnv.$async,
            () => {
              gen.code(
                (0,
                codegen_1._)`"use strict"; ${funcSourceUrl(schema, opts)}`,
              );
              destructureValCxtES5(
                gen,
                opts,
              );
              gen.code(body);
            },
          );
        else
          gen.func(
            validateName,
            (0,
            codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`,
            schemaEnv.$async,
            () =>
              gen
                .code(
                  funcSourceUrl(
                    schema,
                    opts,
                  ),
                )
                .code(body),
          );
      }
      function destructureValCxt(opts) {
        return (0,
        codegen_1._)`{${names_1.default.instancePath}="", ${names_1.default.parentData}, ${names_1.default.parentDataProperty}, ${names_1.default.rootData}=${names_1.default.data}${opts.dynamicRef ? (0, codegen_1._)`, ${names_1.default.dynamicAnchors}={}` : codegen_1.nil}}={}`;
      }
      function destructureValCxtES5(
        gen,
        opts,
      ) {
        gen.if(
          names_1.default.valCxt,
          () => {
            gen.var(
              names_1.default
                .instancePath,
              (0,
              codegen_1._)`${names_1.default.valCxt}.${names_1.default.instancePath}`,
            );
            gen.var(
              names_1.default
                .parentData,
              (0,
              codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentData}`,
            );
            gen.var(
              names_1.default
                .parentDataProperty,
              (0,
              codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentDataProperty}`,
            );
            gen.var(
              names_1.default.rootData,
              (0,
              codegen_1._)`${names_1.default.valCxt}.${names_1.default.rootData}`,
            );
            if (opts.dynamicRef)
              gen.var(
                names_1.default
                  .dynamicAnchors,
                (0,
                codegen_1._)`${names_1.default.valCxt}.${names_1.default.dynamicAnchors}`,
              );
          },
          () => {
            gen.var(
              names_1.default
                .instancePath,
              (0, codegen_1._)`""`,
            );
            gen.var(
              names_1.default
                .parentData,
              (0,
              codegen_1._)`undefined`,
            );
            gen.var(
              names_1.default
                .parentDataProperty,
              (0,
              codegen_1._)`undefined`,
            );
            gen.var(
              names_1.default.rootData,
              names_1.default.data,
            );
            if (opts.dynamicRef)
              gen.var(
                names_1.default
                  .dynamicAnchors,
                (0, codegen_1._)`{}`,
              );
          },
        );
      }
      function topSchemaObjCode(it) {
        const { schema, opts, gen } =
          it;
        validateFunction(it, () => {
          if (
            opts.$comment &&
            schema.$comment
          )
            commentKeyword(it);
          checkNoDefault(it);
          gen.let(
            names_1.default.vErrors,
            null,
          );
          gen.let(
            names_1.default.errors,
            0,
          );
          if (opts.unevaluated)
            resetEvaluated(it);
          typeAndKeywords(it);
          returnResults(it);
        });
      }
      function resetEvaluated(it) {
        const { gen, validateName } =
          it;
        it.evaluated = gen.const(
          "evaluated",
          (0,
          codegen_1._)`${validateName}.evaluated`,
        );
        gen.if(
          (0,
          codegen_1._)`${it.evaluated}.dynamicProps`,
          () =>
            gen.assign(
              (0,
              codegen_1._)`${it.evaluated}.props`,
              (0,
              codegen_1._)`undefined`,
            ),
        );
        gen.if(
          (0,
          codegen_1._)`${it.evaluated}.dynamicItems`,
          () =>
            gen.assign(
              (0,
              codegen_1._)`${it.evaluated}.items`,
              (0,
              codegen_1._)`undefined`,
            ),
        );
      }
      function funcSourceUrl(
        schema,
        opts,
      ) {
        const schId =
          typeof schema == "object" &&
          schema[opts.schemaId];
        return schId &&
          (opts.code.source ||
            opts.code.process)
          ? (0,
            codegen_1._)`/*# sourceURL=${schId} */`
          : codegen_1.nil;
      }
      function subschemaCode(
        it,
        valid,
      ) {
        if (isSchemaObj(it)) {
          checkKeywords(it);
          if (schemaCxtHasRules(it)) {
            subSchemaObjCode(it, valid);
            return;
          }
        }
        (0,
        boolSchema_1.boolOrEmptySchema)(
          it,
          valid,
        );
      }
      function schemaCxtHasRules({
        schema,
        self,
      }) {
        if (typeof schema == "boolean")
          return !schema;
        for (const key in schema)
          if (self.RULES.all[key])
            return true;
        return false;
      }
      function isSchemaObj(it) {
        return (
          typeof it.schema != "boolean"
        );
      }
      function subSchemaObjCode(
        it,
        valid,
      ) {
        const { schema, gen, opts } =
          it;
        if (
          opts.$comment &&
          schema.$comment
        )
          commentKeyword(it);
        updateContext(it);
        checkAsyncSchema(it);
        const errsCount = gen.const(
          "_errs",
          names_1.default.errors,
        );
        typeAndKeywords(it, errsCount);
        gen.var(
          valid,
          (0,
          codegen_1._)`${errsCount} === ${names_1.default.errors}`,
        );
      }
      function checkKeywords(it) {
        (0, util_1.checkUnknownRules)(
          it,
        );
        checkRefsAndKeywords(it);
      }
      function typeAndKeywords(
        it,
        errsCount,
      ) {
        if (it.opts.jtd)
          return schemaKeywords(
            it,
            [],
            false,
            errsCount,
          );
        const types = (0,
        dataType_1.getSchemaTypes)(
          it.schema,
        );
        schemaKeywords(
          it,
          types,
          !(0,
          dataType_1.coerceAndCheckDataType)(
            it,
            types,
          ),
          errsCount,
        );
      }
      function checkRefsAndKeywords(
        it,
      ) {
        const {
          schema,
          errSchemaPath,
          opts,
          self,
        } = it;
        if (
          schema.$ref &&
          opts.ignoreKeywordsWithRef &&
          (0,
          util_1.schemaHasRulesButRef)(
            schema,
            self.RULES,
          )
        )
          self.logger.warn(
            `$ref: keywords ignored in schema at path "${errSchemaPath}"`,
          );
      }
      function checkNoDefault(it) {
        const { schema, opts } = it;
        if (
          schema.default !== void 0 &&
          opts.useDefaults &&
          opts.strictSchema
        )
          (0, util_1.checkStrictMode)(
            it,
            "default is ignored in the schema root",
          );
      }
      function updateContext(it) {
        const schId =
          it.schema[it.opts.schemaId];
        if (schId)
          it.baseId = (0,
          resolve_1.resolveUrl)(
            it.opts.uriResolver,
            it.baseId,
            schId,
          );
      }
      function checkAsyncSchema(it) {
        if (
          it.schema.$async &&
          !it.schemaEnv.$async
        )
          throw new Error(
            "async schema in sync schema",
          );
      }
      function commentKeyword({
        gen,
        schemaEnv,
        schema,
        errSchemaPath,
        opts,
      }) {
        const msg = schema.$comment;
        if (opts.$comment === true)
          gen.code(
            (0,
            codegen_1._)`${names_1.default.self}.logger.log(${msg})`,
          );
        else if (
          typeof opts.$comment ==
          "function"
        ) {
          const schemaPath = (0,
          codegen_1.str)`${errSchemaPath}/$comment`;
          const rootName =
            gen.scopeValue("root", {
              ref: schemaEnv.root,
            });
          gen.code(
            (0,
            codegen_1._)`${names_1.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`,
          );
        }
      }
      function returnResults(it) {
        const {
          gen,
          schemaEnv,
          validateName,
          ValidationError,
          opts,
        } = it;
        if (schemaEnv.$async)
          gen.if(
            (0,
            codegen_1._)`${names_1.default.errors} === 0`,
            () =>
              gen.return(
                names_1.default.data,
              ),
            () =>
              gen.throw(
                (0,
                codegen_1._)`new ${ValidationError}(${names_1.default.vErrors})`,
              ),
          );
        else {
          gen.assign(
            (0,
            codegen_1._)`${validateName}.errors`,
            names_1.default.vErrors,
          );
          if (opts.unevaluated)
            assignEvaluated(it);
          gen.return(
            (0,
            codegen_1._)`${names_1.default.errors} === 0`,
          );
        }
      }
      function assignEvaluated({
        gen,
        evaluated,
        props,
        items,
      }) {
        if (
          props instanceof
          codegen_1.Name
        )
          gen.assign(
            (0,
            codegen_1._)`${evaluated}.props`,
            props,
          );
        if (
          items instanceof
          codegen_1.Name
        )
          gen.assign(
            (0,
            codegen_1._)`${evaluated}.items`,
            items,
          );
      }
      function schemaKeywords(
        it,
        types,
        typeErrors,
        errsCount,
      ) {
        const {
          gen,
          schema,
          data,
          allErrors,
          opts,
          self,
        } = it;
        const { RULES } = self;
        if (
          schema.$ref &&
          (opts.ignoreKeywordsWithRef ||
            !(0,
            util_1.schemaHasRulesButRef)(
              schema,
              RULES,
            ))
        ) {
          gen.block(() =>
            keywordCode(
              it,
              "$ref",
              RULES.all.$ref.definition,
            ),
          );
          return;
        }
        if (!opts.jtd)
          checkStrictTypes(it, types);
        gen.block(() => {
          for (const group of RULES.rules)
            groupKeywords(group);
          groupKeywords(RULES.post);
        });
        function groupKeywords(group) {
          if (
            !(0,
            applicability_1.shouldUseGroup)(
              schema,
              group,
            )
          )
            return;
          if (group.type) {
            gen.if(
              (0,
              dataType_2.checkDataType)(
                group.type,
                data,
                opts.strictNumbers,
              ),
            );
            iterateKeywords(it, group);
            if (
              types.length === 1 &&
              types[0] === group.type &&
              typeErrors
            ) {
              gen.else();
              (0,
              dataType_2.reportTypeError)(
                it,
              );
            }
            gen.endIf();
          } else
            iterateKeywords(it, group);
          if (!allErrors)
            gen.if(
              (0,
              codegen_1._)`${names_1.default.errors} === ${errsCount || 0}`,
            );
        }
      }
      function iterateKeywords(
        it,
        group,
      ) {
        const {
          gen,
          schema,
          opts: { useDefaults },
        } = it;
        if (useDefaults)
          (0,
          defaults_1.assignDefaults)(
            it,
            group.type,
          );
        gen.block(() => {
          for (const rule of group.rules)
            if (
              (0,
              applicability_1.shouldUseRule)(
                schema,
                rule,
              )
            )
              keywordCode(
                it,
                rule.keyword,
                rule.definition,
                group.type,
              );
        });
      }
      function checkStrictTypes(
        it,
        types,
      ) {
        if (
          it.schemaEnv.meta ||
          !it.opts.strictTypes
        )
          return;
        checkContextTypes(it, types);
        if (!it.opts.allowUnionTypes)
          checkMultipleTypes(it, types);
        checkKeywordTypes(
          it,
          it.dataTypes,
        );
      }
      function checkContextTypes(
        it,
        types,
      ) {
        if (!types.length) return;
        if (!it.dataTypes.length) {
          it.dataTypes = types;
          return;
        }
        types.forEach((t) => {
          if (
            !includesType(
              it.dataTypes,
              t,
            )
          )
            strictTypesError(
              it,
              `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`,
            );
        });
        narrowSchemaTypes(it, types);
      }
      function checkMultipleTypes(
        it,
        ts,
      ) {
        if (
          ts.length > 1 &&
          !(
            ts.length === 2 &&
            ts.includes("null")
          )
        )
          strictTypesError(
            it,
            "use allowUnionTypes to allow union type keyword",
          );
      }
      function checkKeywordTypes(
        it,
        ts,
      ) {
        const rules = it.self.RULES.all;
        for (const keyword in rules) {
          const rule = rules[keyword];
          if (
            typeof rule == "object" &&
            (0,
            applicability_1.shouldUseRule)(
              it.schema,
              rule,
            )
          ) {
            const { type } =
              rule.definition;
            if (
              type.length &&
              !type.some((t) =>
                hasApplicableType(
                  ts,
                  t,
                ),
              )
            )
              strictTypesError(
                it,
                `missing type "${type.join(",")}" for keyword "${keyword}"`,
              );
          }
        }
      }
      function hasApplicableType(
        schTs,
        kwdT,
      ) {
        return (
          schTs.includes(kwdT) ||
          (kwdT === "number" &&
            schTs.includes("integer"))
        );
      }
      function includesType(ts, t) {
        return (
          ts.includes(t) ||
          (t === "integer" &&
            ts.includes("number"))
        );
      }
      function narrowSchemaTypes(
        it,
        withTypes,
      ) {
        const ts = [];
        for (const t of it.dataTypes)
          if (
            includesType(withTypes, t)
          )
            ts.push(t);
          else if (
            withTypes.includes(
              "integer",
            ) &&
            t === "number"
          )
            ts.push("integer");
        it.dataTypes = ts;
      }
      function strictTypesError(
        it,
        msg,
      ) {
        const schemaPath =
          it.schemaEnv.baseId +
          it.errSchemaPath;
        msg += ` at "${schemaPath}" (strictTypes)`;
        (0, util_1.checkStrictMode)(
          it,
          msg,
          it.opts.strictTypes,
        );
      }
      var KeywordCxt = class {
        constructor(it, def, keyword) {
          (0,
          keyword_1.validateKeywordUsage)(
            it,
            def,
            keyword,
          );
          this.gen = it.gen;
          this.allErrors = it.allErrors;
          this.keyword = keyword;
          this.data = it.data;
          this.schema =
            it.schema[keyword];
          this.$data =
            def.$data &&
            it.opts.$data &&
            this.schema &&
            this.schema.$data;
          this.schemaValue = (0,
          util_1.schemaRefOrVal)(
            it,
            this.schema,
            keyword,
            this.$data,
          );
          this.schemaType =
            def.schemaType;
          this.parentSchema = it.schema;
          this.params = {};
          this.it = it;
          this.def = def;
          if (this.$data)
            this.schemaCode =
              it.gen.const(
                "vSchema",
                getData(this.$data, it),
              );
          else {
            this.schemaCode =
              this.schemaValue;
            if (
              !(0,
              keyword_1.validSchemaType)(
                this.schema,
                def.schemaType,
                def.allowUndefined,
              )
            )
              throw new Error(
                `${keyword} value must be ${JSON.stringify(def.schemaType)}`,
              );
          }
          if (
            "code" in def
              ? def.trackErrors
              : def.errors !== false
          )
            this.errsCount =
              it.gen.const(
                "_errs",
                names_1.default.errors,
              );
        }
        result(
          condition,
          successAction,
          failAction,
        ) {
          this.failResult(
            (0, codegen_1.not)(
              condition,
            ),
            successAction,
            failAction,
          );
        }
        failResult(
          condition,
          successAction,
          failAction,
        ) {
          this.gen.if(condition);
          if (failAction) failAction();
          else this.error();
          if (successAction) {
            this.gen.else();
            successAction();
            if (this.allErrors)
              this.gen.endIf();
          } else if (this.allErrors)
            this.gen.endIf();
          else this.gen.else();
        }
        pass(condition, failAction) {
          this.failResult(
            (0, codegen_1.not)(
              condition,
            ),
            void 0,
            failAction,
          );
        }
        fail(condition) {
          if (condition === void 0) {
            this.error();
            if (!this.allErrors)
              this.gen.if(false);
            return;
          }
          this.gen.if(condition);
          this.error();
          if (this.allErrors)
            this.gen.endIf();
          else this.gen.else();
        }
        fail$data(condition) {
          if (!this.$data)
            return this.fail(condition);
          const { schemaCode } = this;
          this.fail(
            (0,
            codegen_1._)`${schemaCode} !== undefined && (${(0, codegen_1.or)(this.invalid$data(), condition)})`,
          );
        }
        error(
          append,
          errorParams,
          errorPaths,
        ) {
          if (errorParams) {
            this.setParams(errorParams);
            this._error(
              append,
              errorPaths,
            );
            this.setParams({});
            return;
          }
          this._error(
            append,
            errorPaths,
          );
        }
        _error(append, errorPaths) {
          (append
            ? errors_1.reportExtraError
            : errors_1.reportError)(
            this,
            this.def.error,
            errorPaths,
          );
        }
        $dataError() {
          (0, errors_1.reportError)(
            this,
            this.def.$dataError ||
              errors_1.keyword$DataError,
          );
        }
        reset() {
          if (this.errsCount === void 0)
            throw new Error(
              'add "trackErrors" to keyword definition',
            );
          (0,
          errors_1.resetErrorsCount)(
            this.gen,
            this.errsCount,
          );
        }
        ok(cond) {
          if (!this.allErrors)
            this.gen.if(cond);
        }
        setParams(obj, assign) {
          if (assign)
            Object.assign(
              this.params,
              obj,
            );
          else this.params = obj;
        }
        block$data(
          valid,
          codeBlock,
          $dataValid = codegen_1.nil,
        ) {
          this.gen.block(() => {
            this.check$data(
              valid,
              $dataValid,
            );
            codeBlock();
          });
        }
        check$data(
          valid = codegen_1.nil,
          $dataValid = codegen_1.nil,
        ) {
          if (!this.$data) return;
          const {
            gen,
            schemaCode,
            schemaType,
            def,
          } = this;
          gen.if(
            (0, codegen_1.or)(
              (0,
              codegen_1._)`${schemaCode} === undefined`,
              $dataValid,
            ),
          );
          if (valid !== codegen_1.nil)
            gen.assign(valid, true);
          if (
            schemaType.length ||
            def.validateSchema
          ) {
            gen.elseIf(
              this.invalid$data(),
            );
            this.$dataError();
            if (valid !== codegen_1.nil)
              gen.assign(valid, false);
          }
          gen.else();
        }
        invalid$data() {
          const {
            gen,
            schemaCode,
            schemaType,
            def,
            it,
          } = this;
          return (0, codegen_1.or)(
            wrong$DataType(),
            invalid$DataSchema(),
          );
          function wrong$DataType() {
            if (schemaType.length) {
              /* istanbul ignore if */
              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,
          );
      }
      const JSON_POINTER =
        /^\/(?:[^~]|~0|~1)*$/;
      const 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;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/validation_error.js
var require_validation_error =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      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;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/ref_error.js
var require_ref_error =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const resolve_1 =
        require_resolve();
      var MissingRefError = class extends Error {
        constructor(
          resolver,
          baseId,
          ref,
          msg,
        ) {
          super(
            msg ||
              `can't resolve reference ${ref} from id ${baseId}`,
          );
          this.missingRef = (0,
          resolve_1.resolveUrl)(
            resolver,
            baseId,
            ref,
          );
          this.missingSchema = (0,
          resolve_1.normalizeId)(
            (0, resolve_1.getFullPath)(
              resolver,
              this.missingRef,
            ),
          );
        }
      };
      exports.default = MissingRefError;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/index.js
var require_compile =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.resolveSchema =
        exports.getCompilingSchema =
        exports.resolveRef =
        exports.compileSchema =
        exports.SchemaEnv =
          void 0;
      const codegen_1 =
        require_codegen();
      const validation_error_1 =
        require_validation_error();
      const names_1 = require_names();
      const resolve_1 =
        require_resolve();
      const util_1 = require_util();
      const validate_1 =
        require_validate();
      var SchemaEnv = class {
        constructor(env) {
          var _a;
          this.refs = {};
          this.dynamicAnchors = {};
          let schema;
          if (
            typeof env.schema ==
            "object"
          )
            schema = env.schema;
          this.schema = env.schema;
          this.schemaId = env.schemaId;
          this.root = env.root || this;
          this.baseId =
            (_a = env.baseId) !==
              null && _a !== void 0
              ? _a
              : (0,
                resolve_1.normalizeId)(
                  schema === null ||
                    schema === void 0
                    ? void 0
                    : schema[
                        env.schemaId ||
                          "$id"
                      ],
                );
          this.schemaPath =
            env.schemaPath;
          this.localRefs =
            env.localRefs;
          this.meta = env.meta;
          this.$async =
            schema === null ||
            schema === void 0
              ? void 0
              : schema.$async;
          this.refs = {};
        }
      };
      exports.SchemaEnv = SchemaEnv;
      function compileSchema(sch) {
        const _sch =
          getCompilingSchema.call(
            this,
            sch,
          );
        if (_sch) return _sch;
        const rootId = (0,
        resolve_1.getFullPath)(
          this.opts.uriResolver,
          sch.root.baseId,
        );
        const { es5, lines } =
          this.opts.code;
        const { ownProperties } =
          this.opts;
        const gen =
          new codegen_1.CodeGen(
            this.scope,
            {
              es5,
              lines,
              ownProperties,
            },
          );
        let _ValidationError;
        if (sch.$async)
          _ValidationError =
            gen.scopeValue("Error", {
              ref: validation_error_1.default,
              code: (0,
              codegen_1._)`require("ajv/dist/runtime/validation_error").default`,
            });
        const validateName =
          gen.scopeName("validate");
        sch.validateName = validateName;
        const schemaCxt = {
          gen,
          allErrors:
            this.opts.allErrors,
          data: names_1.default.data,
          parentData:
            names_1.default.parentData,
          parentDataProperty:
            names_1.default
              .parentDataProperty,
          dataNames: [
            names_1.default.data,
          ],
          dataPathArr: [codegen_1.nil],
          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 validate = new Function(
            `${names_1.default.self}`,
            `${names_1.default.scope}`,
            sourceCode,
          )(this, this.scope.get());
          this.scope.value(
            validateName,
            { ref: validate },
          );
          validate.errors = null;
          validate.schema = sch.schema;
          validate.schemaEnv = sch;
          if (sch.$async)
            validate.$async = true;
          if (
            this.opts.code.source ===
            true
          )
            validate.source = {
              validateName,
              validateCode,
              scopeValues: gen._values,
            };
          if (this.opts.unevaluated) {
            const { props, items } =
              schemaCxt;
            validate.evaluated = {
              props:
                props instanceof
                codegen_1.Name
                  ? void 0
                  : props,
              items:
                items instanceof
                codegen_1.Name
                  ? void 0
                  : items,
              dynamicProps:
                props instanceof
                codegen_1.Name,
              dynamicItems:
                items instanceof
                codegen_1.Name,
            };
            if (validate.source)
              validate.source.evaluated =
                (0,
                codegen_1.stringify)(
                  validate.evaluated,
                );
          }
          sch.validate = validate;
          return sch;
        } catch (e) {
          delete sch.validate;
          delete sch.validateName;
          if (sourceCode)
            this.logger.error(
              "Error compiling schema, function code:",
              sourceCode,
            );
          throw e;
        } finally {
          this._compilations.delete(
            sch,
          );
        }
      }
      exports.compileSchema =
        compileSchema;
      function resolveRef(
        root,
        baseId,
        ref,
      ) {
        var _a;
        ref = (0, resolve_1.resolveUrl)(
          this.opts.uriResolver,
          baseId,
          ref,
        );
        const schOrFunc =
          root.refs[ref];
        if (schOrFunc) return schOrFunc;
        let _sch = resolve.call(
          this,
          root,
          ref,
        );
        if (_sch === void 0) {
          const schema =
            (_a = root.localRefs) ===
              null || _a === void 0
              ? void 0
              : _a[ref];
          const { schemaId } =
            this.opts;
          if (schema)
            _sch = new SchemaEnv({
              schema,
              schemaId,
              root,
              baseId,
            });
        }
        if (_sch === void 0) return;
        return (root.refs[ref] =
          inlineOrCompile.call(
            this,
            _sch,
          ));
      }
      exports.resolveRef = resolveRef;
      function inlineOrCompile(sch) {
        if (
          (0, resolve_1.inlineRef)(
            sch.schema,
            this.opts.inlineRefs,
          )
        )
          return sch.schema;
        return sch.validate
          ? sch
          : compileSchema.call(
              this,
              sch,
            );
      }
      function getCompilingSchema(
        schEnv,
      ) {
        for (const sch of this
          ._compilations)
          if (
            sameSchemaEnv(sch, schEnv)
          )
            return sch;
      }
      exports.getCompilingSchema =
        getCompilingSchema;
      function sameSchemaEnv(s1, s2) {
        return (
          s1.schema === s2.schema &&
          s1.root === s2.root &&
          s1.baseId === s2.baseId
        );
      }
      function resolve(root, ref) {
        let sch;
        while (
          typeof (sch =
            this.refs[ref]) == "string"
        )
          ref = sch;
        return (
          sch ||
          this.schemas[ref] ||
          resolveSchema.call(
            this,
            root,
            ref,
          )
        );
      }
      function resolveSchema(
        root,
        ref,
      ) {
        const p =
          this.opts.uriResolver.parse(
            ref,
          );
        const refPath = (0,
        resolve_1._getFullPath)(
          this.opts.uriResolver,
          p,
        );
        let baseId = (0,
        resolve_1.getFullPath)(
          this.opts.uriResolver,
          root.baseId,
          void 0,
        );
        if (
          Object.keys(root.schema)
            .length > 0 &&
          refPath === baseId
        )
          return getJsonPointer.call(
            this,
            p,
            root,
          );
        const id = (0,
        resolve_1.normalizeId)(refPath);
        const schOrRef =
          this.refs[id] ||
          this.schemas[id];
        if (
          typeof schOrRef == "string"
        ) {
          const sch =
            resolveSchema.call(
              this,
              root,
              schOrRef,
            );
          if (
            typeof (sch === null ||
            sch === void 0
              ? void 0
              : sch.schema) !== "object"
          )
            return;
          return getJsonPointer.call(
            this,
            p,
            sch,
          );
        }
        if (
          typeof (schOrRef === null ||
          schOrRef === void 0
            ? void 0
            : schOrRef.schema) !==
          "object"
        )
          return;
        if (!schOrRef.validate)
          compileSchema.call(
            this,
            schOrRef,
          );
        if (
          id ===
          (0, resolve_1.normalizeId)(
            ref,
          )
        ) {
          const { schema } = schOrRef;
          const { schemaId } =
            this.opts;
          const schId =
            schema[schemaId];
          if (schId)
            baseId = (0,
            resolve_1.resolveUrl)(
              this.opts.uriResolver,
              baseId,
              schId,
            );
          return new SchemaEnv({
            schema,
            schemaId,
            root,
            baseId,
          });
        }
        return getJsonPointer.call(
          this,
          p,
          schOrRef,
        );
      }
      exports.resolveSchema =
        resolveSchema;
      const PREVENT_SCOPE_CHANGE =
        /* @__PURE__ */ new Set([
          "properties",
          "patternProperties",
          "enum",
          "dependencies",
          "definitions",
        ]);
      function getJsonPointer(
        parsedRef,
        { baseId, schema, root },
      ) {
        var _a;
        if (
          ((_a = parsedRef.fragment) ===
            null || _a === void 0
            ? void 0
            : _a[0]) !== "/"
        )
          return;
        for (const part of parsedRef.fragment
          .slice(1)
          .split("/")) {
          if (
            typeof schema === "boolean"
          )
            return;
          const partSchema =
            schema[
              (0,
              util_1.unescapeFragment)(
                part,
              )
            ];
          if (partSchema === void 0)
            return;
          schema = partSchema;
          const schId =
            typeof schema ===
              "object" &&
            schema[this.opts.schemaId];
          if (
            !PREVENT_SCOPE_CHANGE.has(
              part,
            ) &&
            schId
          )
            baseId = (0,
            resolve_1.resolveUrl)(
              this.opts.uriResolver,
              baseId,
              schId,
            );
        }
        let env;
        if (
          typeof schema != "boolean" &&
          schema.$ref &&
          !(0,
          util_1.schemaHasRulesButRef)(
            schema,
            this.RULES,
          )
        ) {
          const $ref = (0,
          resolve_1.resolveUrl)(
            this.opts.uriResolver,
            baseId,
            schema.$ref,
          );
          env = resolveSchema.call(
            this,
            root,
            $ref,
          );
        }
        const { schemaId } = this.opts;
        env =
          env ||
          new SchemaEnv({
            schema,
            schemaId,
            root,
            baseId,
          });
        if (
          env.schema !== env.root.schema
        )
          return env;
      }
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/data.json
var require_data =
  /* @__PURE__ */ __commonJSMin(
    (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,
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/lib/utils.js
var require_utils =
  /* @__PURE__ */ __commonJSMin(
    (exports, module) => {
      /** @type {(value: string) => boolean} */
      const isUUID =
        RegExp.prototype.test.bind(
          /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu,
        );
      /** @type {(value: string) => boolean} */
      const isIPv4 =
        RegExp.prototype.test.bind(
          /^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u,
        );
      /** @type {(value: string) => boolean} */
      const isPort =
        RegExp.prototype.test.bind(
          /^\d*$/u,
        );
      /** @type {(value: string) => boolean} */
      const isHexPair =
        RegExp.prototype.test.bind(
          /^[\da-f]{2}$/iu,
        );
      /** @type {(value: string) => boolean} */
      const isUnreserved =
        RegExp.prototype.test.bind(
          /^[\da-z\-._~]$/iu,
        );
      /** @type {(value: string) => boolean} */
      const isPathCharacter =
        RegExp.prototype.test.bind(
          /^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u,
        );
      /** @type {(value: string) => boolean} */
      const isQueryFragmentCharacter =
        RegExp.prototype.test.bind(
          /^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u,
        );
      /** @type {(value: string) => boolean} */
      const isUserinfoCharacter =
        RegExp.prototype.test.bind(
          /^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u,
        );
      const BYTE_HEX = new Array(256);
      {
        const HEX_DIGITS =
          "0123456789ABCDEF";
        for (let i = 0; i < 256; i++)
          BYTE_HEX[i] =
            "%" +
            HEX_DIGITS[i >> 4] +
            HEX_DIGITS[i & 15];
      }
      function percentEncodeNonAscii(
        cp,
      ) {
        if (cp < 2048)
          return (
            BYTE_HEX[192 | (cp >> 6)] +
            BYTE_HEX[128 | (cp & 63)]
          );
        if (cp < 65536)
          return (
            BYTE_HEX[224 | (cp >> 12)] +
            BYTE_HEX[
              128 | ((cp >> 6) & 63)
            ] +
            BYTE_HEX[128 | (cp & 63)]
          );
        return (
          BYTE_HEX[240 | (cp >> 18)] +
          BYTE_HEX[
            128 | ((cp >> 12) & 63)
          ] +
          BYTE_HEX[
            128 | ((cp >> 6) & 63)
          ] +
          BYTE_HEX[128 | (cp & 63)]
        );
      }
      /**
       * @param {Array<string>} input
       * @returns {string}
       */
      function stringArrayToHexStripped(
        input,
      ) {
        let acc = "";
        let code = 0;
        let i = 0;
        for (
          i = 0;
          i < input.length;
          i++
        ) {
          code = input[i].charCodeAt(0);
          if (code === 48) continue;
          if (
            !(
              (code >= 48 &&
                code <= 57) ||
              (code >= 65 &&
                code <= 70) ||
              (code >= 97 &&
                code <= 102)
            )
          )
            return "";
          acc += input[i];
          break;
        }
        for (
          i += 1;
          i < input.length;
          i++
        ) {
          code = input[i].charCodeAt(0);
          if (
            !(
              (code >= 48 &&
                code <= 57) ||
              (code >= 65 &&
                code <= 70) ||
              (code >= 97 &&
                code <= 102)
            )
          )
            return "";
          acc += input[i];
        }
        return acc;
      }
      /** @type {(value: string) => boolean} */
      const isHextet =
        RegExp.prototype.test.bind(
          /^[\dA-Fa-f]{1,4}$/,
        );
      /** @type {(value: string) => boolean} */
      const isIPvFuture =
        RegExp.prototype.test.bind(
          /^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/,
        );
      /** @type {(value: string) => boolean} */
      const isZoneCharacter =
        RegExp.prototype.test.bind(
          /^[A-Za-z\d\-._~]$/,
        );
      /**
       * @param {string} value
       * @returns {boolean}
       */
      const nonSimpleDomain =
        RegExp.prototype.test.bind(
          /[^!"$&'()*+,\-.;=_`a-z{}~]/u,
        );
      /**
       * @param {string} zone
       * @returns {boolean}
       */
      function isZoneIdentifier(zone) {
        if (zone.length === 0)
          return false;
        for (
          let i = 0;
          i < zone.length;
          i++
        ) {
          if (isZoneCharacter(zone[i]))
            continue;
          if (
            zone[i] === "%" &&
            i + 2 < zone.length &&
            isHexPair(
              zone.slice(i + 1, i + 3),
            )
          ) {
            i += 2;
            continue;
          }
          return false;
        }
        return true;
      }
      /**
       * Compresses the longest run of zero hextets to "::" per RFC 5952. A run of a
       * single zero hextet is left uncompressed. On ties the leftmost run wins.
       *
       * @param {string[]} hextets
       * @returns {string}
       */
      function compressIPv6ZeroRun(
        hextets,
      ) {
        let bestStart = -1;
        let bestLength = 0;
        let runStart = -1;
        let runLength = 0;
        for (
          let i = 0;
          i < hextets.length;
          i++
        )
          if (hextets[i] === "0") {
            if (runStart === -1)
              runStart = i;
            runLength++;
            if (
              runLength > bestLength
            ) {
              bestLength = runLength;
              bestStart = runStart;
            }
          } else {
            runStart = -1;
            runLength = 0;
          }
        if (bestLength < 2)
          return hextets.join(":");
        const head = hextets
          .slice(0, bestStart)
          .join(":");
        const tail = hextets
          .slice(bestStart + bestLength)
          .join(":");
        return head + "::" + tail;
      }
      /**
       * Validates an IPv6 address against the alternatives in RFC 3986 section
       * 3.2.2 and returns the same address with leading hextet zeroes removed.
       * An embedded IPv4 address counts as two hextets and is only valid at the end.
       *
       * @param {string} input
       * @returns {string|undefined}
       */
      function normalizeIPv6Address(
        input,
      ) {
        const compression =
          input.indexOf("::");
        if (
          compression !== -1 &&
          input.indexOf(
            "::",
            compression + 1,
          ) !== -1
        )
          return void 0;
        const left =
          compression === -1
            ? input.split(":")
            : input
                .slice(0, compression)
                .split(":");
        const right =
          compression === -1
            ? []
            : input
                .slice(compression + 2)
                .split(":");
        if (compression !== -1) {
          if (
            left.length === 1 &&
            left[0] === ""
          )
            left.length = 0;
          if (
            right.length === 1 &&
            right[0] === ""
          )
            right.length = 0;
        }
        const parts =
          left.concat(right);
        let hextetCount = 0;
        for (
          let i = 0;
          i < parts.length;
          i++
        ) {
          const part = parts[i];
          if (part === "")
            return void 0;
          if (
            part.indexOf(".") !== -1
          ) {
            if (
              i !== parts.length - 1 ||
              (compression !== -1 &&
                right.length === 0) ||
              !isIPv4(part)
            )
              return void 0;
            hextetCount += 2;
            continue;
          }
          if (!isHextet(part))
            return void 0;
          parts[i] = parseInt(
            part,
            16,
          ).toString(16);
          hextetCount++;
        }
        if (compression === -1) {
          if (hextetCount !== 8)
            return void 0;
          return compressIPv6ZeroRun(
            parts,
          );
        }
        if (hextetCount >= 8)
          return void 0;
        const expanded = parts.slice(
          0,
          left.length,
        );
        for (
          let i = hextetCount;
          i < 8;
          i++
        )
          expanded.push("0");
        for (
          let i = left.length;
          i < parts.length;
          i++
        )
          expanded.push(parts[i]);
        return compressIPv6ZeroRun(
          expanded,
        );
      }
      /**
       * @typedef {Object} NormalizeIPv6Result
       * @property {string} host - The normalized host.
       * @property {string} [escapedHost] - The escaped host.
       * @property {boolean} isIPV6 - Indicates if the host is an IPv6 address.
       * @property {boolean} [isIPVFuture] - Indicates if the host is an IPvFuture literal.
       * @property {boolean} [error] - Indicates if a bracketed IP literal is malformed.
       */
      /**
       * Validates and normalizes a bracketed IP literal. Raw zone separators remain
       * accepted for backwards compatibility, while encoded separators and zone
       * contents follow RFC 6874.
       *
       * @param {string} host
       * @returns {NormalizeIPv6Result}
       */
      function normalizeIPv6(host) {
        const bracketed =
          host[0] === "[" &&
          host[host.length - 1] === "]";
        if (
          (host[0] === "[" ||
            host[host.length - 1] ===
              "]") &&
          !bracketed
        )
          return {
            host,
            isIPV6: false,
            error: true,
          };
        let input = bracketed
          ? host.slice(1, -1)
          : host;
        if (
          bracketed &&
          isIPvFuture(input)
        ) {
          input = input.toLowerCase();
          return {
            host: `[${input}]`,
            escapedHost: input,
            isIPV6: false,
            isIPVFuture: true,
          };
        }
        if (findToken(input, ":") < 2)
          return {
            host,
            isIPV6: false,
            error: bracketed,
          };
        let zoneIdentifier = "";
        const zoneSeparator =
          input.indexOf("%");
        if (zoneSeparator !== -1) {
          const separatorLength =
            input
              .slice(
                zoneSeparator,
                zoneSeparator + 3,
              )
              .toLowerCase() === "%25"
              ? 3
              : 1;
          zoneIdentifier = input.slice(
            zoneSeparator +
              separatorLength,
          );
          if (
            !isZoneIdentifier(
              zoneIdentifier,
            )
          )
            return {
              host,
              isIPV6: false,
              error: true,
            };
          input = input.slice(
            0,
            zoneSeparator,
          );
        }
        const address =
          normalizeIPv6Address(input);
        if (address === void 0)
          return {
            host,
            isIPV6: false,
            error: true,
          };
        return {
          host:
            address +
            (zoneIdentifier
              ? "%" + zoneIdentifier
              : ""),
          escapedHost:
            address +
            (zoneIdentifier
              ? "%25" + zoneIdentifier
              : ""),
          isIPV6: true,
        };
      }
      /**
       * @param {string} str
       * @param {string} token
       * @returns {number}
       */
      function findToken(str, token) {
        let ind = 0;
        for (
          let i = 0;
          i < str.length;
          i++
        )
          if (str[i] === token) ind++;
        return ind;
      }
      /**
       * @param {string} path
       * @returns {string}
       *
       * @see https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
       */
      function removeDotSegments(path) {
        let input = path;
        const output = [];
        let nextSlash = -1;
        let len = 0;
        while ((len = input.length)) {
          if (len === 1) {
            if (input === ".") break;
            else if (input === "/") {
              output.push("/");
              break;
            } else {
              output.push(input);
              break;
            }
          } else if (len === 2) {
            if (input[0] === ".") {
              if (input[1] === ".")
                break;
              else if (
                input[1] === "/"
              ) {
                input = input.slice(2);
                continue;
              }
            } else if (
              input[0] === "/"
            ) {
              if (
                input[1] === "." ||
                input[1] === "/"
              ) {
                output.push("/");
                break;
              }
            }
          } else if (len === 3) {
            if (input === "/..") {
              if (output.length !== 0)
                output.pop();
              output.push("/");
              break;
            }
          }
          if (input[0] === ".") {
            if (input[1] === ".") {
              if (input[2] === "/") {
                input = input.slice(3);
                continue;
              }
            } else if (
              input[1] === "/"
            ) {
              input = input.slice(2);
              continue;
            }
          } else if (input[0] === "/") {
            if (input[1] === ".") {
              if (input[2] === "/") {
                input = input.slice(2);
                continue;
              } else if (
                input[2] === "."
              ) {
                if (input[3] === "/") {
                  input =
                    input.slice(3);
                  if (
                    output.length !== 0
                  )
                    output.pop();
                  continue;
                }
              }
            }
          }
          if (
            (nextSlash = input.indexOf(
              "/",
              1,
            )) === -1
          ) {
            output.push(input);
            break;
          } else {
            output.push(
              input.slice(0, nextSlash),
            );
            input =
              input.slice(nextSlash);
          }
        }
        return output.join("");
      }
      /**
       * Re-escape RFC 3986 gen-delims that must not appear literally in the host.
       * After the URI regex parses, these characters cannot be literal in the host
       * field, so any that appear after decoding came from percent-encoding and
       * must be restored to prevent authority structure changes.
       *
       * @param {string} host
       * @param {boolean} isIP - true for IPv4/IPv6 hosts (skip colon re-escaping)
       * @returns {string}
       */
      const HOST_DELIMS = {
        "@": "%40",
        "/": "%2F",
        "?": "%3F",
        "#": "%23",
        ":": "%3A",
      };
      const HOST_DELIM_RE = /[@/?#:]/g;
      const HOST_DELIM_NO_COLON_RE =
        /[@/?#]/g;
      function reescapeHostDelimiters(
        host,
        isIP,
      ) {
        const re = isIP
          ? HOST_DELIM_NO_COLON_RE
          : HOST_DELIM_RE;
        re.lastIndex = 0;
        return host.replace(
          re,
          (ch) => HOST_DELIMS[ch],
        );
      }
      /**
       * Normalizes percent escapes and optionally decodes only unreserved ASCII bytes.
       * Reserved delimiters such as `%2F` stay escaped; `%2E` is unreserved.
       *
       * @param {string} input
       * @param {boolean} [decodeUnreserved=false]
       * @returns {string}
       */
      function normalizePercentEncoding(
        input,
        decodeUnreserved = false,
      ) {
        if (input.indexOf("%") === -1)
          return input;
        let output = "";
        for (
          let i = 0;
          i < input.length;
          i++
        ) {
          if (
            input[i] === "%" &&
            i + 2 < input.length
          ) {
            const hex = input.slice(
              i + 1,
              i + 3,
            );
            if (isHexPair(hex)) {
              const normalizedHex =
                hex.toUpperCase();
              const decoded =
                String.fromCharCode(
                  parseInt(
                    normalizedHex,
                    16,
                  ),
                );
              if (
                decodeUnreserved &&
                isUnreserved(decoded)
              )
                output += decoded;
              else
                output +=
                  "%" + normalizedHex;
              i += 2;
              continue;
            }
          }
          output += input[i];
        }
        return output;
      }
      /**
       * Normalizes path data without turning reserved escapes into live path syntax.
       * Valid escapes are uppercased, raw unsafe characters are escaped, and only
       * unreserved bytes that are not `.` are decoded.
       *
       * @param {string} input
       * @returns {string}
       */
      function normalizePathEncoding(
        input,
      ) {
        let output = "";
        for (
          let i = 0;
          i < input.length;
          i++
        ) {
          const ch = input[i];
          if (
            ch === "%" &&
            i + 2 < input.length
          ) {
            const hex = input.slice(
              i + 1,
              i + 3,
            );
            if (isHexPair(hex)) {
              const normalizedHex =
                hex.toUpperCase();
              const decoded =
                String.fromCharCode(
                  parseInt(
                    normalizedHex,
                    16,
                  ),
                );
              if (
                decoded !== "." &&
                isUnreserved(decoded)
              )
                output += decoded;
              else
                output +=
                  "%" + normalizedHex;
              i += 2;
              continue;
            }
          }
          if (isPathCharacter(ch))
            output += ch;
          else {
            const code =
              input.charCodeAt(i);
            if (code < 128)
              output += isEscapeSafe(
                code,
              )
                ? ch
                : BYTE_HEX[code];
            else if (
              code < 55296 ||
              code > 57343
            )
              output +=
                percentEncodeNonAscii(
                  code,
                );
            else if (
              code <= 56319 &&
              i + 1 < input.length
            ) {
              const low =
                input.charCodeAt(i + 1);
              if (
                low >= 56320 &&
                low <= 57343
              ) {
                output +=
                  percentEncodeNonAscii(
                    65536 +
                      ((code - 55296) <<
                        10) +
                      (low - 56320),
                  );
                i++;
              } else
                output +=
                  percentEncodeNonAscii(
                    65533,
                  );
            } else
              output +=
                percentEncodeNonAscii(
                  65533,
                );
          }
        }
        return output;
      }
      /**
       * Serializes a path without rewriting reserved data. Raw RFC 3986 path
       * characters remain literal, valid escapes are preserved and uppercased, and
       * everything else is UTF-8 percent-encoded. In a path-noscheme, a colon in the
       * first segment must be escaped so the result cannot be parsed as a scheme.
       *
       * @param {string} input
       * @param {boolean} [pathNoScheme=false]
       * @returns {string}
       */
      function serializePathEncoding(
        input,
        pathNoScheme = false,
      ) {
        let output = "";
        let firstSegment =
          pathNoScheme &&
          input[0] !== "/";
        for (
          let i = 0;
          i < input.length;
          i++
        ) {
          const ch = input[i];
          if (
            ch === "%" &&
            i + 2 < input.length
          ) {
            const hex = input.slice(
              i + 1,
              i + 3,
            );
            if (isHexPair(hex)) {
              output +=
                "%" + hex.toUpperCase();
              i += 2;
              continue;
            }
          }
          if (ch === "/")
            firstSegment = false;
          if (
            isPathCharacter(ch) &&
            (ch !== ":" ||
              !firstSegment)
          )
            output += ch;
          else {
            const code =
              input.charCodeAt(i);
            if (code < 128)
              output += BYTE_HEX[code];
            else if (
              code < 55296 ||
              code > 57343
            )
              output +=
                percentEncodeNonAscii(
                  code,
                );
            else if (
              code <= 56319 &&
              i + 1 < input.length
            ) {
              const low =
                input.charCodeAt(i + 1);
              if (
                low >= 56320 &&
                low <= 57343
              ) {
                output +=
                  percentEncodeNonAscii(
                    65536 +
                      ((code - 55296) <<
                        10) +
                      (low - 56320),
                  );
                i++;
              } else
                output +=
                  percentEncodeNonAscii(
                    65533,
                  );
            } else
              output +=
                percentEncodeNonAscii(
                  65533,
                );
          }
        }
        return output;
      }
      /**
       * Percent-encodes a URI component using its RFC 3986 literal character set.
       * Existing valid escapes are preserved and normalized to uppercase hex.
       *
       * @param {string} input
       * @param {(value: string) => boolean} isAllowed
       * @returns {string}
       */
      function encodeComponent(
        input,
        isAllowed,
      ) {
        let output = "";
        for (
          let i = 0;
          i < input.length;
          i++
        ) {
          const ch = input[i];
          if (
            ch === "%" &&
            i + 2 < input.length
          ) {
            const hex = input.slice(
              i + 1,
              i + 3,
            );
            if (isHexPair(hex)) {
              output +=
                "%" + hex.toUpperCase();
              i += 2;
              continue;
            }
          }
          if (isAllowed(ch))
            output += ch;
          else {
            const code =
              input.charCodeAt(i);
            if (code < 128)
              output += BYTE_HEX[code];
            else if (
              code < 55296 ||
              code > 57343
            )
              output +=
                percentEncodeNonAscii(
                  code,
                );
            else if (
              code <= 56319 &&
              i + 1 < input.length
            ) {
              const low =
                input.charCodeAt(i + 1);
              if (
                low >= 56320 &&
                low <= 57343
              ) {
                output +=
                  percentEncodeNonAscii(
                    65536 +
                      ((code - 55296) <<
                        10) +
                      (low - 56320),
                  );
                i++;
              } else
                output +=
                  percentEncodeNonAscii(
                    65533,
                  );
            } else
              output +=
                percentEncodeNonAscii(
                  65533,
                );
          }
        }
        return output;
      }
      /**
       * Encodes userinfo while preserving its RFC 3986 §3.2.1 literal characters.
       * In particular, authority delimiters such as `@`, `/`, `?`, and `#` are data.
       *
       * @param {string} input
       * @returns {string}
       */
      function encodeUserinfo(input) {
        return encodeComponent(
          input,
          isUserinfoCharacter,
        );
      }
      /**
       * Encodes query data using the RFC 3986 §3.4 grammar. A literal `#` must be
       * escaped because it would otherwise begin the fragment component.
       *
       * @param {string} input
       * @returns {string}
       */
      function encodeQuery(input) {
        return encodeComponent(
          input,
          isQueryFragmentCharacter,
        );
      }
      /**
       * Encodes fragment data using the RFC 3986 §3.5 grammar.
       *
       * @param {string} input
       * @returns {string}
       */
      function encodeFragment(input) {
        return encodeComponent(
          input,
          isQueryFragmentCharacter,
        );
      }
      function isEscapeSafe(cp) {
        return (
          (cp >= 48 && cp <= 57) ||
          (cp >= 65 && cp <= 90) ||
          (cp >= 97 && cp <= 122) ||
          cp === 42 ||
          cp === 43 ||
          cp === 45 ||
          cp === 46 ||
          cp === 47 ||
          cp === 64 ||
          cp === 95
        );
      }
      /**
       * Normalizes the percent-encoding of a query or fragment component.
       *
       * Like `normalizePathEncoding`, but uses the query/fragment character set
       * (which additionally allows `?`) and decodes `.` since it has no dot-segment
       * meaning outside of a path.
       *
       * @param {string} input
       * @returns {string}
       */
      function normalizeQueryFragmentEncoding(
        input,
      ) {
        let output = "";
        for (
          let i = 0;
          i < input.length;
          i++
        ) {
          const ch = input[i];
          if (
            ch === "%" &&
            i + 2 < input.length
          ) {
            const hex = input.slice(
              i + 1,
              i + 3,
            );
            if (isHexPair(hex)) {
              const normalizedHex =
                hex.toUpperCase();
              const decoded =
                String.fromCharCode(
                  parseInt(
                    normalizedHex,
                    16,
                  ),
                );
              if (isUnreserved(decoded))
                output += decoded;
              else
                output +=
                  "%" + normalizedHex;
              i += 2;
              continue;
            }
          }
          if (
            isQueryFragmentCharacter(ch)
          )
            output += ch;
          else {
            const code =
              input.charCodeAt(i);
            if (code < 128)
              output += isEscapeSafe(
                code,
              )
                ? ch
                : BYTE_HEX[code];
            else if (
              code < 55296 ||
              code > 57343
            )
              output +=
                percentEncodeNonAscii(
                  code,
                );
            else if (
              code <= 56319 &&
              i + 1 < input.length
            ) {
              const low =
                input.charCodeAt(i + 1);
              if (
                low >= 56320 &&
                low <= 57343
              ) {
                output +=
                  percentEncodeNonAscii(
                    65536 +
                      ((code - 55296) <<
                        10) +
                      (low - 56320),
                  );
                i++;
              } else
                output +=
                  percentEncodeNonAscii(
                    65533,
                  );
            } else
              output +=
                percentEncodeNonAscii(
                  65533,
                );
          }
        }
        return output;
      }
      /**
       * Escapes a component while preserving existing valid percent escapes.
       *
       * @param {string} input
       * @returns {string}
       */
      function escapePreservingEscapes(
        input,
      ) {
        let output = "";
        for (
          let i = 0;
          i < input.length;
          i++
        ) {
          if (
            input[i] === "%" &&
            i + 2 < input.length
          ) {
            const hex = input.slice(
              i + 1,
              i + 3,
            );
            if (isHexPair(hex)) {
              output +=
                "%" + hex.toUpperCase();
              i += 2;
              continue;
            }
          }
          output += escape(input[i]);
        }
        return output;
      }
      /**
       * @param {import('../types/index').URIComponent} component
       * @returns {string|undefined}
       */
      function recomposeAuthority(
        component,
      ) {
        const uriTokens = [];
        if (
          component.userinfo !== void 0
        ) {
          uriTokens.push(
            encodeUserinfo(
              component.userinfo,
            ),
          );
          uriTokens.push("@");
        }
        if (component.host !== void 0) {
          let host = component.host;
          if (!isIPv4(host)) {
            let ipV6res =
              normalizeIPv6(host);
            if (
              ipV6res.isIPV6 !== true &&
              ipV6res.isIPVFuture !==
                true
            ) {
              host =
                normalizePercentEncoding(
                  host,
                  true,
                );
              ipV6res =
                normalizeIPv6(host);
            }
            if (
              ipV6res.isIPV6 === true ||
              ipV6res.isIPVFuture ===
                true
            )
              host = `[${ipV6res.escapedHost}]`;
            else
              host =
                reescapeHostDelimiters(
                  host,
                  false,
                );
          }
          uriTokens.push(host);
        }
        if (
          typeof component.port ===
            "number" ||
          typeof component.port ===
            "string"
        ) {
          const port = String(
            component.port,
          );
          if (!isPort(port))
            throw new TypeError(
              "URI port is malformed.",
            );
          uriTokens.push(":");
          uriTokens.push(port);
        }
        return uriTokens.length
          ? uriTokens.join("")
          : void 0;
      }
      module.exports = {
        nonSimpleDomain,
        recomposeAuthority,
        reescapeHostDelimiters,
        normalizePercentEncoding,
        normalizePathEncoding,
        serializePathEncoding,
        normalizeQueryFragmentEncoding,
        encodeUserinfo,
        encodeQuery,
        encodeFragment,
        escapePreservingEscapes,
        removeDotSegments,
        isIPv4,
        isUUID,
        normalizeIPv6,
        stringArrayToHexStripped,
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/lib/schemes.js
var require_schemes =
  /* @__PURE__ */ __commonJSMin(
    (exports, module) => {
      const { isUUID } =
        require_utils();
      const URN_REG =
        /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
      const supportedSchemeNames = [
        "http",
        "https",
        "ws",
        "wss",
        "urn",
        "urn:uuid",
      ];
      /** @typedef {supportedSchemeNames[number]} SchemeName */
      /**
       * @param {string} name
       * @returns {name is SchemeName}
       */
      function isValidSchemeName(name) {
        return (
          supportedSchemeNames.indexOf(
            name,
          ) !== -1
        );
      }
      /**
       * @callback SchemeFn
       * @param {import('../types/index').URIComponent} component
       * @param {import('../types/index').Options} options
       * @returns {import('../types/index').URIComponent}
       */
      /**
       * @typedef {Object} SchemeHandler
       * @property {SchemeName} scheme - The scheme name.
       * @property {boolean} [domainHost] - Indicates if the scheme supports domain hosts.
       * @property {SchemeFn} parse - Function to parse the URI component for this scheme.
       * @property {SchemeFn} serialize - Function to serialize the URI component for this scheme.
       * @property {boolean} [skipNormalize] - Indicates if normalization should be skipped for this scheme.
       * @property {boolean} [absolutePath] - Indicates if the scheme uses absolute paths.
       * @property {boolean} [unicodeSupport] - Indicates if the scheme supports Unicode.
       */
      /**
       * @param {import('../types/index').URIComponent} wsComponent
       * @returns {boolean}
       */
      function wsIsSecure(wsComponent) {
        if (wsComponent.secure === true)
          return true;
        else if (
          wsComponent.secure === false
        )
          return false;
        else if (wsComponent.scheme)
          return (
            wsComponent.scheme
              .length === 3 &&
            (wsComponent.scheme[0] ===
              "w" ||
              wsComponent.scheme[0] ===
                "W") &&
            (wsComponent.scheme[1] ===
              "s" ||
              wsComponent.scheme[1] ===
                "S") &&
            (wsComponent.scheme[2] ===
              "s" ||
              wsComponent.scheme[2] ===
                "S")
          );
        else return false;
      }
      /** @type {SchemeFn} */
      function httpParse(component) {
        if (!component.host)
          component.error =
            component.error ||
            "HTTP URIs must have a host.";
        return component;
      }
      /** @type {SchemeFn} */
      function httpSerialize(
        component,
      ) {
        const secure =
          String(
            component.scheme,
          ).toLowerCase() === "https";
        if (
          component.port ===
            (secure ? 443 : 80) ||
          component.port === ""
        )
          component.port = void 0;
        if (!component.path)
          component.path = "/";
        return component;
      }
      /** @type {SchemeFn} */
      function wsParse(wsComponent) {
        wsComponent.secure = wsIsSecure(
          wsComponent,
        );
        wsComponent.resourceName =
          (wsComponent.path || "/") +
          (wsComponent.query
            ? "?" + wsComponent.query
            : "");
        wsComponent.path = void 0;
        wsComponent.query = void 0;
        return wsComponent;
      }
      /** @type {SchemeFn} */
      function wsSerialize(
        wsComponent,
      ) {
        if (
          wsComponent.port ===
            (wsIsSecure(wsComponent)
              ? 443
              : 80) ||
          wsComponent.port === ""
        )
          wsComponent.port = void 0;
        if (
          typeof wsComponent.secure ===
          "boolean"
        ) {
          wsComponent.scheme =
            wsComponent.secure
              ? "wss"
              : "ws";
          wsComponent.secure = void 0;
        }
        if (wsComponent.resourceName) {
          const queryIndex =
            wsComponent.resourceName.indexOf(
              "?",
            );
          const path =
            queryIndex === -1
              ? wsComponent.resourceName
              : wsComponent.resourceName.slice(
                  0,
                  queryIndex,
                );
          wsComponent.path =
            path && path !== "/"
              ? path
              : void 0;
          wsComponent.query =
            queryIndex === -1
              ? void 0
              : wsComponent.resourceName.slice(
                  queryIndex + 1,
                );
          wsComponent.resourceName =
            void 0;
        }
        wsComponent.fragment = void 0;
        return wsComponent;
      }
      /** @type {SchemeFn} */
      function urnParse(
        urnComponent,
        options,
      ) {
        if (!urnComponent.path) {
          urnComponent.error =
            "URN can not be parsed";
          return urnComponent;
        }
        const matches =
          urnComponent.path.match(
            URN_REG,
          );
        if (
          matches &&
          matches[0] ===
            urnComponent.path
        ) {
          const scheme =
            options.scheme ||
            urnComponent.scheme ||
            "urn";
          urnComponent.nid =
            matches[1].toLowerCase();
          urnComponent.nss = matches[2];
          const schemeHandler =
            getSchemeHandler(
              `${scheme}:${options.nid || urnComponent.nid}`,
            );
          urnComponent.path = void 0;
          if (schemeHandler)
            urnComponent =
              schemeHandler.parse(
                urnComponent,
                options,
              );
        } else
          urnComponent.error =
            urnComponent.error ||
            "URN can not be parsed.";
        return urnComponent;
      }
      /** @type {SchemeFn} */
      function urnSerialize(
        urnComponent,
        options,
      ) {
        if (urnComponent.nid === void 0)
          throw new Error(
            "URN without nid cannot be serialized",
          );
        const scheme =
          options.scheme ||
          urnComponent.scheme ||
          "urn";
        const nid =
          urnComponent.nid.toLowerCase();
        const schemeHandler =
          getSchemeHandler(
            `${scheme}:${options.nid || nid}`,
          );
        if (schemeHandler)
          urnComponent =
            schemeHandler.serialize(
              urnComponent,
              options,
            );
        const uriComponent =
          urnComponent;
        const nss = urnComponent.nss;
        uriComponent.path = `${nid || options.nid}:${nss}`;
        options.skipEscape = true;
        return uriComponent;
      }
      /** @type {SchemeFn} */
      function urnuuidParse(
        urnComponent,
        options,
      ) {
        const uuidComponent =
          urnComponent;
        uuidComponent.uuid =
          uuidComponent.nss;
        uuidComponent.nss = void 0;
        if (
          !options.tolerant &&
          (!uuidComponent.uuid ||
            !isUUID(uuidComponent.uuid))
        )
          uuidComponent.error =
            uuidComponent.error ||
            "UUID is not valid.";
        return uuidComponent;
      }
      /** @type {SchemeFn} */
      function urnuuidSerialize(
        uuidComponent,
      ) {
        const urnComponent =
          uuidComponent;
        urnComponent.nss = (
          uuidComponent.uuid || ""
        ).toLowerCase();
        return urnComponent;
      }
      const http = {
        scheme: "http",
        domainHost: true,
        parse: httpParse,
        serialize: httpSerialize,
      };
      const https = {
        scheme: "https",
        domainHost: http.domainHost,
        parse: httpParse,
        serialize: httpSerialize,
      };
      const ws = {
        scheme: "ws",
        domainHost: true,
        parse: wsParse,
        serialize: wsSerialize,
      };
      const SCHEMES = {
        http,
        https,
        ws,
        wss: {
          scheme: "wss",
          domainHost: ws.domainHost,
          parse: ws.parse,
          serialize: ws.serialize,
        },
        urn: {
          scheme: "urn",
          parse: urnParse,
          serialize: urnSerialize,
          skipNormalize: true,
        },
        "urn:uuid": {
          scheme: "urn:uuid",
          parse: urnuuidParse,
          serialize: urnuuidSerialize,
          skipNormalize: true,
        },
      };
      Object.setPrototypeOf(
        SCHEMES,
        null,
      );
      /**
       * @param {string|undefined} scheme
       * @returns {SchemeHandler|undefined}
       */
      function getSchemeHandler(
        scheme,
      ) {
        return (
          (scheme &&
            (SCHEMES[scheme] ||
              SCHEMES[
                scheme.toLowerCase()
              ])) ||
          void 0
        );
      }
      module.exports = {
        wsIsSecure,
        SCHEMES,
        isValidSchemeName,
        getSchemeHandler,
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/index.js
var require_fast_uri =
  /* @__PURE__ */ __commonJSMin(
    (exports, module) => {
      const {
        normalizeIPv6,
        removeDotSegments,
        recomposeAuthority,
        normalizePercentEncoding,
        normalizePathEncoding,
        serializePathEncoding,
        normalizeQueryFragmentEncoding,
        encodeQuery,
        encodeFragment,
        reescapeHostDelimiters,
        isIPv4,
        nonSimpleDomain,
      } = require_utils();
      const {
        SCHEMES,
        getSchemeHandler,
      } = require_schemes();
      const VALID_SCHEME =
        /^[A-Za-z][A-Za-z0-9+.-]*$/u;
      const MALFORMED_SCHEME_ERROR =
        "URI scheme is malformed.";
      /**
       * @param {string} scheme
       * @returns {string}
       */
      function decodeValidScheme(
        scheme,
      ) {
        const decodedScheme = unescape(
          String(scheme),
        );
        if (
          !VALID_SCHEME.test(
            decodedScheme,
          )
        )
          throw new TypeError(
            MALFORMED_SCHEME_ERROR,
          );
        return decodedScheme;
      }
      /**
       * @template {import('./types/index').URIComponent|string} T
       * @param {T} uri
       * @param {import('./types/index').Options} [options]
       * @returns {T}
       */
      function normalize(uri, options) {
        if (typeof uri === "string")
          uri = normalizeString(
            uri,
            options,
          );
        else if (
          typeof uri === "object"
        )
          uri = parse(
            serialize(uri, options),
            options,
          );
        return uri;
      }
      /**
       * @param {string} baseURI
       * @param {string} relativeURI
       * @param {import('./types/index').Options} [options]
       * @returns {string}
       */
      function resolve(
        baseURI,
        relativeURI,
        options,
      ) {
        const schemelessOptions =
          options
            ? Object.assign(
                { scheme: "null" },
                options,
              )
            : { scheme: "null" };
        const {
          parsed: baseParsed,
          malformedAuthorityOrPort:
            baseMalformed,
          malformedPercentEncoding:
            baseMalformedPercentEncoding,
          malformedSchemeSpecific:
            baseMalformedSchemeSpecific,
          malformedHost:
            baseMalformedHost,
          malformedScheme:
            baseMalformedScheme,
        } = parseWithStatus(
          baseURI,
          schemelessOptions,
        );
        const {
          parsed: relativeParsed,
          malformedAuthorityOrPort:
            relativeMalformed,
          malformedPercentEncoding:
            relativeMalformedPercentEncoding,
          malformedSchemeSpecific:
            relativeMalformedSchemeSpecific,
          malformedHost:
            relativeMalformedHost,
          malformedScheme:
            relativeMalformedScheme,
        } = parseWithStatus(
          relativeURI,
          schemelessOptions,
        );
        if (
          baseMalformed ||
          relativeMalformed ||
          baseMalformedPercentEncoding ||
          relativeMalformedPercentEncoding ||
          baseMalformedSchemeSpecific ||
          relativeMalformedSchemeSpecific ||
          baseMalformedHost ||
          relativeMalformedHost ||
          baseMalformedScheme ||
          relativeMalformedScheme
        )
          throw new Error(
            baseParsed.error ||
              relativeParsed.error ||
              "URI is malformed.",
          );
        const resolved =
          resolveComponent(
            baseParsed,
            relativeParsed,
            schemelessOptions,
            true,
          );
        const resolvedSchemeHandler =
          getSchemeHandler(
            (options &&
              options.scheme) ||
              resolved.scheme,
          );
        const resolvedHost =
          resolved.host;
        const resolvedHostIsIP =
          resolvedHost !== void 0 &&
          resolvedHost !== "" &&
          (isIPv4(resolvedHost) ||
            normalizeIPv6(resolvedHost)
              .isIPV6);
        canonicalizeHost(
          resolved,
          options || {},
          resolvedSchemeHandler,
          resolvedHostIsIP,
        );
        const encodedASCIIHost =
          resolvedHost &&
          resolvedHost.indexOf("%") !==
            -1 &&
          !/\P{ASCII}/u.test(
            resolvedHost,
          );
        if (
          resolved.error &&
          !encodedASCIIHost
        )
          throw new Error(
            resolved.error,
          );
        schemelessOptions.skipEscape = true;
        return serialize(
          resolved,
          schemelessOptions,
        );
      }
      /**
       * @param {import ('./types/index').URIComponent} base
       * @param {import ('./types/index').URIComponent} relative
       * @param {import('./types/index').Options} [options]
       * @param {boolean} [skipNormalization=false]
       * @returns {import ('./types/index').URIComponent}
       */
      function resolveComponent(
        base,
        relative,
        options,
        skipNormalization,
      ) {
        /** @type {import('./types/index').URIComponent} */
        const target = {};
        if (!skipNormalization) {
          base = parse(
            serialize(base, options),
            options,
          );
          relative = parse(
            serialize(
              relative,
              options,
            ),
            options,
          );
        }
        options = options || {};
        if (
          !options.tolerant &&
          relative.scheme
        ) {
          target.scheme =
            relative.scheme;
          target.userinfo =
            relative.userinfo;
          target.host = relative.host;
          target.port = relative.port;
          target.path =
            removeDotSegments(
              relative.path || "",
            );
          target.query = relative.query;
        } else {
          if (
            relative.userinfo !==
              void 0 ||
            relative.host !== void 0 ||
            relative.port !== void 0
          ) {
            target.userinfo =
              relative.userinfo;
            target.host = relative.host;
            target.port = relative.port;
            target.path =
              removeDotSegments(
                relative.path || "",
              );
            target.query =
              relative.query;
          } else {
            if (!relative.path) {
              target.path = base.path;
              if (
                relative.query !==
                void 0
              )
                target.query =
                  relative.query;
              else
                target.query =
                  base.query;
            } else {
              if (
                relative.path[0] === "/"
              )
                target.path =
                  removeDotSegments(
                    relative.path,
                  );
              else {
                if (
                  (base.userinfo !==
                    void 0 ||
                    base.host !==
                      void 0 ||
                    base.port !==
                      void 0) &&
                  !base.path
                )
                  target.path =
                    "/" + relative.path;
                else if (!base.path)
                  target.path =
                    relative.path;
                else
                  target.path =
                    base.path.slice(
                      0,
                      base.path.lastIndexOf(
                        "/",
                      ) + 1,
                    ) + relative.path;
                target.path =
                  removeDotSegments(
                    target.path,
                  );
              }
              target.query =
                relative.query;
            }
            target.userinfo =
              base.userinfo;
            target.host = base.host;
            target.port = base.port;
          }
          target.scheme = base.scheme;
        }
        target.fragment =
          relative.fragment;
        return target;
      }
      /**
       * @param {import ('./types/index').URIComponent|string} uriA
       * @param {import ('./types/index').URIComponent|string} uriB
       * @param {import ('./types/index').Options} options
       * @returns {boolean}
       */
      function equal(
        uriA,
        uriB,
        options,
      ) {
        const normalizedA =
          normalizeComparableURI(
            uriA,
            options,
          );
        const normalizedB =
          normalizeComparableURI(
            uriB,
            options,
          );
        return (
          normalizedA !== void 0 &&
          normalizedB !== void 0 &&
          normalizedA === normalizedB
        );
      }
      /**
       * @param {Readonly<import('./types/index').URIComponent>} cmpts
       * @param {import('./types/index').Options} [opts]
       * @returns {string}
       */
      function serialize(cmpts, opts) {
        const component = {
          host: cmpts.host,
          scheme: cmpts.scheme,
          userinfo: cmpts.userinfo,
          port: cmpts.port,
          path: cmpts.path,
          query: cmpts.query,
          nid: cmpts.nid,
          nss: cmpts.nss,
          uuid: cmpts.uuid,
          fragment: cmpts.fragment,
          reference: cmpts.reference,
          resourceName:
            cmpts.resourceName,
          secure: cmpts.secure,
          error: "",
        };
        const options = Object.assign(
          {},
          opts,
        );
        const uriTokens = [];
        if (component.scheme)
          component.scheme =
            decodeValidScheme(
              component.scheme,
            );
        const schemeHandler =
          getSchemeHandler(
            options.scheme ||
              component.scheme,
          );
        if (
          schemeHandler &&
          schemeHandler.serialize
        )
          schemeHandler.serialize(
            component,
            options,
          );
        const hasAuthority =
          component.userinfo !==
            void 0 ||
          component.host !== void 0 ||
          component.port !== void 0;
        const pathNoScheme =
          !options.skipEscape &&
          component.scheme === void 0 &&
          !hasAuthority;
        if (component.path !== void 0) {
          if (!options.skipEscape)
            component.path =
              serializePathEncoding(
                component.path,
                pathNoScheme,
              );
          else
            component.path =
              normalizePercentEncoding(
                component.path,
              );
        }
        if (
          options.reference !==
            "suffix" &&
          component.scheme
        ) {
          component.scheme =
            decodeValidScheme(
              component.scheme,
            );
          uriTokens.push(
            component.scheme,
            ":",
          );
        }
        const authority =
          recomposeAuthority(component);
        if (authority !== void 0) {
          if (
            options.reference !==
            "suffix"
          )
            uriTokens.push("//");
          uriTokens.push(authority);
          if (
            component.path &&
            component.path[0] !== "/"
          )
            uriTokens.push("/");
        }
        if (component.path !== void 0) {
          let s = component.path;
          if (
            !options.absolutePath &&
            (!schemeHandler ||
              !schemeHandler.absolutePath)
          )
            s = removeDotSegments(s);
          if (pathNoScheme)
            s = serializePathEncoding(
              s,
              true,
            );
          if (
            authority === void 0 &&
            s[0] === "/" &&
            s[1] === "/"
          )
            s = "/%2F" + s.slice(2);
          uriTokens.push(s);
        }
        if (component.query !== void 0)
          uriTokens.push(
            "?",
            encodeQuery(
              component.query,
            ),
          );
        if (
          component.fragment !== void 0
        )
          uriTokens.push(
            "#",
            encodeFragment(
              component.fragment,
            ),
          );
        return uriTokens.join("");
      }
      const URI_PARSE =
        /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
      const AUTHORITY_PREFIX =
        /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
      const AUTHORITY_INTRODUCER_REGION =
        /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/;
      /**
       * @param {import('./types/index').URIComponent} parsed
       * @param {RegExpMatchArray} matches
       * @returns {string|undefined}
       */
      function getParseError(
        parsed,
        matches,
      ) {
        if (
          matches[2] !== void 0 &&
          parsed.path &&
          parsed.path[0] !== "/"
        )
          return 'URI path must start with "/" when authority is present.';
        if (
          typeof parsed.port ===
            "number" &&
          (parsed.port < 0 ||
            parsed.port > 65535)
        )
          return "URI port is malformed.";
      }
      /**
       * Checks percent syntax without decoding the represented octets. RFC 3986
       * percent-encoding is byte-oriented, so sequences such as `%FF` are valid even
       * though they are not independently valid UTF-8.
       *
       * @param {string|undefined} component
       * @returns {boolean}
       */
      function hasMalformedPercentEncoding(
        component,
      ) {
        if (component === void 0)
          return false;
        let percent =
          component.indexOf("%");
        while (percent !== -1) {
          if (
            percent + 2 >=
              component.length ||
            !/^[\da-f]{2}$/iu.test(
              component.slice(
                percent + 1,
                percent + 3,
              ),
            )
          )
            return true;
          percent = component.indexOf(
            "%",
            percent + 3,
          );
        }
        return false;
      }
      /**
       * Whether the host is a bracketed IP literal (RFC 3986 `IP-literal`).
       * An unterminated `[` is not a literal, so it must still be validated as a
       * reg-name instead of being waved through as an IP.
       *
       * @param {string} host
       * @returns {boolean}
       */
      function isIPLiteral(host) {
        return (
          host[0] === "[" &&
          host[host.length - 1] === "]"
        );
      }
      /**
       * @param {RegExpMatchArray} matches
       * @returns {boolean}
       */
      function hasMalformedComponentPercentEncoding(
        matches,
      ) {
        const host = matches[4];
        return (
          hasMalformedPercentEncoding(
            matches[3],
          ) ||
          (host !== void 0 &&
            !isIPLiteral(host) &&
            hasMalformedPercentEncoding(
              host,
            )) ||
          hasMalformedPercentEncoding(
            matches[6],
          ) ||
          hasMalformedPercentEncoding(
            matches[7],
          ) ||
          hasMalformedPercentEncoding(
            matches[8],
          )
        );
      }
      /**
       * @param {import('./types/index').URIComponent} parsed
       * @param {import('./types/index').Options} options
       * @param {{ domainHost?: boolean, unicodeSupport?: boolean }|undefined} schemeHandler
       * @param {boolean} isIP
       * @returns {boolean} whether host conversion failed
       */
      function canonicalizeHost(
        parsed,
        options,
        schemeHandler,
        isIP,
      ) {
        if (
          !options.unicodeSupport &&
          (!schemeHandler ||
            !schemeHandler.unicodeSupport) &&
          parsed.host &&
          !isIPLiteral(parsed.host) &&
          (options.domainHost ||
            (schemeHandler &&
              schemeHandler.domainHost)) &&
          isIP === false &&
          nonSimpleDomain(parsed.host)
        )
          try {
            parsed.host = new URL(
              "http://" + parsed.host,
            ).hostname;
          } catch (e) {
            parsed.error =
              parsed.error ||
              "Host's domain name can not be converted to ASCII: " +
                e;
            return true;
          }
        return false;
      }
      /**
       * @param {string} uri
       * @param {import('./types/index').Options} [opts]
       * @returns {{ parsed: import('./types/index').URIComponent, malformedAuthorityOrPort: boolean, malformedPercentEncoding: boolean, malformedSchemeSpecific: boolean, malformedHost: boolean, malformedScheme: boolean }}
       */
      function parseWithStatus(
        uri,
        opts,
      ) {
        const options = Object.assign(
          {},
          opts,
        );
        /** @type {import('./types/index').URIComponent} */
        const parsed = {
          scheme: void 0,
          userinfo: void 0,
          host: "",
          port: void 0,
          path: "",
          query: void 0,
          fragment: void 0,
        };
        let malformedAuthorityOrPort = false;
        let malformedPercentEncoding = false;
        let malformedSchemeSpecific = false;
        let malformedHost = false;
        let malformedIPLiteral = false;
        let malformedScheme = false;
        let isIP = false;
        if (
          options.reference === "suffix"
        ) {
          if (options.scheme)
            uri =
              options.scheme +
              ":" +
              uri;
          else uri = "//" + uri;
        }
        const authorityMatch =
          uri.match(AUTHORITY_PREFIX);
        if (
          authorityMatch !== null &&
          authorityMatch[1].indexOf(
            "\\",
          ) !== -1
        ) {
          parsed.error =
            "URI authority must not contain a literal backslash.";
          malformedAuthorityOrPort = true;
        }
        const introducerMatch =
          uri.match(
            AUTHORITY_INTRODUCER_REGION,
          );
        if (introducerMatch !== null) {
          const region =
            introducerMatch[1];
          const normalizedRegion =
            region.replace(
              /[\t\n\r]/g,
              "",
            );
          if (
            normalizedRegion.length >= 2
          ) {
            if (
              normalizedRegion.slice(
                0,
                2,
              ) !== "//"
            ) {
              parsed.error =
                parsed.error ||
                "URI authority must not contain a literal backslash.";
              malformedAuthorityOrPort = true;
            } else if (
              region.length !==
              normalizedRegion.length
            ) {
              parsed.error =
                parsed.error ||
                "URI authority introducer must not contain whitespace.";
              malformedAuthorityOrPort = true;
            }
          }
        }
        const matches =
          uri.match(URI_PARSE);
        if (matches) {
          parsed.scheme = matches[1];
          parsed.userinfo = matches[3];
          parsed.host = matches[4];
          parsed.port = parseInt(
            matches[5],
            10,
          );
          parsed.path =
            matches[6] || "";
          parsed.query = matches[7];
          parsed.fragment = matches[8];
          if (
            parsed.scheme !== void 0
          ) {
            const decodedScheme =
              unescape(parsed.scheme);
            if (
              VALID_SCHEME.test(
                decodedScheme,
              )
            )
              parsed.scheme =
                decodedScheme.toLowerCase();
            else {
              parsed.error =
                parsed.error ||
                MALFORMED_SCHEME_ERROR;
              malformedScheme = true;
            }
          }
          malformedPercentEncoding =
            hasMalformedComponentPercentEncoding(
              matches,
            );
          if (malformedPercentEncoding)
            parsed.error =
              parsed.error ||
              "URI contains malformed percent-encoding.";
          if (isNaN(parsed.port))
            parsed.port = matches[5];
          const parseError =
            getParseError(
              parsed,
              matches,
            );
          if (parseError !== void 0) {
            parsed.error =
              parsed.error ||
              parseError;
            malformedAuthorityOrPort = true;
          }
          if (parsed.host) {
            if (
              isIPv4(parsed.host) ===
              false
            ) {
              const bracketedIPLiteral =
                isIPLiteral(
                  parsed.host,
                );
              const hasIPLiteralBracket =
                parsed.host.indexOf(
                  "[",
                ) !== -1 ||
                parsed.host.indexOf(
                  "]",
                ) !== -1;
              const ipv6result =
                normalizeIPv6(
                  parsed.host,
                );
              isIP =
                ipv6result.isIPV6 ||
                ipv6result.isIPVFuture ===
                  true;
              malformedIPLiteral =
                hasIPLiteralBracket &&
                (!bracketedIPLiteral ||
                  ipv6result.error ===
                    true);
              parsed.host = isIP
                ? ipv6result.host
                : ipv6result.host.toLowerCase();
              if (malformedIPLiteral) {
                parsed.error =
                  parsed.error ||
                  "URI host is malformed.";
                malformedAuthorityOrPort = true;
              }
            } else isIP = true;
          }
          if (
            parsed.scheme === void 0 &&
            parsed.userinfo ===
              void 0 &&
            parsed.host === void 0 &&
            parsed.port === void 0 &&
            parsed.query === void 0 &&
            !parsed.path
          )
            parsed.reference =
              "same-document";
          else if (
            parsed.scheme === void 0
          )
            parsed.reference =
              "relative";
          else if (
            parsed.fragment === void 0
          )
            parsed.reference =
              "absolute";
          else parsed.reference = "uri";
          if (
            options.reference &&
            options.reference !==
              "suffix" &&
            options.reference !==
              parsed.reference
          )
            parsed.error =
              parsed.error ||
              "URI is not a " +
                options.reference +
                " reference.";
          const schemeHandler =
            getSchemeHandler(
              options.scheme ||
                parsed.scheme,
            );
          if (!malformedIPLiteral)
            malformedHost =
              canonicalizeHost(
                parsed,
                options,
                schemeHandler,
                isIP,
              );
          if (
            uri.indexOf("%") !== -1 &&
            parsed.host !== void 0 &&
            !malformedIPLiteral
          ) {
            let host = isIP
              ? parsed.host
              : normalizePercentEncoding(
                  parsed.host,
                  true,
                );
            if (!isIP)
              host =
                normalizePercentEncoding(
                  host.toLowerCase(),
                );
            parsed.host =
              reescapeHostDelimiters(
                host,
                isIP,
              );
          }
          if (
            !schemeHandler ||
            (schemeHandler &&
              !schemeHandler.skipNormalize)
          ) {
            if (parsed.path)
              parsed.path =
                normalizePathEncoding(
                  parsed.path,
                );
            if (parsed.query)
              parsed.query =
                normalizeQueryFragmentEncoding(
                  parsed.query,
                );
            if (parsed.fragment)
              parsed.fragment =
                normalizeQueryFragmentEncoding(
                  parsed.fragment,
                );
          }
          if (
            schemeHandler &&
            schemeHandler.parse
          ) {
            schemeHandler.parse(
              parsed,
              options,
            );
            if (
              schemeHandler ===
                SCHEMES.urn &&
              parsed.nid === void 0
            )
              malformedSchemeSpecific = true;
          }
        } else
          parsed.error =
            parsed.error ||
            "URI can not be parsed.";
        return {
          parsed,
          malformedAuthorityOrPort,
          malformedPercentEncoding,
          malformedSchemeSpecific,
          malformedHost,
          malformedScheme,
        };
      }
      /**
       * @param {string} uri
       * @param {import('./types/index').Options} [opts]
       * @returns
       */
      function parse(uri, opts) {
        return parseWithStatus(
          uri,
          opts,
        ).parsed;
      }
      /**
       * @param {string} uri
       * @param {import('./types/index').Options} [opts]
       * @returns {string}
       */
      function normalizeString(
        uri,
        opts,
      ) {
        return normalizeStringWithStatus(
          uri,
          opts,
        ).normalized;
      }
      /**
       * @param {string} uri
       * @param {import('./types/index').Options} [opts]
       * @returns {{ normalized: string, malformedAuthorityOrPort: boolean, malformedPercentEncoding: boolean, malformedSchemeSpecific: boolean, malformedHost: boolean, malformedScheme: boolean }}
       */
      function normalizeStringWithStatus(
        uri,
        opts,
      ) {
        const {
          parsed,
          malformedAuthorityOrPort,
          malformedPercentEncoding,
          malformedSchemeSpecific,
          malformedHost,
          malformedScheme,
        } = parseWithStatus(uri, opts);
        return {
          normalized:
            malformedAuthorityOrPort ||
            malformedPercentEncoding ||
            malformedSchemeSpecific ||
            malformedHost ||
            malformedScheme
              ? uri
              : serialize(parsed, opts),
          malformedAuthorityOrPort,
          malformedPercentEncoding,
          malformedSchemeSpecific,
          malformedHost,
          malformedScheme,
        };
      }
      /**
       * @param {import ('./types/index').URIComponent|string} uri
       * @param {import('./types/index').Options} [opts]
       * @returns {string|undefined}
       */
      function normalizeComparableURI(
        uri,
        opts,
      ) {
        if (
          typeof uri !== "string" &&
          typeof uri !== "object"
        )
          return;
        let value;
        try {
          value =
            typeof uri === "string"
              ? uri
              : serialize(uri, opts);
        } catch {
          return;
        }
        const {
          normalized,
          malformedAuthorityOrPort,
          malformedPercentEncoding,
          malformedSchemeSpecific,
          malformedHost,
          malformedScheme,
        } = normalizeStringWithStatus(
          value,
          opts,
        );
        return malformedAuthorityOrPort ||
          malformedPercentEncoding ||
          malformedSchemeSpecific ||
          malformedHost ||
          malformedScheme
          ? void 0
          : normalized;
      }
      const fastUri = {
        SCHEMES,
        normalize,
        resolve,
        resolveComponent,
        equal,
        serialize,
        parse,
      };
      module.exports = fastUri;
      module.exports.default = fastUri;
      module.exports.fastUri = fastUri;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/uri.js
var require_uri =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const uri = require_fast_uri();
      uri.code =
        'require("ajv/dist/runtime/uri").default';
      exports.default = uri;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/core.js
var require_core$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.CodeGen =
        exports.Name =
        exports.nil =
        exports.stringify =
        exports.str =
        exports._ =
        exports.KeywordCxt =
          void 0;
      var validate_1 =
        require_validate();
      Object.defineProperty(
        exports,
        "KeywordCxt",
        {
          enumerable: true,
          get: function () {
            return validate_1.KeywordCxt;
          },
        },
      );
      var codegen_1 = require_codegen();
      Object.defineProperty(
        exports,
        "_",
        {
          enumerable: true,
          get: function () {
            return codegen_1._;
          },
        },
      );
      Object.defineProperty(
        exports,
        "str",
        {
          enumerable: true,
          get: function () {
            return codegen_1.str;
          },
        },
      );
      Object.defineProperty(
        exports,
        "stringify",
        {
          enumerable: true,
          get: function () {
            return codegen_1.stringify;
          },
        },
      );
      Object.defineProperty(
        exports,
        "nil",
        {
          enumerable: true,
          get: function () {
            return codegen_1.nil;
          },
        },
      );
      Object.defineProperty(
        exports,
        "Name",
        {
          enumerable: true,
          get: function () {
            return codegen_1.Name;
          },
        },
      );
      Object.defineProperty(
        exports,
        "CodeGen",
        {
          enumerable: true,
          get: function () {
            return codegen_1.CodeGen;
          },
        },
      );
      const validation_error_1 =
        require_validation_error();
      const ref_error_1 =
        require_ref_error();
      const rules_1 = require_rules();
      const compile_1 =
        require_compile();
      const codegen_2 =
        require_codegen();
      const resolve_1 =
        require_resolve();
      const dataType_1 =
        require_dataType();
      const util_1 = require_util();
      const $dataRefSchema =
        require_data();
      const uri_1 = require_uri();
      const defaultRegExp = (
        str,
        flags,
      ) => new RegExp(str, flags);
      defaultRegExp.code = "new RegExp";
      const META_IGNORE_OPTIONS = [
        "removeAdditional",
        "useDefaults",
        "coerceTypes",
      ];
      const EXT_SCOPE_NAMES =
        /* @__PURE__ */ new Set([
          "validate",
          "serialize",
          "parse",
          "wrapper",
          "root",
          "schema",
          "keyword",
          "pattern",
          "formats",
          "validate$data",
          "func",
          "obj",
          "Error",
        ]);
      const 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.",
      };
      const deprecatedOptions = {
        ignoreKeywordsWithRef: "",
        jsPropertySyntax: "",
        unicode:
          '"minLength"/"maxLength" account for unicode characters by default.',
      };
      const MAX_EXPRESSION = 200;
      function requiredOptions(o) {
        var _a,
          _b,
          _c,
          _d,
          _e,
          _f,
          _g,
          _h,
          _j,
          _k,
          _l,
          _m,
          _o,
          _p,
          _q,
          _r,
          _s,
          _t,
          _u,
          _v,
          _w,
          _x,
          _y,
          _z,
          _0;
        const s = o.strict;
        const _optz =
          (_a = o.code) === null ||
          _a === void 0
            ? void 0
            : _a.optimize;
        const optimize =
          _optz === true ||
          _optz === void 0
            ? 1
            : _optz || 0;
        const regExp =
          (_c =
            (_b = o.code) === null ||
            _b === void 0
              ? void 0
              : _b.regExp) !== null &&
          _c !== void 0
            ? _c
            : defaultRegExp;
        const uriResolver =
          (_d = o.uriResolver) !==
            null && _d !== void 0
            ? _d
            : uri_1.default;
        return {
          strictSchema:
            (_f =
              (_e = o.strictSchema) !==
                null && _e !== void 0
                ? _e
                : s) !== null &&
            _f !== void 0
              ? _f
              : true,
          strictNumbers:
            (_h =
              (_g = o.strictNumbers) !==
                null && _g !== void 0
                ? _g
                : s) !== null &&
            _h !== void 0
              ? _h
              : true,
          strictTypes:
            (_k =
              (_j = o.strictTypes) !==
                null && _j !== void 0
                ? _j
                : s) !== null &&
            _k !== void 0
              ? _k
              : "log",
          strictTuples:
            (_m =
              (_l = o.strictTuples) !==
                null && _l !== void 0
                ? _l
                : s) !== null &&
            _m !== void 0
              ? _m
              : "log",
          strictRequired:
            (_p =
              (_o =
                o.strictRequired) !==
                null && _o !== void 0
                ? _o
                : s) !== null &&
            _p !== void 0
              ? _p
              : false,
          code: o.code
            ? {
                ...o.code,
                optimize,
                regExp,
              }
            : {
                optimize,
                regExp,
              },
          loopRequired:
            (_q = o.loopRequired) !==
              null && _q !== void 0
              ? _q
              : MAX_EXPRESSION,
          loopEnum:
            (_r = o.loopEnum) !==
              null && _r !== void 0
              ? _r
              : MAX_EXPRESSION,
          meta:
            (_s = o.meta) !== null &&
            _s !== void 0
              ? _s
              : true,
          messages:
            (_t = o.messages) !==
              null && _t !== void 0
              ? _t
              : true,
          inlineRefs:
            (_u = o.inlineRefs) !==
              null && _u !== void 0
              ? _u
              : true,
          schemaId:
            (_v = o.schemaId) !==
              null && _v !== void 0
              ? _v
              : "$id",
          addUsedSchema:
            (_w = o.addUsedSchema) !==
              null && _w !== void 0
              ? _w
              : true,
          validateSchema:
            (_x = o.validateSchema) !==
              null && _x !== void 0
              ? _x
              : true,
          validateFormats:
            (_y = o.validateFormats) !==
              null && _y !== void 0
              ? _y
              : true,
          unicodeRegExp:
            (_z = o.unicodeRegExp) !==
              null && _z !== void 0
              ? _z
              : true,
          int32range:
            (_0 = o.int32range) !==
              null && _0 !== void 0
              ? _0
              : true,
          uriResolver,
        };
      }
      var Ajv = class {
        constructor(opts = {}) {
          this.schemas = {};
          this.refs = {};
          this.formats =
            Object.create(null);
          this._compilations =
            /* @__PURE__ */ new Set();
          this._loading = {};
          this._cache =
            /* @__PURE__ */ new Map();
          opts = this.opts = {
            ...opts,
            ...requiredOptions(opts),
          };
          const { es5, lines } =
            this.opts.code;
          this.scope =
            new codegen_2.ValueScope({
              scope: {},
              prefixes: EXT_SCOPE_NAMES,
              es5,
              lines,
            });
          this.logger = getLogger(
            opts.logger,
          );
          const formatOpt =
            opts.validateFormats;
          opts.validateFormats = false;
          this.RULES = (0,
          rules_1.getRules)();
          checkOptions.call(
            this,
            removedOptions,
            opts,
            "NOT SUPPORTED",
          );
          checkOptions.call(
            this,
            deprecatedOptions,
            opts,
            "DEPRECATED",
            "warn",
          );
          this._metaOpts =
            getMetaSchemaOptions.call(
              this,
            );
          if (opts.formats)
            addInitialFormats.call(
              this,
            );
          this._addVocabularies();
          this._addDefaultMetaSchema();
          if (opts.keywords)
            addInitialKeywords.call(
              this,
              opts.keywords,
            );
          if (
            typeof opts.meta == "object"
          )
            this.addMetaSchema(
              opts.meta,
            );
          addInitialSchemas.call(this);
          opts.validateFormats =
            formatOpt;
        }
        _addVocabularies() {
          this.addKeyword("$async");
        }
        _addDefaultMetaSchema() {
          const {
            $data,
            meta,
            schemaId,
          } = this.opts;
          let _dataRefSchema =
            $dataRefSchema;
          if (schemaId === "id") {
            _dataRefSchema = {
              ...$dataRefSchema,
            };
            _dataRefSchema.id =
              _dataRefSchema.$id;
            delete _dataRefSchema.$id;
          }
          if (meta && $data)
            this.addMetaSchema(
              _dataRefSchema,
              _dataRefSchema[schemaId],
              false,
            );
        }
        defaultMeta() {
          const { meta, schemaId } =
            this.opts;
          return (this.opts.defaultMeta =
            typeof meta == "object"
              ? meta[schemaId] || meta
              : void 0);
        }
        validate(schemaKeyRef, data) {
          let v;
          if (
            typeof schemaKeyRef ==
            "string"
          ) {
            v = this.getSchema(
              schemaKeyRef,
            );
            if (!v)
              throw new Error(
                `no schema with key or ref "${schemaKeyRef}"`,
              );
          } else
            v = this.compile(
              schemaKeyRef,
            );
          const valid = v(data);
          if (!("$async" in v))
            this.errors = v.errors;
          return valid;
        }
        compile(schema, _meta) {
          const sch = this._addSchema(
            schema,
            _meta,
          );
          return (
            sch.validate ||
            this._compileSchemaEnv(sch)
          );
        }
        compileAsync(schema, meta) {
          if (
            typeof this.opts
              .loadSchema != "function"
          )
            throw new Error(
              "options.loadSchema should be a function",
            );
          const { loadSchema } =
            this.opts;
          return runCompileAsync.call(
            this,
            schema,
            meta,
          );
          async function runCompileAsync(
            _schema,
            _meta,
          ) {
            await loadMetaSchema.call(
              this,
              _schema.$schema,
            );
            const sch = this._addSchema(
              _schema,
              _meta,
            );
            return (
              sch.validate ||
              _compileAsync.call(
                this,
                sch,
              )
            );
          }
          async function loadMetaSchema(
            $ref,
          ) {
            if (
              $ref &&
              !this.getSchema($ref)
            )
              await runCompileAsync.call(
                this,
                { $ref },
                true,
              );
          }
          async function _compileAsync(
            sch,
          ) {
            try {
              return this._compileSchemaEnv(
                sch,
              );
            } catch (e) {
              if (
                !(
                  e instanceof
                  ref_error_1.default
                )
              )
                throw e;
              checkLoaded.call(this, e);
              await loadMissingSchema.call(
                this,
                e.missingSchema,
              );
              return _compileAsync.call(
                this,
                sch,
              );
            }
          }
          function checkLoaded({
            missingSchema: ref,
            missingRef,
          }) {
            if (this.refs[ref])
              throw new Error(
                `AnySchema ${ref} is loaded but ${missingRef} cannot be resolved`,
              );
          }
          async function loadMissingSchema(
            ref,
          ) {
            const _schema =
              await _loadSchema.call(
                this,
                ref,
              );
            if (!this.refs[ref])
              await loadMetaSchema.call(
                this,
                _schema.$schema,
              );
            if (!this.refs[ref])
              this.addSchema(
                _schema,
                ref,
                meta,
              );
          }
          async function _loadSchema(
            ref,
          ) {
            const p =
              this._loading[ref];
            if (p) return p;
            try {
              return await (this._loading[
                ref
              ] = loadSchema(ref));
            } finally {
              delete this._loading[ref];
            }
          }
        }
        addSchema(
          schema,
          key,
          _meta,
          _validateSchema = this.opts
            .validateSchema,
        ) {
          if (Array.isArray(schema)) {
            for (const sch of schema)
              this.addSchema(
                sch,
                void 0,
                _meta,
                _validateSchema,
              );
            return this;
          }
          let id;
          if (
            typeof schema === "object"
          ) {
            const { schemaId } =
              this.opts;
            id = schema[schemaId];
            if (
              id !== void 0 &&
              typeof id != "string"
            )
              throw new Error(
                `schema ${schemaId} must be string`,
              );
          }
          key = (0,
          resolve_1.normalizeId)(
            key || id,
          );
          this._checkUnique(key);
          this.schemas[key] =
            this._addSchema(
              schema,
              _meta,
              key,
              _validateSchema,
              true,
            );
          return this;
        }
        addMetaSchema(
          schema,
          key,
          _validateSchema = this.opts
            .validateSchema,
        ) {
          this.addSchema(
            schema,
            key,
            true,
            _validateSchema,
          );
          return this;
        }
        validateSchema(
          schema,
          throwOrLogError,
        ) {
          if (
            typeof schema == "boolean"
          )
            return true;
          let $schema;
          $schema = schema.$schema;
          if (
            $schema !== void 0 &&
            typeof $schema != "string"
          )
            throw new Error(
              "$schema must be a string",
            );
          $schema =
            $schema ||
            this.opts.defaultMeta ||
            this.defaultMeta();
          if (!$schema) {
            this.logger.warn(
              "meta-schema not available",
            );
            this.errors = null;
            return true;
          }
          const valid = this.validate(
            $schema,
            schema,
          );
          if (
            !valid &&
            throwOrLogError
          ) {
            const message =
              "schema is invalid: " +
              this.errorsText();
            if (
              this.opts
                .validateSchema ===
              "log"
            )
              this.logger.error(
                message,
              );
            else
              throw new Error(message);
          }
          return valid;
        }
        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)
          );
        }
        removeSchema(schemaKeyRef) {
          if (
            schemaKeyRef instanceof
            RegExp
          ) {
            this._removeAllSchemas(
              this.schemas,
              schemaKeyRef,
            );
            this._removeAllSchemas(
              this.refs,
              schemaKeyRef,
            );
            return this;
          }
          switch (typeof schemaKeyRef) {
            case "undefined":
              this._removeAllSchemas(
                this.schemas,
              );
              this._removeAllSchemas(
                this.refs,
              );
              this._cache.clear();
              return this;
            case "string": {
              const sch =
                getSchEnv.call(
                  this,
                  schemaKeyRef,
                );
              if (
                typeof sch == "object"
              )
                this._cache.delete(
                  sch.schema,
                );
              delete this.schemas[
                schemaKeyRef
              ];
              delete this.refs[
                schemaKeyRef
              ];
              return this;
            }
            case "object": {
              const cacheKey =
                schemaKeyRef;
              this._cache.delete(
                cacheKey,
              );
              let id =
                schemaKeyRef[
                  this.opts.schemaId
                ];
              if (id) {
                id = (0,
                resolve_1.normalizeId)(
                  id,
                );
                delete this.schemas[id];
                delete this.refs[id];
              }
              return this;
            }
            default:
              throw new Error(
                "ajv.removeSchema: invalid parameter",
              );
          }
        }
        addVocabulary(definitions) {
          for (const def of definitions)
            this.addKeyword(def);
          return this;
        }
        addKeyword(kwdOrDef, def) {
          let keyword;
          if (
            typeof kwdOrDef == "string"
          ) {
            keyword = kwdOrDef;
            if (
              typeof def == "object"
            ) {
              this.logger.warn(
                "these parameters are deprecated, see docs for addKeyword",
              );
              def.keyword = keyword;
            }
          } else if (
            typeof kwdOrDef ==
              "object" &&
            def === 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;
        }
        removeKeyword(keyword) {
          const { RULES } = this;
          delete RULES.keywords[
            keyword
          ];
          delete RULES.all[keyword];
          for (const group of RULES.rules) {
            const i =
              group.rules.findIndex(
                (rule) =>
                  rule.keyword ===
                  keyword,
              );
            if (i >= 0)
              group.rules.splice(i, 1);
          }
          return this;
        }
        addFormat(name, format) {
          if (typeof format == "string")
            format = new RegExp(format);
          this.formats[name] = format;
          return this;
        }
        errorsText(
          errors = this.errors,
          {
            separator = ", ",
            dataVar = "data",
          } = {},
        ) {
          if (
            !errors ||
            errors.length === 0
          )
            return "No errors";
          return errors
            .map(
              (e) =>
                `${dataVar}${e.instancePath} ${e.message}`,
            )
            .reduce(
              (text, msg) =>
                text + separator + msg,
            );
        }
        $dataMetaSchema(
          metaSchema,
          keywordsJsonPointers,
        ) {
          const rules = this.RULES.all;
          metaSchema = JSON.parse(
            JSON.stringify(metaSchema),
          );
          for (const jsonPointer of keywordsJsonPointers) {
            const segments = jsonPointer
              .split("/")
              .slice(1);
            let keywords = metaSchema;
            for (const seg of segments)
              keywords = keywords[seg];
            for (const key in rules) {
              const rule = rules[key];
              if (
                typeof rule != "object"
              )
                continue;
              const { $data } =
                rule.definition;
              const schema =
                keywords[key];
              if ($data && schema)
                keywords[key] =
                  schemaOrData(schema);
            }
          }
          return metaSchema;
        }
        _removeAllSchemas(
          schemas,
          regex,
        ) {
          for (const keyRef in schemas) {
            const sch = schemas[keyRef];
            if (
              !regex ||
              regex.test(keyRef)
            ) {
              if (
                typeof sch == "string"
              )
                delete schemas[keyRef];
              else if (
                sch &&
                !sch.meta
              ) {
                this._cache.delete(
                  sch.schema,
                );
                delete schemas[keyRef];
              }
            }
          }
        }
        _addSchema(
          schema,
          meta,
          baseId,
          validateSchema = this.opts
            .validateSchema,
          addSchema = this.opts
            .addUsedSchema,
        ) {
          let id;
          const { schemaId } =
            this.opts;
          if (typeof schema == "object")
            id = schema[schemaId];
          else if (this.opts.jtd)
            throw new Error(
              "schema must be object",
            );
          else if (
            typeof schema != "boolean"
          )
            throw new Error(
              "schema must be object or boolean",
            );
          let sch =
            this._cache.get(schema);
          if (sch !== void 0)
            return sch;
          baseId = (0,
          resolve_1.normalizeId)(
            id || baseId,
          );
          const localRefs =
            resolve_1.getSchemaRefs.call(
              this,
              schema,
              baseId,
            );
          sch = new compile_1.SchemaEnv(
            {
              schema,
              schemaId,
              meta,
              baseId,
              localRefs,
            },
          );
          this._cache.set(
            sch.schema,
            sch,
          );
          if (
            addSchema &&
            !baseId.startsWith("#")
          ) {
            if (baseId)
              this._checkUnique(baseId);
            this.refs[baseId] = sch;
          }
          if (validateSchema)
            this.validateSchema(
              schema,
              true,
            );
          return sch;
        }
        _checkUnique(id) {
          if (
            this.schemas[id] ||
            this.refs[id]
          )
            throw new Error(
              `schema with key or id "${id}" already exists`,
            );
        }
        _compileSchemaEnv(sch) {
          if (sch.meta)
            this._compileMetaSchema(
              sch,
            );
          else
            compile_1.compileSchema.call(
              this,
              sch,
            );
          /* istanbul ignore if */
          if (!sch.validate)
            throw new Error(
              "ajv implementation error",
            );
          return sch.validate;
        }
        _compileMetaSchema(sch) {
          const currentOpts = this.opts;
          this.opts = this._metaOpts;
          try {
            compile_1.compileSchema.call(
              this,
              sch,
            );
          } finally {
            this.opts = currentOpts;
          }
        }
      };
      Ajv.ValidationError =
        validation_error_1.default;
      Ajv.MissingRefError =
        ref_error_1.default;
      exports.default = Ajv;
      function checkOptions(
        checkOpts,
        options,
        msg,
        log = "error",
      ) {
        for (const key in checkOpts) {
          const opt = key;
          if (opt in options)
            this.logger[log](
              `${msg}: option ${key}. ${checkOpts[opt]}`,
            );
        }
      }
      function getSchEnv(keyRef) {
        keyRef = (0,
        resolve_1.normalizeId)(keyRef);
        return (
          this.schemas[keyRef] ||
          this.refs[keyRef]
        );
      }
      function addInitialSchemas() {
        const optsSchemas =
          this.opts.schemas;
        if (!optsSchemas) return;
        if (Array.isArray(optsSchemas))
          this.addSchema(optsSchemas);
        else
          for (const key in optsSchemas)
            this.addSchema(
              optsSchemas[key],
              key,
            );
      }
      function addInitialFormats() {
        for (const name in this.opts
          .formats) {
          const format =
            this.opts.formats[name];
          if (format)
            this.addFormat(
              name,
              format,
            );
        }
      }
      function addInitialKeywords(
        defs,
      ) {
        if (Array.isArray(defs)) {
          this.addVocabulary(defs);
          return;
        }
        this.logger.warn(
          "keywords option as map is deprecated, pass array",
        );
        for (const keyword in defs) {
          const def = defs[keyword];
          if (!def.keyword)
            def.keyword = keyword;
          this.addKeyword(def);
        }
      }
      function getMetaSchemaOptions() {
        const metaOpts = {
          ...this.opts,
        };
        for (const opt of META_IGNORE_OPTIONS)
          delete metaOpts[opt];
        return metaOpts;
      }
      const 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",
        );
      }
      const KEYWORD_NAME =
        /^[a-z_$][a-z0-9_$:-]*$/i;
      function checkKeyword(
        keyword,
        def,
      ) {
        const { RULES } = this;
        (0, util_1.eachItem)(
          keyword,
          (kwd) => {
            if (RULES.keywords[kwd])
              throw new Error(
                `Keyword ${kwd} is already defined`,
              );
            if (!KEYWORD_NAME.test(kwd))
              throw new Error(
                `Keyword ${kwd} has invalid name`,
              );
          },
        );
        if (!def) return;
        if (
          def.$data &&
          !(
            "code" in def ||
            "validate" in def
          )
        )
          throw new Error(
            '$data keyword must have "code" or "validate" function',
          );
      }
      function addRule(
        keyword,
        definition,
        dataType,
      ) {
        var _a;
        const post =
          definition === null ||
          definition === void 0
            ? void 0
            : definition.post;
        if (dataType && post)
          throw new Error(
            'keyword with "post" flag cannot have "type"',
          );
        const { RULES } = this;
        let ruleGroup = post
          ? RULES.post
          : RULES.rules.find(
              ({ type: t }) =>
                t === dataType,
            );
        if (!ruleGroup) {
          ruleGroup = {
            type: dataType,
            rules: [],
          };
          RULES.rules.push(ruleGroup);
        }
        RULES.keywords[keyword] = true;
        if (!definition) return;
        const rule = {
          keyword,
          definition: {
            ...definition,
            type: (0,
            dataType_1.getJSONTypes)(
              definition.type,
            ),
            schemaType: (0,
            dataType_1.getJSONTypes)(
              definition.schemaType,
            ),
          },
        };
        if (definition.before)
          addBeforeRule.call(
            this,
            ruleGroup,
            rule,
            definition.before,
          );
        else ruleGroup.rules.push(rule);
        RULES.all[keyword] = rule;
        (_a = definition.implements) ===
          null ||
          _a === void 0 ||
          _a.forEach((kwd) =>
            this.addKeyword(kwd),
          );
      }
      function addBeforeRule(
        ruleGroup,
        rule,
        before,
      ) {
        const i =
          ruleGroup.rules.findIndex(
            (_rule) =>
              _rule.keyword === before,
          );
        if (i >= 0)
          ruleGroup.rules.splice(
            i,
            0,
            rule,
          );
        else {
          ruleGroup.rules.push(rule);
          this.logger.warn(
            `rule ${before} is not defined`,
          );
        }
      }
      function keywordMetaschema(def) {
        let { metaSchema } = def;
        if (metaSchema === void 0)
          return;
        if (
          def.$data &&
          this.opts.$data
        )
          metaSchema =
            schemaOrData(metaSchema);
        def.validateSchema =
          this.compile(
            metaSchema,
            true,
          );
      }
      const $dataRef = {
        $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#",
      };
      function schemaOrData(schema) {
        return {
          anyOf: [schema, $dataRef],
        };
      }
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/core/id.js
var require_id =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.default = {
        keyword: "id",
        code() {
          throw new Error(
            'NOT SUPPORTED: keyword "id", use "$id" for schema ID',
          );
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/core/ref.js
var require_ref =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.callRef =
        exports.getValidate = void 0;
      const ref_error_1 =
        require_ref_error();
      const code_1 = require_code();
      const codegen_1 =
        require_codegen();
      const names_1 = require_names();
      const compile_1 =
        require_compile();
      const util_1 = require_util();
      const def = {
        keyword: "$ref",
        schemaType: "string",
        code(cxt) {
          const {
            gen,
            schema: $ref,
            it,
          } = cxt;
          const {
            baseId,
            schemaEnv: env,
            validateName,
            opts,
            self,
          } = it;
          const { root } = env;
          if (
            ($ref === "#" ||
              $ref === "#/") &&
            baseId === root.baseId
          )
            return callRootRef();
          const schOrEnv =
            compile_1.resolveRef.call(
              self,
              root,
              baseId,
              $ref,
            );
          if (schOrEnv === void 0)
            throw new ref_error_1.default(
              it.opts.uriResolver,
              baseId,
              $ref,
            );
          if (
            schOrEnv instanceof
            compile_1.SchemaEnv
          )
            return callValidate(
              schOrEnv,
            );
          return inlineRefSchema(
            schOrEnv,
          );
          function callRootRef() {
            if (env === root)
              return callRef(
                cxt,
                validateName,
                env,
                env.$async,
              );
            const rootName =
              gen.scopeValue("root", {
                ref: root,
              });
            return callRef(
              cxt,
              (0,
              codegen_1._)`${rootName}.validate`,
              root,
              root.$async,
            );
          }
          function callValidate(sch) {
            callRef(
              cxt,
              getValidate(cxt, sch),
              sch,
              sch.$async,
            );
          }
          function inlineRefSchema(
            sch,
          ) {
            const schName =
              gen.scopeValue(
                "schema",
                opts.code.source ===
                  true
                  ? {
                      ref: sch,
                      code: (0,
                      codegen_1.stringify)(
                        sch,
                      ),
                    }
                  : { ref: sch },
              );
            const valid =
              gen.name("valid");
            const schCxt =
              cxt.subschema(
                {
                  schema: sch,
                  dataTypes: [],
                  schemaPath:
                    codegen_1.nil,
                  topSchemaRef: schName,
                  errSchemaPath: $ref,
                },
                valid,
              );
            cxt.mergeEvaluated(schCxt);
            cxt.ok(valid);
          }
        },
      };
      function getValidate(cxt, sch) {
        const { gen } = cxt;
        return sch.validate
          ? gen.scopeValue("validate", {
              ref: sch.validate,
            })
          : (0,
            codegen_1._)`${gen.scopeValue("wrapper", { ref: sch })}.validate`;
      }
      exports.getValidate = getValidate;
      function callRef(
        cxt,
        v,
        sch,
        $async,
      ) {
        const { gen, it } = cxt;
        const {
          allErrors,
          schemaEnv: env,
          opts,
        } = it;
        const passCxt = opts.passContext
          ? names_1.default.this
          : codegen_1.nil;
        if ($async) callAsyncRef();
        else callSyncRef();
        function callAsyncRef() {
          if (!env.$async)
            throw new Error(
              "async schema referenced by sync schema",
            );
          const valid =
            gen.let("valid");
          gen.try(
            () => {
              gen.code(
                (0,
                codegen_1._)`await ${(0, code_1.callValidateCode)(cxt, v, passCxt)}`,
              );
              addEvaluatedFrom(v);
              if (!allErrors)
                gen.assign(valid, true);
            },
            (e) => {
              gen.if(
                (0,
                codegen_1._)`!(${e} instanceof ${it.ValidationError})`,
                () => gen.throw(e),
              );
              addErrorsFrom(e);
              if (!allErrors)
                gen.assign(
                  valid,
                  false,
                );
            },
          );
          cxt.ok(valid);
        }
        function callSyncRef() {
          cxt.result(
            (0,
            code_1.callValidateCode)(
              cxt,
              v,
              passCxt,
            ),
            () => addEvaluatedFrom(v),
            () => addErrorsFrom(v),
          );
        }
        function addErrorsFrom(source) {
          const errs = (0,
          codegen_1._)`${source}.errors`;
          gen.assign(
            names_1.default.vErrors,
            (0,
            codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`,
          );
          gen.assign(
            names_1.default.errors,
            (0,
            codegen_1._)`${names_1.default.vErrors}.length`,
          );
        }
        function addEvaluatedFrom(
          source,
        ) {
          var _a;
          if (!it.opts.unevaluated)
            return;
          const schEvaluated =
            (_a =
              sch === null ||
              sch === void 0
                ? void 0
                : sch.validate) ===
              null || _a === void 0
              ? void 0
              : _a.evaluated;
          if (it.props !== true) {
            if (
              schEvaluated &&
              !schEvaluated.dynamicProps
            ) {
              if (
                schEvaluated.props !==
                void 0
              )
                it.props =
                  util_1.mergeEvaluated.props(
                    gen,
                    schEvaluated.props,
                    it.props,
                  );
            } else {
              const props = gen.var(
                "props",
                (0,
                codegen_1._)`${source}.evaluated.props`,
              );
              it.props =
                util_1.mergeEvaluated.props(
                  gen,
                  props,
                  it.props,
                  codegen_1.Name,
                );
            }
          }
          if (it.items !== true) {
            if (
              schEvaluated &&
              !schEvaluated.dynamicItems
            ) {
              if (
                schEvaluated.items !==
                void 0
              )
                it.items =
                  util_1.mergeEvaluated.items(
                    gen,
                    schEvaluated.items,
                    it.items,
                  );
            } else {
              const items = gen.var(
                "items",
                (0,
                codegen_1._)`${source}.evaluated.items`,
              );
              it.items =
                util_1.mergeEvaluated.items(
                  gen,
                  items,
                  it.items,
                  codegen_1.Name,
                );
            }
          }
        }
      }
      exports.callRef = callRef;
      exports.default = def;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/core/index.js
var require_core =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const id_1 = require_id();
      const ref_1 = require_ref();
      exports.default = [
        "$schema",
        "$id",
        "$defs",
        "$vocabulary",
        { keyword: "$comment" },
        "definitions",
        id_1.default,
        ref_1.default,
      ];
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitNumber.js
var require_limitNumber =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      const ops = codegen_1.operators;
      const 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,
        },
      };
      exports.default = {
        keyword: Object.keys(KWDs),
        type: "number",
        schemaType: "number",
        $data: true,
        error: {
          message: ({
            keyword,
            schemaCode,
          }) =>
            (0,
            codegen_1.str)`must be ${KWDs[keyword].okStr} ${schemaCode}`,
          params: ({
            keyword,
            schemaCode,
          }) =>
            (0,
            codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`,
        },
        code(cxt) {
          const {
            keyword,
            data,
            schemaCode,
          } = cxt;
          cxt.fail$data(
            (0,
            codegen_1._)`${data} ${KWDs[keyword].fail} ${schemaCode} || isNaN(${data})`,
          );
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/multipleOf.js
var require_multipleOf =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      exports.default = {
        keyword: "multipleOf",
        type: "number",
        schemaType: "number",
        $data: true,
        error: {
          message: ({ schemaCode }) =>
            (0,
            codegen_1.str)`must be multiple of ${schemaCode}`,
          params: ({ schemaCode }) =>
            (0,
            codegen_1._)`{multipleOf: ${schemaCode}}`,
        },
        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}))`,
          );
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/ucs2length.js
var require_ucs2length =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      function ucs2length(str) {
        const len = str.length;
        let length = 0;
        let pos = 0;
        let value;
        while (pos < len) {
          length++;
          value = str.charCodeAt(pos++);
          if (
            value >= 55296 &&
            value <= 56319 &&
            pos < len
          ) {
            value = str.charCodeAt(pos);
            if (
              (value & 64512) ===
              56320
            )
              pos++;
          }
        }
        return length;
      }
      exports.default = ucs2length;
      ucs2length.code =
        'require("ajv/dist/runtime/ucs2length").default';
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitLength.js
var require_limitLength =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      const util_1 = require_util();
      const ucs2length_1 =
        require_ucs2length();
      exports.default = {
        keyword: [
          "maxLength",
          "minLength",
        ],
        type: "string",
        schemaType: "number",
        $data: true,
        error: {
          message({
            keyword,
            schemaCode,
          }) {
            const comp =
              keyword === "maxLength"
                ? "more"
                : "fewer";
            return (0,
            codegen_1.str)`must NOT have ${comp} than ${schemaCode} characters`;
          },
          params: ({ schemaCode }) =>
            (0,
            codegen_1._)`{limit: ${schemaCode}}`,
        },
        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}`,
          );
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/pattern.js
var require_pattern =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const code_1 = require_code();
      const util_1 = require_util();
      const codegen_1 =
        require_codegen();
      exports.default = {
        keyword: "pattern",
        type: "string",
        schemaType: "string",
        $data: true,
        error: {
          message: ({ schemaCode }) =>
            (0,
            codegen_1.str)`must match pattern "${schemaCode}"`,
          params: ({ schemaCode }) =>
            (0,
            codegen_1._)`{pattern: ${schemaCode}}`,
        },
        code(cxt) {
          const {
            gen,
            data,
            $data,
            schema,
            schemaCode,
            it,
          } = cxt;
          const u = it.opts
            .unicodeRegExp
            ? "u"
            : "";
          if ($data) {
            const { regExp } =
              it.opts.code;
            const regExpCode =
              regExp.code ===
              "new RegExp"
                ? (0,
                  codegen_1._)`new RegExp`
                : (0, util_1.useFunc)(
                    gen,
                    regExp,
                  );
            const valid =
              gen.let("valid");
            gen.try(
              () =>
                gen.assign(
                  valid,
                  (0,
                  codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`,
                ),
              () =>
                gen.assign(
                  valid,
                  false,
                ),
            );
            cxt.fail$data(
              (0,
              codegen_1._)`!${valid}`,
            );
          } else {
            const regExp = (0,
            code_1.usePattern)(
              cxt,
              schema,
            );
            cxt.fail$data(
              (0,
              codegen_1._)`!${regExp}.test(${data})`,
            );
          }
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitProperties.js
var require_limitProperties =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      exports.default = {
        keyword: [
          "maxProperties",
          "minProperties",
        ],
        type: "object",
        schemaType: "number",
        $data: true,
        error: {
          message({
            keyword,
            schemaCode,
          }) {
            const comp =
              keyword ===
              "maxProperties"
                ? "more"
                : "fewer";
            return (0,
            codegen_1.str)`must NOT have ${comp} than ${schemaCode} properties`;
          },
          params: ({ schemaCode }) =>
            (0,
            codegen_1._)`{limit: ${schemaCode}}`,
        },
        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}`,
          );
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/required.js
var require_required =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const code_1 = require_code();
      const codegen_1 =
        require_codegen();
      const util_1 = require_util();
      exports.default = {
        keyword: "required",
        type: "object",
        schemaType: "array",
        $data: true,
        error: {
          message: ({
            params: { missingProperty },
          }) =>
            (0,
            codegen_1.str)`must have required property '${missingProperty}'`,
          params: ({
            params: { missingProperty },
          }) =>
            (0,
            codegen_1._)`{missingProperty: ${missingProperty}}`,
        },
        code(cxt) {
          const {
            gen,
            schema,
            schemaCode,
            data,
            $data,
            it,
          } = cxt;
          const { opts } = it;
          if (
            !$data &&
            schema.length === 0
          )
            return;
          const useLoop =
            schema.length >=
            opts.loopRequired;
          if (it.allErrors)
            allErrorsMode();
          else exitOnErrorMode();
          if (opts.strictRequired) {
            const props =
              cxt.parentSchema
                .properties;
            const {
              definedProperties,
            } = cxt.it;
            for (const requiredKey of schema)
              if (
                (props === null ||
                props === void 0
                  ? void 0
                  : props[
                      requiredKey
                    ]) === void 0 &&
                !definedProperties.has(
                  requiredKey,
                )
              ) {
                const msg = `required property "${requiredKey}" is not defined at "${it.schemaEnv.baseId + it.errSchemaPath}" (strictRequired)`;
                (0,
                util_1.checkStrictMode)(
                  it,
                  msg,
                  it.opts
                    .strictRequired,
                );
              }
          }
          function allErrorsMode() {
            if (useLoop || $data)
              cxt.block$data(
                codegen_1.nil,
                loopAllRequired,
              );
            else
              for (const prop of schema)
                (0,
                code_1.checkReportMissingProp)(
                  cxt,
                  prop,
                );
          }
          function exitOnErrorMode() {
            const missing =
              gen.let("missing");
            if (useLoop || $data) {
              const valid = gen.let(
                "valid",
                true,
              );
              cxt.block$data(
                valid,
                () =>
                  loopUntilMissing(
                    missing,
                    valid,
                  ),
              );
              cxt.ok(valid);
            } else {
              gen.if(
                (0,
                code_1.checkMissingProp)(
                  cxt,
                  schema,
                  missing,
                ),
              );
              (0,
              code_1.reportMissingProp)(
                cxt,
                missing,
              );
              gen.else();
            }
          }
          function loopAllRequired() {
            gen.forOf(
              "prop",
              schemaCode,
              (prop) => {
                cxt.setParams({
                  missingProperty: prop,
                });
                gen.if(
                  (0,
                  code_1.noPropertyInData)(
                    gen,
                    data,
                    prop,
                    opts.ownProperties,
                  ),
                  () => cxt.error(),
                );
              },
            );
          }
          function loopUntilMissing(
            missing,
            valid,
          ) {
            cxt.setParams({
              missingProperty: missing,
            });
            gen.forOf(
              missing,
              schemaCode,
              () => {
                gen.assign(
                  valid,
                  (0,
                  code_1.propertyInData)(
                    gen,
                    data,
                    missing,
                    opts.ownProperties,
                  ),
                );
                gen.if(
                  (0, codegen_1.not)(
                    valid,
                  ),
                  () => {
                    cxt.error();
                    gen.break();
                  },
                );
              },
              codegen_1.nil,
            );
          }
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitItems.js
var require_limitItems =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      exports.default = {
        keyword: [
          "maxItems",
          "minItems",
        ],
        type: "array",
        schemaType: "number",
        $data: true,
        error: {
          message({
            keyword,
            schemaCode,
          }) {
            const comp =
              keyword === "maxItems"
                ? "more"
                : "fewer";
            return (0,
            codegen_1.str)`must NOT have ${comp} than ${schemaCode} items`;
          },
          params: ({ schemaCode }) =>
            (0,
            codegen_1._)`{limit: ${schemaCode}}`,
        },
        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}`,
          );
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/equal.js
var require_equal =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const equal =
        require_fast_deep_equal();
      equal.code =
        'require("ajv/dist/runtime/equal").default';
      exports.default = equal;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/uniqueItems.js
var require_uniqueItems =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const dataType_1 =
        require_dataType();
      const codegen_1 =
        require_codegen();
      const util_1 = require_util();
      const equal_1 = require_equal();
      exports.default = {
        keyword: "uniqueItems",
        type: "array",
        schemaType: "boolean",
        $data: true,
        error: {
          message: ({
            params: { i, j },
          }) =>
            (0,
            codegen_1.str)`must NOT have duplicate items (items ## ${j} and ${i} are identical)`,
          params: ({
            params: { i, j },
          }) =>
            (0,
            codegen_1._)`{i: ${i}, j: ${j}}`,
        },
        code(cxt) {
          const {
            gen,
            data,
            $data,
            schema,
            parentSchema,
            schemaCode,
            it,
          } = cxt;
          if (!$data && !schema) return;
          const valid =
            gen.let("valid");
          const itemTypes =
            parentSchema.items
              ? (0,
                dataType_1.getSchemaTypes)(
                  parentSchema.items,
                )
              : [];
          cxt.block$data(
            valid,
            validateUniqueItems,
            (0,
            codegen_1._)`${schemaCode} === false`,
          );
          cxt.ok(valid);
          function validateUniqueItems() {
            const i = gen.let(
              "i",
              (0,
              codegen_1._)`${data}.length`,
            );
            const j = gen.let("j");
            cxt.setParams({
              i,
              j,
            });
            gen.assign(valid, true);
            gen.if(
              (0,
              codegen_1._)`${i} > 1`,
              () =>
                (canOptimize()
                  ? loopN
                  : loopN2)(i, j),
            );
          }
          function canOptimize() {
            return (
              itemTypes.length > 0 &&
              !itemTypes.some(
                (t) =>
                  t === "object" ||
                  t === "array",
              )
            );
          }
          function loopN(i, j) {
            const item =
              gen.name("item");
            const wrongType = (0,
            dataType_1.checkDataTypes)(
              itemTypes,
              item,
              it.opts.strictNumbers,
              dataType_1.DataType.Wrong,
            );
            const indices = gen.const(
              "indices",
              (0, codegen_1._)`{}`,
            );
            gen.for(
              (0,
              codegen_1._)`;${i}--;`,
              () => {
                gen.let(
                  item,
                  (0,
                  codegen_1._)`${data}[${i}]`,
                );
                gen.if(
                  wrongType,
                  (0,
                  codegen_1._)`continue`,
                );
                if (
                  itemTypes.length > 1
                )
                  gen.if(
                    (0,
                    codegen_1._)`typeof ${item} == "string"`,
                    (0,
                    codegen_1._)`${item} += "_"`,
                  );
                gen
                  .if(
                    (0,
                    codegen_1._)`typeof ${indices}[${item}] == "number"`,
                    () => {
                      gen.assign(
                        j,
                        (0,
                        codegen_1._)`${indices}[${item}]`,
                      );
                      cxt.error();
                      gen
                        .assign(
                          valid,
                          false,
                        )
                        .break();
                    },
                  )
                  .code(
                    (0,
                    codegen_1._)`${indices}[${item}] = ${i}`,
                  );
              },
            );
          }
          function loopN2(i, j) {
            const eql = (0,
            util_1.useFunc)(
              gen,
              equal_1.default,
            );
            const outer =
              gen.name("outer");
            gen
              .label(outer)
              .for(
                (0,
                codegen_1._)`;${i}--;`,
                () =>
                  gen.for(
                    (0,
                    codegen_1._)`${j} = ${i}; ${j}--;`,
                    () =>
                      gen.if(
                        (0,
                        codegen_1._)`${eql}(${data}[${i}], ${data}[${j}])`,
                        () => {
                          cxt.error();
                          gen
                            .assign(
                              valid,
                              false,
                            )
                            .break(
                              outer,
                            );
                        },
                      ),
                  ),
              );
          }
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/const.js
var require_const =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      const util_1 = require_util();
      const equal_1 = require_equal();
      exports.default = {
        keyword: "const",
        $data: true,
        error: {
          message:
            "must be equal to constant",
          params: ({ schemaCode }) =>
            (0,
            codegen_1._)`{allowedValue: ${schemaCode}}`,
        },
        code(cxt) {
          const {
            gen,
            data,
            $data,
            schemaCode,
            schema,
          } = cxt;
          if (
            $data ||
            (schema &&
              typeof schema == "object")
          )
            cxt.fail$data(
              (0,
              codegen_1._)`!${(0, util_1.useFunc)(gen, equal_1.default)}(${data}, ${schemaCode})`,
            );
          else
            cxt.fail(
              (0,
              codegen_1._)`${schema} !== ${data}`,
            );
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/enum.js
var require_enum =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      const util_1 = require_util();
      const equal_1 = require_equal();
      exports.default = {
        keyword: "enum",
        schemaType: "array",
        $data: true,
        error: {
          message:
            "must be equal to one of the allowed values",
          params: ({ schemaCode }) =>
            (0,
            codegen_1._)`{allowedValues: ${schemaCode}}`,
        },
        code(cxt) {
          const {
            gen,
            data,
            $data,
            schema,
            schemaCode,
            it,
          } = cxt;
          if (
            !$data &&
            schema.length === 0
          )
            throw new Error(
              "enum must have non-empty array",
            );
          const useLoop =
            schema.length >=
            it.opts.loopEnum;
          let eql;
          const getEql = () =>
            eql !== null &&
            eql !== void 0
              ? eql
              : (eql = (0,
                util_1.useFunc)(
                  gen,
                  equal_1.default,
                ));
          let valid;
          if (useLoop || $data) {
            valid = gen.let("valid");
            cxt.block$data(
              valid,
              loopEnum,
            );
          } else {
            /* istanbul ignore if */
            if (!Array.isArray(schema))
              throw new Error(
                "ajv implementation error",
              );
            const vSchema = gen.const(
              "vSchema",
              schemaCode,
            );
            valid = (0, codegen_1.or)(
              ...schema.map((_x, i) =>
                equalCode(vSchema, i),
              ),
            );
          }
          cxt.pass(valid);
          function loopEnum() {
            gen.assign(valid, false);
            gen.forOf(
              "v",
              schemaCode,
              (v) =>
                gen.if(
                  (0,
                  codegen_1._)`${getEql()}(${data}, ${v})`,
                  () =>
                    gen
                      .assign(
                        valid,
                        true,
                      )
                      .break(),
                ),
            );
          }
          function equalCode(
            vSchema,
            i,
          ) {
            const sch = schema[i];
            return typeof sch ===
              "object" && sch !== null
              ? (0,
                codegen_1._)`${getEql()}(${data}, ${vSchema}[${i}])`
              : (0,
                codegen_1._)`${data} === ${sch}`;
          }
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/index.js
var require_validation =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const limitNumber_1 =
        require_limitNumber();
      const multipleOf_1 =
        require_multipleOf();
      const limitLength_1 =
        require_limitLength();
      const pattern_1 =
        require_pattern();
      const limitProperties_1 =
        require_limitProperties();
      const required_1 =
        require_required();
      const limitItems_1 =
        require_limitItems();
      const uniqueItems_1 =
        require_uniqueItems();
      const const_1 = require_const();
      const enum_1 = require_enum();
      exports.default = [
        limitNumber_1.default,
        multipleOf_1.default,
        limitLength_1.default,
        pattern_1.default,
        limitProperties_1.default,
        required_1.default,
        limitItems_1.default,
        uniqueItems_1.default,
        {
          keyword: "type",
          schemaType: [
            "string",
            "array",
          ],
        },
        {
          keyword: "nullable",
          schemaType: "boolean",
        },
        const_1.default,
        enum_1.default,
      ];
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/additionalItems.js
var require_additionalItems =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.validateAdditionalItems =
        void 0;
      const codegen_1 =
        require_codegen();
      const util_1 = require_util();
      const def = {
        keyword: "additionalItems",
        type: "array",
        schemaType: [
          "boolean",
          "object",
        ],
        before: "uniqueItems",
        error: {
          message: ({
            params: { len },
          }) =>
            (0,
            codegen_1.str)`must NOT have more than ${len} items`,
          params: ({
            params: { len },
          }) =>
            (0,
            codegen_1._)`{limit: ${len}}`,
        },
        code(cxt) {
          const { parentSchema, it } =
            cxt;
          const { items } =
            parentSchema;
          if (!Array.isArray(items)) {
            (0, util_1.checkStrictMode)(
              it,
              '"additionalItems" is ignored when "items" is not an array of schemas',
            );
            return;
          }
          validateAdditionalItems(
            cxt,
            items,
          );
        },
      };
      function validateAdditionalItems(
        cxt,
        items,
      ) {
        const {
          gen,
          schema,
          data,
          keyword,
          it,
        } = cxt;
        it.items = true;
        const len = gen.const(
          "len",
          (0,
          codegen_1._)`${data}.length`,
        );
        if (schema === false) {
          cxt.setParams({
            len: items.length,
          });
          cxt.pass(
            (0,
            codegen_1._)`${len} <= ${items.length}`,
          );
        } else if (
          typeof schema == "object" &&
          !(0,
          util_1.alwaysValidSchema)(
            it,
            schema,
          )
        ) {
          const valid = gen.var(
            "valid",
            (0,
            codegen_1._)`${len} <= ${items.length}`,
          );
          gen.if(
            (0, codegen_1.not)(valid),
            () => validateItems(valid),
          );
          cxt.ok(valid);
        }
        function validateItems(valid) {
          gen.forRange(
            "i",
            items.length,
            len,
            (i) => {
              cxt.subschema(
                {
                  keyword,
                  dataProp: i,
                  dataPropType:
                    util_1.Type.Num,
                },
                valid,
              );
              if (!it.allErrors)
                gen.if(
                  (0, codegen_1.not)(
                    valid,
                  ),
                  () => gen.break(),
                );
            },
          );
        }
      }
      exports.validateAdditionalItems =
        validateAdditionalItems;
      exports.default = def;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/items.js
var require_items =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.validateTuple = void 0;
      const codegen_1 =
        require_codegen();
      const util_1 = require_util();
      const code_1 = require_code();
      const def = {
        keyword: "items",
        type: "array",
        schemaType: [
          "object",
          "array",
          "boolean",
        ],
        before: "uniqueItems",
        code(cxt) {
          const { schema, it } = cxt;
          if (Array.isArray(schema))
            return validateTuple(
              cxt,
              "additionalItems",
              schema,
            );
          it.items = true;
          if (
            (0,
            util_1.alwaysValidSchema)(
              it,
              schema,
            )
          )
            return;
          cxt.ok(
            (0, code_1.validateArray)(
              cxt,
            ),
          );
        },
      };
      function validateTuple(
        cxt,
        extraItems,
        schArr = cxt.schema,
      ) {
        const {
          gen,
          parentSchema,
          data,
          keyword,
          it,
        } = cxt;
        checkStrictTuple(parentSchema);
        if (
          it.opts.unevaluated &&
          schArr.length &&
          it.items !== true
        )
          it.items =
            util_1.mergeEvaluated.items(
              gen,
              schArr.length,
              it.items,
            );
        const valid = gen.name("valid");
        const len = gen.const(
          "len",
          (0,
          codegen_1._)`${data}.length`,
        );
        schArr.forEach((sch, i) => {
          if (
            (0,
            util_1.alwaysValidSchema)(
              it,
              sch,
            )
          )
            return;
          gen.if(
            (0,
            codegen_1._)`${len} > ${i}`,
            () =>
              cxt.subschema(
                {
                  keyword,
                  schemaProp: i,
                  dataProp: i,
                },
                valid,
              ),
          );
          cxt.ok(valid);
        });
        function checkStrictTuple(sch) {
          const {
            opts,
            errSchemaPath,
          } = it;
          const l = schArr.length;
          const fullTuple =
            l === sch.minItems &&
            (l === sch.maxItems ||
              sch[extraItems] ===
                false);
          if (
            opts.strictTuples &&
            !fullTuple
          ) {
            const msg = `"${keyword}" is ${l}-tuple, but minItems or maxItems/${extraItems} are not specified or different at path "${errSchemaPath}"`;
            (0, util_1.checkStrictMode)(
              it,
              msg,
              opts.strictTuples,
            );
          }
        }
      }
      exports.validateTuple =
        validateTuple;
      exports.default = def;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/prefixItems.js
var require_prefixItems =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const items_1 = require_items();
      exports.default = {
        keyword: "prefixItems",
        type: "array",
        schemaType: ["array"],
        before: "uniqueItems",
        code: (cxt) =>
          (0, items_1.validateTuple)(
            cxt,
            "items",
          ),
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/items2020.js
var require_items2020 =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      const util_1 = require_util();
      const code_1 = require_code();
      const additionalItems_1 =
        require_additionalItems();
      exports.default = {
        keyword: "items",
        type: "array",
        schemaType: [
          "object",
          "boolean",
        ],
        before: "uniqueItems",
        error: {
          message: ({
            params: { len },
          }) =>
            (0,
            codegen_1.str)`must NOT have more than ${len} items`,
          params: ({
            params: { len },
          }) =>
            (0,
            codegen_1._)`{limit: ${len}}`,
        },
        code(cxt) {
          const {
            schema,
            parentSchema,
            it,
          } = cxt;
          const { prefixItems } =
            parentSchema;
          it.items = true;
          if (
            (0,
            util_1.alwaysValidSchema)(
              it,
              schema,
            )
          )
            return;
          if (prefixItems)
            (0,
            additionalItems_1.validateAdditionalItems)(
              cxt,
              prefixItems,
            );
          else
            cxt.ok(
              (0, code_1.validateArray)(
                cxt,
              ),
            );
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/contains.js
var require_contains =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      const util_1 = require_util();
      exports.default = {
        keyword: "contains",
        type: "array",
        schemaType: [
          "object",
          "boolean",
        ],
        before: "uniqueItems",
        trackErrors: true,
        error: {
          message: ({
            params: { min, max },
          }) =>
            max === void 0
              ? (0,
                codegen_1.str)`must contain at least ${min} valid item(s)`
              : (0,
                codegen_1.str)`must contain at least ${min} and no more than ${max} valid item(s)`,
          params: ({
            params: { min, max },
          }) =>
            max === void 0
              ? (0,
                codegen_1._)`{minContains: ${min}}`
              : (0,
                codegen_1._)`{minContains: ${min}, maxContains: ${max}}`,
        },
        code(cxt) {
          const {
            gen,
            schema,
            parentSchema,
            data,
            it,
          } = cxt;
          let min;
          let max;
          const {
            minContains,
            maxContains,
          } = parentSchema;
          if (it.opts.next) {
            min =
              minContains === void 0
                ? 1
                : minContains;
            max = maxContains;
          } else min = 1;
          const len = gen.const(
            "len",
            (0,
            codegen_1._)`${data}.length`,
          );
          cxt.setParams({
            min,
            max,
          });
          if (
            max === void 0 &&
            min === 0
          ) {
            (0, util_1.checkStrictMode)(
              it,
              `"minContains" == 0 without "maxContains": "contains" keyword ignored`,
            );
            return;
          }
          if (
            max !== void 0 &&
            min > max
          ) {
            (0, util_1.checkStrictMode)(
              it,
              `"minContains" > "maxContains" is always invalid`,
            );
            cxt.fail();
            return;
          }
          if (
            (0,
            util_1.alwaysValidSchema)(
              it,
              schema,
            )
          ) {
            let cond = (0,
            codegen_1._)`${len} >= ${min}`;
            if (max !== void 0)
              cond = (0,
              codegen_1._)`${cond} && ${len} <= ${max}`;
            cxt.pass(cond);
            return;
          }
          it.items = true;
          const valid =
            gen.name("valid");
          if (
            max === void 0 &&
            min === 1
          )
            validateItems(valid, () =>
              gen.if(valid, () =>
                gen.break(),
              ),
            );
          else if (min === 0) {
            gen.let(valid, true);
            if (max !== void 0)
              gen.if(
                (0,
                codegen_1._)`${data}.length > 0`,
                validateItemsWithCount,
              );
          } else {
            gen.let(valid, false);
            validateItemsWithCount();
          }
          cxt.result(valid, () =>
            cxt.reset(),
          );
          function validateItemsWithCount() {
            const schValid =
              gen.name("_valid");
            const count = gen.let(
              "count",
              0,
            );
            validateItems(
              schValid,
              () =>
                gen.if(schValid, () =>
                  checkLimits(count),
                ),
            );
          }
          function validateItems(
            _valid,
            block,
          ) {
            gen.forRange(
              "i",
              0,
              len,
              (i) => {
                cxt.subschema(
                  {
                    keyword: "contains",
                    dataProp: i,
                    dataPropType:
                      util_1.Type.Num,
                    compositeRule: true,
                  },
                  _valid,
                );
                block();
              },
            );
          }
          function checkLimits(count) {
            gen.code(
              (0,
              codegen_1._)`${count}++`,
            );
            if (max === void 0)
              gen.if(
                (0,
                codegen_1._)`${count} >= ${min}`,
                () =>
                  gen
                    .assign(valid, true)
                    .break(),
              );
            else {
              gen.if(
                (0,
                codegen_1._)`${count} > ${max}`,
                () =>
                  gen
                    .assign(
                      valid,
                      false,
                    )
                    .break(),
              );
              if (min === 1)
                gen.assign(valid, true);
              else
                gen.if(
                  (0,
                  codegen_1._)`${count} >= ${min}`,
                  () =>
                    gen.assign(
                      valid,
                      true,
                    ),
                );
            }
          }
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/dependencies.js
var require_dependencies =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.validateSchemaDeps =
        exports.validatePropertyDeps =
        exports.error =
          void 0;
      const codegen_1 =
        require_codegen();
      const util_1 = require_util();
      const code_1 = require_code();
      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}}`,
      };
      const def = {
        keyword: "dependencies",
        type: "object",
        schemaType: "object",
        error: exports.error,
        code(cxt) {
          const [propDeps, schDeps] =
            splitDependencies(cxt);
          validatePropertyDeps(
            cxt,
            propDeps,
          );
          validateSchemaDeps(
            cxt,
            schDeps,
          );
        },
      };
      function splitDependencies({
        schema,
      }) {
        const propertyDeps = {};
        const schemaDeps = {};
        for (const key in schema) {
          if (key === "__proto__")
            continue;
          const deps = Array.isArray(
            schema[key],
          )
            ? propertyDeps
            : schemaDeps;
          deps[key] = schema[key];
        }
        return [
          propertyDeps,
          schemaDeps,
        ];
      }
      function validatePropertyDeps(
        cxt,
        propertyDeps = cxt.schema,
      ) {
        const { gen, data, it } = cxt;
        if (
          Object.keys(propertyDeps)
            .length === 0
        )
          return;
        const missing =
          gen.let("missing");
        for (const prop in propertyDeps) {
          const deps =
            propertyDeps[prop];
          if (deps.length === 0)
            continue;
          const hasProperty = (0,
          code_1.propertyInData)(
            gen,
            data,
            prop,
            it.opts.ownProperties,
          );
          cxt.setParams({
            property: prop,
            depsCount: deps.length,
            deps: deps.join(", "),
          });
          if (it.allErrors)
            gen.if(hasProperty, () => {
              for (const depProp of deps)
                (0,
                code_1.checkReportMissingProp)(
                  cxt,
                  depProp,
                );
            });
          else {
            gen.if(
              (0,
              codegen_1._)`${hasProperty} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`,
            );
            (0,
            code_1.reportMissingProp)(
              cxt,
              missing,
            );
            gen.else();
          }
        }
      }
      exports.validatePropertyDeps =
        validatePropertyDeps;
      function validateSchemaDeps(
        cxt,
        schemaDeps = cxt.schema,
      ) {
        const {
          gen,
          data,
          keyword,
          it,
        } = cxt;
        const valid = gen.name("valid");
        for (const prop in schemaDeps) {
          if (
            (0,
            util_1.alwaysValidSchema)(
              it,
              schemaDeps[prop],
            )
          )
            continue;
          gen.if(
            (0, code_1.propertyInData)(
              gen,
              data,
              prop,
              it.opts.ownProperties,
            ),
            () => {
              const schCxt =
                cxt.subschema(
                  {
                    keyword,
                    schemaProp: prop,
                  },
                  valid,
                );
              cxt.mergeValidEvaluated(
                schCxt,
                valid,
              );
            },
            () => gen.var(valid, true),
          );
          cxt.ok(valid);
        }
      }
      exports.validateSchemaDeps =
        validateSchemaDeps;
      exports.default = def;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/propertyNames.js
var require_propertyNames =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      const util_1 = require_util();
      exports.default = {
        keyword: "propertyNames",
        type: "object",
        schemaType: [
          "object",
          "boolean",
        ],
        error: {
          message:
            "property name must be valid",
          params: ({ params }) =>
            (0,
            codegen_1._)`{propertyName: ${params.propertyName}}`,
        },
        code(cxt) {
          const {
            gen,
            schema,
            data,
            it,
          } = cxt;
          if (
            (0,
            util_1.alwaysValidSchema)(
              it,
              schema,
            )
          )
            return;
          const valid =
            gen.name("valid");
          gen.forIn(
            "key",
            data,
            (key) => {
              cxt.setParams({
                propertyName: key,
              });
              cxt.subschema(
                {
                  keyword:
                    "propertyNames",
                  data: key,
                  dataTypes: ["string"],
                  propertyName: key,
                  compositeRule: true,
                },
                valid,
              );
              gen.if(
                (0, codegen_1.not)(
                  valid,
                ),
                () => {
                  cxt.error(true);
                  if (!it.allErrors)
                    gen.break();
                },
              );
            },
          );
          cxt.ok(valid);
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js
var require_additionalProperties =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const code_1 = require_code();
      const codegen_1 =
        require_codegen();
      const names_1 = require_names();
      const util_1 = require_util();
      exports.default = {
        keyword: "additionalProperties",
        type: ["object"],
        schemaType: [
          "boolean",
          "object",
        ],
        allowUndefined: true,
        trackErrors: true,
        error: {
          message:
            "must NOT have additional properties",
          params: ({ params }) =>
            (0,
            codegen_1._)`{additionalProperty: ${params.additionalProperty}}`,
        },
        code(cxt) {
          const {
            gen,
            schema,
            parentSchema,
            data,
            errsCount,
            it,
          } = cxt;
          /* istanbul ignore if */
          if (!errsCount)
            throw new Error(
              "ajv implementation error",
            );
          const { allErrors, opts } =
            it;
          it.props = true;
          if (
            opts.removeAdditional !==
              "all" &&
            (0,
            util_1.alwaysValidSchema)(
              it,
              schema,
            )
          )
            return;
          const props = (0,
          code_1.allSchemaProperties)(
            parentSchema.properties,
          );
          const patProps = (0,
          code_1.allSchemaProperties)(
            parentSchema.patternProperties,
          );
          checkAdditionalProperties();
          cxt.ok(
            (0,
            codegen_1._)`${errsCount} === ${names_1.default.errors}`,
          );
          function checkAdditionalProperties() {
            gen.forIn(
              "key",
              data,
              (key) => {
                if (
                  !props.length &&
                  !patProps.length
                )
                  additionalPropertyCode(
                    key,
                  );
                else
                  gen.if(
                    isAdditional(key),
                    () =>
                      additionalPropertyCode(
                        key,
                      ),
                  );
              },
            );
          }
          function isAdditional(key) {
            let definedProp;
            if (props.length > 8) {
              const propsSchema = (0,
              util_1.schemaRefOrVal)(
                it,
                parentSchema.properties,
                "properties",
              );
              definedProp = (0,
              code_1.isOwnProperty)(
                gen,
                propsSchema,
                key,
              );
            } else if (props.length)
              definedProp = (0,
              codegen_1.or)(
                ...props.map(
                  (p) =>
                    (0,
                    codegen_1._)`${key} === ${p}`,
                ),
              );
            else
              definedProp =
                codegen_1.nil;
            if (patProps.length)
              definedProp = (0,
              codegen_1.or)(
                definedProp,
                ...patProps.map(
                  (p) =>
                    (0,
                    codegen_1._)`${(0, code_1.usePattern)(cxt, p)}.test(${key})`,
                ),
              );
            return (0, codegen_1.not)(
              definedProp,
            );
          }
          function deleteAdditional(
            key,
          ) {
            gen.code(
              (0,
              codegen_1._)`delete ${data}[${key}]`,
            );
          }
          function additionalPropertyCode(
            key,
          ) {
            if (
              opts.removeAdditional ===
                "all" ||
              (opts.removeAdditional &&
                schema === false)
            ) {
              deleteAdditional(key);
              return;
            }
            if (schema === false) {
              cxt.setParams({
                additionalProperty: key,
              });
              cxt.error();
              if (!allErrors)
                gen.break();
              return;
            }
            if (
              typeof schema ==
                "object" &&
              !(0,
              util_1.alwaysValidSchema)(
                it,
                schema,
              )
            ) {
              const valid =
                gen.name("valid");
              if (
                opts.removeAdditional ===
                "failing"
              ) {
                applyAdditionalSchema(
                  key,
                  valid,
                  false,
                );
                gen.if(
                  (0, codegen_1.not)(
                    valid,
                  ),
                  () => {
                    cxt.reset();
                    deleteAdditional(
                      key,
                    );
                  },
                );
              } else {
                applyAdditionalSchema(
                  key,
                  valid,
                );
                if (!allErrors)
                  gen.if(
                    (0, codegen_1.not)(
                      valid,
                    ),
                    () => gen.break(),
                  );
              }
            }
          }
          function applyAdditionalSchema(
            key,
            valid,
            errors,
          ) {
            const subschema = {
              keyword:
                "additionalProperties",
              dataProp: key,
              dataPropType:
                util_1.Type.Str,
            };
            if (errors === false)
              Object.assign(subschema, {
                compositeRule: true,
                createErrors: false,
                allErrors: false,
              });
            cxt.subschema(
              subschema,
              valid,
            );
          }
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/properties.js
var require_properties =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const validate_1 =
        require_validate();
      const code_1 = require_code();
      const util_1 = require_util();
      const additionalProperties_1 =
        require_additionalProperties();
      exports.default = {
        keyword: "properties",
        type: "object",
        schemaType: "object",
        code(cxt) {
          const {
            gen,
            schema,
            parentSchema,
            data,
            it,
          } = cxt;
          if (
            it.opts.removeAdditional ===
              "all" &&
            parentSchema.additionalProperties ===
              void 0
          )
            additionalProperties_1.default.code(
              new validate_1.KeywordCxt(
                it,
                additionalProperties_1.default,
                "additionalProperties",
              ),
            );
          const allProps = (0,
          code_1.allSchemaProperties)(
            schema,
          );
          for (const prop of allProps)
            it.definedProperties.add(
              prop,
            );
          if (
            it.opts.unevaluated &&
            allProps.length &&
            it.props !== true
          )
            it.props =
              util_1.mergeEvaluated.props(
                gen,
                (0, util_1.toHash)(
                  allProps,
                ),
                it.props,
              );
          const properties =
            allProps.filter(
              (p) =>
                !(0,
                util_1.alwaysValidSchema)(
                  it,
                  schema[p],
                ),
            );
          if (properties.length === 0)
            return;
          const valid =
            gen.name("valid");
          for (const prop of properties) {
            if (hasDefault(prop))
              applyPropertySchema(prop);
            else {
              gen.if(
                (0,
                code_1.propertyInData)(
                  gen,
                  data,
                  prop,
                  it.opts.ownProperties,
                ),
              );
              applyPropertySchema(prop);
              if (!it.allErrors)
                gen
                  .else()
                  .var(valid, true);
              gen.endIf();
            }
            cxt.it.definedProperties.add(
              prop,
            );
            cxt.ok(valid);
          }
          function hasDefault(prop) {
            return (
              it.opts.useDefaults &&
              !it.compositeRule &&
              schema[prop].default !==
                void 0
            );
          }
          function applyPropertySchema(
            prop,
          ) {
            cxt.subschema(
              {
                keyword: "properties",
                schemaProp: prop,
                dataProp: prop,
              },
              valid,
            );
          }
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/patternProperties.js
var require_patternProperties =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const code_1 = require_code();
      const codegen_1 =
        require_codegen();
      const util_1 = require_util();
      const util_2 = require_util();
      exports.default = {
        keyword: "patternProperties",
        type: "object",
        schemaType: "object",
        code(cxt) {
          const {
            gen,
            schema,
            data,
            parentSchema,
            it,
          } = cxt;
          const { opts } = it;
          const patterns = (0,
          code_1.allSchemaProperties)(
            schema,
          );
          const alwaysValidPatterns =
            patterns.filter((p) =>
              (0,
              util_1.alwaysValidSchema)(
                it,
                schema[p],
              ),
            );
          if (
            patterns.length === 0 ||
            (alwaysValidPatterns.length ===
              patterns.length &&
              (!it.opts.unevaluated ||
                it.props === true))
          )
            return;
          const checkProperties =
            opts.strictSchema &&
            !opts.allowMatchingProperties &&
            parentSchema.properties;
          const valid =
            gen.name("valid");
          if (
            it.props !== true &&
            !(
              it.props instanceof
              codegen_1.Name
            )
          )
            it.props = (0,
            util_2.evaluatedPropsToName)(
              gen,
              it.props,
            );
          const { props } = it;
          validatePatternProperties();
          function validatePatternProperties() {
            for (const pat of patterns) {
              if (checkProperties)
                checkMatchingProperties(
                  pat,
                );
              if (it.allErrors)
                validateProperties(pat);
              else {
                gen.var(valid, true);
                validateProperties(pat);
                gen.if(valid);
              }
            }
          }
          function checkMatchingProperties(
            pat,
          ) {
            for (const prop in checkProperties)
              if (
                new RegExp(pat).test(
                  prop,
                )
              )
                (0,
                util_1.checkStrictMode)(
                  it,
                  `property ${prop} matches pattern ${pat} (use allowMatchingProperties)`,
                );
          }
          function validateProperties(
            pat,
          ) {
            gen.forIn(
              "key",
              data,
              (key) => {
                gen.if(
                  (0,
                  codegen_1._)`${(0, code_1.usePattern)(cxt, pat)}.test(${key})`,
                  () => {
                    const alwaysValid =
                      alwaysValidPatterns.includes(
                        pat,
                      );
                    if (!alwaysValid)
                      cxt.subschema(
                        {
                          keyword:
                            "patternProperties",
                          schemaProp:
                            pat,
                          dataProp: key,
                          dataPropType:
                            util_2.Type
                              .Str,
                        },
                        valid,
                      );
                    if (
                      it.opts
                        .unevaluated &&
                      props !== true
                    )
                      gen.assign(
                        (0,
                        codegen_1._)`${props}[${key}]`,
                        true,
                      );
                    else if (
                      !alwaysValid &&
                      !it.allErrors
                    )
                      gen.if(
                        (0,
                        codegen_1.not)(
                          valid,
                        ),
                        () =>
                          gen.break(),
                      );
                  },
                );
              },
            );
          }
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/not.js
var require_not =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const util_1 = require_util();
      exports.default = {
        keyword: "not",
        schemaType: [
          "object",
          "boolean",
        ],
        trackErrors: true,
        code(cxt) {
          const { gen, schema, it } =
            cxt;
          if (
            (0,
            util_1.alwaysValidSchema)(
              it,
              schema,
            )
          ) {
            cxt.fail();
            return;
          }
          const valid =
            gen.name("valid");
          cxt.subschema(
            {
              keyword: "not",
              compositeRule: true,
              createErrors: false,
              allErrors: false,
            },
            valid,
          );
          cxt.failResult(
            valid,
            () => cxt.reset(),
            () => cxt.error(),
          );
        },
        error: {
          message: "must NOT be valid",
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/anyOf.js
var require_anyOf =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.default = {
        keyword: "anyOf",
        schemaType: "array",
        trackErrors: true,
        code: require_code()
          .validateUnion,
        error: {
          message:
            "must match a schema in anyOf",
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/oneOf.js
var require_oneOf =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      const util_1 = require_util();
      exports.default = {
        keyword: "oneOf",
        schemaType: "array",
        trackErrors: true,
        error: {
          message:
            "must match exactly one schema in oneOf",
          params: ({ params }) =>
            (0,
            codegen_1._)`{passingSchemas: ${params.passing}}`,
        },
        code(cxt) {
          const {
            gen,
            schema,
            parentSchema,
            it,
          } = cxt;
          /* istanbul ignore if */
          if (!Array.isArray(schema))
            throw new Error(
              "ajv implementation error",
            );
          if (
            it.opts.discriminator &&
            parentSchema.discriminator
          )
            return;
          const schArr = schema;
          const valid = gen.let(
            "valid",
            false,
          );
          const passing = gen.let(
            "passing",
            null,
          );
          const schValid =
            gen.name("_valid");
          cxt.setParams({ passing });
          gen.block(validateOneOf);
          cxt.result(
            valid,
            () => cxt.reset(),
            () => cxt.error(true),
          );
          function validateOneOf() {
            schArr.forEach((sch, i) => {
              let schCxt;
              if (
                (0,
                util_1.alwaysValidSchema)(
                  it,
                  sch,
                )
              )
                gen.var(schValid, true);
              else
                schCxt = cxt.subschema(
                  {
                    keyword: "oneOf",
                    schemaProp: i,
                    compositeRule: true,
                  },
                  schValid,
                );
              if (i > 0)
                gen
                  .if(
                    (0,
                    codegen_1._)`${schValid} && ${valid}`,
                  )
                  .assign(valid, false)
                  .assign(
                    passing,
                    (0,
                    codegen_1._)`[${passing}, ${i}]`,
                  )
                  .else();
              gen.if(schValid, () => {
                gen.assign(valid, true);
                gen.assign(passing, i);
                if (schCxt)
                  cxt.mergeEvaluated(
                    schCxt,
                    codegen_1.Name,
                  );
              });
            });
          }
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/allOf.js
var require_allOf =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const util_1 = require_util();
      exports.default = {
        keyword: "allOf",
        schemaType: "array",
        code(cxt) {
          const { gen, schema, it } =
            cxt;
          /* istanbul ignore if */
          if (!Array.isArray(schema))
            throw new Error(
              "ajv implementation error",
            );
          const valid =
            gen.name("valid");
          schema.forEach((sch, i) => {
            if (
              (0,
              util_1.alwaysValidSchema)(
                it,
                sch,
              )
            )
              return;
            const schCxt =
              cxt.subschema(
                {
                  keyword: "allOf",
                  schemaProp: i,
                },
                valid,
              );
            cxt.ok(valid);
            cxt.mergeEvaluated(schCxt);
          });
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/if.js
var require_if =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      const util_1 = require_util();
      const def = {
        keyword: "if",
        schemaType: [
          "object",
          "boolean",
        ],
        trackErrors: true,
        error: {
          message: ({ params }) =>
            (0,
            codegen_1.str)`must match "${params.ifClause}" schema`,
          params: ({ params }) =>
            (0,
            codegen_1._)`{failingKeyword: ${params.ifClause}}`,
        },
        code(cxt) {
          const {
            gen,
            parentSchema,
            it,
          } = cxt;
          if (
            parentSchema.then ===
              void 0 &&
            parentSchema.else === void 0
          )
            (0, util_1.checkStrictMode)(
              it,
              '"if" without "then" and "else" is ignored',
            );
          const hasThen = hasSchema(
            it,
            "then",
          );
          const hasElse = hasSchema(
            it,
            "else",
          );
          if (!hasThen && !hasElse)
            return;
          const valid = gen.let(
            "valid",
            true,
          );
          const schValid =
            gen.name("_valid");
          validateIf();
          cxt.reset();
          if (hasThen && hasElse) {
            const ifClause =
              gen.let("ifClause");
            cxt.setParams({ ifClause });
            gen.if(
              schValid,
              validateClause(
                "then",
                ifClause,
              ),
              validateClause(
                "else",
                ifClause,
              ),
            );
          } else if (hasThen)
            gen.if(
              schValid,
              validateClause("then"),
            );
          else
            gen.if(
              (0, codegen_1.not)(
                schValid,
              ),
              validateClause("else"),
            );
          cxt.pass(valid, () =>
            cxt.error(true),
          );
          function validateIf() {
            const schCxt =
              cxt.subschema(
                {
                  keyword: "if",
                  compositeRule: true,
                  createErrors: false,
                  allErrors: false,
                },
                schValid,
              );
            cxt.mergeEvaluated(schCxt);
          }
          function validateClause(
            keyword,
            ifClause,
          ) {
            return () => {
              const schCxt =
                cxt.subschema(
                  { keyword },
                  schValid,
                );
              gen.assign(
                valid,
                schValid,
              );
              cxt.mergeValidEvaluated(
                schCxt,
                valid,
              );
              if (ifClause)
                gen.assign(
                  ifClause,
                  (0,
                  codegen_1._)`${keyword}`,
                );
              else
                cxt.setParams({
                  ifClause: keyword,
                });
            };
          }
        },
      };
      function hasSchema(it, keyword) {
        const schema =
          it.schema[keyword];
        return (
          schema !== void 0 &&
          !(0,
          util_1.alwaysValidSchema)(
            it,
            schema,
          )
        );
      }
      exports.default = def;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/thenElse.js
var require_thenElse =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const util_1 = require_util();
      exports.default = {
        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`,
            );
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/index.js
var require_applicator =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const additionalItems_1 =
        require_additionalItems();
      const prefixItems_1 =
        require_prefixItems();
      const items_1 = require_items();
      const items2020_1 =
        require_items2020();
      const contains_1 =
        require_contains();
      const dependencies_1 =
        require_dependencies();
      const propertyNames_1 =
        require_propertyNames();
      const additionalProperties_1 =
        require_additionalProperties();
      const properties_1 =
        require_properties();
      const patternProperties_1 =
        require_patternProperties();
      const not_1 = require_not();
      const anyOf_1 = require_anyOf();
      const oneOf_1 = require_oneOf();
      const allOf_1 = require_allOf();
      const if_1 = require_if();
      const thenElse_1 =
        require_thenElse();
      function getApplicator(
        draft2020 = false,
      ) {
        const applicator = [
          not_1.default,
          anyOf_1.default,
          oneOf_1.default,
          allOf_1.default,
          if_1.default,
          thenElse_1.default,
          propertyNames_1.default,
          additionalProperties_1.default,
          dependencies_1.default,
          properties_1.default,
          patternProperties_1.default,
        ];
        if (draft2020)
          applicator.push(
            prefixItems_1.default,
            items2020_1.default,
          );
        else
          applicator.push(
            additionalItems_1.default,
            items_1.default,
          );
        applicator.push(
          contains_1.default,
        );
        return applicator;
      }
      exports.default = getApplicator;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/format/format.js
var require_format$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      exports.default = {
        keyword: "format",
        type: ["number", "string"],
        schemaType: "string",
        $data: true,
        error: {
          message: ({ schemaCode }) =>
            (0,
            codegen_1.str)`must match format "${schemaCode}"`,
          params: ({ schemaCode }) =>
            (0,
            codegen_1._)`{format: ${schemaCode}}`,
        },
        code(cxt, ruleType) {
          const {
            gen,
            data,
            $data,
            schema,
            schemaCode,
            it,
          } = cxt;
          const {
            opts,
            errSchemaPath,
            schemaEnv,
            self,
          } = it;
          if (!opts.validateFormats)
            return;
          if ($data)
            validate$DataFormat();
          else validateFormat();
          function validate$DataFormat() {
            const fmts = gen.scopeValue(
              "formats",
              {
                ref: self.formats,
                code: opts.code.formats,
              },
            );
            const fDef = gen.const(
              "fDef",
              (0,
              codegen_1._)`${fmts}[${schemaCode}]`,
            );
            const fType =
              gen.let("fType");
            const format =
              gen.let("format");
            gen.if(
              (0,
              codegen_1._)`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`,
              () =>
                gen
                  .assign(
                    fType,
                    (0,
                    codegen_1._)`${fDef}.type || "string"`,
                  )
                  .assign(
                    format,
                    (0,
                    codegen_1._)`${fDef}.validate`,
                  ),
              () =>
                gen
                  .assign(
                    fType,
                    (0,
                    codegen_1._)`"string"`,
                  )
                  .assign(format, fDef),
            );
            cxt.fail$data(
              (0, codegen_1.or)(
                unknownFmt(),
                invalidFmt(),
              ),
            );
            function unknownFmt() {
              if (
                opts.strictSchema ===
                false
              )
                return codegen_1.nil;
              return (0,
              codegen_1._)`${schemaCode} && !${format}`;
            }
            function invalidFmt() {
              const callFormat =
                schemaEnv.$async
                  ? (0,
                    codegen_1._)`(${fDef}.async ? await ${format}(${data}) : ${format}(${data}))`
                  : (0,
                    codegen_1._)`${format}(${data})`;
              const validData = (0,
              codegen_1._)`(typeof ${format} == "function" ? ${callFormat} : ${format}.test(${data}))`;
              return (0,
              codegen_1._)`${format} && ${format} !== true && ${fType} === ${ruleType} && !${validData}`;
            }
          }
          function validateFormat() {
            const formatDef =
              self.formats[schema];
            if (!formatDef) {
              unknownFormat();
              return;
            }
            if (formatDef === true)
              return;
            const [
              fmtType,
              format,
              fmtRef,
            ] = getFormat(formatDef);
            if (fmtType === ruleType)
              cxt.pass(
                validCondition(),
              );
            function unknownFormat() {
              if (
                opts.strictSchema ===
                false
              ) {
                self.logger.warn(
                  unknownMsg(),
                );
                return;
              }
              throw new Error(
                unknownMsg(),
              );
              function unknownMsg() {
                return `unknown format "${schema}" ignored in schema at path "${errSchemaPath}"`;
              }
            }
            function getFormat(fmtDef) {
              const code =
                fmtDef instanceof RegExp
                  ? (0,
                    codegen_1.regexpCode)(
                      fmtDef,
                    )
                  : opts.code.formats
                    ? (0,
                      codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(schema)}`
                    : void 0;
              const fmt =
                gen.scopeValue(
                  "formats",
                  {
                    key: schema,
                    ref: fmtDef,
                    code,
                  },
                );
              if (
                typeof fmtDef ==
                  "object" &&
                !(
                  fmtDef instanceof
                  RegExp
                )
              )
                return [
                  fmtDef.type ||
                    "string",
                  fmtDef.validate,
                  (0,
                  codegen_1._)`${fmt}.validate`,
                ];
              return [
                "string",
                fmtDef,
                fmt,
              ];
            }
            function validCondition() {
              if (
                typeof formatDef ==
                  "object" &&
                !(
                  formatDef instanceof
                  RegExp
                ) &&
                formatDef.async
              ) {
                if (!schemaEnv.$async)
                  throw new Error(
                    "async format in sync schema",
                  );
                return (0,
                codegen_1._)`await ${fmtRef}(${data})`;
              }
              return typeof format ==
                "function"
                ? (0,
                  codegen_1._)`${fmtRef}(${data})`
                : (0,
                  codegen_1._)`${fmtRef}.test(${data})`;
            }
          }
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/format/index.js
var require_format =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.default = [
        require_format$1().default,
      ];
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/metadata.js
var require_metadata =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      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",
      ];
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/draft7.js
var require_draft7 =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const core_1 = require_core();
      const validation_1 =
        require_validation();
      const applicator_1 =
        require_applicator();
      const format_1 = require_format();
      const metadata_1 =
        require_metadata();
      exports.default = [
        core_1.default,
        validation_1.default,
        (0, applicator_1.default)(),
        format_1.default,
        metadata_1.metadataVocabulary,
        metadata_1.contentVocabulary,
      ];
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/discriminator/types.js
var require_types =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.DiscrError = void 0;
      var DiscrError;
      (function (DiscrError) {
        DiscrError["Tag"] = "tag";
        DiscrError["Mapping"] =
          "mapping";
      })(
        DiscrError ||
          (exports.DiscrError =
            DiscrError =
              {}),
      );
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/discriminator/index.js
var require_discriminator =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      const types_1 = require_types();
      const compile_1 =
        require_compile();
      const ref_error_1 =
        require_ref_error();
      const util_1 = require_util();
      exports.default = {
        keyword: "discriminator",
        type: "object",
        schemaType: "object",
        error: {
          message: ({
            params: {
              discrError,
              tagName,
            },
          }) =>
            discrError ===
            types_1.DiscrError.Tag
              ? `tag "${tagName}" must be string`
              : `value of tag "${tagName}" must be in oneOf`,
          params: ({
            params: {
              discrError,
              tag,
              tagName,
            },
          }) =>
            (0,
            codegen_1._)`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}`,
        },
        code(cxt) {
          const {
            gen,
            data,
            schema,
            parentSchema,
            it,
          } = cxt;
          const { oneOf } =
            parentSchema;
          if (!it.opts.discriminator)
            throw new Error(
              "discriminator: requires discriminator option",
            );
          const tagName =
            schema.propertyName;
          if (
            typeof tagName != "string"
          )
            throw new Error(
              "discriminator: requires propertyName",
            );
          if (schema.mapping)
            throw new Error(
              "discriminator: mapping is not supported",
            );
          if (!oneOf)
            throw new Error(
              "discriminator: requires oneOf keyword",
            );
          const valid = gen.let(
            "valid",
            false,
          );
          const tag = gen.const(
            "tag",
            (0,
            codegen_1._)`${data}${(0, codegen_1.getProperty)(tagName)}`,
          );
          gen.if(
            (0,
            codegen_1._)`typeof ${tag} == "string"`,
            () => validateMapping(),
            () =>
              cxt.error(false, {
                discrError:
                  types_1.DiscrError
                    .Tag,
                tag,
                tagName,
              }),
          );
          cxt.ok(valid);
          function validateMapping() {
            const mapping =
              getMapping();
            gen.if(false);
            for (const tagValue in mapping) {
              gen.elseIf(
                (0,
                codegen_1._)`${tag} === ${tagValue}`,
              );
              gen.assign(
                valid,
                applyTagSchema(
                  mapping[tagValue],
                ),
              );
            }
            gen.else();
            cxt.error(false, {
              discrError:
                types_1.DiscrError
                  .Mapping,
              tag,
              tagName,
            });
            gen.endIf();
          }
          function applyTagSchema(
            schemaProp,
          ) {
            const _valid =
              gen.name("valid");
            const schCxt =
              cxt.subschema(
                {
                  keyword: "oneOf",
                  schemaProp,
                },
                _valid,
              );
            cxt.mergeEvaluated(
              schCxt,
              codegen_1.Name,
            );
            return _valid;
          }
          function getMapping() {
            var _a;
            const oneOfMapping = {};
            const topRequired =
              hasRequired(parentSchema);
            let tagRequired = true;
            for (
              let i = 0;
              i < oneOf.length;
              i++
            ) {
              let sch = oneOf[i];
              if (
                (sch === null ||
                sch === void 0
                  ? void 0
                  : sch.$ref) &&
                !(0,
                util_1.schemaHasRulesButRef)(
                  sch,
                  it.self.RULES,
                )
              ) {
                const ref = sch.$ref;
                sch =
                  compile_1.resolveRef.call(
                    it.self,
                    it.schemaEnv.root,
                    it.baseId,
                    ref,
                  );
                if (
                  sch instanceof
                  compile_1.SchemaEnv
                )
                  sch = sch.schema;
                if (sch === void 0)
                  throw new ref_error_1.default(
                    it.opts.uriResolver,
                    it.baseId,
                    ref,
                  );
              }
              const propSch =
                (_a =
                  sch === null ||
                  sch === void 0
                    ? void 0
                    : sch.properties) ===
                  null || _a === void 0
                  ? void 0
                  : _a[tagName];
              if (
                typeof propSch !=
                "object"
              )
                throw new Error(
                  `discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`,
                );
              tagRequired =
                tagRequired &&
                (topRequired ||
                  hasRequired(sch));
              addMappings(propSch, i);
            }
            if (!tagRequired)
              throw new Error(
                `discriminator: "${tagName}" must be required`,
              );
            return oneOfMapping;
            function hasRequired({
              required,
            }) {
              return (
                Array.isArray(
                  required,
                ) &&
                required.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;
            }
          }
        },
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/json-schema-draft-07.json
var require_json_schema_draft_07 =
  /* @__PURE__ */ __commonJSMin(
    (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,
      };
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/ajv.js
var require_ajv =
  /* @__PURE__ */ __commonJSMin(
    (exports, module) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.MissingRefError =
        exports.ValidationError =
        exports.CodeGen =
        exports.Name =
        exports.nil =
        exports.stringify =
        exports.str =
        exports._ =
        exports.KeywordCxt =
        exports.Ajv =
          void 0;
      const core_1 = require_core$1();
      const draft7_1 = require_draft7();
      const discriminator_1 =
        require_discriminator();
      const draft7MetaSchema =
        require_json_schema_draft_07();
      const META_SUPPORT_DATA = [
        "/properties",
      ];
      const META_SCHEMA_ID =
        "http://json-schema.org/draft-07/schema";
      var Ajv = class
        extends core_1.default
      {
        _addVocabularies() {
          super._addVocabularies();
          draft7_1.default.forEach(
            (v) =>
              this.addVocabulary(v),
          );
          if (this.opts.discriminator)
            this.addKeyword(
              discriminator_1.default,
            );
        }
        _addDefaultMetaSchema() {
          super._addDefaultMetaSchema();
          if (!this.opts.meta) return;
          const metaSchema = this.opts
            .$data
            ? this.$dataMetaSchema(
                draft7MetaSchema,
                META_SUPPORT_DATA,
              )
            : draft7MetaSchema;
          this.addMetaSchema(
            metaSchema,
            META_SCHEMA_ID,
            false,
          );
          this.refs[
            "http://json-schema.org/schema"
          ] = META_SCHEMA_ID;
        }
        defaultMeta() {
          return (this.opts.defaultMeta =
            super.defaultMeta() ||
            (this.getSchema(
              META_SCHEMA_ID,
            )
              ? META_SCHEMA_ID
              : void 0));
        }
      };
      exports.Ajv = Ajv;
      module.exports = exports = Ajv;
      module.exports.Ajv = Ajv;
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.default = Ajv;
      var validate_1 =
        require_validate();
      Object.defineProperty(
        exports,
        "KeywordCxt",
        {
          enumerable: true,
          get: function () {
            return validate_1.KeywordCxt;
          },
        },
      );
      var codegen_1 = require_codegen();
      Object.defineProperty(
        exports,
        "_",
        {
          enumerable: true,
          get: function () {
            return codegen_1._;
          },
        },
      );
      Object.defineProperty(
        exports,
        "str",
        {
          enumerable: true,
          get: function () {
            return codegen_1.str;
          },
        },
      );
      Object.defineProperty(
        exports,
        "stringify",
        {
          enumerable: true,
          get: function () {
            return codegen_1.stringify;
          },
        },
      );
      Object.defineProperty(
        exports,
        "nil",
        {
          enumerable: true,
          get: function () {
            return codegen_1.nil;
          },
        },
      );
      Object.defineProperty(
        exports,
        "Name",
        {
          enumerable: true,
          get: function () {
            return codegen_1.Name;
          },
        },
      );
      Object.defineProperty(
        exports,
        "CodeGen",
        {
          enumerable: true,
          get: function () {
            return codegen_1.CodeGen;
          },
        },
      );
      var validation_error_1 =
        require_validation_error();
      Object.defineProperty(
        exports,
        "ValidationError",
        {
          enumerable: true,
          get: function () {
            return validation_error_1.default;
          },
        },
      );
      var ref_error_1 =
        require_ref_error();
      Object.defineProperty(
        exports,
        "MissingRefError",
        {
          enumerable: true,
          get: function () {
            return ref_error_1.default;
          },
        },
      );
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-formats@3.0.1_ajv@8.20.0/node_modules/ajv-formats/dist/formats.js
var require_formats =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.formatNames =
        exports.fastFormats =
        exports.fullFormats =
          void 0;
      function fmtDef(
        validate,
        compare,
      ) {
        return {
          validate,
          compare,
        };
      }
      exports.fullFormats = {
        date: fmtDef(date, compareDate),
        time: fmtDef(
          getTime(true),
          compareTime,
        ),
        "date-time": fmtDef(
          getDateTime(true),
          compareDateTime,
        ),
        "iso-time": fmtDef(
          getTime(),
          compareIsoTime,
        ),
        "iso-date-time": fmtDef(
          getDateTime(),
          compareIsoDateTime,
        ),
        duration:
          /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/,
        uri,
        "uri-reference":
          /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i,
        "uri-template":
          /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i,
        url: /^(?:https?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu,
        email:
          /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,
        hostname:
          /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i,
        ipv4: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/,
        ipv6: /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i,
        regex,
        uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,
        "json-pointer":
          /^(?:\/(?:[^~/]|~0|~1)*)*$/,
        "json-pointer-uri-fragment":
          /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i,
        "relative-json-pointer":
          /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/,
        byte,
        int32: {
          type: "number",
          validate: validateInt32,
        },
        int64: {
          type: "number",
          validate: validateInt64,
        },
        float: {
          type: "number",
          validate: validateNumber,
        },
        double: {
          type: "number",
          validate: validateNumber,
        },
        password: true,
        binary: true,
      };
      exports.fastFormats = {
        ...exports.fullFormats,
        date: fmtDef(
          /^\d\d\d\d-[0-1]\d-[0-3]\d$/,
          compareDate,
        ),
        time: fmtDef(
          /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i,
          compareTime,
        ),
        "date-time": fmtDef(
          /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i,
          compareDateTime,
        ),
        "iso-time": fmtDef(
          /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i,
          compareIsoTime,
        ),
        "iso-date-time": fmtDef(
          /^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i,
          compareIsoDateTime,
        ),
        uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i,
        "uri-reference":
          /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i,
        email:
          /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i,
      };
      exports.formatNames = Object.keys(
        exports.fullFormats,
      );
      function isLeapYear(year) {
        return (
          year % 4 === 0 &&
          (year % 100 !== 0 ||
            year % 400 === 0)
        );
      }
      const DATE =
        /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
      const DAYS = [
        0, 31, 28, 31, 30, 31, 30, 31,
        31, 30, 31, 30, 31,
      ];
      function date(str) {
        const matches = DATE.exec(str);
        if (!matches) return false;
        const year = +matches[1];
        const month = +matches[2];
        const day = +matches[3];
        return (
          month >= 1 &&
          month <= 12 &&
          day >= 1 &&
          day <=
            (month === 2 &&
            isLeapYear(year)
              ? 29
              : DAYS[month])
        );
      }
      function compareDate(d1, d2) {
        if (!(d1 && d2)) return void 0;
        if (d1 > d2) return 1;
        if (d1 < d2) return -1;
        return 0;
      }
      const TIME =
        /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
      function getTime(strictTimeZone) {
        return function time(str) {
          const matches =
            TIME.exec(str);
          if (!matches) return false;
          const hr = +matches[1];
          const min = +matches[2];
          const sec = +matches[3];
          const tz = matches[4];
          const tzSign =
            matches[5] === "-" ? -1 : 1;
          const tzH = +(
            matches[6] || 0
          );
          const tzM = +(
            matches[7] || 0
          );
          if (
            tzH > 23 ||
            tzM > 59 ||
            (strictTimeZone && !tz)
          )
            return false;
          if (
            hr <= 23 &&
            min <= 59 &&
            sec < 60
          )
            return true;
          const utcMin =
            min - tzM * tzSign;
          const utcHr =
            hr -
            tzH * tzSign -
            (utcMin < 0 ? 1 : 0);
          return (
            (utcHr === 23 ||
              utcHr === -1) &&
            (utcMin === 59 ||
              utcMin === -1) &&
            sec < 61
          );
        };
      }
      function compareTime(s1, s2) {
        if (!(s1 && s2)) return void 0;
        const t1 =
          /* @__PURE__ */ new Date(
            "2020-01-01T" + s1,
          ).valueOf();
        const t2 =
          /* @__PURE__ */ new Date(
            "2020-01-01T" + s2,
          ).valueOf();
        if (!(t1 && t2)) return void 0;
        return t1 - t2;
      }
      function compareIsoTime(t1, t2) {
        if (!(t1 && t2)) return void 0;
        const a1 = TIME.exec(t1);
        const a2 = TIME.exec(t2);
        if (!(a1 && a2)) return void 0;
        t1 = a1[1] + a1[2] + a1[3];
        t2 = a2[1] + a2[2] + a2[3];
        if (t1 > t2) return 1;
        if (t1 < t2) return -1;
        return 0;
      }
      const DATE_TIME_SEPARATOR =
        /t|\s/i;
      function getDateTime(
        strictTimeZone,
      ) {
        const time = getTime(
          strictTimeZone,
        );
        return function date_time(str) {
          const dateTime = str.split(
            DATE_TIME_SEPARATOR,
          );
          return (
            dateTime.length === 2 &&
            date(dateTime[0]) &&
            time(dateTime[1])
          );
        };
      }
      function compareDateTime(
        dt1,
        dt2,
      ) {
        if (!(dt1 && dt2))
          return void 0;
        const d1 = new Date(
          dt1,
        ).valueOf();
        const d2 = new Date(
          dt2,
        ).valueOf();
        if (!(d1 && d2)) return void 0;
        return d1 - d2;
      }
      function compareIsoDateTime(
        dt1,
        dt2,
      ) {
        if (!(dt1 && dt2))
          return void 0;
        const [d1, t1] = dt1.split(
          DATE_TIME_SEPARATOR,
        );
        const [d2, t2] = dt2.split(
          DATE_TIME_SEPARATOR,
        );
        const res = compareDate(d1, d2);
        if (res === void 0)
          return void 0;
        return (
          res || compareTime(t1, t2)
        );
      }
      const NOT_URI_FRAGMENT = /\/|:/;
      const URI =
        /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
      function uri(str) {
        return (
          NOT_URI_FRAGMENT.test(str) &&
          URI.test(str)
        );
      }
      const BYTE =
        /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm;
      function byte(str) {
        BYTE.lastIndex = 0;
        return BYTE.test(str);
      }
      const MIN_INT32 = -(2 ** 31);
      const MAX_INT32 = 2 ** 31 - 1;
      function validateInt32(value) {
        return (
          Number.isInteger(value) &&
          value <= MAX_INT32 &&
          value >= MIN_INT32
        );
      }
      function validateInt64(value) {
        return Number.isInteger(value);
      }
      function validateNumber() {
        return true;
      }
      const Z_ANCHOR = /[^\\]\\Z/;
      function regex(str) {
        if (Z_ANCHOR.test(str))
          return false;
        try {
          new RegExp(str);
          return true;
        } catch (e) {
          return false;
        }
      }
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-formats@3.0.1_ajv@8.20.0/node_modules/ajv-formats/dist/limit.js
var require_limit =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.formatLimitDefinition =
        void 0;
      const ajv_1 = require_ajv();
      const codegen_1 =
        require_codegen();
      const ops = codegen_1.operators;
      const KWDs = {
        formatMaximum: {
          okStr: "<=",
          ok: ops.LTE,
          fail: ops.GT,
        },
        formatMinimum: {
          okStr: ">=",
          ok: ops.GTE,
          fail: ops.LT,
        },
        formatExclusiveMaximum: {
          okStr: "<",
          ok: ops.LT,
          fail: ops.GTE,
        },
        formatExclusiveMinimum: {
          okStr: ">",
          ok: ops.GT,
          fail: ops.LTE,
        },
      };
      exports.formatLimitDefinition = {
        keyword: Object.keys(KWDs),
        type: "string",
        schemaType: "string",
        $data: true,
        error: {
          message: ({
            keyword,
            schemaCode,
          }) =>
            (0,
            codegen_1.str)`should be ${KWDs[keyword].okStr} ${schemaCode}`,
          params: ({
            keyword,
            schemaCode,
          }) =>
            (0,
            codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`,
        },
        code(cxt) {
          const {
            gen,
            data,
            schemaCode,
            keyword,
            it,
          } = cxt;
          const { opts, self } = it;
          if (!opts.validateFormats)
            return;
          const fCxt =
            new ajv_1.KeywordCxt(
              it,
              self.RULES.all.format
                .definition,
              "format",
            );
          if (fCxt.$data)
            validate$DataFormat();
          else validateFormat();
          function validate$DataFormat() {
            const fmts = gen.scopeValue(
              "formats",
              {
                ref: self.formats,
                code: opts.code.formats,
              },
            );
            const fmt = gen.const(
              "fmt",
              (0,
              codegen_1._)`${fmts}[${fCxt.schemaCode}]`,
            );
            cxt.fail$data(
              (0, codegen_1.or)(
                (0,
                codegen_1._)`typeof ${fmt} != "object"`,
                (0,
                codegen_1._)`${fmt} instanceof RegExp`,
                (0,
                codegen_1._)`typeof ${fmt}.compare != "function"`,
                compareCode(fmt),
              ),
            );
          }
          function validateFormat() {
            const format = fCxt.schema;
            const fmtDef =
              self.formats[format];
            if (
              !fmtDef ||
              fmtDef === true
            )
              return;
            if (
              typeof fmtDef !=
                "object" ||
              fmtDef instanceof
                RegExp ||
              typeof fmtDef.compare !=
                "function"
            )
              throw new Error(
                `"${keyword}": format "${format}" does not define "compare" function`,
              );
            const fmt = gen.scopeValue(
              "formats",
              {
                key: format,
                ref: fmtDef,
                code: opts.code.formats
                  ? (0,
                    codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format)}`
                  : void 0,
              },
            );
            cxt.fail$data(
              compareCode(fmt),
            );
          }
          function compareCode(fmt) {
            return (0,
            codegen_1._)`${fmt}.compare(${data}, ${schemaCode}) ${KWDs[keyword].fail} 0`;
          }
        },
        dependencies: ["format"],
      };
      const formatLimitPlugin = (
        ajv,
      ) => {
        ajv.addKeyword(
          exports.formatLimitDefinition,
        );
        return ajv;
      };
      exports.default =
        formatLimitPlugin;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-formats@3.0.1_ajv@8.20.0/node_modules/ajv-formats/dist/index.js
var require_dist$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports, module) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const formats_1 =
        require_formats();
      const limit_1 = require_limit();
      const codegen_1 =
        require_codegen();
      const fullName =
        new codegen_1.Name(
          "fullFormats",
        );
      const fastName =
        new codegen_1.Name(
          "fastFormats",
        );
      const formatsPlugin = (
        ajv,
        opts = { keywords: true },
      ) => {
        if (Array.isArray(opts)) {
          addFormats(
            ajv,
            opts,
            formats_1.fullFormats,
            fullName,
          );
          return ajv;
        }
        const [formats, exportName] =
          opts.mode === "fast"
            ? [
                formats_1.fastFormats,
                fastName,
              ]
            : [
                formats_1.fullFormats,
                fullName,
              ];
        addFormats(
          ajv,
          opts.formats ||
            formats_1.formatNames,
          formats,
          exportName,
        );
        if (opts.keywords)
          (0, limit_1.default)(ajv);
        return ajv;
      };
      formatsPlugin.get = (
        name,
        mode = "full",
      ) => {
        const f = (
          mode === "fast"
            ? formats_1.fastFormats
            : formats_1.fullFormats
        )[name];
        if (!f)
          throw new Error(
            `Unknown format "${name}"`,
          );
        return f;
      };
      function addFormats(
        ajv,
        list,
        fs,
        exportName,
      ) {
        var _a;
        var _b;
        ((_a = (_b = ajv.opts.code)
          .formats) !== null &&
          _a !== void 0) ||
          (_b.formats = (0,
          codegen_1._)`require("ajv-formats/dist/formats").${exportName}`);
        for (const f of list)
          ajv.addFormat(f, fs[f]);
      }
      module.exports = exports =
        formatsPlugin;
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.default = formatsPlugin;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/typeof.js
var require_typeof$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports, module) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      const TYPES = [
        "undefined",
        "string",
        "number",
        "object",
        "function",
        "boolean",
        "symbol",
      ];
      function getDef() {
        return {
          keyword: "typeof",
          schemaType: [
            "string",
            "array",
          ],
          code(cxt) {
            const {
              data,
              schema,
              schemaValue,
            } = cxt;
            cxt.fail(
              typeof schema == "string"
                ? (0,
                  codegen_1._)`typeof ${data} != ${schema}`
                : (0,
                  codegen_1._)`${schemaValue}.indexOf(typeof ${data}) < 0`,
            );
          },
          metaSchema: {
            anyOf: [
              {
                type: "string",
                enum: TYPES,
              },
              {
                type: "array",
                items: {
                  type: "string",
                  enum: TYPES,
                },
              },
            ],
          },
        };
      }
      exports.default = getDef;
      module.exports = getDef;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/typeof.js
var require_typeof =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$22) => {
      var __importDefault =
        (this$22 &&
          this$22.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const typeof_1 = __importDefault(
        require_typeof$1(),
      );
      const typeofPlugin = (ajv) =>
        ajv.addKeyword(
          (0, typeof_1.default)(),
        );
      exports.default = typeofPlugin;
      module.exports = typeofPlugin;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/instanceof.js
var require_instanceof$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports, module) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const CONSTRUCTORS = {
        Object,
        Array,
        Function,
        Number,
        String,
        Date,
        RegExp,
      };
      /* istanbul ignore else */
      if (typeof Buffer != "undefined")
        CONSTRUCTORS.Buffer = Buffer;
      /* istanbul ignore else */
      if (typeof Promise != "undefined")
        CONSTRUCTORS.Promise = Promise;
      const getDef = Object.assign(
        _getDef,
        { CONSTRUCTORS },
      );
      function _getDef() {
        return {
          keyword: "instanceof",
          schemaType: [
            "string",
            "array",
          ],
          compile(schema) {
            if (
              typeof schema == "string"
            ) {
              const C =
                getConstructor(schema);
              return (data) =>
                data instanceof C;
            }
            if (Array.isArray(schema)) {
              const constructors =
                schema.map(
                  getConstructor,
                );
              return (data) => {
                for (const C of constructors)
                  if (data instanceof C)
                    return true;
                return false;
              };
            }
            /* istanbul ignore next */
            throw new Error(
              "ajv implementation error",
            );
          },
          metaSchema: {
            anyOf: [
              { type: "string" },
              {
                type: "array",
                items: {
                  type: "string",
                },
              },
            ],
          },
        };
      }
      function getConstructor(c) {
        const C = CONSTRUCTORS[c];
        if (C) return C;
        throw new Error(
          `invalid "instanceof" keyword value ${c}`,
        );
      }
      exports.default = getDef;
      module.exports = getDef;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/instanceof.js
var require_instanceof =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$21) => {
      var __importDefault =
        (this$21 &&
          this$21.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const instanceof_1 =
        __importDefault(
          require_instanceof$1(),
        );
      const instanceofPlugin = (ajv) =>
        ajv.addKeyword(
          (0, instanceof_1.default)(),
        );
      exports.default =
        instanceofPlugin;
      module.exports = instanceofPlugin;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/_range.js
var require__range =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      function getRangeDef(keyword) {
        return () => ({
          keyword,
          type: "number",
          schemaType: "array",
          macro: function ([min, max]) {
            validateRangeSchema(
              min,
              max,
            );
            return keyword === "range"
              ? {
                  minimum: min,
                  maximum: max,
                }
              : {
                  exclusiveMinimum: min,
                  exclusiveMaximum: max,
                };
          },
          metaSchema: {
            type: "array",
            minItems: 2,
            maxItems: 2,
            items: { type: "number" },
          },
        });
        function validateRangeSchema(
          min,
          max,
        ) {
          if (
            min > max ||
            (keyword ===
              "exclusiveRange" &&
              min === max)
          )
            throw new Error(
              "There are no numbers in range",
            );
        }
      }
      exports.default = getRangeDef;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/range.js
var require_range$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$20) => {
      var __importDefault =
        (this$20 &&
          this$20.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const getDef = (0,
      __importDefault(require__range())
        .default)("range");
      exports.default = getDef;
      module.exports = getDef;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/range.js
var require_range =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$19) => {
      var __importDefault =
        (this$19 &&
          this$19.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const range_1 = __importDefault(
        require_range$1(),
      );
      const range = (ajv) =>
        ajv.addKeyword(
          (0, range_1.default)(),
        );
      exports.default = range;
      module.exports = range;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/exclusiveRange.js
var require_exclusiveRange$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$18) => {
      var __importDefault =
        (this$18 &&
          this$18.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const getDef = (0,
      __importDefault(require__range())
        .default)("exclusiveRange");
      exports.default = getDef;
      module.exports = getDef;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/exclusiveRange.js
var require_exclusiveRange =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$17) => {
      var __importDefault =
        (this$17 &&
          this$17.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const exclusiveRange_1 =
        __importDefault(
          require_exclusiveRange$1(),
        );
      const exclusiveRange = (ajv) =>
        ajv.addKeyword(
          (0,
          exclusiveRange_1.default)(),
        );
      exports.default = exclusiveRange;
      module.exports = exclusiveRange;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/_util.js
var require__util =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      exports.usePattern =
        exports.metaSchemaRef = void 0;
      const codegen_1 =
        require_codegen();
      const META_SCHEMA_ID =
        "http://json-schema.org/schema";
      function metaSchemaRef({
        defaultMeta,
      } = {}) {
        return defaultMeta === false
          ? {}
          : {
              $ref:
                defaultMeta ||
                META_SCHEMA_ID,
            };
      }
      exports.metaSchemaRef =
        metaSchemaRef;
      function usePattern(
        { gen, it: { opts } },
        pattern,
        flags = opts.unicodeRegExp
          ? "u"
          : "",
      ) {
        const rx = new RegExp(
          pattern,
          flags,
        );
        return gen.scopeValue(
          "pattern",
          {
            key: rx.toString(),
            ref: rx,
            code: (0,
            codegen_1._)`new RegExp(${pattern}, ${flags})`,
          },
        );
      }
      exports.usePattern = usePattern;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/regexp.js
var require_regexp$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports, module) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      const _util_1 = require__util();
      const regexpMetaSchema = {
        type: "object",
        properties: {
          pattern: { type: "string" },
          flags: {
            type: "string",
            nullable: true,
          },
        },
        required: ["pattern"],
        additionalProperties: false,
      };
      const metaRegexp =
        /^\/(.*)\/([gimuy]*)$/;
      function getDef() {
        return {
          keyword: "regexp",
          type: "string",
          schemaType: [
            "string",
            "object",
          ],
          code(cxt) {
            const { data, schema } =
              cxt;
            const regx =
              getRegExp(schema);
            cxt.pass(
              (0,
              codegen_1._)`${regx}.test(${data})`,
            );
            function getRegExp(sch) {
              if (
                typeof sch == "object"
              )
                return (0,
                _util_1.usePattern)(
                  cxt,
                  sch.pattern,
                  sch.flags,
                );
              const rx =
                metaRegexp.exec(sch);
              if (rx)
                return (0,
                _util_1.usePattern)(
                  cxt,
                  rx[1],
                  rx[2],
                );
              throw new Error(
                "cannot parse string into RegExp",
              );
            }
          },
          metaSchema: {
            anyOf: [
              { type: "string" },
              regexpMetaSchema,
            ],
          },
        };
      }
      exports.default = getDef;
      module.exports = getDef;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/regexp.js
var require_regexp =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$16) => {
      var __importDefault =
        (this$16 &&
          this$16.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const regexp_1 = __importDefault(
        require_regexp$1(),
      );
      const regexp = (ajv) =>
        ajv.addKeyword(
          (0, regexp_1.default)(),
        );
      exports.default = regexp;
      module.exports = regexp;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/transform.js
var require_transform$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports, module) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      const transform = {
        trimStart: (s) => s.trimStart(),
        trimEnd: (s) => s.trimEnd(),
        trimLeft: (s) => s.trimStart(),
        trimRight: (s) => s.trimEnd(),
        trim: (s) => s.trim(),
        toLowerCase: (s) =>
          s.toLowerCase(),
        toUpperCase: (s) =>
          s.toUpperCase(),
        toEnumCase: (s, cfg) =>
          (cfg === null ||
          cfg === void 0
            ? void 0
            : cfg.hash[configKey(s)]) ||
          s,
      };
      const getDef = Object.assign(
        _getDef,
        { transform },
      );
      function _getDef() {
        return {
          keyword: "transform",
          schemaType: "array",
          before: "enum",
          code(cxt) {
            const {
              gen,
              data,
              schema,
              parentSchema,
              it,
            } = cxt;
            const {
              parentData,
              parentDataProperty,
            } = it;
            const tNames = schema;
            if (!tNames.length) return;
            let cfg;
            if (
              tNames.includes(
                "toEnumCase",
              )
            ) {
              const config =
                getEnumCaseCfg(
                  parentSchema,
                );
              cfg = gen.scopeValue(
                "obj",
                {
                  ref: config,
                  code: (0,
                  codegen_1.stringify)(
                    config,
                  ),
                },
              );
            }
            gen.if(
              (0,
              codegen_1._)`typeof ${data} == "string" && ${parentData} !== undefined`,
              () => {
                gen.assign(
                  data,
                  transformExpr(
                    tNames.slice(),
                  ),
                );
                gen.assign(
                  (0,
                  codegen_1._)`${parentData}[${parentDataProperty}]`,
                  data,
                );
              },
            );
            function transformExpr(ts) {
              if (!ts.length)
                return data;
              const t = ts.pop();
              if (!(t in transform))
                throw new Error(
                  `transform: unknown transformation ${t}`,
                );
              const func =
                gen.scopeValue("func", {
                  ref: transform[t],
                  code: (0,
                  codegen_1._)`require("ajv-keywords/dist/definitions/transform").transform${(0, codegen_1.getProperty)(t)}`,
                });
              const arg =
                transformExpr(ts);
              return cfg &&
                t === "toEnumCase"
                ? (0,
                  codegen_1._)`${func}(${arg}, ${cfg})`
                : (0,
                  codegen_1._)`${func}(${arg})`;
            }
          },
          metaSchema: {
            type: "array",
            items: {
              type: "string",
              enum: Object.keys(
                transform,
              ),
            },
          },
        };
      }
      function getEnumCaseCfg(
        parentSchema,
      ) {
        const cfg = { hash: {} };
        if (!parentSchema.enum)
          throw new Error(
            'transform: "toEnumCase" requires "enum"',
          );
        for (const v of parentSchema.enum) {
          if (typeof v !== "string")
            continue;
          const k = configKey(v);
          if (cfg.hash[k])
            throw new Error(
              'transform: "toEnumCase" requires all lowercased "enum" values to be unique',
            );
          cfg.hash[k] = v;
        }
        return cfg;
      }
      function configKey(s) {
        return s.toLowerCase();
      }
      exports.default = getDef;
      module.exports = getDef;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/transform.js
var require_transform =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$15) => {
      var __importDefault =
        (this$15 &&
          this$15.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const transform_1 =
        __importDefault(
          require_transform$1(),
        );
      const transform = (ajv) =>
        ajv.addKeyword(
          (0, transform_1.default)(),
        );
      exports.default = transform;
      module.exports = transform;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/uniqueItemProperties.js
var require_uniqueItemProperties$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports, module) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const equal =
        require_fast_deep_equal();
      const SCALAR_TYPES = [
        "number",
        "integer",
        "string",
        "boolean",
        "null",
      ];
      function getDef() {
        return {
          keyword:
            "uniqueItemProperties",
          type: "array",
          schemaType: "array",
          compile(keys, parentSchema) {
            const scalar =
              getScalarKeys(
                keys,
                parentSchema,
              );
            return (data) => {
              if (data.length <= 1)
                return true;
              for (
                let k = 0;
                k < keys.length;
                k++
              ) {
                const key = keys[k];
                if (scalar[k]) {
                  const hash = {};
                  for (const x of data) {
                    if (
                      !x ||
                      typeof x !=
                        "object"
                    )
                      continue;
                    let p = x[key];
                    if (
                      p &&
                      typeof p ==
                        "object"
                    )
                      continue;
                    if (
                      typeof p ==
                      "string"
                    )
                      p = '"' + p;
                    if (hash[p])
                      return false;
                    hash[p] = true;
                  }
                } else
                  for (
                    let i = data.length;
                    i--;
                  ) {
                    const x = data[i];
                    if (
                      !x ||
                      typeof x !=
                        "object"
                    )
                      continue;
                    for (
                      let j = i;
                      j--;
                    ) {
                      const y = data[j];
                      if (
                        y &&
                        typeof y ==
                          "object" &&
                        equal(
                          x[key],
                          y[key],
                        )
                      )
                        return false;
                    }
                  }
              }
              return true;
            };
          },
          metaSchema: {
            type: "array",
            items: { type: "string" },
          },
        };
      }
      exports.default = getDef;
      function getScalarKeys(
        keys,
        schema,
      ) {
        return keys.map((key) => {
          var _a, _b, _c;
          const t =
            (_c =
              (_b =
                (_a = schema.items) ===
                  null || _a === void 0
                  ? void 0
                  : _a.properties) ===
                null || _b === void 0
                ? void 0
                : _b[key]) === null ||
            _c === void 0
              ? void 0
              : _c.type;
          return Array.isArray(t)
            ? !t.includes("object") &&
                !t.includes("array")
            : SCALAR_TYPES.includes(t);
        });
      }
      module.exports = getDef;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/uniqueItemProperties.js
var require_uniqueItemProperties =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$14) => {
      var __importDefault =
        (this$14 &&
          this$14.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const uniqueItemProperties_1 =
        __importDefault(
          require_uniqueItemProperties$1(),
        );
      const uniqueItemProperties = (
        ajv,
      ) =>
        ajv.addKeyword(
          (0,
          uniqueItemProperties_1.default)(),
        );
      exports.default =
        uniqueItemProperties;
      module.exports =
        uniqueItemProperties;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/allRequired.js
var require_allRequired$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports, module) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      function getDef() {
        return {
          keyword: "allRequired",
          type: "object",
          schemaType: "boolean",
          macro(schema, parentSchema) {
            if (!schema) return true;
            const required =
              Object.keys(
                parentSchema.properties,
              );
            if (required.length === 0)
              return true;
            return { required };
          },
          dependencies: ["properties"],
        };
      }
      exports.default = getDef;
      module.exports = getDef;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/allRequired.js
var require_allRequired =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$13) => {
      var __importDefault =
        (this$13 &&
          this$13.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const allRequired_1 =
        __importDefault(
          require_allRequired$1(),
        );
      const allRequired = (ajv) =>
        ajv.addKeyword(
          (0, allRequired_1.default)(),
        );
      exports.default = allRequired;
      module.exports = allRequired;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/_required.js
var require__required =
  /* @__PURE__ */ __commonJSMin(
    (exports) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      function getRequiredDef(keyword) {
        return () => ({
          keyword,
          type: "object",
          schemaType: "array",
          macro(schema) {
            if (schema.length === 0)
              return true;
            if (schema.length === 1)
              return {
                required: schema,
              };
            return {
              [keyword === "anyRequired"
                ? "anyOf"
                : "oneOf"]: schema.map(
                (p) => ({
                  required: [p],
                }),
              ),
            };
          },
          metaSchema: {
            type: "array",
            items: { type: "string" },
          },
        });
      }
      exports.default = getRequiredDef;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/anyRequired.js
var require_anyRequired$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$12) => {
      var __importDefault =
        (this$12 &&
          this$12.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const getDef = (0,
      __importDefault(
        require__required(),
      ).default)("anyRequired");
      exports.default = getDef;
      module.exports = getDef;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/anyRequired.js
var require_anyRequired =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$11) => {
      var __importDefault =
        (this$11 &&
          this$11.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const anyRequired_1 =
        __importDefault(
          require_anyRequired$1(),
        );
      const anyRequired = (ajv) =>
        ajv.addKeyword(
          (0, anyRequired_1.default)(),
        );
      exports.default = anyRequired;
      module.exports = anyRequired;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/oneRequired.js
var require_oneRequired$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$10) => {
      var __importDefault =
        (this$10 &&
          this$10.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const getDef = (0,
      __importDefault(
        require__required(),
      ).default)("oneRequired");
      exports.default = getDef;
      module.exports = getDef;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/oneRequired.js
var require_oneRequired =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$9) => {
      var __importDefault =
        (this$9 &&
          this$9.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const oneRequired_1 =
        __importDefault(
          require_oneRequired$1(),
        );
      const oneRequired = (ajv) =>
        ajv.addKeyword(
          (0, oneRequired_1.default)(),
        );
      exports.default = oneRequired;
      module.exports = oneRequired;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/patternRequired.js
var require_patternRequired$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports, module) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      const _util_1 = require__util();
      const error = {
        message: ({
          params: { missingPattern },
        }) =>
          (0,
          codegen_1.str)`should have property matching pattern '${missingPattern}'`,
        params: ({
          params: { missingPattern },
        }) =>
          (0,
          codegen_1._)`{missingPattern: ${missingPattern}}`,
      };
      function getDef() {
        return {
          keyword: "patternRequired",
          type: "object",
          schemaType: "array",
          error,
          code(cxt) {
            const {
              gen,
              schema,
              data,
            } = cxt;
            if (schema.length === 0)
              return;
            const valid = gen.let(
              "valid",
              true,
            );
            for (const pat of schema)
              validateProperties(pat);
            function validateProperties(
              pattern,
            ) {
              const matched = gen.let(
                "matched",
                false,
              );
              gen.forIn(
                "key",
                data,
                (key) => {
                  gen.assign(
                    matched,
                    (0,
                    codegen_1._)`${(0, _util_1.usePattern)(cxt, pattern)}.test(${key})`,
                  );
                  gen.if(matched, () =>
                    gen.break(),
                  );
                },
              );
              cxt.setParams({
                missingPattern: pattern,
              });
              gen.assign(
                valid,
                (0, codegen_1.and)(
                  valid,
                  matched,
                ),
              );
              cxt.pass(valid);
            }
          },
          metaSchema: {
            type: "array",
            items: {
              type: "string",
              format: "regex",
            },
            uniqueItems: true,
          },
        };
      }
      exports.default = getDef;
      module.exports = getDef;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/patternRequired.js
var require_patternRequired =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$8) => {
      var __importDefault =
        (this$8 &&
          this$8.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const patternRequired_1 =
        __importDefault(
          require_patternRequired$1(),
        );
      const patternRequired = (ajv) =>
        ajv.addKeyword(
          (0,
          patternRequired_1.default)(),
        );
      exports.default = patternRequired;
      module.exports = patternRequired;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/prohibited.js
var require_prohibited$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports, module) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      function getDef() {
        return {
          keyword: "prohibited",
          type: "object",
          schemaType: "array",
          macro: function (schema) {
            if (schema.length === 0)
              return true;
            if (schema.length === 1)
              return {
                not: {
                  required: schema,
                },
              };
            return {
              not: {
                anyOf: schema.map(
                  (p) => ({
                    required: [p],
                  }),
                ),
              },
            };
          },
          metaSchema: {
            type: "array",
            items: { type: "string" },
          },
        };
      }
      exports.default = getDef;
      module.exports = getDef;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/prohibited.js
var require_prohibited =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$7) => {
      var __importDefault =
        (this$7 &&
          this$7.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const prohibited_1 =
        __importDefault(
          require_prohibited$1(),
        );
      const prohibited = (ajv) =>
        ajv.addKeyword(
          (0, prohibited_1.default)(),
        );
      exports.default = prohibited;
      module.exports = prohibited;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/deepProperties.js
var require_deepProperties$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports, module) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const _util_1 = require__util();
      function getDef(opts) {
        return {
          keyword: "deepProperties",
          type: "object",
          schemaType: "object",
          macro: function (schema) {
            const allOf = [];
            for (const pointer in schema)
              allOf.push(
                getSchema(
                  pointer,
                  schema[pointer],
                ),
              );
            return { allOf };
          },
          metaSchema: {
            type: "object",
            propertyNames: {
              type: "string",
              format: "json-pointer",
            },
            additionalProperties: (0,
            _util_1.metaSchemaRef)(
              opts,
            ),
          },
        };
      }
      exports.default = getDef;
      function getSchema(
        jsonPointer,
        schema,
      ) {
        const segments =
          jsonPointer.split("/");
        const rootSchema = {};
        let pointerSchema = rootSchema;
        for (
          let i = 1;
          i < segments.length;
          i++
        ) {
          let segment = segments[i];
          const isLast =
            i === segments.length - 1;
          segment =
            unescapeJsonPointer(
              segment,
            );
          const properties =
            (pointerSchema.properties =
              {});
          let items;
          if (/[0-9]+/.test(segment)) {
            let count = +segment;
            items =
              pointerSchema.items = [];
            pointerSchema.type = [
              "object",
              "array",
            ];
            while (count--)
              items.push({});
          } else
            pointerSchema.type =
              "object";
          pointerSchema = isLast
            ? schema
            : {};
          properties[segment] =
            pointerSchema;
          if (items)
            items.push(pointerSchema);
        }
        return rootSchema;
      }
      function unescapeJsonPointer(
        str,
      ) {
        return str
          .replace(/~1/g, "/")
          .replace(/~0/g, "~");
      }
      module.exports = getDef;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/deepProperties.js
var require_deepProperties =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$6) => {
      var __importDefault =
        (this$6 &&
          this$6.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const deepProperties_1 =
        __importDefault(
          require_deepProperties$1(),
        );
      const deepProperties = (
        ajv,
        opts,
      ) =>
        ajv.addKeyword(
          (0, deepProperties_1.default)(
            opts,
          ),
        );
      exports.default = deepProperties;
      module.exports = deepProperties;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/deepRequired.js
var require_deepRequired$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports, module) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      function getDef() {
        return {
          keyword: "deepRequired",
          type: "object",
          schemaType: "array",
          code(ctx) {
            const { schema, data } =
              ctx;
            const props = schema.map(
              (jp) =>
                (0,
                codegen_1._)`(${getData(jp)}) === undefined`,
            );
            ctx.fail(
              (0, codegen_1.or)(
                ...props,
              ),
            );
            function getData(
              jsonPointer,
            ) {
              if (jsonPointer === "")
                throw new Error(
                  "empty JSON pointer not allowed",
                );
              const segments =
                jsonPointer.split("/");
              let x = data;
              const xs = segments.map(
                (s, i) =>
                  i
                    ? (x = (0,
                      codegen_1._)`${x}${(0, codegen_1.getProperty)(unescapeJPSegment(s))}`)
                    : x,
              );
              return (0, codegen_1.and)(
                ...xs,
              );
            }
          },
          metaSchema: {
            type: "array",
            items: {
              type: "string",
              format: "json-pointer",
            },
          },
        };
      }
      exports.default = getDef;
      function unescapeJPSegment(s) {
        return s
          .replace(/~1/g, "/")
          .replace(/~0/g, "~");
      }
      module.exports = getDef;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/deepRequired.js
var require_deepRequired =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$5) => {
      var __importDefault =
        (this$5 &&
          this$5.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const deepRequired_1 =
        __importDefault(
          require_deepRequired$1(),
        );
      const deepRequired = (ajv) =>
        ajv.addKeyword(
          (0, deepRequired_1.default)(),
        );
      exports.default = deepRequired;
      module.exports = deepRequired;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/dynamicDefaults.js
var require_dynamicDefaults$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports, module) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const sequences = {};
      const DEFAULTS = {
        timestamp: () => () =>
          Date.now(),
        datetime: () => () =>
          /* @__PURE__ */ new Date().toISOString(),
        date: () => () =>
          /* @__PURE__ */ new Date()
            .toISOString()
            .slice(0, 10),
        time: () => () =>
          /* @__PURE__ */ new Date()
            .toISOString()
            .slice(11),
        random: () => () =>
          Math.random(),
        randomint: (args) => {
          var _a;
          const max =
            (_a =
              args === null ||
              args === void 0
                ? void 0
                : args.max) !== null &&
            _a !== void 0
              ? _a
              : 2;
          return () =>
            Math.floor(
              Math.random() * max,
            );
        },
        seq: (args) => {
          var _a;
          const name =
            (_a =
              args === null ||
              args === void 0
                ? void 0
                : args.name) !== null &&
            _a !== void 0
              ? _a
              : "";
          sequences[name] ||
            (sequences[name] = 0);
          return () =>
            sequences[name]++;
        },
      };
      const getDef = Object.assign(
        _getDef,
        { DEFAULTS },
      );
      function _getDef() {
        return {
          keyword: "dynamicDefaults",
          type: "object",
          schemaType: [
            "string",
            "object",
          ],
          modifying: true,
          valid: true,
          compile(
            schema,
            _parentSchema,
            it,
          ) {
            if (
              !it.opts.useDefaults ||
              it.compositeRule
            )
              return () => true;
            const fs = {};
            for (const key in schema)
              fs[key] = getDefault(
                schema[key],
              );
            const empty =
              it.opts.useDefaults ===
              "empty";
            return (data) => {
              for (const prop in schema)
                if (
                  data[prop] ===
                    void 0 ||
                  (empty &&
                    (data[prop] ===
                      null ||
                      data[prop] ===
                        ""))
                )
                  data[prop] =
                    fs[prop]();
              return true;
            };
          },
          metaSchema: {
            type: "object",
            additionalProperties: {
              anyOf: [
                { type: "string" },
                {
                  type: "object",
                  additionalProperties: false,
                  required: [
                    "func",
                    "args",
                  ],
                  properties: {
                    func: {
                      type: "string",
                    },
                    args: {
                      type: "object",
                    },
                  },
                },
              ],
            },
          },
        };
      }
      function getDefault(d) {
        return typeof d == "object"
          ? getObjDefault(d)
          : getStrDefault(d);
      }
      function getObjDefault({
        func,
        args,
      }) {
        const def = DEFAULTS[func];
        assertDefined(func, def);
        return def(args);
      }
      function getStrDefault(d = "") {
        const def = DEFAULTS[d];
        assertDefined(d, def);
        return def();
      }
      function assertDefined(
        name,
        def,
      ) {
        if (!def)
          throw new Error(
            `invalid "dynamicDefaults" keyword property value: ${name}`,
          );
      }
      exports.default = getDef;
      module.exports = getDef;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/dynamicDefaults.js
var require_dynamicDefaults =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$4) => {
      var __importDefault =
        (this$4 &&
          this$4.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const dynamicDefaults_1 =
        __importDefault(
          require_dynamicDefaults$1(),
        );
      const dynamicDefaults = (ajv) =>
        ajv.addKeyword(
          (0,
          dynamicDefaults_1.default)(),
        );
      exports.default = dynamicDefaults;
      module.exports = dynamicDefaults;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/select.js
var require_select$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports, module) => {
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const codegen_1 =
        require_codegen();
      const _util_1 = require__util();
      const error = {
        message: ({
          params: { schemaProp },
        }) =>
          schemaProp
            ? (0,
              codegen_1.str)`should match case "${schemaProp}" schema`
            : (0,
              codegen_1.str)`should match default case schema`,
        params: ({
          params: { schemaProp },
        }) =>
          schemaProp
            ? (0,
              codegen_1._)`{failingCase: ${schemaProp}}`
            : (0,
              codegen_1._)`{failingDefault: true}`,
      };
      function getDef(opts) {
        const metaSchema = (0,
        _util_1.metaSchemaRef)(opts);
        return [
          {
            keyword: "select",
            schemaType: [
              "string",
              "number",
              "boolean",
              "null",
            ],
            $data: true,
            error,
            dependencies: [
              "selectCases",
            ],
            code(cxt) {
              const {
                gen,
                schemaCode,
                parentSchema,
              } = cxt;
              cxt.block$data(
                codegen_1.nil,
                () => {
                  const valid = gen.let(
                    "valid",
                    true,
                  );
                  const schValid =
                    gen.name("_valid");
                  const value =
                    gen.const(
                      "value",
                      (0,
                      codegen_1._)`${schemaCode} === null ? "null" : ${schemaCode}`,
                    );
                  gen.if(false);
                  for (const schemaProp in parentSchema.selectCases) {
                    cxt.setParams({
                      schemaProp,
                    });
                    gen.elseIf(
                      (0,
                      codegen_1._)`"" + ${value} == ${schemaProp}`,
                    );
                    const schCxt =
                      cxt.subschema(
                        {
                          keyword:
                            "selectCases",
                          schemaProp,
                        },
                        schValid,
                      );
                    cxt.mergeEvaluated(
                      schCxt,
                      codegen_1.Name,
                    );
                    gen.assign(
                      valid,
                      schValid,
                    );
                  }
                  gen.else();
                  if (
                    parentSchema.selectDefault !==
                    void 0
                  ) {
                    cxt.setParams({
                      schemaProp:
                        void 0,
                    });
                    const schCxt =
                      cxt.subschema(
                        {
                          keyword:
                            "selectDefault",
                        },
                        schValid,
                      );
                    cxt.mergeEvaluated(
                      schCxt,
                      codegen_1.Name,
                    );
                    gen.assign(
                      valid,
                      schValid,
                    );
                  }
                  gen.endIf();
                  cxt.pass(valid);
                },
              );
            },
          },
          {
            keyword: "selectCases",
            dependencies: ["select"],
            metaSchema: {
              type: "object",
              additionalProperties:
                metaSchema,
            },
          },
          {
            keyword: "selectDefault",
            dependencies: [
              "select",
              "selectCases",
            ],
            metaSchema,
          },
        ];
      }
      exports.default = getDef;
      module.exports = getDef;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/select.js
var require_select =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$3) => {
      var __importDefault =
        (this$3 &&
          this$3.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const select_1 = __importDefault(
        require_select$1(),
      );
      const select = (ajv, opts) => {
        (0, select_1.default)(
          opts,
        ).forEach((d) =>
          ajv.addKeyword(d),
        );
        return ajv;
      };
      exports.default = select;
      module.exports = select;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/index.js
var require_keywords =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$2) => {
      var __importDefault =
        (this$2 &&
          this$2.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const typeof_1 = __importDefault(
        require_typeof(),
      );
      const instanceof_1 =
        __importDefault(
          require_instanceof(),
        );
      const range_1 = __importDefault(
        require_range(),
      );
      const exclusiveRange_1 =
        __importDefault(
          require_exclusiveRange(),
        );
      const regexp_1 = __importDefault(
        require_regexp(),
      );
      const transform_1 =
        __importDefault(
          require_transform(),
        );
      const uniqueItemProperties_1 =
        __importDefault(
          require_uniqueItemProperties(),
        );
      const allRequired_1 =
        __importDefault(
          require_allRequired(),
        );
      const anyRequired_1 =
        __importDefault(
          require_anyRequired(),
        );
      const oneRequired_1 =
        __importDefault(
          require_oneRequired(),
        );
      const patternRequired_1 =
        __importDefault(
          require_patternRequired(),
        );
      const prohibited_1 =
        __importDefault(
          require_prohibited(),
        );
      const deepProperties_1 =
        __importDefault(
          require_deepProperties(),
        );
      const deepRequired_1 =
        __importDefault(
          require_deepRequired(),
        );
      const dynamicDefaults_1 =
        __importDefault(
          require_dynamicDefaults(),
        );
      const select_1 = __importDefault(
        require_select(),
      );
      const ajvKeywords = {
        typeof: typeof_1.default,
        instanceof:
          instanceof_1.default,
        range: range_1.default,
        exclusiveRange:
          exclusiveRange_1.default,
        regexp: regexp_1.default,
        transform: transform_1.default,
        uniqueItemProperties:
          uniqueItemProperties_1.default,
        allRequired:
          allRequired_1.default,
        anyRequired:
          anyRequired_1.default,
        oneRequired:
          oneRequired_1.default,
        patternRequired:
          patternRequired_1.default,
        prohibited:
          prohibited_1.default,
        deepProperties:
          deepProperties_1.default,
        deepRequired:
          deepRequired_1.default,
        dynamicDefaults:
          dynamicDefaults_1.default,
        select: select_1.default,
      };
      exports.default = ajvKeywords;
      module.exports = ajvKeywords;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/index.js
var require_dist =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$1) => {
      var __importDefault =
        (this$1 &&
          this$1.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(
        exports,
        "__esModule",
        { value: true },
      );
      const keywords_1 =
        __importDefault(
          require_keywords(),
        );
      const ajvKeywords = (
        ajv,
        keyword,
      ) => {
        if (Array.isArray(keyword)) {
          for (const k of keyword)
            get(k)(ajv);
          return ajv;
        }
        if (keyword) {
          get(keyword)(ajv);
          return ajv;
        }
        for (keyword in keywords_1.default)
          get(keyword)(ajv);
        return ajv;
      };
      ajvKeywords.get = get;
      function get(keyword) {
        const defFunc =
          keywords_1.default[keyword];
        if (!defFunc)
          throw new Error(
            "Unknown keyword " +
              keyword,
          );
        return defFunc;
      }
      exports.default = ajvKeywords;
      module.exports = ajvKeywords;
      module.exports.default =
        ajvKeywords;
    },
  );
//#endregion
//#region ../schemas/libraries/ajv/download/index.ts
var import_ajv = require_ajv();
var import_dist =
  /* @__PURE__ */ __toESM(
    require_dist$1(),
    1,
  );
var import_dist$1 =
  /* @__PURE__ */ __toESM(
    require_dist(),
    1,
  );
const ajv = new import_ajv.Ajv();
(0, import_dist.default)(ajv, {
  formats: ["url"],
});
(0, import_dist$1.default)(ajv, [
  "instanceof",
]);
const dateSchema = {
  type: "object",
  instanceof: "Date",
  required: [],
};
const imageSchema = {
  type: "object",
  properties: {
    id: { type: "number" },
    created: dateSchema,
    title: {
      type: "string",
      minLength: 1,
      maxLength: 100,
    },
    type: {
      type: "string",
      enum: ["jpg", "png"],
    },
    size: { type: "number" },
    url: {
      type: "string",
      format: "url",
    },
  },
  required: [
    "id",
    "created",
    "title",
    "type",
    "size",
    "url",
  ],
};
const productSchema = {
  type: "object",
  properties: {
    id: { type: "number" },
    created: dateSchema,
    title: {
      type: "string",
      minLength: 1,
      maxLength: 100,
    },
    brand: {
      type: "string",
      minLength: 1,
      maxLength: 30,
    },
    description: {
      type: "string",
      minLength: 1,
      maxLength: 500,
    },
    price: {
      type: "number",
      minimum: 1,
      maximum: 1e4,
    },
    discount: {
      type: "number",
      minimum: 1,
      maximum: 100,
      nullable: true,
    },
    quantity: {
      type: "number",
      minimum: 0,
      maximum: 10,
    },
    tags: {
      type: "array",
      items: {
        type: "string",
        minLength: 1,
        maxLength: 30,
      },
    },
    images: {
      type: "array",
      items: imageSchema,
    },
    ratings: {
      type: "array",
      items: {
        type: "object",
        properties: {
          id: { type: "number" },
          stars: {
            type: "number",
            minimum: 1,
            maximum: 5,
          },
          title: {
            type: "string",
            minLength: 1,
            maxLength: 100,
          },
          text: {
            type: "string",
            minLength: 1,
            maxLength: 1e3,
          },
          images: {
            type: "array",
            items: imageSchema,
          },
        },
        required: [
          "id",
          "stars",
          "title",
          "text",
          "images",
        ],
      },
    },
  },
  required: [
    "id",
    "created",
    "title",
    "brand",
    "description",
    "price",
    "discount",
    "quantity",
    "tags",
    "images",
    "ratings",
  ],
};
ajv.validate(productSchema, {});
//#endregion

//#region \0rolldown/runtime.js
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJSMin = (cb, mod) => () => (
  mod ||
    (cb((mod = { exports: {} }).exports, mod, mod.exports),
    (cb = null)),
  mod.exports
);
var __copyProps = (to, from, except, desc) => {
  if (
    (from && typeof from === "object") ||
    typeof from === "function"
  )
    for (
      var keys = __getOwnPropNames(from),
        i = 0,
        n = keys.length,
        key;
      i < n;
      i++
    ) {
      key = keys[i];
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, {
          get: ((k) => from[k]).bind(null, key),
          enumerable:
            !(desc = __getOwnPropDesc(from, key)) ||
            desc.enumerable,
        });
    }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (
  (target = mod != null ? __create(__getProtoOf(mod)) : {}),
  __copyProps(
    isNodeMode ||
      !mod ||
      !mod.__esModule ||
      !__hasOwnProp.call(mod, "default")
      ? __defProp(target, "default", {
          value: mod,
          enumerable: true,
        })
      : target,
    mod,
  )
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/code.js
var require_code$1 = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.regexpCode =
      exports.getEsmExportName =
      exports.getProperty =
      exports.safeStringify =
      exports.stringify =
      exports.strConcat =
      exports.addCodeArg =
      exports.str =
      exports._ =
      exports.nil =
      exports._Code =
      exports.Name =
      exports.IDENTIFIER =
      exports._CodeOrName =
        void 0;
    var _CodeOrName = class {};
    exports._CodeOrName = _CodeOrName;
    exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
    var Name = class extends _CodeOrName {
      constructor(s) {
        super();
        if (!exports.IDENTIFIER.test(s))
          throw new Error(
            "CodeGen: name must be a valid identifier",
          );
        this.str = s;
      }
      toString() {
        return this.str;
      }
      emptyStr() {
        return false;
      }
      get names() {
        return { [this.str]: 1 };
      }
    };
    exports.Name = Name;
    var _Code = class extends _CodeOrName {
      constructor(code) {
        super();
        this._items =
          typeof code === "string" ? [code] : code;
      }
      toString() {
        return this.str;
      }
      emptyStr() {
        if (this._items.length > 1) return false;
        const item = this._items[0];
        return item === "" || item === '""';
      }
      get str() {
        var _a;
        return (_a = this._str) !== null && _a !== void 0
          ? _a
          : (this._str = this._items.reduce(
              (s, c) => `${s}${c}`,
              "",
            ));
      }
      get names() {
        var _a;
        return (_a = this._names) !== null && _a !== void 0
          ? _a
          : (this._names = this._items.reduce(
              (names, c) => {
                if (c instanceof Name)
                  names[c.str] = (names[c.str] || 0) + 1;
                return names;
              },
              {},
            ));
      }
    };
    exports._Code = _Code;
    exports.nil = new _Code("");
    function _(strs, ...args) {
      const code = [strs[0]];
      let i = 0;
      while (i < args.length) {
        addCodeArg(code, args[i]);
        code.push(strs[++i]);
      }
      return new _Code(code);
    }
    exports._ = _;
    const plus = new _Code("+");
    function str(strs, ...args) {
      const expr = [safeStringify(strs[0])];
      let i = 0;
      while (i < args.length) {
        expr.push(plus);
        addCodeArg(expr, args[i]);
        expr.push(plus, safeStringify(strs[++i]));
      }
      optimize(expr);
      return new _Code(expr);
    }
    exports.str = str;
    function addCodeArg(code, arg) {
      if (arg instanceof _Code) code.push(...arg._items);
      else if (arg instanceof Name) code.push(arg);
      else code.push(interpolate(arg));
    }
    exports.addCodeArg = addCodeArg;
    function optimize(expr) {
      let i = 1;
      while (i < expr.length - 1) {
        if (expr[i] === plus) {
          const res = mergeExprItems(
            expr[i - 1],
            expr[i + 1],
          );
          if (res !== void 0) {
            expr.splice(i - 1, 3, res);
            continue;
          }
          expr[i++] = "+";
        }
        i++;
      }
    }
    function mergeExprItems(a, b) {
      if (b === '""') return a;
      if (a === '""') return b;
      if (typeof a == "string") {
        if (b instanceof Name || a[a.length - 1] !== '"')
          return;
        if (typeof b != "string")
          return `${a.slice(0, -1)}${b}"`;
        if (b[0] === '"')
          return a.slice(0, -1) + b.slice(1);
        return;
      }
      if (
        typeof b == "string" &&
        b[0] === '"' &&
        !(a instanceof Name)
      )
        return `"${a}${b.slice(1)}`;
    }
    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;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/scope.js
var require_scope = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.ValueScope =
      exports.ValueScopeName =
      exports.Scope =
      exports.varKinds =
      exports.UsedValueState =
        void 0;
    const code_1 = require_code$1();
    var ValueError = class extends Error {
      constructor(name) {
        super(`CodeGen: "code" for ${name} not defined`);
        this.value = name.value;
      }
    };
    var UsedValueState;
    (function (UsedValueState) {
      UsedValueState[(UsedValueState["Started"] = 0)] =
        "Started";
      UsedValueState[(UsedValueState["Completed"] = 1)] =
        "Completed";
    })(
      UsedValueState ||
        (exports.UsedValueState = UsedValueState = {}),
    );
    exports.varKinds = {
      const: new code_1.Name("const"),
      let: new code_1.Name("let"),
      var: new code_1.Name("var"),
    };
    var Scope = class {
      constructor({ prefixes, parent } = {}) {
        this._names = {};
        this._prefixes = prefixes;
        this._parent = parent;
      }
      toName(nameOrPrefix) {
        return nameOrPrefix instanceof code_1.Name
          ? nameOrPrefix
          : this.name(nameOrPrefix);
      }
      name(prefix) {
        return new code_1.Name(this._newName(prefix));
      }
      _newName(prefix) {
        const ng =
          this._names[prefix] || this._nameGroup(prefix);
        return `${prefix}${ng.index++}`;
      }
      _nameGroup(prefix) {
        var _a, _b;
        if (
          ((_b =
            (_a = this._parent) === null || _a === void 0
              ? void 0
              : _a._prefixes) === null || _b === void 0
            ? void 0
            : _b.has(prefix)) ||
          (this._prefixes && !this._prefixes.has(prefix))
        )
          throw new Error(
            `CodeGen: prefix "${prefix}" is not allowed in this scope`,
          );
        return (this._names[prefix] = {
          prefix,
          index: 0,
        });
      }
    };
    exports.Scope = Scope;
    var ValueScopeName = class extends code_1.Name {
      constructor(prefix, nameStr) {
        super(nameStr);
        this.prefix = prefix;
      }
      setValue(value, { property, itemIndex }) {
        this.value = value;
        this.scopePath = (0,
        code_1._)`.${new code_1.Name(property)}[${itemIndex}]`;
      }
    };
    exports.ValueScopeName = ValueScopeName;
    const line = (0, code_1._)`\n`;
    var ValueScope = class extends Scope {
      constructor(opts) {
        super(opts);
        this._values = {};
        this._scope = opts.scope;
        this.opts = {
          ...opts,
          _n: opts.lines ? line : code_1.nil,
        };
      }
      get() {
        return this._scope;
      }
      name(prefix) {
        return new ValueScopeName(
          prefix,
          this._newName(prefix),
        );
      }
      value(nameOrPrefix, value) {
        var _a;
        if (value.ref === void 0)
          throw new Error(
            "CodeGen: ref must be passed in value",
          );
        const name = this.toName(nameOrPrefix);
        const { prefix } = name;
        const valueKey =
          (_a = value.key) !== null && _a !== void 0
            ? _a
            : value.ref;
        let vs = this._values[prefix];
        if (vs) {
          const _name = vs.get(valueKey);
          if (_name) return _name;
        } else
          vs = this._values[prefix] =
            /* @__PURE__ */ new Map();
        vs.set(valueKey, name);
        const s =
          this._scope[prefix] || (this._scope[prefix] = []);
        const itemIndex = s.length;
        s[itemIndex] = value.ref;
        name.setValue(value, {
          property: prefix,
          itemIndex,
        });
        return name;
      }
      getValue(prefix, keyOrRef) {
        const vs = this._values[prefix];
        if (!vs) return;
        return vs.get(keyOrRef);
      }
      scopeRefs(scopeName, values = this._values) {
        return this._reduceValues(values, (name) => {
          if (name.scopePath === void 0)
            throw new Error(
              `CodeGen: name "${name}" has no value`,
            );
          return (0,
          code_1._)`${scopeName}${name.scopePath}`;
        });
      }
      scopeCode(
        values = this._values,
        usedValues,
        getCode,
      ) {
        return this._reduceValues(
          values,
          (name) => {
            if (name.value === void 0)
              throw new Error(
                `CodeGen: name "${name}" has no value`,
              );
            return name.value.code;
          },
          usedValues,
          getCode,
        );
      }
      _reduceValues(
        values,
        valueCode,
        usedValues = {},
        getCode,
      ) {
        let code = code_1.nil;
        for (const prefix in values) {
          const vs = values[prefix];
          if (!vs) continue;
          const nameSet = (usedValues[prefix] =
            usedValues[prefix] ||
            /* @__PURE__ */ new Map());
          vs.forEach((name) => {
            if (nameSet.has(name)) return;
            nameSet.set(name, UsedValueState.Started);
            let c = valueCode(name);
            if (c) {
              const def = this.opts.es5
                ? exports.varKinds.var
                : exports.varKinds.const;
              code = (0,
              code_1._)`${code}${def} ${name} = ${c};${this.opts._n}`;
            } else if (
              (c =
                getCode === null || getCode === void 0
                  ? void 0
                  : getCode(name))
            )
              code = (0,
              code_1._)`${code}${c}${this.opts._n}`;
            else throw new ValueError(name);
            nameSet.set(name, UsedValueState.Completed);
          });
        }
        return code;
      }
    };
    exports.ValueScope = ValueScope;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/index.js
var require_codegen = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.or =
      exports.and =
      exports.not =
      exports.CodeGen =
      exports.operators =
      exports.varKinds =
      exports.ValueScopeName =
      exports.ValueScope =
      exports.Scope =
      exports.Name =
      exports.regexpCode =
      exports.stringify =
      exports.getProperty =
      exports.nil =
      exports.strConcat =
      exports.str =
      exports._ =
        void 0;
    const code_1 = require_code$1();
    const scope_1 = require_scope();
    var code_2 = require_code$1();
    Object.defineProperty(exports, "_", {
      enumerable: true,
      get: function () {
        return code_2._;
      },
    });
    Object.defineProperty(exports, "str", {
      enumerable: true,
      get: function () {
        return code_2.str;
      },
    });
    Object.defineProperty(exports, "strConcat", {
      enumerable: true,
      get: function () {
        return code_2.strConcat;
      },
    });
    Object.defineProperty(exports, "nil", {
      enumerable: true,
      get: function () {
        return code_2.nil;
      },
    });
    Object.defineProperty(exports, "getProperty", {
      enumerable: true,
      get: function () {
        return code_2.getProperty;
      },
    });
    Object.defineProperty(exports, "stringify", {
      enumerable: true,
      get: function () {
        return code_2.stringify;
      },
    });
    Object.defineProperty(exports, "regexpCode", {
      enumerable: true,
      get: function () {
        return code_2.regexpCode;
      },
    });
    Object.defineProperty(exports, "Name", {
      enumerable: true,
      get: function () {
        return code_2.Name;
      },
    });
    var scope_2 = require_scope();
    Object.defineProperty(exports, "Scope", {
      enumerable: true,
      get: function () {
        return scope_2.Scope;
      },
    });
    Object.defineProperty(exports, "ValueScope", {
      enumerable: true,
      get: function () {
        return scope_2.ValueScope;
      },
    });
    Object.defineProperty(exports, "ValueScopeName", {
      enumerable: true,
      get: function () {
        return scope_2.ValueScopeName;
      },
    });
    Object.defineProperty(exports, "varKinds", {
      enumerable: true,
      get: function () {
        return scope_2.varKinds;
      },
    });
    exports.operators = {
      GT: new code_1._Code(">"),
      GTE: new code_1._Code(">="),
      LT: new code_1._Code("<"),
      LTE: new code_1._Code("<="),
      EQ: new code_1._Code("==="),
      NEQ: new code_1._Code("!=="),
      NOT: new code_1._Code("!"),
      OR: new code_1._Code("||"),
      AND: new code_1._Code("&&"),
      ADD: new code_1._Code("+"),
    };
    var Node = class {
      optimizeNodes() {
        return this;
      }
      optimizeNames(_names, _constants) {
        return this;
      }
    };
    var Def = class extends Node {
      constructor(varKind, name, rhs) {
        super();
        this.varKind = varKind;
        this.name = name;
        this.rhs = rhs;
      }
      render({ es5, _n }) {
        const varKind = es5
          ? scope_1.varKinds.var
          : this.varKind;
        const rhs =
          this.rhs === void 0 ? "" : ` = ${this.rhs}`;
        return `${varKind} ${this.name}${rhs};` + _n;
      }
      optimizeNames(names, 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() {
        return addExprNames(
          this.lhs instanceof code_1.Name
            ? {}
            : { ...this.lhs.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 }) {
        return (
          `break${this.label ? ` ${this.label}` : ""};` + _n
        );
      }
    };
    var Throw = class extends Node {
      constructor(error) {
        super();
        this.error = error;
      }
      render({ _n }) {
        return `throw ${this.error};` + _n;
      }
      get names() {
        return this.error.names;
      }
    };
    var AnyCode = class extends Node {
      constructor(code) {
        super();
        this.code = code;
      }
      render({ _n }) {
        return `${this.code};` + _n;
      }
      optimizeNodes() {
        return `${this.code}` ? this : void 0;
      }
      optimizeNames(names, 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 _a;
        this.else =
          (_a = this.else) === null || _a === void 0
            ? void 0
            : _a.optimizeNames(names, constants);
        if (
          !(
            super.optimizeNames(names, constants) ||
            this.else
          )
        )
          return;
        this.condition = optimizeExpr(
          this.condition,
          names,
          constants,
        );
        return this;
      }
      get names() {
        const names = super.names;
        addExprNames(names, this.condition);
        if (this.else) addNames(names, this.else.names);
        return names;
      }
    };
    If.kind = "if";
    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() {
        return addExprNames(
          addExprNames(super.names, this.from),
          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, args, async) {
        super();
        this.name = name;
        this.args = args;
        this.async = async;
      }
      render(opts) {
        return (
          `${this.async ? "async " : ""}function ${this.name}(${this.args})` +
          super.render(opts)
        );
      }
    };
    Func.kind = "func";
    var Return = class extends ParentNode {
      render(opts) {
        return "return " + super.render(opts);
      }
    };
    Return.kind = "return";
    var Try = class extends BlockNode {
      render(opts) {
        let code = "try" + super.render(opts);
        if (this.catch) code += this.catch.render(opts);
        if (this.finally) code += this.finally.render(opts);
        return code;
      }
      optimizeNodes() {
        var _a, _b;
        super.optimizeNodes();
        (_a = this.catch) === null ||
          _a === void 0 ||
          _a.optimizeNodes();
        (_b = this.finally) === null ||
          _b === void 0 ||
          _b.optimizeNodes();
        return this;
      }
      optimizeNames(names, constants) {
        var _a, _b;
        super.optimizeNames(names, constants);
        (_a = this.catch) === null ||
          _a === void 0 ||
          _a.optimizeNames(names, constants);
        (_b = this.finally) === null ||
          _b === 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(error) {
        super();
        this.error = error;
      }
      render(opts) {
        return `catch(${this.error})` + super.render(opts);
      }
    };
    Catch.kind = "catch";
    var Finally = class extends BlockNode {
      render(opts) {
        return "finally" + super.render(opts);
      }
    };
    Finally.kind = "finally";
    var CodeGen = class {
      constructor(extScope, opts = {}) {
        this._values = {};
        this._blockStarts = [];
        this._constants = {};
        this.opts = {
          ...opts,
          _n: opts.lines ? "\n" : "",
        };
        this._extScope = extScope;
        this._scope = new scope_1.Scope({
          parent: extScope,
        });
        this._nodes = [new Root()];
      }
      toString() {
        return this._root.render(this.opts);
      }
      name(prefix) {
        return this._scope.name(prefix);
      }
      scopeName(prefix) {
        return this._extScope.name(prefix);
      }
      scopeValue(prefixOrName, value) {
        const name = this._extScope.value(
          prefixOrName,
          value,
        );
        (
          this._values[name.prefix] ||
          (this._values[name.prefix] =
            /* @__PURE__ */ new Set())
        ).add(name);
        return name;
      }
      getScopeValue(prefix, keyOrRef) {
        return this._extScope.getValue(prefix, keyOrRef);
      }
      scopeRefs(scopeName) {
        return this._extScope.scopeRefs(
          scopeName,
          this._values,
        );
      }
      scopeCode() {
        return this._extScope.scopeCode(this._values);
      }
      _def(varKind, nameOrPrefix, rhs, constant) {
        const name = this._scope.toName(nameOrPrefix);
        if (rhs !== void 0 && constant)
          this._constants[name.str] = rhs;
        this._leafNode(new Def(varKind, name, rhs));
        return name;
      }
      const(nameOrPrefix, rhs, _constant) {
        return this._def(
          scope_1.varKinds.const,
          nameOrPrefix,
          rhs,
          _constant,
        );
      }
      let(nameOrPrefix, rhs, _constant) {
        return this._def(
          scope_1.varKinds.let,
          nameOrPrefix,
          rhs,
          _constant,
        );
      }
      var(nameOrPrefix, rhs, _constant) {
        return this._def(
          scope_1.varKinds.var,
          nameOrPrefix,
          rhs,
          _constant,
        );
      }
      assign(lhs, rhs, sideEffects) {
        return this._leafNode(
          new Assign(lhs, rhs, sideEffects),
        );
      }
      add(lhs, rhs) {
        return this._leafNode(
          new AssignOp(lhs, exports.operators.ADD, rhs),
        );
      }
      code(c) {
        if (typeof c == "function") c();
        else if (c !== code_1.nil)
          this._leafNode(new AnyCode(c));
        return this;
      }
      object(...keyValues) {
        const code = ["{"];
        for (const [key, value] of keyValues) {
          if (code.length > 1) code.push(",");
          code.push(key);
          if (key !== value || this.opts.es5) {
            code.push(":");
            (0, code_1.addCodeArg)(code, value);
          }
        }
        code.push("}");
        return new code_1._Code(code);
      }
      if(condition, thenBody, elseBody) {
        this._blockNode(new If(condition));
        if (thenBody && elseBody)
          this.code(thenBody).else().code(elseBody).endIf();
        else if (thenBody) this.code(thenBody).endIf();
        else if (elseBody)
          throw new Error(
            'CodeGen: "else" body without "then" body',
          );
        return this;
      }
      elseIf(condition) {
        return this._elseNode(new If(condition));
      }
      else() {
        return this._elseNode(new Else());
      }
      endIf() {
        return this._endBlockNode(If, Else);
      }
      _for(node, forBody) {
        this._blockNode(node);
        if (forBody) this.code(forBody).endFor();
        return this;
      }
      for(iteration, forBody) {
        return this._for(new ForLoop(iteration), forBody);
      }
      forRange(
        nameOrPrefix,
        from,
        to,
        forBody,
        varKind = this.opts.es5
          ? scope_1.varKinds.var
          : scope_1.varKinds.let,
      ) {
        const name = this._scope.toName(nameOrPrefix);
        return this._for(
          new ForRange(varKind, name, from, to),
          () => forBody(name),
        );
      }
      forOf(
        nameOrPrefix,
        iterable,
        forBody,
        varKind = scope_1.varKinds.const,
      ) {
        const name = this._scope.toName(nameOrPrefix);
        if (this.opts.es5) {
          const arr =
            iterable instanceof code_1.Name
              ? iterable
              : this.var("_arr", iterable);
          return this.forRange(
            "_i",
            0,
            (0, code_1._)`${arr}.length`,
            (i) => {
              this.var(name, (0, code_1._)`${arr}[${i}]`);
              forBody(name);
            },
          );
        }
        return this._for(
          new ForIter("of", varKind, name, iterable),
          () => forBody(name),
        );
      }
      forIn(
        nameOrPrefix,
        obj,
        forBody,
        varKind = this.opts.es5
          ? scope_1.varKinds.var
          : scope_1.varKinds.const,
      ) {
        if (this.opts.ownProperties)
          return this.forOf(
            nameOrPrefix,
            (0, code_1._)`Object.keys(${obj})`,
            forBody,
          );
        const name = this._scope.toName(nameOrPrefix);
        return this._for(
          new ForIter("in", varKind, name, obj),
          () => forBody(name),
        );
      }
      endFor() {
        return this._endBlockNode(For);
      }
      label(label) {
        return this._leafNode(new Label(label));
      }
      break(label) {
        return this._leafNode(new Break(label));
      }
      return(value) {
        const node = new Return();
        this._blockNode(node);
        this.code(value);
        if (node.nodes.length !== 1)
          throw new Error(
            'CodeGen: "return" should have one node',
          );
        return this._endBlockNode(Return);
      }
      try(tryBody, catchCode, finallyCode) {
        if (!catchCode && !finallyCode)
          throw new Error(
            'CodeGen: "try" without "catch" and "finally"',
          );
        const node = new Try();
        this._blockNode(node);
        this.code(tryBody);
        if (catchCode) {
          const error = this.name("e");
          this._currNode = node.catch = new Catch(error);
          catchCode(error);
        }
        if (finallyCode) {
          this._currNode = node.finally = new Finally();
          this.code(finallyCode);
        }
        return this._endBlockNode(Catch, Finally);
      }
      throw(error) {
        return this._leafNode(new Throw(error));
      }
      block(body, nodeCount) {
        this._blockStarts.push(this._nodes.length);
        if (body) this.code(body).endBlock(nodeCount);
        return this;
      }
      endBlock(nodeCount) {
        const len = this._blockStarts.pop();
        if (len === 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;
      }
      func(name, args = code_1.nil, async, funcBody) {
        this._blockNode(new Func(name, args, async));
        if (funcBody) this.code(funcBody).endFunc();
        return this;
      }
      endFunc() {
        return this._endBlockNode(Func);
      }
      optimize(n = 1) {
        while (n-- > 0) {
          this._root.optimizeNodes();
          this._root.optimizeNames(
            this._root.names,
            this._constants,
          );
        }
      }
      _leafNode(node) {
        this._currNode.nodes.push(node);
        return this;
      }
      _blockNode(node) {
        this._currNode.nodes.push(node);
        this._nodes.push(node);
      }
      _endBlockNode(N1, N2) {
        const n = this._currNode;
        if (n instanceof N1 || (N2 && n instanceof N2)) {
          this._nodes.pop();
          return this;
        }
        throw new Error(
          `CodeGen: not in block "${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}"`,
        );
      }
      _elseNode(node) {
        const n = this._currNode;
        if (!(n instanceof If))
          throw new Error('CodeGen: "else" without "if"');
        this._currNode = n.else = node;
        return this;
      }
      get _root() {
        return this._nodes[0];
      }
      get _currNode() {
        const ns = this._nodes;
        return ns[ns.length - 1];
      }
      set _currNode(node) {
        const ns = this._nodes;
        ns[ns.length - 1] = node;
      }
    };
    exports.CodeGen = CodeGen;
    function addNames(names, from) {
      for (const n in from)
        names[n] = (names[n] || 0) + (from[n] || 0);
      return names;
    }
    function addExprNames(names, from) {
      return from instanceof code_1._CodeOrName
        ? addNames(names, from.names)
        : names;
    }
    function optimizeExpr(expr, names, constants) {
      if (expr instanceof code_1.Name)
        return replaceName(expr);
      if (!canOptimize(expr)) return expr;
      return new code_1._Code(
        expr._items.reduce((items, c) => {
          if (c instanceof code_1.Name) c = replaceName(c);
          if (c instanceof code_1._Code)
            items.push(...c._items);
          else items.push(c);
          return items;
        }, []),
      );
      function replaceName(n) {
        const c = constants[n.str];
        if (c === 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;
    const andCode = mappend(exports.operators.AND);
    function and(...args) {
      return args.reduce(andCode);
    }
    exports.and = and;
    const orCode = mappend(exports.operators.OR);
    function or(...args) {
      return args.reduce(orCode);
    }
    exports.or = or;
    function mappend(op) {
      return (x, y) =>
        x === code_1.nil
          ? y
          : y === code_1.nil
            ? x
            : (0, code_1._)`${par(x)} ${op} ${par(y)}`;
    }
    function par(x) {
      return x instanceof code_1.Name
        ? x
        : (0, code_1._)`(${x})`;
    }
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/util.js
var require_util = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.checkStrictMode =
      exports.getErrorPath =
      exports.Type =
      exports.useFunc =
      exports.setEvaluated =
      exports.evaluatedPropsToName =
      exports.mergeEvaluated =
      exports.eachItem =
      exports.unescapeJsonPointer =
      exports.escapeJsonPointer =
      exports.escapeFragment =
      exports.unescapeFragment =
      exports.schemaRefOrVal =
      exports.schemaHasRulesButRef =
      exports.schemaHasRules =
      exports.checkUnknownRules =
      exports.alwaysValidSchema =
      exports.toHash =
        void 0;
    const codegen_1 = require_codegen();
    const code_1 = require_code$1();
    function toHash(arr) {
      const hash = {};
      for (const item of arr) hash[item] = true;
      return hash;
    }
    exports.toHash = toHash;
    function alwaysValidSchema(it, schema) {
      if (typeof schema == "boolean") return schema;
      if (Object.keys(schema).length === 0) return true;
      checkUnknownRules(it, schema);
      return !schemaHasRules(schema, it.self.RULES.all);
    }
    exports.alwaysValidSchema = alwaysValidSchema;
    function checkUnknownRules(it, schema = it.schema) {
      const { opts, self } = it;
      if (!opts.strictSchema) return;
      if (typeof schema === "boolean") return;
      const rules = self.RULES.keywords;
      for (const key in schema)
        if (!rules[key])
          checkStrictMode(it, `unknown keyword: "${key}"`);
    }
    exports.checkUnknownRules = checkUnknownRules;
    function schemaHasRules(schema, rules) {
      if (typeof schema == "boolean") return !schema;
      for (const key in schema) if (rules[key]) return true;
      return false;
    }
    exports.schemaHasRules = schemaHasRules;
    function schemaHasRulesButRef(schema, RULES) {
      if (typeof schema == "boolean") return !schema;
      for (const key in schema)
        if (key !== "$ref" && RULES.all[key]) return true;
      return false;
    }
    exports.schemaHasRulesButRef = schemaHasRulesButRef;
    function schemaRefOrVal(
      { topSchemaRef, schemaPath },
      schema,
      keyword,
      $data,
    ) {
      if (!$data) {
        if (
          typeof schema == "number" ||
          typeof schema == "boolean"
        )
          return schema;
        if (typeof schema == "string")
          return (0, codegen_1._)`${schema}`;
      }
      return (0,
      codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
    }
    exports.schemaRefOrVal = schemaRefOrVal;
    function unescapeFragment(str) {
      return unescapeJsonPointer(decodeURIComponent(str));
    }
    exports.unescapeFragment = unescapeFragment;
    function escapeFragment(str) {
      return encodeURIComponent(escapeJsonPointer(str));
    }
    exports.escapeFragment = escapeFragment;
    function escapeJsonPointer(str) {
      if (typeof str == "number") return `${str}`;
      return str.replace(/~/g, "~0").replace(/\//g, "~1");
    }
    exports.escapeJsonPointer = escapeJsonPointer;
    function unescapeJsonPointer(str) {
      return str.replace(/~1/g, "/").replace(/~0/g, "~");
    }
    exports.unescapeJsonPointer = unescapeJsonPointer;
    function eachItem(xs, f) {
      if (Array.isArray(xs)) for (const x of xs) f(x);
      else f(xs);
    }
    exports.eachItem = eachItem;
    function makeMergeEvaluated({
      mergeNames,
      mergeToName,
      mergeValues,
      resultToName,
    }) {
      return (gen, from, to, toName) => {
        const res =
          to === void 0
            ? from
            : to instanceof codegen_1.Name
              ? (from instanceof codegen_1.Name
                  ? mergeNames(gen, from, to)
                  : mergeToName(gen, from, to),
                to)
              : from instanceof codegen_1.Name
                ? (mergeToName(gen, to, from), from)
                : mergeValues(from, to);
        return toName === codegen_1.Name &&
          !(res instanceof codegen_1.Name)
          ? resultToName(gen, res)
          : res;
      };
    }
    exports.mergeEvaluated = {
      props: makeMergeEvaluated({
        mergeNames: (gen, from, to) =>
          gen.if(
            (0,
            codegen_1._)`${to} !== true && ${from} !== undefined`,
            () => {
              gen.if(
                (0, codegen_1._)`${from} === true`,
                () => gen.assign(to, true),
                () =>
                  gen
                    .assign(
                      to,
                      (0, codegen_1._)`${to} || {}`,
                    )
                    .code(
                      (0,
                      codegen_1._)`Object.assign(${to}, ${from})`,
                    ),
              );
            },
          ),
        mergeToName: (gen, from, to) =>
          gen.if((0, codegen_1._)`${to} !== true`, () => {
            if (from === true) gen.assign(to, true);
            else {
              gen.assign(to, (0, codegen_1._)`${to} || {}`);
              setEvaluated(gen, to, from);
            }
          }),
        mergeValues: (from, to) =>
          from === true
            ? true
            : {
                ...from,
                ...to,
              },
        resultToName: evaluatedPropsToName,
      }),
      items: makeMergeEvaluated({
        mergeNames: (gen, from, to) =>
          gen.if(
            (0,
            codegen_1._)`${to} !== true && ${from} !== undefined`,
            () =>
              gen.assign(
                to,
                (0,
                codegen_1._)`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`,
              ),
          ),
        mergeToName: (gen, from, to) =>
          gen.if((0, codegen_1._)`${to} !== true`, () =>
            gen.assign(
              to,
              from === true
                ? true
                : (0,
                  codegen_1._)`${to} > ${from} ? ${to} : ${from}`,
            ),
          ),
        mergeValues: (from, to) =>
          from === true ? true : Math.max(from, to),
        resultToName: (gen, items) =>
          gen.var("items", items),
      }),
    };
    function evaluatedPropsToName(gen, ps) {
      if (ps === true) return gen.var("props", true);
      const props = gen.var("props", (0, codegen_1._)`{}`);
      if (ps !== void 0) setEvaluated(gen, props, ps);
      return props;
    }
    exports.evaluatedPropsToName = evaluatedPropsToName;
    function setEvaluated(gen, props, ps) {
      Object.keys(ps).forEach((p) =>
        gen.assign(
          (0,
          codegen_1._)`${props}${(0, codegen_1.getProperty)(p)}`,
          true,
        ),
      );
    }
    exports.setEvaluated = setEvaluated;
    const snippets = {};
    function useFunc(gen, f) {
      return gen.scopeValue("func", {
        ref: f,
        code:
          snippets[f.code] ||
          (snippets[f.code] = new code_1._Code(f.code)),
      });
    }
    exports.useFunc = useFunc;
    var Type;
    (function (Type) {
      Type[(Type["Num"] = 0)] = "Num";
      Type[(Type["Str"] = 1)] = "Str";
    })(Type || (exports.Type = Type = {}));
    function getErrorPath(
      dataProp,
      dataPropType,
      jsPropertySyntax,
    ) {
      if (dataProp instanceof codegen_1.Name) {
        const isNumber = dataPropType === Type.Num;
        return jsPropertySyntax
          ? isNumber
            ? (0, codegen_1._)`"[" + ${dataProp} + "]"`
            : (0, codegen_1._)`"['" + ${dataProp} + "']"`
          : isNumber
            ? (0, codegen_1._)`"/" + ${dataProp}`
            : (0,
              codegen_1._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
      }
      return jsPropertySyntax
        ? (0, codegen_1.getProperty)(dataProp).toString()
        : "/" + escapeJsonPointer(dataProp);
    }
    exports.getErrorPath = getErrorPath;
    function checkStrictMode(
      it,
      msg,
      mode = it.opts.strictSchema,
    ) {
      if (!mode) return;
      msg = `strict mode: ${msg}`;
      if (mode === true) throw new Error(msg);
      it.self.logger.warn(msg);
    }
    exports.checkStrictMode = checkStrictMode;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/names.js
var require_names = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    exports.default = {
      data: new codegen_1.Name("data"),
      valCxt: new codegen_1.Name("valCxt"),
      instancePath: new codegen_1.Name("instancePath"),
      parentData: new codegen_1.Name("parentData"),
      parentDataProperty: new codegen_1.Name(
        "parentDataProperty",
      ),
      rootData: new codegen_1.Name("rootData"),
      dynamicAnchors: new codegen_1.Name("dynamicAnchors"),
      vErrors: new codegen_1.Name("vErrors"),
      errors: new codegen_1.Name("errors"),
      this: new codegen_1.Name("this"),
      self: new codegen_1.Name("self"),
      scope: new codegen_1.Name("scope"),
      json: new codegen_1.Name("json"),
      jsonPos: new codegen_1.Name("jsonPos"),
      jsonLen: new codegen_1.Name("jsonLen"),
      jsonPart: new codegen_1.Name("jsonPart"),
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/errors.js
var require_errors = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.extendErrors =
      exports.resetErrorsCount =
      exports.reportExtraError =
      exports.reportError =
      exports.keyword$DataError =
      exports.keywordError =
        void 0;
    const codegen_1 = require_codegen();
    const util_1 = require_util();
    const names_1 = require_names();
    exports.keywordError = {
      message: ({ keyword }) =>
        (0,
        codegen_1.str)`must pass "${keyword}" keyword validation`,
    };
    exports.keyword$DataError = {
      message: ({ keyword, schemaType }) =>
        schemaType
          ? (0,
            codegen_1.str)`"${keyword}" keyword must be ${schemaType} ($data)`
          : (0,
            codegen_1.str)`"${keyword}" keyword is invalid ($data)`,
    };
    function reportError(
      cxt,
      error = exports.keywordError,
      errorPaths,
      overrideAllErrors,
    ) {
      const { it } = cxt;
      const { gen, compositeRule, allErrors } = it;
      const errObj = errorObjectCode(
        cxt,
        error,
        errorPaths,
      );
      if (
        overrideAllErrors !== null &&
        overrideAllErrors !== void 0
          ? overrideAllErrors
          : compositeRule || allErrors
      )
        addError(gen, errObj);
      else returnErrors(it, (0, codegen_1._)`[${errObj}]`);
    }
    exports.reportError = reportError;
    function reportExtraError(
      cxt,
      error = exports.keywordError,
      errorPaths,
    ) {
      const { it } = cxt;
      const { gen, compositeRule, allErrors } = it;
      addError(
        gen,
        errorObjectCode(cxt, error, errorPaths),
      );
      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,
    }) {
      /* istanbul ignore if */
      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);
      }
    }
    const E = {
      keyword: new codegen_1.Name("keyword"),
      schemaPath: new codegen_1.Name("schemaPath"),
      params: new codegen_1.Name("params"),
      propertyName: new codegen_1.Name("propertyName"),
      message: new codegen_1.Name("message"),
      schema: new codegen_1.Name("schema"),
      parentSchema: new codegen_1.Name("parentSchema"),
    };
    function errorObjectCode(cxt, error, errorPaths) {
      const { createErrors } = cxt.it;
      if (createErrors === false)
        return (0, codegen_1._)`{}`;
      return errorObject(cxt, error, errorPaths);
    }
    function errorObject(cxt, error, errorPaths = {}) {
      const { gen, it } = cxt;
      const keyValues = [
        errorInstancePath(it, errorPaths),
        errorSchemaPath(cxt, errorPaths),
      ];
      extraErrorProps(cxt, error, keyValues);
      return gen.object(...keyValues);
    }
    function errorInstancePath(
      { errorPath },
      { instancePath },
    ) {
      const instPath = instancePath
        ? (0,
          codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(instancePath, util_1.Type.Str)}`
        : errorPath;
      return [
        names_1.default.instancePath,
        (0, codegen_1.strConcat)(
          names_1.default.instancePath,
          instPath,
        ),
      ];
    }
    function errorSchemaPath(
      { keyword, it: { errSchemaPath } },
      { schemaPath, parentSchema },
    ) {
      let schPath = parentSchema
        ? errSchemaPath
        : (0, codegen_1.str)`${errSchemaPath}/${keyword}`;
      if (schemaPath)
        schPath = (0,
        codegen_1.str)`${schPath}${(0, util_1.getErrorPath)(schemaPath, util_1.Type.Str)}`;
      return [E.schemaPath, schPath];
    }
    function extraErrorProps(
      cxt,
      { params, message },
      keyValues,
    ) {
      const { keyword, data, schemaValue, it } = cxt;
      const {
        opts,
        propertyName,
        topSchemaRef,
        schemaPath,
      } = it;
      keyValues.push(
        [E.keyword, keyword],
        [
          E.params,
          typeof params == "function"
            ? params(cxt)
            : params || (0, codegen_1._)`{}`,
        ],
      );
      if (opts.messages)
        keyValues.push([
          E.message,
          typeof message == "function"
            ? message(cxt)
            : message,
        ]);
      if (opts.verbose)
        keyValues.push(
          [E.schema, schemaValue],
          [
            E.parentSchema,
            (0, codegen_1._)`${topSchemaRef}${schemaPath}`,
          ],
          [names_1.default.data, data],
        );
      if (propertyName)
        keyValues.push([E.propertyName, propertyName]);
    }
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/boolSchema.js
var require_boolSchema = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.boolOrEmptySchema =
      exports.topBoolOrEmptySchema = void 0;
    const errors_1 = require_errors();
    const codegen_1 = require_codegen();
    const names_1 = require_names();
    const boolError = {
      message: "boolean schema is false",
    };
    function topBoolOrEmptySchema(it) {
      const { gen, schema, validateName } = it;
      if (schema === false) falseSchemaError(it, false);
      else if (
        typeof schema == "object" &&
        schema.$async === true
      )
        gen.return(names_1.default.data);
      else {
        gen.assign(
          (0, codegen_1._)`${validateName}.errors`,
          null,
        );
        gen.return(true);
      }
    }
    exports.topBoolOrEmptySchema = topBoolOrEmptySchema;
    function boolOrEmptySchema(it, valid) {
      const { gen, schema } = it;
      if (schema === false) {
        gen.var(valid, false);
        falseSchemaError(it);
      } else gen.var(valid, true);
    }
    exports.boolOrEmptySchema = boolOrEmptySchema;
    function falseSchemaError(it, overrideAllErrors) {
      const { gen, data } = it;
      const cxt = {
        gen,
        keyword: "false schema",
        data,
        schema: false,
        schemaCode: false,
        schemaValue: false,
        params: {},
        it,
      };
      (0, errors_1.reportError)(
        cxt,
        boolError,
        void 0,
        overrideAllErrors,
      );
    }
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/rules.js
var require_rules = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.getRules = exports.isJSONType = void 0;
    const jsonTypes = /* @__PURE__ */ new Set([
      "string",
      "number",
      "integer",
      "boolean",
      "null",
      "object",
      "array",
    ]);
    function isJSONType(x) {
      return typeof x == "string" && jsonTypes.has(x);
    }
    exports.isJSONType = isJSONType;
    function getRules() {
      const groups = {
        number: {
          type: "number",
          rules: [],
        },
        string: {
          type: "string",
          rules: [],
        },
        array: {
          type: "array",
          rules: [],
        },
        object: {
          type: "object",
          rules: [],
        },
      };
      return {
        types: {
          ...groups,
          integer: true,
          boolean: true,
          null: true,
        },
        rules: [
          { rules: [] },
          groups.number,
          groups.string,
          groups.array,
          groups.object,
        ],
        post: { rules: [] },
        all: {},
        keywords: {},
      };
    }
    exports.getRules = getRules;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/applicability.js
var require_applicability = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.shouldUseRule =
      exports.shouldUseGroup =
      exports.schemaHasRulesForType =
        void 0;
    function schemaHasRulesForType({ schema, self }, type) {
      const group = self.RULES.types[type];
      return (
        group &&
        group !== true &&
        shouldUseGroup(schema, group)
      );
    }
    exports.schemaHasRulesForType = schemaHasRulesForType;
    function shouldUseGroup(schema, group) {
      return group.rules.some((rule) =>
        shouldUseRule(schema, rule),
      );
    }
    exports.shouldUseGroup = shouldUseGroup;
    function shouldUseRule(schema, rule) {
      var _a;
      return (
        schema[rule.keyword] !== void 0 ||
        ((_a = rule.definition.implements) === null ||
        _a === void 0
          ? void 0
          : _a.some((kwd) => schema[kwd] !== void 0))
      );
    }
    exports.shouldUseRule = shouldUseRule;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/dataType.js
var require_dataType = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.reportTypeError =
      exports.checkDataTypes =
      exports.checkDataType =
      exports.coerceAndCheckDataType =
      exports.getJSONTypes =
      exports.getSchemaTypes =
      exports.DataType =
        void 0;
    const rules_1 = require_rules();
    const applicability_1 = require_applicability();
    const errors_1 = require_errors();
    const codegen_1 = require_codegen();
    const util_1 = require_util();
    var DataType;
    (function (DataType) {
      DataType[(DataType["Correct"] = 0)] = "Correct";
      DataType[(DataType["Wrong"] = 1)] = "Wrong";
    })(DataType || (exports.DataType = DataType = {}));
    function getSchemaTypes(schema) {
      const types = getJSONTypes(schema.type);
      if (types.includes("null")) {
        if (schema.nullable === false)
          throw new Error(
            "type: null contradicts nullable: false",
          );
      } else {
        if (!types.length && schema.nullable !== void 0)
          throw new Error(
            '"nullable" cannot be used without "type"',
          );
        if (schema.nullable === true) types.push("null");
      }
      return types;
    }
    exports.getSchemaTypes = getSchemaTypes;
    function getJSONTypes(ts) {
      const types = Array.isArray(ts) ? ts : ts ? [ts] : [];
      if (types.every(rules_1.isJSONType)) return types;
      throw new Error(
        "type must be JSONType or JSONType[]: " +
          types.join(","),
      );
    }
    exports.getJSONTypes = getJSONTypes;
    function coerceAndCheckDataType(it, types) {
      const { gen, data, opts } = it;
      const coerceTo = coerceToTypes(
        types,
        opts.coerceTypes,
      );
      const checkTypes =
        types.length > 0 &&
        !(
          coerceTo.length === 0 &&
          types.length === 1 &&
          (0, applicability_1.schemaHasRulesForType)(
            it,
            types[0],
          )
        );
      if (checkTypes) {
        const wrongType = checkDataTypes(
          types,
          data,
          opts.strictNumbers,
          DataType.Wrong,
        );
        gen.if(wrongType, () => {
          if (coerceTo.length)
            coerceData(it, types, coerceTo);
          else reportTypeError(it);
        });
      }
      return checkTypes;
    }
    exports.coerceAndCheckDataType = coerceAndCheckDataType;
    const 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;
    const typeError = {
      message: ({ schema }) => `must be ${schema}`,
      params: ({ schema, schemaValue }) =>
        typeof schema == "string"
          ? (0, codegen_1._)`{type: ${schema}}`
          : (0, codegen_1._)`{type: ${schemaValue}}`,
    };
    function reportTypeError(it) {
      const cxt = getTypeErrorContext(it);
      (0, errors_1.reportError)(cxt, typeError);
    }
    exports.reportTypeError = reportTypeError;
    function getTypeErrorContext(it) {
      const { gen, data, schema } = it;
      const schemaCode = (0, util_1.schemaRefOrVal)(
        it,
        schema,
        "type",
      );
      return {
        gen,
        keyword: "type",
        data,
        schema: schema.type,
        schemaCode,
        schemaValue: schemaCode,
        parentSchema: schema,
        params: {},
        it,
      };
    }
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/defaults.js
var require_defaults = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.assignDefaults = void 0;
    const codegen_1 = require_codegen();
    const util_1 = require_util();
    function assignDefaults(it, ty) {
      const { properties, items } = it.schema;
      if (ty === "object" && properties)
        for (const key in properties)
          assignDefault(it, key, properties[key].default);
      else if (ty === "array" && Array.isArray(items))
        items.forEach((sch, i) =>
          assignDefault(it, i, sch.default),
        );
    }
    exports.assignDefaults = assignDefaults;
    function assignDefault(it, prop, defaultValue) {
      const { gen, compositeRule, data, opts } = it;
      if (defaultValue === void 0) return;
      const childData = (0,
      codegen_1._)`${data}${(0, codegen_1.getProperty)(prop)}`;
      if (compositeRule) {
        (0, util_1.checkStrictMode)(
          it,
          `default is ignored for: ${childData}`,
        );
        return;
      }
      let condition = (0,
      codegen_1._)`${childData} === undefined`;
      if (opts.useDefaults === "empty")
        condition = (0,
        codegen_1._)`${condition} || ${childData} === null || ${childData} === ""`;
      gen.if(
        condition,
        (0,
        codegen_1._)`${childData} = ${(0, codegen_1.stringify)(defaultValue)}`,
      );
    }
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/code.js
var require_code = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.validateUnion =
      exports.validateArray =
      exports.usePattern =
      exports.callValidateCode =
      exports.schemaProperties =
      exports.allSchemaProperties =
      exports.noPropertyInData =
      exports.propertyInData =
      exports.isOwnProperty =
      exports.hasPropFunc =
      exports.reportMissingProp =
      exports.checkMissingProp =
      exports.checkReportMissingProp =
        void 0;
    const codegen_1 = require_codegen();
    const util_1 = require_util();
    const names_1 = require_names();
    const util_2 = require_util();
    function checkReportMissingProp(cxt, prop) {
      const { gen, data, it } = cxt;
      gen.if(
        noPropertyInData(
          gen,
          data,
          prop,
          it.opts.ownProperties,
        ),
        () => {
          cxt.setParams(
            { missingProperty: (0, codegen_1._)`${prop}` },
            true,
          );
          cxt.error();
        },
      );
    }
    exports.checkReportMissingProp = checkReportMissingProp;
    function checkMissingProp(
      { gen, data, it: { opts } },
      properties,
      missing,
    ) {
      return (0, codegen_1.or)(
        ...properties.map((prop) =>
          (0, codegen_1.and)(
            noPropertyInData(
              gen,
              data,
              prop,
              opts.ownProperties,
            ),
            (0, codegen_1._)`${missing} = ${prop}`,
          ),
        ),
      );
    }
    exports.checkMissingProp = checkMissingProp;
    function reportMissingProp(cxt, missing) {
      cxt.setParams({ missingProperty: missing }, true);
      cxt.error();
    }
    exports.reportMissingProp = reportMissingProp;
    function hasPropFunc(gen) {
      return gen.scopeValue("func", {
        ref: Object.prototype.hasOwnProperty,
        code: (0,
        codegen_1._)`Object.prototype.hasOwnProperty`,
      });
    }
    exports.hasPropFunc = hasPropFunc;
    function isOwnProperty(gen, data, property) {
      return (0,
      codegen_1._)`${hasPropFunc(gen)}.call(${data}, ${property})`;
    }
    exports.isOwnProperty = isOwnProperty;
    function propertyInData(
      gen,
      data,
      property,
      ownProperties,
    ) {
      const cond = (0,
      codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} !== undefined`;
      return ownProperties
        ? (0,
          codegen_1._)`${cond} && ${isOwnProperty(gen, data, property)}`
        : cond;
    }
    exports.propertyInData = propertyInData;
    function noPropertyInData(
      gen,
      data,
      property,
      ownProperties,
    ) {
      const cond = (0,
      codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} === undefined`;
      return ownProperties
        ? (0, codegen_1.or)(
            cond,
            (0, codegen_1.not)(
              isOwnProperty(gen, data, property),
            ),
          )
        : cond;
    }
    exports.noPropertyInData = noPropertyInData;
    function allSchemaProperties(schemaMap) {
      return schemaMap
        ? Object.keys(schemaMap).filter(
            (p) => p !== "__proto__",
          )
        : [];
    }
    exports.allSchemaProperties = allSchemaProperties;
    function schemaProperties(it, schemaMap) {
      return allSchemaProperties(schemaMap).filter(
        (p) =>
          !(0, util_1.alwaysValidSchema)(it, schemaMap[p]),
      );
    }
    exports.schemaProperties = schemaProperties;
    function callValidateCode(
      {
        schemaCode,
        data,
        it: { gen, topSchemaRef, schemaPath, errorPath },
        it,
      },
      func,
      context,
      passSchema,
    ) {
      const dataAndSchema = passSchema
        ? (0,
          codegen_1._)`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}`
        : data;
      const valCxt = [
        [
          names_1.default.instancePath,
          (0, codegen_1.strConcat)(
            names_1.default.instancePath,
            errorPath,
          ),
        ],
        [names_1.default.parentData, it.parentData],
        [
          names_1.default.parentDataProperty,
          it.parentDataProperty,
        ],
        [
          names_1.default.rootData,
          names_1.default.rootData,
        ],
      ];
      if (it.opts.dynamicRef)
        valCxt.push([
          names_1.default.dynamicAnchors,
          names_1.default.dynamicAnchors,
        ]);
      const args = (0,
      codegen_1._)`${dataAndSchema}, ${gen.object(...valCxt)}`;
      return context !== codegen_1.nil
        ? (0,
          codegen_1._)`${func}.call(${context}, ${args})`
        : (0, codegen_1._)`${func}(${args})`;
    }
    exports.callValidateCode = callValidateCode;
    const newRegExp = (0, codegen_1._)`new RegExp`;
    function usePattern({ gen, it: { opts } }, pattern) {
      const u = opts.unicodeRegExp ? "u" : "";
      const { regExp } = opts.code;
      const rx = regExp(pattern, u);
      return gen.scopeValue("pattern", {
        key: rx.toString(),
        ref: rx,
        code: (0,
        codegen_1._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern}, ${u})`,
      });
    }
    exports.usePattern = usePattern;
    function validateArray(cxt) {
      const { gen, data, keyword, it } = cxt;
      const valid = gen.name("valid");
      if (it.allErrors) {
        const validArr = gen.let("valid", true);
        validateItems(() => gen.assign(validArr, false));
        return validArr;
      }
      gen.var(valid, true);
      validateItems(() => gen.break());
      return valid;
      function validateItems(notValid) {
        const len = gen.const(
          "len",
          (0, codegen_1._)`${data}.length`,
        );
        gen.forRange("i", 0, len, (i) => {
          cxt.subschema(
            {
              keyword,
              dataProp: i,
              dataPropType: util_1.Type.Num,
            },
            valid,
          );
          gen.if((0, codegen_1.not)(valid), notValid);
        });
      }
    }
    exports.validateArray = validateArray;
    function validateUnion(cxt) {
      const { gen, schema, keyword, it } = cxt;
      /* istanbul ignore if */
      if (!Array.isArray(schema))
        throw new Error("ajv implementation error");
      if (
        schema.some((sch) =>
          (0, util_1.alwaysValidSchema)(it, sch),
        ) &&
        !it.opts.unevaluated
      )
        return;
      const valid = gen.let("valid", false);
      const schValid = gen.name("_valid");
      gen.block(() =>
        schema.forEach((_sch, i) => {
          const schCxt = cxt.subschema(
            {
              keyword,
              schemaProp: i,
              compositeRule: true,
            },
            schValid,
          );
          gen.assign(
            valid,
            (0, codegen_1._)`${valid} || ${schValid}`,
          );
          if (!cxt.mergeValidEvaluated(schCxt, schValid))
            gen.if((0, codegen_1.not)(valid));
        }),
      );
      cxt.result(
        valid,
        () => cxt.reset(),
        () => cxt.error(true),
      );
    }
    exports.validateUnion = validateUnion;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/keyword.js
var require_keyword = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.validateKeywordUsage =
      exports.validSchemaType =
      exports.funcKeywordCode =
      exports.macroKeywordCode =
        void 0;
    const codegen_1 = require_codegen();
    const names_1 = require_names();
    const code_1 = require_code();
    const errors_1 = require_errors();
    function macroKeywordCode(cxt, def) {
      const { gen, keyword, schema, parentSchema, it } =
        cxt;
      const macroSchema = def.macro.call(
        it.self,
        schema,
        parentSchema,
        it,
      );
      const schemaRef = useKeyword(
        gen,
        keyword,
        macroSchema,
      );
      if (it.opts.validateSchema !== false)
        it.self.validateSchema(macroSchema, true);
      const valid = gen.name("valid");
      cxt.subschema(
        {
          schema: macroSchema,
          schemaPath: codegen_1.nil,
          errSchemaPath: `${it.errSchemaPath}/${keyword}`,
          topSchemaRef: schemaRef,
          compositeRule: true,
        },
        valid,
      );
      cxt.pass(valid, () => cxt.error(true));
    }
    exports.macroKeywordCode = macroKeywordCode;
    function funcKeywordCode(cxt, def) {
      var _a;
      const {
        gen,
        keyword,
        schema,
        parentSchema,
        $data,
        it,
      } = cxt;
      checkAsyncKeyword(it, def);
      const validateRef = useKeyword(
        gen,
        keyword,
        !$data && def.compile
          ? def.compile.call(
              it.self,
              schema,
              parentSchema,
              it,
            )
          : def.validate,
      );
      const valid = gen.let("valid");
      cxt.block$data(valid, validateKeyword);
      cxt.ok(
        (_a = def.valid) !== null && _a !== void 0
          ? _a
          : valid,
      );
      function validateKeyword() {
        if (def.errors === false) {
          assignValid();
          if (def.modifying) modifyData(cxt);
          reportErrs(() => cxt.error());
        } else {
          const ruleErrs = def.async
            ? validateAsync()
            : validateSync();
          if (def.modifying) modifyData(cxt);
          reportErrs(() => addErrs(cxt, ruleErrs));
        }
      }
      function validateAsync() {
        const ruleErrs = gen.let("ruleErrs", null);
        gen.try(
          () => assignValid((0, codegen_1._)`await `),
          (e) =>
            gen.assign(valid, false).if(
              (0,
              codegen_1._)`${e} instanceof ${it.ValidationError}`,
              () =>
                gen.assign(
                  ruleErrs,
                  (0, codegen_1._)`${e}.errors`,
                ),
              () => gen.throw(e),
            ),
        );
        return ruleErrs;
      }
      function validateSync() {
        const validateErrs = (0,
        codegen_1._)`${validateRef}.errors`;
        gen.assign(validateErrs, null);
        assignValid(codegen_1.nil);
        return validateErrs;
      }
      function assignValid(
        _await = def.async
          ? (0, codegen_1._)`await `
          : codegen_1.nil,
      ) {
        const passCxt = it.opts.passContext
          ? names_1.default.this
          : names_1.default.self;
        const passSchema = !(
          ("compile" in def && !$data) ||
          def.schema === false
        );
        gen.assign(
          valid,
          (0,
          codegen_1._)`${_await}${(0, code_1.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`,
          def.modifying,
        );
      }
      function reportErrs(errors) {
        var _a;
        gen.if(
          (0, codegen_1.not)(
            (_a = def.valid) !== null && _a !== void 0
              ? _a
              : valid,
          ),
          errors,
        );
      }
    }
    exports.funcKeywordCode = funcKeywordCode;
    function modifyData(cxt) {
      const { gen, data, it } = cxt;
      gen.if(it.parentData, () =>
        gen.assign(
          data,
          (0,
          codegen_1._)`${it.parentData}[${it.parentDataProperty}]`,
        ),
      );
    }
    function addErrs(cxt, errs) {
      const { gen } = cxt;
      gen.if(
        (0, codegen_1._)`Array.isArray(${errs})`,
        () => {
          gen
            .assign(
              names_1.default.vErrors,
              (0,
              codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`,
            )
            .assign(
              names_1.default.errors,
              (0,
              codegen_1._)`${names_1.default.vErrors}.length`,
            );
          (0, errors_1.extendErrors)(cxt);
        },
        () => cxt.error(),
      );
    }
    function checkAsyncKeyword({ schemaEnv }, def) {
      if (def.async && !schemaEnv.$async)
        throw new Error("async keyword in sync schema");
    }
    function useKeyword(gen, keyword, result) {
      if (result === void 0)
        throw new Error(
          `keyword "${keyword}" failed to compile`,
        );
      return gen.scopeValue(
        "keyword",
        typeof result == "function"
          ? { ref: result }
          : {
              ref: result,
              code: (0, codegen_1.stringify)(result),
            },
      );
    }
    function validSchemaType(
      schema,
      schemaType,
      allowUndefined = false,
    ) {
      return (
        !schemaType.length ||
        schemaType.some((st) =>
          st === "array"
            ? Array.isArray(schema)
            : st === "object"
              ? schema &&
                typeof schema == "object" &&
                !Array.isArray(schema)
              : typeof schema == st ||
                (allowUndefined &&
                  typeof schema == "undefined"),
        )
      );
    }
    exports.validSchemaType = validSchemaType;
    function validateKeywordUsage(
      { schema, opts, self, errSchemaPath },
      def,
      keyword,
    ) {
      /* istanbul ignore if */
      if (
        Array.isArray(def.keyword)
          ? !def.keyword.includes(keyword)
          : def.keyword !== keyword
      )
        throw new Error("ajv implementation error");
      const deps = def.dependencies;
      if (
        deps === null || deps === void 0
          ? void 0
          : deps.some(
              (kwd) =>
                !Object.prototype.hasOwnProperty.call(
                  schema,
                  kwd,
                ),
            )
      )
        throw new Error(
          `parent schema must have dependencies of ${keyword}: ${deps.join(",")}`,
        );
      if (def.validateSchema) {
        if (!def.validateSchema(schema[keyword])) {
          const msg =
            `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` +
            self.errorsText(def.validateSchema.errors);
          if (opts.validateSchema === "log")
            self.logger.error(msg);
          else throw new Error(msg);
        }
      }
    }
    exports.validateKeywordUsage = validateKeywordUsage;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/subschema.js
var require_subschema = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.extendSubschemaMode =
      exports.extendSubschemaData =
      exports.getSubschema =
        void 0;
    const codegen_1 = require_codegen();
    const util_1 = require_util();
    function getSubschema(
      it,
      {
        keyword,
        schemaProp,
        schema,
        schemaPath,
        errSchemaPath,
        topSchemaRef,
      },
    ) {
      if (keyword !== void 0 && schema !== void 0)
        throw new Error(
          'both "keyword" and "schema" passed, only one allowed',
        );
      if (keyword !== void 0) {
        const sch = it.schema[keyword];
        return schemaProp === void 0
          ? {
              schema: sch,
              schemaPath: (0,
              codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}`,
              errSchemaPath: `${it.errSchemaPath}/${keyword}`,
            }
          : {
              schema: sch[schemaProp],
              schemaPath: (0,
              codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}${(0, codegen_1.getProperty)(schemaProp)}`,
              errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}`,
            };
      }
      if (schema !== void 0) {
        if (
          schemaPath === void 0 ||
          errSchemaPath === void 0 ||
          topSchemaRef === void 0
        )
          throw new Error(
            '"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"',
          );
        return {
          schema,
          schemaPath,
          topSchemaRef,
          errSchemaPath,
        };
      }
      throw new Error(
        'either "keyword" or "schema" must be passed',
      );
    }
    exports.getSubschema = getSubschema;
    function extendSubschemaData(
      subschema,
      it,
      {
        dataProp,
        dataPropType: dpType,
        data,
        dataTypes,
        propertyName,
      },
    ) {
      if (data !== void 0 && dataProp !== void 0)
        throw new Error(
          'both "data" and "dataProp" passed, only one allowed',
        );
      const { gen } = it;
      if (dataProp !== void 0) {
        const { errorPath, dataPathArr, opts } = it;
        dataContextProps(
          gen.let(
            "data",
            (0,
            codegen_1._)`${it.data}${(0, codegen_1.getProperty)(dataProp)}`,
            true,
          ),
        );
        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) {
        dataContextProps(
          data instanceof codegen_1.Name
            ? data
            : gen.let("data", data, true),
        );
        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;
  },
);
//#endregion
//#region ../node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js
var require_fast_deep_equal = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    module.exports = function equal(a, b) {
      if (a === b) return true;
      if (
        a &&
        b &&
        typeof a == "object" &&
        typeof b == "object"
      ) {
        if (a.constructor !== b.constructor) return false;
        var length, i, keys;
        if (Array.isArray(a)) {
          length = a.length;
          if (length != b.length) return false;
          for (i = length; i-- !== 0;)
            if (!equal(a[i], b[i])) return false;
          return true;
        }
        if (a.constructor === RegExp)
          return (
            a.source === b.source && a.flags === b.flags
          );
        if (a.valueOf !== Object.prototype.valueOf)
          return a.valueOf() === b.valueOf();
        if (a.toString !== Object.prototype.toString)
          return a.toString() === b.toString();
        keys = Object.keys(a);
        length = keys.length;
        if (length !== Object.keys(b).length) return false;
        for (i = length; i-- !== 0;)
          if (
            !Object.prototype.hasOwnProperty.call(
              b,
              keys[i],
            )
          )
            return false;
        for (i = length; i-- !== 0;) {
          var key = keys[i];
          if (!equal(a[key], b[key])) return false;
        }
        return true;
      }
      return a !== a && b !== b;
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/json-schema-traverse@1.0.0/node_modules/json-schema-traverse/index.js
var require_json_schema_traverse =
  /* @__PURE__ */ __commonJSMin((exports, module) => {
    var traverse = (module.exports = function (
      schema,
      opts,
      cb,
    ) {
      if (typeof opts == "function") {
        cb = opts;
        opts = {};
      }
      cb = opts.cb || cb;
      var pre =
        typeof cb == "function"
          ? cb
          : cb.pre || function () {};
      var post = cb.post || function () {};
      _traverse(opts, pre, post, schema, "", schema);
    });
    traverse.keywords = {
      additionalItems: true,
      items: true,
      contains: true,
      additionalProperties: true,
      propertyNames: true,
      not: true,
      if: true,
      then: true,
      else: true,
    };
    traverse.arrayKeywords = {
      items: true,
      allOf: true,
      anyOf: true,
      oneOf: true,
    };
    traverse.propsKeywords = {
      $defs: true,
      definitions: true,
      properties: true,
      patternProperties: true,
      dependencies: true,
    };
    traverse.skipKeywords = {
      default: true,
      enum: true,
      const: true,
      required: true,
      maximum: true,
      minimum: true,
      exclusiveMaximum: true,
      exclusiveMinimum: true,
      multipleOf: true,
      maxLength: true,
      minLength: true,
      pattern: true,
      format: true,
      maxItems: true,
      minItems: true,
      uniqueItems: true,
      maxProperties: true,
      minProperties: true,
    };
    function _traverse(
      opts,
      pre,
      post,
      schema,
      jsonPtr,
      rootSchema,
      parentJsonPtr,
      parentKeyword,
      parentSchema,
      keyIndex,
    ) {
      if (
        schema &&
        typeof schema == "object" &&
        !Array.isArray(schema)
      ) {
        pre(
          schema,
          jsonPtr,
          rootSchema,
          parentJsonPtr,
          parentKeyword,
          parentSchema,
          keyIndex,
        );
        for (var key in schema) {
          var sch = schema[key];
          if (Array.isArray(sch)) {
            if (key in traverse.arrayKeywords)
              for (var i = 0; i < sch.length; i++)
                _traverse(
                  opts,
                  pre,
                  post,
                  sch[i],
                  jsonPtr + "/" + key + "/" + i,
                  rootSchema,
                  jsonPtr,
                  key,
                  schema,
                  i,
                );
          } else if (key in traverse.propsKeywords) {
            if (sch && typeof sch == "object")
              for (var prop in sch)
                _traverse(
                  opts,
                  pre,
                  post,
                  sch[prop],
                  jsonPtr +
                    "/" +
                    key +
                    "/" +
                    escapeJsonPtr(prop),
                  rootSchema,
                  jsonPtr,
                  key,
                  schema,
                  prop,
                );
          } else if (
            key in traverse.keywords ||
            (opts.allKeys &&
              !(key in traverse.skipKeywords))
          )
            _traverse(
              opts,
              pre,
              post,
              sch,
              jsonPtr + "/" + key,
              rootSchema,
              jsonPtr,
              key,
              schema,
            );
        }
        post(
          schema,
          jsonPtr,
          rootSchema,
          parentJsonPtr,
          parentKeyword,
          parentSchema,
          keyIndex,
        );
      }
    }
    function escapeJsonPtr(str) {
      return str.replace(/~/g, "~0").replace(/\//g, "~1");
    }
  });
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/resolve.js
var require_resolve = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.getSchemaRefs =
      exports.resolveUrl =
      exports.normalizeId =
      exports._getFullPath =
      exports.getFullPath =
      exports.inlineRef =
        void 0;
    const util_1 = require_util();
    const equal = require_fast_deep_equal();
    const traverse = require_json_schema_traverse();
    const SIMPLE_INLINED = /* @__PURE__ */ new Set([
      "type",
      "format",
      "pattern",
      "maxLength",
      "minLength",
      "maxProperties",
      "minProperties",
      "maxItems",
      "minItems",
      "maximum",
      "minimum",
      "uniqueItems",
      "multipleOf",
      "required",
      "enum",
      "const",
    ]);
    function inlineRef(schema, limit = true) {
      if (typeof schema == "boolean") return true;
      if (limit === true) return !hasRef(schema);
      if (!limit) return false;
      return countKeys(schema) <= limit;
    }
    exports.inlineRef = inlineRef;
    const REF_KEYWORDS = /* @__PURE__ */ new Set([
      "$ref",
      "$recursiveRef",
      "$recursiveAnchor",
      "$dynamicRef",
      "$dynamicAnchor",
    ]);
    function hasRef(schema) {
      for (const key in schema) {
        if (REF_KEYWORDS.has(key)) return true;
        const sch = schema[key];
        if (Array.isArray(sch) && sch.some(hasRef))
          return true;
        if (typeof sch == "object" && hasRef(sch))
          return true;
      }
      return false;
    }
    function countKeys(schema) {
      let count = 0;
      for (const key in schema) {
        if (key === "$ref") return Infinity;
        count++;
        if (SIMPLE_INLINED.has(key)) continue;
        if (typeof schema[key] == "object")
          (0, util_1.eachItem)(
            schema[key],
            (sch) => (count += countKeys(sch)),
          );
        if (count === Infinity) return Infinity;
      }
      return count;
    }
    function getFullPath(resolver, id = "", normalize) {
      if (normalize !== false) id = normalizeId(id);
      return _getFullPath(resolver, resolver.parse(id));
    }
    exports.getFullPath = getFullPath;
    function _getFullPath(resolver, p) {
      return resolver.serialize(p).split("#")[0] + "#";
    }
    exports._getFullPath = _getFullPath;
    const 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;
    const ANCHOR = /^[a-z_][-a-z0-9._]*$/i;
    function getSchemaRefs(schema, baseId) {
      if (typeof schema == "boolean") return {};
      const { schemaId, uriResolver } = this.opts;
      const schId = normalizeId(schema[schemaId] || baseId);
      const baseIds = { "": schId };
      const pathPrefix = getFullPath(
        uriResolver,
        schId,
        false,
      );
      const localRefs = {};
      const schemaRefs = /* @__PURE__ */ new Set();
      traverse(
        schema,
        { allKeys: true },
        (sch, jsonPtr, _, parentJsonPtr) => {
          if (parentJsonPtr === void 0) return;
          const fullPath = pathPrefix + jsonPtr;
          let innerBaseId = baseIds[parentJsonPtr];
          if (typeof sch[schemaId] == "string")
            innerBaseId = addRef.call(this, sch[schemaId]);
          addAnchor.call(this, sch.$anchor);
          addAnchor.call(this, sch.$dynamicAnchor);
          baseIds[jsonPtr] = innerBaseId;
          function addRef(ref) {
            const _resolve = this.opts.uriResolver.resolve;
            ref = normalizeId(
              innerBaseId
                ? _resolve(innerBaseId, ref)
                : ref,
            );
            if (schemaRefs.has(ref)) throw ambiguos(ref);
            schemaRefs.add(ref);
            let schOrRef = this.refs[ref];
            if (typeof schOrRef == "string")
              schOrRef = this.refs[schOrRef];
            if (typeof schOrRef == "object")
              checkAmbiguosRef(sch, schOrRef.schema, ref);
            else if (ref !== normalizeId(fullPath)) {
              if (ref[0] === "#") {
                checkAmbiguosRef(sch, localRefs[ref], ref);
                localRefs[ref] = sch;
              } else this.refs[ref] = fullPath;
            }
            return ref;
          }
          function addAnchor(anchor) {
            if (typeof anchor == "string") {
              if (!ANCHOR.test(anchor))
                throw new Error(
                  `invalid anchor "${anchor}"`,
                );
              addRef.call(this, `#${anchor}`);
            }
          }
        },
      );
      return localRefs;
      function checkAmbiguosRef(sch1, sch2, ref) {
        if (sch2 !== void 0 && !equal(sch1, sch2))
          throw ambiguos(ref);
      }
      function ambiguos(ref) {
        return /* @__PURE__ */ new Error(
          `reference "${ref}" resolves to more than one schema`,
        );
      }
    }
    exports.getSchemaRefs = getSchemaRefs;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/index.js
var require_validate = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.getData =
      exports.KeywordCxt =
      exports.validateFunctionCode =
        void 0;
    const boolSchema_1 = require_boolSchema();
    const dataType_1 = require_dataType();
    const applicability_1 = require_applicability();
    const dataType_2 = require_dataType();
    const defaults_1 = require_defaults();
    const keyword_1 = require_keyword();
    const subschema_1 = require_subschema();
    const codegen_1 = require_codegen();
    const names_1 = require_names();
    const resolve_1 = require_resolve();
    const util_1 = require_util();
    const errors_1 = require_errors();
    function validateFunctionCode(it) {
      if (isSchemaObj(it)) {
        checkKeywords(it);
        if (schemaCxtHasRules(it)) {
          topSchemaObjCode(it);
          return;
        }
      }
      validateFunction(it, () =>
        (0, boolSchema_1.topBoolOrEmptySchema)(it),
      );
    }
    exports.validateFunctionCode = validateFunctionCode;
    function validateFunction(
      { gen, validateName, schema, schemaEnv, opts },
      body,
    ) {
      if (opts.code.es5)
        gen.func(
          validateName,
          (0,
          codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`,
          schemaEnv.$async,
          () => {
            gen.code(
              (0,
              codegen_1._)`"use strict"; ${funcSourceUrl(schema, opts)}`,
            );
            destructureValCxtES5(gen, opts);
            gen.code(body);
          },
        );
      else
        gen.func(
          validateName,
          (0,
          codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`,
          schemaEnv.$async,
          () =>
            gen
              .code(funcSourceUrl(schema, opts))
              .code(body),
        );
    }
    function destructureValCxt(opts) {
      return (0,
      codegen_1._)`{${names_1.default.instancePath}="", ${names_1.default.parentData}, ${names_1.default.parentDataProperty}, ${names_1.default.rootData}=${names_1.default.data}${opts.dynamicRef ? (0, codegen_1._)`, ${names_1.default.dynamicAnchors}={}` : codegen_1.nil}}={}`;
    }
    function destructureValCxtES5(gen, opts) {
      gen.if(
        names_1.default.valCxt,
        () => {
          gen.var(
            names_1.default.instancePath,
            (0,
            codegen_1._)`${names_1.default.valCxt}.${names_1.default.instancePath}`,
          );
          gen.var(
            names_1.default.parentData,
            (0,
            codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentData}`,
          );
          gen.var(
            names_1.default.parentDataProperty,
            (0,
            codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentDataProperty}`,
          );
          gen.var(
            names_1.default.rootData,
            (0,
            codegen_1._)`${names_1.default.valCxt}.${names_1.default.rootData}`,
          );
          if (opts.dynamicRef)
            gen.var(
              names_1.default.dynamicAnchors,
              (0,
              codegen_1._)`${names_1.default.valCxt}.${names_1.default.dynamicAnchors}`,
            );
        },
        () => {
          gen.var(
            names_1.default.instancePath,
            (0, codegen_1._)`""`,
          );
          gen.var(
            names_1.default.parentData,
            (0, codegen_1._)`undefined`,
          );
          gen.var(
            names_1.default.parentDataProperty,
            (0, codegen_1._)`undefined`,
          );
          gen.var(
            names_1.default.rootData,
            names_1.default.data,
          );
          if (opts.dynamicRef)
            gen.var(
              names_1.default.dynamicAnchors,
              (0, codegen_1._)`{}`,
            );
        },
      );
    }
    function topSchemaObjCode(it) {
      const { schema, opts, gen } = it;
      validateFunction(it, () => {
        if (opts.$comment && schema.$comment)
          commentKeyword(it);
        checkNoDefault(it);
        gen.let(names_1.default.vErrors, null);
        gen.let(names_1.default.errors, 0);
        if (opts.unevaluated) resetEvaluated(it);
        typeAndKeywords(it);
        returnResults(it);
      });
    }
    function resetEvaluated(it) {
      const { gen, validateName } = it;
      it.evaluated = gen.const(
        "evaluated",
        (0, codegen_1._)`${validateName}.evaluated`,
      );
      gen.if(
        (0, codegen_1._)`${it.evaluated}.dynamicProps`,
        () =>
          gen.assign(
            (0, codegen_1._)`${it.evaluated}.props`,
            (0, codegen_1._)`undefined`,
          ),
      );
      gen.if(
        (0, codegen_1._)`${it.evaluated}.dynamicItems`,
        () =>
          gen.assign(
            (0, codegen_1._)`${it.evaluated}.items`,
            (0, codegen_1._)`undefined`,
          ),
      );
    }
    function funcSourceUrl(schema, opts) {
      const schId =
        typeof schema == "object" && schema[opts.schemaId];
      return schId &&
        (opts.code.source || opts.code.process)
        ? (0, codegen_1._)`/*# sourceURL=${schId} */`
        : codegen_1.nil;
    }
    function subschemaCode(it, valid) {
      if (isSchemaObj(it)) {
        checkKeywords(it);
        if (schemaCxtHasRules(it)) {
          subSchemaObjCode(it, valid);
          return;
        }
      }
      (0, boolSchema_1.boolOrEmptySchema)(it, valid);
    }
    function schemaCxtHasRules({ schema, self }) {
      if (typeof schema == "boolean") return !schema;
      for (const key in schema)
        if (self.RULES.all[key]) return true;
      return false;
    }
    function isSchemaObj(it) {
      return typeof it.schema != "boolean";
    }
    function subSchemaObjCode(it, valid) {
      const { schema, gen, opts } = it;
      if (opts.$comment && schema.$comment)
        commentKeyword(it);
      updateContext(it);
      checkAsyncSchema(it);
      const errsCount = gen.const(
        "_errs",
        names_1.default.errors,
      );
      typeAndKeywords(it, errsCount);
      gen.var(
        valid,
        (0,
        codegen_1._)`${errsCount} === ${names_1.default.errors}`,
      );
    }
    function checkKeywords(it) {
      (0, util_1.checkUnknownRules)(it);
      checkRefsAndKeywords(it);
    }
    function typeAndKeywords(it, errsCount) {
      if (it.opts.jtd)
        return schemaKeywords(it, [], false, errsCount);
      const types = (0, dataType_1.getSchemaTypes)(
        it.schema,
      );
      schemaKeywords(
        it,
        types,
        !(0, dataType_1.coerceAndCheckDataType)(it, types),
        errsCount,
      );
    }
    function checkRefsAndKeywords(it) {
      const { schema, errSchemaPath, opts, self } = it;
      if (
        schema.$ref &&
        opts.ignoreKeywordsWithRef &&
        (0, util_1.schemaHasRulesButRef)(schema, self.RULES)
      )
        self.logger.warn(
          `$ref: keywords ignored in schema at path "${errSchemaPath}"`,
        );
    }
    function checkNoDefault(it) {
      const { schema, opts } = it;
      if (
        schema.default !== void 0 &&
        opts.useDefaults &&
        opts.strictSchema
      )
        (0, util_1.checkStrictMode)(
          it,
          "default is ignored in the schema root",
        );
    }
    function updateContext(it) {
      const schId = it.schema[it.opts.schemaId];
      if (schId)
        it.baseId = (0, resolve_1.resolveUrl)(
          it.opts.uriResolver,
          it.baseId,
          schId,
        );
    }
    function checkAsyncSchema(it) {
      if (it.schema.$async && !it.schemaEnv.$async)
        throw new Error("async schema in sync schema");
    }
    function commentKeyword({
      gen,
      schemaEnv,
      schema,
      errSchemaPath,
      opts,
    }) {
      const msg = schema.$comment;
      if (opts.$comment === true)
        gen.code(
          (0,
          codegen_1._)`${names_1.default.self}.logger.log(${msg})`,
        );
      else if (typeof opts.$comment == "function") {
        const schemaPath = (0,
        codegen_1.str)`${errSchemaPath}/$comment`;
        const rootName = gen.scopeValue("root", {
          ref: schemaEnv.root,
        });
        gen.code(
          (0,
          codegen_1._)`${names_1.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`,
        );
      }
    }
    function returnResults(it) {
      const {
        gen,
        schemaEnv,
        validateName,
        ValidationError,
        opts,
      } = it;
      if (schemaEnv.$async)
        gen.if(
          (0, codegen_1._)`${names_1.default.errors} === 0`,
          () => gen.return(names_1.default.data),
          () =>
            gen.throw(
              (0,
              codegen_1._)`new ${ValidationError}(${names_1.default.vErrors})`,
            ),
        );
      else {
        gen.assign(
          (0, codegen_1._)`${validateName}.errors`,
          names_1.default.vErrors,
        );
        if (opts.unevaluated) assignEvaluated(it);
        gen.return(
          (0, codegen_1._)`${names_1.default.errors} === 0`,
        );
      }
    }
    function assignEvaluated({
      gen,
      evaluated,
      props,
      items,
    }) {
      if (props instanceof codegen_1.Name)
        gen.assign(
          (0, codegen_1._)`${evaluated}.props`,
          props,
        );
      if (items instanceof codegen_1.Name)
        gen.assign(
          (0, codegen_1._)`${evaluated}.items`,
          items,
        );
    }
    function schemaKeywords(
      it,
      types,
      typeErrors,
      errsCount,
    ) {
      const { gen, schema, data, allErrors, opts, self } =
        it;
      const { RULES } = self;
      if (
        schema.$ref &&
        (opts.ignoreKeywordsWithRef ||
          !(0, util_1.schemaHasRulesButRef)(schema, RULES))
      ) {
        gen.block(() =>
          keywordCode(
            it,
            "$ref",
            RULES.all.$ref.definition,
          ),
        );
        return;
      }
      if (!opts.jtd) checkStrictTypes(it, types);
      gen.block(() => {
        for (const group of RULES.rules)
          groupKeywords(group);
        groupKeywords(RULES.post);
      });
      function groupKeywords(group) {
        if (
          !(0, applicability_1.shouldUseGroup)(
            schema,
            group,
          )
        )
          return;
        if (group.type) {
          gen.if(
            (0, dataType_2.checkDataType)(
              group.type,
              data,
              opts.strictNumbers,
            ),
          );
          iterateKeywords(it, group);
          if (
            types.length === 1 &&
            types[0] === group.type &&
            typeErrors
          ) {
            gen.else();
            (0, dataType_2.reportTypeError)(it);
          }
          gen.endIf();
        } else iterateKeywords(it, group);
        if (!allErrors)
          gen.if(
            (0,
            codegen_1._)`${names_1.default.errors} === ${errsCount || 0}`,
          );
      }
    }
    function iterateKeywords(it, group) {
      const {
        gen,
        schema,
        opts: { useDefaults },
      } = it;
      if (useDefaults)
        (0, defaults_1.assignDefaults)(it, group.type);
      gen.block(() => {
        for (const rule of group.rules)
          if (
            (0, applicability_1.shouldUseRule)(schema, rule)
          )
            keywordCode(
              it,
              rule.keyword,
              rule.definition,
              group.type,
            );
      });
    }
    function checkStrictTypes(it, types) {
      if (it.schemaEnv.meta || !it.opts.strictTypes) return;
      checkContextTypes(it, types);
      if (!it.opts.allowUnionTypes)
        checkMultipleTypes(it, types);
      checkKeywordTypes(it, it.dataTypes);
    }
    function checkContextTypes(it, types) {
      if (!types.length) return;
      if (!it.dataTypes.length) {
        it.dataTypes = types;
        return;
      }
      types.forEach((t) => {
        if (!includesType(it.dataTypes, t))
          strictTypesError(
            it,
            `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`,
          );
      });
      narrowSchemaTypes(it, types);
    }
    function checkMultipleTypes(it, ts) {
      if (
        ts.length > 1 &&
        !(ts.length === 2 && ts.includes("null"))
      )
        strictTypesError(
          it,
          "use allowUnionTypes to allow union type keyword",
        );
    }
    function checkKeywordTypes(it, ts) {
      const rules = it.self.RULES.all;
      for (const keyword in rules) {
        const rule = rules[keyword];
        if (
          typeof rule == "object" &&
          (0, applicability_1.shouldUseRule)(
            it.schema,
            rule,
          )
        ) {
          const { type } = rule.definition;
          if (
            type.length &&
            !type.some((t) => hasApplicableType(ts, t))
          )
            strictTypesError(
              it,
              `missing type "${type.join(",")}" for keyword "${keyword}"`,
            );
        }
      }
    }
    function hasApplicableType(schTs, kwdT) {
      return (
        schTs.includes(kwdT) ||
        (kwdT === "number" && schTs.includes("integer"))
      );
    }
    function includesType(ts, t) {
      return (
        ts.includes(t) ||
        (t === "integer" && ts.includes("number"))
      );
    }
    function narrowSchemaTypes(it, withTypes) {
      const ts = [];
      for (const t of it.dataTypes)
        if (includesType(withTypes, t)) ts.push(t);
        else if (
          withTypes.includes("integer") &&
          t === "number"
        )
          ts.push("integer");
      it.dataTypes = ts;
    }
    function strictTypesError(it, msg) {
      const schemaPath =
        it.schemaEnv.baseId + it.errSchemaPath;
      msg += ` at "${schemaPath}" (strictTypes)`;
      (0, util_1.checkStrictMode)(
        it,
        msg,
        it.opts.strictTypes,
      );
    }
    var KeywordCxt = class {
      constructor(it, def, keyword) {
        (0, keyword_1.validateKeywordUsage)(
          it,
          def,
          keyword,
        );
        this.gen = it.gen;
        this.allErrors = it.allErrors;
        this.keyword = keyword;
        this.data = it.data;
        this.schema = it.schema[keyword];
        this.$data =
          def.$data &&
          it.opts.$data &&
          this.schema &&
          this.schema.$data;
        this.schemaValue = (0, util_1.schemaRefOrVal)(
          it,
          this.schema,
          keyword,
          this.$data,
        );
        this.schemaType = def.schemaType;
        this.parentSchema = it.schema;
        this.params = {};
        this.it = it;
        this.def = def;
        if (this.$data)
          this.schemaCode = it.gen.const(
            "vSchema",
            getData(this.$data, it),
          );
        else {
          this.schemaCode = this.schemaValue;
          if (
            !(0, keyword_1.validSchemaType)(
              this.schema,
              def.schemaType,
              def.allowUndefined,
            )
          )
            throw new Error(
              `${keyword} value must be ${JSON.stringify(def.schemaType)}`,
            );
        }
        if (
          "code" in def
            ? def.trackErrors
            : def.errors !== false
        )
          this.errsCount = it.gen.const(
            "_errs",
            names_1.default.errors,
          );
      }
      result(condition, successAction, failAction) {
        this.failResult(
          (0, codegen_1.not)(condition),
          successAction,
          failAction,
        );
      }
      failResult(condition, successAction, failAction) {
        this.gen.if(condition);
        if (failAction) failAction();
        else this.error();
        if (successAction) {
          this.gen.else();
          successAction();
          if (this.allErrors) this.gen.endIf();
        } else if (this.allErrors) this.gen.endIf();
        else this.gen.else();
      }
      pass(condition, failAction) {
        this.failResult(
          (0, codegen_1.not)(condition),
          void 0,
          failAction,
        );
      }
      fail(condition) {
        if (condition === void 0) {
          this.error();
          if (!this.allErrors) this.gen.if(false);
          return;
        }
        this.gen.if(condition);
        this.error();
        if (this.allErrors) this.gen.endIf();
        else this.gen.else();
      }
      fail$data(condition) {
        if (!this.$data) return this.fail(condition);
        const { schemaCode } = this;
        this.fail(
          (0,
          codegen_1._)`${schemaCode} !== undefined && (${(0, codegen_1.or)(this.invalid$data(), condition)})`,
        );
      }
      error(append, errorParams, errorPaths) {
        if (errorParams) {
          this.setParams(errorParams);
          this._error(append, errorPaths);
          this.setParams({});
          return;
        }
        this._error(append, errorPaths);
      }
      _error(append, errorPaths) {
        (append
          ? errors_1.reportExtraError
          : errors_1.reportError)(
          this,
          this.def.error,
          errorPaths,
        );
      }
      $dataError() {
        (0, errors_1.reportError)(
          this,
          this.def.$dataError || errors_1.keyword$DataError,
        );
      }
      reset() {
        if (this.errsCount === void 0)
          throw new Error(
            'add "trackErrors" to keyword definition',
          );
        (0, errors_1.resetErrorsCount)(
          this.gen,
          this.errsCount,
        );
      }
      ok(cond) {
        if (!this.allErrors) this.gen.if(cond);
      }
      setParams(obj, assign) {
        if (assign) Object.assign(this.params, obj);
        else this.params = obj;
      }
      block$data(
        valid,
        codeBlock,
        $dataValid = codegen_1.nil,
      ) {
        this.gen.block(() => {
          this.check$data(valid, $dataValid);
          codeBlock();
        });
      }
      check$data(
        valid = codegen_1.nil,
        $dataValid = codegen_1.nil,
      ) {
        if (!this.$data) return;
        const { gen, schemaCode, schemaType, def } = this;
        gen.if(
          (0, codegen_1.or)(
            (0, codegen_1._)`${schemaCode} === undefined`,
            $dataValid,
          ),
        );
        if (valid !== codegen_1.nil)
          gen.assign(valid, true);
        if (schemaType.length || def.validateSchema) {
          gen.elseIf(this.invalid$data());
          this.$dataError();
          if (valid !== codegen_1.nil)
            gen.assign(valid, false);
        }
        gen.else();
      }
      invalid$data() {
        const { gen, schemaCode, schemaType, def, it } =
          this;
        return (0, codegen_1.or)(
          wrong$DataType(),
          invalid$DataSchema(),
        );
        function wrong$DataType() {
          if (schemaType.length) {
            /* istanbul ignore if */
            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);
    }
    const JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/;
    const 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;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/validation_error.js
var require_validation_error =
  /* @__PURE__ */ __commonJSMin((exports) => {
    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;
  });
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/ref_error.js
var require_ref_error = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const resolve_1 = require_resolve();
    var MissingRefError = class extends Error {
      constructor(resolver, baseId, ref, msg) {
        super(
          msg ||
            `can't resolve reference ${ref} from id ${baseId}`,
        );
        this.missingRef = (0, resolve_1.resolveUrl)(
          resolver,
          baseId,
          ref,
        );
        this.missingSchema = (0, resolve_1.normalizeId)(
          (0, resolve_1.getFullPath)(
            resolver,
            this.missingRef,
          ),
        );
      }
    };
    exports.default = MissingRefError;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/index.js
var require_compile = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.resolveSchema =
      exports.getCompilingSchema =
      exports.resolveRef =
      exports.compileSchema =
      exports.SchemaEnv =
        void 0;
    const codegen_1 = require_codegen();
    const validation_error_1 = require_validation_error();
    const names_1 = require_names();
    const resolve_1 = require_resolve();
    const util_1 = require_util();
    const validate_1 = require_validate();
    var SchemaEnv = class {
      constructor(env) {
        var _a;
        this.refs = {};
        this.dynamicAnchors = {};
        let schema;
        if (typeof env.schema == "object")
          schema = env.schema;
        this.schema = env.schema;
        this.schemaId = env.schemaId;
        this.root = env.root || this;
        this.baseId =
          (_a = env.baseId) !== null && _a !== void 0
            ? _a
            : (0, resolve_1.normalizeId)(
                schema === null || schema === void 0
                  ? void 0
                  : schema[env.schemaId || "$id"],
              );
        this.schemaPath = env.schemaPath;
        this.localRefs = env.localRefs;
        this.meta = env.meta;
        this.$async =
          schema === null || schema === void 0
            ? void 0
            : schema.$async;
        this.refs = {};
      }
    };
    exports.SchemaEnv = SchemaEnv;
    function compileSchema(sch) {
      const _sch = getCompilingSchema.call(this, sch);
      if (_sch) return _sch;
      const rootId = (0, resolve_1.getFullPath)(
        this.opts.uriResolver,
        sch.root.baseId,
      );
      const { es5, lines } = this.opts.code;
      const { ownProperties } = this.opts;
      const gen = new codegen_1.CodeGen(this.scope, {
        es5,
        lines,
        ownProperties,
      });
      let _ValidationError;
      if (sch.$async)
        _ValidationError = gen.scopeValue("Error", {
          ref: validation_error_1.default,
          code: (0,
          codegen_1._)`require("ajv/dist/runtime/validation_error").default`,
        });
      const validateName = gen.scopeName("validate");
      sch.validateName = validateName;
      const schemaCxt = {
        gen,
        allErrors: this.opts.allErrors,
        data: names_1.default.data,
        parentData: names_1.default.parentData,
        parentDataProperty:
          names_1.default.parentDataProperty,
        dataNames: [names_1.default.data],
        dataPathArr: [codegen_1.nil],
        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 validate = new Function(
          `${names_1.default.self}`,
          `${names_1.default.scope}`,
          sourceCode,
        )(this, this.scope.get());
        this.scope.value(validateName, { ref: validate });
        validate.errors = null;
        validate.schema = sch.schema;
        validate.schemaEnv = sch;
        if (sch.$async) validate.$async = true;
        if (this.opts.code.source === true)
          validate.source = {
            validateName,
            validateCode,
            scopeValues: gen._values,
          };
        if (this.opts.unevaluated) {
          const { props, items } = schemaCxt;
          validate.evaluated = {
            props:
              props instanceof codegen_1.Name
                ? void 0
                : props,
            items:
              items instanceof codegen_1.Name
                ? void 0
                : items,
            dynamicProps: props instanceof codegen_1.Name,
            dynamicItems: items instanceof codegen_1.Name,
          };
          if (validate.source)
            validate.source.evaluated = (0,
            codegen_1.stringify)(validate.evaluated);
        }
        sch.validate = validate;
        return sch;
      } catch (e) {
        delete sch.validate;
        delete sch.validateName;
        if (sourceCode)
          this.logger.error(
            "Error compiling schema, function code:",
            sourceCode,
          );
        throw e;
      } finally {
        this._compilations.delete(sch);
      }
    }
    exports.compileSchema = compileSchema;
    function resolveRef(root, baseId, ref) {
      var _a;
      ref = (0, resolve_1.resolveUrl)(
        this.opts.uriResolver,
        baseId,
        ref,
      );
      const schOrFunc = root.refs[ref];
      if (schOrFunc) return schOrFunc;
      let _sch = resolve.call(this, root, ref);
      if (_sch === void 0) {
        const schema =
          (_a = root.localRefs) === null || _a === void 0
            ? void 0
            : _a[ref];
        const { schemaId } = this.opts;
        if (schema)
          _sch = new SchemaEnv({
            schema,
            schemaId,
            root,
            baseId,
          });
      }
      if (_sch === void 0) return;
      return (root.refs[ref] = inlineOrCompile.call(
        this,
        _sch,
      ));
    }
    exports.resolveRef = resolveRef;
    function inlineOrCompile(sch) {
      if (
        (0, resolve_1.inlineRef)(
          sch.schema,
          this.opts.inlineRefs,
        )
      )
        return sch.schema;
      return sch.validate
        ? sch
        : compileSchema.call(this, sch);
    }
    function getCompilingSchema(schEnv) {
      for (const sch of this._compilations)
        if (sameSchemaEnv(sch, schEnv)) return sch;
    }
    exports.getCompilingSchema = getCompilingSchema;
    function sameSchemaEnv(s1, s2) {
      return (
        s1.schema === s2.schema &&
        s1.root === s2.root &&
        s1.baseId === s2.baseId
      );
    }
    function resolve(root, ref) {
      let sch;
      while (typeof (sch = this.refs[ref]) == "string")
        ref = sch;
      return (
        sch ||
        this.schemas[ref] ||
        resolveSchema.call(this, root, ref)
      );
    }
    function resolveSchema(root, ref) {
      const p = this.opts.uriResolver.parse(ref);
      const refPath = (0, resolve_1._getFullPath)(
        this.opts.uriResolver,
        p,
      );
      let baseId = (0, resolve_1.getFullPath)(
        this.opts.uriResolver,
        root.baseId,
        void 0,
      );
      if (
        Object.keys(root.schema).length > 0 &&
        refPath === baseId
      )
        return getJsonPointer.call(this, p, root);
      const id = (0, resolve_1.normalizeId)(refPath);
      const schOrRef = this.refs[id] || this.schemas[id];
      if (typeof schOrRef == "string") {
        const sch = resolveSchema.call(
          this,
          root,
          schOrRef,
        );
        if (
          typeof (sch === null || sch === void 0
            ? void 0
            : sch.schema) !== "object"
        )
          return;
        return getJsonPointer.call(this, p, sch);
      }
      if (
        typeof (schOrRef === null || schOrRef === void 0
          ? void 0
          : schOrRef.schema) !== "object"
      )
        return;
      if (!schOrRef.validate)
        compileSchema.call(this, schOrRef);
      if (id === (0, resolve_1.normalizeId)(ref)) {
        const { schema } = schOrRef;
        const { schemaId } = this.opts;
        const schId = schema[schemaId];
        if (schId)
          baseId = (0, resolve_1.resolveUrl)(
            this.opts.uriResolver,
            baseId,
            schId,
          );
        return new SchemaEnv({
          schema,
          schemaId,
          root,
          baseId,
        });
      }
      return getJsonPointer.call(this, p, schOrRef);
    }
    exports.resolveSchema = resolveSchema;
    const PREVENT_SCOPE_CHANGE = /* @__PURE__ */ new Set([
      "properties",
      "patternProperties",
      "enum",
      "dependencies",
      "definitions",
    ]);
    function getJsonPointer(
      parsedRef,
      { baseId, schema, root },
    ) {
      var _a;
      if (
        ((_a = parsedRef.fragment) === null || _a === void 0
          ? void 0
          : _a[0]) !== "/"
      )
        return;
      for (const part of parsedRef.fragment
        .slice(1)
        .split("/")) {
        if (typeof schema === "boolean") return;
        const partSchema =
          schema[(0, util_1.unescapeFragment)(part)];
        if (partSchema === void 0) return;
        schema = partSchema;
        const schId =
          typeof schema === "object" &&
          schema[this.opts.schemaId];
        if (!PREVENT_SCOPE_CHANGE.has(part) && schId)
          baseId = (0, resolve_1.resolveUrl)(
            this.opts.uriResolver,
            baseId,
            schId,
          );
      }
      let env;
      if (
        typeof schema != "boolean" &&
        schema.$ref &&
        !(0, util_1.schemaHasRulesButRef)(
          schema,
          this.RULES,
        )
      ) {
        const $ref = (0, resolve_1.resolveUrl)(
          this.opts.uriResolver,
          baseId,
          schema.$ref,
        );
        env = resolveSchema.call(this, root, $ref);
      }
      const { schemaId } = this.opts;
      env =
        env ||
        new SchemaEnv({
          schema,
          schemaId,
          root,
          baseId,
        });
      if (env.schema !== env.root.schema) return env;
    }
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/data.json
var require_data = /* @__PURE__ */ __commonJSMin(
  (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,
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/lib/utils.js
var require_utils = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    /** @type {(value: string) => boolean} */
    const isUUID = RegExp.prototype.test.bind(
      /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu,
    );
    /** @type {(value: string) => boolean} */
    const isIPv4 = RegExp.prototype.test.bind(
      /^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u,
    );
    /** @type {(value: string) => boolean} */
    const isPort = RegExp.prototype.test.bind(/^\d*$/u);
    /** @type {(value: string) => boolean} */
    const isHexPair =
      RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
    /** @type {(value: string) => boolean} */
    const isUnreserved =
      RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
    /** @type {(value: string) => boolean} */
    const isPathCharacter = RegExp.prototype.test.bind(
      /^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u,
    );
    /** @type {(value: string) => boolean} */
    const isQueryFragmentCharacter =
      RegExp.prototype.test.bind(
        /^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u,
      );
    /** @type {(value: string) => boolean} */
    const isUserinfoCharacter = RegExp.prototype.test.bind(
      /^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u,
    );
    const BYTE_HEX = new Array(256);
    {
      const HEX_DIGITS = "0123456789ABCDEF";
      for (let i = 0; i < 256; i++)
        BYTE_HEX[i] =
          "%" + HEX_DIGITS[i >> 4] + HEX_DIGITS[i & 15];
    }
    function percentEncodeNonAscii(cp) {
      if (cp < 2048)
        return (
          BYTE_HEX[192 | (cp >> 6)] +
          BYTE_HEX[128 | (cp & 63)]
        );
      if (cp < 65536)
        return (
          BYTE_HEX[224 | (cp >> 12)] +
          BYTE_HEX[128 | ((cp >> 6) & 63)] +
          BYTE_HEX[128 | (cp & 63)]
        );
      return (
        BYTE_HEX[240 | (cp >> 18)] +
        BYTE_HEX[128 | ((cp >> 12) & 63)] +
        BYTE_HEX[128 | ((cp >> 6) & 63)] +
        BYTE_HEX[128 | (cp & 63)]
      );
    }
    /**
     * @param {Array<string>} input
     * @returns {string}
     */
    function stringArrayToHexStripped(input) {
      let acc = "";
      let code = 0;
      let i = 0;
      for (i = 0; i < input.length; i++) {
        code = input[i].charCodeAt(0);
        if (code === 48) continue;
        if (
          !(
            (code >= 48 && code <= 57) ||
            (code >= 65 && code <= 70) ||
            (code >= 97 && code <= 102)
          )
        )
          return "";
        acc += input[i];
        break;
      }
      for (i += 1; i < input.length; i++) {
        code = input[i].charCodeAt(0);
        if (
          !(
            (code >= 48 && code <= 57) ||
            (code >= 65 && code <= 70) ||
            (code >= 97 && code <= 102)
          )
        )
          return "";
        acc += input[i];
      }
      return acc;
    }
    /** @type {(value: string) => boolean} */
    const isHextet = RegExp.prototype.test.bind(
      /^[\dA-Fa-f]{1,4}$/,
    );
    /** @type {(value: string) => boolean} */
    const isIPvFuture = RegExp.prototype.test.bind(
      /^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/,
    );
    /** @type {(value: string) => boolean} */
    const isZoneCharacter = RegExp.prototype.test.bind(
      /^[A-Za-z\d\-._~]$/,
    );
    /**
     * @param {string} value
     * @returns {boolean}
     */
    const nonSimpleDomain = RegExp.prototype.test.bind(
      /[^!"$&'()*+,\-.;=_`a-z{}~]/u,
    );
    /**
     * @param {string} zone
     * @returns {boolean}
     */
    function isZoneIdentifier(zone) {
      if (zone.length === 0) return false;
      for (let i = 0; i < zone.length; i++) {
        if (isZoneCharacter(zone[i])) continue;
        if (
          zone[i] === "%" &&
          i + 2 < zone.length &&
          isHexPair(zone.slice(i + 1, i + 3))
        ) {
          i += 2;
          continue;
        }
        return false;
      }
      return true;
    }
    /**
     * Compresses the longest run of zero hextets to "::" per RFC 5952. A run of a
     * single zero hextet is left uncompressed. On ties the leftmost run wins.
     *
     * @param {string[]} hextets
     * @returns {string}
     */
    function compressIPv6ZeroRun(hextets) {
      let bestStart = -1;
      let bestLength = 0;
      let runStart = -1;
      let runLength = 0;
      for (let i = 0; i < hextets.length; i++)
        if (hextets[i] === "0") {
          if (runStart === -1) runStart = i;
          runLength++;
          if (runLength > bestLength) {
            bestLength = runLength;
            bestStart = runStart;
          }
        } else {
          runStart = -1;
          runLength = 0;
        }
      if (bestLength < 2) return hextets.join(":");
      const head = hextets.slice(0, bestStart).join(":");
      const tail = hextets
        .slice(bestStart + bestLength)
        .join(":");
      return head + "::" + tail;
    }
    /**
     * Validates an IPv6 address against the alternatives in RFC 3986 section
     * 3.2.2 and returns the same address with leading hextet zeroes removed.
     * An embedded IPv4 address counts as two hextets and is only valid at the end.
     *
     * @param {string} input
     * @returns {string|undefined}
     */
    function normalizeIPv6Address(input) {
      const compression = input.indexOf("::");
      if (
        compression !== -1 &&
        input.indexOf("::", compression + 1) !== -1
      )
        return void 0;
      const left =
        compression === -1
          ? input.split(":")
          : input.slice(0, compression).split(":");
      const right =
        compression === -1
          ? []
          : input.slice(compression + 2).split(":");
      if (compression !== -1) {
        if (left.length === 1 && left[0] === "")
          left.length = 0;
        if (right.length === 1 && right[0] === "")
          right.length = 0;
      }
      const parts = left.concat(right);
      let hextetCount = 0;
      for (let i = 0; i < parts.length; i++) {
        const part = parts[i];
        if (part === "") return void 0;
        if (part.indexOf(".") !== -1) {
          if (
            i !== parts.length - 1 ||
            (compression !== -1 && right.length === 0) ||
            !isIPv4(part)
          )
            return void 0;
          hextetCount += 2;
          continue;
        }
        if (!isHextet(part)) return void 0;
        parts[i] = parseInt(part, 16).toString(16);
        hextetCount++;
      }
      if (compression === -1) {
        if (hextetCount !== 8) return void 0;
        return compressIPv6ZeroRun(parts);
      }
      if (hextetCount >= 8) return void 0;
      const expanded = parts.slice(0, left.length);
      for (let i = hextetCount; i < 8; i++)
        expanded.push("0");
      for (let i = left.length; i < parts.length; i++)
        expanded.push(parts[i]);
      return compressIPv6ZeroRun(expanded);
    }
    /**
     * @typedef {Object} NormalizeIPv6Result
     * @property {string} host - The normalized host.
     * @property {string} [escapedHost] - The escaped host.
     * @property {boolean} isIPV6 - Indicates if the host is an IPv6 address.
     * @property {boolean} [isIPVFuture] - Indicates if the host is an IPvFuture literal.
     * @property {boolean} [error] - Indicates if a bracketed IP literal is malformed.
     */
    /**
     * Validates and normalizes a bracketed IP literal. Raw zone separators remain
     * accepted for backwards compatibility, while encoded separators and zone
     * contents follow RFC 6874.
     *
     * @param {string} host
     * @returns {NormalizeIPv6Result}
     */
    function normalizeIPv6(host) {
      const bracketed =
        host[0] === "[" && host[host.length - 1] === "]";
      if (
        (host[0] === "[" ||
          host[host.length - 1] === "]") &&
        !bracketed
      )
        return {
          host,
          isIPV6: false,
          error: true,
        };
      let input = bracketed ? host.slice(1, -1) : host;
      if (bracketed && isIPvFuture(input)) {
        input = input.toLowerCase();
        return {
          host: `[${input}]`,
          escapedHost: input,
          isIPV6: false,
          isIPVFuture: true,
        };
      }
      if (findToken(input, ":") < 2)
        return {
          host,
          isIPV6: false,
          error: bracketed,
        };
      let zoneIdentifier = "";
      const zoneSeparator = input.indexOf("%");
      if (zoneSeparator !== -1) {
        const separatorLength =
          input
            .slice(zoneSeparator, zoneSeparator + 3)
            .toLowerCase() === "%25"
            ? 3
            : 1;
        zoneIdentifier = input.slice(
          zoneSeparator + separatorLength,
        );
        if (!isZoneIdentifier(zoneIdentifier))
          return {
            host,
            isIPV6: false,
            error: true,
          };
        input = input.slice(0, zoneSeparator);
      }
      const address = normalizeIPv6Address(input);
      if (address === void 0)
        return {
          host,
          isIPV6: false,
          error: true,
        };
      return {
        host:
          address +
          (zoneIdentifier ? "%" + zoneIdentifier : ""),
        escapedHost:
          address +
          (zoneIdentifier ? "%25" + zoneIdentifier : ""),
        isIPV6: true,
      };
    }
    /**
     * @param {string} str
     * @param {string} token
     * @returns {number}
     */
    function findToken(str, token) {
      let ind = 0;
      for (let i = 0; i < str.length; i++)
        if (str[i] === token) ind++;
      return ind;
    }
    /**
     * @param {string} path
     * @returns {string}
     *
     * @see https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
     */
    function removeDotSegments(path) {
      let input = path;
      const output = [];
      let nextSlash = -1;
      let len = 0;
      while ((len = input.length)) {
        if (len === 1) {
          if (input === ".") break;
          else if (input === "/") {
            output.push("/");
            break;
          } else {
            output.push(input);
            break;
          }
        } else if (len === 2) {
          if (input[0] === ".") {
            if (input[1] === ".") break;
            else if (input[1] === "/") {
              input = input.slice(2);
              continue;
            }
          } else if (input[0] === "/") {
            if (input[1] === "." || input[1] === "/") {
              output.push("/");
              break;
            }
          }
        } else if (len === 3) {
          if (input === "/..") {
            if (output.length !== 0) output.pop();
            output.push("/");
            break;
          }
        }
        if (input[0] === ".") {
          if (input[1] === ".") {
            if (input[2] === "/") {
              input = input.slice(3);
              continue;
            }
          } else if (input[1] === "/") {
            input = input.slice(2);
            continue;
          }
        } else if (input[0] === "/") {
          if (input[1] === ".") {
            if (input[2] === "/") {
              input = input.slice(2);
              continue;
            } else if (input[2] === ".") {
              if (input[3] === "/") {
                input = input.slice(3);
                if (output.length !== 0) output.pop();
                continue;
              }
            }
          }
        }
        if ((nextSlash = input.indexOf("/", 1)) === -1) {
          output.push(input);
          break;
        } else {
          output.push(input.slice(0, nextSlash));
          input = input.slice(nextSlash);
        }
      }
      return output.join("");
    }
    /**
     * Re-escape RFC 3986 gen-delims that must not appear literally in the host.
     * After the URI regex parses, these characters cannot be literal in the host
     * field, so any that appear after decoding came from percent-encoding and
     * must be restored to prevent authority structure changes.
     *
     * @param {string} host
     * @param {boolean} isIP - true for IPv4/IPv6 hosts (skip colon re-escaping)
     * @returns {string}
     */
    const HOST_DELIMS = {
      "@": "%40",
      "/": "%2F",
      "?": "%3F",
      "#": "%23",
      ":": "%3A",
    };
    const HOST_DELIM_RE = /[@/?#:]/g;
    const HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
    function reescapeHostDelimiters(host, isIP) {
      const re = isIP
        ? HOST_DELIM_NO_COLON_RE
        : HOST_DELIM_RE;
      re.lastIndex = 0;
      return host.replace(re, (ch) => HOST_DELIMS[ch]);
    }
    /**
     * Normalizes percent escapes and optionally decodes only unreserved ASCII bytes.
     * Reserved delimiters such as `%2F` stay escaped; `%2E` is unreserved.
     *
     * @param {string} input
     * @param {boolean} [decodeUnreserved=false]
     * @returns {string}
     */
    function normalizePercentEncoding(
      input,
      decodeUnreserved = false,
    ) {
      if (input.indexOf("%") === -1) return input;
      let output = "";
      for (let i = 0; i < input.length; i++) {
        if (input[i] === "%" && i + 2 < input.length) {
          const hex = input.slice(i + 1, i + 3);
          if (isHexPair(hex)) {
            const normalizedHex = hex.toUpperCase();
            const decoded = String.fromCharCode(
              parseInt(normalizedHex, 16),
            );
            if (decodeUnreserved && isUnreserved(decoded))
              output += decoded;
            else output += "%" + normalizedHex;
            i += 2;
            continue;
          }
        }
        output += input[i];
      }
      return output;
    }
    /**
     * Normalizes path data without turning reserved escapes into live path syntax.
     * Valid escapes are uppercased, raw unsafe characters are escaped, and only
     * unreserved bytes that are not `.` are decoded.
     *
     * @param {string} input
     * @returns {string}
     */
    function normalizePathEncoding(input) {
      let output = "";
      for (let i = 0; i < input.length; i++) {
        const ch = input[i];
        if (ch === "%" && i + 2 < input.length) {
          const hex = input.slice(i + 1, i + 3);
          if (isHexPair(hex)) {
            const normalizedHex = hex.toUpperCase();
            const decoded = String.fromCharCode(
              parseInt(normalizedHex, 16),
            );
            if (decoded !== "." && isUnreserved(decoded))
              output += decoded;
            else output += "%" + normalizedHex;
            i += 2;
            continue;
          }
        }
        if (isPathCharacter(ch)) output += ch;
        else {
          const code = input.charCodeAt(i);
          if (code < 128)
            output += isEscapeSafe(code)
              ? ch
              : BYTE_HEX[code];
          else if (code < 55296 || code > 57343)
            output += percentEncodeNonAscii(code);
          else if (code <= 56319 && i + 1 < input.length) {
            const low = input.charCodeAt(i + 1);
            if (low >= 56320 && low <= 57343) {
              output += percentEncodeNonAscii(
                65536 +
                  ((code - 55296) << 10) +
                  (low - 56320),
              );
              i++;
            } else output += percentEncodeNonAscii(65533);
          } else output += percentEncodeNonAscii(65533);
        }
      }
      return output;
    }
    /**
     * Serializes a path without rewriting reserved data. Raw RFC 3986 path
     * characters remain literal, valid escapes are preserved and uppercased, and
     * everything else is UTF-8 percent-encoded. In a path-noscheme, a colon in the
     * first segment must be escaped so the result cannot be parsed as a scheme.
     *
     * @param {string} input
     * @param {boolean} [pathNoScheme=false]
     * @returns {string}
     */
    function serializePathEncoding(
      input,
      pathNoScheme = false,
    ) {
      let output = "";
      let firstSegment = pathNoScheme && input[0] !== "/";
      for (let i = 0; i < input.length; i++) {
        const ch = input[i];
        if (ch === "%" && i + 2 < input.length) {
          const hex = input.slice(i + 1, i + 3);
          if (isHexPair(hex)) {
            output += "%" + hex.toUpperCase();
            i += 2;
            continue;
          }
        }
        if (ch === "/") firstSegment = false;
        if (
          isPathCharacter(ch) &&
          (ch !== ":" || !firstSegment)
        )
          output += ch;
        else {
          const code = input.charCodeAt(i);
          if (code < 128) output += BYTE_HEX[code];
          else if (code < 55296 || code > 57343)
            output += percentEncodeNonAscii(code);
          else if (code <= 56319 && i + 1 < input.length) {
            const low = input.charCodeAt(i + 1);
            if (low >= 56320 && low <= 57343) {
              output += percentEncodeNonAscii(
                65536 +
                  ((code - 55296) << 10) +
                  (low - 56320),
              );
              i++;
            } else output += percentEncodeNonAscii(65533);
          } else output += percentEncodeNonAscii(65533);
        }
      }
      return output;
    }
    /**
     * Percent-encodes a URI component using its RFC 3986 literal character set.
     * Existing valid escapes are preserved and normalized to uppercase hex.
     *
     * @param {string} input
     * @param {(value: string) => boolean} isAllowed
     * @returns {string}
     */
    function encodeComponent(input, isAllowed) {
      let output = "";
      for (let i = 0; i < input.length; i++) {
        const ch = input[i];
        if (ch === "%" && i + 2 < input.length) {
          const hex = input.slice(i + 1, i + 3);
          if (isHexPair(hex)) {
            output += "%" + hex.toUpperCase();
            i += 2;
            continue;
          }
        }
        if (isAllowed(ch)) output += ch;
        else {
          const code = input.charCodeAt(i);
          if (code < 128) output += BYTE_HEX[code];
          else if (code < 55296 || code > 57343)
            output += percentEncodeNonAscii(code);
          else if (code <= 56319 && i + 1 < input.length) {
            const low = input.charCodeAt(i + 1);
            if (low >= 56320 && low <= 57343) {
              output += percentEncodeNonAscii(
                65536 +
                  ((code - 55296) << 10) +
                  (low - 56320),
              );
              i++;
            } else output += percentEncodeNonAscii(65533);
          } else output += percentEncodeNonAscii(65533);
        }
      }
      return output;
    }
    /**
     * Encodes userinfo while preserving its RFC 3986 §3.2.1 literal characters.
     * In particular, authority delimiters such as `@`, `/`, `?`, and `#` are data.
     *
     * @param {string} input
     * @returns {string}
     */
    function encodeUserinfo(input) {
      return encodeComponent(input, isUserinfoCharacter);
    }
    /**
     * Encodes query data using the RFC 3986 §3.4 grammar. A literal `#` must be
     * escaped because it would otherwise begin the fragment component.
     *
     * @param {string} input
     * @returns {string}
     */
    function encodeQuery(input) {
      return encodeComponent(
        input,
        isQueryFragmentCharacter,
      );
    }
    /**
     * Encodes fragment data using the RFC 3986 §3.5 grammar.
     *
     * @param {string} input
     * @returns {string}
     */
    function encodeFragment(input) {
      return encodeComponent(
        input,
        isQueryFragmentCharacter,
      );
    }
    function isEscapeSafe(cp) {
      return (
        (cp >= 48 && cp <= 57) ||
        (cp >= 65 && cp <= 90) ||
        (cp >= 97 && cp <= 122) ||
        cp === 42 ||
        cp === 43 ||
        cp === 45 ||
        cp === 46 ||
        cp === 47 ||
        cp === 64 ||
        cp === 95
      );
    }
    /**
     * Normalizes the percent-encoding of a query or fragment component.
     *
     * Like `normalizePathEncoding`, but uses the query/fragment character set
     * (which additionally allows `?`) and decodes `.` since it has no dot-segment
     * meaning outside of a path.
     *
     * @param {string} input
     * @returns {string}
     */
    function normalizeQueryFragmentEncoding(input) {
      let output = "";
      for (let i = 0; i < input.length; i++) {
        const ch = input[i];
        if (ch === "%" && i + 2 < input.length) {
          const hex = input.slice(i + 1, i + 3);
          if (isHexPair(hex)) {
            const normalizedHex = hex.toUpperCase();
            const decoded = String.fromCharCode(
              parseInt(normalizedHex, 16),
            );
            if (isUnreserved(decoded)) output += decoded;
            else output += "%" + normalizedHex;
            i += 2;
            continue;
          }
        }
        if (isQueryFragmentCharacter(ch)) output += ch;
        else {
          const code = input.charCodeAt(i);
          if (code < 128)
            output += isEscapeSafe(code)
              ? ch
              : BYTE_HEX[code];
          else if (code < 55296 || code > 57343)
            output += percentEncodeNonAscii(code);
          else if (code <= 56319 && i + 1 < input.length) {
            const low = input.charCodeAt(i + 1);
            if (low >= 56320 && low <= 57343) {
              output += percentEncodeNonAscii(
                65536 +
                  ((code - 55296) << 10) +
                  (low - 56320),
              );
              i++;
            } else output += percentEncodeNonAscii(65533);
          } else output += percentEncodeNonAscii(65533);
        }
      }
      return output;
    }
    /**
     * Escapes a component while preserving existing valid percent escapes.
     *
     * @param {string} input
     * @returns {string}
     */
    function escapePreservingEscapes(input) {
      let output = "";
      for (let i = 0; i < input.length; i++) {
        if (input[i] === "%" && i + 2 < input.length) {
          const hex = input.slice(i + 1, i + 3);
          if (isHexPair(hex)) {
            output += "%" + hex.toUpperCase();
            i += 2;
            continue;
          }
        }
        output += escape(input[i]);
      }
      return output;
    }
    /**
     * @param {import('../types/index').URIComponent} component
     * @returns {string|undefined}
     */
    function recomposeAuthority(component) {
      const uriTokens = [];
      if (component.userinfo !== void 0) {
        uriTokens.push(encodeUserinfo(component.userinfo));
        uriTokens.push("@");
      }
      if (component.host !== void 0) {
        let host = component.host;
        if (!isIPv4(host)) {
          let ipV6res = normalizeIPv6(host);
          if (
            ipV6res.isIPV6 !== true &&
            ipV6res.isIPVFuture !== true
          ) {
            host = normalizePercentEncoding(host, true);
            ipV6res = normalizeIPv6(host);
          }
          if (
            ipV6res.isIPV6 === true ||
            ipV6res.isIPVFuture === true
          )
            host = `[${ipV6res.escapedHost}]`;
          else host = reescapeHostDelimiters(host, false);
        }
        uriTokens.push(host);
      }
      if (
        typeof component.port === "number" ||
        typeof component.port === "string"
      ) {
        const port = String(component.port);
        if (!isPort(port))
          throw new TypeError("URI port is malformed.");
        uriTokens.push(":");
        uriTokens.push(port);
      }
      return uriTokens.length ? uriTokens.join("") : void 0;
    }
    module.exports = {
      nonSimpleDomain,
      recomposeAuthority,
      reescapeHostDelimiters,
      normalizePercentEncoding,
      normalizePathEncoding,
      serializePathEncoding,
      normalizeQueryFragmentEncoding,
      encodeUserinfo,
      encodeQuery,
      encodeFragment,
      escapePreservingEscapes,
      removeDotSegments,
      isIPv4,
      isUUID,
      normalizeIPv6,
      stringArrayToHexStripped,
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/lib/schemes.js
var require_schemes = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    const { isUUID } = require_utils();
    const URN_REG =
      /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
    const supportedSchemeNames = [
      "http",
      "https",
      "ws",
      "wss",
      "urn",
      "urn:uuid",
    ];
    /** @typedef {supportedSchemeNames[number]} SchemeName */
    /**
     * @param {string} name
     * @returns {name is SchemeName}
     */
    function isValidSchemeName(name) {
      return supportedSchemeNames.indexOf(name) !== -1;
    }
    /**
     * @callback SchemeFn
     * @param {import('../types/index').URIComponent} component
     * @param {import('../types/index').Options} options
     * @returns {import('../types/index').URIComponent}
     */
    /**
     * @typedef {Object} SchemeHandler
     * @property {SchemeName} scheme - The scheme name.
     * @property {boolean} [domainHost] - Indicates if the scheme supports domain hosts.
     * @property {SchemeFn} parse - Function to parse the URI component for this scheme.
     * @property {SchemeFn} serialize - Function to serialize the URI component for this scheme.
     * @property {boolean} [skipNormalize] - Indicates if normalization should be skipped for this scheme.
     * @property {boolean} [absolutePath] - Indicates if the scheme uses absolute paths.
     * @property {boolean} [unicodeSupport] - Indicates if the scheme supports Unicode.
     */
    /**
     * @param {import('../types/index').URIComponent} wsComponent
     * @returns {boolean}
     */
    function wsIsSecure(wsComponent) {
      if (wsComponent.secure === true) return true;
      else if (wsComponent.secure === false) return false;
      else if (wsComponent.scheme)
        return (
          wsComponent.scheme.length === 3 &&
          (wsComponent.scheme[0] === "w" ||
            wsComponent.scheme[0] === "W") &&
          (wsComponent.scheme[1] === "s" ||
            wsComponent.scheme[1] === "S") &&
          (wsComponent.scheme[2] === "s" ||
            wsComponent.scheme[2] === "S")
        );
      else return false;
    }
    /** @type {SchemeFn} */
    function httpParse(component) {
      if (!component.host)
        component.error =
          component.error || "HTTP URIs must have a host.";
      return component;
    }
    /** @type {SchemeFn} */
    function httpSerialize(component) {
      const secure =
        String(component.scheme).toLowerCase() === "https";
      if (
        component.port === (secure ? 443 : 80) ||
        component.port === ""
      )
        component.port = void 0;
      if (!component.path) component.path = "/";
      return component;
    }
    /** @type {SchemeFn} */
    function wsParse(wsComponent) {
      wsComponent.secure = wsIsSecure(wsComponent);
      wsComponent.resourceName =
        (wsComponent.path || "/") +
        (wsComponent.query ? "?" + wsComponent.query : "");
      wsComponent.path = void 0;
      wsComponent.query = void 0;
      return wsComponent;
    }
    /** @type {SchemeFn} */
    function wsSerialize(wsComponent) {
      if (
        wsComponent.port ===
          (wsIsSecure(wsComponent) ? 443 : 80) ||
        wsComponent.port === ""
      )
        wsComponent.port = void 0;
      if (typeof wsComponent.secure === "boolean") {
        wsComponent.scheme = wsComponent.secure
          ? "wss"
          : "ws";
        wsComponent.secure = void 0;
      }
      if (wsComponent.resourceName) {
        const queryIndex =
          wsComponent.resourceName.indexOf("?");
        const path =
          queryIndex === -1
            ? wsComponent.resourceName
            : wsComponent.resourceName.slice(0, queryIndex);
        wsComponent.path =
          path && path !== "/" ? path : void 0;
        wsComponent.query =
          queryIndex === -1
            ? void 0
            : wsComponent.resourceName.slice(
                queryIndex + 1,
              );
        wsComponent.resourceName = void 0;
      }
      wsComponent.fragment = void 0;
      return wsComponent;
    }
    /** @type {SchemeFn} */
    function urnParse(urnComponent, options) {
      if (!urnComponent.path) {
        urnComponent.error = "URN can not be parsed";
        return urnComponent;
      }
      const matches = urnComponent.path.match(URN_REG);
      if (matches && matches[0] === urnComponent.path) {
        const scheme =
          options.scheme || urnComponent.scheme || "urn";
        urnComponent.nid = matches[1].toLowerCase();
        urnComponent.nss = matches[2];
        const schemeHandler = getSchemeHandler(
          `${scheme}:${options.nid || urnComponent.nid}`,
        );
        urnComponent.path = void 0;
        if (schemeHandler)
          urnComponent = schemeHandler.parse(
            urnComponent,
            options,
          );
      } else
        urnComponent.error =
          urnComponent.error || "URN can not be parsed.";
      return urnComponent;
    }
    /** @type {SchemeFn} */
    function urnSerialize(urnComponent, options) {
      if (urnComponent.nid === void 0)
        throw new Error(
          "URN without nid cannot be serialized",
        );
      const scheme =
        options.scheme || urnComponent.scheme || "urn";
      const nid = urnComponent.nid.toLowerCase();
      const schemeHandler = getSchemeHandler(
        `${scheme}:${options.nid || nid}`,
      );
      if (schemeHandler)
        urnComponent = schemeHandler.serialize(
          urnComponent,
          options,
        );
      const uriComponent = urnComponent;
      const nss = urnComponent.nss;
      uriComponent.path = `${nid || options.nid}:${nss}`;
      options.skipEscape = true;
      return uriComponent;
    }
    /** @type {SchemeFn} */
    function urnuuidParse(urnComponent, options) {
      const uuidComponent = urnComponent;
      uuidComponent.uuid = uuidComponent.nss;
      uuidComponent.nss = void 0;
      if (
        !options.tolerant &&
        (!uuidComponent.uuid || !isUUID(uuidComponent.uuid))
      )
        uuidComponent.error =
          uuidComponent.error || "UUID is not valid.";
      return uuidComponent;
    }
    /** @type {SchemeFn} */
    function urnuuidSerialize(uuidComponent) {
      const urnComponent = uuidComponent;
      urnComponent.nss = (
        uuidComponent.uuid || ""
      ).toLowerCase();
      return urnComponent;
    }
    const http = {
      scheme: "http",
      domainHost: true,
      parse: httpParse,
      serialize: httpSerialize,
    };
    const https = {
      scheme: "https",
      domainHost: http.domainHost,
      parse: httpParse,
      serialize: httpSerialize,
    };
    const ws = {
      scheme: "ws",
      domainHost: true,
      parse: wsParse,
      serialize: wsSerialize,
    };
    const SCHEMES = {
      http,
      https,
      ws,
      wss: {
        scheme: "wss",
        domainHost: ws.domainHost,
        parse: ws.parse,
        serialize: ws.serialize,
      },
      urn: {
        scheme: "urn",
        parse: urnParse,
        serialize: urnSerialize,
        skipNormalize: true,
      },
      "urn:uuid": {
        scheme: "urn:uuid",
        parse: urnuuidParse,
        serialize: urnuuidSerialize,
        skipNormalize: true,
      },
    };
    Object.setPrototypeOf(SCHEMES, null);
    /**
     * @param {string|undefined} scheme
     * @returns {SchemeHandler|undefined}
     */
    function getSchemeHandler(scheme) {
      return (
        (scheme &&
          (SCHEMES[scheme] ||
            SCHEMES[scheme.toLowerCase()])) ||
        void 0
      );
    }
    module.exports = {
      wsIsSecure,
      SCHEMES,
      isValidSchemeName,
      getSchemeHandler,
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/index.js
var require_fast_uri = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    const {
      normalizeIPv6,
      removeDotSegments,
      recomposeAuthority,
      normalizePercentEncoding,
      normalizePathEncoding,
      serializePathEncoding,
      normalizeQueryFragmentEncoding,
      encodeQuery,
      encodeFragment,
      reescapeHostDelimiters,
      isIPv4,
      nonSimpleDomain,
    } = require_utils();
    const { SCHEMES, getSchemeHandler } = require_schemes();
    const VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
    const MALFORMED_SCHEME_ERROR =
      "URI scheme is malformed.";
    /**
     * @param {string} scheme
     * @returns {string}
     */
    function decodeValidScheme(scheme) {
      const decodedScheme = unescape(String(scheme));
      if (!VALID_SCHEME.test(decodedScheme))
        throw new TypeError(MALFORMED_SCHEME_ERROR);
      return decodedScheme;
    }
    /**
     * @template {import('./types/index').URIComponent|string} T
     * @param {T} uri
     * @param {import('./types/index').Options} [options]
     * @returns {T}
     */
    function normalize(uri, options) {
      if (typeof uri === "string")
        uri = normalizeString(uri, options);
      else if (typeof uri === "object")
        uri = parse(serialize(uri, options), options);
      return uri;
    }
    /**
     * @param {string} baseURI
     * @param {string} relativeURI
     * @param {import('./types/index').Options} [options]
     * @returns {string}
     */
    function resolve(baseURI, relativeURI, options) {
      const schemelessOptions = options
        ? Object.assign({ scheme: "null" }, options)
        : { scheme: "null" };
      const {
        parsed: baseParsed,
        malformedAuthorityOrPort: baseMalformed,
        malformedPercentEncoding:
          baseMalformedPercentEncoding,
        malformedSchemeSpecific:
          baseMalformedSchemeSpecific,
        malformedHost: baseMalformedHost,
        malformedScheme: baseMalformedScheme,
      } = parseWithStatus(baseURI, schemelessOptions);
      const {
        parsed: relativeParsed,
        malformedAuthorityOrPort: relativeMalformed,
        malformedPercentEncoding:
          relativeMalformedPercentEncoding,
        malformedSchemeSpecific:
          relativeMalformedSchemeSpecific,
        malformedHost: relativeMalformedHost,
        malformedScheme: relativeMalformedScheme,
      } = parseWithStatus(relativeURI, schemelessOptions);
      if (
        baseMalformed ||
        relativeMalformed ||
        baseMalformedPercentEncoding ||
        relativeMalformedPercentEncoding ||
        baseMalformedSchemeSpecific ||
        relativeMalformedSchemeSpecific ||
        baseMalformedHost ||
        relativeMalformedHost ||
        baseMalformedScheme ||
        relativeMalformedScheme
      )
        throw new Error(
          baseParsed.error ||
            relativeParsed.error ||
            "URI is malformed.",
        );
      const resolved = resolveComponent(
        baseParsed,
        relativeParsed,
        schemelessOptions,
        true,
      );
      const resolvedSchemeHandler = getSchemeHandler(
        (options && options.scheme) || resolved.scheme,
      );
      const resolvedHost = resolved.host;
      const resolvedHostIsIP =
        resolvedHost !== void 0 &&
        resolvedHost !== "" &&
        (isIPv4(resolvedHost) ||
          normalizeIPv6(resolvedHost).isIPV6);
      canonicalizeHost(
        resolved,
        options || {},
        resolvedSchemeHandler,
        resolvedHostIsIP,
      );
      const encodedASCIIHost =
        resolvedHost &&
        resolvedHost.indexOf("%") !== -1 &&
        !/\P{ASCII}/u.test(resolvedHost);
      if (resolved.error && !encodedASCIIHost)
        throw new Error(resolved.error);
      schemelessOptions.skipEscape = true;
      return serialize(resolved, schemelessOptions);
    }
    /**
     * @param {import ('./types/index').URIComponent} base
     * @param {import ('./types/index').URIComponent} relative
     * @param {import('./types/index').Options} [options]
     * @param {boolean} [skipNormalization=false]
     * @returns {import ('./types/index').URIComponent}
     */
    function resolveComponent(
      base,
      relative,
      options,
      skipNormalization,
    ) {
      /** @type {import('./types/index').URIComponent} */
      const target = {};
      if (!skipNormalization) {
        base = parse(serialize(base, options), options);
        relative = parse(
          serialize(relative, options),
          options,
        );
      }
      options = options || {};
      if (!options.tolerant && relative.scheme) {
        target.scheme = relative.scheme;
        target.userinfo = relative.userinfo;
        target.host = relative.host;
        target.port = relative.port;
        target.path = removeDotSegments(
          relative.path || "",
        );
        target.query = relative.query;
      } else {
        if (
          relative.userinfo !== void 0 ||
          relative.host !== void 0 ||
          relative.port !== void 0
        ) {
          target.userinfo = relative.userinfo;
          target.host = relative.host;
          target.port = relative.port;
          target.path = removeDotSegments(
            relative.path || "",
          );
          target.query = relative.query;
        } else {
          if (!relative.path) {
            target.path = base.path;
            if (relative.query !== void 0)
              target.query = relative.query;
            else target.query = base.query;
          } else {
            if (relative.path[0] === "/")
              target.path = removeDotSegments(
                relative.path,
              );
            else {
              if (
                (base.userinfo !== void 0 ||
                  base.host !== void 0 ||
                  base.port !== void 0) &&
                !base.path
              )
                target.path = "/" + relative.path;
              else if (!base.path)
                target.path = relative.path;
              else
                target.path =
                  base.path.slice(
                    0,
                    base.path.lastIndexOf("/") + 1,
                  ) + relative.path;
              target.path = removeDotSegments(target.path);
            }
            target.query = relative.query;
          }
          target.userinfo = base.userinfo;
          target.host = base.host;
          target.port = base.port;
        }
        target.scheme = base.scheme;
      }
      target.fragment = relative.fragment;
      return target;
    }
    /**
     * @param {import ('./types/index').URIComponent|string} uriA
     * @param {import ('./types/index').URIComponent|string} uriB
     * @param {import ('./types/index').Options} options
     * @returns {boolean}
     */
    function equal(uriA, uriB, options) {
      const normalizedA = normalizeComparableURI(
        uriA,
        options,
      );
      const normalizedB = normalizeComparableURI(
        uriB,
        options,
      );
      return (
        normalizedA !== void 0 &&
        normalizedB !== void 0 &&
        normalizedA === normalizedB
      );
    }
    /**
     * @param {Readonly<import('./types/index').URIComponent>} cmpts
     * @param {import('./types/index').Options} [opts]
     * @returns {string}
     */
    function serialize(cmpts, opts) {
      const component = {
        host: cmpts.host,
        scheme: cmpts.scheme,
        userinfo: cmpts.userinfo,
        port: cmpts.port,
        path: cmpts.path,
        query: cmpts.query,
        nid: cmpts.nid,
        nss: cmpts.nss,
        uuid: cmpts.uuid,
        fragment: cmpts.fragment,
        reference: cmpts.reference,
        resourceName: cmpts.resourceName,
        secure: cmpts.secure,
        error: "",
      };
      const options = Object.assign({}, opts);
      const uriTokens = [];
      if (component.scheme)
        component.scheme = decodeValidScheme(
          component.scheme,
        );
      const schemeHandler = getSchemeHandler(
        options.scheme || component.scheme,
      );
      if (schemeHandler && schemeHandler.serialize)
        schemeHandler.serialize(component, options);
      const hasAuthority =
        component.userinfo !== void 0 ||
        component.host !== void 0 ||
        component.port !== void 0;
      const pathNoScheme =
        !options.skipEscape &&
        component.scheme === void 0 &&
        !hasAuthority;
      if (component.path !== void 0) {
        if (!options.skipEscape)
          component.path = serializePathEncoding(
            component.path,
            pathNoScheme,
          );
        else
          component.path = normalizePercentEncoding(
            component.path,
          );
      }
      if (
        options.reference !== "suffix" &&
        component.scheme
      ) {
        component.scheme = decodeValidScheme(
          component.scheme,
        );
        uriTokens.push(component.scheme, ":");
      }
      const authority = recomposeAuthority(component);
      if (authority !== void 0) {
        if (options.reference !== "suffix")
          uriTokens.push("//");
        uriTokens.push(authority);
        if (component.path && component.path[0] !== "/")
          uriTokens.push("/");
      }
      if (component.path !== void 0) {
        let s = component.path;
        if (
          !options.absolutePath &&
          (!schemeHandler || !schemeHandler.absolutePath)
        )
          s = removeDotSegments(s);
        if (pathNoScheme)
          s = serializePathEncoding(s, true);
        if (
          authority === void 0 &&
          s[0] === "/" &&
          s[1] === "/"
        )
          s = "/%2F" + s.slice(2);
        uriTokens.push(s);
      }
      if (component.query !== void 0)
        uriTokens.push("?", encodeQuery(component.query));
      if (component.fragment !== void 0)
        uriTokens.push(
          "#",
          encodeFragment(component.fragment),
        );
      return uriTokens.join("");
    }
    const URI_PARSE =
      /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
    const AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
    const AUTHORITY_INTRODUCER_REGION =
      /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/;
    /**
     * @param {import('./types/index').URIComponent} parsed
     * @param {RegExpMatchArray} matches
     * @returns {string|undefined}
     */
    function getParseError(parsed, matches) {
      if (
        matches[2] !== void 0 &&
        parsed.path &&
        parsed.path[0] !== "/"
      )
        return 'URI path must start with "/" when authority is present.';
      if (
        typeof parsed.port === "number" &&
        (parsed.port < 0 || parsed.port > 65535)
      )
        return "URI port is malformed.";
    }
    /**
     * Checks percent syntax without decoding the represented octets. RFC 3986
     * percent-encoding is byte-oriented, so sequences such as `%FF` are valid even
     * though they are not independently valid UTF-8.
     *
     * @param {string|undefined} component
     * @returns {boolean}
     */
    function hasMalformedPercentEncoding(component) {
      if (component === void 0) return false;
      let percent = component.indexOf("%");
      while (percent !== -1) {
        if (
          percent + 2 >= component.length ||
          !/^[\da-f]{2}$/iu.test(
            component.slice(percent + 1, percent + 3),
          )
        )
          return true;
        percent = component.indexOf("%", percent + 3);
      }
      return false;
    }
    /**
     * Whether the host is a bracketed IP literal (RFC 3986 `IP-literal`).
     * An unterminated `[` is not a literal, so it must still be validated as a
     * reg-name instead of being waved through as an IP.
     *
     * @param {string} host
     * @returns {boolean}
     */
    function isIPLiteral(host) {
      return (
        host[0] === "[" && host[host.length - 1] === "]"
      );
    }
    /**
     * @param {RegExpMatchArray} matches
     * @returns {boolean}
     */
    function hasMalformedComponentPercentEncoding(matches) {
      const host = matches[4];
      return (
        hasMalformedPercentEncoding(matches[3]) ||
        (host !== void 0 &&
          !isIPLiteral(host) &&
          hasMalformedPercentEncoding(host)) ||
        hasMalformedPercentEncoding(matches[6]) ||
        hasMalformedPercentEncoding(matches[7]) ||
        hasMalformedPercentEncoding(matches[8])
      );
    }
    /**
     * @param {import('./types/index').URIComponent} parsed
     * @param {import('./types/index').Options} options
     * @param {{ domainHost?: boolean, unicodeSupport?: boolean }|undefined} schemeHandler
     * @param {boolean} isIP
     * @returns {boolean} whether host conversion failed
     */
    function canonicalizeHost(
      parsed,
      options,
      schemeHandler,
      isIP,
    ) {
      if (
        !options.unicodeSupport &&
        (!schemeHandler || !schemeHandler.unicodeSupport) &&
        parsed.host &&
        !isIPLiteral(parsed.host) &&
        (options.domainHost ||
          (schemeHandler && schemeHandler.domainHost)) &&
        isIP === false &&
        nonSimpleDomain(parsed.host)
      )
        try {
          parsed.host = new URL(
            "http://" + parsed.host,
          ).hostname;
        } catch (e) {
          parsed.error =
            parsed.error ||
            "Host's domain name can not be converted to ASCII: " +
              e;
          return true;
        }
      return false;
    }
    /**
     * @param {string} uri
     * @param {import('./types/index').Options} [opts]
     * @returns {{ parsed: import('./types/index').URIComponent, malformedAuthorityOrPort: boolean, malformedPercentEncoding: boolean, malformedSchemeSpecific: boolean, malformedHost: boolean, malformedScheme: boolean }}
     */
    function parseWithStatus(uri, opts) {
      const options = Object.assign({}, opts);
      /** @type {import('./types/index').URIComponent} */
      const parsed = {
        scheme: void 0,
        userinfo: void 0,
        host: "",
        port: void 0,
        path: "",
        query: void 0,
        fragment: void 0,
      };
      let malformedAuthorityOrPort = false;
      let malformedPercentEncoding = false;
      let malformedSchemeSpecific = false;
      let malformedHost = false;
      let malformedIPLiteral = false;
      let malformedScheme = false;
      let isIP = false;
      if (options.reference === "suffix") {
        if (options.scheme)
          uri = options.scheme + ":" + uri;
        else uri = "//" + uri;
      }
      const authorityMatch = uri.match(AUTHORITY_PREFIX);
      if (
        authorityMatch !== null &&
        authorityMatch[1].indexOf("\\") !== -1
      ) {
        parsed.error =
          "URI authority must not contain a literal backslash.";
        malformedAuthorityOrPort = true;
      }
      const introducerMatch = uri.match(
        AUTHORITY_INTRODUCER_REGION,
      );
      if (introducerMatch !== null) {
        const region = introducerMatch[1];
        const normalizedRegion = region.replace(
          /[\t\n\r]/g,
          "",
        );
        if (normalizedRegion.length >= 2) {
          if (normalizedRegion.slice(0, 2) !== "//") {
            parsed.error =
              parsed.error ||
              "URI authority must not contain a literal backslash.";
            malformedAuthorityOrPort = true;
          } else if (
            region.length !== normalizedRegion.length
          ) {
            parsed.error =
              parsed.error ||
              "URI authority introducer must not contain whitespace.";
            malformedAuthorityOrPort = true;
          }
        }
      }
      const matches = uri.match(URI_PARSE);
      if (matches) {
        parsed.scheme = matches[1];
        parsed.userinfo = matches[3];
        parsed.host = matches[4];
        parsed.port = parseInt(matches[5], 10);
        parsed.path = matches[6] || "";
        parsed.query = matches[7];
        parsed.fragment = matches[8];
        if (parsed.scheme !== void 0) {
          const decodedScheme = unescape(parsed.scheme);
          if (VALID_SCHEME.test(decodedScheme))
            parsed.scheme = decodedScheme.toLowerCase();
          else {
            parsed.error =
              parsed.error || MALFORMED_SCHEME_ERROR;
            malformedScheme = true;
          }
        }
        malformedPercentEncoding =
          hasMalformedComponentPercentEncoding(matches);
        if (malformedPercentEncoding)
          parsed.error =
            parsed.error ||
            "URI contains malformed percent-encoding.";
        if (isNaN(parsed.port)) parsed.port = matches[5];
        const parseError = getParseError(parsed, matches);
        if (parseError !== void 0) {
          parsed.error = parsed.error || parseError;
          malformedAuthorityOrPort = true;
        }
        if (parsed.host) {
          if (isIPv4(parsed.host) === false) {
            const bracketedIPLiteral = isIPLiteral(
              parsed.host,
            );
            const hasIPLiteralBracket =
              parsed.host.indexOf("[") !== -1 ||
              parsed.host.indexOf("]") !== -1;
            const ipv6result = normalizeIPv6(parsed.host);
            isIP =
              ipv6result.isIPV6 ||
              ipv6result.isIPVFuture === true;
            malformedIPLiteral =
              hasIPLiteralBracket &&
              (!bracketedIPLiteral ||
                ipv6result.error === true);
            parsed.host = isIP
              ? ipv6result.host
              : ipv6result.host.toLowerCase();
            if (malformedIPLiteral) {
              parsed.error =
                parsed.error || "URI host is malformed.";
              malformedAuthorityOrPort = true;
            }
          } else isIP = true;
        }
        if (
          parsed.scheme === void 0 &&
          parsed.userinfo === void 0 &&
          parsed.host === void 0 &&
          parsed.port === void 0 &&
          parsed.query === void 0 &&
          !parsed.path
        )
          parsed.reference = "same-document";
        else if (parsed.scheme === void 0)
          parsed.reference = "relative";
        else if (parsed.fragment === void 0)
          parsed.reference = "absolute";
        else parsed.reference = "uri";
        if (
          options.reference &&
          options.reference !== "suffix" &&
          options.reference !== parsed.reference
        )
          parsed.error =
            parsed.error ||
            "URI is not a " +
              options.reference +
              " reference.";
        const schemeHandler = getSchemeHandler(
          options.scheme || parsed.scheme,
        );
        if (!malformedIPLiteral)
          malformedHost = canonicalizeHost(
            parsed,
            options,
            schemeHandler,
            isIP,
          );
        if (
          uri.indexOf("%") !== -1 &&
          parsed.host !== void 0 &&
          !malformedIPLiteral
        ) {
          let host = isIP
            ? parsed.host
            : normalizePercentEncoding(parsed.host, true);
          if (!isIP)
            host = normalizePercentEncoding(
              host.toLowerCase(),
            );
          parsed.host = reescapeHostDelimiters(host, isIP);
        }
        if (
          !schemeHandler ||
          (schemeHandler && !schemeHandler.skipNormalize)
        ) {
          if (parsed.path)
            parsed.path = normalizePathEncoding(
              parsed.path,
            );
          if (parsed.query)
            parsed.query = normalizeQueryFragmentEncoding(
              parsed.query,
            );
          if (parsed.fragment)
            parsed.fragment =
              normalizeQueryFragmentEncoding(
                parsed.fragment,
              );
        }
        if (schemeHandler && schemeHandler.parse) {
          schemeHandler.parse(parsed, options);
          if (
            schemeHandler === SCHEMES.urn &&
            parsed.nid === void 0
          )
            malformedSchemeSpecific = true;
        }
      } else
        parsed.error =
          parsed.error || "URI can not be parsed.";
      return {
        parsed,
        malformedAuthorityOrPort,
        malformedPercentEncoding,
        malformedSchemeSpecific,
        malformedHost,
        malformedScheme,
      };
    }
    /**
     * @param {string} uri
     * @param {import('./types/index').Options} [opts]
     * @returns
     */
    function parse(uri, opts) {
      return parseWithStatus(uri, opts).parsed;
    }
    /**
     * @param {string} uri
     * @param {import('./types/index').Options} [opts]
     * @returns {string}
     */
    function normalizeString(uri, opts) {
      return normalizeStringWithStatus(uri, opts)
        .normalized;
    }
    /**
     * @param {string} uri
     * @param {import('./types/index').Options} [opts]
     * @returns {{ normalized: string, malformedAuthorityOrPort: boolean, malformedPercentEncoding: boolean, malformedSchemeSpecific: boolean, malformedHost: boolean, malformedScheme: boolean }}
     */
    function normalizeStringWithStatus(uri, opts) {
      const {
        parsed,
        malformedAuthorityOrPort,
        malformedPercentEncoding,
        malformedSchemeSpecific,
        malformedHost,
        malformedScheme,
      } = parseWithStatus(uri, opts);
      return {
        normalized:
          malformedAuthorityOrPort ||
          malformedPercentEncoding ||
          malformedSchemeSpecific ||
          malformedHost ||
          malformedScheme
            ? uri
            : serialize(parsed, opts),
        malformedAuthorityOrPort,
        malformedPercentEncoding,
        malformedSchemeSpecific,
        malformedHost,
        malformedScheme,
      };
    }
    /**
     * @param {import ('./types/index').URIComponent|string} uri
     * @param {import('./types/index').Options} [opts]
     * @returns {string|undefined}
     */
    function normalizeComparableURI(uri, opts) {
      if (
        typeof uri !== "string" &&
        typeof uri !== "object"
      )
        return;
      let value;
      try {
        value =
          typeof uri === "string"
            ? uri
            : serialize(uri, opts);
      } catch {
        return;
      }
      const {
        normalized,
        malformedAuthorityOrPort,
        malformedPercentEncoding,
        malformedSchemeSpecific,
        malformedHost,
        malformedScheme,
      } = normalizeStringWithStatus(value, opts);
      return malformedAuthorityOrPort ||
        malformedPercentEncoding ||
        malformedSchemeSpecific ||
        malformedHost ||
        malformedScheme
        ? void 0
        : normalized;
    }
    const fastUri = {
      SCHEMES,
      normalize,
      resolve,
      resolveComponent,
      equal,
      serialize,
      parse,
    };
    module.exports = fastUri;
    module.exports.default = fastUri;
    module.exports.fastUri = fastUri;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/uri.js
var require_uri = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const uri = require_fast_uri();
    uri.code = 'require("ajv/dist/runtime/uri").default';
    exports.default = uri;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/core.js
var require_core$1 = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.CodeGen =
      exports.Name =
      exports.nil =
      exports.stringify =
      exports.str =
      exports._ =
      exports.KeywordCxt =
        void 0;
    var validate_1 = require_validate();
    Object.defineProperty(exports, "KeywordCxt", {
      enumerable: true,
      get: function () {
        return validate_1.KeywordCxt;
      },
    });
    var codegen_1 = require_codegen();
    Object.defineProperty(exports, "_", {
      enumerable: true,
      get: function () {
        return codegen_1._;
      },
    });
    Object.defineProperty(exports, "str", {
      enumerable: true,
      get: function () {
        return codegen_1.str;
      },
    });
    Object.defineProperty(exports, "stringify", {
      enumerable: true,
      get: function () {
        return codegen_1.stringify;
      },
    });
    Object.defineProperty(exports, "nil", {
      enumerable: true,
      get: function () {
        return codegen_1.nil;
      },
    });
    Object.defineProperty(exports, "Name", {
      enumerable: true,
      get: function () {
        return codegen_1.Name;
      },
    });
    Object.defineProperty(exports, "CodeGen", {
      enumerable: true,
      get: function () {
        return codegen_1.CodeGen;
      },
    });
    const validation_error_1 = require_validation_error();
    const ref_error_1 = require_ref_error();
    const rules_1 = require_rules();
    const compile_1 = require_compile();
    const codegen_2 = require_codegen();
    const resolve_1 = require_resolve();
    const dataType_1 = require_dataType();
    const util_1 = require_util();
    const $dataRefSchema = require_data();
    const uri_1 = require_uri();
    const defaultRegExp = (str, flags) =>
      new RegExp(str, flags);
    defaultRegExp.code = "new RegExp";
    const META_IGNORE_OPTIONS = [
      "removeAdditional",
      "useDefaults",
      "coerceTypes",
    ];
    const EXT_SCOPE_NAMES = /* @__PURE__ */ new Set([
      "validate",
      "serialize",
      "parse",
      "wrapper",
      "root",
      "schema",
      "keyword",
      "pattern",
      "formats",
      "validate$data",
      "func",
      "obj",
      "Error",
    ]);
    const 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.",
    };
    const deprecatedOptions = {
      ignoreKeywordsWithRef: "",
      jsPropertySyntax: "",
      unicode:
        '"minLength"/"maxLength" account for unicode characters by default.',
    };
    const MAX_EXPRESSION = 200;
    function requiredOptions(o) {
      var _a,
        _b,
        _c,
        _d,
        _e,
        _f,
        _g,
        _h,
        _j,
        _k,
        _l,
        _m,
        _o,
        _p,
        _q,
        _r,
        _s,
        _t,
        _u,
        _v,
        _w,
        _x,
        _y,
        _z,
        _0;
      const s = o.strict;
      const _optz =
        (_a = o.code) === null || _a === void 0
          ? void 0
          : _a.optimize;
      const optimize =
        _optz === true || _optz === void 0 ? 1 : _optz || 0;
      const regExp =
        (_c =
          (_b = o.code) === null || _b === void 0
            ? void 0
            : _b.regExp) !== null && _c !== void 0
          ? _c
          : defaultRegExp;
      const uriResolver =
        (_d = o.uriResolver) !== null && _d !== void 0
          ? _d
          : uri_1.default;
      return {
        strictSchema:
          (_f =
            (_e = o.strictSchema) !== null && _e !== void 0
              ? _e
              : s) !== null && _f !== void 0
            ? _f
            : true,
        strictNumbers:
          (_h =
            (_g = o.strictNumbers) !== null && _g !== void 0
              ? _g
              : s) !== null && _h !== void 0
            ? _h
            : true,
        strictTypes:
          (_k =
            (_j = o.strictTypes) !== null && _j !== void 0
              ? _j
              : s) !== null && _k !== void 0
            ? _k
            : "log",
        strictTuples:
          (_m =
            (_l = o.strictTuples) !== null && _l !== void 0
              ? _l
              : s) !== null && _m !== void 0
            ? _m
            : "log",
        strictRequired:
          (_p =
            (_o = o.strictRequired) !== null &&
            _o !== void 0
              ? _o
              : s) !== null && _p !== void 0
            ? _p
            : false,
        code: o.code
          ? {
              ...o.code,
              optimize,
              regExp,
            }
          : {
              optimize,
              regExp,
            },
        loopRequired:
          (_q = o.loopRequired) !== null && _q !== void 0
            ? _q
            : MAX_EXPRESSION,
        loopEnum:
          (_r = o.loopEnum) !== null && _r !== void 0
            ? _r
            : MAX_EXPRESSION,
        meta:
          (_s = o.meta) !== null && _s !== void 0
            ? _s
            : true,
        messages:
          (_t = o.messages) !== null && _t !== void 0
            ? _t
            : true,
        inlineRefs:
          (_u = o.inlineRefs) !== null && _u !== void 0
            ? _u
            : true,
        schemaId:
          (_v = o.schemaId) !== null && _v !== void 0
            ? _v
            : "$id",
        addUsedSchema:
          (_w = o.addUsedSchema) !== null && _w !== void 0
            ? _w
            : true,
        validateSchema:
          (_x = o.validateSchema) !== null && _x !== void 0
            ? _x
            : true,
        validateFormats:
          (_y = o.validateFormats) !== null && _y !== void 0
            ? _y
            : true,
        unicodeRegExp:
          (_z = o.unicodeRegExp) !== null && _z !== void 0
            ? _z
            : true,
        int32range:
          (_0 = o.int32range) !== null && _0 !== void 0
            ? _0
            : true,
        uriResolver,
      };
    }
    var Ajv = class {
      constructor(opts = {}) {
        this.schemas = {};
        this.refs = {};
        this.formats = Object.create(null);
        this._compilations = /* @__PURE__ */ new Set();
        this._loading = {};
        this._cache = /* @__PURE__ */ new Map();
        opts = this.opts = {
          ...opts,
          ...requiredOptions(opts),
        };
        const { es5, lines } = this.opts.code;
        this.scope = new codegen_2.ValueScope({
          scope: {},
          prefixes: EXT_SCOPE_NAMES,
          es5,
          lines,
        });
        this.logger = getLogger(opts.logger);
        const formatOpt = opts.validateFormats;
        opts.validateFormats = false;
        this.RULES = (0, rules_1.getRules)();
        checkOptions.call(
          this,
          removedOptions,
          opts,
          "NOT SUPPORTED",
        );
        checkOptions.call(
          this,
          deprecatedOptions,
          opts,
          "DEPRECATED",
          "warn",
        );
        this._metaOpts = getMetaSchemaOptions.call(this);
        if (opts.formats) addInitialFormats.call(this);
        this._addVocabularies();
        this._addDefaultMetaSchema();
        if (opts.keywords)
          addInitialKeywords.call(this, opts.keywords);
        if (typeof opts.meta == "object")
          this.addMetaSchema(opts.meta);
        addInitialSchemas.call(this);
        opts.validateFormats = formatOpt;
      }
      _addVocabularies() {
        this.addKeyword("$async");
      }
      _addDefaultMetaSchema() {
        const { $data, meta, schemaId } = this.opts;
        let _dataRefSchema = $dataRefSchema;
        if (schemaId === "id") {
          _dataRefSchema = { ...$dataRefSchema };
          _dataRefSchema.id = _dataRefSchema.$id;
          delete _dataRefSchema.$id;
        }
        if (meta && $data)
          this.addMetaSchema(
            _dataRefSchema,
            _dataRefSchema[schemaId],
            false,
          );
      }
      defaultMeta() {
        const { meta, schemaId } = this.opts;
        return (this.opts.defaultMeta =
          typeof meta == "object"
            ? meta[schemaId] || meta
            : void 0);
      }
      validate(schemaKeyRef, data) {
        let v;
        if (typeof schemaKeyRef == "string") {
          v = this.getSchema(schemaKeyRef);
          if (!v)
            throw new Error(
              `no schema with key or ref "${schemaKeyRef}"`,
            );
        } else v = this.compile(schemaKeyRef);
        const valid = v(data);
        if (!("$async" in v)) this.errors = v.errors;
        return valid;
      }
      compile(schema, _meta) {
        const sch = this._addSchema(schema, _meta);
        return sch.validate || this._compileSchemaEnv(sch);
      }
      compileAsync(schema, meta) {
        if (typeof this.opts.loadSchema != "function")
          throw new Error(
            "options.loadSchema should be a function",
          );
        const { loadSchema } = this.opts;
        return runCompileAsync.call(this, schema, meta);
        async function runCompileAsync(_schema, _meta) {
          await loadMetaSchema.call(this, _schema.$schema);
          const sch = this._addSchema(_schema, _meta);
          return (
            sch.validate || _compileAsync.call(this, sch)
          );
        }
        async function loadMetaSchema($ref) {
          if ($ref && !this.getSchema($ref))
            await runCompileAsync.call(
              this,
              { $ref },
              true,
            );
        }
        async function _compileAsync(sch) {
          try {
            return this._compileSchemaEnv(sch);
          } catch (e) {
            if (!(e instanceof ref_error_1.default))
              throw e;
            checkLoaded.call(this, e);
            await loadMissingSchema.call(
              this,
              e.missingSchema,
            );
            return _compileAsync.call(this, sch);
          }
        }
        function checkLoaded({
          missingSchema: ref,
          missingRef,
        }) {
          if (this.refs[ref])
            throw new Error(
              `AnySchema ${ref} is loaded but ${missingRef} cannot be resolved`,
            );
        }
        async function loadMissingSchema(ref) {
          const _schema = await _loadSchema.call(this, ref);
          if (!this.refs[ref])
            await loadMetaSchema.call(
              this,
              _schema.$schema,
            );
          if (!this.refs[ref])
            this.addSchema(_schema, ref, meta);
        }
        async function _loadSchema(ref) {
          const p = this._loading[ref];
          if (p) return p;
          try {
            return await (this._loading[ref] =
              loadSchema(ref));
          } finally {
            delete this._loading[ref];
          }
        }
      }
      addSchema(
        schema,
        key,
        _meta,
        _validateSchema = this.opts.validateSchema,
      ) {
        if (Array.isArray(schema)) {
          for (const sch of schema)
            this.addSchema(
              sch,
              void 0,
              _meta,
              _validateSchema,
            );
          return this;
        }
        let id;
        if (typeof schema === "object") {
          const { schemaId } = this.opts;
          id = schema[schemaId];
          if (id !== void 0 && typeof id != "string")
            throw new Error(
              `schema ${schemaId} must be string`,
            );
        }
        key = (0, resolve_1.normalizeId)(key || id);
        this._checkUnique(key);
        this.schemas[key] = this._addSchema(
          schema,
          _meta,
          key,
          _validateSchema,
          true,
        );
        return this;
      }
      addMetaSchema(
        schema,
        key,
        _validateSchema = this.opts.validateSchema,
      ) {
        this.addSchema(schema, key, true, _validateSchema);
        return this;
      }
      validateSchema(schema, throwOrLogError) {
        if (typeof schema == "boolean") return true;
        let $schema;
        $schema = schema.$schema;
        if (
          $schema !== void 0 &&
          typeof $schema != "string"
        )
          throw new Error("$schema must be a string");
        $schema =
          $schema ||
          this.opts.defaultMeta ||
          this.defaultMeta();
        if (!$schema) {
          this.logger.warn("meta-schema not available");
          this.errors = null;
          return true;
        }
        const valid = this.validate($schema, schema);
        if (!valid && throwOrLogError) {
          const message =
            "schema is invalid: " + this.errorsText();
          if (this.opts.validateSchema === "log")
            this.logger.error(message);
          else throw new Error(message);
        }
        return valid;
      }
      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);
      }
      removeSchema(schemaKeyRef) {
        if (schemaKeyRef instanceof RegExp) {
          this._removeAllSchemas(
            this.schemas,
            schemaKeyRef,
          );
          this._removeAllSchemas(this.refs, schemaKeyRef);
          return this;
        }
        switch (typeof schemaKeyRef) {
          case "undefined":
            this._removeAllSchemas(this.schemas);
            this._removeAllSchemas(this.refs);
            this._cache.clear();
            return this;
          case "string": {
            const sch = getSchEnv.call(this, schemaKeyRef);
            if (typeof sch == "object")
              this._cache.delete(sch.schema);
            delete this.schemas[schemaKeyRef];
            delete this.refs[schemaKeyRef];
            return this;
          }
          case "object": {
            const cacheKey = schemaKeyRef;
            this._cache.delete(cacheKey);
            let id = schemaKeyRef[this.opts.schemaId];
            if (id) {
              id = (0, resolve_1.normalizeId)(id);
              delete this.schemas[id];
              delete this.refs[id];
            }
            return this;
          }
          default:
            throw new Error(
              "ajv.removeSchema: invalid parameter",
            );
        }
      }
      addVocabulary(definitions) {
        for (const def of definitions) this.addKeyword(def);
        return this;
      }
      addKeyword(kwdOrDef, def) {
        let keyword;
        if (typeof kwdOrDef == "string") {
          keyword = kwdOrDef;
          if (typeof def == "object") {
            this.logger.warn(
              "these parameters are deprecated, see docs for addKeyword",
            );
            def.keyword = keyword;
          }
        } else if (
          typeof kwdOrDef == "object" &&
          def === 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;
      }
      removeKeyword(keyword) {
        const { RULES } = this;
        delete RULES.keywords[keyword];
        delete RULES.all[keyword];
        for (const group of RULES.rules) {
          const i = group.rules.findIndex(
            (rule) => rule.keyword === keyword,
          );
          if (i >= 0) group.rules.splice(i, 1);
        }
        return this;
      }
      addFormat(name, format) {
        if (typeof format == "string")
          format = new RegExp(format);
        this.formats[name] = format;
        return this;
      }
      errorsText(
        errors = this.errors,
        { separator = ", ", dataVar = "data" } = {},
      ) {
        if (!errors || errors.length === 0)
          return "No errors";
        return errors
          .map(
            (e) =>
              `${dataVar}${e.instancePath} ${e.message}`,
          )
          .reduce((text, msg) => text + separator + msg);
      }
      $dataMetaSchema(metaSchema, keywordsJsonPointers) {
        const rules = this.RULES.all;
        metaSchema = JSON.parse(JSON.stringify(metaSchema));
        for (const jsonPointer of keywordsJsonPointers) {
          const segments = jsonPointer.split("/").slice(1);
          let keywords = metaSchema;
          for (const seg of segments)
            keywords = keywords[seg];
          for (const key in rules) {
            const rule = rules[key];
            if (typeof rule != "object") continue;
            const { $data } = rule.definition;
            const schema = keywords[key];
            if ($data && schema)
              keywords[key] = schemaOrData(schema);
          }
        }
        return metaSchema;
      }
      _removeAllSchemas(schemas, regex) {
        for (const keyRef in schemas) {
          const sch = schemas[keyRef];
          if (!regex || regex.test(keyRef)) {
            if (typeof sch == "string")
              delete schemas[keyRef];
            else if (sch && !sch.meta) {
              this._cache.delete(sch.schema);
              delete schemas[keyRef];
            }
          }
        }
      }
      _addSchema(
        schema,
        meta,
        baseId,
        validateSchema = this.opts.validateSchema,
        addSchema = this.opts.addUsedSchema,
      ) {
        let id;
        const { schemaId } = this.opts;
        if (typeof schema == "object")
          id = schema[schemaId];
        else if (this.opts.jtd)
          throw new Error("schema must be object");
        else if (typeof schema != "boolean")
          throw new Error(
            "schema must be object or boolean",
          );
        let sch = this._cache.get(schema);
        if (sch !== void 0) return sch;
        baseId = (0, resolve_1.normalizeId)(id || baseId);
        const localRefs = resolve_1.getSchemaRefs.call(
          this,
          schema,
          baseId,
        );
        sch = new compile_1.SchemaEnv({
          schema,
          schemaId,
          meta,
          baseId,
          localRefs,
        });
        this._cache.set(sch.schema, sch);
        if (addSchema && !baseId.startsWith("#")) {
          if (baseId) this._checkUnique(baseId);
          this.refs[baseId] = sch;
        }
        if (validateSchema)
          this.validateSchema(schema, true);
        return sch;
      }
      _checkUnique(id) {
        if (this.schemas[id] || this.refs[id])
          throw new Error(
            `schema with key or id "${id}" already exists`,
          );
      }
      _compileSchemaEnv(sch) {
        if (sch.meta) this._compileMetaSchema(sch);
        else compile_1.compileSchema.call(this, sch);
        /* istanbul ignore if */
        if (!sch.validate)
          throw new Error("ajv implementation error");
        return sch.validate;
      }
      _compileMetaSchema(sch) {
        const currentOpts = this.opts;
        this.opts = this._metaOpts;
        try {
          compile_1.compileSchema.call(this, sch);
        } finally {
          this.opts = currentOpts;
        }
      }
    };
    Ajv.ValidationError = validation_error_1.default;
    Ajv.MissingRefError = ref_error_1.default;
    exports.default = Ajv;
    function checkOptions(
      checkOpts,
      options,
      msg,
      log = "error",
    ) {
      for (const key in checkOpts) {
        const opt = key;
        if (opt in options)
          this.logger[log](
            `${msg}: option ${key}. ${checkOpts[opt]}`,
          );
      }
    }
    function getSchEnv(keyRef) {
      keyRef = (0, resolve_1.normalizeId)(keyRef);
      return this.schemas[keyRef] || this.refs[keyRef];
    }
    function addInitialSchemas() {
      const optsSchemas = this.opts.schemas;
      if (!optsSchemas) return;
      if (Array.isArray(optsSchemas))
        this.addSchema(optsSchemas);
      else
        for (const key in optsSchemas)
          this.addSchema(optsSchemas[key], key);
    }
    function addInitialFormats() {
      for (const name in this.opts.formats) {
        const format = this.opts.formats[name];
        if (format) this.addFormat(name, format);
      }
    }
    function addInitialKeywords(defs) {
      if (Array.isArray(defs)) {
        this.addVocabulary(defs);
        return;
      }
      this.logger.warn(
        "keywords option as map is deprecated, pass array",
      );
      for (const keyword in defs) {
        const def = defs[keyword];
        if (!def.keyword) def.keyword = keyword;
        this.addKeyword(def);
      }
    }
    function getMetaSchemaOptions() {
      const metaOpts = { ...this.opts };
      for (const opt of META_IGNORE_OPTIONS)
        delete metaOpts[opt];
      return metaOpts;
    }
    const 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",
      );
    }
    const KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
    function checkKeyword(keyword, def) {
      const { RULES } = this;
      (0, util_1.eachItem)(keyword, (kwd) => {
        if (RULES.keywords[kwd])
          throw new Error(
            `Keyword ${kwd} is already defined`,
          );
        if (!KEYWORD_NAME.test(kwd))
          throw new Error(
            `Keyword ${kwd} has invalid name`,
          );
      });
      if (!def) return;
      if (
        def.$data &&
        !("code" in def || "validate" in def)
      )
        throw new Error(
          '$data keyword must have "code" or "validate" function',
        );
    }
    function addRule(keyword, definition, dataType) {
      var _a;
      const post =
        definition === null || definition === void 0
          ? void 0
          : definition.post;
      if (dataType && post)
        throw new Error(
          'keyword with "post" flag cannot have "type"',
        );
      const { RULES } = this;
      let ruleGroup = post
        ? RULES.post
        : RULES.rules.find(({ type: t }) => t === dataType);
      if (!ruleGroup) {
        ruleGroup = {
          type: dataType,
          rules: [],
        };
        RULES.rules.push(ruleGroup);
      }
      RULES.keywords[keyword] = true;
      if (!definition) return;
      const rule = {
        keyword,
        definition: {
          ...definition,
          type: (0, dataType_1.getJSONTypes)(
            definition.type,
          ),
          schemaType: (0, dataType_1.getJSONTypes)(
            definition.schemaType,
          ),
        },
      };
      if (definition.before)
        addBeforeRule.call(
          this,
          ruleGroup,
          rule,
          definition.before,
        );
      else ruleGroup.rules.push(rule);
      RULES.all[keyword] = rule;
      (_a = definition.implements) === null ||
        _a === void 0 ||
        _a.forEach((kwd) => this.addKeyword(kwd));
    }
    function addBeforeRule(ruleGroup, rule, before) {
      const i = ruleGroup.rules.findIndex(
        (_rule) => _rule.keyword === before,
      );
      if (i >= 0) ruleGroup.rules.splice(i, 0, rule);
      else {
        ruleGroup.rules.push(rule);
        this.logger.warn(`rule ${before} is not defined`);
      }
    }
    function keywordMetaschema(def) {
      let { metaSchema } = def;
      if (metaSchema === void 0) return;
      if (def.$data && this.opts.$data)
        metaSchema = schemaOrData(metaSchema);
      def.validateSchema = this.compile(metaSchema, true);
    }
    const $dataRef = {
      $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#",
    };
    function schemaOrData(schema) {
      return { anyOf: [schema, $dataRef] };
    }
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/core/id.js
var require_id = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.default = {
      keyword: "id",
      code() {
        throw new Error(
          'NOT SUPPORTED: keyword "id", use "$id" for schema ID',
        );
      },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/core/ref.js
var require_ref = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.callRef = exports.getValidate = void 0;
    const ref_error_1 = require_ref_error();
    const code_1 = require_code();
    const codegen_1 = require_codegen();
    const names_1 = require_names();
    const compile_1 = require_compile();
    const util_1 = require_util();
    const def = {
      keyword: "$ref",
      schemaType: "string",
      code(cxt) {
        const { gen, schema: $ref, it } = cxt;
        const {
          baseId,
          schemaEnv: env,
          validateName,
          opts,
          self,
        } = it;
        const { root } = env;
        if (
          ($ref === "#" || $ref === "#/") &&
          baseId === root.baseId
        )
          return callRootRef();
        const schOrEnv = compile_1.resolveRef.call(
          self,
          root,
          baseId,
          $ref,
        );
        if (schOrEnv === void 0)
          throw new ref_error_1.default(
            it.opts.uriResolver,
            baseId,
            $ref,
          );
        if (schOrEnv instanceof compile_1.SchemaEnv)
          return callValidate(schOrEnv);
        return inlineRefSchema(schOrEnv);
        function callRootRef() {
          if (env === root)
            return callRef(
              cxt,
              validateName,
              env,
              env.$async,
            );
          const rootName = gen.scopeValue("root", {
            ref: root,
          });
          return callRef(
            cxt,
            (0, codegen_1._)`${rootName}.validate`,
            root,
            root.$async,
          );
        }
        function callValidate(sch) {
          callRef(
            cxt,
            getValidate(cxt, sch),
            sch,
            sch.$async,
          );
        }
        function inlineRefSchema(sch) {
          const schName = gen.scopeValue(
            "schema",
            opts.code.source === true
              ? {
                  ref: sch,
                  code: (0, codegen_1.stringify)(sch),
                }
              : { ref: sch },
          );
          const valid = gen.name("valid");
          const schCxt = cxt.subschema(
            {
              schema: sch,
              dataTypes: [],
              schemaPath: codegen_1.nil,
              topSchemaRef: schName,
              errSchemaPath: $ref,
            },
            valid,
          );
          cxt.mergeEvaluated(schCxt);
          cxt.ok(valid);
        }
      },
    };
    function getValidate(cxt, sch) {
      const { gen } = cxt;
      return sch.validate
        ? gen.scopeValue("validate", { ref: sch.validate })
        : (0,
          codegen_1._)`${gen.scopeValue("wrapper", { ref: sch })}.validate`;
    }
    exports.getValidate = getValidate;
    function callRef(cxt, v, sch, $async) {
      const { gen, it } = cxt;
      const { allErrors, schemaEnv: env, opts } = it;
      const passCxt = opts.passContext
        ? names_1.default.this
        : codegen_1.nil;
      if ($async) callAsyncRef();
      else callSyncRef();
      function callAsyncRef() {
        if (!env.$async)
          throw new Error(
            "async schema referenced by sync schema",
          );
        const valid = gen.let("valid");
        gen.try(
          () => {
            gen.code(
              (0,
              codegen_1._)`await ${(0, code_1.callValidateCode)(cxt, v, passCxt)}`,
            );
            addEvaluatedFrom(v);
            if (!allErrors) gen.assign(valid, true);
          },
          (e) => {
            gen.if(
              (0,
              codegen_1._)`!(${e} instanceof ${it.ValidationError})`,
              () => gen.throw(e),
            );
            addErrorsFrom(e);
            if (!allErrors) gen.assign(valid, false);
          },
        );
        cxt.ok(valid);
      }
      function callSyncRef() {
        cxt.result(
          (0, code_1.callValidateCode)(cxt, v, passCxt),
          () => addEvaluatedFrom(v),
          () => addErrorsFrom(v),
        );
      }
      function addErrorsFrom(source) {
        const errs = (0, codegen_1._)`${source}.errors`;
        gen.assign(
          names_1.default.vErrors,
          (0,
          codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`,
        );
        gen.assign(
          names_1.default.errors,
          (0,
          codegen_1._)`${names_1.default.vErrors}.length`,
        );
      }
      function addEvaluatedFrom(source) {
        var _a;
        if (!it.opts.unevaluated) return;
        const schEvaluated =
          (_a =
            sch === null || sch === void 0
              ? void 0
              : sch.validate) === null || _a === void 0
            ? void 0
            : _a.evaluated;
        if (it.props !== true) {
          if (schEvaluated && !schEvaluated.dynamicProps) {
            if (schEvaluated.props !== void 0)
              it.props = util_1.mergeEvaluated.props(
                gen,
                schEvaluated.props,
                it.props,
              );
          } else {
            const props = gen.var(
              "props",
              (0, codegen_1._)`${source}.evaluated.props`,
            );
            it.props = util_1.mergeEvaluated.props(
              gen,
              props,
              it.props,
              codegen_1.Name,
            );
          }
        }
        if (it.items !== true) {
          if (schEvaluated && !schEvaluated.dynamicItems) {
            if (schEvaluated.items !== void 0)
              it.items = util_1.mergeEvaluated.items(
                gen,
                schEvaluated.items,
                it.items,
              );
          } else {
            const items = gen.var(
              "items",
              (0, codegen_1._)`${source}.evaluated.items`,
            );
            it.items = util_1.mergeEvaluated.items(
              gen,
              items,
              it.items,
              codegen_1.Name,
            );
          }
        }
      }
    }
    exports.callRef = callRef;
    exports.default = def;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/core/index.js
var require_core = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const id_1 = require_id();
    const ref_1 = require_ref();
    exports.default = [
      "$schema",
      "$id",
      "$defs",
      "$vocabulary",
      { keyword: "$comment" },
      "definitions",
      id_1.default,
      ref_1.default,
    ];
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitNumber.js
var require_limitNumber = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    const ops = codegen_1.operators;
    const 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,
      },
    };
    exports.default = {
      keyword: Object.keys(KWDs),
      type: "number",
      schemaType: "number",
      $data: true,
      error: {
        message: ({ keyword, schemaCode }) =>
          (0,
          codegen_1.str)`must be ${KWDs[keyword].okStr} ${schemaCode}`,
        params: ({ keyword, schemaCode }) =>
          (0,
          codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`,
      },
      code(cxt) {
        const { keyword, data, schemaCode } = cxt;
        cxt.fail$data(
          (0,
          codegen_1._)`${data} ${KWDs[keyword].fail} ${schemaCode} || isNaN(${data})`,
        );
      },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/multipleOf.js
var require_multipleOf = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    exports.default = {
      keyword: "multipleOf",
      type: "number",
      schemaType: "number",
      $data: true,
      error: {
        message: ({ schemaCode }) =>
          (0,
          codegen_1.str)`must be multiple of ${schemaCode}`,
        params: ({ schemaCode }) =>
          (0, codegen_1._)`{multipleOf: ${schemaCode}}`,
      },
      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}))`,
        );
      },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/ucs2length.js
var require_ucs2length = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    function ucs2length(str) {
      const len = str.length;
      let length = 0;
      let pos = 0;
      let value;
      while (pos < len) {
        length++;
        value = str.charCodeAt(pos++);
        if (value >= 55296 && value <= 56319 && pos < len) {
          value = str.charCodeAt(pos);
          if ((value & 64512) === 56320) pos++;
        }
      }
      return length;
    }
    exports.default = ucs2length;
    ucs2length.code =
      'require("ajv/dist/runtime/ucs2length").default';
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitLength.js
var require_limitLength = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    const util_1 = require_util();
    const ucs2length_1 = require_ucs2length();
    exports.default = {
      keyword: ["maxLength", "minLength"],
      type: "string",
      schemaType: "number",
      $data: true,
      error: {
        message({ keyword, schemaCode }) {
          const comp =
            keyword === "maxLength" ? "more" : "fewer";
          return (0,
          codegen_1.str)`must NOT have ${comp} than ${schemaCode} characters`;
        },
        params: ({ schemaCode }) =>
          (0, codegen_1._)`{limit: ${schemaCode}}`,
      },
      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}`,
        );
      },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/pattern.js
var require_pattern = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const code_1 = require_code();
    const util_1 = require_util();
    const codegen_1 = require_codegen();
    exports.default = {
      keyword: "pattern",
      type: "string",
      schemaType: "string",
      $data: true,
      error: {
        message: ({ schemaCode }) =>
          (0,
          codegen_1.str)`must match pattern "${schemaCode}"`,
        params: ({ schemaCode }) =>
          (0, codegen_1._)`{pattern: ${schemaCode}}`,
      },
      code(cxt) {
        const { gen, data, $data, schema, schemaCode, it } =
          cxt;
        const u = it.opts.unicodeRegExp ? "u" : "";
        if ($data) {
          const { regExp } = it.opts.code;
          const regExpCode =
            regExp.code === "new RegExp"
              ? (0, codegen_1._)`new RegExp`
              : (0, util_1.useFunc)(gen, regExp);
          const valid = gen.let("valid");
          gen.try(
            () =>
              gen.assign(
                valid,
                (0,
                codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`,
              ),
            () => gen.assign(valid, false),
          );
          cxt.fail$data((0, codegen_1._)`!${valid}`);
        } else {
          const regExp = (0, code_1.usePattern)(
            cxt,
            schema,
          );
          cxt.fail$data(
            (0, codegen_1._)`!${regExp}.test(${data})`,
          );
        }
      },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitProperties.js
var require_limitProperties = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    exports.default = {
      keyword: ["maxProperties", "minProperties"],
      type: "object",
      schemaType: "number",
      $data: true,
      error: {
        message({ keyword, schemaCode }) {
          const comp =
            keyword === "maxProperties" ? "more" : "fewer";
          return (0,
          codegen_1.str)`must NOT have ${comp} than ${schemaCode} properties`;
        },
        params: ({ schemaCode }) =>
          (0, codegen_1._)`{limit: ${schemaCode}}`,
      },
      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}`,
        );
      },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/required.js
var require_required = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const code_1 = require_code();
    const codegen_1 = require_codegen();
    const util_1 = require_util();
    exports.default = {
      keyword: "required",
      type: "object",
      schemaType: "array",
      $data: true,
      error: {
        message: ({ params: { missingProperty } }) =>
          (0,
          codegen_1.str)`must have required property '${missingProperty}'`,
        params: ({ params: { missingProperty } }) =>
          (0,
          codegen_1._)`{missingProperty: ${missingProperty}}`,
      },
      code(cxt) {
        const { gen, schema, schemaCode, data, $data, it } =
          cxt;
        const { opts } = it;
        if (!$data && schema.length === 0) return;
        const useLoop = schema.length >= opts.loopRequired;
        if (it.allErrors) allErrorsMode();
        else exitOnErrorMode();
        if (opts.strictRequired) {
          const props = cxt.parentSchema.properties;
          const { definedProperties } = cxt.it;
          for (const requiredKey of schema)
            if (
              (props === null || props === void 0
                ? void 0
                : props[requiredKey]) === void 0 &&
              !definedProperties.has(requiredKey)
            ) {
              const msg = `required property "${requiredKey}" is not defined at "${it.schemaEnv.baseId + it.errSchemaPath}" (strictRequired)`;
              (0, util_1.checkStrictMode)(
                it,
                msg,
                it.opts.strictRequired,
              );
            }
        }
        function allErrorsMode() {
          if (useLoop || $data)
            cxt.block$data(codegen_1.nil, loopAllRequired);
          else
            for (const prop of schema)
              (0, code_1.checkReportMissingProp)(cxt, prop);
        }
        function exitOnErrorMode() {
          const missing = gen.let("missing");
          if (useLoop || $data) {
            const valid = gen.let("valid", true);
            cxt.block$data(valid, () =>
              loopUntilMissing(missing, valid),
            );
            cxt.ok(valid);
          } else {
            gen.if(
              (0, code_1.checkMissingProp)(
                cxt,
                schema,
                missing,
              ),
            );
            (0, code_1.reportMissingProp)(cxt, missing);
            gen.else();
          }
        }
        function loopAllRequired() {
          gen.forOf("prop", schemaCode, (prop) => {
            cxt.setParams({ missingProperty: prop });
            gen.if(
              (0, code_1.noPropertyInData)(
                gen,
                data,
                prop,
                opts.ownProperties,
              ),
              () => cxt.error(),
            );
          });
        }
        function loopUntilMissing(missing, valid) {
          cxt.setParams({ missingProperty: missing });
          gen.forOf(
            missing,
            schemaCode,
            () => {
              gen.assign(
                valid,
                (0, code_1.propertyInData)(
                  gen,
                  data,
                  missing,
                  opts.ownProperties,
                ),
              );
              gen.if((0, codegen_1.not)(valid), () => {
                cxt.error();
                gen.break();
              });
            },
            codegen_1.nil,
          );
        }
      },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitItems.js
var require_limitItems = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    exports.default = {
      keyword: ["maxItems", "minItems"],
      type: "array",
      schemaType: "number",
      $data: true,
      error: {
        message({ keyword, schemaCode }) {
          const comp =
            keyword === "maxItems" ? "more" : "fewer";
          return (0,
          codegen_1.str)`must NOT have ${comp} than ${schemaCode} items`;
        },
        params: ({ schemaCode }) =>
          (0, codegen_1._)`{limit: ${schemaCode}}`,
      },
      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}`,
        );
      },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/equal.js
var require_equal = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const equal = require_fast_deep_equal();
    equal.code =
      'require("ajv/dist/runtime/equal").default';
    exports.default = equal;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/uniqueItems.js
var require_uniqueItems = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const dataType_1 = require_dataType();
    const codegen_1 = require_codegen();
    const util_1 = require_util();
    const equal_1 = require_equal();
    exports.default = {
      keyword: "uniqueItems",
      type: "array",
      schemaType: "boolean",
      $data: true,
      error: {
        message: ({ params: { i, j } }) =>
          (0,
          codegen_1.str)`must NOT have duplicate items (items ## ${j} and ${i} are identical)`,
        params: ({ params: { i, j } }) =>
          (0, codegen_1._)`{i: ${i}, j: ${j}}`,
      },
      code(cxt) {
        const {
          gen,
          data,
          $data,
          schema,
          parentSchema,
          schemaCode,
          it,
        } = cxt;
        if (!$data && !schema) return;
        const valid = gen.let("valid");
        const itemTypes = parentSchema.items
          ? (0, dataType_1.getSchemaTypes)(
              parentSchema.items,
            )
          : [];
        cxt.block$data(
          valid,
          validateUniqueItems,
          (0, codegen_1._)`${schemaCode} === false`,
        );
        cxt.ok(valid);
        function validateUniqueItems() {
          const i = gen.let(
            "i",
            (0, codegen_1._)`${data}.length`,
          );
          const j = gen.let("j");
          cxt.setParams({
            i,
            j,
          });
          gen.assign(valid, true);
          gen.if((0, codegen_1._)`${i} > 1`, () =>
            (canOptimize() ? loopN : loopN2)(i, j),
          );
        }
        function canOptimize() {
          return (
            itemTypes.length > 0 &&
            !itemTypes.some(
              (t) => t === "object" || t === "array",
            )
          );
        }
        function loopN(i, j) {
          const item = gen.name("item");
          const wrongType = (0, dataType_1.checkDataTypes)(
            itemTypes,
            item,
            it.opts.strictNumbers,
            dataType_1.DataType.Wrong,
          );
          const indices = gen.const(
            "indices",
            (0, codegen_1._)`{}`,
          );
          gen.for((0, codegen_1._)`;${i}--;`, () => {
            gen.let(item, (0, codegen_1._)`${data}[${i}]`);
            gen.if(wrongType, (0, codegen_1._)`continue`);
            if (itemTypes.length > 1)
              gen.if(
                (0,
                codegen_1._)`typeof ${item} == "string"`,
                (0, codegen_1._)`${item} += "_"`,
              );
            gen
              .if(
                (0,
                codegen_1._)`typeof ${indices}[${item}] == "number"`,
                () => {
                  gen.assign(
                    j,
                    (0, codegen_1._)`${indices}[${item}]`,
                  );
                  cxt.error();
                  gen.assign(valid, false).break();
                },
              )
              .code(
                (0,
                codegen_1._)`${indices}[${item}] = ${i}`,
              );
          });
        }
        function loopN2(i, j) {
          const eql = (0, util_1.useFunc)(
            gen,
            equal_1.default,
          );
          const outer = gen.name("outer");
          gen
            .label(outer)
            .for((0, codegen_1._)`;${i}--;`, () =>
              gen.for(
                (0, codegen_1._)`${j} = ${i}; ${j}--;`,
                () =>
                  gen.if(
                    (0,
                    codegen_1._)`${eql}(${data}[${i}], ${data}[${j}])`,
                    () => {
                      cxt.error();
                      gen.assign(valid, false).break(outer);
                    },
                  ),
              ),
            );
        }
      },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/const.js
var require_const = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    const util_1 = require_util();
    const equal_1 = require_equal();
    exports.default = {
      keyword: "const",
      $data: true,
      error: {
        message: "must be equal to constant",
        params: ({ schemaCode }) =>
          (0, codegen_1._)`{allowedValue: ${schemaCode}}`,
      },
      code(cxt) {
        const { gen, data, $data, schemaCode, schema } =
          cxt;
        if ($data || (schema && typeof schema == "object"))
          cxt.fail$data(
            (0,
            codegen_1._)`!${(0, util_1.useFunc)(gen, equal_1.default)}(${data}, ${schemaCode})`,
          );
        else
          cxt.fail((0, codegen_1._)`${schema} !== ${data}`);
      },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/enum.js
var require_enum = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    const util_1 = require_util();
    const equal_1 = require_equal();
    exports.default = {
      keyword: "enum",
      schemaType: "array",
      $data: true,
      error: {
        message:
          "must be equal to one of the allowed values",
        params: ({ schemaCode }) =>
          (0, codegen_1._)`{allowedValues: ${schemaCode}}`,
      },
      code(cxt) {
        const { gen, data, $data, schema, schemaCode, it } =
          cxt;
        if (!$data && schema.length === 0)
          throw new Error("enum must have non-empty array");
        const useLoop = schema.length >= it.opts.loopEnum;
        let eql;
        const getEql = () =>
          eql !== null && eql !== void 0
            ? eql
            : (eql = (0, util_1.useFunc)(
                gen,
                equal_1.default,
              ));
        let valid;
        if (useLoop || $data) {
          valid = gen.let("valid");
          cxt.block$data(valid, loopEnum);
        } else {
          /* istanbul ignore if */
          if (!Array.isArray(schema))
            throw new Error("ajv implementation error");
          const vSchema = gen.const("vSchema", schemaCode);
          valid = (0, codegen_1.or)(
            ...schema.map((_x, i) => equalCode(vSchema, i)),
          );
        }
        cxt.pass(valid);
        function loopEnum() {
          gen.assign(valid, false);
          gen.forOf("v", schemaCode, (v) =>
            gen.if(
              (0, codegen_1._)`${getEql()}(${data}, ${v})`,
              () => gen.assign(valid, true).break(),
            ),
          );
        }
        function equalCode(vSchema, i) {
          const sch = schema[i];
          return typeof sch === "object" && sch !== null
            ? (0,
              codegen_1._)`${getEql()}(${data}, ${vSchema}[${i}])`
            : (0, codegen_1._)`${data} === ${sch}`;
        }
      },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/index.js
var require_validation = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const limitNumber_1 = require_limitNumber();
    const multipleOf_1 = require_multipleOf();
    const limitLength_1 = require_limitLength();
    const pattern_1 = require_pattern();
    const limitProperties_1 = require_limitProperties();
    const required_1 = require_required();
    const limitItems_1 = require_limitItems();
    const uniqueItems_1 = require_uniqueItems();
    const const_1 = require_const();
    const enum_1 = require_enum();
    exports.default = [
      limitNumber_1.default,
      multipleOf_1.default,
      limitLength_1.default,
      pattern_1.default,
      limitProperties_1.default,
      required_1.default,
      limitItems_1.default,
      uniqueItems_1.default,
      {
        keyword: "type",
        schemaType: ["string", "array"],
      },
      {
        keyword: "nullable",
        schemaType: "boolean",
      },
      const_1.default,
      enum_1.default,
    ];
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/additionalItems.js
var require_additionalItems = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.validateAdditionalItems = void 0;
    const codegen_1 = require_codegen();
    const util_1 = require_util();
    const def = {
      keyword: "additionalItems",
      type: "array",
      schemaType: ["boolean", "object"],
      before: "uniqueItems",
      error: {
        message: ({ params: { len } }) =>
          (0,
          codegen_1.str)`must NOT have more than ${len} items`,
        params: ({ params: { len } }) =>
          (0, codegen_1._)`{limit: ${len}}`,
      },
      code(cxt) {
        const { parentSchema, it } = cxt;
        const { items } = parentSchema;
        if (!Array.isArray(items)) {
          (0, util_1.checkStrictMode)(
            it,
            '"additionalItems" is ignored when "items" is not an array of schemas',
          );
          return;
        }
        validateAdditionalItems(cxt, items);
      },
    };
    function validateAdditionalItems(cxt, items) {
      const { gen, schema, data, keyword, it } = cxt;
      it.items = true;
      const len = gen.const(
        "len",
        (0, codegen_1._)`${data}.length`,
      );
      if (schema === false) {
        cxt.setParams({ len: items.length });
        cxt.pass(
          (0, codegen_1._)`${len} <= ${items.length}`,
        );
      } else if (
        typeof schema == "object" &&
        !(0, util_1.alwaysValidSchema)(it, schema)
      ) {
        const valid = gen.var(
          "valid",
          (0, codegen_1._)`${len} <= ${items.length}`,
        );
        gen.if((0, codegen_1.not)(valid), () =>
          validateItems(valid),
        );
        cxt.ok(valid);
      }
      function validateItems(valid) {
        gen.forRange("i", items.length, len, (i) => {
          cxt.subschema(
            {
              keyword,
              dataProp: i,
              dataPropType: util_1.Type.Num,
            },
            valid,
          );
          if (!it.allErrors)
            gen.if((0, codegen_1.not)(valid), () =>
              gen.break(),
            );
        });
      }
    }
    exports.validateAdditionalItems =
      validateAdditionalItems;
    exports.default = def;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/items.js
var require_items = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.validateTuple = void 0;
    const codegen_1 = require_codegen();
    const util_1 = require_util();
    const code_1 = require_code();
    const def = {
      keyword: "items",
      type: "array",
      schemaType: ["object", "array", "boolean"],
      before: "uniqueItems",
      code(cxt) {
        const { schema, it } = cxt;
        if (Array.isArray(schema))
          return validateTuple(
            cxt,
            "additionalItems",
            schema,
          );
        it.items = true;
        if ((0, util_1.alwaysValidSchema)(it, schema))
          return;
        cxt.ok((0, code_1.validateArray)(cxt));
      },
    };
    function validateTuple(
      cxt,
      extraItems,
      schArr = cxt.schema,
    ) {
      const { gen, parentSchema, data, keyword, it } = cxt;
      checkStrictTuple(parentSchema);
      if (
        it.opts.unevaluated &&
        schArr.length &&
        it.items !== true
      )
        it.items = util_1.mergeEvaluated.items(
          gen,
          schArr.length,
          it.items,
        );
      const valid = gen.name("valid");
      const len = gen.const(
        "len",
        (0, codegen_1._)`${data}.length`,
      );
      schArr.forEach((sch, i) => {
        if ((0, util_1.alwaysValidSchema)(it, sch)) return;
        gen.if((0, codegen_1._)`${len} > ${i}`, () =>
          cxt.subschema(
            {
              keyword,
              schemaProp: i,
              dataProp: i,
            },
            valid,
          ),
        );
        cxt.ok(valid);
      });
      function checkStrictTuple(sch) {
        const { opts, errSchemaPath } = it;
        const l = schArr.length;
        const fullTuple =
          l === sch.minItems &&
          (l === sch.maxItems || sch[extraItems] === false);
        if (opts.strictTuples && !fullTuple) {
          const msg = `"${keyword}" is ${l}-tuple, but minItems or maxItems/${extraItems} are not specified or different at path "${errSchemaPath}"`;
          (0, util_1.checkStrictMode)(
            it,
            msg,
            opts.strictTuples,
          );
        }
      }
    }
    exports.validateTuple = validateTuple;
    exports.default = def;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/prefixItems.js
var require_prefixItems = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const items_1 = require_items();
    exports.default = {
      keyword: "prefixItems",
      type: "array",
      schemaType: ["array"],
      before: "uniqueItems",
      code: (cxt) =>
        (0, items_1.validateTuple)(cxt, "items"),
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/items2020.js
var require_items2020 = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    const util_1 = require_util();
    const code_1 = require_code();
    const additionalItems_1 = require_additionalItems();
    exports.default = {
      keyword: "items",
      type: "array",
      schemaType: ["object", "boolean"],
      before: "uniqueItems",
      error: {
        message: ({ params: { len } }) =>
          (0,
          codegen_1.str)`must NOT have more than ${len} items`,
        params: ({ params: { len } }) =>
          (0, codegen_1._)`{limit: ${len}}`,
      },
      code(cxt) {
        const { schema, parentSchema, it } = cxt;
        const { prefixItems } = parentSchema;
        it.items = true;
        if ((0, util_1.alwaysValidSchema)(it, schema))
          return;
        if (prefixItems)
          (0, additionalItems_1.validateAdditionalItems)(
            cxt,
            prefixItems,
          );
        else cxt.ok((0, code_1.validateArray)(cxt));
      },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/contains.js
var require_contains = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    const util_1 = require_util();
    exports.default = {
      keyword: "contains",
      type: "array",
      schemaType: ["object", "boolean"],
      before: "uniqueItems",
      trackErrors: true,
      error: {
        message: ({ params: { min, max } }) =>
          max === void 0
            ? (0,
              codegen_1.str)`must contain at least ${min} valid item(s)`
            : (0,
              codegen_1.str)`must contain at least ${min} and no more than ${max} valid item(s)`,
        params: ({ params: { min, max } }) =>
          max === void 0
            ? (0, codegen_1._)`{minContains: ${min}}`
            : (0,
              codegen_1._)`{minContains: ${min}, maxContains: ${max}}`,
      },
      code(cxt) {
        const { gen, schema, parentSchema, data, it } = cxt;
        let min;
        let max;
        const { minContains, maxContains } = parentSchema;
        if (it.opts.next) {
          min = minContains === void 0 ? 1 : minContains;
          max = maxContains;
        } else min = 1;
        const len = gen.const(
          "len",
          (0, codegen_1._)`${data}.length`,
        );
        cxt.setParams({
          min,
          max,
        });
        if (max === void 0 && min === 0) {
          (0, util_1.checkStrictMode)(
            it,
            `"minContains" == 0 without "maxContains": "contains" keyword ignored`,
          );
          return;
        }
        if (max !== void 0 && min > max) {
          (0, util_1.checkStrictMode)(
            it,
            `"minContains" > "maxContains" is always invalid`,
          );
          cxt.fail();
          return;
        }
        if ((0, util_1.alwaysValidSchema)(it, schema)) {
          let cond = (0, codegen_1._)`${len} >= ${min}`;
          if (max !== void 0)
            cond = (0,
            codegen_1._)`${cond} && ${len} <= ${max}`;
          cxt.pass(cond);
          return;
        }
        it.items = true;
        const valid = gen.name("valid");
        if (max === void 0 && min === 1)
          validateItems(valid, () =>
            gen.if(valid, () => gen.break()),
          );
        else if (min === 0) {
          gen.let(valid, true);
          if (max !== void 0)
            gen.if(
              (0, codegen_1._)`${data}.length > 0`,
              validateItemsWithCount,
            );
        } else {
          gen.let(valid, false);
          validateItemsWithCount();
        }
        cxt.result(valid, () => cxt.reset());
        function validateItemsWithCount() {
          const schValid = gen.name("_valid");
          const count = gen.let("count", 0);
          validateItems(schValid, () =>
            gen.if(schValid, () => checkLimits(count)),
          );
        }
        function validateItems(_valid, block) {
          gen.forRange("i", 0, len, (i) => {
            cxt.subschema(
              {
                keyword: "contains",
                dataProp: i,
                dataPropType: util_1.Type.Num,
                compositeRule: true,
              },
              _valid,
            );
            block();
          });
        }
        function checkLimits(count) {
          gen.code((0, codegen_1._)`${count}++`);
          if (max === void 0)
            gen.if(
              (0, codegen_1._)`${count} >= ${min}`,
              () => gen.assign(valid, true).break(),
            );
          else {
            gen.if(
              (0, codegen_1._)`${count} > ${max}`,
              () => gen.assign(valid, false).break(),
            );
            if (min === 1) gen.assign(valid, true);
            else
              gen.if(
                (0, codegen_1._)`${count} >= ${min}`,
                () => gen.assign(valid, true),
              );
          }
        }
      },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/dependencies.js
var require_dependencies = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.validateSchemaDeps =
      exports.validatePropertyDeps =
      exports.error =
        void 0;
    const codegen_1 = require_codegen();
    const util_1 = require_util();
    const code_1 = require_code();
    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}}`,
    };
    const def = {
      keyword: "dependencies",
      type: "object",
      schemaType: "object",
      error: exports.error,
      code(cxt) {
        const [propDeps, schDeps] = splitDependencies(cxt);
        validatePropertyDeps(cxt, propDeps);
        validateSchemaDeps(cxt, schDeps);
      },
    };
    function splitDependencies({ schema }) {
      const propertyDeps = {};
      const schemaDeps = {};
      for (const key in schema) {
        if (key === "__proto__") continue;
        const deps = Array.isArray(schema[key])
          ? propertyDeps
          : schemaDeps;
        deps[key] = schema[key];
      }
      return [propertyDeps, schemaDeps];
    }
    function validatePropertyDeps(
      cxt,
      propertyDeps = cxt.schema,
    ) {
      const { gen, data, it } = cxt;
      if (Object.keys(propertyDeps).length === 0) return;
      const missing = gen.let("missing");
      for (const prop in propertyDeps) {
        const deps = propertyDeps[prop];
        if (deps.length === 0) continue;
        const hasProperty = (0, code_1.propertyInData)(
          gen,
          data,
          prop,
          it.opts.ownProperties,
        );
        cxt.setParams({
          property: prop,
          depsCount: deps.length,
          deps: deps.join(", "),
        });
        if (it.allErrors)
          gen.if(hasProperty, () => {
            for (const depProp of deps)
              (0, code_1.checkReportMissingProp)(
                cxt,
                depProp,
              );
          });
        else {
          gen.if(
            (0,
            codegen_1._)`${hasProperty} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`,
          );
          (0, code_1.reportMissingProp)(cxt, missing);
          gen.else();
        }
      }
    }
    exports.validatePropertyDeps = validatePropertyDeps;
    function validateSchemaDeps(
      cxt,
      schemaDeps = cxt.schema,
    ) {
      const { gen, data, keyword, it } = cxt;
      const valid = gen.name("valid");
      for (const prop in schemaDeps) {
        if (
          (0, util_1.alwaysValidSchema)(
            it,
            schemaDeps[prop],
          )
        )
          continue;
        gen.if(
          (0, code_1.propertyInData)(
            gen,
            data,
            prop,
            it.opts.ownProperties,
          ),
          () => {
            const schCxt = cxt.subschema(
              {
                keyword,
                schemaProp: prop,
              },
              valid,
            );
            cxt.mergeValidEvaluated(schCxt, valid);
          },
          () => gen.var(valid, true),
        );
        cxt.ok(valid);
      }
    }
    exports.validateSchemaDeps = validateSchemaDeps;
    exports.default = def;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/propertyNames.js
var require_propertyNames = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    const util_1 = require_util();
    exports.default = {
      keyword: "propertyNames",
      type: "object",
      schemaType: ["object", "boolean"],
      error: {
        message: "property name must be valid",
        params: ({ params }) =>
          (0,
          codegen_1._)`{propertyName: ${params.propertyName}}`,
      },
      code(cxt) {
        const { gen, schema, data, it } = cxt;
        if ((0, util_1.alwaysValidSchema)(it, schema))
          return;
        const valid = gen.name("valid");
        gen.forIn("key", data, (key) => {
          cxt.setParams({ propertyName: key });
          cxt.subschema(
            {
              keyword: "propertyNames",
              data: key,
              dataTypes: ["string"],
              propertyName: key,
              compositeRule: true,
            },
            valid,
          );
          gen.if((0, codegen_1.not)(valid), () => {
            cxt.error(true);
            if (!it.allErrors) gen.break();
          });
        });
        cxt.ok(valid);
      },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js
var require_additionalProperties =
  /* @__PURE__ */ __commonJSMin((exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const code_1 = require_code();
    const codegen_1 = require_codegen();
    const names_1 = require_names();
    const util_1 = require_util();
    exports.default = {
      keyword: "additionalProperties",
      type: ["object"],
      schemaType: ["boolean", "object"],
      allowUndefined: true,
      trackErrors: true,
      error: {
        message: "must NOT have additional properties",
        params: ({ params }) =>
          (0,
          codegen_1._)`{additionalProperty: ${params.additionalProperty}}`,
      },
      code(cxt) {
        const {
          gen,
          schema,
          parentSchema,
          data,
          errsCount,
          it,
        } = cxt;
        /* istanbul ignore if */
        if (!errsCount)
          throw new Error("ajv implementation error");
        const { allErrors, opts } = it;
        it.props = true;
        if (
          opts.removeAdditional !== "all" &&
          (0, util_1.alwaysValidSchema)(it, schema)
        )
          return;
        const props = (0, code_1.allSchemaProperties)(
          parentSchema.properties,
        );
        const patProps = (0, code_1.allSchemaProperties)(
          parentSchema.patternProperties,
        );
        checkAdditionalProperties();
        cxt.ok(
          (0,
          codegen_1._)`${errsCount} === ${names_1.default.errors}`,
        );
        function checkAdditionalProperties() {
          gen.forIn("key", data, (key) => {
            if (!props.length && !patProps.length)
              additionalPropertyCode(key);
            else
              gen.if(isAdditional(key), () =>
                additionalPropertyCode(key),
              );
          });
        }
        function isAdditional(key) {
          let definedProp;
          if (props.length > 8) {
            const propsSchema = (0, util_1.schemaRefOrVal)(
              it,
              parentSchema.properties,
              "properties",
            );
            definedProp = (0, code_1.isOwnProperty)(
              gen,
              propsSchema,
              key,
            );
          } else if (props.length)
            definedProp = (0, codegen_1.or)(
              ...props.map(
                (p) => (0, codegen_1._)`${key} === ${p}`,
              ),
            );
          else definedProp = codegen_1.nil;
          if (patProps.length)
            definedProp = (0, codegen_1.or)(
              definedProp,
              ...patProps.map(
                (p) =>
                  (0,
                  codegen_1._)`${(0, code_1.usePattern)(cxt, p)}.test(${key})`,
              ),
            );
          return (0, codegen_1.not)(definedProp);
        }
        function deleteAdditional(key) {
          gen.code(
            (0, codegen_1._)`delete ${data}[${key}]`,
          );
        }
        function additionalPropertyCode(key) {
          if (
            opts.removeAdditional === "all" ||
            (opts.removeAdditional && schema === false)
          ) {
            deleteAdditional(key);
            return;
          }
          if (schema === false) {
            cxt.setParams({ additionalProperty: key });
            cxt.error();
            if (!allErrors) gen.break();
            return;
          }
          if (
            typeof schema == "object" &&
            !(0, util_1.alwaysValidSchema)(it, schema)
          ) {
            const valid = gen.name("valid");
            if (opts.removeAdditional === "failing") {
              applyAdditionalSchema(key, valid, false);
              gen.if((0, codegen_1.not)(valid), () => {
                cxt.reset();
                deleteAdditional(key);
              });
            } else {
              applyAdditionalSchema(key, valid);
              if (!allErrors)
                gen.if((0, codegen_1.not)(valid), () =>
                  gen.break(),
                );
            }
          }
        }
        function applyAdditionalSchema(key, valid, errors) {
          const subschema = {
            keyword: "additionalProperties",
            dataProp: key,
            dataPropType: util_1.Type.Str,
          };
          if (errors === false)
            Object.assign(subschema, {
              compositeRule: true,
              createErrors: false,
              allErrors: false,
            });
          cxt.subschema(subschema, valid);
        }
      },
    };
  });
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/properties.js
var require_properties = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const validate_1 = require_validate();
    const code_1 = require_code();
    const util_1 = require_util();
    const additionalProperties_1 =
      require_additionalProperties();
    exports.default = {
      keyword: "properties",
      type: "object",
      schemaType: "object",
      code(cxt) {
        const { gen, schema, parentSchema, data, it } = cxt;
        if (
          it.opts.removeAdditional === "all" &&
          parentSchema.additionalProperties === void 0
        )
          additionalProperties_1.default.code(
            new validate_1.KeywordCxt(
              it,
              additionalProperties_1.default,
              "additionalProperties",
            ),
          );
        const allProps = (0, code_1.allSchemaProperties)(
          schema,
        );
        for (const prop of allProps)
          it.definedProperties.add(prop);
        if (
          it.opts.unevaluated &&
          allProps.length &&
          it.props !== true
        )
          it.props = util_1.mergeEvaluated.props(
            gen,
            (0, util_1.toHash)(allProps),
            it.props,
          );
        const properties = allProps.filter(
          (p) =>
            !(0, util_1.alwaysValidSchema)(it, schema[p]),
        );
        if (properties.length === 0) return;
        const valid = gen.name("valid");
        for (const prop of properties) {
          if (hasDefault(prop)) applyPropertySchema(prop);
          else {
            gen.if(
              (0, code_1.propertyInData)(
                gen,
                data,
                prop,
                it.opts.ownProperties,
              ),
            );
            applyPropertySchema(prop);
            if (!it.allErrors) gen.else().var(valid, true);
            gen.endIf();
          }
          cxt.it.definedProperties.add(prop);
          cxt.ok(valid);
        }
        function hasDefault(prop) {
          return (
            it.opts.useDefaults &&
            !it.compositeRule &&
            schema[prop].default !== void 0
          );
        }
        function applyPropertySchema(prop) {
          cxt.subschema(
            {
              keyword: "properties",
              schemaProp: prop,
              dataProp: prop,
            },
            valid,
          );
        }
      },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/patternProperties.js
var require_patternProperties =
  /* @__PURE__ */ __commonJSMin((exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const code_1 = require_code();
    const codegen_1 = require_codegen();
    const util_1 = require_util();
    const util_2 = require_util();
    exports.default = {
      keyword: "patternProperties",
      type: "object",
      schemaType: "object",
      code(cxt) {
        const { gen, schema, data, parentSchema, it } = cxt;
        const { opts } = it;
        const patterns = (0, code_1.allSchemaProperties)(
          schema,
        );
        const alwaysValidPatterns = patterns.filter((p) =>
          (0, util_1.alwaysValidSchema)(it, schema[p]),
        );
        if (
          patterns.length === 0 ||
          (alwaysValidPatterns.length === patterns.length &&
            (!it.opts.unevaluated || it.props === true))
        )
          return;
        const checkProperties =
          opts.strictSchema &&
          !opts.allowMatchingProperties &&
          parentSchema.properties;
        const valid = gen.name("valid");
        if (
          it.props !== true &&
          !(it.props instanceof codegen_1.Name)
        )
          it.props = (0, util_2.evaluatedPropsToName)(
            gen,
            it.props,
          );
        const { props } = it;
        validatePatternProperties();
        function validatePatternProperties() {
          for (const pat of patterns) {
            if (checkProperties)
              checkMatchingProperties(pat);
            if (it.allErrors) validateProperties(pat);
            else {
              gen.var(valid, true);
              validateProperties(pat);
              gen.if(valid);
            }
          }
        }
        function checkMatchingProperties(pat) {
          for (const prop in checkProperties)
            if (new RegExp(pat).test(prop))
              (0, util_1.checkStrictMode)(
                it,
                `property ${prop} matches pattern ${pat} (use allowMatchingProperties)`,
              );
        }
        function validateProperties(pat) {
          gen.forIn("key", data, (key) => {
            gen.if(
              (0,
              codegen_1._)`${(0, code_1.usePattern)(cxt, pat)}.test(${key})`,
              () => {
                const alwaysValid =
                  alwaysValidPatterns.includes(pat);
                if (!alwaysValid)
                  cxt.subschema(
                    {
                      keyword: "patternProperties",
                      schemaProp: pat,
                      dataProp: key,
                      dataPropType: util_2.Type.Str,
                    },
                    valid,
                  );
                if (it.opts.unevaluated && props !== true)
                  gen.assign(
                    (0, codegen_1._)`${props}[${key}]`,
                    true,
                  );
                else if (!alwaysValid && !it.allErrors)
                  gen.if((0, codegen_1.not)(valid), () =>
                    gen.break(),
                  );
              },
            );
          });
        }
      },
    };
  });
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/not.js
var require_not = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const util_1 = require_util();
    exports.default = {
      keyword: "not",
      schemaType: ["object", "boolean"],
      trackErrors: true,
      code(cxt) {
        const { gen, schema, it } = cxt;
        if ((0, util_1.alwaysValidSchema)(it, schema)) {
          cxt.fail();
          return;
        }
        const valid = gen.name("valid");
        cxt.subschema(
          {
            keyword: "not",
            compositeRule: true,
            createErrors: false,
            allErrors: false,
          },
          valid,
        );
        cxt.failResult(
          valid,
          () => cxt.reset(),
          () => cxt.error(),
        );
      },
      error: { message: "must NOT be valid" },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/anyOf.js
var require_anyOf = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.default = {
      keyword: "anyOf",
      schemaType: "array",
      trackErrors: true,
      code: require_code().validateUnion,
      error: { message: "must match a schema in anyOf" },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/oneOf.js
var require_oneOf = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    const util_1 = require_util();
    exports.default = {
      keyword: "oneOf",
      schemaType: "array",
      trackErrors: true,
      error: {
        message: "must match exactly one schema in oneOf",
        params: ({ params }) =>
          (0,
          codegen_1._)`{passingSchemas: ${params.passing}}`,
      },
      code(cxt) {
        const { gen, schema, parentSchema, it } = cxt;
        /* istanbul ignore if */
        if (!Array.isArray(schema))
          throw new Error("ajv implementation error");
        if (
          it.opts.discriminator &&
          parentSchema.discriminator
        )
          return;
        const schArr = schema;
        const valid = gen.let("valid", false);
        const passing = gen.let("passing", null);
        const schValid = gen.name("_valid");
        cxt.setParams({ passing });
        gen.block(validateOneOf);
        cxt.result(
          valid,
          () => cxt.reset(),
          () => cxt.error(true),
        );
        function validateOneOf() {
          schArr.forEach((sch, i) => {
            let schCxt;
            if ((0, util_1.alwaysValidSchema)(it, sch))
              gen.var(schValid, true);
            else
              schCxt = cxt.subschema(
                {
                  keyword: "oneOf",
                  schemaProp: i,
                  compositeRule: true,
                },
                schValid,
              );
            if (i > 0)
              gen
                .if(
                  (0, codegen_1._)`${schValid} && ${valid}`,
                )
                .assign(valid, false)
                .assign(
                  passing,
                  (0, codegen_1._)`[${passing}, ${i}]`,
                )
                .else();
            gen.if(schValid, () => {
              gen.assign(valid, true);
              gen.assign(passing, i);
              if (schCxt)
                cxt.mergeEvaluated(schCxt, codegen_1.Name);
            });
          });
        }
      },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/allOf.js
var require_allOf = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const util_1 = require_util();
    exports.default = {
      keyword: "allOf",
      schemaType: "array",
      code(cxt) {
        const { gen, schema, it } = cxt;
        /* istanbul ignore if */
        if (!Array.isArray(schema))
          throw new Error("ajv implementation error");
        const valid = gen.name("valid");
        schema.forEach((sch, i) => {
          if ((0, util_1.alwaysValidSchema)(it, sch))
            return;
          const schCxt = cxt.subschema(
            {
              keyword: "allOf",
              schemaProp: i,
            },
            valid,
          );
          cxt.ok(valid);
          cxt.mergeEvaluated(schCxt);
        });
      },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/if.js
var require_if = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    const util_1 = require_util();
    const def = {
      keyword: "if",
      schemaType: ["object", "boolean"],
      trackErrors: true,
      error: {
        message: ({ params }) =>
          (0,
          codegen_1.str)`must match "${params.ifClause}" schema`,
        params: ({ params }) =>
          (0,
          codegen_1._)`{failingKeyword: ${params.ifClause}}`,
      },
      code(cxt) {
        const { gen, parentSchema, it } = cxt;
        if (
          parentSchema.then === void 0 &&
          parentSchema.else === void 0
        )
          (0, util_1.checkStrictMode)(
            it,
            '"if" without "then" and "else" is ignored',
          );
        const hasThen = hasSchema(it, "then");
        const hasElse = hasSchema(it, "else");
        if (!hasThen && !hasElse) return;
        const valid = gen.let("valid", true);
        const schValid = gen.name("_valid");
        validateIf();
        cxt.reset();
        if (hasThen && hasElse) {
          const ifClause = gen.let("ifClause");
          cxt.setParams({ ifClause });
          gen.if(
            schValid,
            validateClause("then", ifClause),
            validateClause("else", ifClause),
          );
        } else if (hasThen)
          gen.if(schValid, validateClause("then"));
        else
          gen.if(
            (0, codegen_1.not)(schValid),
            validateClause("else"),
          );
        cxt.pass(valid, () => cxt.error(true));
        function validateIf() {
          const schCxt = cxt.subschema(
            {
              keyword: "if",
              compositeRule: true,
              createErrors: false,
              allErrors: false,
            },
            schValid,
          );
          cxt.mergeEvaluated(schCxt);
        }
        function validateClause(keyword, ifClause) {
          return () => {
            const schCxt = cxt.subschema(
              { keyword },
              schValid,
            );
            gen.assign(valid, schValid);
            cxt.mergeValidEvaluated(schCxt, valid);
            if (ifClause)
              gen.assign(
                ifClause,
                (0, codegen_1._)`${keyword}`,
              );
            else cxt.setParams({ ifClause: keyword });
          };
        }
      },
    };
    function hasSchema(it, keyword) {
      const schema = it.schema[keyword];
      return (
        schema !== void 0 &&
        !(0, util_1.alwaysValidSchema)(it, schema)
      );
    }
    exports.default = def;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/thenElse.js
var require_thenElse = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const util_1 = require_util();
    exports.default = {
      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`,
          );
      },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/index.js
var require_applicator = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const additionalItems_1 = require_additionalItems();
    const prefixItems_1 = require_prefixItems();
    const items_1 = require_items();
    const items2020_1 = require_items2020();
    const contains_1 = require_contains();
    const dependencies_1 = require_dependencies();
    const propertyNames_1 = require_propertyNames();
    const additionalProperties_1 =
      require_additionalProperties();
    const properties_1 = require_properties();
    const patternProperties_1 = require_patternProperties();
    const not_1 = require_not();
    const anyOf_1 = require_anyOf();
    const oneOf_1 = require_oneOf();
    const allOf_1 = require_allOf();
    const if_1 = require_if();
    const thenElse_1 = require_thenElse();
    function getApplicator(draft2020 = false) {
      const applicator = [
        not_1.default,
        anyOf_1.default,
        oneOf_1.default,
        allOf_1.default,
        if_1.default,
        thenElse_1.default,
        propertyNames_1.default,
        additionalProperties_1.default,
        dependencies_1.default,
        properties_1.default,
        patternProperties_1.default,
      ];
      if (draft2020)
        applicator.push(
          prefixItems_1.default,
          items2020_1.default,
        );
      else
        applicator.push(
          additionalItems_1.default,
          items_1.default,
        );
      applicator.push(contains_1.default);
      return applicator;
    }
    exports.default = getApplicator;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/format/format.js
var require_format$1 = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    exports.default = {
      keyword: "format",
      type: ["number", "string"],
      schemaType: "string",
      $data: true,
      error: {
        message: ({ schemaCode }) =>
          (0,
          codegen_1.str)`must match format "${schemaCode}"`,
        params: ({ schemaCode }) =>
          (0, codegen_1._)`{format: ${schemaCode}}`,
      },
      code(cxt, ruleType) {
        const { gen, data, $data, schema, schemaCode, it } =
          cxt;
        const { opts, errSchemaPath, schemaEnv, self } = it;
        if (!opts.validateFormats) return;
        if ($data) validate$DataFormat();
        else validateFormat();
        function validate$DataFormat() {
          const fmts = gen.scopeValue("formats", {
            ref: self.formats,
            code: opts.code.formats,
          });
          const fDef = gen.const(
            "fDef",
            (0, codegen_1._)`${fmts}[${schemaCode}]`,
          );
          const fType = gen.let("fType");
          const format = gen.let("format");
          gen.if(
            (0,
            codegen_1._)`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`,
            () =>
              gen
                .assign(
                  fType,
                  (0,
                  codegen_1._)`${fDef}.type || "string"`,
                )
                .assign(
                  format,
                  (0, codegen_1._)`${fDef}.validate`,
                ),
            () =>
              gen
                .assign(fType, (0, codegen_1._)`"string"`)
                .assign(format, fDef),
          );
          cxt.fail$data(
            (0, codegen_1.or)(unknownFmt(), invalidFmt()),
          );
          function unknownFmt() {
            if (opts.strictSchema === false)
              return codegen_1.nil;
            return (0,
            codegen_1._)`${schemaCode} && !${format}`;
          }
          function invalidFmt() {
            const callFormat = schemaEnv.$async
              ? (0,
                codegen_1._)`(${fDef}.async ? await ${format}(${data}) : ${format}(${data}))`
              : (0, codegen_1._)`${format}(${data})`;
            const validData = (0,
            codegen_1._)`(typeof ${format} == "function" ? ${callFormat} : ${format}.test(${data}))`;
            return (0,
            codegen_1._)`${format} && ${format} !== true && ${fType} === ${ruleType} && !${validData}`;
          }
        }
        function validateFormat() {
          const formatDef = self.formats[schema];
          if (!formatDef) {
            unknownFormat();
            return;
          }
          if (formatDef === true) return;
          const [fmtType, format, fmtRef] =
            getFormat(formatDef);
          if (fmtType === ruleType)
            cxt.pass(validCondition());
          function unknownFormat() {
            if (opts.strictSchema === false) {
              self.logger.warn(unknownMsg());
              return;
            }
            throw new Error(unknownMsg());
            function unknownMsg() {
              return `unknown format "${schema}" ignored in schema at path "${errSchemaPath}"`;
            }
          }
          function getFormat(fmtDef) {
            const code =
              fmtDef instanceof RegExp
                ? (0, codegen_1.regexpCode)(fmtDef)
                : opts.code.formats
                  ? (0,
                    codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(schema)}`
                  : void 0;
            const fmt = gen.scopeValue("formats", {
              key: schema,
              ref: fmtDef,
              code,
            });
            if (
              typeof fmtDef == "object" &&
              !(fmtDef instanceof RegExp)
            )
              return [
                fmtDef.type || "string",
                fmtDef.validate,
                (0, codegen_1._)`${fmt}.validate`,
              ];
            return ["string", fmtDef, fmt];
          }
          function validCondition() {
            if (
              typeof formatDef == "object" &&
              !(formatDef instanceof RegExp) &&
              formatDef.async
            ) {
              if (!schemaEnv.$async)
                throw new Error(
                  "async format in sync schema",
                );
              return (0,
              codegen_1._)`await ${fmtRef}(${data})`;
            }
            return typeof format == "function"
              ? (0, codegen_1._)`${fmtRef}(${data})`
              : (0, codegen_1._)`${fmtRef}.test(${data})`;
          }
        }
      },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/format/index.js
var require_format = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.default = [require_format$1().default];
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/metadata.js
var require_metadata = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    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",
    ];
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/draft7.js
var require_draft7 = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const core_1 = require_core();
    const validation_1 = require_validation();
    const applicator_1 = require_applicator();
    const format_1 = require_format();
    const metadata_1 = require_metadata();
    exports.default = [
      core_1.default,
      validation_1.default,
      (0, applicator_1.default)(),
      format_1.default,
      metadata_1.metadataVocabulary,
      metadata_1.contentVocabulary,
    ];
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/discriminator/types.js
var require_types = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.DiscrError = void 0;
    var DiscrError;
    (function (DiscrError) {
      DiscrError["Tag"] = "tag";
      DiscrError["Mapping"] = "mapping";
    })(
      DiscrError || (exports.DiscrError = DiscrError = {}),
    );
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/discriminator/index.js
var require_discriminator = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    const types_1 = require_types();
    const compile_1 = require_compile();
    const ref_error_1 = require_ref_error();
    const util_1 = require_util();
    exports.default = {
      keyword: "discriminator",
      type: "object",
      schemaType: "object",
      error: {
        message: ({ params: { discrError, tagName } }) =>
          discrError === types_1.DiscrError.Tag
            ? `tag "${tagName}" must be string`
            : `value of tag "${tagName}" must be in oneOf`,
        params: ({
          params: { discrError, tag, tagName },
        }) =>
          (0,
          codegen_1._)`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}`,
      },
      code(cxt) {
        const { gen, data, schema, parentSchema, it } = cxt;
        const { oneOf } = parentSchema;
        if (!it.opts.discriminator)
          throw new Error(
            "discriminator: requires discriminator option",
          );
        const tagName = schema.propertyName;
        if (typeof tagName != "string")
          throw new Error(
            "discriminator: requires propertyName",
          );
        if (schema.mapping)
          throw new Error(
            "discriminator: mapping is not supported",
          );
        if (!oneOf)
          throw new Error(
            "discriminator: requires oneOf keyword",
          );
        const valid = gen.let("valid", false);
        const tag = gen.const(
          "tag",
          (0,
          codegen_1._)`${data}${(0, codegen_1.getProperty)(tagName)}`,
        );
        gen.if(
          (0, codegen_1._)`typeof ${tag} == "string"`,
          () => validateMapping(),
          () =>
            cxt.error(false, {
              discrError: types_1.DiscrError.Tag,
              tag,
              tagName,
            }),
        );
        cxt.ok(valid);
        function validateMapping() {
          const mapping = getMapping();
          gen.if(false);
          for (const tagValue in mapping) {
            gen.elseIf(
              (0, codegen_1._)`${tag} === ${tagValue}`,
            );
            gen.assign(
              valid,
              applyTagSchema(mapping[tagValue]),
            );
          }
          gen.else();
          cxt.error(false, {
            discrError: types_1.DiscrError.Mapping,
            tag,
            tagName,
          });
          gen.endIf();
        }
        function applyTagSchema(schemaProp) {
          const _valid = gen.name("valid");
          const schCxt = cxt.subschema(
            {
              keyword: "oneOf",
              schemaProp,
            },
            _valid,
          );
          cxt.mergeEvaluated(schCxt, codegen_1.Name);
          return _valid;
        }
        function getMapping() {
          var _a;
          const oneOfMapping = {};
          const topRequired = hasRequired(parentSchema);
          let tagRequired = true;
          for (let i = 0; i < oneOf.length; i++) {
            let sch = oneOf[i];
            if (
              (sch === null || sch === void 0
                ? void 0
                : sch.$ref) &&
              !(0, util_1.schemaHasRulesButRef)(
                sch,
                it.self.RULES,
              )
            ) {
              const ref = sch.$ref;
              sch = compile_1.resolveRef.call(
                it.self,
                it.schemaEnv.root,
                it.baseId,
                ref,
              );
              if (sch instanceof compile_1.SchemaEnv)
                sch = sch.schema;
              if (sch === void 0)
                throw new ref_error_1.default(
                  it.opts.uriResolver,
                  it.baseId,
                  ref,
                );
            }
            const propSch =
              (_a =
                sch === null || sch === void 0
                  ? void 0
                  : sch.properties) === null ||
              _a === void 0
                ? void 0
                : _a[tagName];
            if (typeof propSch != "object")
              throw new Error(
                `discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`,
              );
            tagRequired =
              tagRequired &&
              (topRequired || hasRequired(sch));
            addMappings(propSch, i);
          }
          if (!tagRequired)
            throw new Error(
              `discriminator: "${tagName}" must be required`,
            );
          return oneOfMapping;
          function hasRequired({ required }) {
            return (
              Array.isArray(required) &&
              required.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;
          }
        }
      },
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/json-schema-draft-07.json
var require_json_schema_draft_07 =
  /* @__PURE__ */ __commonJSMin((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,
    };
  });
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/ajv.js
var require_ajv = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.MissingRefError =
      exports.ValidationError =
      exports.CodeGen =
      exports.Name =
      exports.nil =
      exports.stringify =
      exports.str =
      exports._ =
      exports.KeywordCxt =
      exports.Ajv =
        void 0;
    const core_1 = require_core$1();
    const draft7_1 = require_draft7();
    const discriminator_1 = require_discriminator();
    const draft7MetaSchema = require_json_schema_draft_07();
    const META_SUPPORT_DATA = ["/properties"];
    const META_SCHEMA_ID =
      "http://json-schema.org/draft-07/schema";
    var Ajv = class extends core_1.default {
      _addVocabularies() {
        super._addVocabularies();
        draft7_1.default.forEach((v) =>
          this.addVocabulary(v),
        );
        if (this.opts.discriminator)
          this.addKeyword(discriminator_1.default);
      }
      _addDefaultMetaSchema() {
        super._addDefaultMetaSchema();
        if (!this.opts.meta) return;
        const metaSchema = this.opts.$data
          ? this.$dataMetaSchema(
              draft7MetaSchema,
              META_SUPPORT_DATA,
            )
          : draft7MetaSchema;
        this.addMetaSchema(
          metaSchema,
          META_SCHEMA_ID,
          false,
        );
        this.refs["http://json-schema.org/schema"] =
          META_SCHEMA_ID;
      }
      defaultMeta() {
        return (this.opts.defaultMeta =
          super.defaultMeta() ||
          (this.getSchema(META_SCHEMA_ID)
            ? META_SCHEMA_ID
            : void 0));
      }
    };
    exports.Ajv = Ajv;
    module.exports = exports = Ajv;
    module.exports.Ajv = Ajv;
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.default = Ajv;
    var validate_1 = require_validate();
    Object.defineProperty(exports, "KeywordCxt", {
      enumerable: true,
      get: function () {
        return validate_1.KeywordCxt;
      },
    });
    var codegen_1 = require_codegen();
    Object.defineProperty(exports, "_", {
      enumerable: true,
      get: function () {
        return codegen_1._;
      },
    });
    Object.defineProperty(exports, "str", {
      enumerable: true,
      get: function () {
        return codegen_1.str;
      },
    });
    Object.defineProperty(exports, "stringify", {
      enumerable: true,
      get: function () {
        return codegen_1.stringify;
      },
    });
    Object.defineProperty(exports, "nil", {
      enumerable: true,
      get: function () {
        return codegen_1.nil;
      },
    });
    Object.defineProperty(exports, "Name", {
      enumerable: true,
      get: function () {
        return codegen_1.Name;
      },
    });
    Object.defineProperty(exports, "CodeGen", {
      enumerable: true,
      get: function () {
        return codegen_1.CodeGen;
      },
    });
    var validation_error_1 = require_validation_error();
    Object.defineProperty(exports, "ValidationError", {
      enumerable: true,
      get: function () {
        return validation_error_1.default;
      },
    });
    var ref_error_1 = require_ref_error();
    Object.defineProperty(exports, "MissingRefError", {
      enumerable: true,
      get: function () {
        return ref_error_1.default;
      },
    });
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-formats@3.0.1_ajv@8.20.0/node_modules/ajv-formats/dist/formats.js
var require_formats = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.formatNames =
      exports.fastFormats =
      exports.fullFormats =
        void 0;
    function fmtDef(validate, compare) {
      return {
        validate,
        compare,
      };
    }
    exports.fullFormats = {
      date: fmtDef(date, compareDate),
      time: fmtDef(getTime(true), compareTime),
      "date-time": fmtDef(
        getDateTime(true),
        compareDateTime,
      ),
      "iso-time": fmtDef(getTime(), compareIsoTime),
      "iso-date-time": fmtDef(
        getDateTime(),
        compareIsoDateTime,
      ),
      duration:
        /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/,
      uri,
      "uri-reference":
        /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i,
      "uri-template":
        /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i,
      url: /^(?:https?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu,
      email:
        /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,
      hostname:
        /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i,
      ipv4: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/,
      ipv6: /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i,
      regex,
      uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,
      "json-pointer": /^(?:\/(?:[^~/]|~0|~1)*)*$/,
      "json-pointer-uri-fragment":
        /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i,
      "relative-json-pointer":
        /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/,
      byte,
      int32: {
        type: "number",
        validate: validateInt32,
      },
      int64: {
        type: "number",
        validate: validateInt64,
      },
      float: {
        type: "number",
        validate: validateNumber,
      },
      double: {
        type: "number",
        validate: validateNumber,
      },
      password: true,
      binary: true,
    };
    exports.fastFormats = {
      ...exports.fullFormats,
      date: fmtDef(
        /^\d\d\d\d-[0-1]\d-[0-3]\d$/,
        compareDate,
      ),
      time: fmtDef(
        /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i,
        compareTime,
      ),
      "date-time": fmtDef(
        /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i,
        compareDateTime,
      ),
      "iso-time": fmtDef(
        /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i,
        compareIsoTime,
      ),
      "iso-date-time": fmtDef(
        /^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i,
        compareIsoDateTime,
      ),
      uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i,
      "uri-reference":
        /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i,
      email:
        /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i,
    };
    exports.formatNames = Object.keys(exports.fullFormats);
    function isLeapYear(year) {
      return (
        year % 4 === 0 &&
        (year % 100 !== 0 || year % 400 === 0)
      );
    }
    const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
    const DAYS = [
      0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
    ];
    function date(str) {
      const matches = DATE.exec(str);
      if (!matches) return false;
      const year = +matches[1];
      const month = +matches[2];
      const day = +matches[3];
      return (
        month >= 1 &&
        month <= 12 &&
        day >= 1 &&
        day <=
          (month === 2 && isLeapYear(year)
            ? 29
            : DAYS[month])
      );
    }
    function compareDate(d1, d2) {
      if (!(d1 && d2)) return void 0;
      if (d1 > d2) return 1;
      if (d1 < d2) return -1;
      return 0;
    }
    const TIME =
      /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
    function getTime(strictTimeZone) {
      return function time(str) {
        const matches = TIME.exec(str);
        if (!matches) return false;
        const hr = +matches[1];
        const min = +matches[2];
        const sec = +matches[3];
        const tz = matches[4];
        const tzSign = matches[5] === "-" ? -1 : 1;
        const tzH = +(matches[6] || 0);
        const tzM = +(matches[7] || 0);
        if (tzH > 23 || tzM > 59 || (strictTimeZone && !tz))
          return false;
        if (hr <= 23 && min <= 59 && sec < 60) return true;
        const utcMin = min - tzM * tzSign;
        const utcHr =
          hr - tzH * tzSign - (utcMin < 0 ? 1 : 0);
        return (
          (utcHr === 23 || utcHr === -1) &&
          (utcMin === 59 || utcMin === -1) &&
          sec < 61
        );
      };
    }
    function compareTime(s1, s2) {
      if (!(s1 && s2)) return void 0;
      const t1 = /* @__PURE__ */ new Date(
        "2020-01-01T" + s1,
      ).valueOf();
      const t2 = /* @__PURE__ */ new Date(
        "2020-01-01T" + s2,
      ).valueOf();
      if (!(t1 && t2)) return void 0;
      return t1 - t2;
    }
    function compareIsoTime(t1, t2) {
      if (!(t1 && t2)) return void 0;
      const a1 = TIME.exec(t1);
      const a2 = TIME.exec(t2);
      if (!(a1 && a2)) return void 0;
      t1 = a1[1] + a1[2] + a1[3];
      t2 = a2[1] + a2[2] + a2[3];
      if (t1 > t2) return 1;
      if (t1 < t2) return -1;
      return 0;
    }
    const DATE_TIME_SEPARATOR = /t|\s/i;
    function getDateTime(strictTimeZone) {
      const time = getTime(strictTimeZone);
      return function date_time(str) {
        const dateTime = str.split(DATE_TIME_SEPARATOR);
        return (
          dateTime.length === 2 &&
          date(dateTime[0]) &&
          time(dateTime[1])
        );
      };
    }
    function compareDateTime(dt1, dt2) {
      if (!(dt1 && dt2)) return void 0;
      const d1 = new Date(dt1).valueOf();
      const d2 = new Date(dt2).valueOf();
      if (!(d1 && d2)) return void 0;
      return d1 - d2;
    }
    function compareIsoDateTime(dt1, dt2) {
      if (!(dt1 && dt2)) return void 0;
      const [d1, t1] = dt1.split(DATE_TIME_SEPARATOR);
      const [d2, t2] = dt2.split(DATE_TIME_SEPARATOR);
      const res = compareDate(d1, d2);
      if (res === void 0) return void 0;
      return res || compareTime(t1, t2);
    }
    const NOT_URI_FRAGMENT = /\/|:/;
    const URI =
      /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
    function uri(str) {
      return NOT_URI_FRAGMENT.test(str) && URI.test(str);
    }
    const BYTE =
      /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm;
    function byte(str) {
      BYTE.lastIndex = 0;
      return BYTE.test(str);
    }
    const MIN_INT32 = -(2 ** 31);
    const MAX_INT32 = 2 ** 31 - 1;
    function validateInt32(value) {
      return (
        Number.isInteger(value) &&
        value <= MAX_INT32 &&
        value >= MIN_INT32
      );
    }
    function validateInt64(value) {
      return Number.isInteger(value);
    }
    function validateNumber() {
      return true;
    }
    const Z_ANCHOR = /[^\\]\\Z/;
    function regex(str) {
      if (Z_ANCHOR.test(str)) return false;
      try {
        new RegExp(str);
        return true;
      } catch (e) {
        return false;
      }
    }
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-formats@3.0.1_ajv@8.20.0/node_modules/ajv-formats/dist/limit.js
var require_limit = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.formatLimitDefinition = void 0;
    const ajv_1 = require_ajv();
    const codegen_1 = require_codegen();
    const ops = codegen_1.operators;
    const KWDs = {
      formatMaximum: {
        okStr: "<=",
        ok: ops.LTE,
        fail: ops.GT,
      },
      formatMinimum: {
        okStr: ">=",
        ok: ops.GTE,
        fail: ops.LT,
      },
      formatExclusiveMaximum: {
        okStr: "<",
        ok: ops.LT,
        fail: ops.GTE,
      },
      formatExclusiveMinimum: {
        okStr: ">",
        ok: ops.GT,
        fail: ops.LTE,
      },
    };
    exports.formatLimitDefinition = {
      keyword: Object.keys(KWDs),
      type: "string",
      schemaType: "string",
      $data: true,
      error: {
        message: ({ keyword, schemaCode }) =>
          (0,
          codegen_1.str)`should be ${KWDs[keyword].okStr} ${schemaCode}`,
        params: ({ keyword, schemaCode }) =>
          (0,
          codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`,
      },
      code(cxt) {
        const { gen, data, schemaCode, keyword, it } = cxt;
        const { opts, self } = it;
        if (!opts.validateFormats) return;
        const fCxt = new ajv_1.KeywordCxt(
          it,
          self.RULES.all.format.definition,
          "format",
        );
        if (fCxt.$data) validate$DataFormat();
        else validateFormat();
        function validate$DataFormat() {
          const fmts = gen.scopeValue("formats", {
            ref: self.formats,
            code: opts.code.formats,
          });
          const fmt = gen.const(
            "fmt",
            (0, codegen_1._)`${fmts}[${fCxt.schemaCode}]`,
          );
          cxt.fail$data(
            (0, codegen_1.or)(
              (0, codegen_1._)`typeof ${fmt} != "object"`,
              (0, codegen_1._)`${fmt} instanceof RegExp`,
              (0,
              codegen_1._)`typeof ${fmt}.compare != "function"`,
              compareCode(fmt),
            ),
          );
        }
        function validateFormat() {
          const format = fCxt.schema;
          const fmtDef = self.formats[format];
          if (!fmtDef || fmtDef === true) return;
          if (
            typeof fmtDef != "object" ||
            fmtDef instanceof RegExp ||
            typeof fmtDef.compare != "function"
          )
            throw new Error(
              `"${keyword}": format "${format}" does not define "compare" function`,
            );
          const fmt = gen.scopeValue("formats", {
            key: format,
            ref: fmtDef,
            code: opts.code.formats
              ? (0,
                codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format)}`
              : void 0,
          });
          cxt.fail$data(compareCode(fmt));
        }
        function compareCode(fmt) {
          return (0,
          codegen_1._)`${fmt}.compare(${data}, ${schemaCode}) ${KWDs[keyword].fail} 0`;
        }
      },
      dependencies: ["format"],
    };
    const formatLimitPlugin = (ajv) => {
      ajv.addKeyword(exports.formatLimitDefinition);
      return ajv;
    };
    exports.default = formatLimitPlugin;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-formats@3.0.1_ajv@8.20.0/node_modules/ajv-formats/dist/index.js
var require_dist$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const formats_1 = require_formats();
    const limit_1 = require_limit();
    const codegen_1 = require_codegen();
    const fullName = new codegen_1.Name("fullFormats");
    const fastName = new codegen_1.Name("fastFormats");
    const formatsPlugin = (
      ajv,
      opts = { keywords: true },
    ) => {
      if (Array.isArray(opts)) {
        addFormats(
          ajv,
          opts,
          formats_1.fullFormats,
          fullName,
        );
        return ajv;
      }
      const [formats, exportName] =
        opts.mode === "fast"
          ? [formats_1.fastFormats, fastName]
          : [formats_1.fullFormats, fullName];
      addFormats(
        ajv,
        opts.formats || formats_1.formatNames,
        formats,
        exportName,
      );
      if (opts.keywords) (0, limit_1.default)(ajv);
      return ajv;
    };
    formatsPlugin.get = (name, mode = "full") => {
      const f = (
        mode === "fast"
          ? formats_1.fastFormats
          : formats_1.fullFormats
      )[name];
      if (!f) throw new Error(`Unknown format "${name}"`);
      return f;
    };
    function addFormats(ajv, list, fs, exportName) {
      var _a;
      var _b;
      ((_a = (_b = ajv.opts.code).formats) !== null &&
        _a !== void 0) ||
        (_b.formats = (0,
        codegen_1._)`require("ajv-formats/dist/formats").${exportName}`);
      for (const f of list) ajv.addFormat(f, fs[f]);
    }
    module.exports = exports = formatsPlugin;
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.default = formatsPlugin;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/typeof.js
var require_typeof$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    const TYPES = [
      "undefined",
      "string",
      "number",
      "object",
      "function",
      "boolean",
      "symbol",
    ];
    function getDef() {
      return {
        keyword: "typeof",
        schemaType: ["string", "array"],
        code(cxt) {
          const { data, schema, schemaValue } = cxt;
          cxt.fail(
            typeof schema == "string"
              ? (0,
                codegen_1._)`typeof ${data} != ${schema}`
              : (0,
                codegen_1._)`${schemaValue}.indexOf(typeof ${data}) < 0`,
          );
        },
        metaSchema: {
          anyOf: [
            {
              type: "string",
              enum: TYPES,
            },
            {
              type: "array",
              items: {
                type: "string",
                enum: TYPES,
              },
            },
          ],
        },
      };
    }
    exports.default = getDef;
    module.exports = getDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/typeof.js
var require_typeof = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$22) => {
    var __importDefault =
      (this$22 && this$22.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule
          ? mod
          : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const typeof_1 = __importDefault(require_typeof$1());
    const typeofPlugin = (ajv) =>
      ajv.addKeyword((0, typeof_1.default)());
    exports.default = typeofPlugin;
    module.exports = typeofPlugin;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/instanceof.js
var require_instanceof$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const CONSTRUCTORS = {
      Object,
      Array,
      Function,
      Number,
      String,
      Date,
      RegExp,
    };
    /* istanbul ignore else */
    if (typeof Buffer != "undefined")
      CONSTRUCTORS.Buffer = Buffer;
    /* istanbul ignore else */
    if (typeof Promise != "undefined")
      CONSTRUCTORS.Promise = Promise;
    const getDef = Object.assign(_getDef, { CONSTRUCTORS });
    function _getDef() {
      return {
        keyword: "instanceof",
        schemaType: ["string", "array"],
        compile(schema) {
          if (typeof schema == "string") {
            const C = getConstructor(schema);
            return (data) => data instanceof C;
          }
          if (Array.isArray(schema)) {
            const constructors = schema.map(getConstructor);
            return (data) => {
              for (const C of constructors)
                if (data instanceof C) return true;
              return false;
            };
          }
          /* istanbul ignore next */
          throw new Error("ajv implementation error");
        },
        metaSchema: {
          anyOf: [
            { type: "string" },
            {
              type: "array",
              items: { type: "string" },
            },
          ],
        },
      };
    }
    function getConstructor(c) {
      const C = CONSTRUCTORS[c];
      if (C) return C;
      throw new Error(
        `invalid "instanceof" keyword value ${c}`,
      );
    }
    exports.default = getDef;
    module.exports = getDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/instanceof.js
var require_instanceof = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$21) => {
    var __importDefault =
      (this$21 && this$21.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule
          ? mod
          : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const instanceof_1 = __importDefault(
      require_instanceof$1(),
    );
    const instanceofPlugin = (ajv) =>
      ajv.addKeyword((0, instanceof_1.default)());
    exports.default = instanceofPlugin;
    module.exports = instanceofPlugin;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/_range.js
var require__range = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    function getRangeDef(keyword) {
      return () => ({
        keyword,
        type: "number",
        schemaType: "array",
        macro: function ([min, max]) {
          validateRangeSchema(min, max);
          return keyword === "range"
            ? {
                minimum: min,
                maximum: max,
              }
            : {
                exclusiveMinimum: min,
                exclusiveMaximum: max,
              };
        },
        metaSchema: {
          type: "array",
          minItems: 2,
          maxItems: 2,
          items: { type: "number" },
        },
      });
      function validateRangeSchema(min, max) {
        if (
          min > max ||
          (keyword === "exclusiveRange" && min === max)
        )
          throw new Error("There are no numbers in range");
      }
    }
    exports.default = getRangeDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/range.js
var require_range$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$20) => {
    var __importDefault =
      (this$20 && this$20.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule
          ? mod
          : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const getDef = (0,
    __importDefault(require__range()).default)("range");
    exports.default = getDef;
    module.exports = getDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/range.js
var require_range = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$19) => {
    var __importDefault =
      (this$19 && this$19.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule
          ? mod
          : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const range_1 = __importDefault(require_range$1());
    const range = (ajv) =>
      ajv.addKeyword((0, range_1.default)());
    exports.default = range;
    module.exports = range;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/exclusiveRange.js
var require_exclusiveRange$1 =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$18) => {
      var __importDefault =
        (this$18 && this$18.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(exports, "__esModule", {
        value: true,
      });
      const getDef = (0,
      __importDefault(require__range()).default)(
        "exclusiveRange",
      );
      exports.default = getDef;
      module.exports = getDef;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/exclusiveRange.js
var require_exclusiveRange = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$17) => {
    var __importDefault =
      (this$17 && this$17.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule
          ? mod
          : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const exclusiveRange_1 = __importDefault(
      require_exclusiveRange$1(),
    );
    const exclusiveRange = (ajv) =>
      ajv.addKeyword((0, exclusiveRange_1.default)());
    exports.default = exclusiveRange;
    module.exports = exclusiveRange;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/_util.js
var require__util = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.usePattern = exports.metaSchemaRef = void 0;
    const codegen_1 = require_codegen();
    const META_SCHEMA_ID = "http://json-schema.org/schema";
    function metaSchemaRef({ defaultMeta } = {}) {
      return defaultMeta === false
        ? {}
        : { $ref: defaultMeta || META_SCHEMA_ID };
    }
    exports.metaSchemaRef = metaSchemaRef;
    function usePattern(
      { gen, it: { opts } },
      pattern,
      flags = opts.unicodeRegExp ? "u" : "",
    ) {
      const rx = new RegExp(pattern, flags);
      return gen.scopeValue("pattern", {
        key: rx.toString(),
        ref: rx,
        code: (0,
        codegen_1._)`new RegExp(${pattern}, ${flags})`,
      });
    }
    exports.usePattern = usePattern;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/regexp.js
var require_regexp$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    const _util_1 = require__util();
    const regexpMetaSchema = {
      type: "object",
      properties: {
        pattern: { type: "string" },
        flags: {
          type: "string",
          nullable: true,
        },
      },
      required: ["pattern"],
      additionalProperties: false,
    };
    const metaRegexp = /^\/(.*)\/([gimuy]*)$/;
    function getDef() {
      return {
        keyword: "regexp",
        type: "string",
        schemaType: ["string", "object"],
        code(cxt) {
          const { data, schema } = cxt;
          const regx = getRegExp(schema);
          cxt.pass((0, codegen_1._)`${regx}.test(${data})`);
          function getRegExp(sch) {
            if (typeof sch == "object")
              return (0, _util_1.usePattern)(
                cxt,
                sch.pattern,
                sch.flags,
              );
            const rx = metaRegexp.exec(sch);
            if (rx)
              return (0, _util_1.usePattern)(
                cxt,
                rx[1],
                rx[2],
              );
            throw new Error(
              "cannot parse string into RegExp",
            );
          }
        },
        metaSchema: {
          anyOf: [{ type: "string" }, regexpMetaSchema],
        },
      };
    }
    exports.default = getDef;
    module.exports = getDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/regexp.js
var require_regexp = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$16) => {
    var __importDefault =
      (this$16 && this$16.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule
          ? mod
          : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const regexp_1 = __importDefault(require_regexp$1());
    const regexp = (ajv) =>
      ajv.addKeyword((0, regexp_1.default)());
    exports.default = regexp;
    module.exports = regexp;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/transform.js
var require_transform$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    const transform = {
      trimStart: (s) => s.trimStart(),
      trimEnd: (s) => s.trimEnd(),
      trimLeft: (s) => s.trimStart(),
      trimRight: (s) => s.trimEnd(),
      trim: (s) => s.trim(),
      toLowerCase: (s) => s.toLowerCase(),
      toUpperCase: (s) => s.toUpperCase(),
      toEnumCase: (s, cfg) =>
        (cfg === null || cfg === void 0
          ? void 0
          : cfg.hash[configKey(s)]) || s,
    };
    const getDef = Object.assign(_getDef, { transform });
    function _getDef() {
      return {
        keyword: "transform",
        schemaType: "array",
        before: "enum",
        code(cxt) {
          const { gen, data, schema, parentSchema, it } =
            cxt;
          const { parentData, parentDataProperty } = it;
          const tNames = schema;
          if (!tNames.length) return;
          let cfg;
          if (tNames.includes("toEnumCase")) {
            const config = getEnumCaseCfg(parentSchema);
            cfg = gen.scopeValue("obj", {
              ref: config,
              code: (0, codegen_1.stringify)(config),
            });
          }
          gen.if(
            (0,
            codegen_1._)`typeof ${data} == "string" && ${parentData} !== undefined`,
            () => {
              gen.assign(
                data,
                transformExpr(tNames.slice()),
              );
              gen.assign(
                (0,
                codegen_1._)`${parentData}[${parentDataProperty}]`,
                data,
              );
            },
          );
          function transformExpr(ts) {
            if (!ts.length) return data;
            const t = ts.pop();
            if (!(t in transform))
              throw new Error(
                `transform: unknown transformation ${t}`,
              );
            const func = gen.scopeValue("func", {
              ref: transform[t],
              code: (0,
              codegen_1._)`require("ajv-keywords/dist/definitions/transform").transform${(0, codegen_1.getProperty)(t)}`,
            });
            const arg = transformExpr(ts);
            return cfg && t === "toEnumCase"
              ? (0, codegen_1._)`${func}(${arg}, ${cfg})`
              : (0, codegen_1._)`${func}(${arg})`;
          }
        },
        metaSchema: {
          type: "array",
          items: {
            type: "string",
            enum: Object.keys(transform),
          },
        },
      };
    }
    function getEnumCaseCfg(parentSchema) {
      const cfg = { hash: {} };
      if (!parentSchema.enum)
        throw new Error(
          'transform: "toEnumCase" requires "enum"',
        );
      for (const v of parentSchema.enum) {
        if (typeof v !== "string") continue;
        const k = configKey(v);
        if (cfg.hash[k])
          throw new Error(
            'transform: "toEnumCase" requires all lowercased "enum" values to be unique',
          );
        cfg.hash[k] = v;
      }
      return cfg;
    }
    function configKey(s) {
      return s.toLowerCase();
    }
    exports.default = getDef;
    module.exports = getDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/transform.js
var require_transform = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$15) => {
    var __importDefault =
      (this$15 && this$15.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule
          ? mod
          : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const transform_1 = __importDefault(
      require_transform$1(),
    );
    const transform = (ajv) =>
      ajv.addKeyword((0, transform_1.default)());
    exports.default = transform;
    module.exports = transform;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/uniqueItemProperties.js
var require_uniqueItemProperties$1 =
  /* @__PURE__ */ __commonJSMin((exports, module) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const equal = require_fast_deep_equal();
    const SCALAR_TYPES = [
      "number",
      "integer",
      "string",
      "boolean",
      "null",
    ];
    function getDef() {
      return {
        keyword: "uniqueItemProperties",
        type: "array",
        schemaType: "array",
        compile(keys, parentSchema) {
          const scalar = getScalarKeys(keys, parentSchema);
          return (data) => {
            if (data.length <= 1) return true;
            for (let k = 0; k < keys.length; k++) {
              const key = keys[k];
              if (scalar[k]) {
                const hash = {};
                for (const x of data) {
                  if (!x || typeof x != "object") continue;
                  let p = x[key];
                  if (p && typeof p == "object") continue;
                  if (typeof p == "string") p = '"' + p;
                  if (hash[p]) return false;
                  hash[p] = true;
                }
              } else
                for (let i = data.length; i--;) {
                  const x = data[i];
                  if (!x || typeof x != "object") continue;
                  for (let j = i; j--;) {
                    const y = data[j];
                    if (
                      y &&
                      typeof y == "object" &&
                      equal(x[key], y[key])
                    )
                      return false;
                  }
                }
            }
            return true;
          };
        },
        metaSchema: {
          type: "array",
          items: { type: "string" },
        },
      };
    }
    exports.default = getDef;
    function getScalarKeys(keys, schema) {
      return keys.map((key) => {
        var _a, _b, _c;
        const t =
          (_c =
            (_b =
              (_a = schema.items) === null || _a === void 0
                ? void 0
                : _a.properties) === null || _b === void 0
              ? void 0
              : _b[key]) === null || _c === void 0
            ? void 0
            : _c.type;
        return Array.isArray(t)
          ? !t.includes("object") && !t.includes("array")
          : SCALAR_TYPES.includes(t);
      });
    }
    module.exports = getDef;
  });
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/uniqueItemProperties.js
var require_uniqueItemProperties =
  /* @__PURE__ */ __commonJSMin(
    (exports, module, this$14) => {
      var __importDefault =
        (this$14 && this$14.__importDefault) ||
        function (mod) {
          return mod && mod.__esModule
            ? mod
            : { default: mod };
        };
      Object.defineProperty(exports, "__esModule", {
        value: true,
      });
      const uniqueItemProperties_1 = __importDefault(
        require_uniqueItemProperties$1(),
      );
      const uniqueItemProperties = (ajv) =>
        ajv.addKeyword(
          (0, uniqueItemProperties_1.default)(),
        );
      exports.default = uniqueItemProperties;
      module.exports = uniqueItemProperties;
    },
  );
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/allRequired.js
var require_allRequired$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    function getDef() {
      return {
        keyword: "allRequired",
        type: "object",
        schemaType: "boolean",
        macro(schema, parentSchema) {
          if (!schema) return true;
          const required = Object.keys(
            parentSchema.properties,
          );
          if (required.length === 0) return true;
          return { required };
        },
        dependencies: ["properties"],
      };
    }
    exports.default = getDef;
    module.exports = getDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/allRequired.js
var require_allRequired = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$13) => {
    var __importDefault =
      (this$13 && this$13.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule
          ? mod
          : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const allRequired_1 = __importDefault(
      require_allRequired$1(),
    );
    const allRequired = (ajv) =>
      ajv.addKeyword((0, allRequired_1.default)());
    exports.default = allRequired;
    module.exports = allRequired;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/_required.js
var require__required = /* @__PURE__ */ __commonJSMin(
  (exports) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    function getRequiredDef(keyword) {
      return () => ({
        keyword,
        type: "object",
        schemaType: "array",
        macro(schema) {
          if (schema.length === 0) return true;
          if (schema.length === 1)
            return { required: schema };
          return {
            [keyword === "anyRequired" ? "anyOf" : "oneOf"]:
              schema.map((p) => ({ required: [p] })),
          };
        },
        metaSchema: {
          type: "array",
          items: { type: "string" },
        },
      });
    }
    exports.default = getRequiredDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/anyRequired.js
var require_anyRequired$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$12) => {
    var __importDefault =
      (this$12 && this$12.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule
          ? mod
          : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const getDef = (0,
    __importDefault(require__required()).default)(
      "anyRequired",
    );
    exports.default = getDef;
    module.exports = getDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/anyRequired.js
var require_anyRequired = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$11) => {
    var __importDefault =
      (this$11 && this$11.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule
          ? mod
          : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const anyRequired_1 = __importDefault(
      require_anyRequired$1(),
    );
    const anyRequired = (ajv) =>
      ajv.addKeyword((0, anyRequired_1.default)());
    exports.default = anyRequired;
    module.exports = anyRequired;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/oneRequired.js
var require_oneRequired$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$10) => {
    var __importDefault =
      (this$10 && this$10.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule
          ? mod
          : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const getDef = (0,
    __importDefault(require__required()).default)(
      "oneRequired",
    );
    exports.default = getDef;
    module.exports = getDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/oneRequired.js
var require_oneRequired = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$9) => {
    var __importDefault =
      (this$9 && this$9.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule
          ? mod
          : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const oneRequired_1 = __importDefault(
      require_oneRequired$1(),
    );
    const oneRequired = (ajv) =>
      ajv.addKeyword((0, oneRequired_1.default)());
    exports.default = oneRequired;
    module.exports = oneRequired;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/patternRequired.js
var require_patternRequired$1 =
  /* @__PURE__ */ __commonJSMin((exports, module) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    const _util_1 = require__util();
    const error = {
      message: ({ params: { missingPattern } }) =>
        (0,
        codegen_1.str)`should have property matching pattern '${missingPattern}'`,
      params: ({ params: { missingPattern } }) =>
        (0,
        codegen_1._)`{missingPattern: ${missingPattern}}`,
    };
    function getDef() {
      return {
        keyword: "patternRequired",
        type: "object",
        schemaType: "array",
        error,
        code(cxt) {
          const { gen, schema, data } = cxt;
          if (schema.length === 0) return;
          const valid = gen.let("valid", true);
          for (const pat of schema) validateProperties(pat);
          function validateProperties(pattern) {
            const matched = gen.let("matched", false);
            gen.forIn("key", data, (key) => {
              gen.assign(
                matched,
                (0,
                codegen_1._)`${(0, _util_1.usePattern)(cxt, pattern)}.test(${key})`,
              );
              gen.if(matched, () => gen.break());
            });
            cxt.setParams({ missingPattern: pattern });
            gen.assign(
              valid,
              (0, codegen_1.and)(valid, matched),
            );
            cxt.pass(valid);
          }
        },
        metaSchema: {
          type: "array",
          items: {
            type: "string",
            format: "regex",
          },
          uniqueItems: true,
        },
      };
    }
    exports.default = getDef;
    module.exports = getDef;
  });
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/patternRequired.js
var require_patternRequired = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$8) => {
    var __importDefault =
      (this$8 && this$8.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule
          ? mod
          : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const patternRequired_1 = __importDefault(
      require_patternRequired$1(),
    );
    const patternRequired = (ajv) =>
      ajv.addKeyword((0, patternRequired_1.default)());
    exports.default = patternRequired;
    module.exports = patternRequired;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/prohibited.js
var require_prohibited$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    function getDef() {
      return {
        keyword: "prohibited",
        type: "object",
        schemaType: "array",
        macro: function (schema) {
          if (schema.length === 0) return true;
          if (schema.length === 1)
            return { not: { required: schema } };
          return {
            not: {
              anyOf: schema.map((p) => ({ required: [p] })),
            },
          };
        },
        metaSchema: {
          type: "array",
          items: { type: "string" },
        },
      };
    }
    exports.default = getDef;
    module.exports = getDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/prohibited.js
var require_prohibited = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$7) => {
    var __importDefault =
      (this$7 && this$7.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule
          ? mod
          : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const prohibited_1 = __importDefault(
      require_prohibited$1(),
    );
    const prohibited = (ajv) =>
      ajv.addKeyword((0, prohibited_1.default)());
    exports.default = prohibited;
    module.exports = prohibited;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/deepProperties.js
var require_deepProperties$1 =
  /* @__PURE__ */ __commonJSMin((exports, module) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const _util_1 = require__util();
    function getDef(opts) {
      return {
        keyword: "deepProperties",
        type: "object",
        schemaType: "object",
        macro: function (schema) {
          const allOf = [];
          for (const pointer in schema)
            allOf.push(getSchema(pointer, schema[pointer]));
          return { allOf };
        },
        metaSchema: {
          type: "object",
          propertyNames: {
            type: "string",
            format: "json-pointer",
          },
          additionalProperties: (0, _util_1.metaSchemaRef)(
            opts,
          ),
        },
      };
    }
    exports.default = getDef;
    function getSchema(jsonPointer, schema) {
      const segments = jsonPointer.split("/");
      const rootSchema = {};
      let pointerSchema = rootSchema;
      for (let i = 1; i < segments.length; i++) {
        let segment = segments[i];
        const isLast = i === segments.length - 1;
        segment = unescapeJsonPointer(segment);
        const properties = (pointerSchema.properties = {});
        let items;
        if (/[0-9]+/.test(segment)) {
          let count = +segment;
          items = pointerSchema.items = [];
          pointerSchema.type = ["object", "array"];
          while (count--) items.push({});
        } else pointerSchema.type = "object";
        pointerSchema = isLast ? schema : {};
        properties[segment] = pointerSchema;
        if (items) items.push(pointerSchema);
      }
      return rootSchema;
    }
    function unescapeJsonPointer(str) {
      return str.replace(/~1/g, "/").replace(/~0/g, "~");
    }
    module.exports = getDef;
  });
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/deepProperties.js
var require_deepProperties = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$6) => {
    var __importDefault =
      (this$6 && this$6.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule
          ? mod
          : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const deepProperties_1 = __importDefault(
      require_deepProperties$1(),
    );
    const deepProperties = (ajv, opts) =>
      ajv.addKeyword((0, deepProperties_1.default)(opts));
    exports.default = deepProperties;
    module.exports = deepProperties;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/deepRequired.js
var require_deepRequired$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    function getDef() {
      return {
        keyword: "deepRequired",
        type: "object",
        schemaType: "array",
        code(ctx) {
          const { schema, data } = ctx;
          const props = schema.map(
            (jp) =>
              (0,
              codegen_1._)`(${getData(jp)}) === undefined`,
          );
          ctx.fail((0, codegen_1.or)(...props));
          function getData(jsonPointer) {
            if (jsonPointer === "")
              throw new Error(
                "empty JSON pointer not allowed",
              );
            const segments = jsonPointer.split("/");
            let x = data;
            const xs = segments.map((s, i) =>
              i
                ? (x = (0,
                  codegen_1._)`${x}${(0, codegen_1.getProperty)(unescapeJPSegment(s))}`)
                : x,
            );
            return (0, codegen_1.and)(...xs);
          }
        },
        metaSchema: {
          type: "array",
          items: {
            type: "string",
            format: "json-pointer",
          },
        },
      };
    }
    exports.default = getDef;
    function unescapeJPSegment(s) {
      return s.replace(/~1/g, "/").replace(/~0/g, "~");
    }
    module.exports = getDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/deepRequired.js
var require_deepRequired = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$5) => {
    var __importDefault =
      (this$5 && this$5.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule
          ? mod
          : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const deepRequired_1 = __importDefault(
      require_deepRequired$1(),
    );
    const deepRequired = (ajv) =>
      ajv.addKeyword((0, deepRequired_1.default)());
    exports.default = deepRequired;
    module.exports = deepRequired;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/dynamicDefaults.js
var require_dynamicDefaults$1 =
  /* @__PURE__ */ __commonJSMin((exports, module) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const sequences = {};
    const DEFAULTS = {
      timestamp: () => () => Date.now(),
      datetime: () => () =>
        /* @__PURE__ */ new Date().toISOString(),
      date: () => () =>
        /* @__PURE__ */ new Date()
          .toISOString()
          .slice(0, 10),
      time: () => () =>
        /* @__PURE__ */ new Date().toISOString().slice(11),
      random: () => () => Math.random(),
      randomint: (args) => {
        var _a;
        const max =
          (_a =
            args === null || args === void 0
              ? void 0
              : args.max) !== null && _a !== void 0
            ? _a
            : 2;
        return () => Math.floor(Math.random() * max);
      },
      seq: (args) => {
        var _a;
        const name =
          (_a =
            args === null || args === void 0
              ? void 0
              : args.name) !== null && _a !== void 0
            ? _a
            : "";
        sequences[name] || (sequences[name] = 0);
        return () => sequences[name]++;
      },
    };
    const getDef = Object.assign(_getDef, { DEFAULTS });
    function _getDef() {
      return {
        keyword: "dynamicDefaults",
        type: "object",
        schemaType: ["string", "object"],
        modifying: true,
        valid: true,
        compile(schema, _parentSchema, it) {
          if (!it.opts.useDefaults || it.compositeRule)
            return () => true;
          const fs = {};
          for (const key in schema)
            fs[key] = getDefault(schema[key]);
          const empty = it.opts.useDefaults === "empty";
          return (data) => {
            for (const prop in schema)
              if (
                data[prop] === void 0 ||
                (empty &&
                  (data[prop] === null ||
                    data[prop] === ""))
              )
                data[prop] = fs[prop]();
            return true;
          };
        },
        metaSchema: {
          type: "object",
          additionalProperties: {
            anyOf: [
              { type: "string" },
              {
                type: "object",
                additionalProperties: false,
                required: ["func", "args"],
                properties: {
                  func: { type: "string" },
                  args: { type: "object" },
                },
              },
            ],
          },
        },
      };
    }
    function getDefault(d) {
      return typeof d == "object"
        ? getObjDefault(d)
        : getStrDefault(d);
    }
    function getObjDefault({ func, args }) {
      const def = DEFAULTS[func];
      assertDefined(func, def);
      return def(args);
    }
    function getStrDefault(d = "") {
      const def = DEFAULTS[d];
      assertDefined(d, def);
      return def();
    }
    function assertDefined(name, def) {
      if (!def)
        throw new Error(
          `invalid "dynamicDefaults" keyword property value: ${name}`,
        );
    }
    exports.default = getDef;
    module.exports = getDef;
  });
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/dynamicDefaults.js
var require_dynamicDefaults = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$4) => {
    var __importDefault =
      (this$4 && this$4.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule
          ? mod
          : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const dynamicDefaults_1 = __importDefault(
      require_dynamicDefaults$1(),
    );
    const dynamicDefaults = (ajv) =>
      ajv.addKeyword((0, dynamicDefaults_1.default)());
    exports.default = dynamicDefaults;
    module.exports = dynamicDefaults;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/select.js
var require_select$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const codegen_1 = require_codegen();
    const _util_1 = require__util();
    const error = {
      message: ({ params: { schemaProp } }) =>
        schemaProp
          ? (0,
            codegen_1.str)`should match case "${schemaProp}" schema`
          : (0,
            codegen_1.str)`should match default case schema`,
      params: ({ params: { schemaProp } }) =>
        schemaProp
          ? (0, codegen_1._)`{failingCase: ${schemaProp}}`
          : (0, codegen_1._)`{failingDefault: true}`,
    };
    function getDef(opts) {
      const metaSchema = (0, _util_1.metaSchemaRef)(opts);
      return [
        {
          keyword: "select",
          schemaType: [
            "string",
            "number",
            "boolean",
            "null",
          ],
          $data: true,
          error,
          dependencies: ["selectCases"],
          code(cxt) {
            const { gen, schemaCode, parentSchema } = cxt;
            cxt.block$data(codegen_1.nil, () => {
              const valid = gen.let("valid", true);
              const schValid = gen.name("_valid");
              const value = gen.const(
                "value",
                (0,
                codegen_1._)`${schemaCode} === null ? "null" : ${schemaCode}`,
              );
              gen.if(false);
              for (const schemaProp in parentSchema.selectCases) {
                cxt.setParams({ schemaProp });
                gen.elseIf(
                  (0,
                  codegen_1._)`"" + ${value} == ${schemaProp}`,
                );
                const schCxt = cxt.subschema(
                  {
                    keyword: "selectCases",
                    schemaProp,
                  },
                  schValid,
                );
                cxt.mergeEvaluated(schCxt, codegen_1.Name);
                gen.assign(valid, schValid);
              }
              gen.else();
              if (parentSchema.selectDefault !== void 0) {
                cxt.setParams({ schemaProp: void 0 });
                const schCxt = cxt.subschema(
                  { keyword: "selectDefault" },
                  schValid,
                );
                cxt.mergeEvaluated(schCxt, codegen_1.Name);
                gen.assign(valid, schValid);
              }
              gen.endIf();
              cxt.pass(valid);
            });
          },
        },
        {
          keyword: "selectCases",
          dependencies: ["select"],
          metaSchema: {
            type: "object",
            additionalProperties: metaSchema,
          },
        },
        {
          keyword: "selectDefault",
          dependencies: ["select", "selectCases"],
          metaSchema,
        },
      ];
    }
    exports.default = getDef;
    module.exports = getDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/select.js
var require_select = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$3) => {
    var __importDefault =
      (this$3 && this$3.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule
          ? mod
          : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const select_1 = __importDefault(require_select$1());
    const select = (ajv, opts) => {
      (0, select_1.default)(opts).forEach((d) =>
        ajv.addKeyword(d),
      );
      return ajv;
    };
    exports.default = select;
    module.exports = select;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/index.js
var require_keywords = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$2) => {
    var __importDefault =
      (this$2 && this$2.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule
          ? mod
          : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const typeof_1 = __importDefault(require_typeof());
    const instanceof_1 = __importDefault(
      require_instanceof(),
    );
    const range_1 = __importDefault(require_range());
    const exclusiveRange_1 = __importDefault(
      require_exclusiveRange(),
    );
    const regexp_1 = __importDefault(require_regexp());
    const transform_1 = __importDefault(
      require_transform(),
    );
    const uniqueItemProperties_1 = __importDefault(
      require_uniqueItemProperties(),
    );
    const allRequired_1 = __importDefault(
      require_allRequired(),
    );
    const anyRequired_1 = __importDefault(
      require_anyRequired(),
    );
    const oneRequired_1 = __importDefault(
      require_oneRequired(),
    );
    const patternRequired_1 = __importDefault(
      require_patternRequired(),
    );
    const prohibited_1 = __importDefault(
      require_prohibited(),
    );
    const deepProperties_1 = __importDefault(
      require_deepProperties(),
    );
    const deepRequired_1 = __importDefault(
      require_deepRequired(),
    );
    const dynamicDefaults_1 = __importDefault(
      require_dynamicDefaults(),
    );
    const select_1 = __importDefault(require_select());
    const ajvKeywords = {
      typeof: typeof_1.default,
      instanceof: instanceof_1.default,
      range: range_1.default,
      exclusiveRange: exclusiveRange_1.default,
      regexp: regexp_1.default,
      transform: transform_1.default,
      uniqueItemProperties: uniqueItemProperties_1.default,
      allRequired: allRequired_1.default,
      anyRequired: anyRequired_1.default,
      oneRequired: oneRequired_1.default,
      patternRequired: patternRequired_1.default,
      prohibited: prohibited_1.default,
      deepProperties: deepProperties_1.default,
      deepRequired: deepRequired_1.default,
      dynamicDefaults: dynamicDefaults_1.default,
      select: select_1.default,
    };
    exports.default = ajvKeywords;
    module.exports = ajvKeywords;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/index.js
var require_dist = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$1) => {
    var __importDefault =
      (this$1 && this$1.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule
          ? mod
          : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    const keywords_1 = __importDefault(require_keywords());
    const ajvKeywords = (ajv, keyword) => {
      if (Array.isArray(keyword)) {
        for (const k of keyword) get(k)(ajv);
        return ajv;
      }
      if (keyword) {
        get(keyword)(ajv);
        return ajv;
      }
      for (keyword in keywords_1.default) get(keyword)(ajv);
      return ajv;
    };
    ajvKeywords.get = get;
    function get(keyword) {
      const defFunc = keywords_1.default[keyword];
      if (!defFunc)
        throw new Error("Unknown keyword " + keyword);
      return defFunc;
    }
    exports.default = ajvKeywords;
    module.exports = ajvKeywords;
    module.exports.default = ajvKeywords;
  },
);
//#endregion
//#region ../schemas/libraries/ajv/download/index.ts
var import_ajv = require_ajv();
var import_dist = /* @__PURE__ */ __toESM(
  require_dist$1(),
  1,
);
var import_dist$1 = /* @__PURE__ */ __toESM(
  require_dist(),
  1,
);
const ajv = new import_ajv.Ajv();
(0, import_dist.default)(ajv, { formats: ["url"] });
(0, import_dist$1.default)(ajv, ["instanceof"]);
const dateSchema = {
  type: "object",
  instanceof: "Date",
  required: [],
};
const imageSchema = {
  type: "object",
  properties: {
    id: { type: "number" },
    created: dateSchema,
    title: {
      type: "string",
      minLength: 1,
      maxLength: 100,
    },
    type: {
      type: "string",
      enum: ["jpg", "png"],
    },
    size: { type: "number" },
    url: {
      type: "string",
      format: "url",
    },
  },
  required: [
    "id",
    "created",
    "title",
    "type",
    "size",
    "url",
  ],
};
const productSchema = {
  type: "object",
  properties: {
    id: { type: "number" },
    created: dateSchema,
    title: {
      type: "string",
      minLength: 1,
      maxLength: 100,
    },
    brand: {
      type: "string",
      minLength: 1,
      maxLength: 30,
    },
    description: {
      type: "string",
      minLength: 1,
      maxLength: 500,
    },
    price: {
      type: "number",
      minimum: 1,
      maximum: 1e4,
    },
    discount: {
      type: "number",
      minimum: 1,
      maximum: 100,
      nullable: true,
    },
    quantity: {
      type: "number",
      minimum: 0,
      maximum: 10,
    },
    tags: {
      type: "array",
      items: {
        type: "string",
        minLength: 1,
        maxLength: 30,
      },
    },
    images: {
      type: "array",
      items: imageSchema,
    },
    ratings: {
      type: "array",
      items: {
        type: "object",
        properties: {
          id: { type: "number" },
          stars: {
            type: "number",
            minimum: 1,
            maximum: 5,
          },
          title: {
            type: "string",
            minLength: 1,
            maxLength: 100,
          },
          text: {
            type: "string",
            minLength: 1,
            maxLength: 1e3,
          },
          images: {
            type: "array",
            items: imageSchema,
          },
        },
        required: [
          "id",
          "stars",
          "title",
          "text",
          "images",
        ],
      },
    },
  },
  required: [
    "id",
    "created",
    "title",
    "brand",
    "description",
    "price",
    "discount",
    "quantity",
    "tags",
    "images",
    "ratings",
  ],
};
ajv.validate(productSchema, {});
//#endregion

//#region \0rolldown/runtime.js
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJSMin = (cb, mod) => () => (
  mod || (cb((mod = { exports: {} }).exports, mod, mod.exports), (cb = null)),
  mod.exports
);
var __copyProps = (to, from, except, desc) => {
  if ((from && typeof from === "object") || typeof from === "function")
    for (
      var keys = __getOwnPropNames(from), i = 0, n = keys.length, key;
      i < n;
      i++
    ) {
      key = keys[i];
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, {
          get: ((k) => from[k]).bind(null, key),
          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
        });
    }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (
  (target = mod != null ? __create(__getProtoOf(mod)) : {}),
  __copyProps(
    isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default")
      ? __defProp(target, "default", {
          value: mod,
          enumerable: true,
        })
      : target,
    mod,
  )
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/code.js
var require_code$1 = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.regexpCode =
    exports.getEsmExportName =
    exports.getProperty =
    exports.safeStringify =
    exports.stringify =
    exports.strConcat =
    exports.addCodeArg =
    exports.str =
    exports._ =
    exports.nil =
    exports._Code =
    exports.Name =
    exports.IDENTIFIER =
    exports._CodeOrName =
      void 0;
  var _CodeOrName = class {};
  exports._CodeOrName = _CodeOrName;
  exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
  var Name = class extends _CodeOrName {
    constructor(s) {
      super();
      if (!exports.IDENTIFIER.test(s))
        throw new Error("CodeGen: name must be a valid identifier");
      this.str = s;
    }
    toString() {
      return this.str;
    }
    emptyStr() {
      return false;
    }
    get names() {
      return { [this.str]: 1 };
    }
  };
  exports.Name = Name;
  var _Code = class extends _CodeOrName {
    constructor(code) {
      super();
      this._items = typeof code === "string" ? [code] : code;
    }
    toString() {
      return this.str;
    }
    emptyStr() {
      if (this._items.length > 1) return false;
      const item = this._items[0];
      return item === "" || item === '""';
    }
    get str() {
      var _a;
      return (_a = this._str) !== null && _a !== void 0
        ? _a
        : (this._str = this._items.reduce((s, c) => `${s}${c}`, ""));
    }
    get names() {
      var _a;
      return (_a = this._names) !== null && _a !== void 0
        ? _a
        : (this._names = this._items.reduce((names, c) => {
            if (c instanceof Name) names[c.str] = (names[c.str] || 0) + 1;
            return names;
          }, {}));
    }
  };
  exports._Code = _Code;
  exports.nil = new _Code("");
  function _(strs, ...args) {
    const code = [strs[0]];
    let i = 0;
    while (i < args.length) {
      addCodeArg(code, args[i]);
      code.push(strs[++i]);
    }
    return new _Code(code);
  }
  exports._ = _;
  const plus = new _Code("+");
  function str(strs, ...args) {
    const expr = [safeStringify(strs[0])];
    let i = 0;
    while (i < args.length) {
      expr.push(plus);
      addCodeArg(expr, args[i]);
      expr.push(plus, safeStringify(strs[++i]));
    }
    optimize(expr);
    return new _Code(expr);
  }
  exports.str = str;
  function addCodeArg(code, arg) {
    if (arg instanceof _Code) code.push(...arg._items);
    else if (arg instanceof Name) code.push(arg);
    else code.push(interpolate(arg));
  }
  exports.addCodeArg = addCodeArg;
  function optimize(expr) {
    let i = 1;
    while (i < expr.length - 1) {
      if (expr[i] === plus) {
        const res = mergeExprItems(expr[i - 1], expr[i + 1]);
        if (res !== void 0) {
          expr.splice(i - 1, 3, res);
          continue;
        }
        expr[i++] = "+";
      }
      i++;
    }
  }
  function mergeExprItems(a, b) {
    if (b === '""') return a;
    if (a === '""') return b;
    if (typeof a == "string") {
      if (b instanceof Name || a[a.length - 1] !== '"') return;
      if (typeof b != "string") return `${a.slice(0, -1)}${b}"`;
      if (b[0] === '"') return a.slice(0, -1) + b.slice(1);
      return;
    }
    if (typeof b == "string" && b[0] === '"' && !(a instanceof Name))
      return `"${a}${b.slice(1)}`;
  }
  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;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/scope.js
var require_scope = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.ValueScope =
    exports.ValueScopeName =
    exports.Scope =
    exports.varKinds =
    exports.UsedValueState =
      void 0;
  const code_1 = require_code$1();
  var ValueError = class extends Error {
    constructor(name) {
      super(`CodeGen: "code" for ${name} not defined`);
      this.value = name.value;
    }
  };
  var UsedValueState;
  (function (UsedValueState) {
    UsedValueState[(UsedValueState["Started"] = 0)] = "Started";
    UsedValueState[(UsedValueState["Completed"] = 1)] = "Completed";
  })(UsedValueState || (exports.UsedValueState = UsedValueState = {}));
  exports.varKinds = {
    const: new code_1.Name("const"),
    let: new code_1.Name("let"),
    var: new code_1.Name("var"),
  };
  var Scope = class {
    constructor({ prefixes, parent } = {}) {
      this._names = {};
      this._prefixes = prefixes;
      this._parent = parent;
    }
    toName(nameOrPrefix) {
      return nameOrPrefix instanceof code_1.Name
        ? nameOrPrefix
        : this.name(nameOrPrefix);
    }
    name(prefix) {
      return new code_1.Name(this._newName(prefix));
    }
    _newName(prefix) {
      const ng = this._names[prefix] || this._nameGroup(prefix);
      return `${prefix}${ng.index++}`;
    }
    _nameGroup(prefix) {
      var _a, _b;
      if (
        ((_b =
          (_a = this._parent) === null || _a === void 0
            ? void 0
            : _a._prefixes) === null || _b === void 0
          ? void 0
          : _b.has(prefix)) ||
        (this._prefixes && !this._prefixes.has(prefix))
      )
        throw new Error(
          `CodeGen: prefix "${prefix}" is not allowed in this scope`,
        );
      return (this._names[prefix] = {
        prefix,
        index: 0,
      });
    }
  };
  exports.Scope = Scope;
  var ValueScopeName = class extends code_1.Name {
    constructor(prefix, nameStr) {
      super(nameStr);
      this.prefix = prefix;
    }
    setValue(value, { property, itemIndex }) {
      this.value = value;
      this.scopePath = (0,
      code_1._)`.${new code_1.Name(property)}[${itemIndex}]`;
    }
  };
  exports.ValueScopeName = ValueScopeName;
  const line = (0, code_1._)`\n`;
  var ValueScope = class extends Scope {
    constructor(opts) {
      super(opts);
      this._values = {};
      this._scope = opts.scope;
      this.opts = {
        ...opts,
        _n: opts.lines ? line : code_1.nil,
      };
    }
    get() {
      return this._scope;
    }
    name(prefix) {
      return new ValueScopeName(prefix, this._newName(prefix));
    }
    value(nameOrPrefix, value) {
      var _a;
      if (value.ref === void 0)
        throw new Error("CodeGen: ref must be passed in value");
      const name = this.toName(nameOrPrefix);
      const { prefix } = name;
      const valueKey =
        (_a = value.key) !== null && _a !== void 0 ? _a : value.ref;
      let vs = this._values[prefix];
      if (vs) {
        const _name = vs.get(valueKey);
        if (_name) return _name;
      } else vs = this._values[prefix] = /* @__PURE__ */ new Map();
      vs.set(valueKey, name);
      const s = this._scope[prefix] || (this._scope[prefix] = []);
      const itemIndex = s.length;
      s[itemIndex] = value.ref;
      name.setValue(value, {
        property: prefix,
        itemIndex,
      });
      return name;
    }
    getValue(prefix, keyOrRef) {
      const vs = this._values[prefix];
      if (!vs) return;
      return vs.get(keyOrRef);
    }
    scopeRefs(scopeName, values = this._values) {
      return this._reduceValues(values, (name) => {
        if (name.scopePath === void 0)
          throw new Error(`CodeGen: name "${name}" has no value`);
        return (0, code_1._)`${scopeName}${name.scopePath}`;
      });
    }
    scopeCode(values = this._values, usedValues, getCode) {
      return this._reduceValues(
        values,
        (name) => {
          if (name.value === void 0)
            throw new Error(`CodeGen: name "${name}" has no value`);
          return name.value.code;
        },
        usedValues,
        getCode,
      );
    }
    _reduceValues(values, valueCode, usedValues = {}, getCode) {
      let code = code_1.nil;
      for (const prefix in values) {
        const vs = values[prefix];
        if (!vs) continue;
        const nameSet = (usedValues[prefix] =
          usedValues[prefix] || /* @__PURE__ */ new Map());
        vs.forEach((name) => {
          if (nameSet.has(name)) return;
          nameSet.set(name, UsedValueState.Started);
          let c = valueCode(name);
          if (c) {
            const def = this.opts.es5
              ? exports.varKinds.var
              : exports.varKinds.const;
            code = (0, code_1._)`${code}${def} ${name} = ${c};${this.opts._n}`;
          } else if (
            (c =
              getCode === null || getCode === void 0 ? void 0 : getCode(name))
          )
            code = (0, code_1._)`${code}${c}${this.opts._n}`;
          else throw new ValueError(name);
          nameSet.set(name, UsedValueState.Completed);
        });
      }
      return code;
    }
  };
  exports.ValueScope = ValueScope;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/index.js
var require_codegen = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.or =
    exports.and =
    exports.not =
    exports.CodeGen =
    exports.operators =
    exports.varKinds =
    exports.ValueScopeName =
    exports.ValueScope =
    exports.Scope =
    exports.Name =
    exports.regexpCode =
    exports.stringify =
    exports.getProperty =
    exports.nil =
    exports.strConcat =
    exports.str =
    exports._ =
      void 0;
  const code_1 = require_code$1();
  const scope_1 = require_scope();
  var code_2 = require_code$1();
  Object.defineProperty(exports, "_", {
    enumerable: true,
    get: function () {
      return code_2._;
    },
  });
  Object.defineProperty(exports, "str", {
    enumerable: true,
    get: function () {
      return code_2.str;
    },
  });
  Object.defineProperty(exports, "strConcat", {
    enumerable: true,
    get: function () {
      return code_2.strConcat;
    },
  });
  Object.defineProperty(exports, "nil", {
    enumerable: true,
    get: function () {
      return code_2.nil;
    },
  });
  Object.defineProperty(exports, "getProperty", {
    enumerable: true,
    get: function () {
      return code_2.getProperty;
    },
  });
  Object.defineProperty(exports, "stringify", {
    enumerable: true,
    get: function () {
      return code_2.stringify;
    },
  });
  Object.defineProperty(exports, "regexpCode", {
    enumerable: true,
    get: function () {
      return code_2.regexpCode;
    },
  });
  Object.defineProperty(exports, "Name", {
    enumerable: true,
    get: function () {
      return code_2.Name;
    },
  });
  var scope_2 = require_scope();
  Object.defineProperty(exports, "Scope", {
    enumerable: true,
    get: function () {
      return scope_2.Scope;
    },
  });
  Object.defineProperty(exports, "ValueScope", {
    enumerable: true,
    get: function () {
      return scope_2.ValueScope;
    },
  });
  Object.defineProperty(exports, "ValueScopeName", {
    enumerable: true,
    get: function () {
      return scope_2.ValueScopeName;
    },
  });
  Object.defineProperty(exports, "varKinds", {
    enumerable: true,
    get: function () {
      return scope_2.varKinds;
    },
  });
  exports.operators = {
    GT: new code_1._Code(">"),
    GTE: new code_1._Code(">="),
    LT: new code_1._Code("<"),
    LTE: new code_1._Code("<="),
    EQ: new code_1._Code("==="),
    NEQ: new code_1._Code("!=="),
    NOT: new code_1._Code("!"),
    OR: new code_1._Code("||"),
    AND: new code_1._Code("&&"),
    ADD: new code_1._Code("+"),
  };
  var Node = class {
    optimizeNodes() {
      return this;
    }
    optimizeNames(_names, _constants) {
      return this;
    }
  };
  var Def = class extends Node {
    constructor(varKind, name, rhs) {
      super();
      this.varKind = varKind;
      this.name = name;
      this.rhs = rhs;
    }
    render({ es5, _n }) {
      const varKind = es5 ? scope_1.varKinds.var : this.varKind;
      const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
      return `${varKind} ${this.name}${rhs};` + _n;
    }
    optimizeNames(names, 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() {
      return addExprNames(
        this.lhs instanceof code_1.Name ? {} : { ...this.lhs.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 }) {
      return `break${this.label ? ` ${this.label}` : ""};` + _n;
    }
  };
  var Throw = class extends Node {
    constructor(error) {
      super();
      this.error = error;
    }
    render({ _n }) {
      return `throw ${this.error};` + _n;
    }
    get names() {
      return this.error.names;
    }
  };
  var AnyCode = class extends Node {
    constructor(code) {
      super();
      this.code = code;
    }
    render({ _n }) {
      return `${this.code};` + _n;
    }
    optimizeNodes() {
      return `${this.code}` ? this : void 0;
    }
    optimizeNames(names, 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 _a;
      this.else =
        (_a = this.else) === null || _a === void 0
          ? void 0
          : _a.optimizeNames(names, constants);
      if (!(super.optimizeNames(names, constants) || this.else)) return;
      this.condition = optimizeExpr(this.condition, names, constants);
      return this;
    }
    get names() {
      const names = super.names;
      addExprNames(names, this.condition);
      if (this.else) addNames(names, this.else.names);
      return names;
    }
  };
  If.kind = "if";
  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() {
      return addExprNames(addExprNames(super.names, this.from), 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, args, async) {
      super();
      this.name = name;
      this.args = args;
      this.async = async;
    }
    render(opts) {
      return (
        `${this.async ? "async " : ""}function ${this.name}(${this.args})` +
        super.render(opts)
      );
    }
  };
  Func.kind = "func";
  var Return = class extends ParentNode {
    render(opts) {
      return "return " + super.render(opts);
    }
  };
  Return.kind = "return";
  var Try = class extends BlockNode {
    render(opts) {
      let code = "try" + super.render(opts);
      if (this.catch) code += this.catch.render(opts);
      if (this.finally) code += this.finally.render(opts);
      return code;
    }
    optimizeNodes() {
      var _a, _b;
      super.optimizeNodes();
      (_a = this.catch) === null || _a === void 0 || _a.optimizeNodes();
      (_b = this.finally) === null || _b === void 0 || _b.optimizeNodes();
      return this;
    }
    optimizeNames(names, constants) {
      var _a, _b;
      super.optimizeNames(names, constants);
      (_a = this.catch) === null ||
        _a === void 0 ||
        _a.optimizeNames(names, constants);
      (_b = this.finally) === null ||
        _b === 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(error) {
      super();
      this.error = error;
    }
    render(opts) {
      return `catch(${this.error})` + super.render(opts);
    }
  };
  Catch.kind = "catch";
  var Finally = class extends BlockNode {
    render(opts) {
      return "finally" + super.render(opts);
    }
  };
  Finally.kind = "finally";
  var CodeGen = class {
    constructor(extScope, opts = {}) {
      this._values = {};
      this._blockStarts = [];
      this._constants = {};
      this.opts = {
        ...opts,
        _n: opts.lines ? "\n" : "",
      };
      this._extScope = extScope;
      this._scope = new scope_1.Scope({ parent: extScope });
      this._nodes = [new Root()];
    }
    toString() {
      return this._root.render(this.opts);
    }
    name(prefix) {
      return this._scope.name(prefix);
    }
    scopeName(prefix) {
      return this._extScope.name(prefix);
    }
    scopeValue(prefixOrName, value) {
      const name = this._extScope.value(prefixOrName, value);
      (
        this._values[name.prefix] ||
        (this._values[name.prefix] = /* @__PURE__ */ new Set())
      ).add(name);
      return name;
    }
    getScopeValue(prefix, keyOrRef) {
      return this._extScope.getValue(prefix, keyOrRef);
    }
    scopeRefs(scopeName) {
      return this._extScope.scopeRefs(scopeName, this._values);
    }
    scopeCode() {
      return this._extScope.scopeCode(this._values);
    }
    _def(varKind, nameOrPrefix, rhs, constant) {
      const name = this._scope.toName(nameOrPrefix);
      if (rhs !== void 0 && constant) this._constants[name.str] = rhs;
      this._leafNode(new Def(varKind, name, rhs));
      return name;
    }
    const(nameOrPrefix, rhs, _constant) {
      return this._def(scope_1.varKinds.const, nameOrPrefix, rhs, _constant);
    }
    let(nameOrPrefix, rhs, _constant) {
      return this._def(scope_1.varKinds.let, nameOrPrefix, rhs, _constant);
    }
    var(nameOrPrefix, rhs, _constant) {
      return this._def(scope_1.varKinds.var, nameOrPrefix, rhs, _constant);
    }
    assign(lhs, rhs, sideEffects) {
      return this._leafNode(new Assign(lhs, rhs, sideEffects));
    }
    add(lhs, rhs) {
      return this._leafNode(new AssignOp(lhs, exports.operators.ADD, rhs));
    }
    code(c) {
      if (typeof c == "function") c();
      else if (c !== code_1.nil) this._leafNode(new AnyCode(c));
      return this;
    }
    object(...keyValues) {
      const code = ["{"];
      for (const [key, value] of keyValues) {
        if (code.length > 1) code.push(",");
        code.push(key);
        if (key !== value || this.opts.es5) {
          code.push(":");
          (0, code_1.addCodeArg)(code, value);
        }
      }
      code.push("}");
      return new code_1._Code(code);
    }
    if(condition, thenBody, elseBody) {
      this._blockNode(new If(condition));
      if (thenBody && elseBody)
        this.code(thenBody).else().code(elseBody).endIf();
      else if (thenBody) this.code(thenBody).endIf();
      else if (elseBody)
        throw new Error('CodeGen: "else" body without "then" body');
      return this;
    }
    elseIf(condition) {
      return this._elseNode(new If(condition));
    }
    else() {
      return this._elseNode(new Else());
    }
    endIf() {
      return this._endBlockNode(If, Else);
    }
    _for(node, forBody) {
      this._blockNode(node);
      if (forBody) this.code(forBody).endFor();
      return this;
    }
    for(iteration, forBody) {
      return this._for(new ForLoop(iteration), forBody);
    }
    forRange(
      nameOrPrefix,
      from,
      to,
      forBody,
      varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.let,
    ) {
      const name = this._scope.toName(nameOrPrefix);
      return this._for(new ForRange(varKind, name, from, to), () =>
        forBody(name),
      );
    }
    forOf(nameOrPrefix, iterable, forBody, varKind = scope_1.varKinds.const) {
      const name = this._scope.toName(nameOrPrefix);
      if (this.opts.es5) {
        const arr =
          iterable instanceof code_1.Name
            ? iterable
            : this.var("_arr", iterable);
        return this.forRange("_i", 0, (0, code_1._)`${arr}.length`, (i) => {
          this.var(name, (0, code_1._)`${arr}[${i}]`);
          forBody(name);
        });
      }
      return this._for(new ForIter("of", varKind, name, iterable), () =>
        forBody(name),
      );
    }
    forIn(
      nameOrPrefix,
      obj,
      forBody,
      varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.const,
    ) {
      if (this.opts.ownProperties)
        return this.forOf(
          nameOrPrefix,
          (0, code_1._)`Object.keys(${obj})`,
          forBody,
        );
      const name = this._scope.toName(nameOrPrefix);
      return this._for(new ForIter("in", varKind, name, obj), () =>
        forBody(name),
      );
    }
    endFor() {
      return this._endBlockNode(For);
    }
    label(label) {
      return this._leafNode(new Label(label));
    }
    break(label) {
      return this._leafNode(new Break(label));
    }
    return(value) {
      const node = new Return();
      this._blockNode(node);
      this.code(value);
      if (node.nodes.length !== 1)
        throw new Error('CodeGen: "return" should have one node');
      return this._endBlockNode(Return);
    }
    try(tryBody, catchCode, finallyCode) {
      if (!catchCode && !finallyCode)
        throw new Error('CodeGen: "try" without "catch" and "finally"');
      const node = new Try();
      this._blockNode(node);
      this.code(tryBody);
      if (catchCode) {
        const error = this.name("e");
        this._currNode = node.catch = new Catch(error);
        catchCode(error);
      }
      if (finallyCode) {
        this._currNode = node.finally = new Finally();
        this.code(finallyCode);
      }
      return this._endBlockNode(Catch, Finally);
    }
    throw(error) {
      return this._leafNode(new Throw(error));
    }
    block(body, nodeCount) {
      this._blockStarts.push(this._nodes.length);
      if (body) this.code(body).endBlock(nodeCount);
      return this;
    }
    endBlock(nodeCount) {
      const len = this._blockStarts.pop();
      if (len === 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;
    }
    func(name, args = code_1.nil, async, funcBody) {
      this._blockNode(new Func(name, args, async));
      if (funcBody) this.code(funcBody).endFunc();
      return this;
    }
    endFunc() {
      return this._endBlockNode(Func);
    }
    optimize(n = 1) {
      while (n-- > 0) {
        this._root.optimizeNodes();
        this._root.optimizeNames(this._root.names, this._constants);
      }
    }
    _leafNode(node) {
      this._currNode.nodes.push(node);
      return this;
    }
    _blockNode(node) {
      this._currNode.nodes.push(node);
      this._nodes.push(node);
    }
    _endBlockNode(N1, N2) {
      const n = this._currNode;
      if (n instanceof N1 || (N2 && n instanceof N2)) {
        this._nodes.pop();
        return this;
      }
      throw new Error(
        `CodeGen: not in block "${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}"`,
      );
    }
    _elseNode(node) {
      const n = this._currNode;
      if (!(n instanceof If)) throw new Error('CodeGen: "else" without "if"');
      this._currNode = n.else = node;
      return this;
    }
    get _root() {
      return this._nodes[0];
    }
    get _currNode() {
      const ns = this._nodes;
      return ns[ns.length - 1];
    }
    set _currNode(node) {
      const ns = this._nodes;
      ns[ns.length - 1] = node;
    }
  };
  exports.CodeGen = CodeGen;
  function addNames(names, from) {
    for (const n in from) names[n] = (names[n] || 0) + (from[n] || 0);
    return names;
  }
  function addExprNames(names, from) {
    return from instanceof code_1._CodeOrName
      ? addNames(names, from.names)
      : names;
  }
  function optimizeExpr(expr, names, constants) {
    if (expr instanceof code_1.Name) return replaceName(expr);
    if (!canOptimize(expr)) return expr;
    return new code_1._Code(
      expr._items.reduce((items, c) => {
        if (c instanceof code_1.Name) c = replaceName(c);
        if (c instanceof code_1._Code) items.push(...c._items);
        else items.push(c);
        return items;
      }, []),
    );
    function replaceName(n) {
      const c = constants[n.str];
      if (c === 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;
  const andCode = mappend(exports.operators.AND);
  function and(...args) {
    return args.reduce(andCode);
  }
  exports.and = and;
  const orCode = mappend(exports.operators.OR);
  function or(...args) {
    return args.reduce(orCode);
  }
  exports.or = or;
  function mappend(op) {
    return (x, y) =>
      x === code_1.nil
        ? y
        : y === code_1.nil
          ? x
          : (0, code_1._)`${par(x)} ${op} ${par(y)}`;
  }
  function par(x) {
    return x instanceof code_1.Name ? x : (0, code_1._)`(${x})`;
  }
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/util.js
var require_util = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.checkStrictMode =
    exports.getErrorPath =
    exports.Type =
    exports.useFunc =
    exports.setEvaluated =
    exports.evaluatedPropsToName =
    exports.mergeEvaluated =
    exports.eachItem =
    exports.unescapeJsonPointer =
    exports.escapeJsonPointer =
    exports.escapeFragment =
    exports.unescapeFragment =
    exports.schemaRefOrVal =
    exports.schemaHasRulesButRef =
    exports.schemaHasRules =
    exports.checkUnknownRules =
    exports.alwaysValidSchema =
    exports.toHash =
      void 0;
  const codegen_1 = require_codegen();
  const code_1 = require_code$1();
  function toHash(arr) {
    const hash = {};
    for (const item of arr) hash[item] = true;
    return hash;
  }
  exports.toHash = toHash;
  function alwaysValidSchema(it, schema) {
    if (typeof schema == "boolean") return schema;
    if (Object.keys(schema).length === 0) return true;
    checkUnknownRules(it, schema);
    return !schemaHasRules(schema, it.self.RULES.all);
  }
  exports.alwaysValidSchema = alwaysValidSchema;
  function checkUnknownRules(it, schema = it.schema) {
    const { opts, self } = it;
    if (!opts.strictSchema) return;
    if (typeof schema === "boolean") return;
    const rules = self.RULES.keywords;
    for (const key in schema)
      if (!rules[key]) checkStrictMode(it, `unknown keyword: "${key}"`);
  }
  exports.checkUnknownRules = checkUnknownRules;
  function schemaHasRules(schema, rules) {
    if (typeof schema == "boolean") return !schema;
    for (const key in schema) if (rules[key]) return true;
    return false;
  }
  exports.schemaHasRules = schemaHasRules;
  function schemaHasRulesButRef(schema, RULES) {
    if (typeof schema == "boolean") return !schema;
    for (const key in schema) if (key !== "$ref" && RULES.all[key]) return true;
    return false;
  }
  exports.schemaHasRulesButRef = schemaHasRulesButRef;
  function schemaRefOrVal(
    { topSchemaRef, schemaPath },
    schema,
    keyword,
    $data,
  ) {
    if (!$data) {
      if (typeof schema == "number" || typeof schema == "boolean")
        return schema;
      if (typeof schema == "string") return (0, codegen_1._)`${schema}`;
    }
    return (0,
    codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
  }
  exports.schemaRefOrVal = schemaRefOrVal;
  function unescapeFragment(str) {
    return unescapeJsonPointer(decodeURIComponent(str));
  }
  exports.unescapeFragment = unescapeFragment;
  function escapeFragment(str) {
    return encodeURIComponent(escapeJsonPointer(str));
  }
  exports.escapeFragment = escapeFragment;
  function escapeJsonPointer(str) {
    if (typeof str == "number") return `${str}`;
    return str.replace(/~/g, "~0").replace(/\//g, "~1");
  }
  exports.escapeJsonPointer = escapeJsonPointer;
  function unescapeJsonPointer(str) {
    return str.replace(/~1/g, "/").replace(/~0/g, "~");
  }
  exports.unescapeJsonPointer = unescapeJsonPointer;
  function eachItem(xs, f) {
    if (Array.isArray(xs)) for (const x of xs) f(x);
    else f(xs);
  }
  exports.eachItem = eachItem;
  function makeMergeEvaluated({
    mergeNames,
    mergeToName,
    mergeValues,
    resultToName,
  }) {
    return (gen, from, to, toName) => {
      const res =
        to === void 0
          ? from
          : to instanceof codegen_1.Name
            ? (from instanceof codegen_1.Name
                ? mergeNames(gen, from, to)
                : mergeToName(gen, from, to),
              to)
            : from instanceof codegen_1.Name
              ? (mergeToName(gen, to, from), from)
              : mergeValues(from, to);
      return toName === codegen_1.Name && !(res instanceof codegen_1.Name)
        ? resultToName(gen, res)
        : res;
    };
  }
  exports.mergeEvaluated = {
    props: makeMergeEvaluated({
      mergeNames: (gen, from, to) =>
        gen.if(
          (0, codegen_1._)`${to} !== true && ${from} !== undefined`,
          () => {
            gen.if(
              (0, codegen_1._)`${from} === true`,
              () => gen.assign(to, true),
              () =>
                gen
                  .assign(to, (0, codegen_1._)`${to} || {}`)
                  .code((0, codegen_1._)`Object.assign(${to}, ${from})`),
            );
          },
        ),
      mergeToName: (gen, from, to) =>
        gen.if((0, codegen_1._)`${to} !== true`, () => {
          if (from === true) gen.assign(to, true);
          else {
            gen.assign(to, (0, codegen_1._)`${to} || {}`);
            setEvaluated(gen, to, from);
          }
        }),
      mergeValues: (from, to) =>
        from === true
          ? true
          : {
              ...from,
              ...to,
            },
      resultToName: evaluatedPropsToName,
    }),
    items: makeMergeEvaluated({
      mergeNames: (gen, from, to) =>
        gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () =>
          gen.assign(
            to,
            (0,
            codegen_1._)`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`,
          ),
        ),
      mergeToName: (gen, from, to) =>
        gen.if((0, codegen_1._)`${to} !== true`, () =>
          gen.assign(
            to,
            from === true
              ? true
              : (0, codegen_1._)`${to} > ${from} ? ${to} : ${from}`,
          ),
        ),
      mergeValues: (from, to) => (from === true ? true : Math.max(from, to)),
      resultToName: (gen, items) => gen.var("items", items),
    }),
  };
  function evaluatedPropsToName(gen, ps) {
    if (ps === true) return gen.var("props", true);
    const props = gen.var("props", (0, codegen_1._)`{}`);
    if (ps !== void 0) setEvaluated(gen, props, ps);
    return props;
  }
  exports.evaluatedPropsToName = evaluatedPropsToName;
  function setEvaluated(gen, props, ps) {
    Object.keys(ps).forEach((p) =>
      gen.assign(
        (0, codegen_1._)`${props}${(0, codegen_1.getProperty)(p)}`,
        true,
      ),
    );
  }
  exports.setEvaluated = setEvaluated;
  const snippets = {};
  function useFunc(gen, f) {
    return gen.scopeValue("func", {
      ref: f,
      code: snippets[f.code] || (snippets[f.code] = new code_1._Code(f.code)),
    });
  }
  exports.useFunc = useFunc;
  var Type;
  (function (Type) {
    Type[(Type["Num"] = 0)] = "Num";
    Type[(Type["Str"] = 1)] = "Str";
  })(Type || (exports.Type = Type = {}));
  function getErrorPath(dataProp, dataPropType, jsPropertySyntax) {
    if (dataProp instanceof codegen_1.Name) {
      const isNumber = dataPropType === Type.Num;
      return jsPropertySyntax
        ? isNumber
          ? (0, codegen_1._)`"[" + ${dataProp} + "]"`
          : (0, codegen_1._)`"['" + ${dataProp} + "']"`
        : isNumber
          ? (0, codegen_1._)`"/" + ${dataProp}`
          : (0,
            codegen_1._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
    }
    return jsPropertySyntax
      ? (0, codegen_1.getProperty)(dataProp).toString()
      : "/" + escapeJsonPointer(dataProp);
  }
  exports.getErrorPath = getErrorPath;
  function checkStrictMode(it, msg, mode = it.opts.strictSchema) {
    if (!mode) return;
    msg = `strict mode: ${msg}`;
    if (mode === true) throw new Error(msg);
    it.self.logger.warn(msg);
  }
  exports.checkStrictMode = checkStrictMode;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/names.js
var require_names = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  exports.default = {
    data: new codegen_1.Name("data"),
    valCxt: new codegen_1.Name("valCxt"),
    instancePath: new codegen_1.Name("instancePath"),
    parentData: new codegen_1.Name("parentData"),
    parentDataProperty: new codegen_1.Name("parentDataProperty"),
    rootData: new codegen_1.Name("rootData"),
    dynamicAnchors: new codegen_1.Name("dynamicAnchors"),
    vErrors: new codegen_1.Name("vErrors"),
    errors: new codegen_1.Name("errors"),
    this: new codegen_1.Name("this"),
    self: new codegen_1.Name("self"),
    scope: new codegen_1.Name("scope"),
    json: new codegen_1.Name("json"),
    jsonPos: new codegen_1.Name("jsonPos"),
    jsonLen: new codegen_1.Name("jsonLen"),
    jsonPart: new codegen_1.Name("jsonPart"),
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/errors.js
var require_errors = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.extendErrors =
    exports.resetErrorsCount =
    exports.reportExtraError =
    exports.reportError =
    exports.keyword$DataError =
    exports.keywordError =
      void 0;
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const names_1 = require_names();
  exports.keywordError = {
    message: ({ keyword }) =>
      (0, codegen_1.str)`must pass "${keyword}" keyword validation`,
  };
  exports.keyword$DataError = {
    message: ({ keyword, schemaType }) =>
      schemaType
        ? (0, codegen_1.str)`"${keyword}" keyword must be ${schemaType} ($data)`
        : (0, codegen_1.str)`"${keyword}" keyword is invalid ($data)`,
  };
  function reportError(
    cxt,
    error = exports.keywordError,
    errorPaths,
    overrideAllErrors,
  ) {
    const { it } = cxt;
    const { gen, compositeRule, allErrors } = it;
    const errObj = errorObjectCode(cxt, error, errorPaths);
    if (
      overrideAllErrors !== null && overrideAllErrors !== void 0
        ? overrideAllErrors
        : compositeRule || allErrors
    )
      addError(gen, errObj);
    else returnErrors(it, (0, codegen_1._)`[${errObj}]`);
  }
  exports.reportError = reportError;
  function reportExtraError(cxt, error = exports.keywordError, errorPaths) {
    const { it } = cxt;
    const { gen, compositeRule, allErrors } = it;
    addError(gen, errorObjectCode(cxt, error, errorPaths));
    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 }) {
    /* istanbul ignore if */
    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);
    }
  }
  const E = {
    keyword: new codegen_1.Name("keyword"),
    schemaPath: new codegen_1.Name("schemaPath"),
    params: new codegen_1.Name("params"),
    propertyName: new codegen_1.Name("propertyName"),
    message: new codegen_1.Name("message"),
    schema: new codegen_1.Name("schema"),
    parentSchema: new codegen_1.Name("parentSchema"),
  };
  function errorObjectCode(cxt, error, errorPaths) {
    const { createErrors } = cxt.it;
    if (createErrors === false) return (0, codegen_1._)`{}`;
    return errorObject(cxt, error, errorPaths);
  }
  function errorObject(cxt, error, errorPaths = {}) {
    const { gen, it } = cxt;
    const keyValues = [
      errorInstancePath(it, errorPaths),
      errorSchemaPath(cxt, errorPaths),
    ];
    extraErrorProps(cxt, error, keyValues);
    return gen.object(...keyValues);
  }
  function errorInstancePath({ errorPath }, { instancePath }) {
    const instPath = instancePath
      ? (0,
        codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(instancePath, util_1.Type.Str)}`
      : errorPath;
    return [
      names_1.default.instancePath,
      (0, codegen_1.strConcat)(names_1.default.instancePath, instPath),
    ];
  }
  function errorSchemaPath(
    { keyword, it: { errSchemaPath } },
    { schemaPath, parentSchema },
  ) {
    let schPath = parentSchema
      ? errSchemaPath
      : (0, codegen_1.str)`${errSchemaPath}/${keyword}`;
    if (schemaPath)
      schPath = (0,
      codegen_1.str)`${schPath}${(0, util_1.getErrorPath)(schemaPath, util_1.Type.Str)}`;
    return [E.schemaPath, schPath];
  }
  function extraErrorProps(cxt, { params, message }, keyValues) {
    const { keyword, data, schemaValue, it } = cxt;
    const { opts, propertyName, topSchemaRef, schemaPath } = it;
    keyValues.push(
      [E.keyword, keyword],
      [
        E.params,
        typeof params == "function"
          ? params(cxt)
          : params || (0, codegen_1._)`{}`,
      ],
    );
    if (opts.messages)
      keyValues.push([
        E.message,
        typeof message == "function" ? message(cxt) : message,
      ]);
    if (opts.verbose)
      keyValues.push(
        [E.schema, schemaValue],
        [E.parentSchema, (0, codegen_1._)`${topSchemaRef}${schemaPath}`],
        [names_1.default.data, data],
      );
    if (propertyName) keyValues.push([E.propertyName, propertyName]);
  }
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/boolSchema.js
var require_boolSchema = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.boolOrEmptySchema = exports.topBoolOrEmptySchema = void 0;
  const errors_1 = require_errors();
  const codegen_1 = require_codegen();
  const names_1 = require_names();
  const boolError = { message: "boolean schema is false" };
  function topBoolOrEmptySchema(it) {
    const { gen, schema, validateName } = it;
    if (schema === false) falseSchemaError(it, false);
    else if (typeof schema == "object" && schema.$async === true)
      gen.return(names_1.default.data);
    else {
      gen.assign((0, codegen_1._)`${validateName}.errors`, null);
      gen.return(true);
    }
  }
  exports.topBoolOrEmptySchema = topBoolOrEmptySchema;
  function boolOrEmptySchema(it, valid) {
    const { gen, schema } = it;
    if (schema === false) {
      gen.var(valid, false);
      falseSchemaError(it);
    } else gen.var(valid, true);
  }
  exports.boolOrEmptySchema = boolOrEmptySchema;
  function falseSchemaError(it, overrideAllErrors) {
    const { gen, data } = it;
    const cxt = {
      gen,
      keyword: "false schema",
      data,
      schema: false,
      schemaCode: false,
      schemaValue: false,
      params: {},
      it,
    };
    (0, errors_1.reportError)(cxt, boolError, void 0, overrideAllErrors);
  }
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/rules.js
var require_rules = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.getRules = exports.isJSONType = void 0;
  const jsonTypes = /* @__PURE__ */ new Set([
    "string",
    "number",
    "integer",
    "boolean",
    "null",
    "object",
    "array",
  ]);
  function isJSONType(x) {
    return typeof x == "string" && jsonTypes.has(x);
  }
  exports.isJSONType = isJSONType;
  function getRules() {
    const groups = {
      number: {
        type: "number",
        rules: [],
      },
      string: {
        type: "string",
        rules: [],
      },
      array: {
        type: "array",
        rules: [],
      },
      object: {
        type: "object",
        rules: [],
      },
    };
    return {
      types: {
        ...groups,
        integer: true,
        boolean: true,
        null: true,
      },
      rules: [
        { rules: [] },
        groups.number,
        groups.string,
        groups.array,
        groups.object,
      ],
      post: { rules: [] },
      all: {},
      keywords: {},
    };
  }
  exports.getRules = getRules;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/applicability.js
var require_applicability = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.shouldUseRule =
    exports.shouldUseGroup =
    exports.schemaHasRulesForType =
      void 0;
  function schemaHasRulesForType({ schema, self }, type) {
    const group = self.RULES.types[type];
    return group && group !== true && shouldUseGroup(schema, group);
  }
  exports.schemaHasRulesForType = schemaHasRulesForType;
  function shouldUseGroup(schema, group) {
    return group.rules.some((rule) => shouldUseRule(schema, rule));
  }
  exports.shouldUseGroup = shouldUseGroup;
  function shouldUseRule(schema, rule) {
    var _a;
    return (
      schema[rule.keyword] !== void 0 ||
      ((_a = rule.definition.implements) === null || _a === void 0
        ? void 0
        : _a.some((kwd) => schema[kwd] !== void 0))
    );
  }
  exports.shouldUseRule = shouldUseRule;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/dataType.js
var require_dataType = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.reportTypeError =
    exports.checkDataTypes =
    exports.checkDataType =
    exports.coerceAndCheckDataType =
    exports.getJSONTypes =
    exports.getSchemaTypes =
    exports.DataType =
      void 0;
  const rules_1 = require_rules();
  const applicability_1 = require_applicability();
  const errors_1 = require_errors();
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  var DataType;
  (function (DataType) {
    DataType[(DataType["Correct"] = 0)] = "Correct";
    DataType[(DataType["Wrong"] = 1)] = "Wrong";
  })(DataType || (exports.DataType = DataType = {}));
  function getSchemaTypes(schema) {
    const types = getJSONTypes(schema.type);
    if (types.includes("null")) {
      if (schema.nullable === false)
        throw new Error("type: null contradicts nullable: false");
    } else {
      if (!types.length && schema.nullable !== void 0)
        throw new Error('"nullable" cannot be used without "type"');
      if (schema.nullable === true) types.push("null");
    }
    return types;
  }
  exports.getSchemaTypes = getSchemaTypes;
  function getJSONTypes(ts) {
    const types = Array.isArray(ts) ? ts : ts ? [ts] : [];
    if (types.every(rules_1.isJSONType)) return types;
    throw new Error("type must be JSONType or JSONType[]: " + types.join(","));
  }
  exports.getJSONTypes = getJSONTypes;
  function coerceAndCheckDataType(it, types) {
    const { gen, data, opts } = it;
    const coerceTo = coerceToTypes(types, opts.coerceTypes);
    const checkTypes =
      types.length > 0 &&
      !(
        coerceTo.length === 0 &&
        types.length === 1 &&
        (0, applicability_1.schemaHasRulesForType)(it, types[0])
      );
    if (checkTypes) {
      const wrongType = checkDataTypes(
        types,
        data,
        opts.strictNumbers,
        DataType.Wrong,
      );
      gen.if(wrongType, () => {
        if (coerceTo.length) coerceData(it, types, coerceTo);
        else reportTypeError(it);
      });
    }
    return checkTypes;
  }
  exports.coerceAndCheckDataType = coerceAndCheckDataType;
  const 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;
  const typeError = {
    message: ({ schema }) => `must be ${schema}`,
    params: ({ schema, schemaValue }) =>
      typeof schema == "string"
        ? (0, codegen_1._)`{type: ${schema}}`
        : (0, codegen_1._)`{type: ${schemaValue}}`,
  };
  function reportTypeError(it) {
    const cxt = getTypeErrorContext(it);
    (0, errors_1.reportError)(cxt, typeError);
  }
  exports.reportTypeError = reportTypeError;
  function getTypeErrorContext(it) {
    const { gen, data, schema } = it;
    const schemaCode = (0, util_1.schemaRefOrVal)(it, schema, "type");
    return {
      gen,
      keyword: "type",
      data,
      schema: schema.type,
      schemaCode,
      schemaValue: schemaCode,
      parentSchema: schema,
      params: {},
      it,
    };
  }
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/defaults.js
var require_defaults = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.assignDefaults = void 0;
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  function assignDefaults(it, ty) {
    const { properties, items } = it.schema;
    if (ty === "object" && properties)
      for (const key in properties)
        assignDefault(it, key, properties[key].default);
    else if (ty === "array" && Array.isArray(items))
      items.forEach((sch, i) => assignDefault(it, i, sch.default));
  }
  exports.assignDefaults = assignDefaults;
  function assignDefault(it, prop, defaultValue) {
    const { gen, compositeRule, data, opts } = it;
    if (defaultValue === void 0) return;
    const childData = (0,
    codegen_1._)`${data}${(0, codegen_1.getProperty)(prop)}`;
    if (compositeRule) {
      (0, util_1.checkStrictMode)(it, `default is ignored for: ${childData}`);
      return;
    }
    let condition = (0, codegen_1._)`${childData} === undefined`;
    if (opts.useDefaults === "empty")
      condition = (0,
      codegen_1._)`${condition} || ${childData} === null || ${childData} === ""`;
    gen.if(
      condition,
      (0,
      codegen_1._)`${childData} = ${(0, codegen_1.stringify)(defaultValue)}`,
    );
  }
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/code.js
var require_code = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.validateUnion =
    exports.validateArray =
    exports.usePattern =
    exports.callValidateCode =
    exports.schemaProperties =
    exports.allSchemaProperties =
    exports.noPropertyInData =
    exports.propertyInData =
    exports.isOwnProperty =
    exports.hasPropFunc =
    exports.reportMissingProp =
    exports.checkMissingProp =
    exports.checkReportMissingProp =
      void 0;
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const names_1 = require_names();
  const util_2 = require_util();
  function checkReportMissingProp(cxt, prop) {
    const { gen, data, it } = cxt;
    gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => {
      cxt.setParams({ missingProperty: (0, codegen_1._)`${prop}` }, true);
      cxt.error();
    });
  }
  exports.checkReportMissingProp = checkReportMissingProp;
  function checkMissingProp({ gen, data, it: { opts } }, properties, missing) {
    return (0, codegen_1.or)(
      ...properties.map((prop) =>
        (0, codegen_1.and)(
          noPropertyInData(gen, data, prop, opts.ownProperties),
          (0, codegen_1._)`${missing} = ${prop}`,
        ),
      ),
    );
  }
  exports.checkMissingProp = checkMissingProp;
  function reportMissingProp(cxt, missing) {
    cxt.setParams({ missingProperty: missing }, true);
    cxt.error();
  }
  exports.reportMissingProp = reportMissingProp;
  function hasPropFunc(gen) {
    return gen.scopeValue("func", {
      ref: Object.prototype.hasOwnProperty,
      code: (0, codegen_1._)`Object.prototype.hasOwnProperty`,
    });
  }
  exports.hasPropFunc = hasPropFunc;
  function isOwnProperty(gen, data, property) {
    return (0, codegen_1._)`${hasPropFunc(gen)}.call(${data}, ${property})`;
  }
  exports.isOwnProperty = isOwnProperty;
  function propertyInData(gen, data, property, ownProperties) {
    const cond = (0,
    codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} !== undefined`;
    return ownProperties
      ? (0, codegen_1._)`${cond} && ${isOwnProperty(gen, data, property)}`
      : cond;
  }
  exports.propertyInData = propertyInData;
  function noPropertyInData(gen, data, property, ownProperties) {
    const cond = (0,
    codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} === undefined`;
    return ownProperties
      ? (0, codegen_1.or)(
          cond,
          (0, codegen_1.not)(isOwnProperty(gen, data, property)),
        )
      : cond;
  }
  exports.noPropertyInData = noPropertyInData;
  function allSchemaProperties(schemaMap) {
    return schemaMap
      ? Object.keys(schemaMap).filter((p) => p !== "__proto__")
      : [];
  }
  exports.allSchemaProperties = allSchemaProperties;
  function schemaProperties(it, schemaMap) {
    return allSchemaProperties(schemaMap).filter(
      (p) => !(0, util_1.alwaysValidSchema)(it, schemaMap[p]),
    );
  }
  exports.schemaProperties = schemaProperties;
  function callValidateCode(
    { schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it },
    func,
    context,
    passSchema,
  ) {
    const dataAndSchema = passSchema
      ? (0, codegen_1._)`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}`
      : data;
    const valCxt = [
      [
        names_1.default.instancePath,
        (0, codegen_1.strConcat)(names_1.default.instancePath, errorPath),
      ],
      [names_1.default.parentData, it.parentData],
      [names_1.default.parentDataProperty, it.parentDataProperty],
      [names_1.default.rootData, names_1.default.rootData],
    ];
    if (it.opts.dynamicRef)
      valCxt.push([
        names_1.default.dynamicAnchors,
        names_1.default.dynamicAnchors,
      ]);
    const args = (0, codegen_1._)`${dataAndSchema}, ${gen.object(...valCxt)}`;
    return context !== codegen_1.nil
      ? (0, codegen_1._)`${func}.call(${context}, ${args})`
      : (0, codegen_1._)`${func}(${args})`;
  }
  exports.callValidateCode = callValidateCode;
  const newRegExp = (0, codegen_1._)`new RegExp`;
  function usePattern({ gen, it: { opts } }, pattern) {
    const u = opts.unicodeRegExp ? "u" : "";
    const { regExp } = opts.code;
    const rx = regExp(pattern, u);
    return gen.scopeValue("pattern", {
      key: rx.toString(),
      ref: rx,
      code: (0,
      codegen_1._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern}, ${u})`,
    });
  }
  exports.usePattern = usePattern;
  function validateArray(cxt) {
    const { gen, data, keyword, it } = cxt;
    const valid = gen.name("valid");
    if (it.allErrors) {
      const validArr = gen.let("valid", true);
      validateItems(() => gen.assign(validArr, false));
      return validArr;
    }
    gen.var(valid, true);
    validateItems(() => gen.break());
    return valid;
    function validateItems(notValid) {
      const len = gen.const("len", (0, codegen_1._)`${data}.length`);
      gen.forRange("i", 0, len, (i) => {
        cxt.subschema(
          {
            keyword,
            dataProp: i,
            dataPropType: util_1.Type.Num,
          },
          valid,
        );
        gen.if((0, codegen_1.not)(valid), notValid);
      });
    }
  }
  exports.validateArray = validateArray;
  function validateUnion(cxt) {
    const { gen, schema, keyword, it } = cxt;
    /* istanbul ignore if */
    if (!Array.isArray(schema)) throw new Error("ajv implementation error");
    if (
      schema.some((sch) => (0, util_1.alwaysValidSchema)(it, sch)) &&
      !it.opts.unevaluated
    )
      return;
    const valid = gen.let("valid", false);
    const schValid = gen.name("_valid");
    gen.block(() =>
      schema.forEach((_sch, i) => {
        const schCxt = cxt.subschema(
          {
            keyword,
            schemaProp: i,
            compositeRule: true,
          },
          schValid,
        );
        gen.assign(valid, (0, codegen_1._)`${valid} || ${schValid}`);
        if (!cxt.mergeValidEvaluated(schCxt, schValid))
          gen.if((0, codegen_1.not)(valid));
      }),
    );
    cxt.result(
      valid,
      () => cxt.reset(),
      () => cxt.error(true),
    );
  }
  exports.validateUnion = validateUnion;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/keyword.js
var require_keyword = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.validateKeywordUsage =
    exports.validSchemaType =
    exports.funcKeywordCode =
    exports.macroKeywordCode =
      void 0;
  const codegen_1 = require_codegen();
  const names_1 = require_names();
  const code_1 = require_code();
  const errors_1 = require_errors();
  function macroKeywordCode(cxt, def) {
    const { gen, keyword, schema, parentSchema, it } = cxt;
    const macroSchema = def.macro.call(it.self, schema, parentSchema, it);
    const schemaRef = useKeyword(gen, keyword, macroSchema);
    if (it.opts.validateSchema !== false)
      it.self.validateSchema(macroSchema, true);
    const valid = gen.name("valid");
    cxt.subschema(
      {
        schema: macroSchema,
        schemaPath: codegen_1.nil,
        errSchemaPath: `${it.errSchemaPath}/${keyword}`,
        topSchemaRef: schemaRef,
        compositeRule: true,
      },
      valid,
    );
    cxt.pass(valid, () => cxt.error(true));
  }
  exports.macroKeywordCode = macroKeywordCode;
  function funcKeywordCode(cxt, def) {
    var _a;
    const { gen, keyword, schema, parentSchema, $data, it } = cxt;
    checkAsyncKeyword(it, def);
    const validateRef = useKeyword(
      gen,
      keyword,
      !$data && def.compile
        ? def.compile.call(it.self, schema, parentSchema, it)
        : def.validate,
    );
    const valid = gen.let("valid");
    cxt.block$data(valid, validateKeyword);
    cxt.ok((_a = def.valid) !== null && _a !== void 0 ? _a : valid);
    function validateKeyword() {
      if (def.errors === false) {
        assignValid();
        if (def.modifying) modifyData(cxt);
        reportErrs(() => cxt.error());
      } else {
        const ruleErrs = def.async ? validateAsync() : validateSync();
        if (def.modifying) modifyData(cxt);
        reportErrs(() => addErrs(cxt, ruleErrs));
      }
    }
    function validateAsync() {
      const ruleErrs = gen.let("ruleErrs", null);
      gen.try(
        () => assignValid((0, codegen_1._)`await `),
        (e) =>
          gen.assign(valid, false).if(
            (0, codegen_1._)`${e} instanceof ${it.ValidationError}`,
            () => gen.assign(ruleErrs, (0, codegen_1._)`${e}.errors`),
            () => gen.throw(e),
          ),
      );
      return ruleErrs;
    }
    function validateSync() {
      const validateErrs = (0, codegen_1._)`${validateRef}.errors`;
      gen.assign(validateErrs, null);
      assignValid(codegen_1.nil);
      return validateErrs;
    }
    function assignValid(
      _await = def.async ? (0, codegen_1._)`await ` : codegen_1.nil,
    ) {
      const passCxt = it.opts.passContext
        ? names_1.default.this
        : names_1.default.self;
      const passSchema = !(
        ("compile" in def && !$data) ||
        def.schema === false
      );
      gen.assign(
        valid,
        (0,
        codegen_1._)`${_await}${(0, code_1.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`,
        def.modifying,
      );
    }
    function reportErrs(errors) {
      var _a;
      gen.if(
        (0, codegen_1.not)(
          (_a = def.valid) !== null && _a !== void 0 ? _a : valid,
        ),
        errors,
      );
    }
  }
  exports.funcKeywordCode = funcKeywordCode;
  function modifyData(cxt) {
    const { gen, data, it } = cxt;
    gen.if(it.parentData, () =>
      gen.assign(
        data,
        (0, codegen_1._)`${it.parentData}[${it.parentDataProperty}]`,
      ),
    );
  }
  function addErrs(cxt, errs) {
    const { gen } = cxt;
    gen.if(
      (0, codegen_1._)`Array.isArray(${errs})`,
      () => {
        gen
          .assign(
            names_1.default.vErrors,
            (0,
            codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`,
          )
          .assign(
            names_1.default.errors,
            (0, codegen_1._)`${names_1.default.vErrors}.length`,
          );
        (0, errors_1.extendErrors)(cxt);
      },
      () => cxt.error(),
    );
  }
  function checkAsyncKeyword({ schemaEnv }, def) {
    if (def.async && !schemaEnv.$async)
      throw new Error("async keyword in sync schema");
  }
  function useKeyword(gen, keyword, result) {
    if (result === void 0)
      throw new Error(`keyword "${keyword}" failed to compile`);
    return gen.scopeValue(
      "keyword",
      typeof result == "function"
        ? { ref: result }
        : {
            ref: result,
            code: (0, codegen_1.stringify)(result),
          },
    );
  }
  function validSchemaType(schema, schemaType, allowUndefined = false) {
    return (
      !schemaType.length ||
      schemaType.some((st) =>
        st === "array"
          ? Array.isArray(schema)
          : st === "object"
            ? schema && typeof schema == "object" && !Array.isArray(schema)
            : typeof schema == st ||
              (allowUndefined && typeof schema == "undefined"),
      )
    );
  }
  exports.validSchemaType = validSchemaType;
  function validateKeywordUsage(
    { schema, opts, self, errSchemaPath },
    def,
    keyword,
  ) {
    /* istanbul ignore if */
    if (
      Array.isArray(def.keyword)
        ? !def.keyword.includes(keyword)
        : def.keyword !== keyword
    )
      throw new Error("ajv implementation error");
    const deps = def.dependencies;
    if (
      deps === null || deps === void 0
        ? void 0
        : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema, kwd))
    )
      throw new Error(
        `parent schema must have dependencies of ${keyword}: ${deps.join(",")}`,
      );
    if (def.validateSchema) {
      if (!def.validateSchema(schema[keyword])) {
        const msg =
          `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` +
          self.errorsText(def.validateSchema.errors);
        if (opts.validateSchema === "log") self.logger.error(msg);
        else throw new Error(msg);
      }
    }
  }
  exports.validateKeywordUsage = validateKeywordUsage;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/subschema.js
var require_subschema = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.extendSubschemaMode =
    exports.extendSubschemaData =
    exports.getSubschema =
      void 0;
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  function getSubschema(
    it,
    { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef },
  ) {
    if (keyword !== void 0 && schema !== void 0)
      throw new Error('both "keyword" and "schema" passed, only one allowed');
    if (keyword !== void 0) {
      const sch = it.schema[keyword];
      return schemaProp === void 0
        ? {
            schema: sch,
            schemaPath: (0,
            codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}`,
            errSchemaPath: `${it.errSchemaPath}/${keyword}`,
          }
        : {
            schema: sch[schemaProp],
            schemaPath: (0,
            codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}${(0, codegen_1.getProperty)(schemaProp)}`,
            errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}`,
          };
    }
    if (schema !== void 0) {
      if (
        schemaPath === void 0 ||
        errSchemaPath === void 0 ||
        topSchemaRef === void 0
      )
        throw new Error(
          '"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"',
        );
      return {
        schema,
        schemaPath,
        topSchemaRef,
        errSchemaPath,
      };
    }
    throw new Error('either "keyword" or "schema" must be passed');
  }
  exports.getSubschema = getSubschema;
  function extendSubschemaData(
    subschema,
    it,
    { dataProp, dataPropType: dpType, data, dataTypes, propertyName },
  ) {
    if (data !== void 0 && dataProp !== void 0)
      throw new Error('both "data" and "dataProp" passed, only one allowed');
    const { gen } = it;
    if (dataProp !== void 0) {
      const { errorPath, dataPathArr, opts } = it;
      dataContextProps(
        gen.let(
          "data",
          (0, codegen_1._)`${it.data}${(0, codegen_1.getProperty)(dataProp)}`,
          true,
        ),
      );
      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) {
      dataContextProps(
        data instanceof codegen_1.Name ? data : gen.let("data", data, true),
      );
      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;
});
//#endregion
//#region ../node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js
var require_fast_deep_equal = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    module.exports = function equal(a, b) {
      if (a === b) return true;
      if (a && b && typeof a == "object" && typeof b == "object") {
        if (a.constructor !== b.constructor) return false;
        var length, i, keys;
        if (Array.isArray(a)) {
          length = a.length;
          if (length != b.length) return false;
          for (i = length; i-- !== 0;) if (!equal(a[i], b[i])) return false;
          return true;
        }
        if (a.constructor === RegExp)
          return a.source === b.source && a.flags === b.flags;
        if (a.valueOf !== Object.prototype.valueOf)
          return a.valueOf() === b.valueOf();
        if (a.toString !== Object.prototype.toString)
          return a.toString() === b.toString();
        keys = Object.keys(a);
        length = keys.length;
        if (length !== Object.keys(b).length) return false;
        for (i = length; i-- !== 0;)
          if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
        for (i = length; i-- !== 0;) {
          var key = keys[i];
          if (!equal(a[key], b[key])) return false;
        }
        return true;
      }
      return a !== a && b !== b;
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/json-schema-traverse@1.0.0/node_modules/json-schema-traverse/index.js
var require_json_schema_traverse = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    var traverse = (module.exports = function (schema, opts, cb) {
      if (typeof opts == "function") {
        cb = opts;
        opts = {};
      }
      cb = opts.cb || cb;
      var pre = typeof cb == "function" ? cb : cb.pre || function () {};
      var post = cb.post || function () {};
      _traverse(opts, pre, post, schema, "", schema);
    });
    traverse.keywords = {
      additionalItems: true,
      items: true,
      contains: true,
      additionalProperties: true,
      propertyNames: true,
      not: true,
      if: true,
      then: true,
      else: true,
    };
    traverse.arrayKeywords = {
      items: true,
      allOf: true,
      anyOf: true,
      oneOf: true,
    };
    traverse.propsKeywords = {
      $defs: true,
      definitions: true,
      properties: true,
      patternProperties: true,
      dependencies: true,
    };
    traverse.skipKeywords = {
      default: true,
      enum: true,
      const: true,
      required: true,
      maximum: true,
      minimum: true,
      exclusiveMaximum: true,
      exclusiveMinimum: true,
      multipleOf: true,
      maxLength: true,
      minLength: true,
      pattern: true,
      format: true,
      maxItems: true,
      minItems: true,
      uniqueItems: true,
      maxProperties: true,
      minProperties: true,
    };
    function _traverse(
      opts,
      pre,
      post,
      schema,
      jsonPtr,
      rootSchema,
      parentJsonPtr,
      parentKeyword,
      parentSchema,
      keyIndex,
    ) {
      if (schema && typeof schema == "object" && !Array.isArray(schema)) {
        pre(
          schema,
          jsonPtr,
          rootSchema,
          parentJsonPtr,
          parentKeyword,
          parentSchema,
          keyIndex,
        );
        for (var key in schema) {
          var sch = schema[key];
          if (Array.isArray(sch)) {
            if (key in traverse.arrayKeywords)
              for (var i = 0; i < sch.length; i++)
                _traverse(
                  opts,
                  pre,
                  post,
                  sch[i],
                  jsonPtr + "/" + key + "/" + i,
                  rootSchema,
                  jsonPtr,
                  key,
                  schema,
                  i,
                );
          } else if (key in traverse.propsKeywords) {
            if (sch && typeof sch == "object")
              for (var prop in sch)
                _traverse(
                  opts,
                  pre,
                  post,
                  sch[prop],
                  jsonPtr + "/" + key + "/" + escapeJsonPtr(prop),
                  rootSchema,
                  jsonPtr,
                  key,
                  schema,
                  prop,
                );
          } else if (
            key in traverse.keywords ||
            (opts.allKeys && !(key in traverse.skipKeywords))
          )
            _traverse(
              opts,
              pre,
              post,
              sch,
              jsonPtr + "/" + key,
              rootSchema,
              jsonPtr,
              key,
              schema,
            );
        }
        post(
          schema,
          jsonPtr,
          rootSchema,
          parentJsonPtr,
          parentKeyword,
          parentSchema,
          keyIndex,
        );
      }
    }
    function escapeJsonPtr(str) {
      return str.replace(/~/g, "~0").replace(/\//g, "~1");
    }
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/resolve.js
var require_resolve = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.getSchemaRefs =
    exports.resolveUrl =
    exports.normalizeId =
    exports._getFullPath =
    exports.getFullPath =
    exports.inlineRef =
      void 0;
  const util_1 = require_util();
  const equal = require_fast_deep_equal();
  const traverse = require_json_schema_traverse();
  const SIMPLE_INLINED = /* @__PURE__ */ new Set([
    "type",
    "format",
    "pattern",
    "maxLength",
    "minLength",
    "maxProperties",
    "minProperties",
    "maxItems",
    "minItems",
    "maximum",
    "minimum",
    "uniqueItems",
    "multipleOf",
    "required",
    "enum",
    "const",
  ]);
  function inlineRef(schema, limit = true) {
    if (typeof schema == "boolean") return true;
    if (limit === true) return !hasRef(schema);
    if (!limit) return false;
    return countKeys(schema) <= limit;
  }
  exports.inlineRef = inlineRef;
  const REF_KEYWORDS = /* @__PURE__ */ new Set([
    "$ref",
    "$recursiveRef",
    "$recursiveAnchor",
    "$dynamicRef",
    "$dynamicAnchor",
  ]);
  function hasRef(schema) {
    for (const key in schema) {
      if (REF_KEYWORDS.has(key)) return true;
      const sch = schema[key];
      if (Array.isArray(sch) && sch.some(hasRef)) return true;
      if (typeof sch == "object" && hasRef(sch)) return true;
    }
    return false;
  }
  function countKeys(schema) {
    let count = 0;
    for (const key in schema) {
      if (key === "$ref") return Infinity;
      count++;
      if (SIMPLE_INLINED.has(key)) continue;
      if (typeof schema[key] == "object")
        (0, util_1.eachItem)(schema[key], (sch) => (count += countKeys(sch)));
      if (count === Infinity) return Infinity;
    }
    return count;
  }
  function getFullPath(resolver, id = "", normalize) {
    if (normalize !== false) id = normalizeId(id);
    return _getFullPath(resolver, resolver.parse(id));
  }
  exports.getFullPath = getFullPath;
  function _getFullPath(resolver, p) {
    return resolver.serialize(p).split("#")[0] + "#";
  }
  exports._getFullPath = _getFullPath;
  const 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;
  const ANCHOR = /^[a-z_][-a-z0-9._]*$/i;
  function getSchemaRefs(schema, baseId) {
    if (typeof schema == "boolean") return {};
    const { schemaId, uriResolver } = this.opts;
    const schId = normalizeId(schema[schemaId] || baseId);
    const baseIds = { "": schId };
    const pathPrefix = getFullPath(uriResolver, schId, false);
    const localRefs = {};
    const schemaRefs = /* @__PURE__ */ new Set();
    traverse(schema, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
      if (parentJsonPtr === void 0) return;
      const fullPath = pathPrefix + jsonPtr;
      let innerBaseId = baseIds[parentJsonPtr];
      if (typeof sch[schemaId] == "string")
        innerBaseId = addRef.call(this, sch[schemaId]);
      addAnchor.call(this, sch.$anchor);
      addAnchor.call(this, sch.$dynamicAnchor);
      baseIds[jsonPtr] = innerBaseId;
      function addRef(ref) {
        const _resolve = this.opts.uriResolver.resolve;
        ref = normalizeId(innerBaseId ? _resolve(innerBaseId, ref) : ref);
        if (schemaRefs.has(ref)) throw ambiguos(ref);
        schemaRefs.add(ref);
        let schOrRef = this.refs[ref];
        if (typeof schOrRef == "string") schOrRef = this.refs[schOrRef];
        if (typeof schOrRef == "object")
          checkAmbiguosRef(sch, schOrRef.schema, ref);
        else if (ref !== normalizeId(fullPath)) {
          if (ref[0] === "#") {
            checkAmbiguosRef(sch, localRefs[ref], ref);
            localRefs[ref] = sch;
          } else this.refs[ref] = fullPath;
        }
        return ref;
      }
      function addAnchor(anchor) {
        if (typeof anchor == "string") {
          if (!ANCHOR.test(anchor))
            throw new Error(`invalid anchor "${anchor}"`);
          addRef.call(this, `#${anchor}`);
        }
      }
    });
    return localRefs;
    function checkAmbiguosRef(sch1, sch2, ref) {
      if (sch2 !== void 0 && !equal(sch1, sch2)) throw ambiguos(ref);
    }
    function ambiguos(ref) {
      return /* @__PURE__ */ new Error(
        `reference "${ref}" resolves to more than one schema`,
      );
    }
  }
  exports.getSchemaRefs = getSchemaRefs;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/index.js
var require_validate = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.getData = exports.KeywordCxt = exports.validateFunctionCode = void 0;
  const boolSchema_1 = require_boolSchema();
  const dataType_1 = require_dataType();
  const applicability_1 = require_applicability();
  const dataType_2 = require_dataType();
  const defaults_1 = require_defaults();
  const keyword_1 = require_keyword();
  const subschema_1 = require_subschema();
  const codegen_1 = require_codegen();
  const names_1 = require_names();
  const resolve_1 = require_resolve();
  const util_1 = require_util();
  const errors_1 = require_errors();
  function validateFunctionCode(it) {
    if (isSchemaObj(it)) {
      checkKeywords(it);
      if (schemaCxtHasRules(it)) {
        topSchemaObjCode(it);
        return;
      }
    }
    validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it));
  }
  exports.validateFunctionCode = validateFunctionCode;
  function validateFunction(
    { gen, validateName, schema, schemaEnv, opts },
    body,
  ) {
    if (opts.code.es5)
      gen.func(
        validateName,
        (0, codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`,
        schemaEnv.$async,
        () => {
          gen.code(
            (0, codegen_1._)`"use strict"; ${funcSourceUrl(schema, opts)}`,
          );
          destructureValCxtES5(gen, opts);
          gen.code(body);
        },
      );
    else
      gen.func(
        validateName,
        (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`,
        schemaEnv.$async,
        () => gen.code(funcSourceUrl(schema, opts)).code(body),
      );
  }
  function destructureValCxt(opts) {
    return (0,
    codegen_1._)`{${names_1.default.instancePath}="", ${names_1.default.parentData}, ${names_1.default.parentDataProperty}, ${names_1.default.rootData}=${names_1.default.data}${opts.dynamicRef ? (0, codegen_1._)`, ${names_1.default.dynamicAnchors}={}` : codegen_1.nil}}={}`;
  }
  function destructureValCxtES5(gen, opts) {
    gen.if(
      names_1.default.valCxt,
      () => {
        gen.var(
          names_1.default.instancePath,
          (0,
          codegen_1._)`${names_1.default.valCxt}.${names_1.default.instancePath}`,
        );
        gen.var(
          names_1.default.parentData,
          (0,
          codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentData}`,
        );
        gen.var(
          names_1.default.parentDataProperty,
          (0,
          codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentDataProperty}`,
        );
        gen.var(
          names_1.default.rootData,
          (0,
          codegen_1._)`${names_1.default.valCxt}.${names_1.default.rootData}`,
        );
        if (opts.dynamicRef)
          gen.var(
            names_1.default.dynamicAnchors,
            (0,
            codegen_1._)`${names_1.default.valCxt}.${names_1.default.dynamicAnchors}`,
          );
      },
      () => {
        gen.var(names_1.default.instancePath, (0, codegen_1._)`""`);
        gen.var(names_1.default.parentData, (0, codegen_1._)`undefined`);
        gen.var(
          names_1.default.parentDataProperty,
          (0, codegen_1._)`undefined`,
        );
        gen.var(names_1.default.rootData, names_1.default.data);
        if (opts.dynamicRef)
          gen.var(names_1.default.dynamicAnchors, (0, codegen_1._)`{}`);
      },
    );
  }
  function topSchemaObjCode(it) {
    const { schema, opts, gen } = it;
    validateFunction(it, () => {
      if (opts.$comment && schema.$comment) commentKeyword(it);
      checkNoDefault(it);
      gen.let(names_1.default.vErrors, null);
      gen.let(names_1.default.errors, 0);
      if (opts.unevaluated) resetEvaluated(it);
      typeAndKeywords(it);
      returnResults(it);
    });
  }
  function resetEvaluated(it) {
    const { gen, validateName } = it;
    it.evaluated = gen.const(
      "evaluated",
      (0, codegen_1._)`${validateName}.evaluated`,
    );
    gen.if((0, codegen_1._)`${it.evaluated}.dynamicProps`, () =>
      gen.assign(
        (0, codegen_1._)`${it.evaluated}.props`,
        (0, codegen_1._)`undefined`,
      ),
    );
    gen.if((0, codegen_1._)`${it.evaluated}.dynamicItems`, () =>
      gen.assign(
        (0, codegen_1._)`${it.evaluated}.items`,
        (0, codegen_1._)`undefined`,
      ),
    );
  }
  function funcSourceUrl(schema, opts) {
    const schId = typeof schema == "object" && schema[opts.schemaId];
    return schId && (opts.code.source || opts.code.process)
      ? (0, codegen_1._)`/*# sourceURL=${schId} */`
      : codegen_1.nil;
  }
  function subschemaCode(it, valid) {
    if (isSchemaObj(it)) {
      checkKeywords(it);
      if (schemaCxtHasRules(it)) {
        subSchemaObjCode(it, valid);
        return;
      }
    }
    (0, boolSchema_1.boolOrEmptySchema)(it, valid);
  }
  function schemaCxtHasRules({ schema, self }) {
    if (typeof schema == "boolean") return !schema;
    for (const key in schema) if (self.RULES.all[key]) return true;
    return false;
  }
  function isSchemaObj(it) {
    return typeof it.schema != "boolean";
  }
  function subSchemaObjCode(it, valid) {
    const { schema, gen, opts } = it;
    if (opts.$comment && schema.$comment) commentKeyword(it);
    updateContext(it);
    checkAsyncSchema(it);
    const errsCount = gen.const("_errs", names_1.default.errors);
    typeAndKeywords(it, errsCount);
    gen.var(
      valid,
      (0, codegen_1._)`${errsCount} === ${names_1.default.errors}`,
    );
  }
  function checkKeywords(it) {
    (0, util_1.checkUnknownRules)(it);
    checkRefsAndKeywords(it);
  }
  function typeAndKeywords(it, errsCount) {
    if (it.opts.jtd) return schemaKeywords(it, [], false, errsCount);
    const types = (0, dataType_1.getSchemaTypes)(it.schema);
    schemaKeywords(
      it,
      types,
      !(0, dataType_1.coerceAndCheckDataType)(it, types),
      errsCount,
    );
  }
  function checkRefsAndKeywords(it) {
    const { schema, errSchemaPath, opts, self } = it;
    if (
      schema.$ref &&
      opts.ignoreKeywordsWithRef &&
      (0, util_1.schemaHasRulesButRef)(schema, self.RULES)
    )
      self.logger.warn(
        `$ref: keywords ignored in schema at path "${errSchemaPath}"`,
      );
  }
  function checkNoDefault(it) {
    const { schema, opts } = it;
    if (schema.default !== void 0 && opts.useDefaults && opts.strictSchema)
      (0, util_1.checkStrictMode)(it, "default is ignored in the schema root");
  }
  function updateContext(it) {
    const schId = it.schema[it.opts.schemaId];
    if (schId)
      it.baseId = (0, resolve_1.resolveUrl)(
        it.opts.uriResolver,
        it.baseId,
        schId,
      );
  }
  function checkAsyncSchema(it) {
    if (it.schema.$async && !it.schemaEnv.$async)
      throw new Error("async schema in sync schema");
  }
  function commentKeyword({ gen, schemaEnv, schema, errSchemaPath, opts }) {
    const msg = schema.$comment;
    if (opts.$comment === true)
      gen.code((0, codegen_1._)`${names_1.default.self}.logger.log(${msg})`);
    else if (typeof opts.$comment == "function") {
      const schemaPath = (0, codegen_1.str)`${errSchemaPath}/$comment`;
      const rootName = gen.scopeValue("root", { ref: schemaEnv.root });
      gen.code(
        (0,
        codegen_1._)`${names_1.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`,
      );
    }
  }
  function returnResults(it) {
    const { gen, schemaEnv, validateName, ValidationError, opts } = it;
    if (schemaEnv.$async)
      gen.if(
        (0, codegen_1._)`${names_1.default.errors} === 0`,
        () => gen.return(names_1.default.data),
        () =>
          gen.throw(
            (0,
            codegen_1._)`new ${ValidationError}(${names_1.default.vErrors})`,
          ),
      );
    else {
      gen.assign(
        (0, codegen_1._)`${validateName}.errors`,
        names_1.default.vErrors,
      );
      if (opts.unevaluated) assignEvaluated(it);
      gen.return((0, codegen_1._)`${names_1.default.errors} === 0`);
    }
  }
  function assignEvaluated({ gen, evaluated, props, items }) {
    if (props instanceof codegen_1.Name)
      gen.assign((0, codegen_1._)`${evaluated}.props`, props);
    if (items instanceof codegen_1.Name)
      gen.assign((0, codegen_1._)`${evaluated}.items`, items);
  }
  function schemaKeywords(it, types, typeErrors, errsCount) {
    const { gen, schema, data, allErrors, opts, self } = it;
    const { RULES } = self;
    if (
      schema.$ref &&
      (opts.ignoreKeywordsWithRef ||
        !(0, util_1.schemaHasRulesButRef)(schema, RULES))
    ) {
      gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
      return;
    }
    if (!opts.jtd) checkStrictTypes(it, types);
    gen.block(() => {
      for (const group of RULES.rules) groupKeywords(group);
      groupKeywords(RULES.post);
    });
    function groupKeywords(group) {
      if (!(0, applicability_1.shouldUseGroup)(schema, group)) return;
      if (group.type) {
        gen.if(
          (0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers),
        );
        iterateKeywords(it, group);
        if (types.length === 1 && types[0] === group.type && typeErrors) {
          gen.else();
          (0, dataType_2.reportTypeError)(it);
        }
        gen.endIf();
      } else iterateKeywords(it, group);
      if (!allErrors)
        gen.if(
          (0, codegen_1._)`${names_1.default.errors} === ${errsCount || 0}`,
        );
    }
  }
  function iterateKeywords(it, group) {
    const {
      gen,
      schema,
      opts: { useDefaults },
    } = it;
    if (useDefaults) (0, defaults_1.assignDefaults)(it, group.type);
    gen.block(() => {
      for (const rule of group.rules)
        if ((0, applicability_1.shouldUseRule)(schema, rule))
          keywordCode(it, rule.keyword, rule.definition, group.type);
    });
  }
  function checkStrictTypes(it, types) {
    if (it.schemaEnv.meta || !it.opts.strictTypes) return;
    checkContextTypes(it, types);
    if (!it.opts.allowUnionTypes) checkMultipleTypes(it, types);
    checkKeywordTypes(it, it.dataTypes);
  }
  function checkContextTypes(it, types) {
    if (!types.length) return;
    if (!it.dataTypes.length) {
      it.dataTypes = types;
      return;
    }
    types.forEach((t) => {
      if (!includesType(it.dataTypes, t))
        strictTypesError(
          it,
          `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`,
        );
    });
    narrowSchemaTypes(it, types);
  }
  function checkMultipleTypes(it, ts) {
    if (ts.length > 1 && !(ts.length === 2 && ts.includes("null")))
      strictTypesError(it, "use allowUnionTypes to allow union type keyword");
  }
  function checkKeywordTypes(it, ts) {
    const rules = it.self.RULES.all;
    for (const keyword in rules) {
      const rule = rules[keyword];
      if (
        typeof rule == "object" &&
        (0, applicability_1.shouldUseRule)(it.schema, rule)
      ) {
        const { type } = rule.definition;
        if (type.length && !type.some((t) => hasApplicableType(ts, t)))
          strictTypesError(
            it,
            `missing type "${type.join(",")}" for keyword "${keyword}"`,
          );
      }
    }
  }
  function hasApplicableType(schTs, kwdT) {
    return (
      schTs.includes(kwdT) || (kwdT === "number" && schTs.includes("integer"))
    );
  }
  function includesType(ts, t) {
    return ts.includes(t) || (t === "integer" && ts.includes("number"));
  }
  function narrowSchemaTypes(it, withTypes) {
    const ts = [];
    for (const t of it.dataTypes)
      if (includesType(withTypes, t)) ts.push(t);
      else if (withTypes.includes("integer") && t === "number")
        ts.push("integer");
    it.dataTypes = ts;
  }
  function strictTypesError(it, msg) {
    const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
    msg += ` at "${schemaPath}" (strictTypes)`;
    (0, util_1.checkStrictMode)(it, msg, it.opts.strictTypes);
  }
  var KeywordCxt = class {
    constructor(it, def, keyword) {
      (0, keyword_1.validateKeywordUsage)(it, def, keyword);
      this.gen = it.gen;
      this.allErrors = it.allErrors;
      this.keyword = keyword;
      this.data = it.data;
      this.schema = it.schema[keyword];
      this.$data =
        def.$data && it.opts.$data && this.schema && this.schema.$data;
      this.schemaValue = (0, util_1.schemaRefOrVal)(
        it,
        this.schema,
        keyword,
        this.$data,
      );
      this.schemaType = def.schemaType;
      this.parentSchema = it.schema;
      this.params = {};
      this.it = it;
      this.def = def;
      if (this.$data)
        this.schemaCode = it.gen.const("vSchema", getData(this.$data, it));
      else {
        this.schemaCode = this.schemaValue;
        if (
          !(0, keyword_1.validSchemaType)(
            this.schema,
            def.schemaType,
            def.allowUndefined,
          )
        )
          throw new Error(
            `${keyword} value must be ${JSON.stringify(def.schemaType)}`,
          );
      }
      if ("code" in def ? def.trackErrors : def.errors !== false)
        this.errsCount = it.gen.const("_errs", names_1.default.errors);
    }
    result(condition, successAction, failAction) {
      this.failResult((0, codegen_1.not)(condition), successAction, failAction);
    }
    failResult(condition, successAction, failAction) {
      this.gen.if(condition);
      if (failAction) failAction();
      else this.error();
      if (successAction) {
        this.gen.else();
        successAction();
        if (this.allErrors) this.gen.endIf();
      } else if (this.allErrors) this.gen.endIf();
      else this.gen.else();
    }
    pass(condition, failAction) {
      this.failResult((0, codegen_1.not)(condition), void 0, failAction);
    }
    fail(condition) {
      if (condition === void 0) {
        this.error();
        if (!this.allErrors) this.gen.if(false);
        return;
      }
      this.gen.if(condition);
      this.error();
      if (this.allErrors) this.gen.endIf();
      else this.gen.else();
    }
    fail$data(condition) {
      if (!this.$data) return this.fail(condition);
      const { schemaCode } = this;
      this.fail(
        (0,
        codegen_1._)`${schemaCode} !== undefined && (${(0, codegen_1.or)(this.invalid$data(), condition)})`,
      );
    }
    error(append, errorParams, errorPaths) {
      if (errorParams) {
        this.setParams(errorParams);
        this._error(append, errorPaths);
        this.setParams({});
        return;
      }
      this._error(append, errorPaths);
    }
    _error(append, errorPaths) {
      (append ? errors_1.reportExtraError : errors_1.reportError)(
        this,
        this.def.error,
        errorPaths,
      );
    }
    $dataError() {
      (0, errors_1.reportError)(
        this,
        this.def.$dataError || errors_1.keyword$DataError,
      );
    }
    reset() {
      if (this.errsCount === void 0)
        throw new Error('add "trackErrors" to keyword definition');
      (0, errors_1.resetErrorsCount)(this.gen, this.errsCount);
    }
    ok(cond) {
      if (!this.allErrors) this.gen.if(cond);
    }
    setParams(obj, assign) {
      if (assign) Object.assign(this.params, obj);
      else this.params = obj;
    }
    block$data(valid, codeBlock, $dataValid = codegen_1.nil) {
      this.gen.block(() => {
        this.check$data(valid, $dataValid);
        codeBlock();
      });
    }
    check$data(valid = codegen_1.nil, $dataValid = codegen_1.nil) {
      if (!this.$data) return;
      const { gen, schemaCode, schemaType, def } = this;
      gen.if(
        (0, codegen_1.or)(
          (0, codegen_1._)`${schemaCode} === undefined`,
          $dataValid,
        ),
      );
      if (valid !== codegen_1.nil) gen.assign(valid, true);
      if (schemaType.length || def.validateSchema) {
        gen.elseIf(this.invalid$data());
        this.$dataError();
        if (valid !== codegen_1.nil) gen.assign(valid, false);
      }
      gen.else();
    }
    invalid$data() {
      const { gen, schemaCode, schemaType, def, it } = this;
      return (0, codegen_1.or)(wrong$DataType(), invalid$DataSchema());
      function wrong$DataType() {
        if (schemaType.length) {
          /* istanbul ignore if */
          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);
  }
  const JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/;
  const 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;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/validation_error.js
var require_validation_error = /* @__PURE__ */ __commonJSMin((exports) => {
  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;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/ref_error.js
var require_ref_error = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const resolve_1 = require_resolve();
  var MissingRefError = class extends Error {
    constructor(resolver, baseId, ref, msg) {
      super(msg || `can't resolve reference ${ref} from id ${baseId}`);
      this.missingRef = (0, resolve_1.resolveUrl)(resolver, baseId, ref);
      this.missingSchema = (0, resolve_1.normalizeId)(
        (0, resolve_1.getFullPath)(resolver, this.missingRef),
      );
    }
  };
  exports.default = MissingRefError;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/index.js
var require_compile = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.resolveSchema =
    exports.getCompilingSchema =
    exports.resolveRef =
    exports.compileSchema =
    exports.SchemaEnv =
      void 0;
  const codegen_1 = require_codegen();
  const validation_error_1 = require_validation_error();
  const names_1 = require_names();
  const resolve_1 = require_resolve();
  const util_1 = require_util();
  const validate_1 = require_validate();
  var SchemaEnv = class {
    constructor(env) {
      var _a;
      this.refs = {};
      this.dynamicAnchors = {};
      let schema;
      if (typeof env.schema == "object") schema = env.schema;
      this.schema = env.schema;
      this.schemaId = env.schemaId;
      this.root = env.root || this;
      this.baseId =
        (_a = env.baseId) !== null && _a !== void 0
          ? _a
          : (0, resolve_1.normalizeId)(
              schema === null || schema === void 0
                ? void 0
                : schema[env.schemaId || "$id"],
            );
      this.schemaPath = env.schemaPath;
      this.localRefs = env.localRefs;
      this.meta = env.meta;
      this.$async =
        schema === null || schema === void 0 ? void 0 : schema.$async;
      this.refs = {};
    }
  };
  exports.SchemaEnv = SchemaEnv;
  function compileSchema(sch) {
    const _sch = getCompilingSchema.call(this, sch);
    if (_sch) return _sch;
    const rootId = (0, resolve_1.getFullPath)(
      this.opts.uriResolver,
      sch.root.baseId,
    );
    const { es5, lines } = this.opts.code;
    const { ownProperties } = this.opts;
    const gen = new codegen_1.CodeGen(this.scope, {
      es5,
      lines,
      ownProperties,
    });
    let _ValidationError;
    if (sch.$async)
      _ValidationError = gen.scopeValue("Error", {
        ref: validation_error_1.default,
        code: (0,
        codegen_1._)`require("ajv/dist/runtime/validation_error").default`,
      });
    const validateName = gen.scopeName("validate");
    sch.validateName = validateName;
    const schemaCxt = {
      gen,
      allErrors: this.opts.allErrors,
      data: names_1.default.data,
      parentData: names_1.default.parentData,
      parentDataProperty: names_1.default.parentDataProperty,
      dataNames: [names_1.default.data],
      dataPathArr: [codegen_1.nil],
      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 validate = new Function(
        `${names_1.default.self}`,
        `${names_1.default.scope}`,
        sourceCode,
      )(this, this.scope.get());
      this.scope.value(validateName, { ref: validate });
      validate.errors = null;
      validate.schema = sch.schema;
      validate.schemaEnv = sch;
      if (sch.$async) validate.$async = true;
      if (this.opts.code.source === true)
        validate.source = {
          validateName,
          validateCode,
          scopeValues: gen._values,
        };
      if (this.opts.unevaluated) {
        const { props, items } = schemaCxt;
        validate.evaluated = {
          props: props instanceof codegen_1.Name ? void 0 : props,
          items: items instanceof codegen_1.Name ? void 0 : items,
          dynamicProps: props instanceof codegen_1.Name,
          dynamicItems: items instanceof codegen_1.Name,
        };
        if (validate.source)
          validate.source.evaluated = (0, codegen_1.stringify)(
            validate.evaluated,
          );
      }
      sch.validate = validate;
      return sch;
    } catch (e) {
      delete sch.validate;
      delete sch.validateName;
      if (sourceCode)
        this.logger.error("Error compiling schema, function code:", sourceCode);
      throw e;
    } finally {
      this._compilations.delete(sch);
    }
  }
  exports.compileSchema = compileSchema;
  function resolveRef(root, baseId, ref) {
    var _a;
    ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
    const schOrFunc = root.refs[ref];
    if (schOrFunc) return schOrFunc;
    let _sch = resolve.call(this, root, ref);
    if (_sch === void 0) {
      const schema =
        (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
      const { schemaId } = this.opts;
      if (schema)
        _sch = new SchemaEnv({
          schema,
          schemaId,
          root,
          baseId,
        });
    }
    if (_sch === void 0) return;
    return (root.refs[ref] = inlineOrCompile.call(this, _sch));
  }
  exports.resolveRef = resolveRef;
  function inlineOrCompile(sch) {
    if ((0, resolve_1.inlineRef)(sch.schema, this.opts.inlineRefs))
      return sch.schema;
    return sch.validate ? sch : compileSchema.call(this, sch);
  }
  function getCompilingSchema(schEnv) {
    for (const sch of this._compilations)
      if (sameSchemaEnv(sch, schEnv)) return sch;
  }
  exports.getCompilingSchema = getCompilingSchema;
  function sameSchemaEnv(s1, s2) {
    return (
      s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId
    );
  }
  function resolve(root, ref) {
    let sch;
    while (typeof (sch = this.refs[ref]) == "string") ref = sch;
    return sch || this.schemas[ref] || resolveSchema.call(this, root, ref);
  }
  function resolveSchema(root, ref) {
    const p = this.opts.uriResolver.parse(ref);
    const refPath = (0, resolve_1._getFullPath)(this.opts.uriResolver, p);
    let baseId = (0, resolve_1.getFullPath)(
      this.opts.uriResolver,
      root.baseId,
      void 0,
    );
    if (Object.keys(root.schema).length > 0 && refPath === baseId)
      return getJsonPointer.call(this, p, root);
    const id = (0, resolve_1.normalizeId)(refPath);
    const schOrRef = this.refs[id] || this.schemas[id];
    if (typeof schOrRef == "string") {
      const sch = resolveSchema.call(this, root, schOrRef);
      if (
        typeof (sch === null || sch === void 0 ? void 0 : sch.schema) !==
        "object"
      )
        return;
      return getJsonPointer.call(this, p, sch);
    }
    if (
      typeof (schOrRef === null || schOrRef === void 0
        ? void 0
        : schOrRef.schema) !== "object"
    )
      return;
    if (!schOrRef.validate) compileSchema.call(this, schOrRef);
    if (id === (0, resolve_1.normalizeId)(ref)) {
      const { schema } = schOrRef;
      const { schemaId } = this.opts;
      const schId = schema[schemaId];
      if (schId)
        baseId = (0, resolve_1.resolveUrl)(
          this.opts.uriResolver,
          baseId,
          schId,
        );
      return new SchemaEnv({
        schema,
        schemaId,
        root,
        baseId,
      });
    }
    return getJsonPointer.call(this, p, schOrRef);
  }
  exports.resolveSchema = resolveSchema;
  const PREVENT_SCOPE_CHANGE = /* @__PURE__ */ new Set([
    "properties",
    "patternProperties",
    "enum",
    "dependencies",
    "definitions",
  ]);
  function getJsonPointer(parsedRef, { baseId, schema, root }) {
    var _a;
    if (
      ((_a = parsedRef.fragment) === null || _a === void 0 ? void 0 : _a[0]) !==
      "/"
    )
      return;
    for (const part of parsedRef.fragment.slice(1).split("/")) {
      if (typeof schema === "boolean") return;
      const partSchema = schema[(0, util_1.unescapeFragment)(part)];
      if (partSchema === void 0) return;
      schema = partSchema;
      const schId = typeof schema === "object" && schema[this.opts.schemaId];
      if (!PREVENT_SCOPE_CHANGE.has(part) && schId)
        baseId = (0, resolve_1.resolveUrl)(
          this.opts.uriResolver,
          baseId,
          schId,
        );
    }
    let env;
    if (
      typeof schema != "boolean" &&
      schema.$ref &&
      !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)
    ) {
      const $ref = (0, resolve_1.resolveUrl)(
        this.opts.uriResolver,
        baseId,
        schema.$ref,
      );
      env = resolveSchema.call(this, root, $ref);
    }
    const { schemaId } = this.opts;
    env =
      env ||
      new SchemaEnv({
        schema,
        schemaId,
        root,
        baseId,
      });
    if (env.schema !== env.root.schema) return env;
  }
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/data.json
var require_data = /* @__PURE__ */ __commonJSMin((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,
  };
});
//#endregion
//#region ../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/lib/utils.js
var require_utils = /* @__PURE__ */ __commonJSMin((exports, module) => {
  /** @type {(value: string) => boolean} */
  const isUUID = RegExp.prototype.test.bind(
    /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu,
  );
  /** @type {(value: string) => boolean} */
  const isIPv4 = RegExp.prototype.test.bind(
    /^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u,
  );
  /** @type {(value: string) => boolean} */
  const isPort = RegExp.prototype.test.bind(/^\d*$/u);
  /** @type {(value: string) => boolean} */
  const isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
  /** @type {(value: string) => boolean} */
  const isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
  /** @type {(value: string) => boolean} */
  const isPathCharacter = RegExp.prototype.test.bind(
    /^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u,
  );
  /** @type {(value: string) => boolean} */
  const isQueryFragmentCharacter = RegExp.prototype.test.bind(
    /^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u,
  );
  /** @type {(value: string) => boolean} */
  const isUserinfoCharacter = RegExp.prototype.test.bind(
    /^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u,
  );
  const BYTE_HEX = new Array(256);
  {
    const HEX_DIGITS = "0123456789ABCDEF";
    for (let i = 0; i < 256; i++)
      BYTE_HEX[i] = "%" + HEX_DIGITS[i >> 4] + HEX_DIGITS[i & 15];
  }
  function percentEncodeNonAscii(cp) {
    if (cp < 2048) return BYTE_HEX[192 | (cp >> 6)] + BYTE_HEX[128 | (cp & 63)];
    if (cp < 65536)
      return (
        BYTE_HEX[224 | (cp >> 12)] +
        BYTE_HEX[128 | ((cp >> 6) & 63)] +
        BYTE_HEX[128 | (cp & 63)]
      );
    return (
      BYTE_HEX[240 | (cp >> 18)] +
      BYTE_HEX[128 | ((cp >> 12) & 63)] +
      BYTE_HEX[128 | ((cp >> 6) & 63)] +
      BYTE_HEX[128 | (cp & 63)]
    );
  }
  /**
   * @param {Array<string>} input
   * @returns {string}
   */
  function stringArrayToHexStripped(input) {
    let acc = "";
    let code = 0;
    let i = 0;
    for (i = 0; i < input.length; i++) {
      code = input[i].charCodeAt(0);
      if (code === 48) continue;
      if (
        !(
          (code >= 48 && code <= 57) ||
          (code >= 65 && code <= 70) ||
          (code >= 97 && code <= 102)
        )
      )
        return "";
      acc += input[i];
      break;
    }
    for (i += 1; i < input.length; i++) {
      code = input[i].charCodeAt(0);
      if (
        !(
          (code >= 48 && code <= 57) ||
          (code >= 65 && code <= 70) ||
          (code >= 97 && code <= 102)
        )
      )
        return "";
      acc += input[i];
    }
    return acc;
  }
  /** @type {(value: string) => boolean} */
  const isHextet = RegExp.prototype.test.bind(/^[\dA-Fa-f]{1,4}$/);
  /** @type {(value: string) => boolean} */
  const isIPvFuture = RegExp.prototype.test.bind(
    /^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/,
  );
  /** @type {(value: string) => boolean} */
  const isZoneCharacter = RegExp.prototype.test.bind(/^[A-Za-z\d\-._~]$/);
  /**
   * @param {string} value
   * @returns {boolean}
   */
  const nonSimpleDomain = RegExp.prototype.test.bind(
    /[^!"$&'()*+,\-.;=_`a-z{}~]/u,
  );
  /**
   * @param {string} zone
   * @returns {boolean}
   */
  function isZoneIdentifier(zone) {
    if (zone.length === 0) return false;
    for (let i = 0; i < zone.length; i++) {
      if (isZoneCharacter(zone[i])) continue;
      if (
        zone[i] === "%" &&
        i + 2 < zone.length &&
        isHexPair(zone.slice(i + 1, i + 3))
      ) {
        i += 2;
        continue;
      }
      return false;
    }
    return true;
  }
  /**
   * Compresses the longest run of zero hextets to "::" per RFC 5952. A run of a
   * single zero hextet is left uncompressed. On ties the leftmost run wins.
   *
   * @param {string[]} hextets
   * @returns {string}
   */
  function compressIPv6ZeroRun(hextets) {
    let bestStart = -1;
    let bestLength = 0;
    let runStart = -1;
    let runLength = 0;
    for (let i = 0; i < hextets.length; i++)
      if (hextets[i] === "0") {
        if (runStart === -1) runStart = i;
        runLength++;
        if (runLength > bestLength) {
          bestLength = runLength;
          bestStart = runStart;
        }
      } else {
        runStart = -1;
        runLength = 0;
      }
    if (bestLength < 2) return hextets.join(":");
    const head = hextets.slice(0, bestStart).join(":");
    const tail = hextets.slice(bestStart + bestLength).join(":");
    return head + "::" + tail;
  }
  /**
   * Validates an IPv6 address against the alternatives in RFC 3986 section
   * 3.2.2 and returns the same address with leading hextet zeroes removed.
   * An embedded IPv4 address counts as two hextets and is only valid at the end.
   *
   * @param {string} input
   * @returns {string|undefined}
   */
  function normalizeIPv6Address(input) {
    const compression = input.indexOf("::");
    if (compression !== -1 && input.indexOf("::", compression + 1) !== -1)
      return void 0;
    const left =
      compression === -1
        ? input.split(":")
        : input.slice(0, compression).split(":");
    const right =
      compression === -1 ? [] : input.slice(compression + 2).split(":");
    if (compression !== -1) {
      if (left.length === 1 && left[0] === "") left.length = 0;
      if (right.length === 1 && right[0] === "") right.length = 0;
    }
    const parts = left.concat(right);
    let hextetCount = 0;
    for (let i = 0; i < parts.length; i++) {
      const part = parts[i];
      if (part === "") return void 0;
      if (part.indexOf(".") !== -1) {
        if (
          i !== parts.length - 1 ||
          (compression !== -1 && right.length === 0) ||
          !isIPv4(part)
        )
          return void 0;
        hextetCount += 2;
        continue;
      }
      if (!isHextet(part)) return void 0;
      parts[i] = parseInt(part, 16).toString(16);
      hextetCount++;
    }
    if (compression === -1) {
      if (hextetCount !== 8) return void 0;
      return compressIPv6ZeroRun(parts);
    }
    if (hextetCount >= 8) return void 0;
    const expanded = parts.slice(0, left.length);
    for (let i = hextetCount; i < 8; i++) expanded.push("0");
    for (let i = left.length; i < parts.length; i++) expanded.push(parts[i]);
    return compressIPv6ZeroRun(expanded);
  }
  /**
   * @typedef {Object} NormalizeIPv6Result
   * @property {string} host - The normalized host.
   * @property {string} [escapedHost] - The escaped host.
   * @property {boolean} isIPV6 - Indicates if the host is an IPv6 address.
   * @property {boolean} [isIPVFuture] - Indicates if the host is an IPvFuture literal.
   * @property {boolean} [error] - Indicates if a bracketed IP literal is malformed.
   */
  /**
   * Validates and normalizes a bracketed IP literal. Raw zone separators remain
   * accepted for backwards compatibility, while encoded separators and zone
   * contents follow RFC 6874.
   *
   * @param {string} host
   * @returns {NormalizeIPv6Result}
   */
  function normalizeIPv6(host) {
    const bracketed = host[0] === "[" && host[host.length - 1] === "]";
    if ((host[0] === "[" || host[host.length - 1] === "]") && !bracketed)
      return {
        host,
        isIPV6: false,
        error: true,
      };
    let input = bracketed ? host.slice(1, -1) : host;
    if (bracketed && isIPvFuture(input)) {
      input = input.toLowerCase();
      return {
        host: `[${input}]`,
        escapedHost: input,
        isIPV6: false,
        isIPVFuture: true,
      };
    }
    if (findToken(input, ":") < 2)
      return {
        host,
        isIPV6: false,
        error: bracketed,
      };
    let zoneIdentifier = "";
    const zoneSeparator = input.indexOf("%");
    if (zoneSeparator !== -1) {
      const separatorLength =
        input.slice(zoneSeparator, zoneSeparator + 3).toLowerCase() === "%25"
          ? 3
          : 1;
      zoneIdentifier = input.slice(zoneSeparator + separatorLength);
      if (!isZoneIdentifier(zoneIdentifier))
        return {
          host,
          isIPV6: false,
          error: true,
        };
      input = input.slice(0, zoneSeparator);
    }
    const address = normalizeIPv6Address(input);
    if (address === void 0)
      return {
        host,
        isIPV6: false,
        error: true,
      };
    return {
      host: address + (zoneIdentifier ? "%" + zoneIdentifier : ""),
      escapedHost: address + (zoneIdentifier ? "%25" + zoneIdentifier : ""),
      isIPV6: true,
    };
  }
  /**
   * @param {string} str
   * @param {string} token
   * @returns {number}
   */
  function findToken(str, token) {
    let ind = 0;
    for (let i = 0; i < str.length; i++) if (str[i] === token) ind++;
    return ind;
  }
  /**
   * @param {string} path
   * @returns {string}
   *
   * @see https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
   */
  function removeDotSegments(path) {
    let input = path;
    const output = [];
    let nextSlash = -1;
    let len = 0;
    while ((len = input.length)) {
      if (len === 1) {
        if (input === ".") break;
        else if (input === "/") {
          output.push("/");
          break;
        } else {
          output.push(input);
          break;
        }
      } else if (len === 2) {
        if (input[0] === ".") {
          if (input[1] === ".") break;
          else if (input[1] === "/") {
            input = input.slice(2);
            continue;
          }
        } else if (input[0] === "/") {
          if (input[1] === "." || input[1] === "/") {
            output.push("/");
            break;
          }
        }
      } else if (len === 3) {
        if (input === "/..") {
          if (output.length !== 0) output.pop();
          output.push("/");
          break;
        }
      }
      if (input[0] === ".") {
        if (input[1] === ".") {
          if (input[2] === "/") {
            input = input.slice(3);
            continue;
          }
        } else if (input[1] === "/") {
          input = input.slice(2);
          continue;
        }
      } else if (input[0] === "/") {
        if (input[1] === ".") {
          if (input[2] === "/") {
            input = input.slice(2);
            continue;
          } else if (input[2] === ".") {
            if (input[3] === "/") {
              input = input.slice(3);
              if (output.length !== 0) output.pop();
              continue;
            }
          }
        }
      }
      if ((nextSlash = input.indexOf("/", 1)) === -1) {
        output.push(input);
        break;
      } else {
        output.push(input.slice(0, nextSlash));
        input = input.slice(nextSlash);
      }
    }
    return output.join("");
  }
  /**
   * Re-escape RFC 3986 gen-delims that must not appear literally in the host.
   * After the URI regex parses, these characters cannot be literal in the host
   * field, so any that appear after decoding came from percent-encoding and
   * must be restored to prevent authority structure changes.
   *
   * @param {string} host
   * @param {boolean} isIP - true for IPv4/IPv6 hosts (skip colon re-escaping)
   * @returns {string}
   */
  const HOST_DELIMS = {
    "@": "%40",
    "/": "%2F",
    "?": "%3F",
    "#": "%23",
    ":": "%3A",
  };
  const HOST_DELIM_RE = /[@/?#:]/g;
  const HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
  function reescapeHostDelimiters(host, isIP) {
    const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
    re.lastIndex = 0;
    return host.replace(re, (ch) => HOST_DELIMS[ch]);
  }
  /**
   * Normalizes percent escapes and optionally decodes only unreserved ASCII bytes.
   * Reserved delimiters such as `%2F` stay escaped; `%2E` is unreserved.
   *
   * @param {string} input
   * @param {boolean} [decodeUnreserved=false]
   * @returns {string}
   */
  function normalizePercentEncoding(input, decodeUnreserved = false) {
    if (input.indexOf("%") === -1) return input;
    let output = "";
    for (let i = 0; i < input.length; i++) {
      if (input[i] === "%" && i + 2 < input.length) {
        const hex = input.slice(i + 1, i + 3);
        if (isHexPair(hex)) {
          const normalizedHex = hex.toUpperCase();
          const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
          if (decodeUnreserved && isUnreserved(decoded)) output += decoded;
          else output += "%" + normalizedHex;
          i += 2;
          continue;
        }
      }
      output += input[i];
    }
    return output;
  }
  /**
   * Normalizes path data without turning reserved escapes into live path syntax.
   * Valid escapes are uppercased, raw unsafe characters are escaped, and only
   * unreserved bytes that are not `.` are decoded.
   *
   * @param {string} input
   * @returns {string}
   */
  function normalizePathEncoding(input) {
    let output = "";
    for (let i = 0; i < input.length; i++) {
      const ch = input[i];
      if (ch === "%" && i + 2 < input.length) {
        const hex = input.slice(i + 1, i + 3);
        if (isHexPair(hex)) {
          const normalizedHex = hex.toUpperCase();
          const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
          if (decoded !== "." && isUnreserved(decoded)) output += decoded;
          else output += "%" + normalizedHex;
          i += 2;
          continue;
        }
      }
      if (isPathCharacter(ch)) output += ch;
      else {
        const code = input.charCodeAt(i);
        if (code < 128) output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
        else if (code < 55296 || code > 57343)
          output += percentEncodeNonAscii(code);
        else if (code <= 56319 && i + 1 < input.length) {
          const low = input.charCodeAt(i + 1);
          if (low >= 56320 && low <= 57343) {
            output += percentEncodeNonAscii(
              65536 + ((code - 55296) << 10) + (low - 56320),
            );
            i++;
          } else output += percentEncodeNonAscii(65533);
        } else output += percentEncodeNonAscii(65533);
      }
    }
    return output;
  }
  /**
   * Serializes a path without rewriting reserved data. Raw RFC 3986 path
   * characters remain literal, valid escapes are preserved and uppercased, and
   * everything else is UTF-8 percent-encoded. In a path-noscheme, a colon in the
   * first segment must be escaped so the result cannot be parsed as a scheme.
   *
   * @param {string} input
   * @param {boolean} [pathNoScheme=false]
   * @returns {string}
   */
  function serializePathEncoding(input, pathNoScheme = false) {
    let output = "";
    let firstSegment = pathNoScheme && input[0] !== "/";
    for (let i = 0; i < input.length; i++) {
      const ch = input[i];
      if (ch === "%" && i + 2 < input.length) {
        const hex = input.slice(i + 1, i + 3);
        if (isHexPair(hex)) {
          output += "%" + hex.toUpperCase();
          i += 2;
          continue;
        }
      }
      if (ch === "/") firstSegment = false;
      if (isPathCharacter(ch) && (ch !== ":" || !firstSegment)) output += ch;
      else {
        const code = input.charCodeAt(i);
        if (code < 128) output += BYTE_HEX[code];
        else if (code < 55296 || code > 57343)
          output += percentEncodeNonAscii(code);
        else if (code <= 56319 && i + 1 < input.length) {
          const low = input.charCodeAt(i + 1);
          if (low >= 56320 && low <= 57343) {
            output += percentEncodeNonAscii(
              65536 + ((code - 55296) << 10) + (low - 56320),
            );
            i++;
          } else output += percentEncodeNonAscii(65533);
        } else output += percentEncodeNonAscii(65533);
      }
    }
    return output;
  }
  /**
   * Percent-encodes a URI component using its RFC 3986 literal character set.
   * Existing valid escapes are preserved and normalized to uppercase hex.
   *
   * @param {string} input
   * @param {(value: string) => boolean} isAllowed
   * @returns {string}
   */
  function encodeComponent(input, isAllowed) {
    let output = "";
    for (let i = 0; i < input.length; i++) {
      const ch = input[i];
      if (ch === "%" && i + 2 < input.length) {
        const hex = input.slice(i + 1, i + 3);
        if (isHexPair(hex)) {
          output += "%" + hex.toUpperCase();
          i += 2;
          continue;
        }
      }
      if (isAllowed(ch)) output += ch;
      else {
        const code = input.charCodeAt(i);
        if (code < 128) output += BYTE_HEX[code];
        else if (code < 55296 || code > 57343)
          output += percentEncodeNonAscii(code);
        else if (code <= 56319 && i + 1 < input.length) {
          const low = input.charCodeAt(i + 1);
          if (low >= 56320 && low <= 57343) {
            output += percentEncodeNonAscii(
              65536 + ((code - 55296) << 10) + (low - 56320),
            );
            i++;
          } else output += percentEncodeNonAscii(65533);
        } else output += percentEncodeNonAscii(65533);
      }
    }
    return output;
  }
  /**
   * Encodes userinfo while preserving its RFC 3986 §3.2.1 literal characters.
   * In particular, authority delimiters such as `@`, `/`, `?`, and `#` are data.
   *
   * @param {string} input
   * @returns {string}
   */
  function encodeUserinfo(input) {
    return encodeComponent(input, isUserinfoCharacter);
  }
  /**
   * Encodes query data using the RFC 3986 §3.4 grammar. A literal `#` must be
   * escaped because it would otherwise begin the fragment component.
   *
   * @param {string} input
   * @returns {string}
   */
  function encodeQuery(input) {
    return encodeComponent(input, isQueryFragmentCharacter);
  }
  /**
   * Encodes fragment data using the RFC 3986 §3.5 grammar.
   *
   * @param {string} input
   * @returns {string}
   */
  function encodeFragment(input) {
    return encodeComponent(input, isQueryFragmentCharacter);
  }
  function isEscapeSafe(cp) {
    return (
      (cp >= 48 && cp <= 57) ||
      (cp >= 65 && cp <= 90) ||
      (cp >= 97 && cp <= 122) ||
      cp === 42 ||
      cp === 43 ||
      cp === 45 ||
      cp === 46 ||
      cp === 47 ||
      cp === 64 ||
      cp === 95
    );
  }
  /**
   * Normalizes the percent-encoding of a query or fragment component.
   *
   * Like `normalizePathEncoding`, but uses the query/fragment character set
   * (which additionally allows `?`) and decodes `.` since it has no dot-segment
   * meaning outside of a path.
   *
   * @param {string} input
   * @returns {string}
   */
  function normalizeQueryFragmentEncoding(input) {
    let output = "";
    for (let i = 0; i < input.length; i++) {
      const ch = input[i];
      if (ch === "%" && i + 2 < input.length) {
        const hex = input.slice(i + 1, i + 3);
        if (isHexPair(hex)) {
          const normalizedHex = hex.toUpperCase();
          const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
          if (isUnreserved(decoded)) output += decoded;
          else output += "%" + normalizedHex;
          i += 2;
          continue;
        }
      }
      if (isQueryFragmentCharacter(ch)) output += ch;
      else {
        const code = input.charCodeAt(i);
        if (code < 128) output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
        else if (code < 55296 || code > 57343)
          output += percentEncodeNonAscii(code);
        else if (code <= 56319 && i + 1 < input.length) {
          const low = input.charCodeAt(i + 1);
          if (low >= 56320 && low <= 57343) {
            output += percentEncodeNonAscii(
              65536 + ((code - 55296) << 10) + (low - 56320),
            );
            i++;
          } else output += percentEncodeNonAscii(65533);
        } else output += percentEncodeNonAscii(65533);
      }
    }
    return output;
  }
  /**
   * Escapes a component while preserving existing valid percent escapes.
   *
   * @param {string} input
   * @returns {string}
   */
  function escapePreservingEscapes(input) {
    let output = "";
    for (let i = 0; i < input.length; i++) {
      if (input[i] === "%" && i + 2 < input.length) {
        const hex = input.slice(i + 1, i + 3);
        if (isHexPair(hex)) {
          output += "%" + hex.toUpperCase();
          i += 2;
          continue;
        }
      }
      output += escape(input[i]);
    }
    return output;
  }
  /**
   * @param {import('../types/index').URIComponent} component
   * @returns {string|undefined}
   */
  function recomposeAuthority(component) {
    const uriTokens = [];
    if (component.userinfo !== void 0) {
      uriTokens.push(encodeUserinfo(component.userinfo));
      uriTokens.push("@");
    }
    if (component.host !== void 0) {
      let host = component.host;
      if (!isIPv4(host)) {
        let ipV6res = normalizeIPv6(host);
        if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
          host = normalizePercentEncoding(host, true);
          ipV6res = normalizeIPv6(host);
        }
        if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true)
          host = `[${ipV6res.escapedHost}]`;
        else host = reescapeHostDelimiters(host, false);
      }
      uriTokens.push(host);
    }
    if (
      typeof component.port === "number" ||
      typeof component.port === "string"
    ) {
      const port = String(component.port);
      if (!isPort(port)) throw new TypeError("URI port is malformed.");
      uriTokens.push(":");
      uriTokens.push(port);
    }
    return uriTokens.length ? uriTokens.join("") : void 0;
  }
  module.exports = {
    nonSimpleDomain,
    recomposeAuthority,
    reescapeHostDelimiters,
    normalizePercentEncoding,
    normalizePathEncoding,
    serializePathEncoding,
    normalizeQueryFragmentEncoding,
    encodeUserinfo,
    encodeQuery,
    encodeFragment,
    escapePreservingEscapes,
    removeDotSegments,
    isIPv4,
    isUUID,
    normalizeIPv6,
    stringArrayToHexStripped,
  };
});
//#endregion
//#region ../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/lib/schemes.js
var require_schemes = /* @__PURE__ */ __commonJSMin((exports, module) => {
  const { isUUID } = require_utils();
  const URN_REG =
    /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
  const supportedSchemeNames = [
    "http",
    "https",
    "ws",
    "wss",
    "urn",
    "urn:uuid",
  ];
  /** @typedef {supportedSchemeNames[number]} SchemeName */
  /**
   * @param {string} name
   * @returns {name is SchemeName}
   */
  function isValidSchemeName(name) {
    return supportedSchemeNames.indexOf(name) !== -1;
  }
  /**
   * @callback SchemeFn
   * @param {import('../types/index').URIComponent} component
   * @param {import('../types/index').Options} options
   * @returns {import('../types/index').URIComponent}
   */
  /**
   * @typedef {Object} SchemeHandler
   * @property {SchemeName} scheme - The scheme name.
   * @property {boolean} [domainHost] - Indicates if the scheme supports domain hosts.
   * @property {SchemeFn} parse - Function to parse the URI component for this scheme.
   * @property {SchemeFn} serialize - Function to serialize the URI component for this scheme.
   * @property {boolean} [skipNormalize] - Indicates if normalization should be skipped for this scheme.
   * @property {boolean} [absolutePath] - Indicates if the scheme uses absolute paths.
   * @property {boolean} [unicodeSupport] - Indicates if the scheme supports Unicode.
   */
  /**
   * @param {import('../types/index').URIComponent} wsComponent
   * @returns {boolean}
   */
  function wsIsSecure(wsComponent) {
    if (wsComponent.secure === true) return true;
    else if (wsComponent.secure === false) return false;
    else if (wsComponent.scheme)
      return (
        wsComponent.scheme.length === 3 &&
        (wsComponent.scheme[0] === "w" || wsComponent.scheme[0] === "W") &&
        (wsComponent.scheme[1] === "s" || wsComponent.scheme[1] === "S") &&
        (wsComponent.scheme[2] === "s" || wsComponent.scheme[2] === "S")
      );
    else return false;
  }
  /** @type {SchemeFn} */
  function httpParse(component) {
    if (!component.host)
      component.error = component.error || "HTTP URIs must have a host.";
    return component;
  }
  /** @type {SchemeFn} */
  function httpSerialize(component) {
    const secure = String(component.scheme).toLowerCase() === "https";
    if (component.port === (secure ? 443 : 80) || component.port === "")
      component.port = void 0;
    if (!component.path) component.path = "/";
    return component;
  }
  /** @type {SchemeFn} */
  function wsParse(wsComponent) {
    wsComponent.secure = wsIsSecure(wsComponent);
    wsComponent.resourceName =
      (wsComponent.path || "/") +
      (wsComponent.query ? "?" + wsComponent.query : "");
    wsComponent.path = void 0;
    wsComponent.query = void 0;
    return wsComponent;
  }
  /** @type {SchemeFn} */
  function wsSerialize(wsComponent) {
    if (
      wsComponent.port === (wsIsSecure(wsComponent) ? 443 : 80) ||
      wsComponent.port === ""
    )
      wsComponent.port = void 0;
    if (typeof wsComponent.secure === "boolean") {
      wsComponent.scheme = wsComponent.secure ? "wss" : "ws";
      wsComponent.secure = void 0;
    }
    if (wsComponent.resourceName) {
      const queryIndex = wsComponent.resourceName.indexOf("?");
      const path =
        queryIndex === -1
          ? wsComponent.resourceName
          : wsComponent.resourceName.slice(0, queryIndex);
      wsComponent.path = path && path !== "/" ? path : void 0;
      wsComponent.query =
        queryIndex === -1
          ? void 0
          : wsComponent.resourceName.slice(queryIndex + 1);
      wsComponent.resourceName = void 0;
    }
    wsComponent.fragment = void 0;
    return wsComponent;
  }
  /** @type {SchemeFn} */
  function urnParse(urnComponent, options) {
    if (!urnComponent.path) {
      urnComponent.error = "URN can not be parsed";
      return urnComponent;
    }
    const matches = urnComponent.path.match(URN_REG);
    if (matches && matches[0] === urnComponent.path) {
      const scheme = options.scheme || urnComponent.scheme || "urn";
      urnComponent.nid = matches[1].toLowerCase();
      urnComponent.nss = matches[2];
      const schemeHandler = getSchemeHandler(
        `${scheme}:${options.nid || urnComponent.nid}`,
      );
      urnComponent.path = void 0;
      if (schemeHandler)
        urnComponent = schemeHandler.parse(urnComponent, options);
    } else urnComponent.error = urnComponent.error || "URN can not be parsed.";
    return urnComponent;
  }
  /** @type {SchemeFn} */
  function urnSerialize(urnComponent, options) {
    if (urnComponent.nid === void 0)
      throw new Error("URN without nid cannot be serialized");
    const scheme = options.scheme || urnComponent.scheme || "urn";
    const nid = urnComponent.nid.toLowerCase();
    const schemeHandler = getSchemeHandler(`${scheme}:${options.nid || nid}`);
    if (schemeHandler)
      urnComponent = schemeHandler.serialize(urnComponent, options);
    const uriComponent = urnComponent;
    const nss = urnComponent.nss;
    uriComponent.path = `${nid || options.nid}:${nss}`;
    options.skipEscape = true;
    return uriComponent;
  }
  /** @type {SchemeFn} */
  function urnuuidParse(urnComponent, options) {
    const uuidComponent = urnComponent;
    uuidComponent.uuid = uuidComponent.nss;
    uuidComponent.nss = void 0;
    if (
      !options.tolerant &&
      (!uuidComponent.uuid || !isUUID(uuidComponent.uuid))
    )
      uuidComponent.error = uuidComponent.error || "UUID is not valid.";
    return uuidComponent;
  }
  /** @type {SchemeFn} */
  function urnuuidSerialize(uuidComponent) {
    const urnComponent = uuidComponent;
    urnComponent.nss = (uuidComponent.uuid || "").toLowerCase();
    return urnComponent;
  }
  const http = {
    scheme: "http",
    domainHost: true,
    parse: httpParse,
    serialize: httpSerialize,
  };
  const https = {
    scheme: "https",
    domainHost: http.domainHost,
    parse: httpParse,
    serialize: httpSerialize,
  };
  const ws = {
    scheme: "ws",
    domainHost: true,
    parse: wsParse,
    serialize: wsSerialize,
  };
  const SCHEMES = {
    http,
    https,
    ws,
    wss: {
      scheme: "wss",
      domainHost: ws.domainHost,
      parse: ws.parse,
      serialize: ws.serialize,
    },
    urn: {
      scheme: "urn",
      parse: urnParse,
      serialize: urnSerialize,
      skipNormalize: true,
    },
    "urn:uuid": {
      scheme: "urn:uuid",
      parse: urnuuidParse,
      serialize: urnuuidSerialize,
      skipNormalize: true,
    },
  };
  Object.setPrototypeOf(SCHEMES, null);
  /**
   * @param {string|undefined} scheme
   * @returns {SchemeHandler|undefined}
   */
  function getSchemeHandler(scheme) {
    return (
      (scheme && (SCHEMES[scheme] || SCHEMES[scheme.toLowerCase()])) || void 0
    );
  }
  module.exports = {
    wsIsSecure,
    SCHEMES,
    isValidSchemeName,
    getSchemeHandler,
  };
});
//#endregion
//#region ../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/index.js
var require_fast_uri = /* @__PURE__ */ __commonJSMin((exports, module) => {
  const {
    normalizeIPv6,
    removeDotSegments,
    recomposeAuthority,
    normalizePercentEncoding,
    normalizePathEncoding,
    serializePathEncoding,
    normalizeQueryFragmentEncoding,
    encodeQuery,
    encodeFragment,
    reescapeHostDelimiters,
    isIPv4,
    nonSimpleDomain,
  } = require_utils();
  const { SCHEMES, getSchemeHandler } = require_schemes();
  const VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
  const MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
  /**
   * @param {string} scheme
   * @returns {string}
   */
  function decodeValidScheme(scheme) {
    const decodedScheme = unescape(String(scheme));
    if (!VALID_SCHEME.test(decodedScheme))
      throw new TypeError(MALFORMED_SCHEME_ERROR);
    return decodedScheme;
  }
  /**
   * @template {import('./types/index').URIComponent|string} T
   * @param {T} uri
   * @param {import('./types/index').Options} [options]
   * @returns {T}
   */
  function normalize(uri, options) {
    if (typeof uri === "string") uri = normalizeString(uri, options);
    else if (typeof uri === "object")
      uri = parse(serialize(uri, options), options);
    return uri;
  }
  /**
   * @param {string} baseURI
   * @param {string} relativeURI
   * @param {import('./types/index').Options} [options]
   * @returns {string}
   */
  function resolve(baseURI, relativeURI, options) {
    const schemelessOptions = options
      ? Object.assign({ scheme: "null" }, options)
      : { scheme: "null" };
    const {
      parsed: baseParsed,
      malformedAuthorityOrPort: baseMalformed,
      malformedPercentEncoding: baseMalformedPercentEncoding,
      malformedSchemeSpecific: baseMalformedSchemeSpecific,
      malformedHost: baseMalformedHost,
      malformedScheme: baseMalformedScheme,
    } = parseWithStatus(baseURI, schemelessOptions);
    const {
      parsed: relativeParsed,
      malformedAuthorityOrPort: relativeMalformed,
      malformedPercentEncoding: relativeMalformedPercentEncoding,
      malformedSchemeSpecific: relativeMalformedSchemeSpecific,
      malformedHost: relativeMalformedHost,
      malformedScheme: relativeMalformedScheme,
    } = parseWithStatus(relativeURI, schemelessOptions);
    if (
      baseMalformed ||
      relativeMalformed ||
      baseMalformedPercentEncoding ||
      relativeMalformedPercentEncoding ||
      baseMalformedSchemeSpecific ||
      relativeMalformedSchemeSpecific ||
      baseMalformedHost ||
      relativeMalformedHost ||
      baseMalformedScheme ||
      relativeMalformedScheme
    )
      throw new Error(
        baseParsed.error || relativeParsed.error || "URI is malformed.",
      );
    const resolved = resolveComponent(
      baseParsed,
      relativeParsed,
      schemelessOptions,
      true,
    );
    const resolvedSchemeHandler = getSchemeHandler(
      (options && options.scheme) || resolved.scheme,
    );
    const resolvedHost = resolved.host;
    const resolvedHostIsIP =
      resolvedHost !== void 0 &&
      resolvedHost !== "" &&
      (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
    canonicalizeHost(
      resolved,
      options || {},
      resolvedSchemeHandler,
      resolvedHostIsIP,
    );
    const encodedASCIIHost =
      resolvedHost &&
      resolvedHost.indexOf("%") !== -1 &&
      !/\P{ASCII}/u.test(resolvedHost);
    if (resolved.error && !encodedASCIIHost) throw new Error(resolved.error);
    schemelessOptions.skipEscape = true;
    return serialize(resolved, schemelessOptions);
  }
  /**
   * @param {import ('./types/index').URIComponent} base
   * @param {import ('./types/index').URIComponent} relative
   * @param {import('./types/index').Options} [options]
   * @param {boolean} [skipNormalization=false]
   * @returns {import ('./types/index').URIComponent}
   */
  function resolveComponent(base, relative, options, skipNormalization) {
    /** @type {import('./types/index').URIComponent} */
    const target = {};
    if (!skipNormalization) {
      base = parse(serialize(base, options), options);
      relative = parse(serialize(relative, options), options);
    }
    options = options || {};
    if (!options.tolerant && relative.scheme) {
      target.scheme = relative.scheme;
      target.userinfo = relative.userinfo;
      target.host = relative.host;
      target.port = relative.port;
      target.path = removeDotSegments(relative.path || "");
      target.query = relative.query;
    } else {
      if (
        relative.userinfo !== void 0 ||
        relative.host !== void 0 ||
        relative.port !== void 0
      ) {
        target.userinfo = relative.userinfo;
        target.host = relative.host;
        target.port = relative.port;
        target.path = removeDotSegments(relative.path || "");
        target.query = relative.query;
      } else {
        if (!relative.path) {
          target.path = base.path;
          if (relative.query !== void 0) target.query = relative.query;
          else target.query = base.query;
        } else {
          if (relative.path[0] === "/")
            target.path = removeDotSegments(relative.path);
          else {
            if (
              (base.userinfo !== void 0 ||
                base.host !== void 0 ||
                base.port !== void 0) &&
              !base.path
            )
              target.path = "/" + relative.path;
            else if (!base.path) target.path = relative.path;
            else
              target.path =
                base.path.slice(0, base.path.lastIndexOf("/") + 1) +
                relative.path;
            target.path = removeDotSegments(target.path);
          }
          target.query = relative.query;
        }
        target.userinfo = base.userinfo;
        target.host = base.host;
        target.port = base.port;
      }
      target.scheme = base.scheme;
    }
    target.fragment = relative.fragment;
    return target;
  }
  /**
   * @param {import ('./types/index').URIComponent|string} uriA
   * @param {import ('./types/index').URIComponent|string} uriB
   * @param {import ('./types/index').Options} options
   * @returns {boolean}
   */
  function equal(uriA, uriB, options) {
    const normalizedA = normalizeComparableURI(uriA, options);
    const normalizedB = normalizeComparableURI(uriB, options);
    return (
      normalizedA !== void 0 &&
      normalizedB !== void 0 &&
      normalizedA === normalizedB
    );
  }
  /**
   * @param {Readonly<import('./types/index').URIComponent>} cmpts
   * @param {import('./types/index').Options} [opts]
   * @returns {string}
   */
  function serialize(cmpts, opts) {
    const component = {
      host: cmpts.host,
      scheme: cmpts.scheme,
      userinfo: cmpts.userinfo,
      port: cmpts.port,
      path: cmpts.path,
      query: cmpts.query,
      nid: cmpts.nid,
      nss: cmpts.nss,
      uuid: cmpts.uuid,
      fragment: cmpts.fragment,
      reference: cmpts.reference,
      resourceName: cmpts.resourceName,
      secure: cmpts.secure,
      error: "",
    };
    const options = Object.assign({}, opts);
    const uriTokens = [];
    if (component.scheme)
      component.scheme = decodeValidScheme(component.scheme);
    const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
    if (schemeHandler && schemeHandler.serialize)
      schemeHandler.serialize(component, options);
    const hasAuthority =
      component.userinfo !== void 0 ||
      component.host !== void 0 ||
      component.port !== void 0;
    const pathNoScheme =
      !options.skipEscape && component.scheme === void 0 && !hasAuthority;
    if (component.path !== void 0) {
      if (!options.skipEscape)
        component.path = serializePathEncoding(component.path, pathNoScheme);
      else component.path = normalizePercentEncoding(component.path);
    }
    if (options.reference !== "suffix" && component.scheme) {
      component.scheme = decodeValidScheme(component.scheme);
      uriTokens.push(component.scheme, ":");
    }
    const authority = recomposeAuthority(component);
    if (authority !== void 0) {
      if (options.reference !== "suffix") uriTokens.push("//");
      uriTokens.push(authority);
      if (component.path && component.path[0] !== "/") uriTokens.push("/");
    }
    if (component.path !== void 0) {
      let s = component.path;
      if (
        !options.absolutePath &&
        (!schemeHandler || !schemeHandler.absolutePath)
      )
        s = removeDotSegments(s);
      if (pathNoScheme) s = serializePathEncoding(s, true);
      if (authority === void 0 && s[0] === "/" && s[1] === "/")
        s = "/%2F" + s.slice(2);
      uriTokens.push(s);
    }
    if (component.query !== void 0)
      uriTokens.push("?", encodeQuery(component.query));
    if (component.fragment !== void 0)
      uriTokens.push("#", encodeFragment(component.fragment));
    return uriTokens.join("");
  }
  const URI_PARSE =
    /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
  const AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
  const AUTHORITY_INTRODUCER_REGION = /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/;
  /**
   * @param {import('./types/index').URIComponent} parsed
   * @param {RegExpMatchArray} matches
   * @returns {string|undefined}
   */
  function getParseError(parsed, matches) {
    if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/")
      return 'URI path must start with "/" when authority is present.';
    if (
      typeof parsed.port === "number" &&
      (parsed.port < 0 || parsed.port > 65535)
    )
      return "URI port is malformed.";
  }
  /**
   * Checks percent syntax without decoding the represented octets. RFC 3986
   * percent-encoding is byte-oriented, so sequences such as `%FF` are valid even
   * though they are not independently valid UTF-8.
   *
   * @param {string|undefined} component
   * @returns {boolean}
   */
  function hasMalformedPercentEncoding(component) {
    if (component === void 0) return false;
    let percent = component.indexOf("%");
    while (percent !== -1) {
      if (
        percent + 2 >= component.length ||
        !/^[\da-f]{2}$/iu.test(component.slice(percent + 1, percent + 3))
      )
        return true;
      percent = component.indexOf("%", percent + 3);
    }
    return false;
  }
  /**
   * Whether the host is a bracketed IP literal (RFC 3986 `IP-literal`).
   * An unterminated `[` is not a literal, so it must still be validated as a
   * reg-name instead of being waved through as an IP.
   *
   * @param {string} host
   * @returns {boolean}
   */
  function isIPLiteral(host) {
    return host[0] === "[" && host[host.length - 1] === "]";
  }
  /**
   * @param {RegExpMatchArray} matches
   * @returns {boolean}
   */
  function hasMalformedComponentPercentEncoding(matches) {
    const host = matches[4];
    return (
      hasMalformedPercentEncoding(matches[3]) ||
      (host !== void 0 &&
        !isIPLiteral(host) &&
        hasMalformedPercentEncoding(host)) ||
      hasMalformedPercentEncoding(matches[6]) ||
      hasMalformedPercentEncoding(matches[7]) ||
      hasMalformedPercentEncoding(matches[8])
    );
  }
  /**
   * @param {import('./types/index').URIComponent} parsed
   * @param {import('./types/index').Options} options
   * @param {{ domainHost?: boolean, unicodeSupport?: boolean }|undefined} schemeHandler
   * @param {boolean} isIP
   * @returns {boolean} whether host conversion failed
   */
  function canonicalizeHost(parsed, options, schemeHandler, isIP) {
    if (
      !options.unicodeSupport &&
      (!schemeHandler || !schemeHandler.unicodeSupport) &&
      parsed.host &&
      !isIPLiteral(parsed.host) &&
      (options.domainHost || (schemeHandler && schemeHandler.domainHost)) &&
      isIP === false &&
      nonSimpleDomain(parsed.host)
    )
      try {
        parsed.host = new URL("http://" + parsed.host).hostname;
      } catch (e) {
        parsed.error =
          parsed.error ||
          "Host's domain name can not be converted to ASCII: " + e;
        return true;
      }
    return false;
  }
  /**
   * @param {string} uri
   * @param {import('./types/index').Options} [opts]
   * @returns {{ parsed: import('./types/index').URIComponent, malformedAuthorityOrPort: boolean, malformedPercentEncoding: boolean, malformedSchemeSpecific: boolean, malformedHost: boolean, malformedScheme: boolean }}
   */
  function parseWithStatus(uri, opts) {
    const options = Object.assign({}, opts);
    /** @type {import('./types/index').URIComponent} */
    const parsed = {
      scheme: void 0,
      userinfo: void 0,
      host: "",
      port: void 0,
      path: "",
      query: void 0,
      fragment: void 0,
    };
    let malformedAuthorityOrPort = false;
    let malformedPercentEncoding = false;
    let malformedSchemeSpecific = false;
    let malformedHost = false;
    let malformedIPLiteral = false;
    let malformedScheme = false;
    let isIP = false;
    if (options.reference === "suffix") {
      if (options.scheme) uri = options.scheme + ":" + uri;
      else uri = "//" + uri;
    }
    const authorityMatch = uri.match(AUTHORITY_PREFIX);
    if (authorityMatch !== null && authorityMatch[1].indexOf("\\") !== -1) {
      parsed.error = "URI authority must not contain a literal backslash.";
      malformedAuthorityOrPort = true;
    }
    const introducerMatch = uri.match(AUTHORITY_INTRODUCER_REGION);
    if (introducerMatch !== null) {
      const region = introducerMatch[1];
      const normalizedRegion = region.replace(/[\t\n\r]/g, "");
      if (normalizedRegion.length >= 2) {
        if (normalizedRegion.slice(0, 2) !== "//") {
          parsed.error =
            parsed.error ||
            "URI authority must not contain a literal backslash.";
          malformedAuthorityOrPort = true;
        } else if (region.length !== normalizedRegion.length) {
          parsed.error =
            parsed.error ||
            "URI authority introducer must not contain whitespace.";
          malformedAuthorityOrPort = true;
        }
      }
    }
    const matches = uri.match(URI_PARSE);
    if (matches) {
      parsed.scheme = matches[1];
      parsed.userinfo = matches[3];
      parsed.host = matches[4];
      parsed.port = parseInt(matches[5], 10);
      parsed.path = matches[6] || "";
      parsed.query = matches[7];
      parsed.fragment = matches[8];
      if (parsed.scheme !== void 0) {
        const decodedScheme = unescape(parsed.scheme);
        if (VALID_SCHEME.test(decodedScheme))
          parsed.scheme = decodedScheme.toLowerCase();
        else {
          parsed.error = parsed.error || MALFORMED_SCHEME_ERROR;
          malformedScheme = true;
        }
      }
      malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches);
      if (malformedPercentEncoding)
        parsed.error =
          parsed.error || "URI contains malformed percent-encoding.";
      if (isNaN(parsed.port)) parsed.port = matches[5];
      const parseError = getParseError(parsed, matches);
      if (parseError !== void 0) {
        parsed.error = parsed.error || parseError;
        malformedAuthorityOrPort = true;
      }
      if (parsed.host) {
        if (isIPv4(parsed.host) === false) {
          const bracketedIPLiteral = isIPLiteral(parsed.host);
          const hasIPLiteralBracket =
            parsed.host.indexOf("[") !== -1 || parsed.host.indexOf("]") !== -1;
          const ipv6result = normalizeIPv6(parsed.host);
          isIP = ipv6result.isIPV6 || ipv6result.isIPVFuture === true;
          malformedIPLiteral =
            hasIPLiteralBracket &&
            (!bracketedIPLiteral || ipv6result.error === true);
          parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase();
          if (malformedIPLiteral) {
            parsed.error = parsed.error || "URI host is malformed.";
            malformedAuthorityOrPort = true;
          }
        } else isIP = true;
      }
      if (
        parsed.scheme === void 0 &&
        parsed.userinfo === void 0 &&
        parsed.host === void 0 &&
        parsed.port === void 0 &&
        parsed.query === void 0 &&
        !parsed.path
      )
        parsed.reference = "same-document";
      else if (parsed.scheme === void 0) parsed.reference = "relative";
      else if (parsed.fragment === void 0) parsed.reference = "absolute";
      else parsed.reference = "uri";
      if (
        options.reference &&
        options.reference !== "suffix" &&
        options.reference !== parsed.reference
      )
        parsed.error =
          parsed.error || "URI is not a " + options.reference + " reference.";
      const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
      if (!malformedIPLiteral)
        malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
      if (
        uri.indexOf("%") !== -1 &&
        parsed.host !== void 0 &&
        !malformedIPLiteral
      ) {
        let host = isIP
          ? parsed.host
          : normalizePercentEncoding(parsed.host, true);
        if (!isIP) host = normalizePercentEncoding(host.toLowerCase());
        parsed.host = reescapeHostDelimiters(host, isIP);
      }
      if (!schemeHandler || (schemeHandler && !schemeHandler.skipNormalize)) {
        if (parsed.path) parsed.path = normalizePathEncoding(parsed.path);
        if (parsed.query)
          parsed.query = normalizeQueryFragmentEncoding(parsed.query);
        if (parsed.fragment)
          parsed.fragment = normalizeQueryFragmentEncoding(parsed.fragment);
      }
      if (schemeHandler && schemeHandler.parse) {
        schemeHandler.parse(parsed, options);
        if (schemeHandler === SCHEMES.urn && parsed.nid === void 0)
          malformedSchemeSpecific = true;
      }
    } else parsed.error = parsed.error || "URI can not be parsed.";
    return {
      parsed,
      malformedAuthorityOrPort,
      malformedPercentEncoding,
      malformedSchemeSpecific,
      malformedHost,
      malformedScheme,
    };
  }
  /**
   * @param {string} uri
   * @param {import('./types/index').Options} [opts]
   * @returns
   */
  function parse(uri, opts) {
    return parseWithStatus(uri, opts).parsed;
  }
  /**
   * @param {string} uri
   * @param {import('./types/index').Options} [opts]
   * @returns {string}
   */
  function normalizeString(uri, opts) {
    return normalizeStringWithStatus(uri, opts).normalized;
  }
  /**
   * @param {string} uri
   * @param {import('./types/index').Options} [opts]
   * @returns {{ normalized: string, malformedAuthorityOrPort: boolean, malformedPercentEncoding: boolean, malformedSchemeSpecific: boolean, malformedHost: boolean, malformedScheme: boolean }}
   */
  function normalizeStringWithStatus(uri, opts) {
    const {
      parsed,
      malformedAuthorityOrPort,
      malformedPercentEncoding,
      malformedSchemeSpecific,
      malformedHost,
      malformedScheme,
    } = parseWithStatus(uri, opts);
    return {
      normalized:
        malformedAuthorityOrPort ||
        malformedPercentEncoding ||
        malformedSchemeSpecific ||
        malformedHost ||
        malformedScheme
          ? uri
          : serialize(parsed, opts),
      malformedAuthorityOrPort,
      malformedPercentEncoding,
      malformedSchemeSpecific,
      malformedHost,
      malformedScheme,
    };
  }
  /**
   * @param {import ('./types/index').URIComponent|string} uri
   * @param {import('./types/index').Options} [opts]
   * @returns {string|undefined}
   */
  function normalizeComparableURI(uri, opts) {
    if (typeof uri !== "string" && typeof uri !== "object") return;
    let value;
    try {
      value = typeof uri === "string" ? uri : serialize(uri, opts);
    } catch {
      return;
    }
    const {
      normalized,
      malformedAuthorityOrPort,
      malformedPercentEncoding,
      malformedSchemeSpecific,
      malformedHost,
      malformedScheme,
    } = normalizeStringWithStatus(value, opts);
    return malformedAuthorityOrPort ||
      malformedPercentEncoding ||
      malformedSchemeSpecific ||
      malformedHost ||
      malformedScheme
      ? void 0
      : normalized;
  }
  const fastUri = {
    SCHEMES,
    normalize,
    resolve,
    resolveComponent,
    equal,
    serialize,
    parse,
  };
  module.exports = fastUri;
  module.exports.default = fastUri;
  module.exports.fastUri = fastUri;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/uri.js
var require_uri = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const uri = require_fast_uri();
  uri.code = 'require("ajv/dist/runtime/uri").default';
  exports.default = uri;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/core.js
var require_core$1 = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.CodeGen =
    exports.Name =
    exports.nil =
    exports.stringify =
    exports.str =
    exports._ =
    exports.KeywordCxt =
      void 0;
  var validate_1 = require_validate();
  Object.defineProperty(exports, "KeywordCxt", {
    enumerable: true,
    get: function () {
      return validate_1.KeywordCxt;
    },
  });
  var codegen_1 = require_codegen();
  Object.defineProperty(exports, "_", {
    enumerable: true,
    get: function () {
      return codegen_1._;
    },
  });
  Object.defineProperty(exports, "str", {
    enumerable: true,
    get: function () {
      return codegen_1.str;
    },
  });
  Object.defineProperty(exports, "stringify", {
    enumerable: true,
    get: function () {
      return codegen_1.stringify;
    },
  });
  Object.defineProperty(exports, "nil", {
    enumerable: true,
    get: function () {
      return codegen_1.nil;
    },
  });
  Object.defineProperty(exports, "Name", {
    enumerable: true,
    get: function () {
      return codegen_1.Name;
    },
  });
  Object.defineProperty(exports, "CodeGen", {
    enumerable: true,
    get: function () {
      return codegen_1.CodeGen;
    },
  });
  const validation_error_1 = require_validation_error();
  const ref_error_1 = require_ref_error();
  const rules_1 = require_rules();
  const compile_1 = require_compile();
  const codegen_2 = require_codegen();
  const resolve_1 = require_resolve();
  const dataType_1 = require_dataType();
  const util_1 = require_util();
  const $dataRefSchema = require_data();
  const uri_1 = require_uri();
  const defaultRegExp = (str, flags) => new RegExp(str, flags);
  defaultRegExp.code = "new RegExp";
  const META_IGNORE_OPTIONS = [
    "removeAdditional",
    "useDefaults",
    "coerceTypes",
  ];
  const EXT_SCOPE_NAMES = /* @__PURE__ */ new Set([
    "validate",
    "serialize",
    "parse",
    "wrapper",
    "root",
    "schema",
    "keyword",
    "pattern",
    "formats",
    "validate$data",
    "func",
    "obj",
    "Error",
  ]);
  const 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.",
  };
  const deprecatedOptions = {
    ignoreKeywordsWithRef: "",
    jsPropertySyntax: "",
    unicode:
      '"minLength"/"maxLength" account for unicode characters by default.',
  };
  const MAX_EXPRESSION = 200;
  function requiredOptions(o) {
    var _a,
      _b,
      _c,
      _d,
      _e,
      _f,
      _g,
      _h,
      _j,
      _k,
      _l,
      _m,
      _o,
      _p,
      _q,
      _r,
      _s,
      _t,
      _u,
      _v,
      _w,
      _x,
      _y,
      _z,
      _0;
    const s = o.strict;
    const _optz =
      (_a = o.code) === null || _a === void 0 ? void 0 : _a.optimize;
    const optimize = _optz === true || _optz === void 0 ? 1 : _optz || 0;
    const regExp =
      (_c = (_b = o.code) === null || _b === void 0 ? void 0 : _b.regExp) !==
        null && _c !== void 0
        ? _c
        : defaultRegExp;
    const uriResolver =
      (_d = o.uriResolver) !== null && _d !== void 0 ? _d : uri_1.default;
    return {
      strictSchema:
        (_f = (_e = o.strictSchema) !== null && _e !== void 0 ? _e : s) !==
          null && _f !== void 0
          ? _f
          : true,
      strictNumbers:
        (_h = (_g = o.strictNumbers) !== null && _g !== void 0 ? _g : s) !==
          null && _h !== void 0
          ? _h
          : true,
      strictTypes:
        (_k = (_j = o.strictTypes) !== null && _j !== void 0 ? _j : s) !==
          null && _k !== void 0
          ? _k
          : "log",
      strictTuples:
        (_m = (_l = o.strictTuples) !== null && _l !== void 0 ? _l : s) !==
          null && _m !== void 0
          ? _m
          : "log",
      strictRequired:
        (_p = (_o = o.strictRequired) !== null && _o !== void 0 ? _o : s) !==
          null && _p !== void 0
          ? _p
          : false,
      code: o.code
        ? {
            ...o.code,
            optimize,
            regExp,
          }
        : {
            optimize,
            regExp,
          },
      loopRequired:
        (_q = o.loopRequired) !== null && _q !== void 0 ? _q : MAX_EXPRESSION,
      loopEnum:
        (_r = o.loopEnum) !== null && _r !== void 0 ? _r : MAX_EXPRESSION,
      meta: (_s = o.meta) !== null && _s !== void 0 ? _s : true,
      messages: (_t = o.messages) !== null && _t !== void 0 ? _t : true,
      inlineRefs: (_u = o.inlineRefs) !== null && _u !== void 0 ? _u : true,
      schemaId: (_v = o.schemaId) !== null && _v !== void 0 ? _v : "$id",
      addUsedSchema:
        (_w = o.addUsedSchema) !== null && _w !== void 0 ? _w : true,
      validateSchema:
        (_x = o.validateSchema) !== null && _x !== void 0 ? _x : true,
      validateFormats:
        (_y = o.validateFormats) !== null && _y !== void 0 ? _y : true,
      unicodeRegExp:
        (_z = o.unicodeRegExp) !== null && _z !== void 0 ? _z : true,
      int32range: (_0 = o.int32range) !== null && _0 !== void 0 ? _0 : true,
      uriResolver,
    };
  }
  var Ajv = class {
    constructor(opts = {}) {
      this.schemas = {};
      this.refs = {};
      this.formats = Object.create(null);
      this._compilations = /* @__PURE__ */ new Set();
      this._loading = {};
      this._cache = /* @__PURE__ */ new Map();
      opts = this.opts = {
        ...opts,
        ...requiredOptions(opts),
      };
      const { es5, lines } = this.opts.code;
      this.scope = new codegen_2.ValueScope({
        scope: {},
        prefixes: EXT_SCOPE_NAMES,
        es5,
        lines,
      });
      this.logger = getLogger(opts.logger);
      const formatOpt = opts.validateFormats;
      opts.validateFormats = false;
      this.RULES = (0, rules_1.getRules)();
      checkOptions.call(this, removedOptions, opts, "NOT SUPPORTED");
      checkOptions.call(this, deprecatedOptions, opts, "DEPRECATED", "warn");
      this._metaOpts = getMetaSchemaOptions.call(this);
      if (opts.formats) addInitialFormats.call(this);
      this._addVocabularies();
      this._addDefaultMetaSchema();
      if (opts.keywords) addInitialKeywords.call(this, opts.keywords);
      if (typeof opts.meta == "object") this.addMetaSchema(opts.meta);
      addInitialSchemas.call(this);
      opts.validateFormats = formatOpt;
    }
    _addVocabularies() {
      this.addKeyword("$async");
    }
    _addDefaultMetaSchema() {
      const { $data, meta, schemaId } = this.opts;
      let _dataRefSchema = $dataRefSchema;
      if (schemaId === "id") {
        _dataRefSchema = { ...$dataRefSchema };
        _dataRefSchema.id = _dataRefSchema.$id;
        delete _dataRefSchema.$id;
      }
      if (meta && $data)
        this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false);
    }
    defaultMeta() {
      const { meta, schemaId } = this.opts;
      return (this.opts.defaultMeta =
        typeof meta == "object" ? meta[schemaId] || meta : void 0);
    }
    validate(schemaKeyRef, data) {
      let v;
      if (typeof schemaKeyRef == "string") {
        v = this.getSchema(schemaKeyRef);
        if (!v) throw new Error(`no schema with key or ref "${schemaKeyRef}"`);
      } else v = this.compile(schemaKeyRef);
      const valid = v(data);
      if (!("$async" in v)) this.errors = v.errors;
      return valid;
    }
    compile(schema, _meta) {
      const sch = this._addSchema(schema, _meta);
      return sch.validate || this._compileSchemaEnv(sch);
    }
    compileAsync(schema, meta) {
      if (typeof this.opts.loadSchema != "function")
        throw new Error("options.loadSchema should be a function");
      const { loadSchema } = this.opts;
      return runCompileAsync.call(this, schema, meta);
      async function runCompileAsync(_schema, _meta) {
        await loadMetaSchema.call(this, _schema.$schema);
        const sch = this._addSchema(_schema, _meta);
        return sch.validate || _compileAsync.call(this, sch);
      }
      async function loadMetaSchema($ref) {
        if ($ref && !this.getSchema($ref))
          await runCompileAsync.call(this, { $ref }, true);
      }
      async function _compileAsync(sch) {
        try {
          return this._compileSchemaEnv(sch);
        } catch (e) {
          if (!(e instanceof ref_error_1.default)) throw e;
          checkLoaded.call(this, e);
          await loadMissingSchema.call(this, e.missingSchema);
          return _compileAsync.call(this, sch);
        }
      }
      function checkLoaded({ missingSchema: ref, missingRef }) {
        if (this.refs[ref])
          throw new Error(
            `AnySchema ${ref} is loaded but ${missingRef} cannot be resolved`,
          );
      }
      async function loadMissingSchema(ref) {
        const _schema = await _loadSchema.call(this, ref);
        if (!this.refs[ref]) await loadMetaSchema.call(this, _schema.$schema);
        if (!this.refs[ref]) this.addSchema(_schema, ref, meta);
      }
      async function _loadSchema(ref) {
        const p = this._loading[ref];
        if (p) return p;
        try {
          return await (this._loading[ref] = loadSchema(ref));
        } finally {
          delete this._loading[ref];
        }
      }
    }
    addSchema(schema, key, _meta, _validateSchema = this.opts.validateSchema) {
      if (Array.isArray(schema)) {
        for (const sch of schema)
          this.addSchema(sch, void 0, _meta, _validateSchema);
        return this;
      }
      let id;
      if (typeof schema === "object") {
        const { schemaId } = this.opts;
        id = schema[schemaId];
        if (id !== void 0 && typeof id != "string")
          throw new Error(`schema ${schemaId} must be string`);
      }
      key = (0, resolve_1.normalizeId)(key || id);
      this._checkUnique(key);
      this.schemas[key] = this._addSchema(
        schema,
        _meta,
        key,
        _validateSchema,
        true,
      );
      return this;
    }
    addMetaSchema(schema, key, _validateSchema = this.opts.validateSchema) {
      this.addSchema(schema, key, true, _validateSchema);
      return this;
    }
    validateSchema(schema, throwOrLogError) {
      if (typeof schema == "boolean") return true;
      let $schema;
      $schema = schema.$schema;
      if ($schema !== void 0 && typeof $schema != "string")
        throw new Error("$schema must be a string");
      $schema = $schema || this.opts.defaultMeta || this.defaultMeta();
      if (!$schema) {
        this.logger.warn("meta-schema not available");
        this.errors = null;
        return true;
      }
      const valid = this.validate($schema, schema);
      if (!valid && throwOrLogError) {
        const message = "schema is invalid: " + this.errorsText();
        if (this.opts.validateSchema === "log") this.logger.error(message);
        else throw new Error(message);
      }
      return valid;
    }
    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);
    }
    removeSchema(schemaKeyRef) {
      if (schemaKeyRef instanceof RegExp) {
        this._removeAllSchemas(this.schemas, schemaKeyRef);
        this._removeAllSchemas(this.refs, schemaKeyRef);
        return this;
      }
      switch (typeof schemaKeyRef) {
        case "undefined":
          this._removeAllSchemas(this.schemas);
          this._removeAllSchemas(this.refs);
          this._cache.clear();
          return this;
        case "string": {
          const sch = getSchEnv.call(this, schemaKeyRef);
          if (typeof sch == "object") this._cache.delete(sch.schema);
          delete this.schemas[schemaKeyRef];
          delete this.refs[schemaKeyRef];
          return this;
        }
        case "object": {
          const cacheKey = schemaKeyRef;
          this._cache.delete(cacheKey);
          let id = schemaKeyRef[this.opts.schemaId];
          if (id) {
            id = (0, resolve_1.normalizeId)(id);
            delete this.schemas[id];
            delete this.refs[id];
          }
          return this;
        }
        default:
          throw new Error("ajv.removeSchema: invalid parameter");
      }
    }
    addVocabulary(definitions) {
      for (const def of definitions) this.addKeyword(def);
      return this;
    }
    addKeyword(kwdOrDef, def) {
      let keyword;
      if (typeof kwdOrDef == "string") {
        keyword = kwdOrDef;
        if (typeof def == "object") {
          this.logger.warn(
            "these parameters are deprecated, see docs for addKeyword",
          );
          def.keyword = keyword;
        }
      } else if (typeof kwdOrDef == "object" && def === 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;
    }
    removeKeyword(keyword) {
      const { RULES } = this;
      delete RULES.keywords[keyword];
      delete RULES.all[keyword];
      for (const group of RULES.rules) {
        const i = group.rules.findIndex((rule) => rule.keyword === keyword);
        if (i >= 0) group.rules.splice(i, 1);
      }
      return this;
    }
    addFormat(name, format) {
      if (typeof format == "string") format = new RegExp(format);
      this.formats[name] = format;
      return this;
    }
    errorsText(
      errors = this.errors,
      { separator = ", ", dataVar = "data" } = {},
    ) {
      if (!errors || errors.length === 0) return "No errors";
      return errors
        .map((e) => `${dataVar}${e.instancePath} ${e.message}`)
        .reduce((text, msg) => text + separator + msg);
    }
    $dataMetaSchema(metaSchema, keywordsJsonPointers) {
      const rules = this.RULES.all;
      metaSchema = JSON.parse(JSON.stringify(metaSchema));
      for (const jsonPointer of keywordsJsonPointers) {
        const segments = jsonPointer.split("/").slice(1);
        let keywords = metaSchema;
        for (const seg of segments) keywords = keywords[seg];
        for (const key in rules) {
          const rule = rules[key];
          if (typeof rule != "object") continue;
          const { $data } = rule.definition;
          const schema = keywords[key];
          if ($data && schema) keywords[key] = schemaOrData(schema);
        }
      }
      return metaSchema;
    }
    _removeAllSchemas(schemas, regex) {
      for (const keyRef in schemas) {
        const sch = schemas[keyRef];
        if (!regex || regex.test(keyRef)) {
          if (typeof sch == "string") delete schemas[keyRef];
          else if (sch && !sch.meta) {
            this._cache.delete(sch.schema);
            delete schemas[keyRef];
          }
        }
      }
    }
    _addSchema(
      schema,
      meta,
      baseId,
      validateSchema = this.opts.validateSchema,
      addSchema = this.opts.addUsedSchema,
    ) {
      let id;
      const { schemaId } = this.opts;
      if (typeof schema == "object") id = schema[schemaId];
      else if (this.opts.jtd) throw new Error("schema must be object");
      else if (typeof schema != "boolean")
        throw new Error("schema must be object or boolean");
      let sch = this._cache.get(schema);
      if (sch !== void 0) return sch;
      baseId = (0, resolve_1.normalizeId)(id || baseId);
      const localRefs = resolve_1.getSchemaRefs.call(this, schema, baseId);
      sch = new compile_1.SchemaEnv({
        schema,
        schemaId,
        meta,
        baseId,
        localRefs,
      });
      this._cache.set(sch.schema, sch);
      if (addSchema && !baseId.startsWith("#")) {
        if (baseId) this._checkUnique(baseId);
        this.refs[baseId] = sch;
      }
      if (validateSchema) this.validateSchema(schema, true);
      return sch;
    }
    _checkUnique(id) {
      if (this.schemas[id] || this.refs[id])
        throw new Error(`schema with key or id "${id}" already exists`);
    }
    _compileSchemaEnv(sch) {
      if (sch.meta) this._compileMetaSchema(sch);
      else compile_1.compileSchema.call(this, sch);
      /* istanbul ignore if */
      if (!sch.validate) throw new Error("ajv implementation error");
      return sch.validate;
    }
    _compileMetaSchema(sch) {
      const currentOpts = this.opts;
      this.opts = this._metaOpts;
      try {
        compile_1.compileSchema.call(this, sch);
      } finally {
        this.opts = currentOpts;
      }
    }
  };
  Ajv.ValidationError = validation_error_1.default;
  Ajv.MissingRefError = ref_error_1.default;
  exports.default = Ajv;
  function checkOptions(checkOpts, options, msg, log = "error") {
    for (const key in checkOpts) {
      const opt = key;
      if (opt in options)
        this.logger[log](`${msg}: option ${key}. ${checkOpts[opt]}`);
    }
  }
  function getSchEnv(keyRef) {
    keyRef = (0, resolve_1.normalizeId)(keyRef);
    return this.schemas[keyRef] || this.refs[keyRef];
  }
  function addInitialSchemas() {
    const optsSchemas = this.opts.schemas;
    if (!optsSchemas) return;
    if (Array.isArray(optsSchemas)) this.addSchema(optsSchemas);
    else for (const key in optsSchemas) this.addSchema(optsSchemas[key], key);
  }
  function addInitialFormats() {
    for (const name in this.opts.formats) {
      const format = this.opts.formats[name];
      if (format) this.addFormat(name, format);
    }
  }
  function addInitialKeywords(defs) {
    if (Array.isArray(defs)) {
      this.addVocabulary(defs);
      return;
    }
    this.logger.warn("keywords option as map is deprecated, pass array");
    for (const keyword in defs) {
      const def = defs[keyword];
      if (!def.keyword) def.keyword = keyword;
      this.addKeyword(def);
    }
  }
  function getMetaSchemaOptions() {
    const metaOpts = { ...this.opts };
    for (const opt of META_IGNORE_OPTIONS) delete metaOpts[opt];
    return metaOpts;
  }
  const 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");
  }
  const KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
  function checkKeyword(keyword, def) {
    const { RULES } = this;
    (0, util_1.eachItem)(keyword, (kwd) => {
      if (RULES.keywords[kwd])
        throw new Error(`Keyword ${kwd} is already defined`);
      if (!KEYWORD_NAME.test(kwd))
        throw new Error(`Keyword ${kwd} has invalid name`);
    });
    if (!def) return;
    if (def.$data && !("code" in def || "validate" in def))
      throw new Error('$data keyword must have "code" or "validate" function');
  }
  function addRule(keyword, definition, dataType) {
    var _a;
    const post =
      definition === null || definition === void 0 ? void 0 : definition.post;
    if (dataType && post)
      throw new Error('keyword with "post" flag cannot have "type"');
    const { RULES } = this;
    let ruleGroup = post
      ? RULES.post
      : RULES.rules.find(({ type: t }) => t === dataType);
    if (!ruleGroup) {
      ruleGroup = {
        type: dataType,
        rules: [],
      };
      RULES.rules.push(ruleGroup);
    }
    RULES.keywords[keyword] = true;
    if (!definition) return;
    const rule = {
      keyword,
      definition: {
        ...definition,
        type: (0, dataType_1.getJSONTypes)(definition.type),
        schemaType: (0, dataType_1.getJSONTypes)(definition.schemaType),
      },
    };
    if (definition.before)
      addBeforeRule.call(this, ruleGroup, rule, definition.before);
    else ruleGroup.rules.push(rule);
    RULES.all[keyword] = rule;
    (_a = definition.implements) === null ||
      _a === void 0 ||
      _a.forEach((kwd) => this.addKeyword(kwd));
  }
  function addBeforeRule(ruleGroup, rule, before) {
    const i = ruleGroup.rules.findIndex((_rule) => _rule.keyword === before);
    if (i >= 0) ruleGroup.rules.splice(i, 0, rule);
    else {
      ruleGroup.rules.push(rule);
      this.logger.warn(`rule ${before} is not defined`);
    }
  }
  function keywordMetaschema(def) {
    let { metaSchema } = def;
    if (metaSchema === void 0) return;
    if (def.$data && this.opts.$data) metaSchema = schemaOrData(metaSchema);
    def.validateSchema = this.compile(metaSchema, true);
  }
  const $dataRef = {
    $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#",
  };
  function schemaOrData(schema) {
    return { anyOf: [schema, $dataRef] };
  }
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/core/id.js
var require_id = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.default = {
    keyword: "id",
    code() {
      throw new Error('NOT SUPPORTED: keyword "id", use "$id" for schema ID');
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/core/ref.js
var require_ref = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.callRef = exports.getValidate = void 0;
  const ref_error_1 = require_ref_error();
  const code_1 = require_code();
  const codegen_1 = require_codegen();
  const names_1 = require_names();
  const compile_1 = require_compile();
  const util_1 = require_util();
  const def = {
    keyword: "$ref",
    schemaType: "string",
    code(cxt) {
      const { gen, schema: $ref, it } = cxt;
      const { baseId, schemaEnv: env, validateName, opts, self } = it;
      const { root } = env;
      if (($ref === "#" || $ref === "#/") && baseId === root.baseId)
        return callRootRef();
      const schOrEnv = compile_1.resolveRef.call(self, root, baseId, $ref);
      if (schOrEnv === void 0)
        throw new ref_error_1.default(it.opts.uriResolver, baseId, $ref);
      if (schOrEnv instanceof compile_1.SchemaEnv)
        return callValidate(schOrEnv);
      return inlineRefSchema(schOrEnv);
      function callRootRef() {
        if (env === root) return callRef(cxt, validateName, env, env.$async);
        const rootName = gen.scopeValue("root", { ref: root });
        return callRef(
          cxt,
          (0, codegen_1._)`${rootName}.validate`,
          root,
          root.$async,
        );
      }
      function callValidate(sch) {
        callRef(cxt, getValidate(cxt, sch), sch, sch.$async);
      }
      function inlineRefSchema(sch) {
        const schName = gen.scopeValue(
          "schema",
          opts.code.source === true
            ? {
                ref: sch,
                code: (0, codegen_1.stringify)(sch),
              }
            : { ref: sch },
        );
        const valid = gen.name("valid");
        const schCxt = cxt.subschema(
          {
            schema: sch,
            dataTypes: [],
            schemaPath: codegen_1.nil,
            topSchemaRef: schName,
            errSchemaPath: $ref,
          },
          valid,
        );
        cxt.mergeEvaluated(schCxt);
        cxt.ok(valid);
      }
    },
  };
  function getValidate(cxt, sch) {
    const { gen } = cxt;
    return sch.validate
      ? gen.scopeValue("validate", { ref: sch.validate })
      : (0, codegen_1._)`${gen.scopeValue("wrapper", { ref: sch })}.validate`;
  }
  exports.getValidate = getValidate;
  function callRef(cxt, v, sch, $async) {
    const { gen, it } = cxt;
    const { allErrors, schemaEnv: env, opts } = it;
    const passCxt = opts.passContext ? names_1.default.this : codegen_1.nil;
    if ($async) callAsyncRef();
    else callSyncRef();
    function callAsyncRef() {
      if (!env.$async)
        throw new Error("async schema referenced by sync schema");
      const valid = gen.let("valid");
      gen.try(
        () => {
          gen.code(
            (0,
            codegen_1._)`await ${(0, code_1.callValidateCode)(cxt, v, passCxt)}`,
          );
          addEvaluatedFrom(v);
          if (!allErrors) gen.assign(valid, true);
        },
        (e) => {
          gen.if(
            (0, codegen_1._)`!(${e} instanceof ${it.ValidationError})`,
            () => gen.throw(e),
          );
          addErrorsFrom(e);
          if (!allErrors) gen.assign(valid, false);
        },
      );
      cxt.ok(valid);
    }
    function callSyncRef() {
      cxt.result(
        (0, code_1.callValidateCode)(cxt, v, passCxt),
        () => addEvaluatedFrom(v),
        () => addErrorsFrom(v),
      );
    }
    function addErrorsFrom(source) {
      const errs = (0, codegen_1._)`${source}.errors`;
      gen.assign(
        names_1.default.vErrors,
        (0,
        codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`,
      );
      gen.assign(
        names_1.default.errors,
        (0, codegen_1._)`${names_1.default.vErrors}.length`,
      );
    }
    function addEvaluatedFrom(source) {
      var _a;
      if (!it.opts.unevaluated) return;
      const schEvaluated =
        (_a = sch === null || sch === void 0 ? void 0 : sch.validate) ===
          null || _a === void 0
          ? void 0
          : _a.evaluated;
      if (it.props !== true) {
        if (schEvaluated && !schEvaluated.dynamicProps) {
          if (schEvaluated.props !== void 0)
            it.props = util_1.mergeEvaluated.props(
              gen,
              schEvaluated.props,
              it.props,
            );
        } else {
          const props = gen.var(
            "props",
            (0, codegen_1._)`${source}.evaluated.props`,
          );
          it.props = util_1.mergeEvaluated.props(
            gen,
            props,
            it.props,
            codegen_1.Name,
          );
        }
      }
      if (it.items !== true) {
        if (schEvaluated && !schEvaluated.dynamicItems) {
          if (schEvaluated.items !== void 0)
            it.items = util_1.mergeEvaluated.items(
              gen,
              schEvaluated.items,
              it.items,
            );
        } else {
          const items = gen.var(
            "items",
            (0, codegen_1._)`${source}.evaluated.items`,
          );
          it.items = util_1.mergeEvaluated.items(
            gen,
            items,
            it.items,
            codegen_1.Name,
          );
        }
      }
    }
  }
  exports.callRef = callRef;
  exports.default = def;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/core/index.js
var require_core = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const id_1 = require_id();
  const ref_1 = require_ref();
  exports.default = [
    "$schema",
    "$id",
    "$defs",
    "$vocabulary",
    { keyword: "$comment" },
    "definitions",
    id_1.default,
    ref_1.default,
  ];
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitNumber.js
var require_limitNumber = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const ops = codegen_1.operators;
  const 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,
    },
  };
  exports.default = {
    keyword: Object.keys(KWDs),
    type: "number",
    schemaType: "number",
    $data: true,
    error: {
      message: ({ keyword, schemaCode }) =>
        (0, codegen_1.str)`must be ${KWDs[keyword].okStr} ${schemaCode}`,
      params: ({ keyword, schemaCode }) =>
        (0,
        codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`,
    },
    code(cxt) {
      const { keyword, data, schemaCode } = cxt;
      cxt.fail$data(
        (0,
        codegen_1._)`${data} ${KWDs[keyword].fail} ${schemaCode} || isNaN(${data})`,
      );
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/multipleOf.js
var require_multipleOf = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  exports.default = {
    keyword: "multipleOf",
    type: "number",
    schemaType: "number",
    $data: true,
    error: {
      message: ({ schemaCode }) =>
        (0, codegen_1.str)`must be multiple of ${schemaCode}`,
      params: ({ schemaCode }) => (0, codegen_1._)`{multipleOf: ${schemaCode}}`,
    },
    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}))`,
      );
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/ucs2length.js
var require_ucs2length = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  function ucs2length(str) {
    const len = str.length;
    let length = 0;
    let pos = 0;
    let value;
    while (pos < len) {
      length++;
      value = str.charCodeAt(pos++);
      if (value >= 55296 && value <= 56319 && pos < len) {
        value = str.charCodeAt(pos);
        if ((value & 64512) === 56320) pos++;
      }
    }
    return length;
  }
  exports.default = ucs2length;
  ucs2length.code = 'require("ajv/dist/runtime/ucs2length").default';
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitLength.js
var require_limitLength = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const ucs2length_1 = require_ucs2length();
  exports.default = {
    keyword: ["maxLength", "minLength"],
    type: "string",
    schemaType: "number",
    $data: true,
    error: {
      message({ keyword, schemaCode }) {
        const comp = keyword === "maxLength" ? "more" : "fewer";
        return (0,
        codegen_1.str)`must NOT have ${comp} than ${schemaCode} characters`;
      },
      params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`,
    },
    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}`);
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/pattern.js
var require_pattern = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const code_1 = require_code();
  const util_1 = require_util();
  const codegen_1 = require_codegen();
  exports.default = {
    keyword: "pattern",
    type: "string",
    schemaType: "string",
    $data: true,
    error: {
      message: ({ schemaCode }) =>
        (0, codegen_1.str)`must match pattern "${schemaCode}"`,
      params: ({ schemaCode }) => (0, codegen_1._)`{pattern: ${schemaCode}}`,
    },
    code(cxt) {
      const { gen, data, $data, schema, schemaCode, it } = cxt;
      const u = it.opts.unicodeRegExp ? "u" : "";
      if ($data) {
        const { regExp } = it.opts.code;
        const regExpCode =
          regExp.code === "new RegExp"
            ? (0, codegen_1._)`new RegExp`
            : (0, util_1.useFunc)(gen, regExp);
        const valid = gen.let("valid");
        gen.try(
          () =>
            gen.assign(
              valid,
              (0,
              codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`,
            ),
          () => gen.assign(valid, false),
        );
        cxt.fail$data((0, codegen_1._)`!${valid}`);
      } else {
        const regExp = (0, code_1.usePattern)(cxt, schema);
        cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitProperties.js
var require_limitProperties = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  exports.default = {
    keyword: ["maxProperties", "minProperties"],
    type: "object",
    schemaType: "number",
    $data: true,
    error: {
      message({ keyword, schemaCode }) {
        const comp = keyword === "maxProperties" ? "more" : "fewer";
        return (0,
        codegen_1.str)`must NOT have ${comp} than ${schemaCode} properties`;
      },
      params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`,
    },
    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}`,
      );
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/required.js
var require_required = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const code_1 = require_code();
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  exports.default = {
    keyword: "required",
    type: "object",
    schemaType: "array",
    $data: true,
    error: {
      message: ({ params: { missingProperty } }) =>
        (0, codegen_1.str)`must have required property '${missingProperty}'`,
      params: ({ params: { missingProperty } }) =>
        (0, codegen_1._)`{missingProperty: ${missingProperty}}`,
    },
    code(cxt) {
      const { gen, schema, schemaCode, data, $data, it } = cxt;
      const { opts } = it;
      if (!$data && schema.length === 0) return;
      const useLoop = schema.length >= opts.loopRequired;
      if (it.allErrors) allErrorsMode();
      else exitOnErrorMode();
      if (opts.strictRequired) {
        const props = cxt.parentSchema.properties;
        const { definedProperties } = cxt.it;
        for (const requiredKey of schema)
          if (
            (props === null || props === void 0
              ? void 0
              : props[requiredKey]) === void 0 &&
            !definedProperties.has(requiredKey)
          ) {
            const msg = `required property "${requiredKey}" is not defined at "${it.schemaEnv.baseId + it.errSchemaPath}" (strictRequired)`;
            (0, util_1.checkStrictMode)(it, msg, it.opts.strictRequired);
          }
      }
      function allErrorsMode() {
        if (useLoop || $data) cxt.block$data(codegen_1.nil, loopAllRequired);
        else
          for (const prop of schema)
            (0, code_1.checkReportMissingProp)(cxt, prop);
      }
      function exitOnErrorMode() {
        const missing = gen.let("missing");
        if (useLoop || $data) {
          const valid = gen.let("valid", true);
          cxt.block$data(valid, () => loopUntilMissing(missing, valid));
          cxt.ok(valid);
        } else {
          gen.if((0, code_1.checkMissingProp)(cxt, schema, missing));
          (0, code_1.reportMissingProp)(cxt, missing);
          gen.else();
        }
      }
      function loopAllRequired() {
        gen.forOf("prop", schemaCode, (prop) => {
          cxt.setParams({ missingProperty: prop });
          gen.if(
            (0, code_1.noPropertyInData)(gen, data, prop, opts.ownProperties),
            () => cxt.error(),
          );
        });
      }
      function loopUntilMissing(missing, valid) {
        cxt.setParams({ missingProperty: missing });
        gen.forOf(
          missing,
          schemaCode,
          () => {
            gen.assign(
              valid,
              (0, code_1.propertyInData)(
                gen,
                data,
                missing,
                opts.ownProperties,
              ),
            );
            gen.if((0, codegen_1.not)(valid), () => {
              cxt.error();
              gen.break();
            });
          },
          codegen_1.nil,
        );
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitItems.js
var require_limitItems = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  exports.default = {
    keyword: ["maxItems", "minItems"],
    type: "array",
    schemaType: "number",
    $data: true,
    error: {
      message({ keyword, schemaCode }) {
        const comp = keyword === "maxItems" ? "more" : "fewer";
        return (0,
        codegen_1.str)`must NOT have ${comp} than ${schemaCode} items`;
      },
      params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`,
    },
    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}`);
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/equal.js
var require_equal = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const equal = require_fast_deep_equal();
  equal.code = 'require("ajv/dist/runtime/equal").default';
  exports.default = equal;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/uniqueItems.js
var require_uniqueItems = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const dataType_1 = require_dataType();
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const equal_1 = require_equal();
  exports.default = {
    keyword: "uniqueItems",
    type: "array",
    schemaType: "boolean",
    $data: true,
    error: {
      message: ({ params: { i, j } }) =>
        (0,
        codegen_1.str)`must NOT have duplicate items (items ## ${j} and ${i} are identical)`,
      params: ({ params: { i, j } }) => (0, codegen_1._)`{i: ${i}, j: ${j}}`,
    },
    code(cxt) {
      const { gen, data, $data, schema, parentSchema, schemaCode, it } = cxt;
      if (!$data && !schema) return;
      const valid = gen.let("valid");
      const itemTypes = parentSchema.items
        ? (0, dataType_1.getSchemaTypes)(parentSchema.items)
        : [];
      cxt.block$data(
        valid,
        validateUniqueItems,
        (0, codegen_1._)`${schemaCode} === false`,
      );
      cxt.ok(valid);
      function validateUniqueItems() {
        const i = gen.let("i", (0, codegen_1._)`${data}.length`);
        const j = gen.let("j");
        cxt.setParams({
          i,
          j,
        });
        gen.assign(valid, true);
        gen.if((0, codegen_1._)`${i} > 1`, () =>
          (canOptimize() ? loopN : loopN2)(i, j),
        );
      }
      function canOptimize() {
        return (
          itemTypes.length > 0 &&
          !itemTypes.some((t) => t === "object" || t === "array")
        );
      }
      function loopN(i, j) {
        const item = gen.name("item");
        const wrongType = (0, dataType_1.checkDataTypes)(
          itemTypes,
          item,
          it.opts.strictNumbers,
          dataType_1.DataType.Wrong,
        );
        const indices = gen.const("indices", (0, codegen_1._)`{}`);
        gen.for((0, codegen_1._)`;${i}--;`, () => {
          gen.let(item, (0, codegen_1._)`${data}[${i}]`);
          gen.if(wrongType, (0, codegen_1._)`continue`);
          if (itemTypes.length > 1)
            gen.if(
              (0, codegen_1._)`typeof ${item} == "string"`,
              (0, codegen_1._)`${item} += "_"`,
            );
          gen
            .if(
              (0, codegen_1._)`typeof ${indices}[${item}] == "number"`,
              () => {
                gen.assign(j, (0, codegen_1._)`${indices}[${item}]`);
                cxt.error();
                gen.assign(valid, false).break();
              },
            )
            .code((0, codegen_1._)`${indices}[${item}] = ${i}`);
        });
      }
      function loopN2(i, j) {
        const eql = (0, util_1.useFunc)(gen, equal_1.default);
        const outer = gen.name("outer");
        gen.label(outer).for((0, codegen_1._)`;${i}--;`, () =>
          gen.for((0, codegen_1._)`${j} = ${i}; ${j}--;`, () =>
            gen.if(
              (0, codegen_1._)`${eql}(${data}[${i}], ${data}[${j}])`,
              () => {
                cxt.error();
                gen.assign(valid, false).break(outer);
              },
            ),
          ),
        );
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/const.js
var require_const = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const equal_1 = require_equal();
  exports.default = {
    keyword: "const",
    $data: true,
    error: {
      message: "must be equal to constant",
      params: ({ schemaCode }) =>
        (0, codegen_1._)`{allowedValue: ${schemaCode}}`,
    },
    code(cxt) {
      const { gen, data, $data, schemaCode, schema } = cxt;
      if ($data || (schema && typeof schema == "object"))
        cxt.fail$data(
          (0,
          codegen_1._)`!${(0, util_1.useFunc)(gen, equal_1.default)}(${data}, ${schemaCode})`,
        );
      else cxt.fail((0, codegen_1._)`${schema} !== ${data}`);
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/enum.js
var require_enum = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const equal_1 = require_equal();
  exports.default = {
    keyword: "enum",
    schemaType: "array",
    $data: true,
    error: {
      message: "must be equal to one of the allowed values",
      params: ({ schemaCode }) =>
        (0, codegen_1._)`{allowedValues: ${schemaCode}}`,
    },
    code(cxt) {
      const { gen, data, $data, schema, schemaCode, it } = cxt;
      if (!$data && schema.length === 0)
        throw new Error("enum must have non-empty array");
      const useLoop = schema.length >= it.opts.loopEnum;
      let eql;
      const getEql = () =>
        eql !== null && eql !== void 0
          ? eql
          : (eql = (0, util_1.useFunc)(gen, equal_1.default));
      let valid;
      if (useLoop || $data) {
        valid = gen.let("valid");
        cxt.block$data(valid, loopEnum);
      } else {
        /* istanbul ignore if */
        if (!Array.isArray(schema)) throw new Error("ajv implementation error");
        const vSchema = gen.const("vSchema", schemaCode);
        valid = (0, codegen_1.or)(
          ...schema.map((_x, i) => equalCode(vSchema, i)),
        );
      }
      cxt.pass(valid);
      function loopEnum() {
        gen.assign(valid, false);
        gen.forOf("v", schemaCode, (v) =>
          gen.if((0, codegen_1._)`${getEql()}(${data}, ${v})`, () =>
            gen.assign(valid, true).break(),
          ),
        );
      }
      function equalCode(vSchema, i) {
        const sch = schema[i];
        return typeof sch === "object" && sch !== null
          ? (0, codegen_1._)`${getEql()}(${data}, ${vSchema}[${i}])`
          : (0, codegen_1._)`${data} === ${sch}`;
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/index.js
var require_validation = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const limitNumber_1 = require_limitNumber();
  const multipleOf_1 = require_multipleOf();
  const limitLength_1 = require_limitLength();
  const pattern_1 = require_pattern();
  const limitProperties_1 = require_limitProperties();
  const required_1 = require_required();
  const limitItems_1 = require_limitItems();
  const uniqueItems_1 = require_uniqueItems();
  const const_1 = require_const();
  const enum_1 = require_enum();
  exports.default = [
    limitNumber_1.default,
    multipleOf_1.default,
    limitLength_1.default,
    pattern_1.default,
    limitProperties_1.default,
    required_1.default,
    limitItems_1.default,
    uniqueItems_1.default,
    {
      keyword: "type",
      schemaType: ["string", "array"],
    },
    {
      keyword: "nullable",
      schemaType: "boolean",
    },
    const_1.default,
    enum_1.default,
  ];
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/additionalItems.js
var require_additionalItems = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.validateAdditionalItems = void 0;
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const def = {
    keyword: "additionalItems",
    type: "array",
    schemaType: ["boolean", "object"],
    before: "uniqueItems",
    error: {
      message: ({ params: { len } }) =>
        (0, codegen_1.str)`must NOT have more than ${len} items`,
      params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`,
    },
    code(cxt) {
      const { parentSchema, it } = cxt;
      const { items } = parentSchema;
      if (!Array.isArray(items)) {
        (0, util_1.checkStrictMode)(
          it,
          '"additionalItems" is ignored when "items" is not an array of schemas',
        );
        return;
      }
      validateAdditionalItems(cxt, items);
    },
  };
  function validateAdditionalItems(cxt, items) {
    const { gen, schema, data, keyword, it } = cxt;
    it.items = true;
    const len = gen.const("len", (0, codegen_1._)`${data}.length`);
    if (schema === false) {
      cxt.setParams({ len: items.length });
      cxt.pass((0, codegen_1._)`${len} <= ${items.length}`);
    } else if (
      typeof schema == "object" &&
      !(0, util_1.alwaysValidSchema)(it, schema)
    ) {
      const valid = gen.var(
        "valid",
        (0, codegen_1._)`${len} <= ${items.length}`,
      );
      gen.if((0, codegen_1.not)(valid), () => validateItems(valid));
      cxt.ok(valid);
    }
    function validateItems(valid) {
      gen.forRange("i", items.length, len, (i) => {
        cxt.subschema(
          {
            keyword,
            dataProp: i,
            dataPropType: util_1.Type.Num,
          },
          valid,
        );
        if (!it.allErrors) gen.if((0, codegen_1.not)(valid), () => gen.break());
      });
    }
  }
  exports.validateAdditionalItems = validateAdditionalItems;
  exports.default = def;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/items.js
var require_items = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.validateTuple = void 0;
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const code_1 = require_code();
  const def = {
    keyword: "items",
    type: "array",
    schemaType: ["object", "array", "boolean"],
    before: "uniqueItems",
    code(cxt) {
      const { schema, it } = cxt;
      if (Array.isArray(schema))
        return validateTuple(cxt, "additionalItems", schema);
      it.items = true;
      if ((0, util_1.alwaysValidSchema)(it, schema)) return;
      cxt.ok((0, code_1.validateArray)(cxt));
    },
  };
  function validateTuple(cxt, extraItems, schArr = cxt.schema) {
    const { gen, parentSchema, data, keyword, it } = cxt;
    checkStrictTuple(parentSchema);
    if (it.opts.unevaluated && schArr.length && it.items !== true)
      it.items = util_1.mergeEvaluated.items(gen, schArr.length, it.items);
    const valid = gen.name("valid");
    const len = gen.const("len", (0, codegen_1._)`${data}.length`);
    schArr.forEach((sch, i) => {
      if ((0, util_1.alwaysValidSchema)(it, sch)) return;
      gen.if((0, codegen_1._)`${len} > ${i}`, () =>
        cxt.subschema(
          {
            keyword,
            schemaProp: i,
            dataProp: i,
          },
          valid,
        ),
      );
      cxt.ok(valid);
    });
    function checkStrictTuple(sch) {
      const { opts, errSchemaPath } = it;
      const l = schArr.length;
      const fullTuple =
        l === sch.minItems && (l === sch.maxItems || sch[extraItems] === false);
      if (opts.strictTuples && !fullTuple) {
        const msg = `"${keyword}" is ${l}-tuple, but minItems or maxItems/${extraItems} are not specified or different at path "${errSchemaPath}"`;
        (0, util_1.checkStrictMode)(it, msg, opts.strictTuples);
      }
    }
  }
  exports.validateTuple = validateTuple;
  exports.default = def;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/prefixItems.js
var require_prefixItems = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const items_1 = require_items();
  exports.default = {
    keyword: "prefixItems",
    type: "array",
    schemaType: ["array"],
    before: "uniqueItems",
    code: (cxt) => (0, items_1.validateTuple)(cxt, "items"),
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/items2020.js
var require_items2020 = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const code_1 = require_code();
  const additionalItems_1 = require_additionalItems();
  exports.default = {
    keyword: "items",
    type: "array",
    schemaType: ["object", "boolean"],
    before: "uniqueItems",
    error: {
      message: ({ params: { len } }) =>
        (0, codegen_1.str)`must NOT have more than ${len} items`,
      params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`,
    },
    code(cxt) {
      const { schema, parentSchema, it } = cxt;
      const { prefixItems } = parentSchema;
      it.items = true;
      if ((0, util_1.alwaysValidSchema)(it, schema)) return;
      if (prefixItems)
        (0, additionalItems_1.validateAdditionalItems)(cxt, prefixItems);
      else cxt.ok((0, code_1.validateArray)(cxt));
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/contains.js
var require_contains = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  exports.default = {
    keyword: "contains",
    type: "array",
    schemaType: ["object", "boolean"],
    before: "uniqueItems",
    trackErrors: true,
    error: {
      message: ({ params: { min, max } }) =>
        max === void 0
          ? (0, codegen_1.str)`must contain at least ${min} valid item(s)`
          : (0,
            codegen_1.str)`must contain at least ${min} and no more than ${max} valid item(s)`,
      params: ({ params: { min, max } }) =>
        max === void 0
          ? (0, codegen_1._)`{minContains: ${min}}`
          : (0, codegen_1._)`{minContains: ${min}, maxContains: ${max}}`,
    },
    code(cxt) {
      const { gen, schema, parentSchema, data, it } = cxt;
      let min;
      let max;
      const { minContains, maxContains } = parentSchema;
      if (it.opts.next) {
        min = minContains === void 0 ? 1 : minContains;
        max = maxContains;
      } else min = 1;
      const len = gen.const("len", (0, codegen_1._)`${data}.length`);
      cxt.setParams({
        min,
        max,
      });
      if (max === void 0 && min === 0) {
        (0, util_1.checkStrictMode)(
          it,
          `"minContains" == 0 without "maxContains": "contains" keyword ignored`,
        );
        return;
      }
      if (max !== void 0 && min > max) {
        (0, util_1.checkStrictMode)(
          it,
          `"minContains" > "maxContains" is always invalid`,
        );
        cxt.fail();
        return;
      }
      if ((0, util_1.alwaysValidSchema)(it, schema)) {
        let cond = (0, codegen_1._)`${len} >= ${min}`;
        if (max !== void 0)
          cond = (0, codegen_1._)`${cond} && ${len} <= ${max}`;
        cxt.pass(cond);
        return;
      }
      it.items = true;
      const valid = gen.name("valid");
      if (max === void 0 && min === 1)
        validateItems(valid, () => gen.if(valid, () => gen.break()));
      else if (min === 0) {
        gen.let(valid, true);
        if (max !== void 0)
          gen.if((0, codegen_1._)`${data}.length > 0`, validateItemsWithCount);
      } else {
        gen.let(valid, false);
        validateItemsWithCount();
      }
      cxt.result(valid, () => cxt.reset());
      function validateItemsWithCount() {
        const schValid = gen.name("_valid");
        const count = gen.let("count", 0);
        validateItems(schValid, () =>
          gen.if(schValid, () => checkLimits(count)),
        );
      }
      function validateItems(_valid, block) {
        gen.forRange("i", 0, len, (i) => {
          cxt.subschema(
            {
              keyword: "contains",
              dataProp: i,
              dataPropType: util_1.Type.Num,
              compositeRule: true,
            },
            _valid,
          );
          block();
        });
      }
      function checkLimits(count) {
        gen.code((0, codegen_1._)`${count}++`);
        if (max === void 0)
          gen.if((0, codegen_1._)`${count} >= ${min}`, () =>
            gen.assign(valid, true).break(),
          );
        else {
          gen.if((0, codegen_1._)`${count} > ${max}`, () =>
            gen.assign(valid, false).break(),
          );
          if (min === 1) gen.assign(valid, true);
          else
            gen.if((0, codegen_1._)`${count} >= ${min}`, () =>
              gen.assign(valid, true),
            );
        }
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/dependencies.js
var require_dependencies = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.validateSchemaDeps =
    exports.validatePropertyDeps =
    exports.error =
      void 0;
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const code_1 = require_code();
  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}}`,
  };
  const def = {
    keyword: "dependencies",
    type: "object",
    schemaType: "object",
    error: exports.error,
    code(cxt) {
      const [propDeps, schDeps] = splitDependencies(cxt);
      validatePropertyDeps(cxt, propDeps);
      validateSchemaDeps(cxt, schDeps);
    },
  };
  function splitDependencies({ schema }) {
    const propertyDeps = {};
    const schemaDeps = {};
    for (const key in schema) {
      if (key === "__proto__") continue;
      const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps;
      deps[key] = schema[key];
    }
    return [propertyDeps, schemaDeps];
  }
  function validatePropertyDeps(cxt, propertyDeps = cxt.schema) {
    const { gen, data, it } = cxt;
    if (Object.keys(propertyDeps).length === 0) return;
    const missing = gen.let("missing");
    for (const prop in propertyDeps) {
      const deps = propertyDeps[prop];
      if (deps.length === 0) continue;
      const hasProperty = (0, code_1.propertyInData)(
        gen,
        data,
        prop,
        it.opts.ownProperties,
      );
      cxt.setParams({
        property: prop,
        depsCount: deps.length,
        deps: deps.join(", "),
      });
      if (it.allErrors)
        gen.if(hasProperty, () => {
          for (const depProp of deps)
            (0, code_1.checkReportMissingProp)(cxt, depProp);
        });
      else {
        gen.if(
          (0,
          codegen_1._)`${hasProperty} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`,
        );
        (0, code_1.reportMissingProp)(cxt, missing);
        gen.else();
      }
    }
  }
  exports.validatePropertyDeps = validatePropertyDeps;
  function validateSchemaDeps(cxt, schemaDeps = cxt.schema) {
    const { gen, data, keyword, it } = cxt;
    const valid = gen.name("valid");
    for (const prop in schemaDeps) {
      if ((0, util_1.alwaysValidSchema)(it, schemaDeps[prop])) continue;
      gen.if(
        (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties),
        () => {
          const schCxt = cxt.subschema(
            {
              keyword,
              schemaProp: prop,
            },
            valid,
          );
          cxt.mergeValidEvaluated(schCxt, valid);
        },
        () => gen.var(valid, true),
      );
      cxt.ok(valid);
    }
  }
  exports.validateSchemaDeps = validateSchemaDeps;
  exports.default = def;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/propertyNames.js
var require_propertyNames = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  exports.default = {
    keyword: "propertyNames",
    type: "object",
    schemaType: ["object", "boolean"],
    error: {
      message: "property name must be valid",
      params: ({ params }) =>
        (0, codegen_1._)`{propertyName: ${params.propertyName}}`,
    },
    code(cxt) {
      const { gen, schema, data, it } = cxt;
      if ((0, util_1.alwaysValidSchema)(it, schema)) return;
      const valid = gen.name("valid");
      gen.forIn("key", data, (key) => {
        cxt.setParams({ propertyName: key });
        cxt.subschema(
          {
            keyword: "propertyNames",
            data: key,
            dataTypes: ["string"],
            propertyName: key,
            compositeRule: true,
          },
          valid,
        );
        gen.if((0, codegen_1.not)(valid), () => {
          cxt.error(true);
          if (!it.allErrors) gen.break();
        });
      });
      cxt.ok(valid);
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js
var require_additionalProperties = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const code_1 = require_code();
  const codegen_1 = require_codegen();
  const names_1 = require_names();
  const util_1 = require_util();
  exports.default = {
    keyword: "additionalProperties",
    type: ["object"],
    schemaType: ["boolean", "object"],
    allowUndefined: true,
    trackErrors: true,
    error: {
      message: "must NOT have additional properties",
      params: ({ params }) =>
        (0, codegen_1._)`{additionalProperty: ${params.additionalProperty}}`,
    },
    code(cxt) {
      const { gen, schema, parentSchema, data, errsCount, it } = cxt;
      /* istanbul ignore if */
      if (!errsCount) throw new Error("ajv implementation error");
      const { allErrors, opts } = it;
      it.props = true;
      if (
        opts.removeAdditional !== "all" &&
        (0, util_1.alwaysValidSchema)(it, schema)
      )
        return;
      const props = (0, code_1.allSchemaProperties)(parentSchema.properties);
      const patProps = (0, code_1.allSchemaProperties)(
        parentSchema.patternProperties,
      );
      checkAdditionalProperties();
      cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
      function checkAdditionalProperties() {
        gen.forIn("key", data, (key) => {
          if (!props.length && !patProps.length) additionalPropertyCode(key);
          else gen.if(isAdditional(key), () => additionalPropertyCode(key));
        });
      }
      function isAdditional(key) {
        let definedProp;
        if (props.length > 8) {
          const propsSchema = (0, util_1.schemaRefOrVal)(
            it,
            parentSchema.properties,
            "properties",
          );
          definedProp = (0, code_1.isOwnProperty)(gen, propsSchema, key);
        } else if (props.length)
          definedProp = (0, codegen_1.or)(
            ...props.map((p) => (0, codegen_1._)`${key} === ${p}`),
          );
        else definedProp = codegen_1.nil;
        if (patProps.length)
          definedProp = (0, codegen_1.or)(
            definedProp,
            ...patProps.map(
              (p) =>
                (0,
                codegen_1._)`${(0, code_1.usePattern)(cxt, p)}.test(${key})`,
            ),
          );
        return (0, codegen_1.not)(definedProp);
      }
      function deleteAdditional(key) {
        gen.code((0, codegen_1._)`delete ${data}[${key}]`);
      }
      function additionalPropertyCode(key) {
        if (
          opts.removeAdditional === "all" ||
          (opts.removeAdditional && schema === false)
        ) {
          deleteAdditional(key);
          return;
        }
        if (schema === false) {
          cxt.setParams({ additionalProperty: key });
          cxt.error();
          if (!allErrors) gen.break();
          return;
        }
        if (
          typeof schema == "object" &&
          !(0, util_1.alwaysValidSchema)(it, schema)
        ) {
          const valid = gen.name("valid");
          if (opts.removeAdditional === "failing") {
            applyAdditionalSchema(key, valid, false);
            gen.if((0, codegen_1.not)(valid), () => {
              cxt.reset();
              deleteAdditional(key);
            });
          } else {
            applyAdditionalSchema(key, valid);
            if (!allErrors)
              gen.if((0, codegen_1.not)(valid), () => gen.break());
          }
        }
      }
      function applyAdditionalSchema(key, valid, errors) {
        const subschema = {
          keyword: "additionalProperties",
          dataProp: key,
          dataPropType: util_1.Type.Str,
        };
        if (errors === false)
          Object.assign(subschema, {
            compositeRule: true,
            createErrors: false,
            allErrors: false,
          });
        cxt.subschema(subschema, valid);
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/properties.js
var require_properties = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const validate_1 = require_validate();
  const code_1 = require_code();
  const util_1 = require_util();
  const additionalProperties_1 = require_additionalProperties();
  exports.default = {
    keyword: "properties",
    type: "object",
    schemaType: "object",
    code(cxt) {
      const { gen, schema, parentSchema, data, it } = cxt;
      if (
        it.opts.removeAdditional === "all" &&
        parentSchema.additionalProperties === void 0
      )
        additionalProperties_1.default.code(
          new validate_1.KeywordCxt(
            it,
            additionalProperties_1.default,
            "additionalProperties",
          ),
        );
      const allProps = (0, code_1.allSchemaProperties)(schema);
      for (const prop of allProps) it.definedProperties.add(prop);
      if (it.opts.unevaluated && allProps.length && it.props !== true)
        it.props = util_1.mergeEvaluated.props(
          gen,
          (0, util_1.toHash)(allProps),
          it.props,
        );
      const properties = allProps.filter(
        (p) => !(0, util_1.alwaysValidSchema)(it, schema[p]),
      );
      if (properties.length === 0) return;
      const valid = gen.name("valid");
      for (const prop of properties) {
        if (hasDefault(prop)) applyPropertySchema(prop);
        else {
          gen.if(
            (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties),
          );
          applyPropertySchema(prop);
          if (!it.allErrors) gen.else().var(valid, true);
          gen.endIf();
        }
        cxt.it.definedProperties.add(prop);
        cxt.ok(valid);
      }
      function hasDefault(prop) {
        return (
          it.opts.useDefaults &&
          !it.compositeRule &&
          schema[prop].default !== void 0
        );
      }
      function applyPropertySchema(prop) {
        cxt.subschema(
          {
            keyword: "properties",
            schemaProp: prop,
            dataProp: prop,
          },
          valid,
        );
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/patternProperties.js
var require_patternProperties = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const code_1 = require_code();
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const util_2 = require_util();
  exports.default = {
    keyword: "patternProperties",
    type: "object",
    schemaType: "object",
    code(cxt) {
      const { gen, schema, data, parentSchema, it } = cxt;
      const { opts } = it;
      const patterns = (0, code_1.allSchemaProperties)(schema);
      const alwaysValidPatterns = patterns.filter((p) =>
        (0, util_1.alwaysValidSchema)(it, schema[p]),
      );
      if (
        patterns.length === 0 ||
        (alwaysValidPatterns.length === patterns.length &&
          (!it.opts.unevaluated || it.props === true))
      )
        return;
      const checkProperties =
        opts.strictSchema &&
        !opts.allowMatchingProperties &&
        parentSchema.properties;
      const valid = gen.name("valid");
      if (it.props !== true && !(it.props instanceof codegen_1.Name))
        it.props = (0, util_2.evaluatedPropsToName)(gen, it.props);
      const { props } = it;
      validatePatternProperties();
      function validatePatternProperties() {
        for (const pat of patterns) {
          if (checkProperties) checkMatchingProperties(pat);
          if (it.allErrors) validateProperties(pat);
          else {
            gen.var(valid, true);
            validateProperties(pat);
            gen.if(valid);
          }
        }
      }
      function checkMatchingProperties(pat) {
        for (const prop in checkProperties)
          if (new RegExp(pat).test(prop))
            (0, util_1.checkStrictMode)(
              it,
              `property ${prop} matches pattern ${pat} (use allowMatchingProperties)`,
            );
      }
      function validateProperties(pat) {
        gen.forIn("key", data, (key) => {
          gen.if(
            (0, codegen_1._)`${(0, code_1.usePattern)(cxt, pat)}.test(${key})`,
            () => {
              const alwaysValid = alwaysValidPatterns.includes(pat);
              if (!alwaysValid)
                cxt.subschema(
                  {
                    keyword: "patternProperties",
                    schemaProp: pat,
                    dataProp: key,
                    dataPropType: util_2.Type.Str,
                  },
                  valid,
                );
              if (it.opts.unevaluated && props !== true)
                gen.assign((0, codegen_1._)`${props}[${key}]`, true);
              else if (!alwaysValid && !it.allErrors)
                gen.if((0, codegen_1.not)(valid), () => gen.break());
            },
          );
        });
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/not.js
var require_not = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const util_1 = require_util();
  exports.default = {
    keyword: "not",
    schemaType: ["object", "boolean"],
    trackErrors: true,
    code(cxt) {
      const { gen, schema, it } = cxt;
      if ((0, util_1.alwaysValidSchema)(it, schema)) {
        cxt.fail();
        return;
      }
      const valid = gen.name("valid");
      cxt.subschema(
        {
          keyword: "not",
          compositeRule: true,
          createErrors: false,
          allErrors: false,
        },
        valid,
      );
      cxt.failResult(
        valid,
        () => cxt.reset(),
        () => cxt.error(),
      );
    },
    error: { message: "must NOT be valid" },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/anyOf.js
var require_anyOf = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.default = {
    keyword: "anyOf",
    schemaType: "array",
    trackErrors: true,
    code: require_code().validateUnion,
    error: { message: "must match a schema in anyOf" },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/oneOf.js
var require_oneOf = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  exports.default = {
    keyword: "oneOf",
    schemaType: "array",
    trackErrors: true,
    error: {
      message: "must match exactly one schema in oneOf",
      params: ({ params }) =>
        (0, codegen_1._)`{passingSchemas: ${params.passing}}`,
    },
    code(cxt) {
      const { gen, schema, parentSchema, it } = cxt;
      /* istanbul ignore if */
      if (!Array.isArray(schema)) throw new Error("ajv implementation error");
      if (it.opts.discriminator && parentSchema.discriminator) return;
      const schArr = schema;
      const valid = gen.let("valid", false);
      const passing = gen.let("passing", null);
      const schValid = gen.name("_valid");
      cxt.setParams({ passing });
      gen.block(validateOneOf);
      cxt.result(
        valid,
        () => cxt.reset(),
        () => cxt.error(true),
      );
      function validateOneOf() {
        schArr.forEach((sch, i) => {
          let schCxt;
          if ((0, util_1.alwaysValidSchema)(it, sch)) gen.var(schValid, true);
          else
            schCxt = cxt.subschema(
              {
                keyword: "oneOf",
                schemaProp: i,
                compositeRule: true,
              },
              schValid,
            );
          if (i > 0)
            gen
              .if((0, codegen_1._)`${schValid} && ${valid}`)
              .assign(valid, false)
              .assign(passing, (0, codegen_1._)`[${passing}, ${i}]`)
              .else();
          gen.if(schValid, () => {
            gen.assign(valid, true);
            gen.assign(passing, i);
            if (schCxt) cxt.mergeEvaluated(schCxt, codegen_1.Name);
          });
        });
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/allOf.js
var require_allOf = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const util_1 = require_util();
  exports.default = {
    keyword: "allOf",
    schemaType: "array",
    code(cxt) {
      const { gen, schema, it } = cxt;
      /* istanbul ignore if */
      if (!Array.isArray(schema)) throw new Error("ajv implementation error");
      const valid = gen.name("valid");
      schema.forEach((sch, i) => {
        if ((0, util_1.alwaysValidSchema)(it, sch)) return;
        const schCxt = cxt.subschema(
          {
            keyword: "allOf",
            schemaProp: i,
          },
          valid,
        );
        cxt.ok(valid);
        cxt.mergeEvaluated(schCxt);
      });
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/if.js
var require_if = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const def = {
    keyword: "if",
    schemaType: ["object", "boolean"],
    trackErrors: true,
    error: {
      message: ({ params }) =>
        (0, codegen_1.str)`must match "${params.ifClause}" schema`,
      params: ({ params }) =>
        (0, codegen_1._)`{failingKeyword: ${params.ifClause}}`,
    },
    code(cxt) {
      const { gen, parentSchema, it } = cxt;
      if (parentSchema.then === void 0 && parentSchema.else === void 0)
        (0, util_1.checkStrictMode)(
          it,
          '"if" without "then" and "else" is ignored',
        );
      const hasThen = hasSchema(it, "then");
      const hasElse = hasSchema(it, "else");
      if (!hasThen && !hasElse) return;
      const valid = gen.let("valid", true);
      const schValid = gen.name("_valid");
      validateIf();
      cxt.reset();
      if (hasThen && hasElse) {
        const ifClause = gen.let("ifClause");
        cxt.setParams({ ifClause });
        gen.if(
          schValid,
          validateClause("then", ifClause),
          validateClause("else", ifClause),
        );
      } else if (hasThen) gen.if(schValid, validateClause("then"));
      else gen.if((0, codegen_1.not)(schValid), validateClause("else"));
      cxt.pass(valid, () => cxt.error(true));
      function validateIf() {
        const schCxt = cxt.subschema(
          {
            keyword: "if",
            compositeRule: true,
            createErrors: false,
            allErrors: false,
          },
          schValid,
        );
        cxt.mergeEvaluated(schCxt);
      }
      function validateClause(keyword, ifClause) {
        return () => {
          const schCxt = cxt.subschema({ keyword }, schValid);
          gen.assign(valid, schValid);
          cxt.mergeValidEvaluated(schCxt, valid);
          if (ifClause) gen.assign(ifClause, (0, codegen_1._)`${keyword}`);
          else cxt.setParams({ ifClause: keyword });
        };
      }
    },
  };
  function hasSchema(it, keyword) {
    const schema = it.schema[keyword];
    return schema !== void 0 && !(0, util_1.alwaysValidSchema)(it, schema);
  }
  exports.default = def;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/thenElse.js
var require_thenElse = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const util_1 = require_util();
  exports.default = {
    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`);
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/index.js
var require_applicator = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const additionalItems_1 = require_additionalItems();
  const prefixItems_1 = require_prefixItems();
  const items_1 = require_items();
  const items2020_1 = require_items2020();
  const contains_1 = require_contains();
  const dependencies_1 = require_dependencies();
  const propertyNames_1 = require_propertyNames();
  const additionalProperties_1 = require_additionalProperties();
  const properties_1 = require_properties();
  const patternProperties_1 = require_patternProperties();
  const not_1 = require_not();
  const anyOf_1 = require_anyOf();
  const oneOf_1 = require_oneOf();
  const allOf_1 = require_allOf();
  const if_1 = require_if();
  const thenElse_1 = require_thenElse();
  function getApplicator(draft2020 = false) {
    const applicator = [
      not_1.default,
      anyOf_1.default,
      oneOf_1.default,
      allOf_1.default,
      if_1.default,
      thenElse_1.default,
      propertyNames_1.default,
      additionalProperties_1.default,
      dependencies_1.default,
      properties_1.default,
      patternProperties_1.default,
    ];
    if (draft2020) applicator.push(prefixItems_1.default, items2020_1.default);
    else applicator.push(additionalItems_1.default, items_1.default);
    applicator.push(contains_1.default);
    return applicator;
  }
  exports.default = getApplicator;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/format/format.js
var require_format$1 = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  exports.default = {
    keyword: "format",
    type: ["number", "string"],
    schemaType: "string",
    $data: true,
    error: {
      message: ({ schemaCode }) =>
        (0, codegen_1.str)`must match format "${schemaCode}"`,
      params: ({ schemaCode }) => (0, codegen_1._)`{format: ${schemaCode}}`,
    },
    code(cxt, ruleType) {
      const { gen, data, $data, schema, schemaCode, it } = cxt;
      const { opts, errSchemaPath, schemaEnv, self } = it;
      if (!opts.validateFormats) return;
      if ($data) validate$DataFormat();
      else validateFormat();
      function validate$DataFormat() {
        const fmts = gen.scopeValue("formats", {
          ref: self.formats,
          code: opts.code.formats,
        });
        const fDef = gen.const(
          "fDef",
          (0, codegen_1._)`${fmts}[${schemaCode}]`,
        );
        const fType = gen.let("fType");
        const format = gen.let("format");
        gen.if(
          (0,
          codegen_1._)`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`,
          () =>
            gen
              .assign(fType, (0, codegen_1._)`${fDef}.type || "string"`)
              .assign(format, (0, codegen_1._)`${fDef}.validate`),
          () =>
            gen.assign(fType, (0, codegen_1._)`"string"`).assign(format, fDef),
        );
        cxt.fail$data((0, codegen_1.or)(unknownFmt(), invalidFmt()));
        function unknownFmt() {
          if (opts.strictSchema === false) return codegen_1.nil;
          return (0, codegen_1._)`${schemaCode} && !${format}`;
        }
        function invalidFmt() {
          const callFormat = schemaEnv.$async
            ? (0,
              codegen_1._)`(${fDef}.async ? await ${format}(${data}) : ${format}(${data}))`
            : (0, codegen_1._)`${format}(${data})`;
          const validData = (0,
          codegen_1._)`(typeof ${format} == "function" ? ${callFormat} : ${format}.test(${data}))`;
          return (0,
          codegen_1._)`${format} && ${format} !== true && ${fType} === ${ruleType} && !${validData}`;
        }
      }
      function validateFormat() {
        const formatDef = self.formats[schema];
        if (!formatDef) {
          unknownFormat();
          return;
        }
        if (formatDef === true) return;
        const [fmtType, format, fmtRef] = getFormat(formatDef);
        if (fmtType === ruleType) cxt.pass(validCondition());
        function unknownFormat() {
          if (opts.strictSchema === false) {
            self.logger.warn(unknownMsg());
            return;
          }
          throw new Error(unknownMsg());
          function unknownMsg() {
            return `unknown format "${schema}" ignored in schema at path "${errSchemaPath}"`;
          }
        }
        function getFormat(fmtDef) {
          const code =
            fmtDef instanceof RegExp
              ? (0, codegen_1.regexpCode)(fmtDef)
              : opts.code.formats
                ? (0,
                  codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(schema)}`
                : void 0;
          const fmt = gen.scopeValue("formats", {
            key: schema,
            ref: fmtDef,
            code,
          });
          if (typeof fmtDef == "object" && !(fmtDef instanceof RegExp))
            return [
              fmtDef.type || "string",
              fmtDef.validate,
              (0, codegen_1._)`${fmt}.validate`,
            ];
          return ["string", fmtDef, fmt];
        }
        function validCondition() {
          if (
            typeof formatDef == "object" &&
            !(formatDef instanceof RegExp) &&
            formatDef.async
          ) {
            if (!schemaEnv.$async)
              throw new Error("async format in sync schema");
            return (0, codegen_1._)`await ${fmtRef}(${data})`;
          }
          return typeof format == "function"
            ? (0, codegen_1._)`${fmtRef}(${data})`
            : (0, codegen_1._)`${fmtRef}.test(${data})`;
        }
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/format/index.js
var require_format = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.default = [require_format$1().default];
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/metadata.js
var require_metadata = /* @__PURE__ */ __commonJSMin((exports) => {
  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",
  ];
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/draft7.js
var require_draft7 = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const core_1 = require_core();
  const validation_1 = require_validation();
  const applicator_1 = require_applicator();
  const format_1 = require_format();
  const metadata_1 = require_metadata();
  exports.default = [
    core_1.default,
    validation_1.default,
    (0, applicator_1.default)(),
    format_1.default,
    metadata_1.metadataVocabulary,
    metadata_1.contentVocabulary,
  ];
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/discriminator/types.js
var require_types = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.DiscrError = void 0;
  var DiscrError;
  (function (DiscrError) {
    DiscrError["Tag"] = "tag";
    DiscrError["Mapping"] = "mapping";
  })(DiscrError || (exports.DiscrError = DiscrError = {}));
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/discriminator/index.js
var require_discriminator = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const types_1 = require_types();
  const compile_1 = require_compile();
  const ref_error_1 = require_ref_error();
  const util_1 = require_util();
  exports.default = {
    keyword: "discriminator",
    type: "object",
    schemaType: "object",
    error: {
      message: ({ params: { discrError, tagName } }) =>
        discrError === types_1.DiscrError.Tag
          ? `tag "${tagName}" must be string`
          : `value of tag "${tagName}" must be in oneOf`,
      params: ({ params: { discrError, tag, tagName } }) =>
        (0,
        codegen_1._)`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}`,
    },
    code(cxt) {
      const { gen, data, schema, parentSchema, it } = cxt;
      const { oneOf } = parentSchema;
      if (!it.opts.discriminator)
        throw new Error("discriminator: requires discriminator option");
      const tagName = schema.propertyName;
      if (typeof tagName != "string")
        throw new Error("discriminator: requires propertyName");
      if (schema.mapping)
        throw new Error("discriminator: mapping is not supported");
      if (!oneOf) throw new Error("discriminator: requires oneOf keyword");
      const valid = gen.let("valid", false);
      const tag = gen.const(
        "tag",
        (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(tagName)}`,
      );
      gen.if(
        (0, codegen_1._)`typeof ${tag} == "string"`,
        () => validateMapping(),
        () =>
          cxt.error(false, {
            discrError: types_1.DiscrError.Tag,
            tag,
            tagName,
          }),
      );
      cxt.ok(valid);
      function validateMapping() {
        const mapping = getMapping();
        gen.if(false);
        for (const tagValue in mapping) {
          gen.elseIf((0, codegen_1._)`${tag} === ${tagValue}`);
          gen.assign(valid, applyTagSchema(mapping[tagValue]));
        }
        gen.else();
        cxt.error(false, {
          discrError: types_1.DiscrError.Mapping,
          tag,
          tagName,
        });
        gen.endIf();
      }
      function applyTagSchema(schemaProp) {
        const _valid = gen.name("valid");
        const schCxt = cxt.subschema(
          {
            keyword: "oneOf",
            schemaProp,
          },
          _valid,
        );
        cxt.mergeEvaluated(schCxt, codegen_1.Name);
        return _valid;
      }
      function getMapping() {
        var _a;
        const oneOfMapping = {};
        const topRequired = hasRequired(parentSchema);
        let tagRequired = true;
        for (let i = 0; i < oneOf.length; i++) {
          let sch = oneOf[i];
          if (
            (sch === null || sch === void 0 ? void 0 : sch.$ref) &&
            !(0, util_1.schemaHasRulesButRef)(sch, it.self.RULES)
          ) {
            const ref = sch.$ref;
            sch = compile_1.resolveRef.call(
              it.self,
              it.schemaEnv.root,
              it.baseId,
              ref,
            );
            if (sch instanceof compile_1.SchemaEnv) sch = sch.schema;
            if (sch === void 0)
              throw new ref_error_1.default(
                it.opts.uriResolver,
                it.baseId,
                ref,
              );
          }
          const propSch =
            (_a = sch === null || sch === void 0 ? void 0 : sch.properties) ===
              null || _a === void 0
              ? void 0
              : _a[tagName];
          if (typeof propSch != "object")
            throw new Error(
              `discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`,
            );
          tagRequired = tagRequired && (topRequired || hasRequired(sch));
          addMappings(propSch, i);
        }
        if (!tagRequired)
          throw new Error(`discriminator: "${tagName}" must be required`);
        return oneOfMapping;
        function hasRequired({ required }) {
          return Array.isArray(required) && required.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;
        }
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/json-schema-draft-07.json
var require_json_schema_draft_07 = /* @__PURE__ */ __commonJSMin(
  (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,
    };
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/ajv.js
var require_ajv = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.MissingRefError =
    exports.ValidationError =
    exports.CodeGen =
    exports.Name =
    exports.nil =
    exports.stringify =
    exports.str =
    exports._ =
    exports.KeywordCxt =
    exports.Ajv =
      void 0;
  const core_1 = require_core$1();
  const draft7_1 = require_draft7();
  const discriminator_1 = require_discriminator();
  const draft7MetaSchema = require_json_schema_draft_07();
  const META_SUPPORT_DATA = ["/properties"];
  const META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
  var Ajv = class extends core_1.default {
    _addVocabularies() {
      super._addVocabularies();
      draft7_1.default.forEach((v) => this.addVocabulary(v));
      if (this.opts.discriminator) this.addKeyword(discriminator_1.default);
    }
    _addDefaultMetaSchema() {
      super._addDefaultMetaSchema();
      if (!this.opts.meta) return;
      const metaSchema = this.opts.$data
        ? this.$dataMetaSchema(draft7MetaSchema, META_SUPPORT_DATA)
        : draft7MetaSchema;
      this.addMetaSchema(metaSchema, META_SCHEMA_ID, false);
      this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
    }
    defaultMeta() {
      return (this.opts.defaultMeta =
        super.defaultMeta() ||
        (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0));
    }
  };
  exports.Ajv = Ajv;
  module.exports = exports = Ajv;
  module.exports.Ajv = Ajv;
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.default = Ajv;
  var validate_1 = require_validate();
  Object.defineProperty(exports, "KeywordCxt", {
    enumerable: true,
    get: function () {
      return validate_1.KeywordCxt;
    },
  });
  var codegen_1 = require_codegen();
  Object.defineProperty(exports, "_", {
    enumerable: true,
    get: function () {
      return codegen_1._;
    },
  });
  Object.defineProperty(exports, "str", {
    enumerable: true,
    get: function () {
      return codegen_1.str;
    },
  });
  Object.defineProperty(exports, "stringify", {
    enumerable: true,
    get: function () {
      return codegen_1.stringify;
    },
  });
  Object.defineProperty(exports, "nil", {
    enumerable: true,
    get: function () {
      return codegen_1.nil;
    },
  });
  Object.defineProperty(exports, "Name", {
    enumerable: true,
    get: function () {
      return codegen_1.Name;
    },
  });
  Object.defineProperty(exports, "CodeGen", {
    enumerable: true,
    get: function () {
      return codegen_1.CodeGen;
    },
  });
  var validation_error_1 = require_validation_error();
  Object.defineProperty(exports, "ValidationError", {
    enumerable: true,
    get: function () {
      return validation_error_1.default;
    },
  });
  var ref_error_1 = require_ref_error();
  Object.defineProperty(exports, "MissingRefError", {
    enumerable: true,
    get: function () {
      return ref_error_1.default;
    },
  });
});
//#endregion
//#region ../node_modules/.pnpm/ajv-formats@3.0.1_ajv@8.20.0/node_modules/ajv-formats/dist/formats.js
var require_formats = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.formatNames = exports.fastFormats = exports.fullFormats = void 0;
  function fmtDef(validate, compare) {
    return {
      validate,
      compare,
    };
  }
  exports.fullFormats = {
    date: fmtDef(date, compareDate),
    time: fmtDef(getTime(true), compareTime),
    "date-time": fmtDef(getDateTime(true), compareDateTime),
    "iso-time": fmtDef(getTime(), compareIsoTime),
    "iso-date-time": fmtDef(getDateTime(), compareIsoDateTime),
    duration:
      /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/,
    uri,
    "uri-reference":
      /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i,
    "uri-template":
      /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i,
    url: /^(?:https?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu,
    email:
      /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,
    hostname:
      /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i,
    ipv4: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/,
    ipv6: /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i,
    regex,
    uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,
    "json-pointer": /^(?:\/(?:[^~/]|~0|~1)*)*$/,
    "json-pointer-uri-fragment":
      /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i,
    "relative-json-pointer": /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/,
    byte,
    int32: {
      type: "number",
      validate: validateInt32,
    },
    int64: {
      type: "number",
      validate: validateInt64,
    },
    float: {
      type: "number",
      validate: validateNumber,
    },
    double: {
      type: "number",
      validate: validateNumber,
    },
    password: true,
    binary: true,
  };
  exports.fastFormats = {
    ...exports.fullFormats,
    date: fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d$/, compareDate),
    time: fmtDef(
      /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i,
      compareTime,
    ),
    "date-time": fmtDef(
      /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i,
      compareDateTime,
    ),
    "iso-time": fmtDef(
      /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i,
      compareIsoTime,
    ),
    "iso-date-time": fmtDef(
      /^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i,
      compareIsoDateTime,
    ),
    uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i,
    "uri-reference":
      /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i,
    email:
      /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i,
  };
  exports.formatNames = Object.keys(exports.fullFormats);
  function isLeapYear(year) {
    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
  }
  const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
  const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
  function date(str) {
    const matches = DATE.exec(str);
    if (!matches) return false;
    const year = +matches[1];
    const month = +matches[2];
    const day = +matches[3];
    return (
      month >= 1 &&
      month <= 12 &&
      day >= 1 &&
      day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month])
    );
  }
  function compareDate(d1, d2) {
    if (!(d1 && d2)) return void 0;
    if (d1 > d2) return 1;
    if (d1 < d2) return -1;
    return 0;
  }
  const TIME =
    /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
  function getTime(strictTimeZone) {
    return function time(str) {
      const matches = TIME.exec(str);
      if (!matches) return false;
      const hr = +matches[1];
      const min = +matches[2];
      const sec = +matches[3];
      const tz = matches[4];
      const tzSign = matches[5] === "-" ? -1 : 1;
      const tzH = +(matches[6] || 0);
      const tzM = +(matches[7] || 0);
      if (tzH > 23 || tzM > 59 || (strictTimeZone && !tz)) return false;
      if (hr <= 23 && min <= 59 && sec < 60) return true;
      const utcMin = min - tzM * tzSign;
      const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0);
      return (
        (utcHr === 23 || utcHr === -1) &&
        (utcMin === 59 || utcMin === -1) &&
        sec < 61
      );
    };
  }
  function compareTime(s1, s2) {
    if (!(s1 && s2)) return void 0;
    const t1 = /* @__PURE__ */ new Date("2020-01-01T" + s1).valueOf();
    const t2 = /* @__PURE__ */ new Date("2020-01-01T" + s2).valueOf();
    if (!(t1 && t2)) return void 0;
    return t1 - t2;
  }
  function compareIsoTime(t1, t2) {
    if (!(t1 && t2)) return void 0;
    const a1 = TIME.exec(t1);
    const a2 = TIME.exec(t2);
    if (!(a1 && a2)) return void 0;
    t1 = a1[1] + a1[2] + a1[3];
    t2 = a2[1] + a2[2] + a2[3];
    if (t1 > t2) return 1;
    if (t1 < t2) return -1;
    return 0;
  }
  const DATE_TIME_SEPARATOR = /t|\s/i;
  function getDateTime(strictTimeZone) {
    const time = getTime(strictTimeZone);
    return function date_time(str) {
      const dateTime = str.split(DATE_TIME_SEPARATOR);
      return dateTime.length === 2 && date(dateTime[0]) && time(dateTime[1]);
    };
  }
  function compareDateTime(dt1, dt2) {
    if (!(dt1 && dt2)) return void 0;
    const d1 = new Date(dt1).valueOf();
    const d2 = new Date(dt2).valueOf();
    if (!(d1 && d2)) return void 0;
    return d1 - d2;
  }
  function compareIsoDateTime(dt1, dt2) {
    if (!(dt1 && dt2)) return void 0;
    const [d1, t1] = dt1.split(DATE_TIME_SEPARATOR);
    const [d2, t2] = dt2.split(DATE_TIME_SEPARATOR);
    const res = compareDate(d1, d2);
    if (res === void 0) return void 0;
    return res || compareTime(t1, t2);
  }
  const NOT_URI_FRAGMENT = /\/|:/;
  const URI =
    /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
  function uri(str) {
    return NOT_URI_FRAGMENT.test(str) && URI.test(str);
  }
  const BYTE =
    /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm;
  function byte(str) {
    BYTE.lastIndex = 0;
    return BYTE.test(str);
  }
  const MIN_INT32 = -(2 ** 31);
  const MAX_INT32 = 2 ** 31 - 1;
  function validateInt32(value) {
    return Number.isInteger(value) && value <= MAX_INT32 && value >= MIN_INT32;
  }
  function validateInt64(value) {
    return Number.isInteger(value);
  }
  function validateNumber() {
    return true;
  }
  const Z_ANCHOR = /[^\\]\\Z/;
  function regex(str) {
    if (Z_ANCHOR.test(str)) return false;
    try {
      new RegExp(str);
      return true;
    } catch (e) {
      return false;
    }
  }
});
//#endregion
//#region ../node_modules/.pnpm/ajv-formats@3.0.1_ajv@8.20.0/node_modules/ajv-formats/dist/limit.js
var require_limit = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.formatLimitDefinition = void 0;
  const ajv_1 = require_ajv();
  const codegen_1 = require_codegen();
  const ops = codegen_1.operators;
  const KWDs = {
    formatMaximum: {
      okStr: "<=",
      ok: ops.LTE,
      fail: ops.GT,
    },
    formatMinimum: {
      okStr: ">=",
      ok: ops.GTE,
      fail: ops.LT,
    },
    formatExclusiveMaximum: {
      okStr: "<",
      ok: ops.LT,
      fail: ops.GTE,
    },
    formatExclusiveMinimum: {
      okStr: ">",
      ok: ops.GT,
      fail: ops.LTE,
    },
  };
  exports.formatLimitDefinition = {
    keyword: Object.keys(KWDs),
    type: "string",
    schemaType: "string",
    $data: true,
    error: {
      message: ({ keyword, schemaCode }) =>
        (0, codegen_1.str)`should be ${KWDs[keyword].okStr} ${schemaCode}`,
      params: ({ keyword, schemaCode }) =>
        (0,
        codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`,
    },
    code(cxt) {
      const { gen, data, schemaCode, keyword, it } = cxt;
      const { opts, self } = it;
      if (!opts.validateFormats) return;
      const fCxt = new ajv_1.KeywordCxt(
        it,
        self.RULES.all.format.definition,
        "format",
      );
      if (fCxt.$data) validate$DataFormat();
      else validateFormat();
      function validate$DataFormat() {
        const fmts = gen.scopeValue("formats", {
          ref: self.formats,
          code: opts.code.formats,
        });
        const fmt = gen.const(
          "fmt",
          (0, codegen_1._)`${fmts}[${fCxt.schemaCode}]`,
        );
        cxt.fail$data(
          (0, codegen_1.or)(
            (0, codegen_1._)`typeof ${fmt} != "object"`,
            (0, codegen_1._)`${fmt} instanceof RegExp`,
            (0, codegen_1._)`typeof ${fmt}.compare != "function"`,
            compareCode(fmt),
          ),
        );
      }
      function validateFormat() {
        const format = fCxt.schema;
        const fmtDef = self.formats[format];
        if (!fmtDef || fmtDef === true) return;
        if (
          typeof fmtDef != "object" ||
          fmtDef instanceof RegExp ||
          typeof fmtDef.compare != "function"
        )
          throw new Error(
            `"${keyword}": format "${format}" does not define "compare" function`,
          );
        const fmt = gen.scopeValue("formats", {
          key: format,
          ref: fmtDef,
          code: opts.code.formats
            ? (0,
              codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format)}`
            : void 0,
        });
        cxt.fail$data(compareCode(fmt));
      }
      function compareCode(fmt) {
        return (0,
        codegen_1._)`${fmt}.compare(${data}, ${schemaCode}) ${KWDs[keyword].fail} 0`;
      }
    },
    dependencies: ["format"],
  };
  const formatLimitPlugin = (ajv) => {
    ajv.addKeyword(exports.formatLimitDefinition);
    return ajv;
  };
  exports.default = formatLimitPlugin;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-formats@3.0.1_ajv@8.20.0/node_modules/ajv-formats/dist/index.js
var require_dist$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const formats_1 = require_formats();
  const limit_1 = require_limit();
  const codegen_1 = require_codegen();
  const fullName = new codegen_1.Name("fullFormats");
  const fastName = new codegen_1.Name("fastFormats");
  const formatsPlugin = (ajv, opts = { keywords: true }) => {
    if (Array.isArray(opts)) {
      addFormats(ajv, opts, formats_1.fullFormats, fullName);
      return ajv;
    }
    const [formats, exportName] =
      opts.mode === "fast"
        ? [formats_1.fastFormats, fastName]
        : [formats_1.fullFormats, fullName];
    addFormats(ajv, opts.formats || formats_1.formatNames, formats, exportName);
    if (opts.keywords) (0, limit_1.default)(ajv);
    return ajv;
  };
  formatsPlugin.get = (name, mode = "full") => {
    const f = (mode === "fast" ? formats_1.fastFormats : formats_1.fullFormats)[
      name
    ];
    if (!f) throw new Error(`Unknown format "${name}"`);
    return f;
  };
  function addFormats(ajv, list, fs, exportName) {
    var _a;
    var _b;
    ((_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0) ||
      (_b.formats = (0,
      codegen_1._)`require("ajv-formats/dist/formats").${exportName}`);
    for (const f of list) ajv.addFormat(f, fs[f]);
  }
  module.exports = exports = formatsPlugin;
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.default = formatsPlugin;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/typeof.js
var require_typeof$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const TYPES = [
    "undefined",
    "string",
    "number",
    "object",
    "function",
    "boolean",
    "symbol",
  ];
  function getDef() {
    return {
      keyword: "typeof",
      schemaType: ["string", "array"],
      code(cxt) {
        const { data, schema, schemaValue } = cxt;
        cxt.fail(
          typeof schema == "string"
            ? (0, codegen_1._)`typeof ${data} != ${schema}`
            : (0, codegen_1._)`${schemaValue}.indexOf(typeof ${data}) < 0`,
        );
      },
      metaSchema: {
        anyOf: [
          {
            type: "string",
            enum: TYPES,
          },
          {
            type: "array",
            items: {
              type: "string",
              enum: TYPES,
            },
          },
        ],
      },
    };
  }
  exports.default = getDef;
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/typeof.js
var require_typeof = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$22) => {
    var __importDefault =
      (this$22 && this$22.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const typeof_1 = __importDefault(require_typeof$1());
    const typeofPlugin = (ajv) => ajv.addKeyword((0, typeof_1.default)());
    exports.default = typeofPlugin;
    module.exports = typeofPlugin;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/instanceof.js
var require_instanceof$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const CONSTRUCTORS = {
    Object,
    Array,
    Function,
    Number,
    String,
    Date,
    RegExp,
  };
  /* istanbul ignore else */
  if (typeof Buffer != "undefined") CONSTRUCTORS.Buffer = Buffer;
  /* istanbul ignore else */
  if (typeof Promise != "undefined") CONSTRUCTORS.Promise = Promise;
  const getDef = Object.assign(_getDef, { CONSTRUCTORS });
  function _getDef() {
    return {
      keyword: "instanceof",
      schemaType: ["string", "array"],
      compile(schema) {
        if (typeof schema == "string") {
          const C = getConstructor(schema);
          return (data) => data instanceof C;
        }
        if (Array.isArray(schema)) {
          const constructors = schema.map(getConstructor);
          return (data) => {
            for (const C of constructors) if (data instanceof C) return true;
            return false;
          };
        }
        /* istanbul ignore next */
        throw new Error("ajv implementation error");
      },
      metaSchema: {
        anyOf: [
          { type: "string" },
          {
            type: "array",
            items: { type: "string" },
          },
        ],
      },
    };
  }
  function getConstructor(c) {
    const C = CONSTRUCTORS[c];
    if (C) return C;
    throw new Error(`invalid "instanceof" keyword value ${c}`);
  }
  exports.default = getDef;
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/instanceof.js
var require_instanceof = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$21) => {
    var __importDefault =
      (this$21 && this$21.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const instanceof_1 = __importDefault(require_instanceof$1());
    const instanceofPlugin = (ajv) =>
      ajv.addKeyword((0, instanceof_1.default)());
    exports.default = instanceofPlugin;
    module.exports = instanceofPlugin;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/_range.js
var require__range = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  function getRangeDef(keyword) {
    return () => ({
      keyword,
      type: "number",
      schemaType: "array",
      macro: function ([min, max]) {
        validateRangeSchema(min, max);
        return keyword === "range"
          ? {
              minimum: min,
              maximum: max,
            }
          : {
              exclusiveMinimum: min,
              exclusiveMaximum: max,
            };
      },
      metaSchema: {
        type: "array",
        minItems: 2,
        maxItems: 2,
        items: { type: "number" },
      },
    });
    function validateRangeSchema(min, max) {
      if (min > max || (keyword === "exclusiveRange" && min === max))
        throw new Error("There are no numbers in range");
    }
  }
  exports.default = getRangeDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/range.js
var require_range$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$20) => {
    var __importDefault =
      (this$20 && this$20.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const getDef = (0, __importDefault(require__range()).default)("range");
    exports.default = getDef;
    module.exports = getDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/range.js
var require_range = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$19) => {
    var __importDefault =
      (this$19 && this$19.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const range_1 = __importDefault(require_range$1());
    const range = (ajv) => ajv.addKeyword((0, range_1.default)());
    exports.default = range;
    module.exports = range;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/exclusiveRange.js
var require_exclusiveRange$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$18) => {
    var __importDefault =
      (this$18 && this$18.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const getDef = (0, __importDefault(require__range()).default)(
      "exclusiveRange",
    );
    exports.default = getDef;
    module.exports = getDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/exclusiveRange.js
var require_exclusiveRange = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$17) => {
    var __importDefault =
      (this$17 && this$17.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const exclusiveRange_1 = __importDefault(require_exclusiveRange$1());
    const exclusiveRange = (ajv) =>
      ajv.addKeyword((0, exclusiveRange_1.default)());
    exports.default = exclusiveRange;
    module.exports = exclusiveRange;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/_util.js
var require__util = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.usePattern = exports.metaSchemaRef = void 0;
  const codegen_1 = require_codegen();
  const META_SCHEMA_ID = "http://json-schema.org/schema";
  function metaSchemaRef({ defaultMeta } = {}) {
    return defaultMeta === false ? {} : { $ref: defaultMeta || META_SCHEMA_ID };
  }
  exports.metaSchemaRef = metaSchemaRef;
  function usePattern(
    { gen, it: { opts } },
    pattern,
    flags = opts.unicodeRegExp ? "u" : "",
  ) {
    const rx = new RegExp(pattern, flags);
    return gen.scopeValue("pattern", {
      key: rx.toString(),
      ref: rx,
      code: (0, codegen_1._)`new RegExp(${pattern}, ${flags})`,
    });
  }
  exports.usePattern = usePattern;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/regexp.js
var require_regexp$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const _util_1 = require__util();
  const regexpMetaSchema = {
    type: "object",
    properties: {
      pattern: { type: "string" },
      flags: {
        type: "string",
        nullable: true,
      },
    },
    required: ["pattern"],
    additionalProperties: false,
  };
  const metaRegexp = /^\/(.*)\/([gimuy]*)$/;
  function getDef() {
    return {
      keyword: "regexp",
      type: "string",
      schemaType: ["string", "object"],
      code(cxt) {
        const { data, schema } = cxt;
        const regx = getRegExp(schema);
        cxt.pass((0, codegen_1._)`${regx}.test(${data})`);
        function getRegExp(sch) {
          if (typeof sch == "object")
            return (0, _util_1.usePattern)(cxt, sch.pattern, sch.flags);
          const rx = metaRegexp.exec(sch);
          if (rx) return (0, _util_1.usePattern)(cxt, rx[1], rx[2]);
          throw new Error("cannot parse string into RegExp");
        }
      },
      metaSchema: { anyOf: [{ type: "string" }, regexpMetaSchema] },
    };
  }
  exports.default = getDef;
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/regexp.js
var require_regexp = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$16) => {
    var __importDefault =
      (this$16 && this$16.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const regexp_1 = __importDefault(require_regexp$1());
    const regexp = (ajv) => ajv.addKeyword((0, regexp_1.default)());
    exports.default = regexp;
    module.exports = regexp;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/transform.js
var require_transform$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const transform = {
    trimStart: (s) => s.trimStart(),
    trimEnd: (s) => s.trimEnd(),
    trimLeft: (s) => s.trimStart(),
    trimRight: (s) => s.trimEnd(),
    trim: (s) => s.trim(),
    toLowerCase: (s) => s.toLowerCase(),
    toUpperCase: (s) => s.toUpperCase(),
    toEnumCase: (s, cfg) =>
      (cfg === null || cfg === void 0 ? void 0 : cfg.hash[configKey(s)]) || s,
  };
  const getDef = Object.assign(_getDef, { transform });
  function _getDef() {
    return {
      keyword: "transform",
      schemaType: "array",
      before: "enum",
      code(cxt) {
        const { gen, data, schema, parentSchema, it } = cxt;
        const { parentData, parentDataProperty } = it;
        const tNames = schema;
        if (!tNames.length) return;
        let cfg;
        if (tNames.includes("toEnumCase")) {
          const config = getEnumCaseCfg(parentSchema);
          cfg = gen.scopeValue("obj", {
            ref: config,
            code: (0, codegen_1.stringify)(config),
          });
        }
        gen.if(
          (0,
          codegen_1._)`typeof ${data} == "string" && ${parentData} !== undefined`,
          () => {
            gen.assign(data, transformExpr(tNames.slice()));
            gen.assign(
              (0, codegen_1._)`${parentData}[${parentDataProperty}]`,
              data,
            );
          },
        );
        function transformExpr(ts) {
          if (!ts.length) return data;
          const t = ts.pop();
          if (!(t in transform))
            throw new Error(`transform: unknown transformation ${t}`);
          const func = gen.scopeValue("func", {
            ref: transform[t],
            code: (0,
            codegen_1._)`require("ajv-keywords/dist/definitions/transform").transform${(0, codegen_1.getProperty)(t)}`,
          });
          const arg = transformExpr(ts);
          return cfg && t === "toEnumCase"
            ? (0, codegen_1._)`${func}(${arg}, ${cfg})`
            : (0, codegen_1._)`${func}(${arg})`;
        }
      },
      metaSchema: {
        type: "array",
        items: {
          type: "string",
          enum: Object.keys(transform),
        },
      },
    };
  }
  function getEnumCaseCfg(parentSchema) {
    const cfg = { hash: {} };
    if (!parentSchema.enum)
      throw new Error('transform: "toEnumCase" requires "enum"');
    for (const v of parentSchema.enum) {
      if (typeof v !== "string") continue;
      const k = configKey(v);
      if (cfg.hash[k])
        throw new Error(
          'transform: "toEnumCase" requires all lowercased "enum" values to be unique',
        );
      cfg.hash[k] = v;
    }
    return cfg;
  }
  function configKey(s) {
    return s.toLowerCase();
  }
  exports.default = getDef;
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/transform.js
var require_transform = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$15) => {
    var __importDefault =
      (this$15 && this$15.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const transform_1 = __importDefault(require_transform$1());
    const transform = (ajv) => ajv.addKeyword((0, transform_1.default)());
    exports.default = transform;
    module.exports = transform;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/uniqueItemProperties.js
var require_uniqueItemProperties$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    Object.defineProperty(exports, "__esModule", { value: true });
    const equal = require_fast_deep_equal();
    const SCALAR_TYPES = ["number", "integer", "string", "boolean", "null"];
    function getDef() {
      return {
        keyword: "uniqueItemProperties",
        type: "array",
        schemaType: "array",
        compile(keys, parentSchema) {
          const scalar = getScalarKeys(keys, parentSchema);
          return (data) => {
            if (data.length <= 1) return true;
            for (let k = 0; k < keys.length; k++) {
              const key = keys[k];
              if (scalar[k]) {
                const hash = {};
                for (const x of data) {
                  if (!x || typeof x != "object") continue;
                  let p = x[key];
                  if (p && typeof p == "object") continue;
                  if (typeof p == "string") p = '"' + p;
                  if (hash[p]) return false;
                  hash[p] = true;
                }
              } else
                for (let i = data.length; i--;) {
                  const x = data[i];
                  if (!x || typeof x != "object") continue;
                  for (let j = i; j--;) {
                    const y = data[j];
                    if (y && typeof y == "object" && equal(x[key], y[key]))
                      return false;
                  }
                }
            }
            return true;
          };
        },
        metaSchema: {
          type: "array",
          items: { type: "string" },
        },
      };
    }
    exports.default = getDef;
    function getScalarKeys(keys, schema) {
      return keys.map((key) => {
        var _a, _b, _c;
        const t =
          (_c =
            (_b =
              (_a = schema.items) === null || _a === void 0
                ? void 0
                : _a.properties) === null || _b === void 0
              ? void 0
              : _b[key]) === null || _c === void 0
            ? void 0
            : _c.type;
        return Array.isArray(t)
          ? !t.includes("object") && !t.includes("array")
          : SCALAR_TYPES.includes(t);
      });
    }
    module.exports = getDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/uniqueItemProperties.js
var require_uniqueItemProperties = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$14) => {
    var __importDefault =
      (this$14 && this$14.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const uniqueItemProperties_1 = __importDefault(
      require_uniqueItemProperties$1(),
    );
    const uniqueItemProperties = (ajv) =>
      ajv.addKeyword((0, uniqueItemProperties_1.default)());
    exports.default = uniqueItemProperties;
    module.exports = uniqueItemProperties;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/allRequired.js
var require_allRequired$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  function getDef() {
    return {
      keyword: "allRequired",
      type: "object",
      schemaType: "boolean",
      macro(schema, parentSchema) {
        if (!schema) return true;
        const required = Object.keys(parentSchema.properties);
        if (required.length === 0) return true;
        return { required };
      },
      dependencies: ["properties"],
    };
  }
  exports.default = getDef;
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/allRequired.js
var require_allRequired = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$13) => {
    var __importDefault =
      (this$13 && this$13.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const allRequired_1 = __importDefault(require_allRequired$1());
    const allRequired = (ajv) => ajv.addKeyword((0, allRequired_1.default)());
    exports.default = allRequired;
    module.exports = allRequired;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/_required.js
var require__required = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  function getRequiredDef(keyword) {
    return () => ({
      keyword,
      type: "object",
      schemaType: "array",
      macro(schema) {
        if (schema.length === 0) return true;
        if (schema.length === 1) return { required: schema };
        return {
          [keyword === "anyRequired" ? "anyOf" : "oneOf"]: schema.map((p) => ({
            required: [p],
          })),
        };
      },
      metaSchema: {
        type: "array",
        items: { type: "string" },
      },
    });
  }
  exports.default = getRequiredDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/anyRequired.js
var require_anyRequired$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$12) => {
    var __importDefault =
      (this$12 && this$12.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const getDef = (0, __importDefault(require__required()).default)(
      "anyRequired",
    );
    exports.default = getDef;
    module.exports = getDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/anyRequired.js
var require_anyRequired = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$11) => {
    var __importDefault =
      (this$11 && this$11.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const anyRequired_1 = __importDefault(require_anyRequired$1());
    const anyRequired = (ajv) => ajv.addKeyword((0, anyRequired_1.default)());
    exports.default = anyRequired;
    module.exports = anyRequired;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/oneRequired.js
var require_oneRequired$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$10) => {
    var __importDefault =
      (this$10 && this$10.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const getDef = (0, __importDefault(require__required()).default)(
      "oneRequired",
    );
    exports.default = getDef;
    module.exports = getDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/oneRequired.js
var require_oneRequired = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$9) => {
    var __importDefault =
      (this$9 && this$9.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const oneRequired_1 = __importDefault(require_oneRequired$1());
    const oneRequired = (ajv) => ajv.addKeyword((0, oneRequired_1.default)());
    exports.default = oneRequired;
    module.exports = oneRequired;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/patternRequired.js
var require_patternRequired$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    Object.defineProperty(exports, "__esModule", { value: true });
    const codegen_1 = require_codegen();
    const _util_1 = require__util();
    const error = {
      message: ({ params: { missingPattern } }) =>
        (0,
        codegen_1.str)`should have property matching pattern '${missingPattern}'`,
      params: ({ params: { missingPattern } }) =>
        (0, codegen_1._)`{missingPattern: ${missingPattern}}`,
    };
    function getDef() {
      return {
        keyword: "patternRequired",
        type: "object",
        schemaType: "array",
        error,
        code(cxt) {
          const { gen, schema, data } = cxt;
          if (schema.length === 0) return;
          const valid = gen.let("valid", true);
          for (const pat of schema) validateProperties(pat);
          function validateProperties(pattern) {
            const matched = gen.let("matched", false);
            gen.forIn("key", data, (key) => {
              gen.assign(
                matched,
                (0,
                codegen_1._)`${(0, _util_1.usePattern)(cxt, pattern)}.test(${key})`,
              );
              gen.if(matched, () => gen.break());
            });
            cxt.setParams({ missingPattern: pattern });
            gen.assign(valid, (0, codegen_1.and)(valid, matched));
            cxt.pass(valid);
          }
        },
        metaSchema: {
          type: "array",
          items: {
            type: "string",
            format: "regex",
          },
          uniqueItems: true,
        },
      };
    }
    exports.default = getDef;
    module.exports = getDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/patternRequired.js
var require_patternRequired = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$8) => {
    var __importDefault =
      (this$8 && this$8.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const patternRequired_1 = __importDefault(require_patternRequired$1());
    const patternRequired = (ajv) =>
      ajv.addKeyword((0, patternRequired_1.default)());
    exports.default = patternRequired;
    module.exports = patternRequired;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/prohibited.js
var require_prohibited$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  function getDef() {
    return {
      keyword: "prohibited",
      type: "object",
      schemaType: "array",
      macro: function (schema) {
        if (schema.length === 0) return true;
        if (schema.length === 1) return { not: { required: schema } };
        return { not: { anyOf: schema.map((p) => ({ required: [p] })) } };
      },
      metaSchema: {
        type: "array",
        items: { type: "string" },
      },
    };
  }
  exports.default = getDef;
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/prohibited.js
var require_prohibited = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$7) => {
    var __importDefault =
      (this$7 && this$7.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const prohibited_1 = __importDefault(require_prohibited$1());
    const prohibited = (ajv) => ajv.addKeyword((0, prohibited_1.default)());
    exports.default = prohibited;
    module.exports = prohibited;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/deepProperties.js
var require_deepProperties$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    Object.defineProperty(exports, "__esModule", { value: true });
    const _util_1 = require__util();
    function getDef(opts) {
      return {
        keyword: "deepProperties",
        type: "object",
        schemaType: "object",
        macro: function (schema) {
          const allOf = [];
          for (const pointer in schema)
            allOf.push(getSchema(pointer, schema[pointer]));
          return { allOf };
        },
        metaSchema: {
          type: "object",
          propertyNames: {
            type: "string",
            format: "json-pointer",
          },
          additionalProperties: (0, _util_1.metaSchemaRef)(opts),
        },
      };
    }
    exports.default = getDef;
    function getSchema(jsonPointer, schema) {
      const segments = jsonPointer.split("/");
      const rootSchema = {};
      let pointerSchema = rootSchema;
      for (let i = 1; i < segments.length; i++) {
        let segment = segments[i];
        const isLast = i === segments.length - 1;
        segment = unescapeJsonPointer(segment);
        const properties = (pointerSchema.properties = {});
        let items;
        if (/[0-9]+/.test(segment)) {
          let count = +segment;
          items = pointerSchema.items = [];
          pointerSchema.type = ["object", "array"];
          while (count--) items.push({});
        } else pointerSchema.type = "object";
        pointerSchema = isLast ? schema : {};
        properties[segment] = pointerSchema;
        if (items) items.push(pointerSchema);
      }
      return rootSchema;
    }
    function unescapeJsonPointer(str) {
      return str.replace(/~1/g, "/").replace(/~0/g, "~");
    }
    module.exports = getDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/deepProperties.js
var require_deepProperties = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$6) => {
    var __importDefault =
      (this$6 && this$6.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const deepProperties_1 = __importDefault(require_deepProperties$1());
    const deepProperties = (ajv, opts) =>
      ajv.addKeyword((0, deepProperties_1.default)(opts));
    exports.default = deepProperties;
    module.exports = deepProperties;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/deepRequired.js
var require_deepRequired$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    Object.defineProperty(exports, "__esModule", { value: true });
    const codegen_1 = require_codegen();
    function getDef() {
      return {
        keyword: "deepRequired",
        type: "object",
        schemaType: "array",
        code(ctx) {
          const { schema, data } = ctx;
          const props = schema.map(
            (jp) => (0, codegen_1._)`(${getData(jp)}) === undefined`,
          );
          ctx.fail((0, codegen_1.or)(...props));
          function getData(jsonPointer) {
            if (jsonPointer === "")
              throw new Error("empty JSON pointer not allowed");
            const segments = jsonPointer.split("/");
            let x = data;
            const xs = segments.map((s, i) =>
              i
                ? (x = (0,
                  codegen_1._)`${x}${(0, codegen_1.getProperty)(unescapeJPSegment(s))}`)
                : x,
            );
            return (0, codegen_1.and)(...xs);
          }
        },
        metaSchema: {
          type: "array",
          items: {
            type: "string",
            format: "json-pointer",
          },
        },
      };
    }
    exports.default = getDef;
    function unescapeJPSegment(s) {
      return s.replace(/~1/g, "/").replace(/~0/g, "~");
    }
    module.exports = getDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/deepRequired.js
var require_deepRequired = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$5) => {
    var __importDefault =
      (this$5 && this$5.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const deepRequired_1 = __importDefault(require_deepRequired$1());
    const deepRequired = (ajv) => ajv.addKeyword((0, deepRequired_1.default)());
    exports.default = deepRequired;
    module.exports = deepRequired;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/dynamicDefaults.js
var require_dynamicDefaults$1 = /* @__PURE__ */ __commonJSMin(
  (exports, module) => {
    Object.defineProperty(exports, "__esModule", { value: true });
    const sequences = {};
    const DEFAULTS = {
      timestamp: () => () => Date.now(),
      datetime: () => () => /* @__PURE__ */ new Date().toISOString(),
      date: () => () => /* @__PURE__ */ new Date().toISOString().slice(0, 10),
      time: () => () => /* @__PURE__ */ new Date().toISOString().slice(11),
      random: () => () => Math.random(),
      randomint: (args) => {
        var _a;
        const max =
          (_a = args === null || args === void 0 ? void 0 : args.max) !==
            null && _a !== void 0
            ? _a
            : 2;
        return () => Math.floor(Math.random() * max);
      },
      seq: (args) => {
        var _a;
        const name =
          (_a = args === null || args === void 0 ? void 0 : args.name) !==
            null && _a !== void 0
            ? _a
            : "";
        sequences[name] || (sequences[name] = 0);
        return () => sequences[name]++;
      },
    };
    const getDef = Object.assign(_getDef, { DEFAULTS });
    function _getDef() {
      return {
        keyword: "dynamicDefaults",
        type: "object",
        schemaType: ["string", "object"],
        modifying: true,
        valid: true,
        compile(schema, _parentSchema, it) {
          if (!it.opts.useDefaults || it.compositeRule) return () => true;
          const fs = {};
          for (const key in schema) fs[key] = getDefault(schema[key]);
          const empty = it.opts.useDefaults === "empty";
          return (data) => {
            for (const prop in schema)
              if (
                data[prop] === void 0 ||
                (empty && (data[prop] === null || data[prop] === ""))
              )
                data[prop] = fs[prop]();
            return true;
          };
        },
        metaSchema: {
          type: "object",
          additionalProperties: {
            anyOf: [
              { type: "string" },
              {
                type: "object",
                additionalProperties: false,
                required: ["func", "args"],
                properties: {
                  func: { type: "string" },
                  args: { type: "object" },
                },
              },
            ],
          },
        },
      };
    }
    function getDefault(d) {
      return typeof d == "object" ? getObjDefault(d) : getStrDefault(d);
    }
    function getObjDefault({ func, args }) {
      const def = DEFAULTS[func];
      assertDefined(func, def);
      return def(args);
    }
    function getStrDefault(d = "") {
      const def = DEFAULTS[d];
      assertDefined(d, def);
      return def();
    }
    function assertDefined(name, def) {
      if (!def)
        throw new Error(
          `invalid "dynamicDefaults" keyword property value: ${name}`,
        );
    }
    exports.default = getDef;
    module.exports = getDef;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/dynamicDefaults.js
var require_dynamicDefaults = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$4) => {
    var __importDefault =
      (this$4 && this$4.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const dynamicDefaults_1 = __importDefault(require_dynamicDefaults$1());
    const dynamicDefaults = (ajv) =>
      ajv.addKeyword((0, dynamicDefaults_1.default)());
    exports.default = dynamicDefaults;
    module.exports = dynamicDefaults;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/select.js
var require_select$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const _util_1 = require__util();
  const error = {
    message: ({ params: { schemaProp } }) =>
      schemaProp
        ? (0, codegen_1.str)`should match case "${schemaProp}" schema`
        : (0, codegen_1.str)`should match default case schema`,
    params: ({ params: { schemaProp } }) =>
      schemaProp
        ? (0, codegen_1._)`{failingCase: ${schemaProp}}`
        : (0, codegen_1._)`{failingDefault: true}`,
  };
  function getDef(opts) {
    const metaSchema = (0, _util_1.metaSchemaRef)(opts);
    return [
      {
        keyword: "select",
        schemaType: ["string", "number", "boolean", "null"],
        $data: true,
        error,
        dependencies: ["selectCases"],
        code(cxt) {
          const { gen, schemaCode, parentSchema } = cxt;
          cxt.block$data(codegen_1.nil, () => {
            const valid = gen.let("valid", true);
            const schValid = gen.name("_valid");
            const value = gen.const(
              "value",
              (0, codegen_1._)`${schemaCode} === null ? "null" : ${schemaCode}`,
            );
            gen.if(false);
            for (const schemaProp in parentSchema.selectCases) {
              cxt.setParams({ schemaProp });
              gen.elseIf((0, codegen_1._)`"" + ${value} == ${schemaProp}`);
              const schCxt = cxt.subschema(
                {
                  keyword: "selectCases",
                  schemaProp,
                },
                schValid,
              );
              cxt.mergeEvaluated(schCxt, codegen_1.Name);
              gen.assign(valid, schValid);
            }
            gen.else();
            if (parentSchema.selectDefault !== void 0) {
              cxt.setParams({ schemaProp: void 0 });
              const schCxt = cxt.subschema(
                { keyword: "selectDefault" },
                schValid,
              );
              cxt.mergeEvaluated(schCxt, codegen_1.Name);
              gen.assign(valid, schValid);
            }
            gen.endIf();
            cxt.pass(valid);
          });
        },
      },
      {
        keyword: "selectCases",
        dependencies: ["select"],
        metaSchema: {
          type: "object",
          additionalProperties: metaSchema,
        },
      },
      {
        keyword: "selectDefault",
        dependencies: ["select", "selectCases"],
        metaSchema,
      },
    ];
  }
  exports.default = getDef;
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/select.js
var require_select = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$3) => {
    var __importDefault =
      (this$3 && this$3.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const select_1 = __importDefault(require_select$1());
    const select = (ajv, opts) => {
      (0, select_1.default)(opts).forEach((d) => ajv.addKeyword(d));
      return ajv;
    };
    exports.default = select;
    module.exports = select;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/index.js
var require_keywords = /* @__PURE__ */ __commonJSMin(
  (exports, module, this$2) => {
    var __importDefault =
      (this$2 && this$2.__importDefault) ||
      function (mod) {
        return mod && mod.__esModule ? mod : { default: mod };
      };
    Object.defineProperty(exports, "__esModule", { value: true });
    const typeof_1 = __importDefault(require_typeof());
    const instanceof_1 = __importDefault(require_instanceof());
    const range_1 = __importDefault(require_range());
    const exclusiveRange_1 = __importDefault(require_exclusiveRange());
    const regexp_1 = __importDefault(require_regexp());
    const transform_1 = __importDefault(require_transform());
    const uniqueItemProperties_1 = __importDefault(
      require_uniqueItemProperties(),
    );
    const allRequired_1 = __importDefault(require_allRequired());
    const anyRequired_1 = __importDefault(require_anyRequired());
    const oneRequired_1 = __importDefault(require_oneRequired());
    const patternRequired_1 = __importDefault(require_patternRequired());
    const prohibited_1 = __importDefault(require_prohibited());
    const deepProperties_1 = __importDefault(require_deepProperties());
    const deepRequired_1 = __importDefault(require_deepRequired());
    const dynamicDefaults_1 = __importDefault(require_dynamicDefaults());
    const select_1 = __importDefault(require_select());
    const ajvKeywords = {
      typeof: typeof_1.default,
      instanceof: instanceof_1.default,
      range: range_1.default,
      exclusiveRange: exclusiveRange_1.default,
      regexp: regexp_1.default,
      transform: transform_1.default,
      uniqueItemProperties: uniqueItemProperties_1.default,
      allRequired: allRequired_1.default,
      anyRequired: anyRequired_1.default,
      oneRequired: oneRequired_1.default,
      patternRequired: patternRequired_1.default,
      prohibited: prohibited_1.default,
      deepProperties: deepProperties_1.default,
      deepRequired: deepRequired_1.default,
      dynamicDefaults: dynamicDefaults_1.default,
      select: select_1.default,
    };
    exports.default = ajvKeywords;
    module.exports = ajvKeywords;
  },
);
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/index.js
var require_dist = /* @__PURE__ */ __commonJSMin((exports, module, this$1) => {
  var __importDefault =
    (this$1 && this$1.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const keywords_1 = __importDefault(require_keywords());
  const ajvKeywords = (ajv, keyword) => {
    if (Array.isArray(keyword)) {
      for (const k of keyword) get(k)(ajv);
      return ajv;
    }
    if (keyword) {
      get(keyword)(ajv);
      return ajv;
    }
    for (keyword in keywords_1.default) get(keyword)(ajv);
    return ajv;
  };
  ajvKeywords.get = get;
  function get(keyword) {
    const defFunc = keywords_1.default[keyword];
    if (!defFunc) throw new Error("Unknown keyword " + keyword);
    return defFunc;
  }
  exports.default = ajvKeywords;
  module.exports = ajvKeywords;
  module.exports.default = ajvKeywords;
});
//#endregion
//#region ../schemas/libraries/ajv/download/index.ts
var import_ajv = require_ajv();
var import_dist = /* @__PURE__ */ __toESM(require_dist$1(), 1);
var import_dist$1 = /* @__PURE__ */ __toESM(require_dist(), 1);
const ajv = new import_ajv.Ajv();
(0, import_dist.default)(ajv, { formats: ["url"] });
(0, import_dist$1.default)(ajv, ["instanceof"]);
const dateSchema = {
  type: "object",
  instanceof: "Date",
  required: [],
};
const imageSchema = {
  type: "object",
  properties: {
    id: { type: "number" },
    created: dateSchema,
    title: {
      type: "string",
      minLength: 1,
      maxLength: 100,
    },
    type: {
      type: "string",
      enum: ["jpg", "png"],
    },
    size: { type: "number" },
    url: {
      type: "string",
      format: "url",
    },
  },
  required: ["id", "created", "title", "type", "size", "url"],
};
const productSchema = {
  type: "object",
  properties: {
    id: { type: "number" },
    created: dateSchema,
    title: {
      type: "string",
      minLength: 1,
      maxLength: 100,
    },
    brand: {
      type: "string",
      minLength: 1,
      maxLength: 30,
    },
    description: {
      type: "string",
      minLength: 1,
      maxLength: 500,
    },
    price: {
      type: "number",
      minimum: 1,
      maximum: 1e4,
    },
    discount: {
      type: "number",
      minimum: 1,
      maximum: 100,
      nullable: true,
    },
    quantity: {
      type: "number",
      minimum: 0,
      maximum: 10,
    },
    tags: {
      type: "array",
      items: {
        type: "string",
        minLength: 1,
        maxLength: 30,
      },
    },
    images: {
      type: "array",
      items: imageSchema,
    },
    ratings: {
      type: "array",
      items: {
        type: "object",
        properties: {
          id: { type: "number" },
          stars: {
            type: "number",
            minimum: 1,
            maximum: 5,
          },
          title: {
            type: "string",
            minLength: 1,
            maxLength: 100,
          },
          text: {
            type: "string",
            minLength: 1,
            maxLength: 1e3,
          },
          images: {
            type: "array",
            items: imageSchema,
          },
        },
        required: ["id", "stars", "title", "text", "images"],
      },
    },
  },
  required: [
    "id",
    "created",
    "title",
    "brand",
    "description",
    "price",
    "discount",
    "quantity",
    "tags",
    "images",
    "ratings",
  ],
};
ajv.validate(productSchema, {});
//#endregion

//#region \0rolldown/runtime.js
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJSMin = (cb, mod) => () => (
  mod || (cb((mod = { exports: {} }).exports, mod, mod.exports), (cb = null)),
  mod.exports
);
var __copyProps = (to, from, except, desc) => {
  if ((from && typeof from === "object") || typeof from === "function")
    for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
      key = keys[i];
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, {
          get: ((k) => from[k]).bind(null, key),
          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
        });
    }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (
  (target = mod != null ? __create(__getProtoOf(mod)) : {}),
  __copyProps(
    isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default")
      ? __defProp(target, "default", {
          value: mod,
          enumerable: true,
        })
      : target,
    mod,
  )
);
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/code.js
var require_code$1 = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.regexpCode =
    exports.getEsmExportName =
    exports.getProperty =
    exports.safeStringify =
    exports.stringify =
    exports.strConcat =
    exports.addCodeArg =
    exports.str =
    exports._ =
    exports.nil =
    exports._Code =
    exports.Name =
    exports.IDENTIFIER =
    exports._CodeOrName =
      void 0;
  var _CodeOrName = class {};
  exports._CodeOrName = _CodeOrName;
  exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
  var Name = class extends _CodeOrName {
    constructor(s) {
      super();
      if (!exports.IDENTIFIER.test(s)) throw new Error("CodeGen: name must be a valid identifier");
      this.str = s;
    }
    toString() {
      return this.str;
    }
    emptyStr() {
      return false;
    }
    get names() {
      return { [this.str]: 1 };
    }
  };
  exports.Name = Name;
  var _Code = class extends _CodeOrName {
    constructor(code) {
      super();
      this._items = typeof code === "string" ? [code] : code;
    }
    toString() {
      return this.str;
    }
    emptyStr() {
      if (this._items.length > 1) return false;
      const item = this._items[0];
      return item === "" || item === '""';
    }
    get str() {
      var _a;
      return (_a = this._str) !== null && _a !== void 0
        ? _a
        : (this._str = this._items.reduce((s, c) => `${s}${c}`, ""));
    }
    get names() {
      var _a;
      return (_a = this._names) !== null && _a !== void 0
        ? _a
        : (this._names = this._items.reduce((names, c) => {
            if (c instanceof Name) names[c.str] = (names[c.str] || 0) + 1;
            return names;
          }, {}));
    }
  };
  exports._Code = _Code;
  exports.nil = new _Code("");
  function _(strs, ...args) {
    const code = [strs[0]];
    let i = 0;
    while (i < args.length) {
      addCodeArg(code, args[i]);
      code.push(strs[++i]);
    }
    return new _Code(code);
  }
  exports._ = _;
  const plus = new _Code("+");
  function str(strs, ...args) {
    const expr = [safeStringify(strs[0])];
    let i = 0;
    while (i < args.length) {
      expr.push(plus);
      addCodeArg(expr, args[i]);
      expr.push(plus, safeStringify(strs[++i]));
    }
    optimize(expr);
    return new _Code(expr);
  }
  exports.str = str;
  function addCodeArg(code, arg) {
    if (arg instanceof _Code) code.push(...arg._items);
    else if (arg instanceof Name) code.push(arg);
    else code.push(interpolate(arg));
  }
  exports.addCodeArg = addCodeArg;
  function optimize(expr) {
    let i = 1;
    while (i < expr.length - 1) {
      if (expr[i] === plus) {
        const res = mergeExprItems(expr[i - 1], expr[i + 1]);
        if (res !== void 0) {
          expr.splice(i - 1, 3, res);
          continue;
        }
        expr[i++] = "+";
      }
      i++;
    }
  }
  function mergeExprItems(a, b) {
    if (b === '""') return a;
    if (a === '""') return b;
    if (typeof a == "string") {
      if (b instanceof Name || a[a.length - 1] !== '"') return;
      if (typeof b != "string") return `${a.slice(0, -1)}${b}"`;
      if (b[0] === '"') return a.slice(0, -1) + b.slice(1);
      return;
    }
    if (typeof b == "string" && b[0] === '"' && !(a instanceof Name)) return `"${a}${b.slice(1)}`;
  }
  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;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/scope.js
var require_scope = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.ValueScope =
    exports.ValueScopeName =
    exports.Scope =
    exports.varKinds =
    exports.UsedValueState =
      void 0;
  const code_1 = require_code$1();
  var ValueError = class extends Error {
    constructor(name) {
      super(`CodeGen: "code" for ${name} not defined`);
      this.value = name.value;
    }
  };
  var UsedValueState;
  (function (UsedValueState) {
    UsedValueState[(UsedValueState["Started"] = 0)] = "Started";
    UsedValueState[(UsedValueState["Completed"] = 1)] = "Completed";
  })(UsedValueState || (exports.UsedValueState = UsedValueState = {}));
  exports.varKinds = {
    const: new code_1.Name("const"),
    let: new code_1.Name("let"),
    var: new code_1.Name("var"),
  };
  var Scope = class {
    constructor({ prefixes, parent } = {}) {
      this._names = {};
      this._prefixes = prefixes;
      this._parent = parent;
    }
    toName(nameOrPrefix) {
      return nameOrPrefix instanceof code_1.Name ? nameOrPrefix : this.name(nameOrPrefix);
    }
    name(prefix) {
      return new code_1.Name(this._newName(prefix));
    }
    _newName(prefix) {
      const ng = this._names[prefix] || this._nameGroup(prefix);
      return `${prefix}${ng.index++}`;
    }
    _nameGroup(prefix) {
      var _a, _b;
      if (
        ((_b = (_a = this._parent) === null || _a === void 0 ? void 0 : _a._prefixes) === null ||
        _b === void 0
          ? void 0
          : _b.has(prefix)) ||
        (this._prefixes && !this._prefixes.has(prefix))
      )
        throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`);
      return (this._names[prefix] = {
        prefix,
        index: 0,
      });
    }
  };
  exports.Scope = Scope;
  var ValueScopeName = class extends code_1.Name {
    constructor(prefix, nameStr) {
      super(nameStr);
      this.prefix = prefix;
    }
    setValue(value, { property, itemIndex }) {
      this.value = value;
      this.scopePath = (0, code_1._)`.${new code_1.Name(property)}[${itemIndex}]`;
    }
  };
  exports.ValueScopeName = ValueScopeName;
  const line = (0, code_1._)`\n`;
  var ValueScope = class extends Scope {
    constructor(opts) {
      super(opts);
      this._values = {};
      this._scope = opts.scope;
      this.opts = {
        ...opts,
        _n: opts.lines ? line : code_1.nil,
      };
    }
    get() {
      return this._scope;
    }
    name(prefix) {
      return new ValueScopeName(prefix, this._newName(prefix));
    }
    value(nameOrPrefix, value) {
      var _a;
      if (value.ref === void 0) throw new Error("CodeGen: ref must be passed in value");
      const name = this.toName(nameOrPrefix);
      const { prefix } = name;
      const valueKey = (_a = value.key) !== null && _a !== void 0 ? _a : value.ref;
      let vs = this._values[prefix];
      if (vs) {
        const _name = vs.get(valueKey);
        if (_name) return _name;
      } else vs = this._values[prefix] = /* @__PURE__ */ new Map();
      vs.set(valueKey, name);
      const s = this._scope[prefix] || (this._scope[prefix] = []);
      const itemIndex = s.length;
      s[itemIndex] = value.ref;
      name.setValue(value, {
        property: prefix,
        itemIndex,
      });
      return name;
    }
    getValue(prefix, keyOrRef) {
      const vs = this._values[prefix];
      if (!vs) return;
      return vs.get(keyOrRef);
    }
    scopeRefs(scopeName, values = this._values) {
      return this._reduceValues(values, (name) => {
        if (name.scopePath === void 0) throw new Error(`CodeGen: name "${name}" has no value`);
        return (0, code_1._)`${scopeName}${name.scopePath}`;
      });
    }
    scopeCode(values = this._values, usedValues, getCode) {
      return this._reduceValues(
        values,
        (name) => {
          if (name.value === void 0) throw new Error(`CodeGen: name "${name}" has no value`);
          return name.value.code;
        },
        usedValues,
        getCode,
      );
    }
    _reduceValues(values, valueCode, usedValues = {}, getCode) {
      let code = code_1.nil;
      for (const prefix in values) {
        const vs = values[prefix];
        if (!vs) continue;
        const nameSet = (usedValues[prefix] = usedValues[prefix] || /* @__PURE__ */ new Map());
        vs.forEach((name) => {
          if (nameSet.has(name)) return;
          nameSet.set(name, UsedValueState.Started);
          let c = valueCode(name);
          if (c) {
            const def = this.opts.es5 ? exports.varKinds.var : exports.varKinds.const;
            code = (0, code_1._)`${code}${def} ${name} = ${c};${this.opts._n}`;
          } else if ((c = getCode === null || getCode === void 0 ? void 0 : getCode(name)))
            code = (0, code_1._)`${code}${c}${this.opts._n}`;
          else throw new ValueError(name);
          nameSet.set(name, UsedValueState.Completed);
        });
      }
      return code;
    }
  };
  exports.ValueScope = ValueScope;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/index.js
var require_codegen = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.or =
    exports.and =
    exports.not =
    exports.CodeGen =
    exports.operators =
    exports.varKinds =
    exports.ValueScopeName =
    exports.ValueScope =
    exports.Scope =
    exports.Name =
    exports.regexpCode =
    exports.stringify =
    exports.getProperty =
    exports.nil =
    exports.strConcat =
    exports.str =
    exports._ =
      void 0;
  const code_1 = require_code$1();
  const scope_1 = require_scope();
  var code_2 = require_code$1();
  Object.defineProperty(exports, "_", {
    enumerable: true,
    get: function () {
      return code_2._;
    },
  });
  Object.defineProperty(exports, "str", {
    enumerable: true,
    get: function () {
      return code_2.str;
    },
  });
  Object.defineProperty(exports, "strConcat", {
    enumerable: true,
    get: function () {
      return code_2.strConcat;
    },
  });
  Object.defineProperty(exports, "nil", {
    enumerable: true,
    get: function () {
      return code_2.nil;
    },
  });
  Object.defineProperty(exports, "getProperty", {
    enumerable: true,
    get: function () {
      return code_2.getProperty;
    },
  });
  Object.defineProperty(exports, "stringify", {
    enumerable: true,
    get: function () {
      return code_2.stringify;
    },
  });
  Object.defineProperty(exports, "regexpCode", {
    enumerable: true,
    get: function () {
      return code_2.regexpCode;
    },
  });
  Object.defineProperty(exports, "Name", {
    enumerable: true,
    get: function () {
      return code_2.Name;
    },
  });
  var scope_2 = require_scope();
  Object.defineProperty(exports, "Scope", {
    enumerable: true,
    get: function () {
      return scope_2.Scope;
    },
  });
  Object.defineProperty(exports, "ValueScope", {
    enumerable: true,
    get: function () {
      return scope_2.ValueScope;
    },
  });
  Object.defineProperty(exports, "ValueScopeName", {
    enumerable: true,
    get: function () {
      return scope_2.ValueScopeName;
    },
  });
  Object.defineProperty(exports, "varKinds", {
    enumerable: true,
    get: function () {
      return scope_2.varKinds;
    },
  });
  exports.operators = {
    GT: new code_1._Code(">"),
    GTE: new code_1._Code(">="),
    LT: new code_1._Code("<"),
    LTE: new code_1._Code("<="),
    EQ: new code_1._Code("==="),
    NEQ: new code_1._Code("!=="),
    NOT: new code_1._Code("!"),
    OR: new code_1._Code("||"),
    AND: new code_1._Code("&&"),
    ADD: new code_1._Code("+"),
  };
  var Node = class {
    optimizeNodes() {
      return this;
    }
    optimizeNames(_names, _constants) {
      return this;
    }
  };
  var Def = class extends Node {
    constructor(varKind, name, rhs) {
      super();
      this.varKind = varKind;
      this.name = name;
      this.rhs = rhs;
    }
    render({ es5, _n }) {
      const varKind = es5 ? scope_1.varKinds.var : this.varKind;
      const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
      return `${varKind} ${this.name}${rhs};` + _n;
    }
    optimizeNames(names, 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() {
      return addExprNames(this.lhs instanceof code_1.Name ? {} : { ...this.lhs.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 }) {
      return `break${this.label ? ` ${this.label}` : ""};` + _n;
    }
  };
  var Throw = class extends Node {
    constructor(error) {
      super();
      this.error = error;
    }
    render({ _n }) {
      return `throw ${this.error};` + _n;
    }
    get names() {
      return this.error.names;
    }
  };
  var AnyCode = class extends Node {
    constructor(code) {
      super();
      this.code = code;
    }
    render({ _n }) {
      return `${this.code};` + _n;
    }
    optimizeNodes() {
      return `${this.code}` ? this : void 0;
    }
    optimizeNames(names, 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 _a;
      this.else =
        (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants);
      if (!(super.optimizeNames(names, constants) || this.else)) return;
      this.condition = optimizeExpr(this.condition, names, constants);
      return this;
    }
    get names() {
      const names = super.names;
      addExprNames(names, this.condition);
      if (this.else) addNames(names, this.else.names);
      return names;
    }
  };
  If.kind = "if";
  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() {
      return addExprNames(addExprNames(super.names, this.from), 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, args, async) {
      super();
      this.name = name;
      this.args = args;
      this.async = async;
    }
    render(opts) {
      return (
        `${this.async ? "async " : ""}function ${this.name}(${this.args})` + super.render(opts)
      );
    }
  };
  Func.kind = "func";
  var Return = class extends ParentNode {
    render(opts) {
      return "return " + super.render(opts);
    }
  };
  Return.kind = "return";
  var Try = class extends BlockNode {
    render(opts) {
      let code = "try" + super.render(opts);
      if (this.catch) code += this.catch.render(opts);
      if (this.finally) code += this.finally.render(opts);
      return code;
    }
    optimizeNodes() {
      var _a, _b;
      super.optimizeNodes();
      (_a = this.catch) === null || _a === void 0 || _a.optimizeNodes();
      (_b = this.finally) === null || _b === void 0 || _b.optimizeNodes();
      return this;
    }
    optimizeNames(names, constants) {
      var _a, _b;
      super.optimizeNames(names, constants);
      (_a = this.catch) === null || _a === void 0 || _a.optimizeNames(names, constants);
      (_b = this.finally) === null || _b === 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(error) {
      super();
      this.error = error;
    }
    render(opts) {
      return `catch(${this.error})` + super.render(opts);
    }
  };
  Catch.kind = "catch";
  var Finally = class extends BlockNode {
    render(opts) {
      return "finally" + super.render(opts);
    }
  };
  Finally.kind = "finally";
  var CodeGen = class {
    constructor(extScope, opts = {}) {
      this._values = {};
      this._blockStarts = [];
      this._constants = {};
      this.opts = {
        ...opts,
        _n: opts.lines ? "\n" : "",
      };
      this._extScope = extScope;
      this._scope = new scope_1.Scope({ parent: extScope });
      this._nodes = [new Root()];
    }
    toString() {
      return this._root.render(this.opts);
    }
    name(prefix) {
      return this._scope.name(prefix);
    }
    scopeName(prefix) {
      return this._extScope.name(prefix);
    }
    scopeValue(prefixOrName, value) {
      const name = this._extScope.value(prefixOrName, value);
      (this._values[name.prefix] || (this._values[name.prefix] = /* @__PURE__ */ new Set())).add(
        name,
      );
      return name;
    }
    getScopeValue(prefix, keyOrRef) {
      return this._extScope.getValue(prefix, keyOrRef);
    }
    scopeRefs(scopeName) {
      return this._extScope.scopeRefs(scopeName, this._values);
    }
    scopeCode() {
      return this._extScope.scopeCode(this._values);
    }
    _def(varKind, nameOrPrefix, rhs, constant) {
      const name = this._scope.toName(nameOrPrefix);
      if (rhs !== void 0 && constant) this._constants[name.str] = rhs;
      this._leafNode(new Def(varKind, name, rhs));
      return name;
    }
    const(nameOrPrefix, rhs, _constant) {
      return this._def(scope_1.varKinds.const, nameOrPrefix, rhs, _constant);
    }
    let(nameOrPrefix, rhs, _constant) {
      return this._def(scope_1.varKinds.let, nameOrPrefix, rhs, _constant);
    }
    var(nameOrPrefix, rhs, _constant) {
      return this._def(scope_1.varKinds.var, nameOrPrefix, rhs, _constant);
    }
    assign(lhs, rhs, sideEffects) {
      return this._leafNode(new Assign(lhs, rhs, sideEffects));
    }
    add(lhs, rhs) {
      return this._leafNode(new AssignOp(lhs, exports.operators.ADD, rhs));
    }
    code(c) {
      if (typeof c == "function") c();
      else if (c !== code_1.nil) this._leafNode(new AnyCode(c));
      return this;
    }
    object(...keyValues) {
      const code = ["{"];
      for (const [key, value] of keyValues) {
        if (code.length > 1) code.push(",");
        code.push(key);
        if (key !== value || this.opts.es5) {
          code.push(":");
          (0, code_1.addCodeArg)(code, value);
        }
      }
      code.push("}");
      return new code_1._Code(code);
    }
    if(condition, thenBody, elseBody) {
      this._blockNode(new If(condition));
      if (thenBody && elseBody) this.code(thenBody).else().code(elseBody).endIf();
      else if (thenBody) this.code(thenBody).endIf();
      else if (elseBody) throw new Error('CodeGen: "else" body without "then" body');
      return this;
    }
    elseIf(condition) {
      return this._elseNode(new If(condition));
    }
    else() {
      return this._elseNode(new Else());
    }
    endIf() {
      return this._endBlockNode(If, Else);
    }
    _for(node, forBody) {
      this._blockNode(node);
      if (forBody) this.code(forBody).endFor();
      return this;
    }
    for(iteration, forBody) {
      return this._for(new ForLoop(iteration), forBody);
    }
    forRange(
      nameOrPrefix,
      from,
      to,
      forBody,
      varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.let,
    ) {
      const name = this._scope.toName(nameOrPrefix);
      return this._for(new ForRange(varKind, name, from, to), () => forBody(name));
    }
    forOf(nameOrPrefix, iterable, forBody, varKind = scope_1.varKinds.const) {
      const name = this._scope.toName(nameOrPrefix);
      if (this.opts.es5) {
        const arr = iterable instanceof code_1.Name ? iterable : this.var("_arr", iterable);
        return this.forRange("_i", 0, (0, code_1._)`${arr}.length`, (i) => {
          this.var(name, (0, code_1._)`${arr}[${i}]`);
          forBody(name);
        });
      }
      return this._for(new ForIter("of", varKind, name, iterable), () => forBody(name));
    }
    forIn(
      nameOrPrefix,
      obj,
      forBody,
      varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.const,
    ) {
      if (this.opts.ownProperties)
        return this.forOf(nameOrPrefix, (0, code_1._)`Object.keys(${obj})`, forBody);
      const name = this._scope.toName(nameOrPrefix);
      return this._for(new ForIter("in", varKind, name, obj), () => forBody(name));
    }
    endFor() {
      return this._endBlockNode(For);
    }
    label(label) {
      return this._leafNode(new Label(label));
    }
    break(label) {
      return this._leafNode(new Break(label));
    }
    return(value) {
      const node = new Return();
      this._blockNode(node);
      this.code(value);
      if (node.nodes.length !== 1) throw new Error('CodeGen: "return" should have one node');
      return this._endBlockNode(Return);
    }
    try(tryBody, catchCode, finallyCode) {
      if (!catchCode && !finallyCode)
        throw new Error('CodeGen: "try" without "catch" and "finally"');
      const node = new Try();
      this._blockNode(node);
      this.code(tryBody);
      if (catchCode) {
        const error = this.name("e");
        this._currNode = node.catch = new Catch(error);
        catchCode(error);
      }
      if (finallyCode) {
        this._currNode = node.finally = new Finally();
        this.code(finallyCode);
      }
      return this._endBlockNode(Catch, Finally);
    }
    throw(error) {
      return this._leafNode(new Throw(error));
    }
    block(body, nodeCount) {
      this._blockStarts.push(this._nodes.length);
      if (body) this.code(body).endBlock(nodeCount);
      return this;
    }
    endBlock(nodeCount) {
      const len = this._blockStarts.pop();
      if (len === 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;
    }
    func(name, args = code_1.nil, async, funcBody) {
      this._blockNode(new Func(name, args, async));
      if (funcBody) this.code(funcBody).endFunc();
      return this;
    }
    endFunc() {
      return this._endBlockNode(Func);
    }
    optimize(n = 1) {
      while (n-- > 0) {
        this._root.optimizeNodes();
        this._root.optimizeNames(this._root.names, this._constants);
      }
    }
    _leafNode(node) {
      this._currNode.nodes.push(node);
      return this;
    }
    _blockNode(node) {
      this._currNode.nodes.push(node);
      this._nodes.push(node);
    }
    _endBlockNode(N1, N2) {
      const n = this._currNode;
      if (n instanceof N1 || (N2 && n instanceof N2)) {
        this._nodes.pop();
        return this;
      }
      throw new Error(`CodeGen: not in block "${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}"`);
    }
    _elseNode(node) {
      const n = this._currNode;
      if (!(n instanceof If)) throw new Error('CodeGen: "else" without "if"');
      this._currNode = n.else = node;
      return this;
    }
    get _root() {
      return this._nodes[0];
    }
    get _currNode() {
      const ns = this._nodes;
      return ns[ns.length - 1];
    }
    set _currNode(node) {
      const ns = this._nodes;
      ns[ns.length - 1] = node;
    }
  };
  exports.CodeGen = CodeGen;
  function addNames(names, from) {
    for (const n in from) names[n] = (names[n] || 0) + (from[n] || 0);
    return names;
  }
  function addExprNames(names, from) {
    return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
  }
  function optimizeExpr(expr, names, constants) {
    if (expr instanceof code_1.Name) return replaceName(expr);
    if (!canOptimize(expr)) return expr;
    return new code_1._Code(
      expr._items.reduce((items, c) => {
        if (c instanceof code_1.Name) c = replaceName(c);
        if (c instanceof code_1._Code) items.push(...c._items);
        else items.push(c);
        return items;
      }, []),
    );
    function replaceName(n) {
      const c = constants[n.str];
      if (c === 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;
  const andCode = mappend(exports.operators.AND);
  function and(...args) {
    return args.reduce(andCode);
  }
  exports.and = and;
  const orCode = mappend(exports.operators.OR);
  function or(...args) {
    return args.reduce(orCode);
  }
  exports.or = or;
  function mappend(op) {
    return (x, y) =>
      x === code_1.nil ? y : y === code_1.nil ? x : (0, code_1._)`${par(x)} ${op} ${par(y)}`;
  }
  function par(x) {
    return x instanceof code_1.Name ? x : (0, code_1._)`(${x})`;
  }
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/util.js
var require_util = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.checkStrictMode =
    exports.getErrorPath =
    exports.Type =
    exports.useFunc =
    exports.setEvaluated =
    exports.evaluatedPropsToName =
    exports.mergeEvaluated =
    exports.eachItem =
    exports.unescapeJsonPointer =
    exports.escapeJsonPointer =
    exports.escapeFragment =
    exports.unescapeFragment =
    exports.schemaRefOrVal =
    exports.schemaHasRulesButRef =
    exports.schemaHasRules =
    exports.checkUnknownRules =
    exports.alwaysValidSchema =
    exports.toHash =
      void 0;
  const codegen_1 = require_codegen();
  const code_1 = require_code$1();
  function toHash(arr) {
    const hash = {};
    for (const item of arr) hash[item] = true;
    return hash;
  }
  exports.toHash = toHash;
  function alwaysValidSchema(it, schema) {
    if (typeof schema == "boolean") return schema;
    if (Object.keys(schema).length === 0) return true;
    checkUnknownRules(it, schema);
    return !schemaHasRules(schema, it.self.RULES.all);
  }
  exports.alwaysValidSchema = alwaysValidSchema;
  function checkUnknownRules(it, schema = it.schema) {
    const { opts, self } = it;
    if (!opts.strictSchema) return;
    if (typeof schema === "boolean") return;
    const rules = self.RULES.keywords;
    for (const key in schema) if (!rules[key]) checkStrictMode(it, `unknown keyword: "${key}"`);
  }
  exports.checkUnknownRules = checkUnknownRules;
  function schemaHasRules(schema, rules) {
    if (typeof schema == "boolean") return !schema;
    for (const key in schema) if (rules[key]) return true;
    return false;
  }
  exports.schemaHasRules = schemaHasRules;
  function schemaHasRulesButRef(schema, RULES) {
    if (typeof schema == "boolean") return !schema;
    for (const key in schema) if (key !== "$ref" && RULES.all[key]) return true;
    return false;
  }
  exports.schemaHasRulesButRef = schemaHasRulesButRef;
  function schemaRefOrVal({ topSchemaRef, schemaPath }, schema, keyword, $data) {
    if (!$data) {
      if (typeof schema == "number" || typeof schema == "boolean") return schema;
      if (typeof schema == "string") return (0, codegen_1._)`${schema}`;
    }
    return (0, codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
  }
  exports.schemaRefOrVal = schemaRefOrVal;
  function unescapeFragment(str) {
    return unescapeJsonPointer(decodeURIComponent(str));
  }
  exports.unescapeFragment = unescapeFragment;
  function escapeFragment(str) {
    return encodeURIComponent(escapeJsonPointer(str));
  }
  exports.escapeFragment = escapeFragment;
  function escapeJsonPointer(str) {
    if (typeof str == "number") return `${str}`;
    return str.replace(/~/g, "~0").replace(/\//g, "~1");
  }
  exports.escapeJsonPointer = escapeJsonPointer;
  function unescapeJsonPointer(str) {
    return str.replace(/~1/g, "/").replace(/~0/g, "~");
  }
  exports.unescapeJsonPointer = unescapeJsonPointer;
  function eachItem(xs, f) {
    if (Array.isArray(xs)) for (const x of xs) f(x);
    else f(xs);
  }
  exports.eachItem = eachItem;
  function makeMergeEvaluated({ mergeNames, mergeToName, mergeValues, resultToName }) {
    return (gen, from, to, toName) => {
      const res =
        to === void 0
          ? from
          : to instanceof codegen_1.Name
            ? (from instanceof codegen_1.Name
                ? mergeNames(gen, from, to)
                : mergeToName(gen, from, to),
              to)
            : from instanceof codegen_1.Name
              ? (mergeToName(gen, to, from), from)
              : mergeValues(from, to);
      return toName === codegen_1.Name && !(res instanceof codegen_1.Name)
        ? resultToName(gen, res)
        : res;
    };
  }
  exports.mergeEvaluated = {
    props: makeMergeEvaluated({
      mergeNames: (gen, from, to) =>
        gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () => {
          gen.if(
            (0, codegen_1._)`${from} === true`,
            () => gen.assign(to, true),
            () =>
              gen
                .assign(to, (0, codegen_1._)`${to} || {}`)
                .code((0, codegen_1._)`Object.assign(${to}, ${from})`),
          );
        }),
      mergeToName: (gen, from, to) =>
        gen.if((0, codegen_1._)`${to} !== true`, () => {
          if (from === true) gen.assign(to, true);
          else {
            gen.assign(to, (0, codegen_1._)`${to} || {}`);
            setEvaluated(gen, to, from);
          }
        }),
      mergeValues: (from, to) =>
        from === true
          ? true
          : {
              ...from,
              ...to,
            },
      resultToName: evaluatedPropsToName,
    }),
    items: makeMergeEvaluated({
      mergeNames: (gen, from, to) =>
        gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () =>
          gen.assign(
            to,
            (0, codegen_1._)`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`,
          ),
        ),
      mergeToName: (gen, from, to) =>
        gen.if((0, codegen_1._)`${to} !== true`, () =>
          gen.assign(
            to,
            from === true ? true : (0, codegen_1._)`${to} > ${from} ? ${to} : ${from}`,
          ),
        ),
      mergeValues: (from, to) => (from === true ? true : Math.max(from, to)),
      resultToName: (gen, items) => gen.var("items", items),
    }),
  };
  function evaluatedPropsToName(gen, ps) {
    if (ps === true) return gen.var("props", true);
    const props = gen.var("props", (0, codegen_1._)`{}`);
    if (ps !== void 0) setEvaluated(gen, props, ps);
    return props;
  }
  exports.evaluatedPropsToName = evaluatedPropsToName;
  function setEvaluated(gen, props, ps) {
    Object.keys(ps).forEach((p) =>
      gen.assign((0, codegen_1._)`${props}${(0, codegen_1.getProperty)(p)}`, true),
    );
  }
  exports.setEvaluated = setEvaluated;
  const snippets = {};
  function useFunc(gen, f) {
    return gen.scopeValue("func", {
      ref: f,
      code: snippets[f.code] || (snippets[f.code] = new code_1._Code(f.code)),
    });
  }
  exports.useFunc = useFunc;
  var Type;
  (function (Type) {
    Type[(Type["Num"] = 0)] = "Num";
    Type[(Type["Str"] = 1)] = "Str";
  })(Type || (exports.Type = Type = {}));
  function getErrorPath(dataProp, dataPropType, jsPropertySyntax) {
    if (dataProp instanceof codegen_1.Name) {
      const isNumber = dataPropType === Type.Num;
      return jsPropertySyntax
        ? isNumber
          ? (0, codegen_1._)`"[" + ${dataProp} + "]"`
          : (0, codegen_1._)`"['" + ${dataProp} + "']"`
        : isNumber
          ? (0, codegen_1._)`"/" + ${dataProp}`
          : (0, codegen_1._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
    }
    return jsPropertySyntax
      ? (0, codegen_1.getProperty)(dataProp).toString()
      : "/" + escapeJsonPointer(dataProp);
  }
  exports.getErrorPath = getErrorPath;
  function checkStrictMode(it, msg, mode = it.opts.strictSchema) {
    if (!mode) return;
    msg = `strict mode: ${msg}`;
    if (mode === true) throw new Error(msg);
    it.self.logger.warn(msg);
  }
  exports.checkStrictMode = checkStrictMode;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/names.js
var require_names = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  exports.default = {
    data: new codegen_1.Name("data"),
    valCxt: new codegen_1.Name("valCxt"),
    instancePath: new codegen_1.Name("instancePath"),
    parentData: new codegen_1.Name("parentData"),
    parentDataProperty: new codegen_1.Name("parentDataProperty"),
    rootData: new codegen_1.Name("rootData"),
    dynamicAnchors: new codegen_1.Name("dynamicAnchors"),
    vErrors: new codegen_1.Name("vErrors"),
    errors: new codegen_1.Name("errors"),
    this: new codegen_1.Name("this"),
    self: new codegen_1.Name("self"),
    scope: new codegen_1.Name("scope"),
    json: new codegen_1.Name("json"),
    jsonPos: new codegen_1.Name("jsonPos"),
    jsonLen: new codegen_1.Name("jsonLen"),
    jsonPart: new codegen_1.Name("jsonPart"),
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/errors.js
var require_errors = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.extendErrors =
    exports.resetErrorsCount =
    exports.reportExtraError =
    exports.reportError =
    exports.keyword$DataError =
    exports.keywordError =
      void 0;
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const names_1 = require_names();
  exports.keywordError = {
    message: ({ keyword }) => (0, codegen_1.str)`must pass "${keyword}" keyword validation`,
  };
  exports.keyword$DataError = {
    message: ({ keyword, schemaType }) =>
      schemaType
        ? (0, codegen_1.str)`"${keyword}" keyword must be ${schemaType} ($data)`
        : (0, codegen_1.str)`"${keyword}" keyword is invalid ($data)`,
  };
  function reportError(cxt, error = exports.keywordError, errorPaths, overrideAllErrors) {
    const { it } = cxt;
    const { gen, compositeRule, allErrors } = it;
    const errObj = errorObjectCode(cxt, error, errorPaths);
    if (
      overrideAllErrors !== null && overrideAllErrors !== void 0
        ? overrideAllErrors
        : compositeRule || allErrors
    )
      addError(gen, errObj);
    else returnErrors(it, (0, codegen_1._)`[${errObj}]`);
  }
  exports.reportError = reportError;
  function reportExtraError(cxt, error = exports.keywordError, errorPaths) {
    const { it } = cxt;
    const { gen, compositeRule, allErrors } = it;
    addError(gen, errorObjectCode(cxt, error, errorPaths));
    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 }) {
    /* istanbul ignore if */
    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);
    }
  }
  const E = {
    keyword: new codegen_1.Name("keyword"),
    schemaPath: new codegen_1.Name("schemaPath"),
    params: new codegen_1.Name("params"),
    propertyName: new codegen_1.Name("propertyName"),
    message: new codegen_1.Name("message"),
    schema: new codegen_1.Name("schema"),
    parentSchema: new codegen_1.Name("parentSchema"),
  };
  function errorObjectCode(cxt, error, errorPaths) {
    const { createErrors } = cxt.it;
    if (createErrors === false) return (0, codegen_1._)`{}`;
    return errorObject(cxt, error, errorPaths);
  }
  function errorObject(cxt, error, errorPaths = {}) {
    const { gen, it } = cxt;
    const keyValues = [errorInstancePath(it, errorPaths), errorSchemaPath(cxt, errorPaths)];
    extraErrorProps(cxt, error, keyValues);
    return gen.object(...keyValues);
  }
  function errorInstancePath({ errorPath }, { instancePath }) {
    const instPath = instancePath
      ? (0, codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(instancePath, util_1.Type.Str)}`
      : errorPath;
    return [
      names_1.default.instancePath,
      (0, codegen_1.strConcat)(names_1.default.instancePath, instPath),
    ];
  }
  function errorSchemaPath({ keyword, it: { errSchemaPath } }, { schemaPath, parentSchema }) {
    let schPath = parentSchema ? errSchemaPath : (0, codegen_1.str)`${errSchemaPath}/${keyword}`;
    if (schemaPath)
      schPath = (0,
      codegen_1.str)`${schPath}${(0, util_1.getErrorPath)(schemaPath, util_1.Type.Str)}`;
    return [E.schemaPath, schPath];
  }
  function extraErrorProps(cxt, { params, message }, keyValues) {
    const { keyword, data, schemaValue, it } = cxt;
    const { opts, propertyName, topSchemaRef, schemaPath } = it;
    keyValues.push(
      [E.keyword, keyword],
      [E.params, typeof params == "function" ? params(cxt) : params || (0, codegen_1._)`{}`],
    );
    if (opts.messages)
      keyValues.push([E.message, typeof message == "function" ? message(cxt) : message]);
    if (opts.verbose)
      keyValues.push(
        [E.schema, schemaValue],
        [E.parentSchema, (0, codegen_1._)`${topSchemaRef}${schemaPath}`],
        [names_1.default.data, data],
      );
    if (propertyName) keyValues.push([E.propertyName, propertyName]);
  }
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/boolSchema.js
var require_boolSchema = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.boolOrEmptySchema = exports.topBoolOrEmptySchema = void 0;
  const errors_1 = require_errors();
  const codegen_1 = require_codegen();
  const names_1 = require_names();
  const boolError = { message: "boolean schema is false" };
  function topBoolOrEmptySchema(it) {
    const { gen, schema, validateName } = it;
    if (schema === false) falseSchemaError(it, false);
    else if (typeof schema == "object" && schema.$async === true) gen.return(names_1.default.data);
    else {
      gen.assign((0, codegen_1._)`${validateName}.errors`, null);
      gen.return(true);
    }
  }
  exports.topBoolOrEmptySchema = topBoolOrEmptySchema;
  function boolOrEmptySchema(it, valid) {
    const { gen, schema } = it;
    if (schema === false) {
      gen.var(valid, false);
      falseSchemaError(it);
    } else gen.var(valid, true);
  }
  exports.boolOrEmptySchema = boolOrEmptySchema;
  function falseSchemaError(it, overrideAllErrors) {
    const { gen, data } = it;
    const cxt = {
      gen,
      keyword: "false schema",
      data,
      schema: false,
      schemaCode: false,
      schemaValue: false,
      params: {},
      it,
    };
    (0, errors_1.reportError)(cxt, boolError, void 0, overrideAllErrors);
  }
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/rules.js
var require_rules = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.getRules = exports.isJSONType = void 0;
  const jsonTypes = /* @__PURE__ */ new Set([
    "string",
    "number",
    "integer",
    "boolean",
    "null",
    "object",
    "array",
  ]);
  function isJSONType(x) {
    return typeof x == "string" && jsonTypes.has(x);
  }
  exports.isJSONType = isJSONType;
  function getRules() {
    const groups = {
      number: {
        type: "number",
        rules: [],
      },
      string: {
        type: "string",
        rules: [],
      },
      array: {
        type: "array",
        rules: [],
      },
      object: {
        type: "object",
        rules: [],
      },
    };
    return {
      types: {
        ...groups,
        integer: true,
        boolean: true,
        null: true,
      },
      rules: [{ rules: [] }, groups.number, groups.string, groups.array, groups.object],
      post: { rules: [] },
      all: {},
      keywords: {},
    };
  }
  exports.getRules = getRules;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/applicability.js
var require_applicability = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.shouldUseRule = exports.shouldUseGroup = exports.schemaHasRulesForType = void 0;
  function schemaHasRulesForType({ schema, self }, type) {
    const group = self.RULES.types[type];
    return group && group !== true && shouldUseGroup(schema, group);
  }
  exports.schemaHasRulesForType = schemaHasRulesForType;
  function shouldUseGroup(schema, group) {
    return group.rules.some((rule) => shouldUseRule(schema, rule));
  }
  exports.shouldUseGroup = shouldUseGroup;
  function shouldUseRule(schema, rule) {
    var _a;
    return (
      schema[rule.keyword] !== void 0 ||
      ((_a = rule.definition.implements) === null || _a === void 0
        ? void 0
        : _a.some((kwd) => schema[kwd] !== void 0))
    );
  }
  exports.shouldUseRule = shouldUseRule;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/dataType.js
var require_dataType = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.reportTypeError =
    exports.checkDataTypes =
    exports.checkDataType =
    exports.coerceAndCheckDataType =
    exports.getJSONTypes =
    exports.getSchemaTypes =
    exports.DataType =
      void 0;
  const rules_1 = require_rules();
  const applicability_1 = require_applicability();
  const errors_1 = require_errors();
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  var DataType;
  (function (DataType) {
    DataType[(DataType["Correct"] = 0)] = "Correct";
    DataType[(DataType["Wrong"] = 1)] = "Wrong";
  })(DataType || (exports.DataType = DataType = {}));
  function getSchemaTypes(schema) {
    const types = getJSONTypes(schema.type);
    if (types.includes("null")) {
      if (schema.nullable === false) throw new Error("type: null contradicts nullable: false");
    } else {
      if (!types.length && schema.nullable !== void 0)
        throw new Error('"nullable" cannot be used without "type"');
      if (schema.nullable === true) types.push("null");
    }
    return types;
  }
  exports.getSchemaTypes = getSchemaTypes;
  function getJSONTypes(ts) {
    const types = Array.isArray(ts) ? ts : ts ? [ts] : [];
    if (types.every(rules_1.isJSONType)) return types;
    throw new Error("type must be JSONType or JSONType[]: " + types.join(","));
  }
  exports.getJSONTypes = getJSONTypes;
  function coerceAndCheckDataType(it, types) {
    const { gen, data, opts } = it;
    const coerceTo = coerceToTypes(types, opts.coerceTypes);
    const checkTypes =
      types.length > 0 &&
      !(
        coerceTo.length === 0 &&
        types.length === 1 &&
        (0, applicability_1.schemaHasRulesForType)(it, types[0])
      );
    if (checkTypes) {
      const wrongType = checkDataTypes(types, data, opts.strictNumbers, DataType.Wrong);
      gen.if(wrongType, () => {
        if (coerceTo.length) coerceData(it, types, coerceTo);
        else reportTypeError(it);
      });
    }
    return checkTypes;
  }
  exports.coerceAndCheckDataType = coerceAndCheckDataType;
  const 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;
  const typeError = {
    message: ({ schema }) => `must be ${schema}`,
    params: ({ schema, schemaValue }) =>
      typeof schema == "string"
        ? (0, codegen_1._)`{type: ${schema}}`
        : (0, codegen_1._)`{type: ${schemaValue}}`,
  };
  function reportTypeError(it) {
    const cxt = getTypeErrorContext(it);
    (0, errors_1.reportError)(cxt, typeError);
  }
  exports.reportTypeError = reportTypeError;
  function getTypeErrorContext(it) {
    const { gen, data, schema } = it;
    const schemaCode = (0, util_1.schemaRefOrVal)(it, schema, "type");
    return {
      gen,
      keyword: "type",
      data,
      schema: schema.type,
      schemaCode,
      schemaValue: schemaCode,
      parentSchema: schema,
      params: {},
      it,
    };
  }
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/defaults.js
var require_defaults = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.assignDefaults = void 0;
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  function assignDefaults(it, ty) {
    const { properties, items } = it.schema;
    if (ty === "object" && properties)
      for (const key in properties) assignDefault(it, key, properties[key].default);
    else if (ty === "array" && Array.isArray(items))
      items.forEach((sch, i) => assignDefault(it, i, sch.default));
  }
  exports.assignDefaults = assignDefaults;
  function assignDefault(it, prop, defaultValue) {
    const { gen, compositeRule, data, opts } = it;
    if (defaultValue === void 0) return;
    const childData = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(prop)}`;
    if (compositeRule) {
      (0, util_1.checkStrictMode)(it, `default is ignored for: ${childData}`);
      return;
    }
    let condition = (0, codegen_1._)`${childData} === undefined`;
    if (opts.useDefaults === "empty")
      condition = (0, codegen_1._)`${condition} || ${childData} === null || ${childData} === ""`;
    gen.if(condition, (0, codegen_1._)`${childData} = ${(0, codegen_1.stringify)(defaultValue)}`);
  }
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/code.js
var require_code = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.validateUnion =
    exports.validateArray =
    exports.usePattern =
    exports.callValidateCode =
    exports.schemaProperties =
    exports.allSchemaProperties =
    exports.noPropertyInData =
    exports.propertyInData =
    exports.isOwnProperty =
    exports.hasPropFunc =
    exports.reportMissingProp =
    exports.checkMissingProp =
    exports.checkReportMissingProp =
      void 0;
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const names_1 = require_names();
  const util_2 = require_util();
  function checkReportMissingProp(cxt, prop) {
    const { gen, data, it } = cxt;
    gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => {
      cxt.setParams({ missingProperty: (0, codegen_1._)`${prop}` }, true);
      cxt.error();
    });
  }
  exports.checkReportMissingProp = checkReportMissingProp;
  function checkMissingProp({ gen, data, it: { opts } }, properties, missing) {
    return (0, codegen_1.or)(
      ...properties.map((prop) =>
        (0, codegen_1.and)(
          noPropertyInData(gen, data, prop, opts.ownProperties),
          (0, codegen_1._)`${missing} = ${prop}`,
        ),
      ),
    );
  }
  exports.checkMissingProp = checkMissingProp;
  function reportMissingProp(cxt, missing) {
    cxt.setParams({ missingProperty: missing }, true);
    cxt.error();
  }
  exports.reportMissingProp = reportMissingProp;
  function hasPropFunc(gen) {
    return gen.scopeValue("func", {
      ref: Object.prototype.hasOwnProperty,
      code: (0, codegen_1._)`Object.prototype.hasOwnProperty`,
    });
  }
  exports.hasPropFunc = hasPropFunc;
  function isOwnProperty(gen, data, property) {
    return (0, codegen_1._)`${hasPropFunc(gen)}.call(${data}, ${property})`;
  }
  exports.isOwnProperty = isOwnProperty;
  function propertyInData(gen, data, property, ownProperties) {
    const cond = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} !== undefined`;
    return ownProperties
      ? (0, codegen_1._)`${cond} && ${isOwnProperty(gen, data, property)}`
      : cond;
  }
  exports.propertyInData = propertyInData;
  function noPropertyInData(gen, data, property, ownProperties) {
    const cond = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} === undefined`;
    return ownProperties
      ? (0, codegen_1.or)(cond, (0, codegen_1.not)(isOwnProperty(gen, data, property)))
      : cond;
  }
  exports.noPropertyInData = noPropertyInData;
  function allSchemaProperties(schemaMap) {
    return schemaMap ? Object.keys(schemaMap).filter((p) => p !== "__proto__") : [];
  }
  exports.allSchemaProperties = allSchemaProperties;
  function schemaProperties(it, schemaMap) {
    return allSchemaProperties(schemaMap).filter(
      (p) => !(0, util_1.alwaysValidSchema)(it, schemaMap[p]),
    );
  }
  exports.schemaProperties = schemaProperties;
  function callValidateCode(
    { schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it },
    func,
    context,
    passSchema,
  ) {
    const dataAndSchema = passSchema
      ? (0, codegen_1._)`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}`
      : data;
    const valCxt = [
      [
        names_1.default.instancePath,
        (0, codegen_1.strConcat)(names_1.default.instancePath, errorPath),
      ],
      [names_1.default.parentData, it.parentData],
      [names_1.default.parentDataProperty, it.parentDataProperty],
      [names_1.default.rootData, names_1.default.rootData],
    ];
    if (it.opts.dynamicRef)
      valCxt.push([names_1.default.dynamicAnchors, names_1.default.dynamicAnchors]);
    const args = (0, codegen_1._)`${dataAndSchema}, ${gen.object(...valCxt)}`;
    return context !== codegen_1.nil
      ? (0, codegen_1._)`${func}.call(${context}, ${args})`
      : (0, codegen_1._)`${func}(${args})`;
  }
  exports.callValidateCode = callValidateCode;
  const newRegExp = (0, codegen_1._)`new RegExp`;
  function usePattern({ gen, it: { opts } }, pattern) {
    const u = opts.unicodeRegExp ? "u" : "";
    const { regExp } = opts.code;
    const rx = regExp(pattern, u);
    return gen.scopeValue("pattern", {
      key: rx.toString(),
      ref: rx,
      code: (0,
      codegen_1._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern}, ${u})`,
    });
  }
  exports.usePattern = usePattern;
  function validateArray(cxt) {
    const { gen, data, keyword, it } = cxt;
    const valid = gen.name("valid");
    if (it.allErrors) {
      const validArr = gen.let("valid", true);
      validateItems(() => gen.assign(validArr, false));
      return validArr;
    }
    gen.var(valid, true);
    validateItems(() => gen.break());
    return valid;
    function validateItems(notValid) {
      const len = gen.const("len", (0, codegen_1._)`${data}.length`);
      gen.forRange("i", 0, len, (i) => {
        cxt.subschema(
          {
            keyword,
            dataProp: i,
            dataPropType: util_1.Type.Num,
          },
          valid,
        );
        gen.if((0, codegen_1.not)(valid), notValid);
      });
    }
  }
  exports.validateArray = validateArray;
  function validateUnion(cxt) {
    const { gen, schema, keyword, it } = cxt;
    /* istanbul ignore if */
    if (!Array.isArray(schema)) throw new Error("ajv implementation error");
    if (schema.some((sch) => (0, util_1.alwaysValidSchema)(it, sch)) && !it.opts.unevaluated)
      return;
    const valid = gen.let("valid", false);
    const schValid = gen.name("_valid");
    gen.block(() =>
      schema.forEach((_sch, i) => {
        const schCxt = cxt.subschema(
          {
            keyword,
            schemaProp: i,
            compositeRule: true,
          },
          schValid,
        );
        gen.assign(valid, (0, codegen_1._)`${valid} || ${schValid}`);
        if (!cxt.mergeValidEvaluated(schCxt, schValid)) gen.if((0, codegen_1.not)(valid));
      }),
    );
    cxt.result(
      valid,
      () => cxt.reset(),
      () => cxt.error(true),
    );
  }
  exports.validateUnion = validateUnion;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/keyword.js
var require_keyword = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.validateKeywordUsage =
    exports.validSchemaType =
    exports.funcKeywordCode =
    exports.macroKeywordCode =
      void 0;
  const codegen_1 = require_codegen();
  const names_1 = require_names();
  const code_1 = require_code();
  const errors_1 = require_errors();
  function macroKeywordCode(cxt, def) {
    const { gen, keyword, schema, parentSchema, it } = cxt;
    const macroSchema = def.macro.call(it.self, schema, parentSchema, it);
    const schemaRef = useKeyword(gen, keyword, macroSchema);
    if (it.opts.validateSchema !== false) it.self.validateSchema(macroSchema, true);
    const valid = gen.name("valid");
    cxt.subschema(
      {
        schema: macroSchema,
        schemaPath: codegen_1.nil,
        errSchemaPath: `${it.errSchemaPath}/${keyword}`,
        topSchemaRef: schemaRef,
        compositeRule: true,
      },
      valid,
    );
    cxt.pass(valid, () => cxt.error(true));
  }
  exports.macroKeywordCode = macroKeywordCode;
  function funcKeywordCode(cxt, def) {
    var _a;
    const { gen, keyword, schema, parentSchema, $data, it } = cxt;
    checkAsyncKeyword(it, def);
    const validateRef = useKeyword(
      gen,
      keyword,
      !$data && def.compile ? def.compile.call(it.self, schema, parentSchema, it) : def.validate,
    );
    const valid = gen.let("valid");
    cxt.block$data(valid, validateKeyword);
    cxt.ok((_a = def.valid) !== null && _a !== void 0 ? _a : valid);
    function validateKeyword() {
      if (def.errors === false) {
        assignValid();
        if (def.modifying) modifyData(cxt);
        reportErrs(() => cxt.error());
      } else {
        const ruleErrs = def.async ? validateAsync() : validateSync();
        if (def.modifying) modifyData(cxt);
        reportErrs(() => addErrs(cxt, ruleErrs));
      }
    }
    function validateAsync() {
      const ruleErrs = gen.let("ruleErrs", null);
      gen.try(
        () => assignValid((0, codegen_1._)`await `),
        (e) =>
          gen.assign(valid, false).if(
            (0, codegen_1._)`${e} instanceof ${it.ValidationError}`,
            () => gen.assign(ruleErrs, (0, codegen_1._)`${e}.errors`),
            () => gen.throw(e),
          ),
      );
      return ruleErrs;
    }
    function validateSync() {
      const validateErrs = (0, codegen_1._)`${validateRef}.errors`;
      gen.assign(validateErrs, null);
      assignValid(codegen_1.nil);
      return validateErrs;
    }
    function assignValid(_await = def.async ? (0, codegen_1._)`await ` : codegen_1.nil) {
      const passCxt = it.opts.passContext ? names_1.default.this : names_1.default.self;
      const passSchema = !(("compile" in def && !$data) || def.schema === false);
      gen.assign(
        valid,
        (0,
        codegen_1._)`${_await}${(0, code_1.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`,
        def.modifying,
      );
    }
    function reportErrs(errors) {
      var _a;
      gen.if((0, codegen_1.not)((_a = def.valid) !== null && _a !== void 0 ? _a : valid), errors);
    }
  }
  exports.funcKeywordCode = funcKeywordCode;
  function modifyData(cxt) {
    const { gen, data, it } = cxt;
    gen.if(it.parentData, () =>
      gen.assign(data, (0, codegen_1._)`${it.parentData}[${it.parentDataProperty}]`),
    );
  }
  function addErrs(cxt, errs) {
    const { gen } = cxt;
    gen.if(
      (0, codegen_1._)`Array.isArray(${errs})`,
      () => {
        gen
          .assign(
            names_1.default.vErrors,
            (0,
            codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`,
          )
          .assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`);
        (0, errors_1.extendErrors)(cxt);
      },
      () => cxt.error(),
    );
  }
  function checkAsyncKeyword({ schemaEnv }, def) {
    if (def.async && !schemaEnv.$async) throw new Error("async keyword in sync schema");
  }
  function useKeyword(gen, keyword, result) {
    if (result === void 0) throw new Error(`keyword "${keyword}" failed to compile`);
    return gen.scopeValue(
      "keyword",
      typeof result == "function"
        ? { ref: result }
        : {
            ref: result,
            code: (0, codegen_1.stringify)(result),
          },
    );
  }
  function validSchemaType(schema, schemaType, allowUndefined = false) {
    return (
      !schemaType.length ||
      schemaType.some((st) =>
        st === "array"
          ? Array.isArray(schema)
          : st === "object"
            ? schema && typeof schema == "object" && !Array.isArray(schema)
            : typeof schema == st || (allowUndefined && typeof schema == "undefined"),
      )
    );
  }
  exports.validSchemaType = validSchemaType;
  function validateKeywordUsage({ schema, opts, self, errSchemaPath }, def, keyword) {
    /* istanbul ignore if */
    if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword)
      throw new Error("ajv implementation error");
    const deps = def.dependencies;
    if (
      deps === null || deps === void 0
        ? void 0
        : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema, kwd))
    )
      throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(",")}`);
    if (def.validateSchema) {
      if (!def.validateSchema(schema[keyword])) {
        const msg =
          `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` +
          self.errorsText(def.validateSchema.errors);
        if (opts.validateSchema === "log") self.logger.error(msg);
        else throw new Error(msg);
      }
    }
  }
  exports.validateKeywordUsage = validateKeywordUsage;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/subschema.js
var require_subschema = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = void 0;
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  function getSubschema(
    it,
    { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef },
  ) {
    if (keyword !== void 0 && schema !== void 0)
      throw new Error('both "keyword" and "schema" passed, only one allowed');
    if (keyword !== void 0) {
      const sch = it.schema[keyword];
      return schemaProp === void 0
        ? {
            schema: sch,
            schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}`,
            errSchemaPath: `${it.errSchemaPath}/${keyword}`,
          }
        : {
            schema: sch[schemaProp],
            schemaPath: (0,
            codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}${(0, codegen_1.getProperty)(schemaProp)}`,
            errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}`,
          };
    }
    if (schema !== void 0) {
      if (schemaPath === void 0 || errSchemaPath === void 0 || topSchemaRef === void 0)
        throw new Error(
          '"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"',
        );
      return {
        schema,
        schemaPath,
        topSchemaRef,
        errSchemaPath,
      };
    }
    throw new Error('either "keyword" or "schema" must be passed');
  }
  exports.getSubschema = getSubschema;
  function extendSubschemaData(
    subschema,
    it,
    { dataProp, dataPropType: dpType, data, dataTypes, propertyName },
  ) {
    if (data !== void 0 && dataProp !== void 0)
      throw new Error('both "data" and "dataProp" passed, only one allowed');
    const { gen } = it;
    if (dataProp !== void 0) {
      const { errorPath, dataPathArr, opts } = it;
      dataContextProps(
        gen.let("data", (0, codegen_1._)`${it.data}${(0, codegen_1.getProperty)(dataProp)}`, true),
      );
      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) {
      dataContextProps(data instanceof codegen_1.Name ? data : gen.let("data", data, true));
      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;
});
//#endregion
//#region ../node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js
var require_fast_deep_equal = /* @__PURE__ */ __commonJSMin((exports, module) => {
  module.exports = function equal(a, b) {
    if (a === b) return true;
    if (a && b && typeof a == "object" && typeof b == "object") {
      if (a.constructor !== b.constructor) return false;
      var length, i, keys;
      if (Array.isArray(a)) {
        length = a.length;
        if (length != b.length) return false;
        for (i = length; i-- !== 0;) if (!equal(a[i], b[i])) return false;
        return true;
      }
      if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
      if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
      if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
      keys = Object.keys(a);
      length = keys.length;
      if (length !== Object.keys(b).length) return false;
      for (i = length; i-- !== 0;)
        if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
      for (i = length; i-- !== 0;) {
        var key = keys[i];
        if (!equal(a[key], b[key])) return false;
      }
      return true;
    }
    return a !== a && b !== b;
  };
});
//#endregion
//#region ../node_modules/.pnpm/json-schema-traverse@1.0.0/node_modules/json-schema-traverse/index.js
var require_json_schema_traverse = /* @__PURE__ */ __commonJSMin((exports, module) => {
  var traverse = (module.exports = function (schema, opts, cb) {
    if (typeof opts == "function") {
      cb = opts;
      opts = {};
    }
    cb = opts.cb || cb;
    var pre = typeof cb == "function" ? cb : cb.pre || function () {};
    var post = cb.post || function () {};
    _traverse(opts, pre, post, schema, "", schema);
  });
  traverse.keywords = {
    additionalItems: true,
    items: true,
    contains: true,
    additionalProperties: true,
    propertyNames: true,
    not: true,
    if: true,
    then: true,
    else: true,
  };
  traverse.arrayKeywords = {
    items: true,
    allOf: true,
    anyOf: true,
    oneOf: true,
  };
  traverse.propsKeywords = {
    $defs: true,
    definitions: true,
    properties: true,
    patternProperties: true,
    dependencies: true,
  };
  traverse.skipKeywords = {
    default: true,
    enum: true,
    const: true,
    required: true,
    maximum: true,
    minimum: true,
    exclusiveMaximum: true,
    exclusiveMinimum: true,
    multipleOf: true,
    maxLength: true,
    minLength: true,
    pattern: true,
    format: true,
    maxItems: true,
    minItems: true,
    uniqueItems: true,
    maxProperties: true,
    minProperties: true,
  };
  function _traverse(
    opts,
    pre,
    post,
    schema,
    jsonPtr,
    rootSchema,
    parentJsonPtr,
    parentKeyword,
    parentSchema,
    keyIndex,
  ) {
    if (schema && typeof schema == "object" && !Array.isArray(schema)) {
      pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
      for (var key in schema) {
        var sch = schema[key];
        if (Array.isArray(sch)) {
          if (key in traverse.arrayKeywords)
            for (var i = 0; i < sch.length; i++)
              _traverse(
                opts,
                pre,
                post,
                sch[i],
                jsonPtr + "/" + key + "/" + i,
                rootSchema,
                jsonPtr,
                key,
                schema,
                i,
              );
        } else if (key in traverse.propsKeywords) {
          if (sch && typeof sch == "object")
            for (var prop in sch)
              _traverse(
                opts,
                pre,
                post,
                sch[prop],
                jsonPtr + "/" + key + "/" + escapeJsonPtr(prop),
                rootSchema,
                jsonPtr,
                key,
                schema,
                prop,
              );
        } else if (key in traverse.keywords || (opts.allKeys && !(key in traverse.skipKeywords)))
          _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema);
      }
      post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
    }
  }
  function escapeJsonPtr(str) {
    return str.replace(/~/g, "~0").replace(/\//g, "~1");
  }
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/resolve.js
var require_resolve = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.getSchemaRefs =
    exports.resolveUrl =
    exports.normalizeId =
    exports._getFullPath =
    exports.getFullPath =
    exports.inlineRef =
      void 0;
  const util_1 = require_util();
  const equal = require_fast_deep_equal();
  const traverse = require_json_schema_traverse();
  const SIMPLE_INLINED = /* @__PURE__ */ new Set([
    "type",
    "format",
    "pattern",
    "maxLength",
    "minLength",
    "maxProperties",
    "minProperties",
    "maxItems",
    "minItems",
    "maximum",
    "minimum",
    "uniqueItems",
    "multipleOf",
    "required",
    "enum",
    "const",
  ]);
  function inlineRef(schema, limit = true) {
    if (typeof schema == "boolean") return true;
    if (limit === true) return !hasRef(schema);
    if (!limit) return false;
    return countKeys(schema) <= limit;
  }
  exports.inlineRef = inlineRef;
  const REF_KEYWORDS = /* @__PURE__ */ new Set([
    "$ref",
    "$recursiveRef",
    "$recursiveAnchor",
    "$dynamicRef",
    "$dynamicAnchor",
  ]);
  function hasRef(schema) {
    for (const key in schema) {
      if (REF_KEYWORDS.has(key)) return true;
      const sch = schema[key];
      if (Array.isArray(sch) && sch.some(hasRef)) return true;
      if (typeof sch == "object" && hasRef(sch)) return true;
    }
    return false;
  }
  function countKeys(schema) {
    let count = 0;
    for (const key in schema) {
      if (key === "$ref") return Infinity;
      count++;
      if (SIMPLE_INLINED.has(key)) continue;
      if (typeof schema[key] == "object")
        (0, util_1.eachItem)(schema[key], (sch) => (count += countKeys(sch)));
      if (count === Infinity) return Infinity;
    }
    return count;
  }
  function getFullPath(resolver, id = "", normalize) {
    if (normalize !== false) id = normalizeId(id);
    return _getFullPath(resolver, resolver.parse(id));
  }
  exports.getFullPath = getFullPath;
  function _getFullPath(resolver, p) {
    return resolver.serialize(p).split("#")[0] + "#";
  }
  exports._getFullPath = _getFullPath;
  const 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;
  const ANCHOR = /^[a-z_][-a-z0-9._]*$/i;
  function getSchemaRefs(schema, baseId) {
    if (typeof schema == "boolean") return {};
    const { schemaId, uriResolver } = this.opts;
    const schId = normalizeId(schema[schemaId] || baseId);
    const baseIds = { "": schId };
    const pathPrefix = getFullPath(uriResolver, schId, false);
    const localRefs = {};
    const schemaRefs = /* @__PURE__ */ new Set();
    traverse(schema, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
      if (parentJsonPtr === void 0) return;
      const fullPath = pathPrefix + jsonPtr;
      let innerBaseId = baseIds[parentJsonPtr];
      if (typeof sch[schemaId] == "string") innerBaseId = addRef.call(this, sch[schemaId]);
      addAnchor.call(this, sch.$anchor);
      addAnchor.call(this, sch.$dynamicAnchor);
      baseIds[jsonPtr] = innerBaseId;
      function addRef(ref) {
        const _resolve = this.opts.uriResolver.resolve;
        ref = normalizeId(innerBaseId ? _resolve(innerBaseId, ref) : ref);
        if (schemaRefs.has(ref)) throw ambiguos(ref);
        schemaRefs.add(ref);
        let schOrRef = this.refs[ref];
        if (typeof schOrRef == "string") schOrRef = this.refs[schOrRef];
        if (typeof schOrRef == "object") checkAmbiguosRef(sch, schOrRef.schema, ref);
        else if (ref !== normalizeId(fullPath)) {
          if (ref[0] === "#") {
            checkAmbiguosRef(sch, localRefs[ref], ref);
            localRefs[ref] = sch;
          } else this.refs[ref] = fullPath;
        }
        return ref;
      }
      function addAnchor(anchor) {
        if (typeof anchor == "string") {
          if (!ANCHOR.test(anchor)) throw new Error(`invalid anchor "${anchor}"`);
          addRef.call(this, `#${anchor}`);
        }
      }
    });
    return localRefs;
    function checkAmbiguosRef(sch1, sch2, ref) {
      if (sch2 !== void 0 && !equal(sch1, sch2)) throw ambiguos(ref);
    }
    function ambiguos(ref) {
      return /* @__PURE__ */ new Error(`reference "${ref}" resolves to more than one schema`);
    }
  }
  exports.getSchemaRefs = getSchemaRefs;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/index.js
var require_validate = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.getData = exports.KeywordCxt = exports.validateFunctionCode = void 0;
  const boolSchema_1 = require_boolSchema();
  const dataType_1 = require_dataType();
  const applicability_1 = require_applicability();
  const dataType_2 = require_dataType();
  const defaults_1 = require_defaults();
  const keyword_1 = require_keyword();
  const subschema_1 = require_subschema();
  const codegen_1 = require_codegen();
  const names_1 = require_names();
  const resolve_1 = require_resolve();
  const util_1 = require_util();
  const errors_1 = require_errors();
  function validateFunctionCode(it) {
    if (isSchemaObj(it)) {
      checkKeywords(it);
      if (schemaCxtHasRules(it)) {
        topSchemaObjCode(it);
        return;
      }
    }
    validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it));
  }
  exports.validateFunctionCode = validateFunctionCode;
  function validateFunction({ gen, validateName, schema, schemaEnv, opts }, body) {
    if (opts.code.es5)
      gen.func(
        validateName,
        (0, codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`,
        schemaEnv.$async,
        () => {
          gen.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema, opts)}`);
          destructureValCxtES5(gen, opts);
          gen.code(body);
        },
      );
    else
      gen.func(
        validateName,
        (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`,
        schemaEnv.$async,
        () => gen.code(funcSourceUrl(schema, opts)).code(body),
      );
  }
  function destructureValCxt(opts) {
    return (0,
    codegen_1._)`{${names_1.default.instancePath}="", ${names_1.default.parentData}, ${names_1.default.parentDataProperty}, ${names_1.default.rootData}=${names_1.default.data}${opts.dynamicRef ? (0, codegen_1._)`, ${names_1.default.dynamicAnchors}={}` : codegen_1.nil}}={}`;
  }
  function destructureValCxtES5(gen, opts) {
    gen.if(
      names_1.default.valCxt,
      () => {
        gen.var(
          names_1.default.instancePath,
          (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.instancePath}`,
        );
        gen.var(
          names_1.default.parentData,
          (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentData}`,
        );
        gen.var(
          names_1.default.parentDataProperty,
          (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentDataProperty}`,
        );
        gen.var(
          names_1.default.rootData,
          (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.rootData}`,
        );
        if (opts.dynamicRef)
          gen.var(
            names_1.default.dynamicAnchors,
            (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.dynamicAnchors}`,
          );
      },
      () => {
        gen.var(names_1.default.instancePath, (0, codegen_1._)`""`);
        gen.var(names_1.default.parentData, (0, codegen_1._)`undefined`);
        gen.var(names_1.default.parentDataProperty, (0, codegen_1._)`undefined`);
        gen.var(names_1.default.rootData, names_1.default.data);
        if (opts.dynamicRef) gen.var(names_1.default.dynamicAnchors, (0, codegen_1._)`{}`);
      },
    );
  }
  function topSchemaObjCode(it) {
    const { schema, opts, gen } = it;
    validateFunction(it, () => {
      if (opts.$comment && schema.$comment) commentKeyword(it);
      checkNoDefault(it);
      gen.let(names_1.default.vErrors, null);
      gen.let(names_1.default.errors, 0);
      if (opts.unevaluated) resetEvaluated(it);
      typeAndKeywords(it);
      returnResults(it);
    });
  }
  function resetEvaluated(it) {
    const { gen, validateName } = it;
    it.evaluated = gen.const("evaluated", (0, codegen_1._)`${validateName}.evaluated`);
    gen.if((0, codegen_1._)`${it.evaluated}.dynamicProps`, () =>
      gen.assign((0, codegen_1._)`${it.evaluated}.props`, (0, codegen_1._)`undefined`),
    );
    gen.if((0, codegen_1._)`${it.evaluated}.dynamicItems`, () =>
      gen.assign((0, codegen_1._)`${it.evaluated}.items`, (0, codegen_1._)`undefined`),
    );
  }
  function funcSourceUrl(schema, opts) {
    const schId = typeof schema == "object" && schema[opts.schemaId];
    return schId && (opts.code.source || opts.code.process)
      ? (0, codegen_1._)`/*# sourceURL=${schId} */`
      : codegen_1.nil;
  }
  function subschemaCode(it, valid) {
    if (isSchemaObj(it)) {
      checkKeywords(it);
      if (schemaCxtHasRules(it)) {
        subSchemaObjCode(it, valid);
        return;
      }
    }
    (0, boolSchema_1.boolOrEmptySchema)(it, valid);
  }
  function schemaCxtHasRules({ schema, self }) {
    if (typeof schema == "boolean") return !schema;
    for (const key in schema) if (self.RULES.all[key]) return true;
    return false;
  }
  function isSchemaObj(it) {
    return typeof it.schema != "boolean";
  }
  function subSchemaObjCode(it, valid) {
    const { schema, gen, opts } = it;
    if (opts.$comment && schema.$comment) commentKeyword(it);
    updateContext(it);
    checkAsyncSchema(it);
    const errsCount = gen.const("_errs", names_1.default.errors);
    typeAndKeywords(it, errsCount);
    gen.var(valid, (0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
  }
  function checkKeywords(it) {
    (0, util_1.checkUnknownRules)(it);
    checkRefsAndKeywords(it);
  }
  function typeAndKeywords(it, errsCount) {
    if (it.opts.jtd) return schemaKeywords(it, [], false, errsCount);
    const types = (0, dataType_1.getSchemaTypes)(it.schema);
    schemaKeywords(it, types, !(0, dataType_1.coerceAndCheckDataType)(it, types), errsCount);
  }
  function checkRefsAndKeywords(it) {
    const { schema, errSchemaPath, opts, self } = it;
    if (
      schema.$ref &&
      opts.ignoreKeywordsWithRef &&
      (0, util_1.schemaHasRulesButRef)(schema, self.RULES)
    )
      self.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
  }
  function checkNoDefault(it) {
    const { schema, opts } = it;
    if (schema.default !== void 0 && opts.useDefaults && opts.strictSchema)
      (0, util_1.checkStrictMode)(it, "default is ignored in the schema root");
  }
  function updateContext(it) {
    const schId = it.schema[it.opts.schemaId];
    if (schId) it.baseId = (0, resolve_1.resolveUrl)(it.opts.uriResolver, it.baseId, schId);
  }
  function checkAsyncSchema(it) {
    if (it.schema.$async && !it.schemaEnv.$async) throw new Error("async schema in sync schema");
  }
  function commentKeyword({ gen, schemaEnv, schema, errSchemaPath, opts }) {
    const msg = schema.$comment;
    if (opts.$comment === true)
      gen.code((0, codegen_1._)`${names_1.default.self}.logger.log(${msg})`);
    else if (typeof opts.$comment == "function") {
      const schemaPath = (0, codegen_1.str)`${errSchemaPath}/$comment`;
      const rootName = gen.scopeValue("root", { ref: schemaEnv.root });
      gen.code(
        (0,
        codegen_1._)`${names_1.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`,
      );
    }
  }
  function returnResults(it) {
    const { gen, schemaEnv, validateName, ValidationError, opts } = it;
    if (schemaEnv.$async)
      gen.if(
        (0, codegen_1._)`${names_1.default.errors} === 0`,
        () => gen.return(names_1.default.data),
        () => gen.throw((0, codegen_1._)`new ${ValidationError}(${names_1.default.vErrors})`),
      );
    else {
      gen.assign((0, codegen_1._)`${validateName}.errors`, names_1.default.vErrors);
      if (opts.unevaluated) assignEvaluated(it);
      gen.return((0, codegen_1._)`${names_1.default.errors} === 0`);
    }
  }
  function assignEvaluated({ gen, evaluated, props, items }) {
    if (props instanceof codegen_1.Name) gen.assign((0, codegen_1._)`${evaluated}.props`, props);
    if (items instanceof codegen_1.Name) gen.assign((0, codegen_1._)`${evaluated}.items`, items);
  }
  function schemaKeywords(it, types, typeErrors, errsCount) {
    const { gen, schema, data, allErrors, opts, self } = it;
    const { RULES } = self;
    if (
      schema.$ref &&
      (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))
    ) {
      gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
      return;
    }
    if (!opts.jtd) checkStrictTypes(it, types);
    gen.block(() => {
      for (const group of RULES.rules) groupKeywords(group);
      groupKeywords(RULES.post);
    });
    function groupKeywords(group) {
      if (!(0, applicability_1.shouldUseGroup)(schema, group)) return;
      if (group.type) {
        gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
        iterateKeywords(it, group);
        if (types.length === 1 && types[0] === group.type && typeErrors) {
          gen.else();
          (0, dataType_2.reportTypeError)(it);
        }
        gen.endIf();
      } else iterateKeywords(it, group);
      if (!allErrors) gen.if((0, codegen_1._)`${names_1.default.errors} === ${errsCount || 0}`);
    }
  }
  function iterateKeywords(it, group) {
    const {
      gen,
      schema,
      opts: { useDefaults },
    } = it;
    if (useDefaults) (0, defaults_1.assignDefaults)(it, group.type);
    gen.block(() => {
      for (const rule of group.rules)
        if ((0, applicability_1.shouldUseRule)(schema, rule))
          keywordCode(it, rule.keyword, rule.definition, group.type);
    });
  }
  function checkStrictTypes(it, types) {
    if (it.schemaEnv.meta || !it.opts.strictTypes) return;
    checkContextTypes(it, types);
    if (!it.opts.allowUnionTypes) checkMultipleTypes(it, types);
    checkKeywordTypes(it, it.dataTypes);
  }
  function checkContextTypes(it, types) {
    if (!types.length) return;
    if (!it.dataTypes.length) {
      it.dataTypes = types;
      return;
    }
    types.forEach((t) => {
      if (!includesType(it.dataTypes, t))
        strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`);
    });
    narrowSchemaTypes(it, types);
  }
  function checkMultipleTypes(it, ts) {
    if (ts.length > 1 && !(ts.length === 2 && ts.includes("null")))
      strictTypesError(it, "use allowUnionTypes to allow union type keyword");
  }
  function checkKeywordTypes(it, ts) {
    const rules = it.self.RULES.all;
    for (const keyword in rules) {
      const rule = rules[keyword];
      if (typeof rule == "object" && (0, applicability_1.shouldUseRule)(it.schema, rule)) {
        const { type } = rule.definition;
        if (type.length && !type.some((t) => hasApplicableType(ts, t)))
          strictTypesError(it, `missing type "${type.join(",")}" for keyword "${keyword}"`);
      }
    }
  }
  function hasApplicableType(schTs, kwdT) {
    return schTs.includes(kwdT) || (kwdT === "number" && schTs.includes("integer"));
  }
  function includesType(ts, t) {
    return ts.includes(t) || (t === "integer" && ts.includes("number"));
  }
  function narrowSchemaTypes(it, withTypes) {
    const ts = [];
    for (const t of it.dataTypes)
      if (includesType(withTypes, t)) ts.push(t);
      else if (withTypes.includes("integer") && t === "number") ts.push("integer");
    it.dataTypes = ts;
  }
  function strictTypesError(it, msg) {
    const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
    msg += ` at "${schemaPath}" (strictTypes)`;
    (0, util_1.checkStrictMode)(it, msg, it.opts.strictTypes);
  }
  var KeywordCxt = class {
    constructor(it, def, keyword) {
      (0, keyword_1.validateKeywordUsage)(it, def, keyword);
      this.gen = it.gen;
      this.allErrors = it.allErrors;
      this.keyword = keyword;
      this.data = it.data;
      this.schema = it.schema[keyword];
      this.$data = def.$data && it.opts.$data && this.schema && this.schema.$data;
      this.schemaValue = (0, util_1.schemaRefOrVal)(it, this.schema, keyword, this.$data);
      this.schemaType = def.schemaType;
      this.parentSchema = it.schema;
      this.params = {};
      this.it = it;
      this.def = def;
      if (this.$data) this.schemaCode = it.gen.const("vSchema", getData(this.$data, it));
      else {
        this.schemaCode = this.schemaValue;
        if (!(0, keyword_1.validSchemaType)(this.schema, def.schemaType, def.allowUndefined))
          throw new Error(`${keyword} value must be ${JSON.stringify(def.schemaType)}`);
      }
      if ("code" in def ? def.trackErrors : def.errors !== false)
        this.errsCount = it.gen.const("_errs", names_1.default.errors);
    }
    result(condition, successAction, failAction) {
      this.failResult((0, codegen_1.not)(condition), successAction, failAction);
    }
    failResult(condition, successAction, failAction) {
      this.gen.if(condition);
      if (failAction) failAction();
      else this.error();
      if (successAction) {
        this.gen.else();
        successAction();
        if (this.allErrors) this.gen.endIf();
      } else if (this.allErrors) this.gen.endIf();
      else this.gen.else();
    }
    pass(condition, failAction) {
      this.failResult((0, codegen_1.not)(condition), void 0, failAction);
    }
    fail(condition) {
      if (condition === void 0) {
        this.error();
        if (!this.allErrors) this.gen.if(false);
        return;
      }
      this.gen.if(condition);
      this.error();
      if (this.allErrors) this.gen.endIf();
      else this.gen.else();
    }
    fail$data(condition) {
      if (!this.$data) return this.fail(condition);
      const { schemaCode } = this;
      this.fail(
        (0,
        codegen_1._)`${schemaCode} !== undefined && (${(0, codegen_1.or)(this.invalid$data(), condition)})`,
      );
    }
    error(append, errorParams, errorPaths) {
      if (errorParams) {
        this.setParams(errorParams);
        this._error(append, errorPaths);
        this.setParams({});
        return;
      }
      this._error(append, errorPaths);
    }
    _error(append, errorPaths) {
      (append ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths);
    }
    $dataError() {
      (0, errors_1.reportError)(this, this.def.$dataError || errors_1.keyword$DataError);
    }
    reset() {
      if (this.errsCount === void 0) throw new Error('add "trackErrors" to keyword definition');
      (0, errors_1.resetErrorsCount)(this.gen, this.errsCount);
    }
    ok(cond) {
      if (!this.allErrors) this.gen.if(cond);
    }
    setParams(obj, assign) {
      if (assign) Object.assign(this.params, obj);
      else this.params = obj;
    }
    block$data(valid, codeBlock, $dataValid = codegen_1.nil) {
      this.gen.block(() => {
        this.check$data(valid, $dataValid);
        codeBlock();
      });
    }
    check$data(valid = codegen_1.nil, $dataValid = codegen_1.nil) {
      if (!this.$data) return;
      const { gen, schemaCode, schemaType, def } = this;
      gen.if((0, codegen_1.or)((0, codegen_1._)`${schemaCode} === undefined`, $dataValid));
      if (valid !== codegen_1.nil) gen.assign(valid, true);
      if (schemaType.length || def.validateSchema) {
        gen.elseIf(this.invalid$data());
        this.$dataError();
        if (valid !== codegen_1.nil) gen.assign(valid, false);
      }
      gen.else();
    }
    invalid$data() {
      const { gen, schemaCode, schemaType, def, it } = this;
      return (0, codegen_1.or)(wrong$DataType(), invalid$DataSchema());
      function wrong$DataType() {
        if (schemaType.length) {
          /* istanbul ignore if */
          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);
  }
  const JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/;
  const 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;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/validation_error.js
var require_validation_error = /* @__PURE__ */ __commonJSMin((exports) => {
  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;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/ref_error.js
var require_ref_error = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const resolve_1 = require_resolve();
  var MissingRefError = class extends Error {
    constructor(resolver, baseId, ref, msg) {
      super(msg || `can't resolve reference ${ref} from id ${baseId}`);
      this.missingRef = (0, resolve_1.resolveUrl)(resolver, baseId, ref);
      this.missingSchema = (0, resolve_1.normalizeId)(
        (0, resolve_1.getFullPath)(resolver, this.missingRef),
      );
    }
  };
  exports.default = MissingRefError;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/index.js
var require_compile = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.resolveSchema =
    exports.getCompilingSchema =
    exports.resolveRef =
    exports.compileSchema =
    exports.SchemaEnv =
      void 0;
  const codegen_1 = require_codegen();
  const validation_error_1 = require_validation_error();
  const names_1 = require_names();
  const resolve_1 = require_resolve();
  const util_1 = require_util();
  const validate_1 = require_validate();
  var SchemaEnv = class {
    constructor(env) {
      var _a;
      this.refs = {};
      this.dynamicAnchors = {};
      let schema;
      if (typeof env.schema == "object") schema = env.schema;
      this.schema = env.schema;
      this.schemaId = env.schemaId;
      this.root = env.root || this;
      this.baseId =
        (_a = env.baseId) !== null && _a !== void 0
          ? _a
          : (0, resolve_1.normalizeId)(
              schema === null || schema === void 0 ? void 0 : schema[env.schemaId || "$id"],
            );
      this.schemaPath = env.schemaPath;
      this.localRefs = env.localRefs;
      this.meta = env.meta;
      this.$async = schema === null || schema === void 0 ? void 0 : schema.$async;
      this.refs = {};
    }
  };
  exports.SchemaEnv = SchemaEnv;
  function compileSchema(sch) {
    const _sch = getCompilingSchema.call(this, sch);
    if (_sch) return _sch;
    const rootId = (0, resolve_1.getFullPath)(this.opts.uriResolver, sch.root.baseId);
    const { es5, lines } = this.opts.code;
    const { ownProperties } = this.opts;
    const gen = new codegen_1.CodeGen(this.scope, {
      es5,
      lines,
      ownProperties,
    });
    let _ValidationError;
    if (sch.$async)
      _ValidationError = gen.scopeValue("Error", {
        ref: validation_error_1.default,
        code: (0, codegen_1._)`require("ajv/dist/runtime/validation_error").default`,
      });
    const validateName = gen.scopeName("validate");
    sch.validateName = validateName;
    const schemaCxt = {
      gen,
      allErrors: this.opts.allErrors,
      data: names_1.default.data,
      parentData: names_1.default.parentData,
      parentDataProperty: names_1.default.parentDataProperty,
      dataNames: [names_1.default.data],
      dataPathArr: [codegen_1.nil],
      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 validate = new Function(
        `${names_1.default.self}`,
        `${names_1.default.scope}`,
        sourceCode,
      )(this, this.scope.get());
      this.scope.value(validateName, { ref: validate });
      validate.errors = null;
      validate.schema = sch.schema;
      validate.schemaEnv = sch;
      if (sch.$async) validate.$async = true;
      if (this.opts.code.source === true)
        validate.source = {
          validateName,
          validateCode,
          scopeValues: gen._values,
        };
      if (this.opts.unevaluated) {
        const { props, items } = schemaCxt;
        validate.evaluated = {
          props: props instanceof codegen_1.Name ? void 0 : props,
          items: items instanceof codegen_1.Name ? void 0 : items,
          dynamicProps: props instanceof codegen_1.Name,
          dynamicItems: items instanceof codegen_1.Name,
        };
        if (validate.source)
          validate.source.evaluated = (0, codegen_1.stringify)(validate.evaluated);
      }
      sch.validate = validate;
      return sch;
    } catch (e) {
      delete sch.validate;
      delete sch.validateName;
      if (sourceCode) this.logger.error("Error compiling schema, function code:", sourceCode);
      throw e;
    } finally {
      this._compilations.delete(sch);
    }
  }
  exports.compileSchema = compileSchema;
  function resolveRef(root, baseId, ref) {
    var _a;
    ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
    const schOrFunc = root.refs[ref];
    if (schOrFunc) return schOrFunc;
    let _sch = resolve.call(this, root, ref);
    if (_sch === void 0) {
      const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
      const { schemaId } = this.opts;
      if (schema)
        _sch = new SchemaEnv({
          schema,
          schemaId,
          root,
          baseId,
        });
    }
    if (_sch === void 0) return;
    return (root.refs[ref] = inlineOrCompile.call(this, _sch));
  }
  exports.resolveRef = resolveRef;
  function inlineOrCompile(sch) {
    if ((0, resolve_1.inlineRef)(sch.schema, this.opts.inlineRefs)) return sch.schema;
    return sch.validate ? sch : compileSchema.call(this, sch);
  }
  function getCompilingSchema(schEnv) {
    for (const sch of this._compilations) if (sameSchemaEnv(sch, schEnv)) return sch;
  }
  exports.getCompilingSchema = getCompilingSchema;
  function sameSchemaEnv(s1, s2) {
    return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
  }
  function resolve(root, ref) {
    let sch;
    while (typeof (sch = this.refs[ref]) == "string") ref = sch;
    return sch || this.schemas[ref] || resolveSchema.call(this, root, ref);
  }
  function resolveSchema(root, ref) {
    const p = this.opts.uriResolver.parse(ref);
    const refPath = (0, resolve_1._getFullPath)(this.opts.uriResolver, p);
    let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root.baseId, void 0);
    if (Object.keys(root.schema).length > 0 && refPath === baseId)
      return getJsonPointer.call(this, p, root);
    const id = (0, resolve_1.normalizeId)(refPath);
    const schOrRef = this.refs[id] || this.schemas[id];
    if (typeof schOrRef == "string") {
      const sch = resolveSchema.call(this, root, schOrRef);
      if (typeof (sch === null || sch === void 0 ? void 0 : sch.schema) !== "object") return;
      return getJsonPointer.call(this, p, sch);
    }
    if (typeof (schOrRef === null || schOrRef === void 0 ? void 0 : schOrRef.schema) !== "object")
      return;
    if (!schOrRef.validate) compileSchema.call(this, schOrRef);
    if (id === (0, resolve_1.normalizeId)(ref)) {
      const { schema } = schOrRef;
      const { schemaId } = this.opts;
      const schId = schema[schemaId];
      if (schId) baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
      return new SchemaEnv({
        schema,
        schemaId,
        root,
        baseId,
      });
    }
    return getJsonPointer.call(this, p, schOrRef);
  }
  exports.resolveSchema = resolveSchema;
  const PREVENT_SCOPE_CHANGE = /* @__PURE__ */ new Set([
    "properties",
    "patternProperties",
    "enum",
    "dependencies",
    "definitions",
  ]);
  function getJsonPointer(parsedRef, { baseId, schema, root }) {
    var _a;
    if (((_a = parsedRef.fragment) === null || _a === void 0 ? void 0 : _a[0]) !== "/") return;
    for (const part of parsedRef.fragment.slice(1).split("/")) {
      if (typeof schema === "boolean") return;
      const partSchema = schema[(0, util_1.unescapeFragment)(part)];
      if (partSchema === void 0) return;
      schema = partSchema;
      const schId = typeof schema === "object" && schema[this.opts.schemaId];
      if (!PREVENT_SCOPE_CHANGE.has(part) && schId)
        baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
    }
    let env;
    if (
      typeof schema != "boolean" &&
      schema.$ref &&
      !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)
    ) {
      const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref);
      env = resolveSchema.call(this, root, $ref);
    }
    const { schemaId } = this.opts;
    env =
      env ||
      new SchemaEnv({
        schema,
        schemaId,
        root,
        baseId,
      });
    if (env.schema !== env.root.schema) return env;
  }
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/data.json
var require_data = /* @__PURE__ */ __commonJSMin((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,
  };
});
//#endregion
//#region ../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/lib/utils.js
var require_utils = /* @__PURE__ */ __commonJSMin((exports, module) => {
  /** @type {(value: string) => boolean} */
  const isUUID = RegExp.prototype.test.bind(
    /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu,
  );
  /** @type {(value: string) => boolean} */
  const isIPv4 = RegExp.prototype.test.bind(
    /^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u,
  );
  /** @type {(value: string) => boolean} */
  const isPort = RegExp.prototype.test.bind(/^\d*$/u);
  /** @type {(value: string) => boolean} */
  const isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
  /** @type {(value: string) => boolean} */
  const isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
  /** @type {(value: string) => boolean} */
  const isPathCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u);
  /** @type {(value: string) => boolean} */
  const isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u);
  /** @type {(value: string) => boolean} */
  const isUserinfoCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u);
  const BYTE_HEX = new Array(256);
  {
    const HEX_DIGITS = "0123456789ABCDEF";
    for (let i = 0; i < 256; i++) BYTE_HEX[i] = "%" + HEX_DIGITS[i >> 4] + HEX_DIGITS[i & 15];
  }
  function percentEncodeNonAscii(cp) {
    if (cp < 2048) return BYTE_HEX[192 | (cp >> 6)] + BYTE_HEX[128 | (cp & 63)];
    if (cp < 65536)
      return (
        BYTE_HEX[224 | (cp >> 12)] + BYTE_HEX[128 | ((cp >> 6) & 63)] + BYTE_HEX[128 | (cp & 63)]
      );
    return (
      BYTE_HEX[240 | (cp >> 18)] +
      BYTE_HEX[128 | ((cp >> 12) & 63)] +
      BYTE_HEX[128 | ((cp >> 6) & 63)] +
      BYTE_HEX[128 | (cp & 63)]
    );
  }
  /**
   * @param {Array<string>} input
   * @returns {string}
   */
  function stringArrayToHexStripped(input) {
    let acc = "";
    let code = 0;
    let i = 0;
    for (i = 0; i < input.length; i++) {
      code = input[i].charCodeAt(0);
      if (code === 48) continue;
      if (
        !((code >= 48 && code <= 57) || (code >= 65 && code <= 70) || (code >= 97 && code <= 102))
      )
        return "";
      acc += input[i];
      break;
    }
    for (i += 1; i < input.length; i++) {
      code = input[i].charCodeAt(0);
      if (
        !((code >= 48 && code <= 57) || (code >= 65 && code <= 70) || (code >= 97 && code <= 102))
      )
        return "";
      acc += input[i];
    }
    return acc;
  }
  /** @type {(value: string) => boolean} */
  const isHextet = RegExp.prototype.test.bind(/^[\dA-Fa-f]{1,4}$/);
  /** @type {(value: string) => boolean} */
  const isIPvFuture = RegExp.prototype.test.bind(/^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/);
  /** @type {(value: string) => boolean} */
  const isZoneCharacter = RegExp.prototype.test.bind(/^[A-Za-z\d\-._~]$/);
  /**
   * @param {string} value
   * @returns {boolean}
   */
  const nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
  /**
   * @param {string} zone
   * @returns {boolean}
   */
  function isZoneIdentifier(zone) {
    if (zone.length === 0) return false;
    for (let i = 0; i < zone.length; i++) {
      if (isZoneCharacter(zone[i])) continue;
      if (zone[i] === "%" && i + 2 < zone.length && isHexPair(zone.slice(i + 1, i + 3))) {
        i += 2;
        continue;
      }
      return false;
    }
    return true;
  }
  /**
   * Compresses the longest run of zero hextets to "::" per RFC 5952. A run of a
   * single zero hextet is left uncompressed. On ties the leftmost run wins.
   *
   * @param {string[]} hextets
   * @returns {string}
   */
  function compressIPv6ZeroRun(hextets) {
    let bestStart = -1;
    let bestLength = 0;
    let runStart = -1;
    let runLength = 0;
    for (let i = 0; i < hextets.length; i++)
      if (hextets[i] === "0") {
        if (runStart === -1) runStart = i;
        runLength++;
        if (runLength > bestLength) {
          bestLength = runLength;
          bestStart = runStart;
        }
      } else {
        runStart = -1;
        runLength = 0;
      }
    if (bestLength < 2) return hextets.join(":");
    const head = hextets.slice(0, bestStart).join(":");
    const tail = hextets.slice(bestStart + bestLength).join(":");
    return head + "::" + tail;
  }
  /**
   * Validates an IPv6 address against the alternatives in RFC 3986 section
   * 3.2.2 and returns the same address with leading hextet zeroes removed.
   * An embedded IPv4 address counts as two hextets and is only valid at the end.
   *
   * @param {string} input
   * @returns {string|undefined}
   */
  function normalizeIPv6Address(input) {
    const compression = input.indexOf("::");
    if (compression !== -1 && input.indexOf("::", compression + 1) !== -1) return void 0;
    const left = compression === -1 ? input.split(":") : input.slice(0, compression).split(":");
    const right = compression === -1 ? [] : input.slice(compression + 2).split(":");
    if (compression !== -1) {
      if (left.length === 1 && left[0] === "") left.length = 0;
      if (right.length === 1 && right[0] === "") right.length = 0;
    }
    const parts = left.concat(right);
    let hextetCount = 0;
    for (let i = 0; i < parts.length; i++) {
      const part = parts[i];
      if (part === "") return void 0;
      if (part.indexOf(".") !== -1) {
        if (i !== parts.length - 1 || (compression !== -1 && right.length === 0) || !isIPv4(part))
          return void 0;
        hextetCount += 2;
        continue;
      }
      if (!isHextet(part)) return void 0;
      parts[i] = parseInt(part, 16).toString(16);
      hextetCount++;
    }
    if (compression === -1) {
      if (hextetCount !== 8) return void 0;
      return compressIPv6ZeroRun(parts);
    }
    if (hextetCount >= 8) return void 0;
    const expanded = parts.slice(0, left.length);
    for (let i = hextetCount; i < 8; i++) expanded.push("0");
    for (let i = left.length; i < parts.length; i++) expanded.push(parts[i]);
    return compressIPv6ZeroRun(expanded);
  }
  /**
   * @typedef {Object} NormalizeIPv6Result
   * @property {string} host - The normalized host.
   * @property {string} [escapedHost] - The escaped host.
   * @property {boolean} isIPV6 - Indicates if the host is an IPv6 address.
   * @property {boolean} [isIPVFuture] - Indicates if the host is an IPvFuture literal.
   * @property {boolean} [error] - Indicates if a bracketed IP literal is malformed.
   */
  /**
   * Validates and normalizes a bracketed IP literal. Raw zone separators remain
   * accepted for backwards compatibility, while encoded separators and zone
   * contents follow RFC 6874.
   *
   * @param {string} host
   * @returns {NormalizeIPv6Result}
   */
  function normalizeIPv6(host) {
    const bracketed = host[0] === "[" && host[host.length - 1] === "]";
    if ((host[0] === "[" || host[host.length - 1] === "]") && !bracketed)
      return {
        host,
        isIPV6: false,
        error: true,
      };
    let input = bracketed ? host.slice(1, -1) : host;
    if (bracketed && isIPvFuture(input)) {
      input = input.toLowerCase();
      return {
        host: `[${input}]`,
        escapedHost: input,
        isIPV6: false,
        isIPVFuture: true,
      };
    }
    if (findToken(input, ":") < 2)
      return {
        host,
        isIPV6: false,
        error: bracketed,
      };
    let zoneIdentifier = "";
    const zoneSeparator = input.indexOf("%");
    if (zoneSeparator !== -1) {
      const separatorLength =
        input.slice(zoneSeparator, zoneSeparator + 3).toLowerCase() === "%25" ? 3 : 1;
      zoneIdentifier = input.slice(zoneSeparator + separatorLength);
      if (!isZoneIdentifier(zoneIdentifier))
        return {
          host,
          isIPV6: false,
          error: true,
        };
      input = input.slice(0, zoneSeparator);
    }
    const address = normalizeIPv6Address(input);
    if (address === void 0)
      return {
        host,
        isIPV6: false,
        error: true,
      };
    return {
      host: address + (zoneIdentifier ? "%" + zoneIdentifier : ""),
      escapedHost: address + (zoneIdentifier ? "%25" + zoneIdentifier : ""),
      isIPV6: true,
    };
  }
  /**
   * @param {string} str
   * @param {string} token
   * @returns {number}
   */
  function findToken(str, token) {
    let ind = 0;
    for (let i = 0; i < str.length; i++) if (str[i] === token) ind++;
    return ind;
  }
  /**
   * @param {string} path
   * @returns {string}
   *
   * @see https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
   */
  function removeDotSegments(path) {
    let input = path;
    const output = [];
    let nextSlash = -1;
    let len = 0;
    while ((len = input.length)) {
      if (len === 1) {
        if (input === ".") break;
        else if (input === "/") {
          output.push("/");
          break;
        } else {
          output.push(input);
          break;
        }
      } else if (len === 2) {
        if (input[0] === ".") {
          if (input[1] === ".") break;
          else if (input[1] === "/") {
            input = input.slice(2);
            continue;
          }
        } else if (input[0] === "/") {
          if (input[1] === "." || input[1] === "/") {
            output.push("/");
            break;
          }
        }
      } else if (len === 3) {
        if (input === "/..") {
          if (output.length !== 0) output.pop();
          output.push("/");
          break;
        }
      }
      if (input[0] === ".") {
        if (input[1] === ".") {
          if (input[2] === "/") {
            input = input.slice(3);
            continue;
          }
        } else if (input[1] === "/") {
          input = input.slice(2);
          continue;
        }
      } else if (input[0] === "/") {
        if (input[1] === ".") {
          if (input[2] === "/") {
            input = input.slice(2);
            continue;
          } else if (input[2] === ".") {
            if (input[3] === "/") {
              input = input.slice(3);
              if (output.length !== 0) output.pop();
              continue;
            }
          }
        }
      }
      if ((nextSlash = input.indexOf("/", 1)) === -1) {
        output.push(input);
        break;
      } else {
        output.push(input.slice(0, nextSlash));
        input = input.slice(nextSlash);
      }
    }
    return output.join("");
  }
  /**
   * Re-escape RFC 3986 gen-delims that must not appear literally in the host.
   * After the URI regex parses, these characters cannot be literal in the host
   * field, so any that appear after decoding came from percent-encoding and
   * must be restored to prevent authority structure changes.
   *
   * @param {string} host
   * @param {boolean} isIP - true for IPv4/IPv6 hosts (skip colon re-escaping)
   * @returns {string}
   */
  const HOST_DELIMS = {
    "@": "%40",
    "/": "%2F",
    "?": "%3F",
    "#": "%23",
    ":": "%3A",
  };
  const HOST_DELIM_RE = /[@/?#:]/g;
  const HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
  function reescapeHostDelimiters(host, isIP) {
    const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
    re.lastIndex = 0;
    return host.replace(re, (ch) => HOST_DELIMS[ch]);
  }
  /**
   * Normalizes percent escapes and optionally decodes only unreserved ASCII bytes.
   * Reserved delimiters such as `%2F` stay escaped; `%2E` is unreserved.
   *
   * @param {string} input
   * @param {boolean} [decodeUnreserved=false]
   * @returns {string}
   */
  function normalizePercentEncoding(input, decodeUnreserved = false) {
    if (input.indexOf("%") === -1) return input;
    let output = "";
    for (let i = 0; i < input.length; i++) {
      if (input[i] === "%" && i + 2 < input.length) {
        const hex = input.slice(i + 1, i + 3);
        if (isHexPair(hex)) {
          const normalizedHex = hex.toUpperCase();
          const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
          if (decodeUnreserved && isUnreserved(decoded)) output += decoded;
          else output += "%" + normalizedHex;
          i += 2;
          continue;
        }
      }
      output += input[i];
    }
    return output;
  }
  /**
   * Normalizes path data without turning reserved escapes into live path syntax.
   * Valid escapes are uppercased, raw unsafe characters are escaped, and only
   * unreserved bytes that are not `.` are decoded.
   *
   * @param {string} input
   * @returns {string}
   */
  function normalizePathEncoding(input) {
    let output = "";
    for (let i = 0; i < input.length; i++) {
      const ch = input[i];
      if (ch === "%" && i + 2 < input.length) {
        const hex = input.slice(i + 1, i + 3);
        if (isHexPair(hex)) {
          const normalizedHex = hex.toUpperCase();
          const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
          if (decoded !== "." && isUnreserved(decoded)) output += decoded;
          else output += "%" + normalizedHex;
          i += 2;
          continue;
        }
      }
      if (isPathCharacter(ch)) output += ch;
      else {
        const code = input.charCodeAt(i);
        if (code < 128) output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
        else if (code < 55296 || code > 57343) output += percentEncodeNonAscii(code);
        else if (code <= 56319 && i + 1 < input.length) {
          const low = input.charCodeAt(i + 1);
          if (low >= 56320 && low <= 57343) {
            output += percentEncodeNonAscii(65536 + ((code - 55296) << 10) + (low - 56320));
            i++;
          } else output += percentEncodeNonAscii(65533);
        } else output += percentEncodeNonAscii(65533);
      }
    }
    return output;
  }
  /**
   * Serializes a path without rewriting reserved data. Raw RFC 3986 path
   * characters remain literal, valid escapes are preserved and uppercased, and
   * everything else is UTF-8 percent-encoded. In a path-noscheme, a colon in the
   * first segment must be escaped so the result cannot be parsed as a scheme.
   *
   * @param {string} input
   * @param {boolean} [pathNoScheme=false]
   * @returns {string}
   */
  function serializePathEncoding(input, pathNoScheme = false) {
    let output = "";
    let firstSegment = pathNoScheme && input[0] !== "/";
    for (let i = 0; i < input.length; i++) {
      const ch = input[i];
      if (ch === "%" && i + 2 < input.length) {
        const hex = input.slice(i + 1, i + 3);
        if (isHexPair(hex)) {
          output += "%" + hex.toUpperCase();
          i += 2;
          continue;
        }
      }
      if (ch === "/") firstSegment = false;
      if (isPathCharacter(ch) && (ch !== ":" || !firstSegment)) output += ch;
      else {
        const code = input.charCodeAt(i);
        if (code < 128) output += BYTE_HEX[code];
        else if (code < 55296 || code > 57343) output += percentEncodeNonAscii(code);
        else if (code <= 56319 && i + 1 < input.length) {
          const low = input.charCodeAt(i + 1);
          if (low >= 56320 && low <= 57343) {
            output += percentEncodeNonAscii(65536 + ((code - 55296) << 10) + (low - 56320));
            i++;
          } else output += percentEncodeNonAscii(65533);
        } else output += percentEncodeNonAscii(65533);
      }
    }
    return output;
  }
  /**
   * Percent-encodes a URI component using its RFC 3986 literal character set.
   * Existing valid escapes are preserved and normalized to uppercase hex.
   *
   * @param {string} input
   * @param {(value: string) => boolean} isAllowed
   * @returns {string}
   */
  function encodeComponent(input, isAllowed) {
    let output = "";
    for (let i = 0; i < input.length; i++) {
      const ch = input[i];
      if (ch === "%" && i + 2 < input.length) {
        const hex = input.slice(i + 1, i + 3);
        if (isHexPair(hex)) {
          output += "%" + hex.toUpperCase();
          i += 2;
          continue;
        }
      }
      if (isAllowed(ch)) output += ch;
      else {
        const code = input.charCodeAt(i);
        if (code < 128) output += BYTE_HEX[code];
        else if (code < 55296 || code > 57343) output += percentEncodeNonAscii(code);
        else if (code <= 56319 && i + 1 < input.length) {
          const low = input.charCodeAt(i + 1);
          if (low >= 56320 && low <= 57343) {
            output += percentEncodeNonAscii(65536 + ((code - 55296) << 10) + (low - 56320));
            i++;
          } else output += percentEncodeNonAscii(65533);
        } else output += percentEncodeNonAscii(65533);
      }
    }
    return output;
  }
  /**
   * Encodes userinfo while preserving its RFC 3986 §3.2.1 literal characters.
   * In particular, authority delimiters such as `@`, `/`, `?`, and `#` are data.
   *
   * @param {string} input
   * @returns {string}
   */
  function encodeUserinfo(input) {
    return encodeComponent(input, isUserinfoCharacter);
  }
  /**
   * Encodes query data using the RFC 3986 §3.4 grammar. A literal `#` must be
   * escaped because it would otherwise begin the fragment component.
   *
   * @param {string} input
   * @returns {string}
   */
  function encodeQuery(input) {
    return encodeComponent(input, isQueryFragmentCharacter);
  }
  /**
   * Encodes fragment data using the RFC 3986 §3.5 grammar.
   *
   * @param {string} input
   * @returns {string}
   */
  function encodeFragment(input) {
    return encodeComponent(input, isQueryFragmentCharacter);
  }
  function isEscapeSafe(cp) {
    return (
      (cp >= 48 && cp <= 57) ||
      (cp >= 65 && cp <= 90) ||
      (cp >= 97 && cp <= 122) ||
      cp === 42 ||
      cp === 43 ||
      cp === 45 ||
      cp === 46 ||
      cp === 47 ||
      cp === 64 ||
      cp === 95
    );
  }
  /**
   * Normalizes the percent-encoding of a query or fragment component.
   *
   * Like `normalizePathEncoding`, but uses the query/fragment character set
   * (which additionally allows `?`) and decodes `.` since it has no dot-segment
   * meaning outside of a path.
   *
   * @param {string} input
   * @returns {string}
   */
  function normalizeQueryFragmentEncoding(input) {
    let output = "";
    for (let i = 0; i < input.length; i++) {
      const ch = input[i];
      if (ch === "%" && i + 2 < input.length) {
        const hex = input.slice(i + 1, i + 3);
        if (isHexPair(hex)) {
          const normalizedHex = hex.toUpperCase();
          const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
          if (isUnreserved(decoded)) output += decoded;
          else output += "%" + normalizedHex;
          i += 2;
          continue;
        }
      }
      if (isQueryFragmentCharacter(ch)) output += ch;
      else {
        const code = input.charCodeAt(i);
        if (code < 128) output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
        else if (code < 55296 || code > 57343) output += percentEncodeNonAscii(code);
        else if (code <= 56319 && i + 1 < input.length) {
          const low = input.charCodeAt(i + 1);
          if (low >= 56320 && low <= 57343) {
            output += percentEncodeNonAscii(65536 + ((code - 55296) << 10) + (low - 56320));
            i++;
          } else output += percentEncodeNonAscii(65533);
        } else output += percentEncodeNonAscii(65533);
      }
    }
    return output;
  }
  /**
   * Escapes a component while preserving existing valid percent escapes.
   *
   * @param {string} input
   * @returns {string}
   */
  function escapePreservingEscapes(input) {
    let output = "";
    for (let i = 0; i < input.length; i++) {
      if (input[i] === "%" && i + 2 < input.length) {
        const hex = input.slice(i + 1, i + 3);
        if (isHexPair(hex)) {
          output += "%" + hex.toUpperCase();
          i += 2;
          continue;
        }
      }
      output += escape(input[i]);
    }
    return output;
  }
  /**
   * @param {import('../types/index').URIComponent} component
   * @returns {string|undefined}
   */
  function recomposeAuthority(component) {
    const uriTokens = [];
    if (component.userinfo !== void 0) {
      uriTokens.push(encodeUserinfo(component.userinfo));
      uriTokens.push("@");
    }
    if (component.host !== void 0) {
      let host = component.host;
      if (!isIPv4(host)) {
        let ipV6res = normalizeIPv6(host);
        if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
          host = normalizePercentEncoding(host, true);
          ipV6res = normalizeIPv6(host);
        }
        if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true)
          host = `[${ipV6res.escapedHost}]`;
        else host = reescapeHostDelimiters(host, false);
      }
      uriTokens.push(host);
    }
    if (typeof component.port === "number" || typeof component.port === "string") {
      const port = String(component.port);
      if (!isPort(port)) throw new TypeError("URI port is malformed.");
      uriTokens.push(":");
      uriTokens.push(port);
    }
    return uriTokens.length ? uriTokens.join("") : void 0;
  }
  module.exports = {
    nonSimpleDomain,
    recomposeAuthority,
    reescapeHostDelimiters,
    normalizePercentEncoding,
    normalizePathEncoding,
    serializePathEncoding,
    normalizeQueryFragmentEncoding,
    encodeUserinfo,
    encodeQuery,
    encodeFragment,
    escapePreservingEscapes,
    removeDotSegments,
    isIPv4,
    isUUID,
    normalizeIPv6,
    stringArrayToHexStripped,
  };
});
//#endregion
//#region ../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/lib/schemes.js
var require_schemes = /* @__PURE__ */ __commonJSMin((exports, module) => {
  const { isUUID } = require_utils();
  const URN_REG = /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
  const supportedSchemeNames = ["http", "https", "ws", "wss", "urn", "urn:uuid"];
  /** @typedef {supportedSchemeNames[number]} SchemeName */
  /**
   * @param {string} name
   * @returns {name is SchemeName}
   */
  function isValidSchemeName(name) {
    return supportedSchemeNames.indexOf(name) !== -1;
  }
  /**
   * @callback SchemeFn
   * @param {import('../types/index').URIComponent} component
   * @param {import('../types/index').Options} options
   * @returns {import('../types/index').URIComponent}
   */
  /**
   * @typedef {Object} SchemeHandler
   * @property {SchemeName} scheme - The scheme name.
   * @property {boolean} [domainHost] - Indicates if the scheme supports domain hosts.
   * @property {SchemeFn} parse - Function to parse the URI component for this scheme.
   * @property {SchemeFn} serialize - Function to serialize the URI component for this scheme.
   * @property {boolean} [skipNormalize] - Indicates if normalization should be skipped for this scheme.
   * @property {boolean} [absolutePath] - Indicates if the scheme uses absolute paths.
   * @property {boolean} [unicodeSupport] - Indicates if the scheme supports Unicode.
   */
  /**
   * @param {import('../types/index').URIComponent} wsComponent
   * @returns {boolean}
   */
  function wsIsSecure(wsComponent) {
    if (wsComponent.secure === true) return true;
    else if (wsComponent.secure === false) return false;
    else if (wsComponent.scheme)
      return (
        wsComponent.scheme.length === 3 &&
        (wsComponent.scheme[0] === "w" || wsComponent.scheme[0] === "W") &&
        (wsComponent.scheme[1] === "s" || wsComponent.scheme[1] === "S") &&
        (wsComponent.scheme[2] === "s" || wsComponent.scheme[2] === "S")
      );
    else return false;
  }
  /** @type {SchemeFn} */
  function httpParse(component) {
    if (!component.host) component.error = component.error || "HTTP URIs must have a host.";
    return component;
  }
  /** @type {SchemeFn} */
  function httpSerialize(component) {
    const secure = String(component.scheme).toLowerCase() === "https";
    if (component.port === (secure ? 443 : 80) || component.port === "") component.port = void 0;
    if (!component.path) component.path = "/";
    return component;
  }
  /** @type {SchemeFn} */
  function wsParse(wsComponent) {
    wsComponent.secure = wsIsSecure(wsComponent);
    wsComponent.resourceName =
      (wsComponent.path || "/") + (wsComponent.query ? "?" + wsComponent.query : "");
    wsComponent.path = void 0;
    wsComponent.query = void 0;
    return wsComponent;
  }
  /** @type {SchemeFn} */
  function wsSerialize(wsComponent) {
    if (wsComponent.port === (wsIsSecure(wsComponent) ? 443 : 80) || wsComponent.port === "")
      wsComponent.port = void 0;
    if (typeof wsComponent.secure === "boolean") {
      wsComponent.scheme = wsComponent.secure ? "wss" : "ws";
      wsComponent.secure = void 0;
    }
    if (wsComponent.resourceName) {
      const queryIndex = wsComponent.resourceName.indexOf("?");
      const path =
        queryIndex === -1
          ? wsComponent.resourceName
          : wsComponent.resourceName.slice(0, queryIndex);
      wsComponent.path = path && path !== "/" ? path : void 0;
      wsComponent.query =
        queryIndex === -1 ? void 0 : wsComponent.resourceName.slice(queryIndex + 1);
      wsComponent.resourceName = void 0;
    }
    wsComponent.fragment = void 0;
    return wsComponent;
  }
  /** @type {SchemeFn} */
  function urnParse(urnComponent, options) {
    if (!urnComponent.path) {
      urnComponent.error = "URN can not be parsed";
      return urnComponent;
    }
    const matches = urnComponent.path.match(URN_REG);
    if (matches && matches[0] === urnComponent.path) {
      const scheme = options.scheme || urnComponent.scheme || "urn";
      urnComponent.nid = matches[1].toLowerCase();
      urnComponent.nss = matches[2];
      const schemeHandler = getSchemeHandler(`${scheme}:${options.nid || urnComponent.nid}`);
      urnComponent.path = void 0;
      if (schemeHandler) urnComponent = schemeHandler.parse(urnComponent, options);
    } else urnComponent.error = urnComponent.error || "URN can not be parsed.";
    return urnComponent;
  }
  /** @type {SchemeFn} */
  function urnSerialize(urnComponent, options) {
    if (urnComponent.nid === void 0) throw new Error("URN without nid cannot be serialized");
    const scheme = options.scheme || urnComponent.scheme || "urn";
    const nid = urnComponent.nid.toLowerCase();
    const schemeHandler = getSchemeHandler(`${scheme}:${options.nid || nid}`);
    if (schemeHandler) urnComponent = schemeHandler.serialize(urnComponent, options);
    const uriComponent = urnComponent;
    const nss = urnComponent.nss;
    uriComponent.path = `${nid || options.nid}:${nss}`;
    options.skipEscape = true;
    return uriComponent;
  }
  /** @type {SchemeFn} */
  function urnuuidParse(urnComponent, options) {
    const uuidComponent = urnComponent;
    uuidComponent.uuid = uuidComponent.nss;
    uuidComponent.nss = void 0;
    if (!options.tolerant && (!uuidComponent.uuid || !isUUID(uuidComponent.uuid)))
      uuidComponent.error = uuidComponent.error || "UUID is not valid.";
    return uuidComponent;
  }
  /** @type {SchemeFn} */
  function urnuuidSerialize(uuidComponent) {
    const urnComponent = uuidComponent;
    urnComponent.nss = (uuidComponent.uuid || "").toLowerCase();
    return urnComponent;
  }
  const http = {
    scheme: "http",
    domainHost: true,
    parse: httpParse,
    serialize: httpSerialize,
  };
  const https = {
    scheme: "https",
    domainHost: http.domainHost,
    parse: httpParse,
    serialize: httpSerialize,
  };
  const ws = {
    scheme: "ws",
    domainHost: true,
    parse: wsParse,
    serialize: wsSerialize,
  };
  const SCHEMES = {
    http,
    https,
    ws,
    wss: {
      scheme: "wss",
      domainHost: ws.domainHost,
      parse: ws.parse,
      serialize: ws.serialize,
    },
    urn: {
      scheme: "urn",
      parse: urnParse,
      serialize: urnSerialize,
      skipNormalize: true,
    },
    "urn:uuid": {
      scheme: "urn:uuid",
      parse: urnuuidParse,
      serialize: urnuuidSerialize,
      skipNormalize: true,
    },
  };
  Object.setPrototypeOf(SCHEMES, null);
  /**
   * @param {string|undefined} scheme
   * @returns {SchemeHandler|undefined}
   */
  function getSchemeHandler(scheme) {
    return (scheme && (SCHEMES[scheme] || SCHEMES[scheme.toLowerCase()])) || void 0;
  }
  module.exports = {
    wsIsSecure,
    SCHEMES,
    isValidSchemeName,
    getSchemeHandler,
  };
});
//#endregion
//#region ../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/index.js
var require_fast_uri = /* @__PURE__ */ __commonJSMin((exports, module) => {
  const {
    normalizeIPv6,
    removeDotSegments,
    recomposeAuthority,
    normalizePercentEncoding,
    normalizePathEncoding,
    serializePathEncoding,
    normalizeQueryFragmentEncoding,
    encodeQuery,
    encodeFragment,
    reescapeHostDelimiters,
    isIPv4,
    nonSimpleDomain,
  } = require_utils();
  const { SCHEMES, getSchemeHandler } = require_schemes();
  const VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
  const MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
  /**
   * @param {string} scheme
   * @returns {string}
   */
  function decodeValidScheme(scheme) {
    const decodedScheme = unescape(String(scheme));
    if (!VALID_SCHEME.test(decodedScheme)) throw new TypeError(MALFORMED_SCHEME_ERROR);
    return decodedScheme;
  }
  /**
   * @template {import('./types/index').URIComponent|string} T
   * @param {T} uri
   * @param {import('./types/index').Options} [options]
   * @returns {T}
   */
  function normalize(uri, options) {
    if (typeof uri === "string") uri = normalizeString(uri, options);
    else if (typeof uri === "object") uri = parse(serialize(uri, options), options);
    return uri;
  }
  /**
   * @param {string} baseURI
   * @param {string} relativeURI
   * @param {import('./types/index').Options} [options]
   * @returns {string}
   */
  function resolve(baseURI, relativeURI, options) {
    const schemelessOptions = options
      ? Object.assign({ scheme: "null" }, options)
      : { scheme: "null" };
    const {
      parsed: baseParsed,
      malformedAuthorityOrPort: baseMalformed,
      malformedPercentEncoding: baseMalformedPercentEncoding,
      malformedSchemeSpecific: baseMalformedSchemeSpecific,
      malformedHost: baseMalformedHost,
      malformedScheme: baseMalformedScheme,
    } = parseWithStatus(baseURI, schemelessOptions);
    const {
      parsed: relativeParsed,
      malformedAuthorityOrPort: relativeMalformed,
      malformedPercentEncoding: relativeMalformedPercentEncoding,
      malformedSchemeSpecific: relativeMalformedSchemeSpecific,
      malformedHost: relativeMalformedHost,
      malformedScheme: relativeMalformedScheme,
    } = parseWithStatus(relativeURI, schemelessOptions);
    if (
      baseMalformed ||
      relativeMalformed ||
      baseMalformedPercentEncoding ||
      relativeMalformedPercentEncoding ||
      baseMalformedSchemeSpecific ||
      relativeMalformedSchemeSpecific ||
      baseMalformedHost ||
      relativeMalformedHost ||
      baseMalformedScheme ||
      relativeMalformedScheme
    )
      throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
    const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
    const resolvedSchemeHandler = getSchemeHandler((options && options.scheme) || resolved.scheme);
    const resolvedHost = resolved.host;
    const resolvedHostIsIP =
      resolvedHost !== void 0 &&
      resolvedHost !== "" &&
      (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
    canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
    const encodedASCIIHost =
      resolvedHost && resolvedHost.indexOf("%") !== -1 && !/\P{ASCII}/u.test(resolvedHost);
    if (resolved.error && !encodedASCIIHost) throw new Error(resolved.error);
    schemelessOptions.skipEscape = true;
    return serialize(resolved, schemelessOptions);
  }
  /**
   * @param {import ('./types/index').URIComponent} base
   * @param {import ('./types/index').URIComponent} relative
   * @param {import('./types/index').Options} [options]
   * @param {boolean} [skipNormalization=false]
   * @returns {import ('./types/index').URIComponent}
   */
  function resolveComponent(base, relative, options, skipNormalization) {
    /** @type {import('./types/index').URIComponent} */
    const target = {};
    if (!skipNormalization) {
      base = parse(serialize(base, options), options);
      relative = parse(serialize(relative, options), options);
    }
    options = options || {};
    if (!options.tolerant && relative.scheme) {
      target.scheme = relative.scheme;
      target.userinfo = relative.userinfo;
      target.host = relative.host;
      target.port = relative.port;
      target.path = removeDotSegments(relative.path || "");
      target.query = relative.query;
    } else {
      if (relative.userinfo !== void 0 || relative.host !== void 0 || relative.port !== void 0) {
        target.userinfo = relative.userinfo;
        target.host = relative.host;
        target.port = relative.port;
        target.path = removeDotSegments(relative.path || "");
        target.query = relative.query;
      } else {
        if (!relative.path) {
          target.path = base.path;
          if (relative.query !== void 0) target.query = relative.query;
          else target.query = base.query;
        } else {
          if (relative.path[0] === "/") target.path = removeDotSegments(relative.path);
          else {
            if (
              (base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) &&
              !base.path
            )
              target.path = "/" + relative.path;
            else if (!base.path) target.path = relative.path;
            else target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
            target.path = removeDotSegments(target.path);
          }
          target.query = relative.query;
        }
        target.userinfo = base.userinfo;
        target.host = base.host;
        target.port = base.port;
      }
      target.scheme = base.scheme;
    }
    target.fragment = relative.fragment;
    return target;
  }
  /**
   * @param {import ('./types/index').URIComponent|string} uriA
   * @param {import ('./types/index').URIComponent|string} uriB
   * @param {import ('./types/index').Options} options
   * @returns {boolean}
   */
  function equal(uriA, uriB, options) {
    const normalizedA = normalizeComparableURI(uriA, options);
    const normalizedB = normalizeComparableURI(uriB, options);
    return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA === normalizedB;
  }
  /**
   * @param {Readonly<import('./types/index').URIComponent>} cmpts
   * @param {import('./types/index').Options} [opts]
   * @returns {string}
   */
  function serialize(cmpts, opts) {
    const component = {
      host: cmpts.host,
      scheme: cmpts.scheme,
      userinfo: cmpts.userinfo,
      port: cmpts.port,
      path: cmpts.path,
      query: cmpts.query,
      nid: cmpts.nid,
      nss: cmpts.nss,
      uuid: cmpts.uuid,
      fragment: cmpts.fragment,
      reference: cmpts.reference,
      resourceName: cmpts.resourceName,
      secure: cmpts.secure,
      error: "",
    };
    const options = Object.assign({}, opts);
    const uriTokens = [];
    if (component.scheme) component.scheme = decodeValidScheme(component.scheme);
    const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
    if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
    const hasAuthority =
      component.userinfo !== void 0 || component.host !== void 0 || component.port !== void 0;
    const pathNoScheme = !options.skipEscape && component.scheme === void 0 && !hasAuthority;
    if (component.path !== void 0) {
      if (!options.skipEscape) component.path = serializePathEncoding(component.path, pathNoScheme);
      else component.path = normalizePercentEncoding(component.path);
    }
    if (options.reference !== "suffix" && component.scheme) {
      component.scheme = decodeValidScheme(component.scheme);
      uriTokens.push(component.scheme, ":");
    }
    const authority = recomposeAuthority(component);
    if (authority !== void 0) {
      if (options.reference !== "suffix") uriTokens.push("//");
      uriTokens.push(authority);
      if (component.path && component.path[0] !== "/") uriTokens.push("/");
    }
    if (component.path !== void 0) {
      let s = component.path;
      if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath))
        s = removeDotSegments(s);
      if (pathNoScheme) s = serializePathEncoding(s, true);
      if (authority === void 0 && s[0] === "/" && s[1] === "/") s = "/%2F" + s.slice(2);
      uriTokens.push(s);
    }
    if (component.query !== void 0) uriTokens.push("?", encodeQuery(component.query));
    if (component.fragment !== void 0) uriTokens.push("#", encodeFragment(component.fragment));
    return uriTokens.join("");
  }
  const URI_PARSE =
    /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
  const AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
  const AUTHORITY_INTRODUCER_REGION = /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/;
  /**
   * @param {import('./types/index').URIComponent} parsed
   * @param {RegExpMatchArray} matches
   * @returns {string|undefined}
   */
  function getParseError(parsed, matches) {
    if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/")
      return 'URI path must start with "/" when authority is present.';
    if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535))
      return "URI port is malformed.";
  }
  /**
   * Checks percent syntax without decoding the represented octets. RFC 3986
   * percent-encoding is byte-oriented, so sequences such as `%FF` are valid even
   * though they are not independently valid UTF-8.
   *
   * @param {string|undefined} component
   * @returns {boolean}
   */
  function hasMalformedPercentEncoding(component) {
    if (component === void 0) return false;
    let percent = component.indexOf("%");
    while (percent !== -1) {
      if (
        percent + 2 >= component.length ||
        !/^[\da-f]{2}$/iu.test(component.slice(percent + 1, percent + 3))
      )
        return true;
      percent = component.indexOf("%", percent + 3);
    }
    return false;
  }
  /**
   * Whether the host is a bracketed IP literal (RFC 3986 `IP-literal`).
   * An unterminated `[` is not a literal, so it must still be validated as a
   * reg-name instead of being waved through as an IP.
   *
   * @param {string} host
   * @returns {boolean}
   */
  function isIPLiteral(host) {
    return host[0] === "[" && host[host.length - 1] === "]";
  }
  /**
   * @param {RegExpMatchArray} matches
   * @returns {boolean}
   */
  function hasMalformedComponentPercentEncoding(matches) {
    const host = matches[4];
    return (
      hasMalformedPercentEncoding(matches[3]) ||
      (host !== void 0 && !isIPLiteral(host) && hasMalformedPercentEncoding(host)) ||
      hasMalformedPercentEncoding(matches[6]) ||
      hasMalformedPercentEncoding(matches[7]) ||
      hasMalformedPercentEncoding(matches[8])
    );
  }
  /**
   * @param {import('./types/index').URIComponent} parsed
   * @param {import('./types/index').Options} options
   * @param {{ domainHost?: boolean, unicodeSupport?: boolean }|undefined} schemeHandler
   * @param {boolean} isIP
   * @returns {boolean} whether host conversion failed
   */
  function canonicalizeHost(parsed, options, schemeHandler, isIP) {
    if (
      !options.unicodeSupport &&
      (!schemeHandler || !schemeHandler.unicodeSupport) &&
      parsed.host &&
      !isIPLiteral(parsed.host) &&
      (options.domainHost || (schemeHandler && schemeHandler.domainHost)) &&
      isIP === false &&
      nonSimpleDomain(parsed.host)
    )
      try {
        parsed.host = new URL("http://" + parsed.host).hostname;
      } catch (e) {
        parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
        return true;
      }
    return false;
  }
  /**
   * @param {string} uri
   * @param {import('./types/index').Options} [opts]
   * @returns {{ parsed: import('./types/index').URIComponent, malformedAuthorityOrPort: boolean, malformedPercentEncoding: boolean, malformedSchemeSpecific: boolean, malformedHost: boolean, malformedScheme: boolean }}
   */
  function parseWithStatus(uri, opts) {
    const options = Object.assign({}, opts);
    /** @type {import('./types/index').URIComponent} */
    const parsed = {
      scheme: void 0,
      userinfo: void 0,
      host: "",
      port: void 0,
      path: "",
      query: void 0,
      fragment: void 0,
    };
    let malformedAuthorityOrPort = false;
    let malformedPercentEncoding = false;
    let malformedSchemeSpecific = false;
    let malformedHost = false;
    let malformedIPLiteral = false;
    let malformedScheme = false;
    let isIP = false;
    if (options.reference === "suffix") {
      if (options.scheme) uri = options.scheme + ":" + uri;
      else uri = "//" + uri;
    }
    const authorityMatch = uri.match(AUTHORITY_PREFIX);
    if (authorityMatch !== null && authorityMatch[1].indexOf("\\") !== -1) {
      parsed.error = "URI authority must not contain a literal backslash.";
      malformedAuthorityOrPort = true;
    }
    const introducerMatch = uri.match(AUTHORITY_INTRODUCER_REGION);
    if (introducerMatch !== null) {
      const region = introducerMatch[1];
      const normalizedRegion = region.replace(/[\t\n\r]/g, "");
      if (normalizedRegion.length >= 2) {
        if (normalizedRegion.slice(0, 2) !== "//") {
          parsed.error = parsed.error || "URI authority must not contain a literal backslash.";
          malformedAuthorityOrPort = true;
        } else if (region.length !== normalizedRegion.length) {
          parsed.error = parsed.error || "URI authority introducer must not contain whitespace.";
          malformedAuthorityOrPort = true;
        }
      }
    }
    const matches = uri.match(URI_PARSE);
    if (matches) {
      parsed.scheme = matches[1];
      parsed.userinfo = matches[3];
      parsed.host = matches[4];
      parsed.port = parseInt(matches[5], 10);
      parsed.path = matches[6] || "";
      parsed.query = matches[7];
      parsed.fragment = matches[8];
      if (parsed.scheme !== void 0) {
        const decodedScheme = unescape(parsed.scheme);
        if (VALID_SCHEME.test(decodedScheme)) parsed.scheme = decodedScheme.toLowerCase();
        else {
          parsed.error = parsed.error || MALFORMED_SCHEME_ERROR;
          malformedScheme = true;
        }
      }
      malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches);
      if (malformedPercentEncoding)
        parsed.error = parsed.error || "URI contains malformed percent-encoding.";
      if (isNaN(parsed.port)) parsed.port = matches[5];
      const parseError = getParseError(parsed, matches);
      if (parseError !== void 0) {
        parsed.error = parsed.error || parseError;
        malformedAuthorityOrPort = true;
      }
      if (parsed.host) {
        if (isIPv4(parsed.host) === false) {
          const bracketedIPLiteral = isIPLiteral(parsed.host);
          const hasIPLiteralBracket =
            parsed.host.indexOf("[") !== -1 || parsed.host.indexOf("]") !== -1;
          const ipv6result = normalizeIPv6(parsed.host);
          isIP = ipv6result.isIPV6 || ipv6result.isIPVFuture === true;
          malformedIPLiteral =
            hasIPLiteralBracket && (!bracketedIPLiteral || ipv6result.error === true);
          parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase();
          if (malformedIPLiteral) {
            parsed.error = parsed.error || "URI host is malformed.";
            malformedAuthorityOrPort = true;
          }
        } else isIP = true;
      }
      if (
        parsed.scheme === void 0 &&
        parsed.userinfo === void 0 &&
        parsed.host === void 0 &&
        parsed.port === void 0 &&
        parsed.query === void 0 &&
        !parsed.path
      )
        parsed.reference = "same-document";
      else if (parsed.scheme === void 0) parsed.reference = "relative";
      else if (parsed.fragment === void 0) parsed.reference = "absolute";
      else parsed.reference = "uri";
      if (
        options.reference &&
        options.reference !== "suffix" &&
        options.reference !== parsed.reference
      )
        parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
      const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
      if (!malformedIPLiteral)
        malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
      if (uri.indexOf("%") !== -1 && parsed.host !== void 0 && !malformedIPLiteral) {
        let host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
        if (!isIP) host = normalizePercentEncoding(host.toLowerCase());
        parsed.host = reescapeHostDelimiters(host, isIP);
      }
      if (!schemeHandler || (schemeHandler && !schemeHandler.skipNormalize)) {
        if (parsed.path) parsed.path = normalizePathEncoding(parsed.path);
        if (parsed.query) parsed.query = normalizeQueryFragmentEncoding(parsed.query);
        if (parsed.fragment) parsed.fragment = normalizeQueryFragmentEncoding(parsed.fragment);
      }
      if (schemeHandler && schemeHandler.parse) {
        schemeHandler.parse(parsed, options);
        if (schemeHandler === SCHEMES.urn && parsed.nid === void 0) malformedSchemeSpecific = true;
      }
    } else parsed.error = parsed.error || "URI can not be parsed.";
    return {
      parsed,
      malformedAuthorityOrPort,
      malformedPercentEncoding,
      malformedSchemeSpecific,
      malformedHost,
      malformedScheme,
    };
  }
  /**
   * @param {string} uri
   * @param {import('./types/index').Options} [opts]
   * @returns
   */
  function parse(uri, opts) {
    return parseWithStatus(uri, opts).parsed;
  }
  /**
   * @param {string} uri
   * @param {import('./types/index').Options} [opts]
   * @returns {string}
   */
  function normalizeString(uri, opts) {
    return normalizeStringWithStatus(uri, opts).normalized;
  }
  /**
   * @param {string} uri
   * @param {import('./types/index').Options} [opts]
   * @returns {{ normalized: string, malformedAuthorityOrPort: boolean, malformedPercentEncoding: boolean, malformedSchemeSpecific: boolean, malformedHost: boolean, malformedScheme: boolean }}
   */
  function normalizeStringWithStatus(uri, opts) {
    const {
      parsed,
      malformedAuthorityOrPort,
      malformedPercentEncoding,
      malformedSchemeSpecific,
      malformedHost,
      malformedScheme,
    } = parseWithStatus(uri, opts);
    return {
      normalized:
        malformedAuthorityOrPort ||
        malformedPercentEncoding ||
        malformedSchemeSpecific ||
        malformedHost ||
        malformedScheme
          ? uri
          : serialize(parsed, opts),
      malformedAuthorityOrPort,
      malformedPercentEncoding,
      malformedSchemeSpecific,
      malformedHost,
      malformedScheme,
    };
  }
  /**
   * @param {import ('./types/index').URIComponent|string} uri
   * @param {import('./types/index').Options} [opts]
   * @returns {string|undefined}
   */
  function normalizeComparableURI(uri, opts) {
    if (typeof uri !== "string" && typeof uri !== "object") return;
    let value;
    try {
      value = typeof uri === "string" ? uri : serialize(uri, opts);
    } catch {
      return;
    }
    const {
      normalized,
      malformedAuthorityOrPort,
      malformedPercentEncoding,
      malformedSchemeSpecific,
      malformedHost,
      malformedScheme,
    } = normalizeStringWithStatus(value, opts);
    return malformedAuthorityOrPort ||
      malformedPercentEncoding ||
      malformedSchemeSpecific ||
      malformedHost ||
      malformedScheme
      ? void 0
      : normalized;
  }
  const fastUri = {
    SCHEMES,
    normalize,
    resolve,
    resolveComponent,
    equal,
    serialize,
    parse,
  };
  module.exports = fastUri;
  module.exports.default = fastUri;
  module.exports.fastUri = fastUri;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/uri.js
var require_uri = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const uri = require_fast_uri();
  uri.code = 'require("ajv/dist/runtime/uri").default';
  exports.default = uri;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/core.js
var require_core$1 = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.CodeGen =
    exports.Name =
    exports.nil =
    exports.stringify =
    exports.str =
    exports._ =
    exports.KeywordCxt =
      void 0;
  var validate_1 = require_validate();
  Object.defineProperty(exports, "KeywordCxt", {
    enumerable: true,
    get: function () {
      return validate_1.KeywordCxt;
    },
  });
  var codegen_1 = require_codegen();
  Object.defineProperty(exports, "_", {
    enumerable: true,
    get: function () {
      return codegen_1._;
    },
  });
  Object.defineProperty(exports, "str", {
    enumerable: true,
    get: function () {
      return codegen_1.str;
    },
  });
  Object.defineProperty(exports, "stringify", {
    enumerable: true,
    get: function () {
      return codegen_1.stringify;
    },
  });
  Object.defineProperty(exports, "nil", {
    enumerable: true,
    get: function () {
      return codegen_1.nil;
    },
  });
  Object.defineProperty(exports, "Name", {
    enumerable: true,
    get: function () {
      return codegen_1.Name;
    },
  });
  Object.defineProperty(exports, "CodeGen", {
    enumerable: true,
    get: function () {
      return codegen_1.CodeGen;
    },
  });
  const validation_error_1 = require_validation_error();
  const ref_error_1 = require_ref_error();
  const rules_1 = require_rules();
  const compile_1 = require_compile();
  const codegen_2 = require_codegen();
  const resolve_1 = require_resolve();
  const dataType_1 = require_dataType();
  const util_1 = require_util();
  const $dataRefSchema = require_data();
  const uri_1 = require_uri();
  const defaultRegExp = (str, flags) => new RegExp(str, flags);
  defaultRegExp.code = "new RegExp";
  const META_IGNORE_OPTIONS = ["removeAdditional", "useDefaults", "coerceTypes"];
  const EXT_SCOPE_NAMES = /* @__PURE__ */ new Set([
    "validate",
    "serialize",
    "parse",
    "wrapper",
    "root",
    "schema",
    "keyword",
    "pattern",
    "formats",
    "validate$data",
    "func",
    "obj",
    "Error",
  ]);
  const 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.",
  };
  const deprecatedOptions = {
    ignoreKeywordsWithRef: "",
    jsPropertySyntax: "",
    unicode: '"minLength"/"maxLength" account for unicode characters by default.',
  };
  const MAX_EXPRESSION = 200;
  function requiredOptions(o) {
    var _a,
      _b,
      _c,
      _d,
      _e,
      _f,
      _g,
      _h,
      _j,
      _k,
      _l,
      _m,
      _o,
      _p,
      _q,
      _r,
      _s,
      _t,
      _u,
      _v,
      _w,
      _x,
      _y,
      _z,
      _0;
    const s = o.strict;
    const _optz = (_a = o.code) === null || _a === void 0 ? void 0 : _a.optimize;
    const optimize = _optz === true || _optz === void 0 ? 1 : _optz || 0;
    const regExp =
      (_c = (_b = o.code) === null || _b === void 0 ? void 0 : _b.regExp) !== null && _c !== void 0
        ? _c
        : defaultRegExp;
    const uriResolver = (_d = o.uriResolver) !== null && _d !== void 0 ? _d : uri_1.default;
    return {
      strictSchema:
        (_f = (_e = o.strictSchema) !== null && _e !== void 0 ? _e : s) !== null && _f !== void 0
          ? _f
          : true,
      strictNumbers:
        (_h = (_g = o.strictNumbers) !== null && _g !== void 0 ? _g : s) !== null && _h !== void 0
          ? _h
          : true,
      strictTypes:
        (_k = (_j = o.strictTypes) !== null && _j !== void 0 ? _j : s) !== null && _k !== void 0
          ? _k
          : "log",
      strictTuples:
        (_m = (_l = o.strictTuples) !== null && _l !== void 0 ? _l : s) !== null && _m !== void 0
          ? _m
          : "log",
      strictRequired:
        (_p = (_o = o.strictRequired) !== null && _o !== void 0 ? _o : s) !== null && _p !== void 0
          ? _p
          : false,
      code: o.code
        ? {
            ...o.code,
            optimize,
            regExp,
          }
        : {
            optimize,
            regExp,
          },
      loopRequired: (_q = o.loopRequired) !== null && _q !== void 0 ? _q : MAX_EXPRESSION,
      loopEnum: (_r = o.loopEnum) !== null && _r !== void 0 ? _r : MAX_EXPRESSION,
      meta: (_s = o.meta) !== null && _s !== void 0 ? _s : true,
      messages: (_t = o.messages) !== null && _t !== void 0 ? _t : true,
      inlineRefs: (_u = o.inlineRefs) !== null && _u !== void 0 ? _u : true,
      schemaId: (_v = o.schemaId) !== null && _v !== void 0 ? _v : "$id",
      addUsedSchema: (_w = o.addUsedSchema) !== null && _w !== void 0 ? _w : true,
      validateSchema: (_x = o.validateSchema) !== null && _x !== void 0 ? _x : true,
      validateFormats: (_y = o.validateFormats) !== null && _y !== void 0 ? _y : true,
      unicodeRegExp: (_z = o.unicodeRegExp) !== null && _z !== void 0 ? _z : true,
      int32range: (_0 = o.int32range) !== null && _0 !== void 0 ? _0 : true,
      uriResolver,
    };
  }
  var Ajv = class {
    constructor(opts = {}) {
      this.schemas = {};
      this.refs = {};
      this.formats = Object.create(null);
      this._compilations = /* @__PURE__ */ new Set();
      this._loading = {};
      this._cache = /* @__PURE__ */ new Map();
      opts = this.opts = {
        ...opts,
        ...requiredOptions(opts),
      };
      const { es5, lines } = this.opts.code;
      this.scope = new codegen_2.ValueScope({
        scope: {},
        prefixes: EXT_SCOPE_NAMES,
        es5,
        lines,
      });
      this.logger = getLogger(opts.logger);
      const formatOpt = opts.validateFormats;
      opts.validateFormats = false;
      this.RULES = (0, rules_1.getRules)();
      checkOptions.call(this, removedOptions, opts, "NOT SUPPORTED");
      checkOptions.call(this, deprecatedOptions, opts, "DEPRECATED", "warn");
      this._metaOpts = getMetaSchemaOptions.call(this);
      if (opts.formats) addInitialFormats.call(this);
      this._addVocabularies();
      this._addDefaultMetaSchema();
      if (opts.keywords) addInitialKeywords.call(this, opts.keywords);
      if (typeof opts.meta == "object") this.addMetaSchema(opts.meta);
      addInitialSchemas.call(this);
      opts.validateFormats = formatOpt;
    }
    _addVocabularies() {
      this.addKeyword("$async");
    }
    _addDefaultMetaSchema() {
      const { $data, meta, schemaId } = this.opts;
      let _dataRefSchema = $dataRefSchema;
      if (schemaId === "id") {
        _dataRefSchema = { ...$dataRefSchema };
        _dataRefSchema.id = _dataRefSchema.$id;
        delete _dataRefSchema.$id;
      }
      if (meta && $data) this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false);
    }
    defaultMeta() {
      const { meta, schemaId } = this.opts;
      return (this.opts.defaultMeta = typeof meta == "object" ? meta[schemaId] || meta : void 0);
    }
    validate(schemaKeyRef, data) {
      let v;
      if (typeof schemaKeyRef == "string") {
        v = this.getSchema(schemaKeyRef);
        if (!v) throw new Error(`no schema with key or ref "${schemaKeyRef}"`);
      } else v = this.compile(schemaKeyRef);
      const valid = v(data);
      if (!("$async" in v)) this.errors = v.errors;
      return valid;
    }
    compile(schema, _meta) {
      const sch = this._addSchema(schema, _meta);
      return sch.validate || this._compileSchemaEnv(sch);
    }
    compileAsync(schema, meta) {
      if (typeof this.opts.loadSchema != "function")
        throw new Error("options.loadSchema should be a function");
      const { loadSchema } = this.opts;
      return runCompileAsync.call(this, schema, meta);
      async function runCompileAsync(_schema, _meta) {
        await loadMetaSchema.call(this, _schema.$schema);
        const sch = this._addSchema(_schema, _meta);
        return sch.validate || _compileAsync.call(this, sch);
      }
      async function loadMetaSchema($ref) {
        if ($ref && !this.getSchema($ref)) await runCompileAsync.call(this, { $ref }, true);
      }
      async function _compileAsync(sch) {
        try {
          return this._compileSchemaEnv(sch);
        } catch (e) {
          if (!(e instanceof ref_error_1.default)) throw e;
          checkLoaded.call(this, e);
          await loadMissingSchema.call(this, e.missingSchema);
          return _compileAsync.call(this, sch);
        }
      }
      function checkLoaded({ missingSchema: ref, missingRef }) {
        if (this.refs[ref])
          throw new Error(`AnySchema ${ref} is loaded but ${missingRef} cannot be resolved`);
      }
      async function loadMissingSchema(ref) {
        const _schema = await _loadSchema.call(this, ref);
        if (!this.refs[ref]) await loadMetaSchema.call(this, _schema.$schema);
        if (!this.refs[ref]) this.addSchema(_schema, ref, meta);
      }
      async function _loadSchema(ref) {
        const p = this._loading[ref];
        if (p) return p;
        try {
          return await (this._loading[ref] = loadSchema(ref));
        } finally {
          delete this._loading[ref];
        }
      }
    }
    addSchema(schema, key, _meta, _validateSchema = this.opts.validateSchema) {
      if (Array.isArray(schema)) {
        for (const sch of schema) this.addSchema(sch, void 0, _meta, _validateSchema);
        return this;
      }
      let id;
      if (typeof schema === "object") {
        const { schemaId } = this.opts;
        id = schema[schemaId];
        if (id !== void 0 && typeof id != "string")
          throw new Error(`schema ${schemaId} must be string`);
      }
      key = (0, resolve_1.normalizeId)(key || id);
      this._checkUnique(key);
      this.schemas[key] = this._addSchema(schema, _meta, key, _validateSchema, true);
      return this;
    }
    addMetaSchema(schema, key, _validateSchema = this.opts.validateSchema) {
      this.addSchema(schema, key, true, _validateSchema);
      return this;
    }
    validateSchema(schema, throwOrLogError) {
      if (typeof schema == "boolean") return true;
      let $schema;
      $schema = schema.$schema;
      if ($schema !== void 0 && typeof $schema != "string")
        throw new Error("$schema must be a string");
      $schema = $schema || this.opts.defaultMeta || this.defaultMeta();
      if (!$schema) {
        this.logger.warn("meta-schema not available");
        this.errors = null;
        return true;
      }
      const valid = this.validate($schema, schema);
      if (!valid && throwOrLogError) {
        const message = "schema is invalid: " + this.errorsText();
        if (this.opts.validateSchema === "log") this.logger.error(message);
        else throw new Error(message);
      }
      return valid;
    }
    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);
    }
    removeSchema(schemaKeyRef) {
      if (schemaKeyRef instanceof RegExp) {
        this._removeAllSchemas(this.schemas, schemaKeyRef);
        this._removeAllSchemas(this.refs, schemaKeyRef);
        return this;
      }
      switch (typeof schemaKeyRef) {
        case "undefined":
          this._removeAllSchemas(this.schemas);
          this._removeAllSchemas(this.refs);
          this._cache.clear();
          return this;
        case "string": {
          const sch = getSchEnv.call(this, schemaKeyRef);
          if (typeof sch == "object") this._cache.delete(sch.schema);
          delete this.schemas[schemaKeyRef];
          delete this.refs[schemaKeyRef];
          return this;
        }
        case "object": {
          const cacheKey = schemaKeyRef;
          this._cache.delete(cacheKey);
          let id = schemaKeyRef[this.opts.schemaId];
          if (id) {
            id = (0, resolve_1.normalizeId)(id);
            delete this.schemas[id];
            delete this.refs[id];
          }
          return this;
        }
        default:
          throw new Error("ajv.removeSchema: invalid parameter");
      }
    }
    addVocabulary(definitions) {
      for (const def of definitions) this.addKeyword(def);
      return this;
    }
    addKeyword(kwdOrDef, def) {
      let keyword;
      if (typeof kwdOrDef == "string") {
        keyword = kwdOrDef;
        if (typeof def == "object") {
          this.logger.warn("these parameters are deprecated, see docs for addKeyword");
          def.keyword = keyword;
        }
      } else if (typeof kwdOrDef == "object" && def === 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;
    }
    removeKeyword(keyword) {
      const { RULES } = this;
      delete RULES.keywords[keyword];
      delete RULES.all[keyword];
      for (const group of RULES.rules) {
        const i = group.rules.findIndex((rule) => rule.keyword === keyword);
        if (i >= 0) group.rules.splice(i, 1);
      }
      return this;
    }
    addFormat(name, format) {
      if (typeof format == "string") format = new RegExp(format);
      this.formats[name] = format;
      return this;
    }
    errorsText(errors = this.errors, { separator = ", ", dataVar = "data" } = {}) {
      if (!errors || errors.length === 0) return "No errors";
      return errors
        .map((e) => `${dataVar}${e.instancePath} ${e.message}`)
        .reduce((text, msg) => text + separator + msg);
    }
    $dataMetaSchema(metaSchema, keywordsJsonPointers) {
      const rules = this.RULES.all;
      metaSchema = JSON.parse(JSON.stringify(metaSchema));
      for (const jsonPointer of keywordsJsonPointers) {
        const segments = jsonPointer.split("/").slice(1);
        let keywords = metaSchema;
        for (const seg of segments) keywords = keywords[seg];
        for (const key in rules) {
          const rule = rules[key];
          if (typeof rule != "object") continue;
          const { $data } = rule.definition;
          const schema = keywords[key];
          if ($data && schema) keywords[key] = schemaOrData(schema);
        }
      }
      return metaSchema;
    }
    _removeAllSchemas(schemas, regex) {
      for (const keyRef in schemas) {
        const sch = schemas[keyRef];
        if (!regex || regex.test(keyRef)) {
          if (typeof sch == "string") delete schemas[keyRef];
          else if (sch && !sch.meta) {
            this._cache.delete(sch.schema);
            delete schemas[keyRef];
          }
        }
      }
    }
    _addSchema(
      schema,
      meta,
      baseId,
      validateSchema = this.opts.validateSchema,
      addSchema = this.opts.addUsedSchema,
    ) {
      let id;
      const { schemaId } = this.opts;
      if (typeof schema == "object") id = schema[schemaId];
      else if (this.opts.jtd) throw new Error("schema must be object");
      else if (typeof schema != "boolean") throw new Error("schema must be object or boolean");
      let sch = this._cache.get(schema);
      if (sch !== void 0) return sch;
      baseId = (0, resolve_1.normalizeId)(id || baseId);
      const localRefs = resolve_1.getSchemaRefs.call(this, schema, baseId);
      sch = new compile_1.SchemaEnv({
        schema,
        schemaId,
        meta,
        baseId,
        localRefs,
      });
      this._cache.set(sch.schema, sch);
      if (addSchema && !baseId.startsWith("#")) {
        if (baseId) this._checkUnique(baseId);
        this.refs[baseId] = sch;
      }
      if (validateSchema) this.validateSchema(schema, true);
      return sch;
    }
    _checkUnique(id) {
      if (this.schemas[id] || this.refs[id])
        throw new Error(`schema with key or id "${id}" already exists`);
    }
    _compileSchemaEnv(sch) {
      if (sch.meta) this._compileMetaSchema(sch);
      else compile_1.compileSchema.call(this, sch);
      /* istanbul ignore if */
      if (!sch.validate) throw new Error("ajv implementation error");
      return sch.validate;
    }
    _compileMetaSchema(sch) {
      const currentOpts = this.opts;
      this.opts = this._metaOpts;
      try {
        compile_1.compileSchema.call(this, sch);
      } finally {
        this.opts = currentOpts;
      }
    }
  };
  Ajv.ValidationError = validation_error_1.default;
  Ajv.MissingRefError = ref_error_1.default;
  exports.default = Ajv;
  function checkOptions(checkOpts, options, msg, log = "error") {
    for (const key in checkOpts) {
      const opt = key;
      if (opt in options) this.logger[log](`${msg}: option ${key}. ${checkOpts[opt]}`);
    }
  }
  function getSchEnv(keyRef) {
    keyRef = (0, resolve_1.normalizeId)(keyRef);
    return this.schemas[keyRef] || this.refs[keyRef];
  }
  function addInitialSchemas() {
    const optsSchemas = this.opts.schemas;
    if (!optsSchemas) return;
    if (Array.isArray(optsSchemas)) this.addSchema(optsSchemas);
    else for (const key in optsSchemas) this.addSchema(optsSchemas[key], key);
  }
  function addInitialFormats() {
    for (const name in this.opts.formats) {
      const format = this.opts.formats[name];
      if (format) this.addFormat(name, format);
    }
  }
  function addInitialKeywords(defs) {
    if (Array.isArray(defs)) {
      this.addVocabulary(defs);
      return;
    }
    this.logger.warn("keywords option as map is deprecated, pass array");
    for (const keyword in defs) {
      const def = defs[keyword];
      if (!def.keyword) def.keyword = keyword;
      this.addKeyword(def);
    }
  }
  function getMetaSchemaOptions() {
    const metaOpts = { ...this.opts };
    for (const opt of META_IGNORE_OPTIONS) delete metaOpts[opt];
    return metaOpts;
  }
  const 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");
  }
  const KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
  function checkKeyword(keyword, def) {
    const { RULES } = this;
    (0, util_1.eachItem)(keyword, (kwd) => {
      if (RULES.keywords[kwd]) throw new Error(`Keyword ${kwd} is already defined`);
      if (!KEYWORD_NAME.test(kwd)) throw new Error(`Keyword ${kwd} has invalid name`);
    });
    if (!def) return;
    if (def.$data && !("code" in def || "validate" in def))
      throw new Error('$data keyword must have "code" or "validate" function');
  }
  function addRule(keyword, definition, dataType) {
    var _a;
    const post = definition === null || definition === void 0 ? void 0 : definition.post;
    if (dataType && post) throw new Error('keyword with "post" flag cannot have "type"');
    const { RULES } = this;
    let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t }) => t === dataType);
    if (!ruleGroup) {
      ruleGroup = {
        type: dataType,
        rules: [],
      };
      RULES.rules.push(ruleGroup);
    }
    RULES.keywords[keyword] = true;
    if (!definition) return;
    const rule = {
      keyword,
      definition: {
        ...definition,
        type: (0, dataType_1.getJSONTypes)(definition.type),
        schemaType: (0, dataType_1.getJSONTypes)(definition.schemaType),
      },
    };
    if (definition.before) addBeforeRule.call(this, ruleGroup, rule, definition.before);
    else ruleGroup.rules.push(rule);
    RULES.all[keyword] = rule;
    (_a = definition.implements) === null ||
      _a === void 0 ||
      _a.forEach((kwd) => this.addKeyword(kwd));
  }
  function addBeforeRule(ruleGroup, rule, before) {
    const i = ruleGroup.rules.findIndex((_rule) => _rule.keyword === before);
    if (i >= 0) ruleGroup.rules.splice(i, 0, rule);
    else {
      ruleGroup.rules.push(rule);
      this.logger.warn(`rule ${before} is not defined`);
    }
  }
  function keywordMetaschema(def) {
    let { metaSchema } = def;
    if (metaSchema === void 0) return;
    if (def.$data && this.opts.$data) metaSchema = schemaOrData(metaSchema);
    def.validateSchema = this.compile(metaSchema, true);
  }
  const $dataRef = {
    $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#",
  };
  function schemaOrData(schema) {
    return { anyOf: [schema, $dataRef] };
  }
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/core/id.js
var require_id = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.default = {
    keyword: "id",
    code() {
      throw new Error('NOT SUPPORTED: keyword "id", use "$id" for schema ID');
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/core/ref.js
var require_ref = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.callRef = exports.getValidate = void 0;
  const ref_error_1 = require_ref_error();
  const code_1 = require_code();
  const codegen_1 = require_codegen();
  const names_1 = require_names();
  const compile_1 = require_compile();
  const util_1 = require_util();
  const def = {
    keyword: "$ref",
    schemaType: "string",
    code(cxt) {
      const { gen, schema: $ref, it } = cxt;
      const { baseId, schemaEnv: env, validateName, opts, self } = it;
      const { root } = env;
      if (($ref === "#" || $ref === "#/") && baseId === root.baseId) return callRootRef();
      const schOrEnv = compile_1.resolveRef.call(self, root, baseId, $ref);
      if (schOrEnv === void 0) throw new ref_error_1.default(it.opts.uriResolver, baseId, $ref);
      if (schOrEnv instanceof compile_1.SchemaEnv) return callValidate(schOrEnv);
      return inlineRefSchema(schOrEnv);
      function callRootRef() {
        if (env === root) return callRef(cxt, validateName, env, env.$async);
        const rootName = gen.scopeValue("root", { ref: root });
        return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root, root.$async);
      }
      function callValidate(sch) {
        callRef(cxt, getValidate(cxt, sch), sch, sch.$async);
      }
      function inlineRefSchema(sch) {
        const schName = gen.scopeValue(
          "schema",
          opts.code.source === true
            ? {
                ref: sch,
                code: (0, codegen_1.stringify)(sch),
              }
            : { ref: sch },
        );
        const valid = gen.name("valid");
        const schCxt = cxt.subschema(
          {
            schema: sch,
            dataTypes: [],
            schemaPath: codegen_1.nil,
            topSchemaRef: schName,
            errSchemaPath: $ref,
          },
          valid,
        );
        cxt.mergeEvaluated(schCxt);
        cxt.ok(valid);
      }
    },
  };
  function getValidate(cxt, sch) {
    const { gen } = cxt;
    return sch.validate
      ? gen.scopeValue("validate", { ref: sch.validate })
      : (0, codegen_1._)`${gen.scopeValue("wrapper", { ref: sch })}.validate`;
  }
  exports.getValidate = getValidate;
  function callRef(cxt, v, sch, $async) {
    const { gen, it } = cxt;
    const { allErrors, schemaEnv: env, opts } = it;
    const passCxt = opts.passContext ? names_1.default.this : codegen_1.nil;
    if ($async) callAsyncRef();
    else callSyncRef();
    function callAsyncRef() {
      if (!env.$async) throw new Error("async schema referenced by sync schema");
      const valid = gen.let("valid");
      gen.try(
        () => {
          gen.code((0, codegen_1._)`await ${(0, code_1.callValidateCode)(cxt, v, passCxt)}`);
          addEvaluatedFrom(v);
          if (!allErrors) gen.assign(valid, true);
        },
        (e) => {
          gen.if((0, codegen_1._)`!(${e} instanceof ${it.ValidationError})`, () => gen.throw(e));
          addErrorsFrom(e);
          if (!allErrors) gen.assign(valid, false);
        },
      );
      cxt.ok(valid);
    }
    function callSyncRef() {
      cxt.result(
        (0, code_1.callValidateCode)(cxt, v, passCxt),
        () => addEvaluatedFrom(v),
        () => addErrorsFrom(v),
      );
    }
    function addErrorsFrom(source) {
      const errs = (0, codegen_1._)`${source}.errors`;
      gen.assign(
        names_1.default.vErrors,
        (0,
        codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`,
      );
      gen.assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`);
    }
    function addEvaluatedFrom(source) {
      var _a;
      if (!it.opts.unevaluated) return;
      const schEvaluated =
        (_a = sch === null || sch === void 0 ? void 0 : sch.validate) === null || _a === void 0
          ? void 0
          : _a.evaluated;
      if (it.props !== true) {
        if (schEvaluated && !schEvaluated.dynamicProps) {
          if (schEvaluated.props !== void 0)
            it.props = util_1.mergeEvaluated.props(gen, schEvaluated.props, it.props);
        } else {
          const props = gen.var("props", (0, codegen_1._)`${source}.evaluated.props`);
          it.props = util_1.mergeEvaluated.props(gen, props, it.props, codegen_1.Name);
        }
      }
      if (it.items !== true) {
        if (schEvaluated && !schEvaluated.dynamicItems) {
          if (schEvaluated.items !== void 0)
            it.items = util_1.mergeEvaluated.items(gen, schEvaluated.items, it.items);
        } else {
          const items = gen.var("items", (0, codegen_1._)`${source}.evaluated.items`);
          it.items = util_1.mergeEvaluated.items(gen, items, it.items, codegen_1.Name);
        }
      }
    }
  }
  exports.callRef = callRef;
  exports.default = def;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/core/index.js
var require_core = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const id_1 = require_id();
  const ref_1 = require_ref();
  exports.default = [
    "$schema",
    "$id",
    "$defs",
    "$vocabulary",
    { keyword: "$comment" },
    "definitions",
    id_1.default,
    ref_1.default,
  ];
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitNumber.js
var require_limitNumber = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const ops = codegen_1.operators;
  const 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,
    },
  };
  exports.default = {
    keyword: Object.keys(KWDs),
    type: "number",
    schemaType: "number",
    $data: true,
    error: {
      message: ({ keyword, schemaCode }) =>
        (0, codegen_1.str)`must be ${KWDs[keyword].okStr} ${schemaCode}`,
      params: ({ keyword, schemaCode }) =>
        (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`,
    },
    code(cxt) {
      const { keyword, data, schemaCode } = cxt;
      cxt.fail$data(
        (0, codegen_1._)`${data} ${KWDs[keyword].fail} ${schemaCode} || isNaN(${data})`,
      );
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/multipleOf.js
var require_multipleOf = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  exports.default = {
    keyword: "multipleOf",
    type: "number",
    schemaType: "number",
    $data: true,
    error: {
      message: ({ schemaCode }) => (0, codegen_1.str)`must be multiple of ${schemaCode}`,
      params: ({ schemaCode }) => (0, codegen_1._)`{multipleOf: ${schemaCode}}`,
    },
    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}))`,
      );
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/ucs2length.js
var require_ucs2length = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  function ucs2length(str) {
    const len = str.length;
    let length = 0;
    let pos = 0;
    let value;
    while (pos < len) {
      length++;
      value = str.charCodeAt(pos++);
      if (value >= 55296 && value <= 56319 && pos < len) {
        value = str.charCodeAt(pos);
        if ((value & 64512) === 56320) pos++;
      }
    }
    return length;
  }
  exports.default = ucs2length;
  ucs2length.code = 'require("ajv/dist/runtime/ucs2length").default';
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitLength.js
var require_limitLength = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const ucs2length_1 = require_ucs2length();
  exports.default = {
    keyword: ["maxLength", "minLength"],
    type: "string",
    schemaType: "number",
    $data: true,
    error: {
      message({ keyword, schemaCode }) {
        const comp = keyword === "maxLength" ? "more" : "fewer";
        return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} characters`;
      },
      params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`,
    },
    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}`);
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/pattern.js
var require_pattern = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const code_1 = require_code();
  const util_1 = require_util();
  const codegen_1 = require_codegen();
  exports.default = {
    keyword: "pattern",
    type: "string",
    schemaType: "string",
    $data: true,
    error: {
      message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`,
      params: ({ schemaCode }) => (0, codegen_1._)`{pattern: ${schemaCode}}`,
    },
    code(cxt) {
      const { gen, data, $data, schema, schemaCode, it } = cxt;
      const u = it.opts.unicodeRegExp ? "u" : "";
      if ($data) {
        const { regExp } = it.opts.code;
        const regExpCode =
          regExp.code === "new RegExp"
            ? (0, codegen_1._)`new RegExp`
            : (0, util_1.useFunc)(gen, regExp);
        const valid = gen.let("valid");
        gen.try(
          () =>
            gen.assign(valid, (0, codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`),
          () => gen.assign(valid, false),
        );
        cxt.fail$data((0, codegen_1._)`!${valid}`);
      } else {
        const regExp = (0, code_1.usePattern)(cxt, schema);
        cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitProperties.js
var require_limitProperties = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  exports.default = {
    keyword: ["maxProperties", "minProperties"],
    type: "object",
    schemaType: "number",
    $data: true,
    error: {
      message({ keyword, schemaCode }) {
        const comp = keyword === "maxProperties" ? "more" : "fewer";
        return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} properties`;
      },
      params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`,
    },
    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}`);
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/required.js
var require_required = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const code_1 = require_code();
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  exports.default = {
    keyword: "required",
    type: "object",
    schemaType: "array",
    $data: true,
    error: {
      message: ({ params: { missingProperty } }) =>
        (0, codegen_1.str)`must have required property '${missingProperty}'`,
      params: ({ params: { missingProperty } }) =>
        (0, codegen_1._)`{missingProperty: ${missingProperty}}`,
    },
    code(cxt) {
      const { gen, schema, schemaCode, data, $data, it } = cxt;
      const { opts } = it;
      if (!$data && schema.length === 0) return;
      const useLoop = schema.length >= opts.loopRequired;
      if (it.allErrors) allErrorsMode();
      else exitOnErrorMode();
      if (opts.strictRequired) {
        const props = cxt.parentSchema.properties;
        const { definedProperties } = cxt.it;
        for (const requiredKey of schema)
          if (
            (props === null || props === void 0 ? void 0 : props[requiredKey]) === void 0 &&
            !definedProperties.has(requiredKey)
          ) {
            const msg = `required property "${requiredKey}" is not defined at "${it.schemaEnv.baseId + it.errSchemaPath}" (strictRequired)`;
            (0, util_1.checkStrictMode)(it, msg, it.opts.strictRequired);
          }
      }
      function allErrorsMode() {
        if (useLoop || $data) cxt.block$data(codegen_1.nil, loopAllRequired);
        else for (const prop of schema) (0, code_1.checkReportMissingProp)(cxt, prop);
      }
      function exitOnErrorMode() {
        const missing = gen.let("missing");
        if (useLoop || $data) {
          const valid = gen.let("valid", true);
          cxt.block$data(valid, () => loopUntilMissing(missing, valid));
          cxt.ok(valid);
        } else {
          gen.if((0, code_1.checkMissingProp)(cxt, schema, missing));
          (0, code_1.reportMissingProp)(cxt, missing);
          gen.else();
        }
      }
      function loopAllRequired() {
        gen.forOf("prop", schemaCode, (prop) => {
          cxt.setParams({ missingProperty: prop });
          gen.if((0, code_1.noPropertyInData)(gen, data, prop, opts.ownProperties), () =>
            cxt.error(),
          );
        });
      }
      function loopUntilMissing(missing, valid) {
        cxt.setParams({ missingProperty: missing });
        gen.forOf(
          missing,
          schemaCode,
          () => {
            gen.assign(valid, (0, code_1.propertyInData)(gen, data, missing, opts.ownProperties));
            gen.if((0, codegen_1.not)(valid), () => {
              cxt.error();
              gen.break();
            });
          },
          codegen_1.nil,
        );
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitItems.js
var require_limitItems = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  exports.default = {
    keyword: ["maxItems", "minItems"],
    type: "array",
    schemaType: "number",
    $data: true,
    error: {
      message({ keyword, schemaCode }) {
        const comp = keyword === "maxItems" ? "more" : "fewer";
        return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} items`;
      },
      params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`,
    },
    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}`);
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/equal.js
var require_equal = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const equal = require_fast_deep_equal();
  equal.code = 'require("ajv/dist/runtime/equal").default';
  exports.default = equal;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/uniqueItems.js
var require_uniqueItems = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const dataType_1 = require_dataType();
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const equal_1 = require_equal();
  exports.default = {
    keyword: "uniqueItems",
    type: "array",
    schemaType: "boolean",
    $data: true,
    error: {
      message: ({ params: { i, j } }) =>
        (0, codegen_1.str)`must NOT have duplicate items (items ## ${j} and ${i} are identical)`,
      params: ({ params: { i, j } }) => (0, codegen_1._)`{i: ${i}, j: ${j}}`,
    },
    code(cxt) {
      const { gen, data, $data, schema, parentSchema, schemaCode, it } = cxt;
      if (!$data && !schema) return;
      const valid = gen.let("valid");
      const itemTypes = parentSchema.items
        ? (0, dataType_1.getSchemaTypes)(parentSchema.items)
        : [];
      cxt.block$data(valid, validateUniqueItems, (0, codegen_1._)`${schemaCode} === false`);
      cxt.ok(valid);
      function validateUniqueItems() {
        const i = gen.let("i", (0, codegen_1._)`${data}.length`);
        const j = gen.let("j");
        cxt.setParams({
          i,
          j,
        });
        gen.assign(valid, true);
        gen.if((0, codegen_1._)`${i} > 1`, () => (canOptimize() ? loopN : loopN2)(i, j));
      }
      function canOptimize() {
        return itemTypes.length > 0 && !itemTypes.some((t) => t === "object" || t === "array");
      }
      function loopN(i, j) {
        const item = gen.name("item");
        const wrongType = (0, dataType_1.checkDataTypes)(
          itemTypes,
          item,
          it.opts.strictNumbers,
          dataType_1.DataType.Wrong,
        );
        const indices = gen.const("indices", (0, codegen_1._)`{}`);
        gen.for((0, codegen_1._)`;${i}--;`, () => {
          gen.let(item, (0, codegen_1._)`${data}[${i}]`);
          gen.if(wrongType, (0, codegen_1._)`continue`);
          if (itemTypes.length > 1)
            gen.if((0, codegen_1._)`typeof ${item} == "string"`, (0, codegen_1._)`${item} += "_"`);
          gen
            .if((0, codegen_1._)`typeof ${indices}[${item}] == "number"`, () => {
              gen.assign(j, (0, codegen_1._)`${indices}[${item}]`);
              cxt.error();
              gen.assign(valid, false).break();
            })
            .code((0, codegen_1._)`${indices}[${item}] = ${i}`);
        });
      }
      function loopN2(i, j) {
        const eql = (0, util_1.useFunc)(gen, equal_1.default);
        const outer = gen.name("outer");
        gen.label(outer).for((0, codegen_1._)`;${i}--;`, () =>
          gen.for((0, codegen_1._)`${j} = ${i}; ${j}--;`, () =>
            gen.if((0, codegen_1._)`${eql}(${data}[${i}], ${data}[${j}])`, () => {
              cxt.error();
              gen.assign(valid, false).break(outer);
            }),
          ),
        );
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/const.js
var require_const = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const equal_1 = require_equal();
  exports.default = {
    keyword: "const",
    $data: true,
    error: {
      message: "must be equal to constant",
      params: ({ schemaCode }) => (0, codegen_1._)`{allowedValue: ${schemaCode}}`,
    },
    code(cxt) {
      const { gen, data, $data, schemaCode, schema } = cxt;
      if ($data || (schema && typeof schema == "object"))
        cxt.fail$data(
          (0, codegen_1._)`!${(0, util_1.useFunc)(gen, equal_1.default)}(${data}, ${schemaCode})`,
        );
      else cxt.fail((0, codegen_1._)`${schema} !== ${data}`);
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/enum.js
var require_enum = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const equal_1 = require_equal();
  exports.default = {
    keyword: "enum",
    schemaType: "array",
    $data: true,
    error: {
      message: "must be equal to one of the allowed values",
      params: ({ schemaCode }) => (0, codegen_1._)`{allowedValues: ${schemaCode}}`,
    },
    code(cxt) {
      const { gen, data, $data, schema, schemaCode, it } = cxt;
      if (!$data && schema.length === 0) throw new Error("enum must have non-empty array");
      const useLoop = schema.length >= it.opts.loopEnum;
      let eql;
      const getEql = () =>
        eql !== null && eql !== void 0 ? eql : (eql = (0, util_1.useFunc)(gen, equal_1.default));
      let valid;
      if (useLoop || $data) {
        valid = gen.let("valid");
        cxt.block$data(valid, loopEnum);
      } else {
        /* istanbul ignore if */
        if (!Array.isArray(schema)) throw new Error("ajv implementation error");
        const vSchema = gen.const("vSchema", schemaCode);
        valid = (0, codegen_1.or)(...schema.map((_x, i) => equalCode(vSchema, i)));
      }
      cxt.pass(valid);
      function loopEnum() {
        gen.assign(valid, false);
        gen.forOf("v", schemaCode, (v) =>
          gen.if((0, codegen_1._)`${getEql()}(${data}, ${v})`, () =>
            gen.assign(valid, true).break(),
          ),
        );
      }
      function equalCode(vSchema, i) {
        const sch = schema[i];
        return typeof sch === "object" && sch !== null
          ? (0, codegen_1._)`${getEql()}(${data}, ${vSchema}[${i}])`
          : (0, codegen_1._)`${data} === ${sch}`;
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/index.js
var require_validation = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const limitNumber_1 = require_limitNumber();
  const multipleOf_1 = require_multipleOf();
  const limitLength_1 = require_limitLength();
  const pattern_1 = require_pattern();
  const limitProperties_1 = require_limitProperties();
  const required_1 = require_required();
  const limitItems_1 = require_limitItems();
  const uniqueItems_1 = require_uniqueItems();
  const const_1 = require_const();
  const enum_1 = require_enum();
  exports.default = [
    limitNumber_1.default,
    multipleOf_1.default,
    limitLength_1.default,
    pattern_1.default,
    limitProperties_1.default,
    required_1.default,
    limitItems_1.default,
    uniqueItems_1.default,
    {
      keyword: "type",
      schemaType: ["string", "array"],
    },
    {
      keyword: "nullable",
      schemaType: "boolean",
    },
    const_1.default,
    enum_1.default,
  ];
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/additionalItems.js
var require_additionalItems = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.validateAdditionalItems = void 0;
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const def = {
    keyword: "additionalItems",
    type: "array",
    schemaType: ["boolean", "object"],
    before: "uniqueItems",
    error: {
      message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
      params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`,
    },
    code(cxt) {
      const { parentSchema, it } = cxt;
      const { items } = parentSchema;
      if (!Array.isArray(items)) {
        (0, util_1.checkStrictMode)(
          it,
          '"additionalItems" is ignored when "items" is not an array of schemas',
        );
        return;
      }
      validateAdditionalItems(cxt, items);
    },
  };
  function validateAdditionalItems(cxt, items) {
    const { gen, schema, data, keyword, it } = cxt;
    it.items = true;
    const len = gen.const("len", (0, codegen_1._)`${data}.length`);
    if (schema === false) {
      cxt.setParams({ len: items.length });
      cxt.pass((0, codegen_1._)`${len} <= ${items.length}`);
    } else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
      const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items.length}`);
      gen.if((0, codegen_1.not)(valid), () => validateItems(valid));
      cxt.ok(valid);
    }
    function validateItems(valid) {
      gen.forRange("i", items.length, len, (i) => {
        cxt.subschema(
          {
            keyword,
            dataProp: i,
            dataPropType: util_1.Type.Num,
          },
          valid,
        );
        if (!it.allErrors) gen.if((0, codegen_1.not)(valid), () => gen.break());
      });
    }
  }
  exports.validateAdditionalItems = validateAdditionalItems;
  exports.default = def;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/items.js
var require_items = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.validateTuple = void 0;
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const code_1 = require_code();
  const def = {
    keyword: "items",
    type: "array",
    schemaType: ["object", "array", "boolean"],
    before: "uniqueItems",
    code(cxt) {
      const { schema, it } = cxt;
      if (Array.isArray(schema)) return validateTuple(cxt, "additionalItems", schema);
      it.items = true;
      if ((0, util_1.alwaysValidSchema)(it, schema)) return;
      cxt.ok((0, code_1.validateArray)(cxt));
    },
  };
  function validateTuple(cxt, extraItems, schArr = cxt.schema) {
    const { gen, parentSchema, data, keyword, it } = cxt;
    checkStrictTuple(parentSchema);
    if (it.opts.unevaluated && schArr.length && it.items !== true)
      it.items = util_1.mergeEvaluated.items(gen, schArr.length, it.items);
    const valid = gen.name("valid");
    const len = gen.const("len", (0, codegen_1._)`${data}.length`);
    schArr.forEach((sch, i) => {
      if ((0, util_1.alwaysValidSchema)(it, sch)) return;
      gen.if((0, codegen_1._)`${len} > ${i}`, () =>
        cxt.subschema(
          {
            keyword,
            schemaProp: i,
            dataProp: i,
          },
          valid,
        ),
      );
      cxt.ok(valid);
    });
    function checkStrictTuple(sch) {
      const { opts, errSchemaPath } = it;
      const l = schArr.length;
      const fullTuple = l === sch.minItems && (l === sch.maxItems || sch[extraItems] === false);
      if (opts.strictTuples && !fullTuple) {
        const msg = `"${keyword}" is ${l}-tuple, but minItems or maxItems/${extraItems} are not specified or different at path "${errSchemaPath}"`;
        (0, util_1.checkStrictMode)(it, msg, opts.strictTuples);
      }
    }
  }
  exports.validateTuple = validateTuple;
  exports.default = def;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/prefixItems.js
var require_prefixItems = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const items_1 = require_items();
  exports.default = {
    keyword: "prefixItems",
    type: "array",
    schemaType: ["array"],
    before: "uniqueItems",
    code: (cxt) => (0, items_1.validateTuple)(cxt, "items"),
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/items2020.js
var require_items2020 = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const code_1 = require_code();
  const additionalItems_1 = require_additionalItems();
  exports.default = {
    keyword: "items",
    type: "array",
    schemaType: ["object", "boolean"],
    before: "uniqueItems",
    error: {
      message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
      params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`,
    },
    code(cxt) {
      const { schema, parentSchema, it } = cxt;
      const { prefixItems } = parentSchema;
      it.items = true;
      if ((0, util_1.alwaysValidSchema)(it, schema)) return;
      if (prefixItems) (0, additionalItems_1.validateAdditionalItems)(cxt, prefixItems);
      else cxt.ok((0, code_1.validateArray)(cxt));
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/contains.js
var require_contains = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  exports.default = {
    keyword: "contains",
    type: "array",
    schemaType: ["object", "boolean"],
    before: "uniqueItems",
    trackErrors: true,
    error: {
      message: ({ params: { min, max } }) =>
        max === void 0
          ? (0, codegen_1.str)`must contain at least ${min} valid item(s)`
          : (0, codegen_1.str)`must contain at least ${min} and no more than ${max} valid item(s)`,
      params: ({ params: { min, max } }) =>
        max === void 0
          ? (0, codegen_1._)`{minContains: ${min}}`
          : (0, codegen_1._)`{minContains: ${min}, maxContains: ${max}}`,
    },
    code(cxt) {
      const { gen, schema, parentSchema, data, it } = cxt;
      let min;
      let max;
      const { minContains, maxContains } = parentSchema;
      if (it.opts.next) {
        min = minContains === void 0 ? 1 : minContains;
        max = maxContains;
      } else min = 1;
      const len = gen.const("len", (0, codegen_1._)`${data}.length`);
      cxt.setParams({
        min,
        max,
      });
      if (max === void 0 && min === 0) {
        (0, util_1.checkStrictMode)(
          it,
          `"minContains" == 0 without "maxContains": "contains" keyword ignored`,
        );
        return;
      }
      if (max !== void 0 && min > max) {
        (0, util_1.checkStrictMode)(it, `"minContains" > "maxContains" is always invalid`);
        cxt.fail();
        return;
      }
      if ((0, util_1.alwaysValidSchema)(it, schema)) {
        let cond = (0, codegen_1._)`${len} >= ${min}`;
        if (max !== void 0) cond = (0, codegen_1._)`${cond} && ${len} <= ${max}`;
        cxt.pass(cond);
        return;
      }
      it.items = true;
      const valid = gen.name("valid");
      if (max === void 0 && min === 1) validateItems(valid, () => gen.if(valid, () => gen.break()));
      else if (min === 0) {
        gen.let(valid, true);
        if (max !== void 0) gen.if((0, codegen_1._)`${data}.length > 0`, validateItemsWithCount);
      } else {
        gen.let(valid, false);
        validateItemsWithCount();
      }
      cxt.result(valid, () => cxt.reset());
      function validateItemsWithCount() {
        const schValid = gen.name("_valid");
        const count = gen.let("count", 0);
        validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)));
      }
      function validateItems(_valid, block) {
        gen.forRange("i", 0, len, (i) => {
          cxt.subschema(
            {
              keyword: "contains",
              dataProp: i,
              dataPropType: util_1.Type.Num,
              compositeRule: true,
            },
            _valid,
          );
          block();
        });
      }
      function checkLimits(count) {
        gen.code((0, codegen_1._)`${count}++`);
        if (max === void 0)
          gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true).break());
        else {
          gen.if((0, codegen_1._)`${count} > ${max}`, () => gen.assign(valid, false).break());
          if (min === 1) gen.assign(valid, true);
          else gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true));
        }
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/dependencies.js
var require_dependencies = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = void 0;
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const code_1 = require_code();
  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}}`,
  };
  const def = {
    keyword: "dependencies",
    type: "object",
    schemaType: "object",
    error: exports.error,
    code(cxt) {
      const [propDeps, schDeps] = splitDependencies(cxt);
      validatePropertyDeps(cxt, propDeps);
      validateSchemaDeps(cxt, schDeps);
    },
  };
  function splitDependencies({ schema }) {
    const propertyDeps = {};
    const schemaDeps = {};
    for (const key in schema) {
      if (key === "__proto__") continue;
      const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps;
      deps[key] = schema[key];
    }
    return [propertyDeps, schemaDeps];
  }
  function validatePropertyDeps(cxt, propertyDeps = cxt.schema) {
    const { gen, data, it } = cxt;
    if (Object.keys(propertyDeps).length === 0) return;
    const missing = gen.let("missing");
    for (const prop in propertyDeps) {
      const deps = propertyDeps[prop];
      if (deps.length === 0) continue;
      const hasProperty = (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties);
      cxt.setParams({
        property: prop,
        depsCount: deps.length,
        deps: deps.join(", "),
      });
      if (it.allErrors)
        gen.if(hasProperty, () => {
          for (const depProp of deps) (0, code_1.checkReportMissingProp)(cxt, depProp);
        });
      else {
        gen.if(
          (0, codegen_1._)`${hasProperty} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`,
        );
        (0, code_1.reportMissingProp)(cxt, missing);
        gen.else();
      }
    }
  }
  exports.validatePropertyDeps = validatePropertyDeps;
  function validateSchemaDeps(cxt, schemaDeps = cxt.schema) {
    const { gen, data, keyword, it } = cxt;
    const valid = gen.name("valid");
    for (const prop in schemaDeps) {
      if ((0, util_1.alwaysValidSchema)(it, schemaDeps[prop])) continue;
      gen.if(
        (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties),
        () => {
          const schCxt = cxt.subschema(
            {
              keyword,
              schemaProp: prop,
            },
            valid,
          );
          cxt.mergeValidEvaluated(schCxt, valid);
        },
        () => gen.var(valid, true),
      );
      cxt.ok(valid);
    }
  }
  exports.validateSchemaDeps = validateSchemaDeps;
  exports.default = def;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/propertyNames.js
var require_propertyNames = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  exports.default = {
    keyword: "propertyNames",
    type: "object",
    schemaType: ["object", "boolean"],
    error: {
      message: "property name must be valid",
      params: ({ params }) => (0, codegen_1._)`{propertyName: ${params.propertyName}}`,
    },
    code(cxt) {
      const { gen, schema, data, it } = cxt;
      if ((0, util_1.alwaysValidSchema)(it, schema)) return;
      const valid = gen.name("valid");
      gen.forIn("key", data, (key) => {
        cxt.setParams({ propertyName: key });
        cxt.subschema(
          {
            keyword: "propertyNames",
            data: key,
            dataTypes: ["string"],
            propertyName: key,
            compositeRule: true,
          },
          valid,
        );
        gen.if((0, codegen_1.not)(valid), () => {
          cxt.error(true);
          if (!it.allErrors) gen.break();
        });
      });
      cxt.ok(valid);
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js
var require_additionalProperties = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const code_1 = require_code();
  const codegen_1 = require_codegen();
  const names_1 = require_names();
  const util_1 = require_util();
  exports.default = {
    keyword: "additionalProperties",
    type: ["object"],
    schemaType: ["boolean", "object"],
    allowUndefined: true,
    trackErrors: true,
    error: {
      message: "must NOT have additional properties",
      params: ({ params }) => (0, codegen_1._)`{additionalProperty: ${params.additionalProperty}}`,
    },
    code(cxt) {
      const { gen, schema, parentSchema, data, errsCount, it } = cxt;
      /* istanbul ignore if */
      if (!errsCount) throw new Error("ajv implementation error");
      const { allErrors, opts } = it;
      it.props = true;
      if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema)) return;
      const props = (0, code_1.allSchemaProperties)(parentSchema.properties);
      const patProps = (0, code_1.allSchemaProperties)(parentSchema.patternProperties);
      checkAdditionalProperties();
      cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
      function checkAdditionalProperties() {
        gen.forIn("key", data, (key) => {
          if (!props.length && !patProps.length) additionalPropertyCode(key);
          else gen.if(isAdditional(key), () => additionalPropertyCode(key));
        });
      }
      function isAdditional(key) {
        let definedProp;
        if (props.length > 8) {
          const propsSchema = (0, util_1.schemaRefOrVal)(it, parentSchema.properties, "properties");
          definedProp = (0, code_1.isOwnProperty)(gen, propsSchema, key);
        } else if (props.length)
          definedProp = (0, codegen_1.or)(...props.map((p) => (0, codegen_1._)`${key} === ${p}`));
        else definedProp = codegen_1.nil;
        if (patProps.length)
          definedProp = (0, codegen_1.or)(
            definedProp,
            ...patProps.map(
              (p) => (0, codegen_1._)`${(0, code_1.usePattern)(cxt, p)}.test(${key})`,
            ),
          );
        return (0, codegen_1.not)(definedProp);
      }
      function deleteAdditional(key) {
        gen.code((0, codegen_1._)`delete ${data}[${key}]`);
      }
      function additionalPropertyCode(key) {
        if (opts.removeAdditional === "all" || (opts.removeAdditional && schema === false)) {
          deleteAdditional(key);
          return;
        }
        if (schema === false) {
          cxt.setParams({ additionalProperty: key });
          cxt.error();
          if (!allErrors) gen.break();
          return;
        }
        if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
          const valid = gen.name("valid");
          if (opts.removeAdditional === "failing") {
            applyAdditionalSchema(key, valid, false);
            gen.if((0, codegen_1.not)(valid), () => {
              cxt.reset();
              deleteAdditional(key);
            });
          } else {
            applyAdditionalSchema(key, valid);
            if (!allErrors) gen.if((0, codegen_1.not)(valid), () => gen.break());
          }
        }
      }
      function applyAdditionalSchema(key, valid, errors) {
        const subschema = {
          keyword: "additionalProperties",
          dataProp: key,
          dataPropType: util_1.Type.Str,
        };
        if (errors === false)
          Object.assign(subschema, {
            compositeRule: true,
            createErrors: false,
            allErrors: false,
          });
        cxt.subschema(subschema, valid);
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/properties.js
var require_properties = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const validate_1 = require_validate();
  const code_1 = require_code();
  const util_1 = require_util();
  const additionalProperties_1 = require_additionalProperties();
  exports.default = {
    keyword: "properties",
    type: "object",
    schemaType: "object",
    code(cxt) {
      const { gen, schema, parentSchema, data, it } = cxt;
      if (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === void 0)
        additionalProperties_1.default.code(
          new validate_1.KeywordCxt(it, additionalProperties_1.default, "additionalProperties"),
        );
      const allProps = (0, code_1.allSchemaProperties)(schema);
      for (const prop of allProps) it.definedProperties.add(prop);
      if (it.opts.unevaluated && allProps.length && it.props !== true)
        it.props = util_1.mergeEvaluated.props(gen, (0, util_1.toHash)(allProps), it.props);
      const properties = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema[p]));
      if (properties.length === 0) return;
      const valid = gen.name("valid");
      for (const prop of properties) {
        if (hasDefault(prop)) applyPropertySchema(prop);
        else {
          gen.if((0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties));
          applyPropertySchema(prop);
          if (!it.allErrors) gen.else().var(valid, true);
          gen.endIf();
        }
        cxt.it.definedProperties.add(prop);
        cxt.ok(valid);
      }
      function hasDefault(prop) {
        return it.opts.useDefaults && !it.compositeRule && schema[prop].default !== void 0;
      }
      function applyPropertySchema(prop) {
        cxt.subschema(
          {
            keyword: "properties",
            schemaProp: prop,
            dataProp: prop,
          },
          valid,
        );
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/patternProperties.js
var require_patternProperties = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const code_1 = require_code();
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const util_2 = require_util();
  exports.default = {
    keyword: "patternProperties",
    type: "object",
    schemaType: "object",
    code(cxt) {
      const { gen, schema, data, parentSchema, it } = cxt;
      const { opts } = it;
      const patterns = (0, code_1.allSchemaProperties)(schema);
      const alwaysValidPatterns = patterns.filter((p) =>
        (0, util_1.alwaysValidSchema)(it, schema[p]),
      );
      if (
        patterns.length === 0 ||
        (alwaysValidPatterns.length === patterns.length &&
          (!it.opts.unevaluated || it.props === true))
      )
        return;
      const checkProperties =
        opts.strictSchema && !opts.allowMatchingProperties && parentSchema.properties;
      const valid = gen.name("valid");
      if (it.props !== true && !(it.props instanceof codegen_1.Name))
        it.props = (0, util_2.evaluatedPropsToName)(gen, it.props);
      const { props } = it;
      validatePatternProperties();
      function validatePatternProperties() {
        for (const pat of patterns) {
          if (checkProperties) checkMatchingProperties(pat);
          if (it.allErrors) validateProperties(pat);
          else {
            gen.var(valid, true);
            validateProperties(pat);
            gen.if(valid);
          }
        }
      }
      function checkMatchingProperties(pat) {
        for (const prop in checkProperties)
          if (new RegExp(pat).test(prop))
            (0, util_1.checkStrictMode)(
              it,
              `property ${prop} matches pattern ${pat} (use allowMatchingProperties)`,
            );
      }
      function validateProperties(pat) {
        gen.forIn("key", data, (key) => {
          gen.if((0, codegen_1._)`${(0, code_1.usePattern)(cxt, pat)}.test(${key})`, () => {
            const alwaysValid = alwaysValidPatterns.includes(pat);
            if (!alwaysValid)
              cxt.subschema(
                {
                  keyword: "patternProperties",
                  schemaProp: pat,
                  dataProp: key,
                  dataPropType: util_2.Type.Str,
                },
                valid,
              );
            if (it.opts.unevaluated && props !== true)
              gen.assign((0, codegen_1._)`${props}[${key}]`, true);
            else if (!alwaysValid && !it.allErrors)
              gen.if((0, codegen_1.not)(valid), () => gen.break());
          });
        });
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/not.js
var require_not = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const util_1 = require_util();
  exports.default = {
    keyword: "not",
    schemaType: ["object", "boolean"],
    trackErrors: true,
    code(cxt) {
      const { gen, schema, it } = cxt;
      if ((0, util_1.alwaysValidSchema)(it, schema)) {
        cxt.fail();
        return;
      }
      const valid = gen.name("valid");
      cxt.subschema(
        {
          keyword: "not",
          compositeRule: true,
          createErrors: false,
          allErrors: false,
        },
        valid,
      );
      cxt.failResult(
        valid,
        () => cxt.reset(),
        () => cxt.error(),
      );
    },
    error: { message: "must NOT be valid" },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/anyOf.js
var require_anyOf = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.default = {
    keyword: "anyOf",
    schemaType: "array",
    trackErrors: true,
    code: require_code().validateUnion,
    error: { message: "must match a schema in anyOf" },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/oneOf.js
var require_oneOf = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  exports.default = {
    keyword: "oneOf",
    schemaType: "array",
    trackErrors: true,
    error: {
      message: "must match exactly one schema in oneOf",
      params: ({ params }) => (0, codegen_1._)`{passingSchemas: ${params.passing}}`,
    },
    code(cxt) {
      const { gen, schema, parentSchema, it } = cxt;
      /* istanbul ignore if */
      if (!Array.isArray(schema)) throw new Error("ajv implementation error");
      if (it.opts.discriminator && parentSchema.discriminator) return;
      const schArr = schema;
      const valid = gen.let("valid", false);
      const passing = gen.let("passing", null);
      const schValid = gen.name("_valid");
      cxt.setParams({ passing });
      gen.block(validateOneOf);
      cxt.result(
        valid,
        () => cxt.reset(),
        () => cxt.error(true),
      );
      function validateOneOf() {
        schArr.forEach((sch, i) => {
          let schCxt;
          if ((0, util_1.alwaysValidSchema)(it, sch)) gen.var(schValid, true);
          else
            schCxt = cxt.subschema(
              {
                keyword: "oneOf",
                schemaProp: i,
                compositeRule: true,
              },
              schValid,
            );
          if (i > 0)
            gen
              .if((0, codegen_1._)`${schValid} && ${valid}`)
              .assign(valid, false)
              .assign(passing, (0, codegen_1._)`[${passing}, ${i}]`)
              .else();
          gen.if(schValid, () => {
            gen.assign(valid, true);
            gen.assign(passing, i);
            if (schCxt) cxt.mergeEvaluated(schCxt, codegen_1.Name);
          });
        });
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/allOf.js
var require_allOf = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const util_1 = require_util();
  exports.default = {
    keyword: "allOf",
    schemaType: "array",
    code(cxt) {
      const { gen, schema, it } = cxt;
      /* istanbul ignore if */
      if (!Array.isArray(schema)) throw new Error("ajv implementation error");
      const valid = gen.name("valid");
      schema.forEach((sch, i) => {
        if ((0, util_1.alwaysValidSchema)(it, sch)) return;
        const schCxt = cxt.subschema(
          {
            keyword: "allOf",
            schemaProp: i,
          },
          valid,
        );
        cxt.ok(valid);
        cxt.mergeEvaluated(schCxt);
      });
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/if.js
var require_if = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const util_1 = require_util();
  const def = {
    keyword: "if",
    schemaType: ["object", "boolean"],
    trackErrors: true,
    error: {
      message: ({ params }) => (0, codegen_1.str)`must match "${params.ifClause}" schema`,
      params: ({ params }) => (0, codegen_1._)`{failingKeyword: ${params.ifClause}}`,
    },
    code(cxt) {
      const { gen, parentSchema, it } = cxt;
      if (parentSchema.then === void 0 && parentSchema.else === void 0)
        (0, util_1.checkStrictMode)(it, '"if" without "then" and "else" is ignored');
      const hasThen = hasSchema(it, "then");
      const hasElse = hasSchema(it, "else");
      if (!hasThen && !hasElse) return;
      const valid = gen.let("valid", true);
      const schValid = gen.name("_valid");
      validateIf();
      cxt.reset();
      if (hasThen && hasElse) {
        const ifClause = gen.let("ifClause");
        cxt.setParams({ ifClause });
        gen.if(schValid, validateClause("then", ifClause), validateClause("else", ifClause));
      } else if (hasThen) gen.if(schValid, validateClause("then"));
      else gen.if((0, codegen_1.not)(schValid), validateClause("else"));
      cxt.pass(valid, () => cxt.error(true));
      function validateIf() {
        const schCxt = cxt.subschema(
          {
            keyword: "if",
            compositeRule: true,
            createErrors: false,
            allErrors: false,
          },
          schValid,
        );
        cxt.mergeEvaluated(schCxt);
      }
      function validateClause(keyword, ifClause) {
        return () => {
          const schCxt = cxt.subschema({ keyword }, schValid);
          gen.assign(valid, schValid);
          cxt.mergeValidEvaluated(schCxt, valid);
          if (ifClause) gen.assign(ifClause, (0, codegen_1._)`${keyword}`);
          else cxt.setParams({ ifClause: keyword });
        };
      }
    },
  };
  function hasSchema(it, keyword) {
    const schema = it.schema[keyword];
    return schema !== void 0 && !(0, util_1.alwaysValidSchema)(it, schema);
  }
  exports.default = def;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/thenElse.js
var require_thenElse = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const util_1 = require_util();
  exports.default = {
    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`);
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/index.js
var require_applicator = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const additionalItems_1 = require_additionalItems();
  const prefixItems_1 = require_prefixItems();
  const items_1 = require_items();
  const items2020_1 = require_items2020();
  const contains_1 = require_contains();
  const dependencies_1 = require_dependencies();
  const propertyNames_1 = require_propertyNames();
  const additionalProperties_1 = require_additionalProperties();
  const properties_1 = require_properties();
  const patternProperties_1 = require_patternProperties();
  const not_1 = require_not();
  const anyOf_1 = require_anyOf();
  const oneOf_1 = require_oneOf();
  const allOf_1 = require_allOf();
  const if_1 = require_if();
  const thenElse_1 = require_thenElse();
  function getApplicator(draft2020 = false) {
    const applicator = [
      not_1.default,
      anyOf_1.default,
      oneOf_1.default,
      allOf_1.default,
      if_1.default,
      thenElse_1.default,
      propertyNames_1.default,
      additionalProperties_1.default,
      dependencies_1.default,
      properties_1.default,
      patternProperties_1.default,
    ];
    if (draft2020) applicator.push(prefixItems_1.default, items2020_1.default);
    else applicator.push(additionalItems_1.default, items_1.default);
    applicator.push(contains_1.default);
    return applicator;
  }
  exports.default = getApplicator;
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/format/format.js
var require_format$1 = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  exports.default = {
    keyword: "format",
    type: ["number", "string"],
    schemaType: "string",
    $data: true,
    error: {
      message: ({ schemaCode }) => (0, codegen_1.str)`must match format "${schemaCode}"`,
      params: ({ schemaCode }) => (0, codegen_1._)`{format: ${schemaCode}}`,
    },
    code(cxt, ruleType) {
      const { gen, data, $data, schema, schemaCode, it } = cxt;
      const { opts, errSchemaPath, schemaEnv, self } = it;
      if (!opts.validateFormats) return;
      if ($data) validate$DataFormat();
      else validateFormat();
      function validate$DataFormat() {
        const fmts = gen.scopeValue("formats", {
          ref: self.formats,
          code: opts.code.formats,
        });
        const fDef = gen.const("fDef", (0, codegen_1._)`${fmts}[${schemaCode}]`);
        const fType = gen.let("fType");
        const format = gen.let("format");
        gen.if(
          (0, codegen_1._)`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`,
          () =>
            gen
              .assign(fType, (0, codegen_1._)`${fDef}.type || "string"`)
              .assign(format, (0, codegen_1._)`${fDef}.validate`),
          () => gen.assign(fType, (0, codegen_1._)`"string"`).assign(format, fDef),
        );
        cxt.fail$data((0, codegen_1.or)(unknownFmt(), invalidFmt()));
        function unknownFmt() {
          if (opts.strictSchema === false) return codegen_1.nil;
          return (0, codegen_1._)`${schemaCode} && !${format}`;
        }
        function invalidFmt() {
          const callFormat = schemaEnv.$async
            ? (0, codegen_1._)`(${fDef}.async ? await ${format}(${data}) : ${format}(${data}))`
            : (0, codegen_1._)`${format}(${data})`;
          const validData = (0,
          codegen_1._)`(typeof ${format} == "function" ? ${callFormat} : ${format}.test(${data}))`;
          return (0,
          codegen_1._)`${format} && ${format} !== true && ${fType} === ${ruleType} && !${validData}`;
        }
      }
      function validateFormat() {
        const formatDef = self.formats[schema];
        if (!formatDef) {
          unknownFormat();
          return;
        }
        if (formatDef === true) return;
        const [fmtType, format, fmtRef] = getFormat(formatDef);
        if (fmtType === ruleType) cxt.pass(validCondition());
        function unknownFormat() {
          if (opts.strictSchema === false) {
            self.logger.warn(unknownMsg());
            return;
          }
          throw new Error(unknownMsg());
          function unknownMsg() {
            return `unknown format "${schema}" ignored in schema at path "${errSchemaPath}"`;
          }
        }
        function getFormat(fmtDef) {
          const code =
            fmtDef instanceof RegExp
              ? (0, codegen_1.regexpCode)(fmtDef)
              : opts.code.formats
                ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(schema)}`
                : void 0;
          const fmt = gen.scopeValue("formats", {
            key: schema,
            ref: fmtDef,
            code,
          });
          if (typeof fmtDef == "object" && !(fmtDef instanceof RegExp))
            return [fmtDef.type || "string", fmtDef.validate, (0, codegen_1._)`${fmt}.validate`];
          return ["string", fmtDef, fmt];
        }
        function validCondition() {
          if (typeof formatDef == "object" && !(formatDef instanceof RegExp) && formatDef.async) {
            if (!schemaEnv.$async) throw new Error("async format in sync schema");
            return (0, codegen_1._)`await ${fmtRef}(${data})`;
          }
          return typeof format == "function"
            ? (0, codegen_1._)`${fmtRef}(${data})`
            : (0, codegen_1._)`${fmtRef}.test(${data})`;
        }
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/format/index.js
var require_format = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.default = [require_format$1().default];
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/metadata.js
var require_metadata = /* @__PURE__ */ __commonJSMin((exports) => {
  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"];
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/draft7.js
var require_draft7 = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const core_1 = require_core();
  const validation_1 = require_validation();
  const applicator_1 = require_applicator();
  const format_1 = require_format();
  const metadata_1 = require_metadata();
  exports.default = [
    core_1.default,
    validation_1.default,
    (0, applicator_1.default)(),
    format_1.default,
    metadata_1.metadataVocabulary,
    metadata_1.contentVocabulary,
  ];
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/discriminator/types.js
var require_types = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.DiscrError = void 0;
  var DiscrError;
  (function (DiscrError) {
    DiscrError["Tag"] = "tag";
    DiscrError["Mapping"] = "mapping";
  })(DiscrError || (exports.DiscrError = DiscrError = {}));
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/discriminator/index.js
var require_discriminator = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const types_1 = require_types();
  const compile_1 = require_compile();
  const ref_error_1 = require_ref_error();
  const util_1 = require_util();
  exports.default = {
    keyword: "discriminator",
    type: "object",
    schemaType: "object",
    error: {
      message: ({ params: { discrError, tagName } }) =>
        discrError === types_1.DiscrError.Tag
          ? `tag "${tagName}" must be string`
          : `value of tag "${tagName}" must be in oneOf`,
      params: ({ params: { discrError, tag, tagName } }) =>
        (0, codegen_1._)`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}`,
    },
    code(cxt) {
      const { gen, data, schema, parentSchema, it } = cxt;
      const { oneOf } = parentSchema;
      if (!it.opts.discriminator) throw new Error("discriminator: requires discriminator option");
      const tagName = schema.propertyName;
      if (typeof tagName != "string") throw new Error("discriminator: requires propertyName");
      if (schema.mapping) throw new Error("discriminator: mapping is not supported");
      if (!oneOf) throw new Error("discriminator: requires oneOf keyword");
      const valid = gen.let("valid", false);
      const tag = gen.const("tag", (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(tagName)}`);
      gen.if(
        (0, codegen_1._)`typeof ${tag} == "string"`,
        () => validateMapping(),
        () =>
          cxt.error(false, {
            discrError: types_1.DiscrError.Tag,
            tag,
            tagName,
          }),
      );
      cxt.ok(valid);
      function validateMapping() {
        const mapping = getMapping();
        gen.if(false);
        for (const tagValue in mapping) {
          gen.elseIf((0, codegen_1._)`${tag} === ${tagValue}`);
          gen.assign(valid, applyTagSchema(mapping[tagValue]));
        }
        gen.else();
        cxt.error(false, {
          discrError: types_1.DiscrError.Mapping,
          tag,
          tagName,
        });
        gen.endIf();
      }
      function applyTagSchema(schemaProp) {
        const _valid = gen.name("valid");
        const schCxt = cxt.subschema(
          {
            keyword: "oneOf",
            schemaProp,
          },
          _valid,
        );
        cxt.mergeEvaluated(schCxt, codegen_1.Name);
        return _valid;
      }
      function getMapping() {
        var _a;
        const oneOfMapping = {};
        const topRequired = hasRequired(parentSchema);
        let tagRequired = true;
        for (let i = 0; i < oneOf.length; i++) {
          let sch = oneOf[i];
          if (
            (sch === null || sch === void 0 ? void 0 : sch.$ref) &&
            !(0, util_1.schemaHasRulesButRef)(sch, it.self.RULES)
          ) {
            const ref = sch.$ref;
            sch = compile_1.resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref);
            if (sch instanceof compile_1.SchemaEnv) sch = sch.schema;
            if (sch === void 0) throw new ref_error_1.default(it.opts.uriResolver, it.baseId, ref);
          }
          const propSch =
            (_a = sch === null || sch === void 0 ? void 0 : sch.properties) === null ||
            _a === void 0
              ? void 0
              : _a[tagName];
          if (typeof propSch != "object")
            throw new Error(
              `discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`,
            );
          tagRequired = tagRequired && (topRequired || hasRequired(sch));
          addMappings(propSch, i);
        }
        if (!tagRequired) throw new Error(`discriminator: "${tagName}" must be required`);
        return oneOfMapping;
        function hasRequired({ required }) {
          return Array.isArray(required) && required.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;
        }
      }
    },
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/json-schema-draft-07.json
var require_json_schema_draft_07 = /* @__PURE__ */ __commonJSMin((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,
  };
});
//#endregion
//#region ../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/ajv.js
var require_ajv = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.MissingRefError =
    exports.ValidationError =
    exports.CodeGen =
    exports.Name =
    exports.nil =
    exports.stringify =
    exports.str =
    exports._ =
    exports.KeywordCxt =
    exports.Ajv =
      void 0;
  const core_1 = require_core$1();
  const draft7_1 = require_draft7();
  const discriminator_1 = require_discriminator();
  const draft7MetaSchema = require_json_schema_draft_07();
  const META_SUPPORT_DATA = ["/properties"];
  const META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
  var Ajv = class extends core_1.default {
    _addVocabularies() {
      super._addVocabularies();
      draft7_1.default.forEach((v) => this.addVocabulary(v));
      if (this.opts.discriminator) this.addKeyword(discriminator_1.default);
    }
    _addDefaultMetaSchema() {
      super._addDefaultMetaSchema();
      if (!this.opts.meta) return;
      const metaSchema = this.opts.$data
        ? this.$dataMetaSchema(draft7MetaSchema, META_SUPPORT_DATA)
        : draft7MetaSchema;
      this.addMetaSchema(metaSchema, META_SCHEMA_ID, false);
      this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
    }
    defaultMeta() {
      return (this.opts.defaultMeta =
        super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0));
    }
  };
  exports.Ajv = Ajv;
  module.exports = exports = Ajv;
  module.exports.Ajv = Ajv;
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.default = Ajv;
  var validate_1 = require_validate();
  Object.defineProperty(exports, "KeywordCxt", {
    enumerable: true,
    get: function () {
      return validate_1.KeywordCxt;
    },
  });
  var codegen_1 = require_codegen();
  Object.defineProperty(exports, "_", {
    enumerable: true,
    get: function () {
      return codegen_1._;
    },
  });
  Object.defineProperty(exports, "str", {
    enumerable: true,
    get: function () {
      return codegen_1.str;
    },
  });
  Object.defineProperty(exports, "stringify", {
    enumerable: true,
    get: function () {
      return codegen_1.stringify;
    },
  });
  Object.defineProperty(exports, "nil", {
    enumerable: true,
    get: function () {
      return codegen_1.nil;
    },
  });
  Object.defineProperty(exports, "Name", {
    enumerable: true,
    get: function () {
      return codegen_1.Name;
    },
  });
  Object.defineProperty(exports, "CodeGen", {
    enumerable: true,
    get: function () {
      return codegen_1.CodeGen;
    },
  });
  var validation_error_1 = require_validation_error();
  Object.defineProperty(exports, "ValidationError", {
    enumerable: true,
    get: function () {
      return validation_error_1.default;
    },
  });
  var ref_error_1 = require_ref_error();
  Object.defineProperty(exports, "MissingRefError", {
    enumerable: true,
    get: function () {
      return ref_error_1.default;
    },
  });
});
//#endregion
//#region ../node_modules/.pnpm/ajv-formats@3.0.1_ajv@8.20.0/node_modules/ajv-formats/dist/formats.js
var require_formats = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.formatNames = exports.fastFormats = exports.fullFormats = void 0;
  function fmtDef(validate, compare) {
    return {
      validate,
      compare,
    };
  }
  exports.fullFormats = {
    date: fmtDef(date, compareDate),
    time: fmtDef(getTime(true), compareTime),
    "date-time": fmtDef(getDateTime(true), compareDateTime),
    "iso-time": fmtDef(getTime(), compareIsoTime),
    "iso-date-time": fmtDef(getDateTime(), compareIsoDateTime),
    duration: /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/,
    uri,
    "uri-reference":
      /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i,
    "uri-template":
      /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i,
    url: /^(?:https?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu,
    email:
      /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,
    hostname:
      /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i,
    ipv4: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/,
    ipv6: /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i,
    regex,
    uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,
    "json-pointer": /^(?:\/(?:[^~/]|~0|~1)*)*$/,
    "json-pointer-uri-fragment": /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i,
    "relative-json-pointer": /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/,
    byte,
    int32: {
      type: "number",
      validate: validateInt32,
    },
    int64: {
      type: "number",
      validate: validateInt64,
    },
    float: {
      type: "number",
      validate: validateNumber,
    },
    double: {
      type: "number",
      validate: validateNumber,
    },
    password: true,
    binary: true,
  };
  exports.fastFormats = {
    ...exports.fullFormats,
    date: fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d$/, compareDate),
    time: fmtDef(
      /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i,
      compareTime,
    ),
    "date-time": fmtDef(
      /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i,
      compareDateTime,
    ),
    "iso-time": fmtDef(
      /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i,
      compareIsoTime,
    ),
    "iso-date-time": fmtDef(
      /^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i,
      compareIsoDateTime,
    ),
    uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i,
    "uri-reference": /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i,
    email:
      /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i,
  };
  exports.formatNames = Object.keys(exports.fullFormats);
  function isLeapYear(year) {
    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
  }
  const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
  const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
  function date(str) {
    const matches = DATE.exec(str);
    if (!matches) return false;
    const year = +matches[1];
    const month = +matches[2];
    const day = +matches[3];
    return (
      month >= 1 &&
      month <= 12 &&
      day >= 1 &&
      day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month])
    );
  }
  function compareDate(d1, d2) {
    if (!(d1 && d2)) return void 0;
    if (d1 > d2) return 1;
    if (d1 < d2) return -1;
    return 0;
  }
  const TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
  function getTime(strictTimeZone) {
    return function time(str) {
      const matches = TIME.exec(str);
      if (!matches) return false;
      const hr = +matches[1];
      const min = +matches[2];
      const sec = +matches[3];
      const tz = matches[4];
      const tzSign = matches[5] === "-" ? -1 : 1;
      const tzH = +(matches[6] || 0);
      const tzM = +(matches[7] || 0);
      if (tzH > 23 || tzM > 59 || (strictTimeZone && !tz)) return false;
      if (hr <= 23 && min <= 59 && sec < 60) return true;
      const utcMin = min - tzM * tzSign;
      const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0);
      return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61;
    };
  }
  function compareTime(s1, s2) {
    if (!(s1 && s2)) return void 0;
    const t1 = /* @__PURE__ */ new Date("2020-01-01T" + s1).valueOf();
    const t2 = /* @__PURE__ */ new Date("2020-01-01T" + s2).valueOf();
    if (!(t1 && t2)) return void 0;
    return t1 - t2;
  }
  function compareIsoTime(t1, t2) {
    if (!(t1 && t2)) return void 0;
    const a1 = TIME.exec(t1);
    const a2 = TIME.exec(t2);
    if (!(a1 && a2)) return void 0;
    t1 = a1[1] + a1[2] + a1[3];
    t2 = a2[1] + a2[2] + a2[3];
    if (t1 > t2) return 1;
    if (t1 < t2) return -1;
    return 0;
  }
  const DATE_TIME_SEPARATOR = /t|\s/i;
  function getDateTime(strictTimeZone) {
    const time = getTime(strictTimeZone);
    return function date_time(str) {
      const dateTime = str.split(DATE_TIME_SEPARATOR);
      return dateTime.length === 2 && date(dateTime[0]) && time(dateTime[1]);
    };
  }
  function compareDateTime(dt1, dt2) {
    if (!(dt1 && dt2)) return void 0;
    const d1 = new Date(dt1).valueOf();
    const d2 = new Date(dt2).valueOf();
    if (!(d1 && d2)) return void 0;
    return d1 - d2;
  }
  function compareIsoDateTime(dt1, dt2) {
    if (!(dt1 && dt2)) return void 0;
    const [d1, t1] = dt1.split(DATE_TIME_SEPARATOR);
    const [d2, t2] = dt2.split(DATE_TIME_SEPARATOR);
    const res = compareDate(d1, d2);
    if (res === void 0) return void 0;
    return res || compareTime(t1, t2);
  }
  const NOT_URI_FRAGMENT = /\/|:/;
  const URI =
    /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
  function uri(str) {
    return NOT_URI_FRAGMENT.test(str) && URI.test(str);
  }
  const BYTE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm;
  function byte(str) {
    BYTE.lastIndex = 0;
    return BYTE.test(str);
  }
  const MIN_INT32 = -(2 ** 31);
  const MAX_INT32 = 2 ** 31 - 1;
  function validateInt32(value) {
    return Number.isInteger(value) && value <= MAX_INT32 && value >= MIN_INT32;
  }
  function validateInt64(value) {
    return Number.isInteger(value);
  }
  function validateNumber() {
    return true;
  }
  const Z_ANCHOR = /[^\\]\\Z/;
  function regex(str) {
    if (Z_ANCHOR.test(str)) return false;
    try {
      new RegExp(str);
      return true;
    } catch (e) {
      return false;
    }
  }
});
//#endregion
//#region ../node_modules/.pnpm/ajv-formats@3.0.1_ajv@8.20.0/node_modules/ajv-formats/dist/limit.js
var require_limit = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.formatLimitDefinition = void 0;
  const ajv_1 = require_ajv();
  const codegen_1 = require_codegen();
  const ops = codegen_1.operators;
  const KWDs = {
    formatMaximum: {
      okStr: "<=",
      ok: ops.LTE,
      fail: ops.GT,
    },
    formatMinimum: {
      okStr: ">=",
      ok: ops.GTE,
      fail: ops.LT,
    },
    formatExclusiveMaximum: {
      okStr: "<",
      ok: ops.LT,
      fail: ops.GTE,
    },
    formatExclusiveMinimum: {
      okStr: ">",
      ok: ops.GT,
      fail: ops.LTE,
    },
  };
  exports.formatLimitDefinition = {
    keyword: Object.keys(KWDs),
    type: "string",
    schemaType: "string",
    $data: true,
    error: {
      message: ({ keyword, schemaCode }) =>
        (0, codegen_1.str)`should be ${KWDs[keyword].okStr} ${schemaCode}`,
      params: ({ keyword, schemaCode }) =>
        (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`,
    },
    code(cxt) {
      const { gen, data, schemaCode, keyword, it } = cxt;
      const { opts, self } = it;
      if (!opts.validateFormats) return;
      const fCxt = new ajv_1.KeywordCxt(it, self.RULES.all.format.definition, "format");
      if (fCxt.$data) validate$DataFormat();
      else validateFormat();
      function validate$DataFormat() {
        const fmts = gen.scopeValue("formats", {
          ref: self.formats,
          code: opts.code.formats,
        });
        const fmt = gen.const("fmt", (0, codegen_1._)`${fmts}[${fCxt.schemaCode}]`);
        cxt.fail$data(
          (0, codegen_1.or)(
            (0, codegen_1._)`typeof ${fmt} != "object"`,
            (0, codegen_1._)`${fmt} instanceof RegExp`,
            (0, codegen_1._)`typeof ${fmt}.compare != "function"`,
            compareCode(fmt),
          ),
        );
      }
      function validateFormat() {
        const format = fCxt.schema;
        const fmtDef = self.formats[format];
        if (!fmtDef || fmtDef === true) return;
        if (
          typeof fmtDef != "object" ||
          fmtDef instanceof RegExp ||
          typeof fmtDef.compare != "function"
        )
          throw new Error(`"${keyword}": format "${format}" does not define "compare" function`);
        const fmt = gen.scopeValue("formats", {
          key: format,
          ref: fmtDef,
          code: opts.code.formats
            ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format)}`
            : void 0,
        });
        cxt.fail$data(compareCode(fmt));
      }
      function compareCode(fmt) {
        return (0, codegen_1._)`${fmt}.compare(${data}, ${schemaCode}) ${KWDs[keyword].fail} 0`;
      }
    },
    dependencies: ["format"],
  };
  const formatLimitPlugin = (ajv) => {
    ajv.addKeyword(exports.formatLimitDefinition);
    return ajv;
  };
  exports.default = formatLimitPlugin;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-formats@3.0.1_ajv@8.20.0/node_modules/ajv-formats/dist/index.js
var require_dist$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const formats_1 = require_formats();
  const limit_1 = require_limit();
  const codegen_1 = require_codegen();
  const fullName = new codegen_1.Name("fullFormats");
  const fastName = new codegen_1.Name("fastFormats");
  const formatsPlugin = (ajv, opts = { keywords: true }) => {
    if (Array.isArray(opts)) {
      addFormats(ajv, opts, formats_1.fullFormats, fullName);
      return ajv;
    }
    const [formats, exportName] =
      opts.mode === "fast" ? [formats_1.fastFormats, fastName] : [formats_1.fullFormats, fullName];
    addFormats(ajv, opts.formats || formats_1.formatNames, formats, exportName);
    if (opts.keywords) (0, limit_1.default)(ajv);
    return ajv;
  };
  formatsPlugin.get = (name, mode = "full") => {
    const f = (mode === "fast" ? formats_1.fastFormats : formats_1.fullFormats)[name];
    if (!f) throw new Error(`Unknown format "${name}"`);
    return f;
  };
  function addFormats(ajv, list, fs, exportName) {
    var _a;
    var _b;
    ((_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0) ||
      (_b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`);
    for (const f of list) ajv.addFormat(f, fs[f]);
  }
  module.exports = exports = formatsPlugin;
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.default = formatsPlugin;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/typeof.js
var require_typeof$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const TYPES = ["undefined", "string", "number", "object", "function", "boolean", "symbol"];
  function getDef() {
    return {
      keyword: "typeof",
      schemaType: ["string", "array"],
      code(cxt) {
        const { data, schema, schemaValue } = cxt;
        cxt.fail(
          typeof schema == "string"
            ? (0, codegen_1._)`typeof ${data} != ${schema}`
            : (0, codegen_1._)`${schemaValue}.indexOf(typeof ${data}) < 0`,
        );
      },
      metaSchema: {
        anyOf: [
          {
            type: "string",
            enum: TYPES,
          },
          {
            type: "array",
            items: {
              type: "string",
              enum: TYPES,
            },
          },
        ],
      },
    };
  }
  exports.default = getDef;
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/typeof.js
var require_typeof = /* @__PURE__ */ __commonJSMin((exports, module, this$22) => {
  var __importDefault =
    (this$22 && this$22.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const typeof_1 = __importDefault(require_typeof$1());
  const typeofPlugin = (ajv) => ajv.addKeyword((0, typeof_1.default)());
  exports.default = typeofPlugin;
  module.exports = typeofPlugin;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/instanceof.js
var require_instanceof$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const CONSTRUCTORS = {
    Object,
    Array,
    Function,
    Number,
    String,
    Date,
    RegExp,
  };
  /* istanbul ignore else */
  if (typeof Buffer != "undefined") CONSTRUCTORS.Buffer = Buffer;
  /* istanbul ignore else */
  if (typeof Promise != "undefined") CONSTRUCTORS.Promise = Promise;
  const getDef = Object.assign(_getDef, { CONSTRUCTORS });
  function _getDef() {
    return {
      keyword: "instanceof",
      schemaType: ["string", "array"],
      compile(schema) {
        if (typeof schema == "string") {
          const C = getConstructor(schema);
          return (data) => data instanceof C;
        }
        if (Array.isArray(schema)) {
          const constructors = schema.map(getConstructor);
          return (data) => {
            for (const C of constructors) if (data instanceof C) return true;
            return false;
          };
        }
        /* istanbul ignore next */
        throw new Error("ajv implementation error");
      },
      metaSchema: {
        anyOf: [
          { type: "string" },
          {
            type: "array",
            items: { type: "string" },
          },
        ],
      },
    };
  }
  function getConstructor(c) {
    const C = CONSTRUCTORS[c];
    if (C) return C;
    throw new Error(`invalid "instanceof" keyword value ${c}`);
  }
  exports.default = getDef;
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/instanceof.js
var require_instanceof = /* @__PURE__ */ __commonJSMin((exports, module, this$21) => {
  var __importDefault =
    (this$21 && this$21.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const instanceof_1 = __importDefault(require_instanceof$1());
  const instanceofPlugin = (ajv) => ajv.addKeyword((0, instanceof_1.default)());
  exports.default = instanceofPlugin;
  module.exports = instanceofPlugin;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/_range.js
var require__range = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  function getRangeDef(keyword) {
    return () => ({
      keyword,
      type: "number",
      schemaType: "array",
      macro: function ([min, max]) {
        validateRangeSchema(min, max);
        return keyword === "range"
          ? {
              minimum: min,
              maximum: max,
            }
          : {
              exclusiveMinimum: min,
              exclusiveMaximum: max,
            };
      },
      metaSchema: {
        type: "array",
        minItems: 2,
        maxItems: 2,
        items: { type: "number" },
      },
    });
    function validateRangeSchema(min, max) {
      if (min > max || (keyword === "exclusiveRange" && min === max))
        throw new Error("There are no numbers in range");
    }
  }
  exports.default = getRangeDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/range.js
var require_range$1 = /* @__PURE__ */ __commonJSMin((exports, module, this$20) => {
  var __importDefault =
    (this$20 && this$20.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const getDef = (0, __importDefault(require__range()).default)("range");
  exports.default = getDef;
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/range.js
var require_range = /* @__PURE__ */ __commonJSMin((exports, module, this$19) => {
  var __importDefault =
    (this$19 && this$19.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const range_1 = __importDefault(require_range$1());
  const range = (ajv) => ajv.addKeyword((0, range_1.default)());
  exports.default = range;
  module.exports = range;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/exclusiveRange.js
var require_exclusiveRange$1 = /* @__PURE__ */ __commonJSMin((exports, module, this$18) => {
  var __importDefault =
    (this$18 && this$18.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const getDef = (0, __importDefault(require__range()).default)("exclusiveRange");
  exports.default = getDef;
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/exclusiveRange.js
var require_exclusiveRange = /* @__PURE__ */ __commonJSMin((exports, module, this$17) => {
  var __importDefault =
    (this$17 && this$17.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const exclusiveRange_1 = __importDefault(require_exclusiveRange$1());
  const exclusiveRange = (ajv) => ajv.addKeyword((0, exclusiveRange_1.default)());
  exports.default = exclusiveRange;
  module.exports = exclusiveRange;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/_util.js
var require__util = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.usePattern = exports.metaSchemaRef = void 0;
  const codegen_1 = require_codegen();
  const META_SCHEMA_ID = "http://json-schema.org/schema";
  function metaSchemaRef({ defaultMeta } = {}) {
    return defaultMeta === false ? {} : { $ref: defaultMeta || META_SCHEMA_ID };
  }
  exports.metaSchemaRef = metaSchemaRef;
  function usePattern({ gen, it: { opts } }, pattern, flags = opts.unicodeRegExp ? "u" : "") {
    const rx = new RegExp(pattern, flags);
    return gen.scopeValue("pattern", {
      key: rx.toString(),
      ref: rx,
      code: (0, codegen_1._)`new RegExp(${pattern}, ${flags})`,
    });
  }
  exports.usePattern = usePattern;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/regexp.js
var require_regexp$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const _util_1 = require__util();
  const regexpMetaSchema = {
    type: "object",
    properties: {
      pattern: { type: "string" },
      flags: {
        type: "string",
        nullable: true,
      },
    },
    required: ["pattern"],
    additionalProperties: false,
  };
  const metaRegexp = /^\/(.*)\/([gimuy]*)$/;
  function getDef() {
    return {
      keyword: "regexp",
      type: "string",
      schemaType: ["string", "object"],
      code(cxt) {
        const { data, schema } = cxt;
        const regx = getRegExp(schema);
        cxt.pass((0, codegen_1._)`${regx}.test(${data})`);
        function getRegExp(sch) {
          if (typeof sch == "object") return (0, _util_1.usePattern)(cxt, sch.pattern, sch.flags);
          const rx = metaRegexp.exec(sch);
          if (rx) return (0, _util_1.usePattern)(cxt, rx[1], rx[2]);
          throw new Error("cannot parse string into RegExp");
        }
      },
      metaSchema: { anyOf: [{ type: "string" }, regexpMetaSchema] },
    };
  }
  exports.default = getDef;
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/regexp.js
var require_regexp = /* @__PURE__ */ __commonJSMin((exports, module, this$16) => {
  var __importDefault =
    (this$16 && this$16.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const regexp_1 = __importDefault(require_regexp$1());
  const regexp = (ajv) => ajv.addKeyword((0, regexp_1.default)());
  exports.default = regexp;
  module.exports = regexp;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/transform.js
var require_transform$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const transform = {
    trimStart: (s) => s.trimStart(),
    trimEnd: (s) => s.trimEnd(),
    trimLeft: (s) => s.trimStart(),
    trimRight: (s) => s.trimEnd(),
    trim: (s) => s.trim(),
    toLowerCase: (s) => s.toLowerCase(),
    toUpperCase: (s) => s.toUpperCase(),
    toEnumCase: (s, cfg) => (cfg === null || cfg === void 0 ? void 0 : cfg.hash[configKey(s)]) || s,
  };
  const getDef = Object.assign(_getDef, { transform });
  function _getDef() {
    return {
      keyword: "transform",
      schemaType: "array",
      before: "enum",
      code(cxt) {
        const { gen, data, schema, parentSchema, it } = cxt;
        const { parentData, parentDataProperty } = it;
        const tNames = schema;
        if (!tNames.length) return;
        let cfg;
        if (tNames.includes("toEnumCase")) {
          const config = getEnumCaseCfg(parentSchema);
          cfg = gen.scopeValue("obj", {
            ref: config,
            code: (0, codegen_1.stringify)(config),
          });
        }
        gen.if((0, codegen_1._)`typeof ${data} == "string" && ${parentData} !== undefined`, () => {
          gen.assign(data, transformExpr(tNames.slice()));
          gen.assign((0, codegen_1._)`${parentData}[${parentDataProperty}]`, data);
        });
        function transformExpr(ts) {
          if (!ts.length) return data;
          const t = ts.pop();
          if (!(t in transform)) throw new Error(`transform: unknown transformation ${t}`);
          const func = gen.scopeValue("func", {
            ref: transform[t],
            code: (0,
            codegen_1._)`require("ajv-keywords/dist/definitions/transform").transform${(0, codegen_1.getProperty)(t)}`,
          });
          const arg = transformExpr(ts);
          return cfg && t === "toEnumCase"
            ? (0, codegen_1._)`${func}(${arg}, ${cfg})`
            : (0, codegen_1._)`${func}(${arg})`;
        }
      },
      metaSchema: {
        type: "array",
        items: {
          type: "string",
          enum: Object.keys(transform),
        },
      },
    };
  }
  function getEnumCaseCfg(parentSchema) {
    const cfg = { hash: {} };
    if (!parentSchema.enum) throw new Error('transform: "toEnumCase" requires "enum"');
    for (const v of parentSchema.enum) {
      if (typeof v !== "string") continue;
      const k = configKey(v);
      if (cfg.hash[k])
        throw new Error(
          'transform: "toEnumCase" requires all lowercased "enum" values to be unique',
        );
      cfg.hash[k] = v;
    }
    return cfg;
  }
  function configKey(s) {
    return s.toLowerCase();
  }
  exports.default = getDef;
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/transform.js
var require_transform = /* @__PURE__ */ __commonJSMin((exports, module, this$15) => {
  var __importDefault =
    (this$15 && this$15.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const transform_1 = __importDefault(require_transform$1());
  const transform = (ajv) => ajv.addKeyword((0, transform_1.default)());
  exports.default = transform;
  module.exports = transform;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/uniqueItemProperties.js
var require_uniqueItemProperties$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const equal = require_fast_deep_equal();
  const SCALAR_TYPES = ["number", "integer", "string", "boolean", "null"];
  function getDef() {
    return {
      keyword: "uniqueItemProperties",
      type: "array",
      schemaType: "array",
      compile(keys, parentSchema) {
        const scalar = getScalarKeys(keys, parentSchema);
        return (data) => {
          if (data.length <= 1) return true;
          for (let k = 0; k < keys.length; k++) {
            const key = keys[k];
            if (scalar[k]) {
              const hash = {};
              for (const x of data) {
                if (!x || typeof x != "object") continue;
                let p = x[key];
                if (p && typeof p == "object") continue;
                if (typeof p == "string") p = '"' + p;
                if (hash[p]) return false;
                hash[p] = true;
              }
            } else
              for (let i = data.length; i--;) {
                const x = data[i];
                if (!x || typeof x != "object") continue;
                for (let j = i; j--;) {
                  const y = data[j];
                  if (y && typeof y == "object" && equal(x[key], y[key])) return false;
                }
              }
          }
          return true;
        };
      },
      metaSchema: {
        type: "array",
        items: { type: "string" },
      },
    };
  }
  exports.default = getDef;
  function getScalarKeys(keys, schema) {
    return keys.map((key) => {
      var _a, _b, _c;
      const t =
        (_c =
          (_b = (_a = schema.items) === null || _a === void 0 ? void 0 : _a.properties) === null ||
          _b === void 0
            ? void 0
            : _b[key]) === null || _c === void 0
          ? void 0
          : _c.type;
      return Array.isArray(t)
        ? !t.includes("object") && !t.includes("array")
        : SCALAR_TYPES.includes(t);
    });
  }
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/uniqueItemProperties.js
var require_uniqueItemProperties = /* @__PURE__ */ __commonJSMin((exports, module, this$14) => {
  var __importDefault =
    (this$14 && this$14.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const uniqueItemProperties_1 = __importDefault(require_uniqueItemProperties$1());
  const uniqueItemProperties = (ajv) => ajv.addKeyword((0, uniqueItemProperties_1.default)());
  exports.default = uniqueItemProperties;
  module.exports = uniqueItemProperties;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/allRequired.js
var require_allRequired$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  function getDef() {
    return {
      keyword: "allRequired",
      type: "object",
      schemaType: "boolean",
      macro(schema, parentSchema) {
        if (!schema) return true;
        const required = Object.keys(parentSchema.properties);
        if (required.length === 0) return true;
        return { required };
      },
      dependencies: ["properties"],
    };
  }
  exports.default = getDef;
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/allRequired.js
var require_allRequired = /* @__PURE__ */ __commonJSMin((exports, module, this$13) => {
  var __importDefault =
    (this$13 && this$13.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const allRequired_1 = __importDefault(require_allRequired$1());
  const allRequired = (ajv) => ajv.addKeyword((0, allRequired_1.default)());
  exports.default = allRequired;
  module.exports = allRequired;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/_required.js
var require__required = /* @__PURE__ */ __commonJSMin((exports) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  function getRequiredDef(keyword) {
    return () => ({
      keyword,
      type: "object",
      schemaType: "array",
      macro(schema) {
        if (schema.length === 0) return true;
        if (schema.length === 1) return { required: schema };
        return {
          [keyword === "anyRequired" ? "anyOf" : "oneOf"]: schema.map((p) => ({ required: [p] })),
        };
      },
      metaSchema: {
        type: "array",
        items: { type: "string" },
      },
    });
  }
  exports.default = getRequiredDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/anyRequired.js
var require_anyRequired$1 = /* @__PURE__ */ __commonJSMin((exports, module, this$12) => {
  var __importDefault =
    (this$12 && this$12.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const getDef = (0, __importDefault(require__required()).default)("anyRequired");
  exports.default = getDef;
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/anyRequired.js
var require_anyRequired = /* @__PURE__ */ __commonJSMin((exports, module, this$11) => {
  var __importDefault =
    (this$11 && this$11.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const anyRequired_1 = __importDefault(require_anyRequired$1());
  const anyRequired = (ajv) => ajv.addKeyword((0, anyRequired_1.default)());
  exports.default = anyRequired;
  module.exports = anyRequired;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/oneRequired.js
var require_oneRequired$1 = /* @__PURE__ */ __commonJSMin((exports, module, this$10) => {
  var __importDefault =
    (this$10 && this$10.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const getDef = (0, __importDefault(require__required()).default)("oneRequired");
  exports.default = getDef;
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/oneRequired.js
var require_oneRequired = /* @__PURE__ */ __commonJSMin((exports, module, this$9) => {
  var __importDefault =
    (this$9 && this$9.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const oneRequired_1 = __importDefault(require_oneRequired$1());
  const oneRequired = (ajv) => ajv.addKeyword((0, oneRequired_1.default)());
  exports.default = oneRequired;
  module.exports = oneRequired;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/patternRequired.js
var require_patternRequired$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const _util_1 = require__util();
  const error = {
    message: ({ params: { missingPattern } }) =>
      (0, codegen_1.str)`should have property matching pattern '${missingPattern}'`,
    params: ({ params: { missingPattern } }) =>
      (0, codegen_1._)`{missingPattern: ${missingPattern}}`,
  };
  function getDef() {
    return {
      keyword: "patternRequired",
      type: "object",
      schemaType: "array",
      error,
      code(cxt) {
        const { gen, schema, data } = cxt;
        if (schema.length === 0) return;
        const valid = gen.let("valid", true);
        for (const pat of schema) validateProperties(pat);
        function validateProperties(pattern) {
          const matched = gen.let("matched", false);
          gen.forIn("key", data, (key) => {
            gen.assign(
              matched,
              (0, codegen_1._)`${(0, _util_1.usePattern)(cxt, pattern)}.test(${key})`,
            );
            gen.if(matched, () => gen.break());
          });
          cxt.setParams({ missingPattern: pattern });
          gen.assign(valid, (0, codegen_1.and)(valid, matched));
          cxt.pass(valid);
        }
      },
      metaSchema: {
        type: "array",
        items: {
          type: "string",
          format: "regex",
        },
        uniqueItems: true,
      },
    };
  }
  exports.default = getDef;
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/patternRequired.js
var require_patternRequired = /* @__PURE__ */ __commonJSMin((exports, module, this$8) => {
  var __importDefault =
    (this$8 && this$8.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const patternRequired_1 = __importDefault(require_patternRequired$1());
  const patternRequired = (ajv) => ajv.addKeyword((0, patternRequired_1.default)());
  exports.default = patternRequired;
  module.exports = patternRequired;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/prohibited.js
var require_prohibited$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  function getDef() {
    return {
      keyword: "prohibited",
      type: "object",
      schemaType: "array",
      macro: function (schema) {
        if (schema.length === 0) return true;
        if (schema.length === 1) return { not: { required: schema } };
        return { not: { anyOf: schema.map((p) => ({ required: [p] })) } };
      },
      metaSchema: {
        type: "array",
        items: { type: "string" },
      },
    };
  }
  exports.default = getDef;
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/prohibited.js
var require_prohibited = /* @__PURE__ */ __commonJSMin((exports, module, this$7) => {
  var __importDefault =
    (this$7 && this$7.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const prohibited_1 = __importDefault(require_prohibited$1());
  const prohibited = (ajv) => ajv.addKeyword((0, prohibited_1.default)());
  exports.default = prohibited;
  module.exports = prohibited;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/deepProperties.js
var require_deepProperties$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const _util_1 = require__util();
  function getDef(opts) {
    return {
      keyword: "deepProperties",
      type: "object",
      schemaType: "object",
      macro: function (schema) {
        const allOf = [];
        for (const pointer in schema) allOf.push(getSchema(pointer, schema[pointer]));
        return { allOf };
      },
      metaSchema: {
        type: "object",
        propertyNames: {
          type: "string",
          format: "json-pointer",
        },
        additionalProperties: (0, _util_1.metaSchemaRef)(opts),
      },
    };
  }
  exports.default = getDef;
  function getSchema(jsonPointer, schema) {
    const segments = jsonPointer.split("/");
    const rootSchema = {};
    let pointerSchema = rootSchema;
    for (let i = 1; i < segments.length; i++) {
      let segment = segments[i];
      const isLast = i === segments.length - 1;
      segment = unescapeJsonPointer(segment);
      const properties = (pointerSchema.properties = {});
      let items;
      if (/[0-9]+/.test(segment)) {
        let count = +segment;
        items = pointerSchema.items = [];
        pointerSchema.type = ["object", "array"];
        while (count--) items.push({});
      } else pointerSchema.type = "object";
      pointerSchema = isLast ? schema : {};
      properties[segment] = pointerSchema;
      if (items) items.push(pointerSchema);
    }
    return rootSchema;
  }
  function unescapeJsonPointer(str) {
    return str.replace(/~1/g, "/").replace(/~0/g, "~");
  }
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/deepProperties.js
var require_deepProperties = /* @__PURE__ */ __commonJSMin((exports, module, this$6) => {
  var __importDefault =
    (this$6 && this$6.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const deepProperties_1 = __importDefault(require_deepProperties$1());
  const deepProperties = (ajv, opts) => ajv.addKeyword((0, deepProperties_1.default)(opts));
  exports.default = deepProperties;
  module.exports = deepProperties;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/deepRequired.js
var require_deepRequired$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  function getDef() {
    return {
      keyword: "deepRequired",
      type: "object",
      schemaType: "array",
      code(ctx) {
        const { schema, data } = ctx;
        const props = schema.map((jp) => (0, codegen_1._)`(${getData(jp)}) === undefined`);
        ctx.fail((0, codegen_1.or)(...props));
        function getData(jsonPointer) {
          if (jsonPointer === "") throw new Error("empty JSON pointer not allowed");
          const segments = jsonPointer.split("/");
          let x = data;
          const xs = segments.map((s, i) =>
            i ? (x = (0, codegen_1._)`${x}${(0, codegen_1.getProperty)(unescapeJPSegment(s))}`) : x,
          );
          return (0, codegen_1.and)(...xs);
        }
      },
      metaSchema: {
        type: "array",
        items: {
          type: "string",
          format: "json-pointer",
        },
      },
    };
  }
  exports.default = getDef;
  function unescapeJPSegment(s) {
    return s.replace(/~1/g, "/").replace(/~0/g, "~");
  }
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/deepRequired.js
var require_deepRequired = /* @__PURE__ */ __commonJSMin((exports, module, this$5) => {
  var __importDefault =
    (this$5 && this$5.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const deepRequired_1 = __importDefault(require_deepRequired$1());
  const deepRequired = (ajv) => ajv.addKeyword((0, deepRequired_1.default)());
  exports.default = deepRequired;
  module.exports = deepRequired;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/dynamicDefaults.js
var require_dynamicDefaults$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const sequences = {};
  const DEFAULTS = {
    timestamp: () => () => Date.now(),
    datetime: () => () => /* @__PURE__ */ new Date().toISOString(),
    date: () => () => /* @__PURE__ */ new Date().toISOString().slice(0, 10),
    time: () => () => /* @__PURE__ */ new Date().toISOString().slice(11),
    random: () => () => Math.random(),
    randomint: (args) => {
      var _a;
      const max =
        (_a = args === null || args === void 0 ? void 0 : args.max) !== null && _a !== void 0
          ? _a
          : 2;
      return () => Math.floor(Math.random() * max);
    },
    seq: (args) => {
      var _a;
      const name =
        (_a = args === null || args === void 0 ? void 0 : args.name) !== null && _a !== void 0
          ? _a
          : "";
      sequences[name] || (sequences[name] = 0);
      return () => sequences[name]++;
    },
  };
  const getDef = Object.assign(_getDef, { DEFAULTS });
  function _getDef() {
    return {
      keyword: "dynamicDefaults",
      type: "object",
      schemaType: ["string", "object"],
      modifying: true,
      valid: true,
      compile(schema, _parentSchema, it) {
        if (!it.opts.useDefaults || it.compositeRule) return () => true;
        const fs = {};
        for (const key in schema) fs[key] = getDefault(schema[key]);
        const empty = it.opts.useDefaults === "empty";
        return (data) => {
          for (const prop in schema)
            if (data[prop] === void 0 || (empty && (data[prop] === null || data[prop] === "")))
              data[prop] = fs[prop]();
          return true;
        };
      },
      metaSchema: {
        type: "object",
        additionalProperties: {
          anyOf: [
            { type: "string" },
            {
              type: "object",
              additionalProperties: false,
              required: ["func", "args"],
              properties: {
                func: { type: "string" },
                args: { type: "object" },
              },
            },
          ],
        },
      },
    };
  }
  function getDefault(d) {
    return typeof d == "object" ? getObjDefault(d) : getStrDefault(d);
  }
  function getObjDefault({ func, args }) {
    const def = DEFAULTS[func];
    assertDefined(func, def);
    return def(args);
  }
  function getStrDefault(d = "") {
    const def = DEFAULTS[d];
    assertDefined(d, def);
    return def();
  }
  function assertDefined(name, def) {
    if (!def) throw new Error(`invalid "dynamicDefaults" keyword property value: ${name}`);
  }
  exports.default = getDef;
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/dynamicDefaults.js
var require_dynamicDefaults = /* @__PURE__ */ __commonJSMin((exports, module, this$4) => {
  var __importDefault =
    (this$4 && this$4.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const dynamicDefaults_1 = __importDefault(require_dynamicDefaults$1());
  const dynamicDefaults = (ajv) => ajv.addKeyword((0, dynamicDefaults_1.default)());
  exports.default = dynamicDefaults;
  module.exports = dynamicDefaults;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/definitions/select.js
var require_select$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
  Object.defineProperty(exports, "__esModule", { value: true });
  const codegen_1 = require_codegen();
  const _util_1 = require__util();
  const error = {
    message: ({ params: { schemaProp } }) =>
      schemaProp
        ? (0, codegen_1.str)`should match case "${schemaProp}" schema`
        : (0, codegen_1.str)`should match default case schema`,
    params: ({ params: { schemaProp } }) =>
      schemaProp
        ? (0, codegen_1._)`{failingCase: ${schemaProp}}`
        : (0, codegen_1._)`{failingDefault: true}`,
  };
  function getDef(opts) {
    const metaSchema = (0, _util_1.metaSchemaRef)(opts);
    return [
      {
        keyword: "select",
        schemaType: ["string", "number", "boolean", "null"],
        $data: true,
        error,
        dependencies: ["selectCases"],
        code(cxt) {
          const { gen, schemaCode, parentSchema } = cxt;
          cxt.block$data(codegen_1.nil, () => {
            const valid = gen.let("valid", true);
            const schValid = gen.name("_valid");
            const value = gen.const(
              "value",
              (0, codegen_1._)`${schemaCode} === null ? "null" : ${schemaCode}`,
            );
            gen.if(false);
            for (const schemaProp in parentSchema.selectCases) {
              cxt.setParams({ schemaProp });
              gen.elseIf((0, codegen_1._)`"" + ${value} == ${schemaProp}`);
              const schCxt = cxt.subschema(
                {
                  keyword: "selectCases",
                  schemaProp,
                },
                schValid,
              );
              cxt.mergeEvaluated(schCxt, codegen_1.Name);
              gen.assign(valid, schValid);
            }
            gen.else();
            if (parentSchema.selectDefault !== void 0) {
              cxt.setParams({ schemaProp: void 0 });
              const schCxt = cxt.subschema({ keyword: "selectDefault" }, schValid);
              cxt.mergeEvaluated(schCxt, codegen_1.Name);
              gen.assign(valid, schValid);
            }
            gen.endIf();
            cxt.pass(valid);
          });
        },
      },
      {
        keyword: "selectCases",
        dependencies: ["select"],
        metaSchema: {
          type: "object",
          additionalProperties: metaSchema,
        },
      },
      {
        keyword: "selectDefault",
        dependencies: ["select", "selectCases"],
        metaSchema,
      },
    ];
  }
  exports.default = getDef;
  module.exports = getDef;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/select.js
var require_select = /* @__PURE__ */ __commonJSMin((exports, module, this$3) => {
  var __importDefault =
    (this$3 && this$3.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const select_1 = __importDefault(require_select$1());
  const select = (ajv, opts) => {
    (0, select_1.default)(opts).forEach((d) => ajv.addKeyword(d));
    return ajv;
  };
  exports.default = select;
  module.exports = select;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/keywords/index.js
var require_keywords = /* @__PURE__ */ __commonJSMin((exports, module, this$2) => {
  var __importDefault =
    (this$2 && this$2.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const typeof_1 = __importDefault(require_typeof());
  const instanceof_1 = __importDefault(require_instanceof());
  const range_1 = __importDefault(require_range());
  const exclusiveRange_1 = __importDefault(require_exclusiveRange());
  const regexp_1 = __importDefault(require_regexp());
  const transform_1 = __importDefault(require_transform());
  const uniqueItemProperties_1 = __importDefault(require_uniqueItemProperties());
  const allRequired_1 = __importDefault(require_allRequired());
  const anyRequired_1 = __importDefault(require_anyRequired());
  const oneRequired_1 = __importDefault(require_oneRequired());
  const patternRequired_1 = __importDefault(require_patternRequired());
  const prohibited_1 = __importDefault(require_prohibited());
  const deepProperties_1 = __importDefault(require_deepProperties());
  const deepRequired_1 = __importDefault(require_deepRequired());
  const dynamicDefaults_1 = __importDefault(require_dynamicDefaults());
  const select_1 = __importDefault(require_select());
  const ajvKeywords = {
    typeof: typeof_1.default,
    instanceof: instanceof_1.default,
    range: range_1.default,
    exclusiveRange: exclusiveRange_1.default,
    regexp: regexp_1.default,
    transform: transform_1.default,
    uniqueItemProperties: uniqueItemProperties_1.default,
    allRequired: allRequired_1.default,
    anyRequired: anyRequired_1.default,
    oneRequired: oneRequired_1.default,
    patternRequired: patternRequired_1.default,
    prohibited: prohibited_1.default,
    deepProperties: deepProperties_1.default,
    deepRequired: deepRequired_1.default,
    dynamicDefaults: dynamicDefaults_1.default,
    select: select_1.default,
  };
  exports.default = ajvKeywords;
  module.exports = ajvKeywords;
});
//#endregion
//#region ../node_modules/.pnpm/ajv-keywords@5.1.0_ajv@8.20.0/node_modules/ajv-keywords/dist/index.js
var require_dist = /* @__PURE__ */ __commonJSMin((exports, module, this$1) => {
  var __importDefault =
    (this$1 && this$1.__importDefault) ||
    function (mod) {
      return mod && mod.__esModule ? mod : { default: mod };
    };
  Object.defineProperty(exports, "__esModule", { value: true });
  const keywords_1 = __importDefault(require_keywords());
  const ajvKeywords = (ajv, keyword) => {
    if (Array.isArray(keyword)) {
      for (const k of keyword) get(k)(ajv);
      return ajv;
    }
    if (keyword) {
      get(keyword)(ajv);
      return ajv;
    }
    for (keyword in keywords_1.default) get(keyword)(ajv);
    return ajv;
  };
  ajvKeywords.get = get;
  function get(keyword) {
    const defFunc = keywords_1.default[keyword];
    if (!defFunc) throw new Error("Unknown keyword " + keyword);
    return defFunc;
  }
  exports.default = ajvKeywords;
  module.exports = ajvKeywords;
  module.exports.default = ajvKeywords;
});
//#endregion
//#region ../schemas/libraries/ajv/download/index.ts
var import_ajv = require_ajv();
var import_dist = /* @__PURE__ */ __toESM(require_dist$1(), 1);
var import_dist$1 = /* @__PURE__ */ __toESM(require_dist(), 1);
const ajv = new import_ajv.Ajv();
(0, import_dist.default)(ajv, { formats: ["url"] });
(0, import_dist$1.default)(ajv, ["instanceof"]);
const dateSchema = {
  type: "object",
  instanceof: "Date",
  required: [],
};
const imageSchema = {
  type: "object",
  properties: {
    id: { type: "number" },
    created: dateSchema,
    title: {
      type: "string",
      minLength: 1,
      maxLength: 100,
    },
    type: {
      type: "string",
      enum: ["jpg", "png"],
    },
    size: { type: "number" },
    url: {
      type: "string",
      format: "url",
    },
  },
  required: ["id", "created", "title", "type", "size", "url"],
};
const productSchema = {
  type: "object",
  properties: {
    id: { type: "number" },
    created: dateSchema,
    title: {
      type: "string",
      minLength: 1,
      maxLength: 100,
    },
    brand: {
      type: "string",
      minLength: 1,
      maxLength: 30,
    },
    description: {
      type: "string",
      minLength: 1,
      maxLength: 500,
    },
    price: {
      type: "number",
      minimum: 1,
      maximum: 1e4,
    },
    discount: {
      type: "number",
      minimum: 1,
      maximum: 100,
      nullable: true,
    },
    quantity: {
      type: "number",
      minimum: 0,
      maximum: 10,
    },
    tags: {
      type: "array",
      items: {
        type: "string",
        minLength: 1,
        maxLength: 30,
      },
    },
    images: {
      type: "array",
      items: imageSchema,
    },
    ratings: {
      type: "array",
      items: {
        type: "object",
        properties: {
          id: { type: "number" },
          stars: {
            type: "number",
            minimum: 1,
            maximum: 5,
          },
          title: {
            type: "string",
            minLength: 1,
            maxLength: 100,
          },
          text: {
            type: "string",
            minLength: 1,
            maxLength: 1e3,
          },
          images: {
            type: "array",
            items: imageSchema,
          },
        },
        required: ["id", "stars", "title", "text", "images"],
      },
    },
  },
  required: [
    "id",
    "created",
    "title",
    "brand",
    "description",
    "price",
    "discount",
    "quantity",
    "tags",
    "images",
    "ratings",
  ],
};
ajv.validate(productSchema, {});
//#endregion

Preferences

Style

Theme

NPM browser

Code ligatures